ticket: use base32 project record ids

.yoi/tickets/00001KTJCG4Q0/item.md

@@ -0,0 +1,78 @@
+---
+title: "Allow SpawnPod to specify child cwd"
+state: "closed"
+created_at: "2026-06-08T01:10:36Z"
+updated_at: "2026-06-08T08:17:51Z"
+queued_by: "workspace-panel"
+queued_at: "2026-06-08T03:06:04Z"
+---
+
+## Background
+
+Current multi-agent/worktree workflows assume Coder/Reviewer Pods are spawned with the parent Orchestrator's cwd, usually the main workspace. Worktree isolation is enforced by delegated write scope and by task text instructing the Coder to run every Bash command with `cd <repo>/.worktree/<task-name> && ...`.
+
+Current workflow text explicitly says:
+
+```text
+Pod の cwd は main workspace のままになる。必ず作業対象が child worktree であることを明示し、Bash 実行時は毎回 cd <repo>/.worktree/<task-name> && ... させる。
+```
+
+This works but is fragile and awkward:
+
+- Coder can forget to `cd` before commands.
+- Bash/tool execution starts from the main workspace even when all edits should happen in the child worktree.
+- Command snippets are noisy and error-prone.
+- Child worktree behavior is controlled by prompt discipline rather than runtime configuration.
+
+`SpawnPod` currently has no LLM-facing `cwd` field; internally child processes are launched with `Command::current_dir(self.spawner_pwd)`.
+
+This ticket is **not** about changing the child Pod's runtime workspace root. A spawned child remains in the same project/workspace context as its parent. The improvement is only to let the child process/tool cwd point at a child worktree inside that workspace.
+
+## Goal
+
+Allow `SpawnPod` callers to specify the child Pod's process/tool `cwd`, so implementation Pods can start directly inside their child worktree while inheriting the parent workspace context and keeping explicit scope delegation.
+
+## Requirements
+
+- Add a `SpawnPod` input field named `cwd` for the child process/tool working directory.
+- When omitted, preserve current behavior: child cwd defaults to the spawner Pod's pwd.
+- `cwd` must not change the runtime workspace root.
+  - Child Pods inherit the parent workspace/project context.
+  - Profile discovery, project records, Ticket config, workflow registry, memory root resolution start point, and Pod identity policy should continue to use the inherited runtime workspace context unless another explicit design says otherwise.
+- When `cwd` is provided:
+  - Validate the path is absolute.
+  - Validate the path exists and is a directory.
+  - Validate the parent has at least read authority for the path.
+  - Set the child process `current_dir` to that path.
+  - Ensure Bash/tool default cwd uses that path.
+- Ensure delegated scope remains explicit and independent from cwd.
+  - cwd does not grant permission by itself.
+  - Child read/write scope must still be supplied through `scope` and validated against parent/delegation authority.
+- Support the standard worktree case:
+  - inherited workspace root = main repo;
+  - child cwd = `<repo>/.worktree/<task-name>`;
+  - child read scope may include main repo if needed;
+  - child write scope is the child worktree or narrower.
+- Update `worktree-workflow` and `multi-agent-workflow` to prefer spawning Coder Pods with `cwd` set to the child worktree instead of telling them to `cd` every time.
+- Keep main workspace authority responsibilities explicit:
+  - ticket orchestration progress, final review/approval/close, and merge authority remain with Orchestrator/main workspace unless intentionally delegated.
+- Ensure child worktree `.yoi` sparse rules and `.yoi/memory` behavior remain intact.
+- Add diagnostics if requested cwd is not permitted or invalid.
+
+## Design notes
+
+- The field should be named `cwd`, not `workspace_root`, because SpawnPod children should not move into a different workspace. They only need a different process/tool working directory inside the same workspace context.
+- `cwd` should not affect default Pod name. `SpawnPod.name` is already explicit.
+- `cwd` should not affect Profile selection or project profile discovery.
+- Reviewer Pods may use main workspace cwd or child worktree cwd depending on review style; workflow guidance should state the recommended default rather than make `cwd` imply review authority.
+
+## Acceptance criteria
+
+- `SpawnPod` can launch a child Pod with process/tool cwd set to an explicit child worktree path.
+- The child Pod's Bash tool starts fresh shells rooted at that child worktree without requiring `cd` in every command.
+- Omitting `cwd` preserves current behavior.
+- Invalid/non-directory/out-of-scope cwd requests fail with clear errors.
+- cwd selection does not grant implicit read/write permission and does not alter inherited workspace context.
+- Worktree/multi-agent workflows are updated to use the new field for coder Pods.
+- Tests cover omitted/default cwd, explicit valid cwd, invalid cwd, permission denial, and workspace-context inheritance.
+- Focused tests, `cargo fmt --check`, `git diff --check`, and `target/debug/yoi ticket doctor` pass.

.yoi/tickets/00001KTJCG4Q0/resolution.md

@@ -0,0 +1,32 @@
+Merged and completed `SpawnPod.cwd` support.
+
+Summary:
+- Added optional `SpawnPodInput.cwd` for child process/tool working directory.
+- Validates `cwd` before launch: absolute, existing directory, and usable under the child effective direct scope.
+- Preserves omitted-`cwd` behavior.
+- Separates runtime workspace context from tool cwd: child runtime receives inherited `--workspace`, while requested tool cwd is passed separately as hidden `--tool-cwd`.
+- `Pod` now separates `workspace_root` from `pwd`; workspace/project/Ticket/workflow/memory/Profile context uses `workspace_root`, while tools/Bash/ScopedFs use `pwd`.
+- Updated maintained multi-agent/worktree guidance to use `SpawnPod.cwd` as non-authority convenience while keeping delegated scope explicit.
+
+Merged branch/worktree:
+- Branch: `allow-spawnpod-child-workspace-cwd`
+- Commits: `3dd7707`, `248744f`
+- Merge commit on `develop`: `05df656 merge: allow SpawnPod child cwd`
+
+Validation passed after merge:
+- `cargo test -p pod spawn_pod --test spawn_pod_test`
+- `cargo test -p pod spawn_pod`
+- `cargo check -q`
+- `cargo fmt --check`
+- `git diff --check`
+- `cargo run -q -p yoi -- ticket doctor`
+- `nix build .#yoi`
+
+Cleanup completed:
+- Stopped coder/reviewer Pods and reclaimed scope.
+- Removed `.worktree/allow-spawnpod-child-workspace-cwd`.
+- Deleted branch `allow-spawnpod-child-workspace-cwd`.
+
+Residual notes:
+- Manual callers using a worktree cwd must still delegate readable workspace context plus explicit worktree scope; `cwd` grants no authority.
+- Restore behavior for already-spawned Pods with distinct tool cwd was not deeply audited beyond launch-time/nested SpawnPod behavior and remains a possible future refinement if needed.

.yoi/tickets/00001KTJCG4Q0/thread.md

@@ -0,0 +1,447 @@
+<!-- event: create author: LocalTicketBackend at: 2026-06-08T01:10:36Z -->
+
+## Created
+
+Created by LocalTicketBackend create.
+
+---
+
+<!-- event: decision author: ticket-intake at: 2026-06-08T02:46:39Z -->
+
+## Decision
+
+## Intake readiness classification
+
+- readiness: implementation_ready
+- needs_preflight: true
+- risk_flags: [authority-boundary, scope-delegation, pod-runtime, workspace-context, workflow-guidance]
+
+The Ticket is specific enough for Orchestrator routing: it fixes the public tool input name (`cwd`), default behavior when omitted, the distinction between process/tool cwd and inherited workspace context, and the invariant that `cwd` grants no authority by itself. Preflight remains required because the change touches SpawnPod delegation authority, scope validation, runtime cwd behavior, and workflow guidance.
+
+---
+
+<!-- event: intake_summary author: ticket-intake at: 2026-06-08T02:46:46Z -->
+
+## Intake summary
+
+Existing Ticket updated rather than duplicated. Scope is to add an optional `cwd` field to `SpawnPod` so child Pods can run process/tool commands from a child worktree while inheriting the parent workspace context. Required invariants: omitted `cwd` preserves current spawner pwd behavior; provided `cwd` is absolute, existing directory, and within parent read authority; cwd does not grant read/write permission, change workspace root, alter Profile discovery, or affect Pod naming; delegated scope remains explicit. Worktree and multi-agent workflow guidance should prefer coder Pods with child-worktree cwd. Ticket is implementation-ready for routing, with preflight recommended because it touches authority/scope/runtime/workflow boundaries.
+
+---
+
+<!-- event: state_changed author: ticket-intake at: 2026-06-08T02:46:46Z from: intake to: ready reason: intake_ready field: workflow_state -->
+
+## State changed
+
+Intake classified the existing Ticket as ready for Orchestrator routing. The user or panel may now queue it; implementation must still wait for Orchestrator acceptance and any preflight/routing decision.
+
+---
+
+<!-- event: state_changed author: workspace-panel at: 2026-06-08T03:06:04Z from: ready to: queued reason: queued field: workflow_state -->
+
+## State changed
+
+Ticket queued for Orchestrator routing.
+
+
+---
+
+<!-- event: decision author: orchestrator at: 2026-06-08T03:07:33Z -->
+
+## Decision
+
+Routing decision: preflight_needed
+
+Reason:
+- The Ticket is well specified, but Intake explicitly records that preflight remains required because this touches SpawnPod delegation authority, scope validation, runtime cwd behavior, and workflow guidance.
+- The proposed `cwd` field must preserve a strict authority boundary: cwd changes process/tool working directory only, does not grant read/write permission, does not change workspace context, and does not affect Profile discovery or Pod naming.
+- This needs a short binding design note before coder delegation so reviewer can judge schema, validation, runtime launch, and workflow-guidance changes against recorded authority invariants rather than implementation convenience.
+
+Evidence checked:
+- Ticket body requirements, design notes, and acceptance criteria.
+- Thread: Intake classification, risk flags, and latest `ready -> queued` event.
+- Workspace state: no matching branch/worktree exists; main workspace has unrelated Ticket-record edits.
+- Code map search for SpawnPod input/launch, cwd/current_dir, scope validation, and workflow guidance paths.
+- Ticket doctor: 0 errors; existing warnings are unrelated legacy closed-Ticket diagnostics.
+
+Next action:
+- Run `ticket-preflight-workflow` before implementation delegation.
+- Preflight should record: `cwd` schema/name, required validation (`absolute`, existing directory, within parent read authority), whether cwd must also be readable by delegated child scope or only by parent authority at launch, exact relationship to child process `current_dir` and Bash default cwd, unchanged workspace/profile/Pod-name semantics, diagnostics, and workflow guidance updates.
+- Leave this Ticket queued for now; do not transition `queued -> inprogress`, create `.worktree/allow-spawnpod-child-workspace-cwd`, or spawn coder/reviewer Pods until preflight records implementation readiness.
+
+Escalate if:
+- cwd validation would require broad capability model changes.
+- Setting child process cwd cannot be separated from workspace-root/Profile discovery.
+- Tool default cwd cannot be made consistent without changing Bash/tool execution semantics more broadly.
+
+---
+
+<!-- event: decision author: orchestrator at: 2026-06-08T07:06:17Z -->
+
+## Decision
+
+Routing decision: implementation_ready
+
+Correction:
+- The previous `preflight_needed` routing decision was too conservative. The Ticket body already fixes the core authority boundary: `cwd` is intentionally separate from runtime workspace root, Profile discovery, project/Ticket/memory roots, and Pod identity.
+- The remaining choices are bounded implementation details rather than preflight blockers.
+
+Reason:
+- The Ticket explicitly states that `SpawnPod.cwd` is optional child process/tool working-directory context, not workspace context and not an authority grant.
+- It already records that `cwd` does not replace delegated scope and does not change profile/manifest/workspace-root semantics.
+- The recently merged direct/delegation authority split strengthens the surrounding invariant: child scope delegation remains explicit and independent from process cwd.
+- Requirements and acceptance criteria are observable: schema/input support, validation/diagnostics, child process current_dir/default Bash cwd, workflow guidance, and tests.
+
+Evidence checked:
+- Ticket body and thread, including the user clarification that the Ticket exists specifically to separate workspace and cwd.
+- Workspace state: no existing matching worktree/branch; main workspace clean before this routing update.
+- Existing workflow pain observed earlier: spawned child Pods currently validate/run from parent cwd and require non-recursive parent read grants even when implementation work should be rooted in a child worktree.
+- Related completed Ticket: `split-direct-and-delegation-authority` has now separated direct scope from delegation authority, so `cwd` can remain a process context without implying child authority.
+
+IntentPacket:
+
+Intent:
+- Add an optional `cwd` field to `SpawnPod` so the parent can choose the child process/tool default working directory independently from runtime workspace context and delegated scope.
+
+Binding decisions / invariants:
+- `cwd` means child process/tool working directory only.
+- `cwd` is not runtime workspace root.
+- `cwd` does not affect Profile discovery, project record root, Ticket config root, workflow registry, memory root discovery, Pod name/default identity, or role launch workspace context.
+- `cwd` grants no read/write authority. Child filesystem access remains controlled by explicit delegated `scope` and, after the direct/delegation split, by the parent's delegation authority.
+- Omitted `cwd` preserves existing behavior as closely as possible.
+- Provided `cwd` must be absolute, exist, and be a directory.
+- Provided `cwd` must be readable/usable under the child effective direct scope, or launch must fail clearly. This prevents starting a child in a directory it cannot inspect/use.
+- Worktree/multi-agent workflows should set coder `cwd` to the child worktree while still delegating explicit read/write scope to that worktree.
+- Reviewer `cwd` is a workflow convenience, not an authority signal.
+
+Requirements / acceptance criteria:
+- Extend `SpawnPod` tool input/schema with optional `cwd`.
+- Validate `cwd` before child launch and return clear errors for relative, missing, non-directory, or not-in-child-scope paths.
+- Start the spawned Pod process with `cwd` as its process current directory when provided.
+- Ensure the child Bash/tool default cwd is the provided `cwd` so commands no longer need mandatory `cd <worktree> && ...` wrappers.
+- Preserve existing behavior for callers that omit `cwd`.
+- Keep delegated scope validation independent from `cwd`.
+- Update multi-agent/worktree workflow guidance and/or generated launch prompt wording where maintained guidance currently tells coders to `cd` into worktrees because SpawnPod cannot set cwd.
+- Add focused tests for schema/validation and child launch cwd behavior where practical.
+
+Implementation latitude:
+- Coder may choose exact Rust field names/types and validation helper placement.
+- Coder may update only maintained workflow/prompt guidance that directly references child worktree `cd` workarounds.
+- If runtime process cwd is easier to validate via child direct scope than parent authority, prefer child-scope validation because `cwd` is for the child's usable environment, not a parent capability grant.
+- Coder may leave role launcher/Profile workspace-root behavior untouched unless a test proves `cwd` currently contaminates it.
+
+Escalate if:
+- Adding `cwd` requires changing workspace-root/Profile/memory-root semantics.
+- Child process current_dir cannot be changed without broad runtime command redesign.
+- A safe validation rule cannot be expressed without granting authority via `cwd`.
+- Existing spawned Pod registry/scope accounting assumes child process cwd is always the parent cwd in a way that cannot be localized.
+
+Validation:
+- Focused tests for `SpawnPod` input/schema validation.
+- Tests or probes proving provided `cwd` becomes the child process/tool default cwd while omitted `cwd` preserves current behavior.
+- SpawnPod scope/delegation tests to ensure `cwd` does not bypass delegated scope.
+- `cargo test -p pod spawn_pod --test spawn_pod_test` or focused equivalent.
+- `cargo test -p protocol` / schema tests if tool input types live there.
+- `cargo fmt --check`.
+- `git diff --check`.
+- `cargo run -q -p yoi -- ticket doctor`.
+- Because tool schema/runtime/workflow guidance may change, final merge-completion should include `nix build .#yoi`.
+
+Current code map:
+- `crates/pod/src/tools/pod_management.rs` or current SpawnPod tool input/handler path.
+- `crates/pod/src/spawn/tool.rs` and related runtime spawn implementation after the authority split.
+- `crates/protocol/src/lib.rs` if tool schemas/input structs are protocol-owned.
+- `crates/pod/tests/spawn_pod_test.rs` for SpawnPod behavior tests.
+- Workflow guidance files for worktree/multi-agent coder instructions.
+
+Critical risks / reviewer focus:
+- `cwd` must not become a hidden workspace-root or authority source.
+- Relative/missing/out-of-scope cwd must fail clearly before launch.
+- Omitted `cwd` must preserve existing launch behavior.
+- Child direct tools must run from `cwd` by default when provided.
+- Delegated scope and delegation authority validation must remain independent and stricter than cwd convenience.
+
+---
+
+<!-- event: state_changed author: orchestrator at: 2026-06-08T07:06:29Z from: queued to: inprogress reason: orchestrator_acceptance field: workflow_state -->
+
+## State changed
+
+Accepted queued implementation after correcting the prior over-conservative preflight routing and recording an implementation-ready IntentPacket. This acceptance precedes worktree creation and coder/reviewer Pod spawning.
+
+---
+
+<!-- event: plan author: orchestrator at: 2026-06-08T07:07:00Z -->
+
+## Plan
+
+Implementation routing accepted and worktree created.
+
+Worktree plan:
+- Branch: `allow-spawnpod-child-workspace-cwd`
+- Worktree: `.worktree/allow-spawnpod-child-workspace-cwd`
+- Base: `15cf4a1 ticket: route spawnpod cwd implementation`
+- Scope: add optional `SpawnPod.cwd` as child process/tool working-directory context, separate from workspace root and delegated authority.
+
+Delegation plan:
+- Spawn sibling coder Pod with write scope limited to `.worktree/allow-spawnpod-child-workspace-cwd`.
+- Coder must run Bash commands from the child worktree for now because the current live `SpawnPod` tool does not yet support `cwd`; implementing that support is the Ticket goal.
+- Coder must not edit main-workspace `.yoi` / Ticket / workflow / docs records, and must not create generated memory/local/runtime/secret-like files.
+- Reviewer will be spawned read-only after coder reports diff/commits and validation evidence.
+
+Stop/completion policy:
+- Because the human authorized cleanup after completion, this Orchestrator will proceed through reviewer approval, merge-completion validation, Ticket close, Pod stop, worktree removal, and branch deletion if the branch is approved and merge authority remains clear.
+
+---
+
+<!-- event: implementation_report author: orchestrator at: 2026-06-08T07:25:03Z -->
+
+## Implementation report
+
+Coder completed and reviewer delegated.
+
+Coder result:
+- Pod: `coder-spawnpod-child-cwd`
+- Commit: `3dd7707 feat: add SpawnPod cwd`
+- Worktree status: clean after commit.
+- Diff against `develop`: 6 files changed, 270 insertions, 6 deletions.
+
+Files touched by coder:
+- `crates/pod/src/spawn/tool.rs`
+- `crates/pod/tests/spawn_pod_test.rs`
+- `resources/prompts/internal.toml`
+- `crates/client/src/ticket_role.rs`
+- `.yoi/workflow/multi-agent-workflow.md`
+- `.yoi/workflow/worktree-workflow.md`
+
+Coder reported implementation:
+- Added `SpawnPodInput.cwd: Option<PathBuf>`.
+- Validates relative, missing, non-directory, and not-child-readable-scope `cwd` before launch with `InvalidArgument` diagnostics.
+- Omitted `cwd` preserves existing spawner-pwd behavior.
+- Provided `cwd` is passed to child process `Command::current_dir(...)`.
+- Added focused tests for schema/validation, provided cwd becoming child process cwd, and omitted cwd preserving previous behavior.
+- Updated maintained SpawnPod and multi-agent/worktree guidance to describe `cwd` as non-authority child working directory.
+
+Coder reported validation:
+- `cargo test -p pod spawn_pod --test spawn_pod_test`
+- `cargo test -p pod spawn_pod`
+- `cargo fmt`
+- `cargo fmt --check`
+- `git diff --check`
+- `cargo run -q -p yoi -- ticket doctor`
+- `nix build .#yoi`
+
+Reviewer delegation:
+- Spawned sibling reviewer Pod: `reviewer-spawnpod-child-cwd`.
+- Reviewer scope: read-only child worktree plus non-recursive parent-root read required by current launch cwd behavior.
+- Reviewer was instructed to judge against the recorded Ticket requirements and binding decisions.
+
+Pending:
+- Await reviewer verdict before merge-ready dossier / merge-completion.
+- No merge, close, final approval, or cleanup has occurred for this Ticket.
+
+---
+
+<!-- event: implementation_report author: orchestrator at: 2026-06-08T07:32:03Z -->
+
+## Implementation report
+
+Reviewer returned `request_changes`; coder fix-loop delegated.
+
+Reviewer verdict:
+- `request_changes`
+
+Blocker:
+- Current implementation makes `cwd` affect spawned child runtime workspace/context instead of only child process/tool working directory.
+
+Reviewer evidence:
+- `SpawnPod` launches the child command with `.current_dir(child_cwd)`.
+- The child `yoi pod --adopt` entrypoint defaults `--workspace` to `.` and resolves it through `std::env::current_dir()`.
+- Runtime setup then sets current_dir to that workspace and `Pod::new` captures current pwd for workspace-like context, memory layout, and workflow loading.
+- Therefore `cwd=<repo>/.worktree/<task>` causes the child runtime to derive workspace/memory/workflow context from the worktree, violating the Ticket invariant that `cwd` is not runtime workspace root and must not affect project/Ticket/workflow/memory/Profile context.
+
+Action taken:
+- Sent fix-loop instructions to `coder-spawnpod-child-cwd`.
+- Required fix: preserve inherited runtime workspace root/context separately from requested tool/Bash `cwd`; ensure omitted `cwd` preserves existing behavior; keep validation independent from authority; add tests that fail against the blocked implementation rather than only fake-command `pwd` tests.
+
+Pending:
+- Await coder fix report and reviewer re-review.
+- No merge, close, final approval, or cleanup has occurred.
+
+---
+
+<!-- event: implementation_report author: orchestrator at: 2026-06-08T08:08:10Z -->
+
+## Implementation report
+
+Coder fix-loop completed and reviewer re-review delegated.
+
+Coder follow-up:
+- Commit: `248744f fix: keep SpawnPod cwd separate`
+- Worktree: clean on branch `allow-spawnpod-child-workspace-cwd`.
+- Fixes claimed:
+  - `SpawnPod.cwd` is passed as hidden `--tool-cwd`, while child runtime still receives inherited `--workspace <parent workspace root>`.
+  - Child process launch current_dir is workspace root, not tool cwd, preventing runtime context from being derived from the tool cwd.
+  - Adopted child startup separates runtime workspace context from tool cwd.
+  - `Pod` stores `workspace_root` and `pwd` separately; memory/Ticket/workflow/Profile context uses `workspace_root`, while Bash/tools/ScopedFs use `pwd`.
+  - Ticket role coder guidance no longer assumes mandatory `cd <worktree>` when SpawnPod cwd is available.
+  - Added tests proving runtime workspace and tool cwd stay separate, omitted cwd preserves prior pwd behavior, and memory layout derives from workspace root rather than tool cwd.
+
+Coder validation reported:
+- `cargo test -p pod spawn_pod`
+- `cargo fmt --check`
+- `git diff --check`
+- `cargo run -q -p yoi -- ticket doctor`
+- `nix build .#yoi`
+
+Action taken:
+- Sent updated commits and prior blocker checklist to `reviewer-spawnpod-child-cwd` for read-only re-review.
+
+Pending:
+- Await reviewer verdict before merge-ready dossier / merge-completion.
+- No merge, close, final approval, or cleanup has occurred.
+
+---
+
+<!-- event: implementation_report author: orchestrator at: 2026-06-08T08:13:38Z -->
+
+## Implementation report
+
+Merge-ready dossier: SpawnPod child cwd
+
+Ticket id/slug:
+- `20260608-011036-allow-spawnpod-child-workspace-cwd` / `allow-spawnpod-child-workspace-cwd`
+
+Branch/worktree:
+- Branch: `allow-spawnpod-child-workspace-cwd`
+- Worktree: `.worktree/allow-spawnpod-child-workspace-cwd`
+- Current branch commits:
+  - `3dd7707 feat: add SpawnPod cwd`
+  - `248744f fix: keep SpawnPod cwd separate`
+
+Intent / invariant check:
+- `SpawnPod.cwd` is child process/tool working directory only.
+- Runtime workspace/project/Ticket/workflow/memory/Profile context remains inherited through explicit workspace root and is not derived from tool cwd.
+- `cwd` grants no authority; child filesystem access remains controlled by explicit delegated direct scope and parent delegation authority.
+- Omitted `cwd` preserves current/spawner-pwd behavior.
+- Invalid/missing/non-directory/not-child-readable-scope cwd is rejected before launch.
+
+Implementation summary:
+- Added optional `SpawnPodInput.cwd`.
+- Added validation for relative/missing/non-directory/not-child-scope-readable cwd.
+- Initial implementation blocker was fixed by separating runtime workspace root from tool cwd:
+  - child runtime receives explicit `--workspace <parent workspace root>`;
+  - child tool cwd is passed separately as hidden `--tool-cwd`;
+  - command launch current_dir remains workspace root, not tool cwd;
+  - Pod stores `workspace_root` and `pwd` separately.
+- Updated nested SpawnPod registration so inherited workspace root and current tool pwd remain distinct.
+- Updated maintained prompt/workflow guidance to use `SpawnPod.cwd` as non-authority child working directory while still delegating explicit scope.
+
+Files touched:
+- `.yoi/workflow/multi-agent-workflow.md`
+- `.yoi/workflow/worktree-workflow.md`
+- `crates/client/src/ticket_role.rs`
+- `crates/pod/src/controller.rs`
+- `crates/pod/src/entrypoint.rs`
+- `crates/pod/src/pod.rs`
+- `crates/pod/src/spawn/tool.rs`
+- `crates/pod/tests/spawn_pod_test.rs`
+- `resources/prompts/internal.toml`
+
+Coder / reviewer Pods:
+- Coder: `coder-spawnpod-child-cwd`
+- Reviewer: `reviewer-spawnpod-child-cwd`
+
+Review evidence:
+- Initial reviewer verdict: `request_changes` because `Command::current_dir(child_cwd)` caused child runtime workspace context to be derived from cwd.
+- Coder fix commit: `248744f fix: keep SpawnPod cwd separate`.
+- Re-review verdict: `approve`.
+- Reviewer confirmed runtime workspace and tool cwd are now separated, memory/workflow layout uses workspace root, tool cwd is used for default tool/Bash cwd, omitted cwd preserves behavior, and validation remains non-authority.
+
+Validation performed by coder and/or reviewer:
+- `cargo test -p pod spawn_pod --test spawn_pod_test`
+- `cargo test -p pod spawn_pod`
+- `cargo fmt --check`
+- `git diff --check develop...HEAD`
+- `cargo run -q -p yoi -- ticket doctor`
+- `nix build .#yoi`
+
+Blockers fixed or rejected findings:
+- Fixed: `cwd` no longer changes runtime workspace/project/Ticket/workflow/memory context.
+- No remaining reviewer blockers.
+
+Residual risks:
+- Child effective direct scope must be readable for both inherited workspace root and tool cwd. This is intentional and keeps cwd non-authoritative, but manual callers must include workspace read scope when using a worktree cwd.
+- Restore behavior for an already-spawned Pod's distinct tool cwd was not deeply audited beyond launch-time requirements; reviewer judged launch and nested SpawnPod behavior sufficient for this Ticket.
+
+Dirty state:
+- Child worktree is clean at `248744f`.
+- Main workspace has unrelated active worktrees/Ticket-record changes for Ticket language work; they are outside this branch's core implementation paths and understood. Note that both branches touch `crates/client/src/ticket_role.rs`, so later Ticket-language merge may need normal conflict awareness.
+
+Parent/human decision needs:
+- User has authorized merge-completion and cleanup after approved work. Proceeding to merge-completion unless post-merge validation fails.
+
+---
+
+<!-- event: review author: orchestrator at: 2026-06-08T08:17:33Z status: approve -->
+
+## Review: approve
+
+Final merge-completion approval after merge to `develop` and post-merge validation.
+
+Evidence:
+- Merged branch `allow-spawnpod-child-workspace-cwd` with `--no-ff`; a merge conflict in `crates/pod/src/pod.rs` was resolved by preserving both the Intake role marker methods and the new tool/process cwd documentation.
+- Reviewer `reviewer-spawnpod-child-cwd` approved after fix-loop.
+- Post-merge validation passed: `cargo test -p pod spawn_pod --test spawn_pod_test`, `cargo test -p pod spawn_pod`, `cargo check -q`, `cargo fmt --check`, `git diff --check`, `cargo run -q -p yoi -- ticket doctor`, and `nix build .#yoi`.
+- Coder/reviewer Pods stopped and delegated scope reclaimed.
+- Merged worktree removed and branch deleted.
+
+This approval is for the merged main-branch result, not merely the branch-local reviewer verdict.
+
+---
+
+<!-- event: state_changed author: orchestrator at: 2026-06-08T08:17:33Z from: inprogress to: done reason: merged_and_validated field: workflow_state -->
+
+## State changed
+
+Merged to `develop`, post-merge validation passed, final merge-completion approval recorded, and SpawnPod cwd branch/worktree/Pods cleaned up.
+
+---
+
+<!-- event: close author: hare at: 2026-06-08T08:17:51Z status: closed -->
+
+## Closed
+
+Merged and completed `SpawnPod.cwd` support.
+
+Summary:
+- Added optional `SpawnPodInput.cwd` for child process/tool working directory.
+- Validates `cwd` before launch: absolute, existing directory, and usable under the child effective direct scope.
+- Preserves omitted-`cwd` behavior.
+- Separates runtime workspace context from tool cwd: child runtime receives inherited `--workspace`, while requested tool cwd is passed separately as hidden `--tool-cwd`.
+- `Pod` now separates `workspace_root` from `pwd`; workspace/project/Ticket/workflow/memory/Profile context uses `workspace_root`, while tools/Bash/ScopedFs use `pwd`.
+- Updated maintained multi-agent/worktree guidance to use `SpawnPod.cwd` as non-authority convenience while keeping delegated scope explicit.
+
+Merged branch/worktree:
+- Branch: `allow-spawnpod-child-workspace-cwd`
+- Commits: `3dd7707`, `248744f`
+- Merge commit on `develop`: `05df656 merge: allow SpawnPod child cwd`
+
+Validation passed after merge:
+- `cargo test -p pod spawn_pod --test spawn_pod_test`
+- `cargo test -p pod spawn_pod`
+- `cargo check -q`
+- `cargo fmt --check`
+- `git diff --check`
+- `cargo run -q -p yoi -- ticket doctor`
+- `nix build .#yoi`
+
+Cleanup completed:
+- Stopped coder/reviewer Pods and reclaimed scope.
+- Removed `.worktree/allow-spawnpod-child-workspace-cwd`.
+- Deleted branch `allow-spawnpod-child-workspace-cwd`.
+
+Residual notes:
+- Manual callers using a worktree cwd must still delegate readable workspace context plus explicit worktree scope; `cwd` grants no authority.
+- Restore behavior for already-spawned Pods with distinct tool cwd was not deeply audited beyond launch-time/nested SpawnPod behavior and remains a possible future refinement if needed.
+
+---