@gotgenes/pi-subagents 10.1.0 → 10.2.1

package/docs/plans/0231-push-exec-registry-to-runner.md

@@ -0,0 +1,245 @@
+---
+issue: 231
+issue_title: "Push exec/registry relay deps to runner construction (Phase 15, Step 3)"
+---
+
+# Push exec/registry relay deps to runner construction
+
+## Problem Statement
+
+`AgentManager` receives `exec` and `registry` in its constructor but never uses them directly.
+They are stored as fields solely to relay them into `runner.run()` via the `RunContext` parameter.
+This makes `AgentManager` wider than necessary and prevents the runner from being self-contained — a prerequisite for #229 (Agent.run() absorbs startAgent).
+
+## Goals
+
+- Move `exec` and `registry` from `AgentManager` construction to `ConcreteAgentRunner` construction.
+- Remove `exec` and `registry` from `AgentManagerOptions` (7 → 5 fields).
+- Remove `exec` and `registry` from `RunContext` (4 → 2 fields).
+- Group runner-owned dependencies in a `RunnerDeps` interface: `{ io, exec, registry }`.
+- Replace `runAgent()`'s `io: RunnerIO` parameter with `deps: RunnerDeps`.
+
+## Non-Goals
+
+- Dissolving `RunContext` entirely — it shrinks to `{ cwd?, parentSession? }`, which is still a coherent per-call grouping.
+  Issue #229 will likely dissolve it when `Agent.run()` calls the runner directly.
+- Changing the `AgentRunner` interface's `run()` signature — callers continue to pass `RunOptions` with `context: RunContext`.
+  `ConcreteAgentRunner` merges its stored deps before calling `runAgent()`.
+- Touching `resume()` or `resumeAgent()` — they don't use `exec` or `registry`.
+
+## Background
+
+Issue #169 extracted `RunContext` from `RunOptions` to group the 4 parent-context fields: `exec`, `registry`, `cwd`, `parentSession`.
+The doc comment describes them as "parent environment and identity" fields.
+However, 2 of the 4 fields (`exec`, `registry`) are static — identical across every `run()` call — while the other 2 (`cwd`, `parentSession`) vary per spawn.
+The static pair are relay-only dependencies on `AgentManager`: stored at construction, never read, only forwarded.
+
+From the code-design skill, this is a **parameter relay** smell: intermediaries (`AgentManager`) carry fields they never use, only to thread them to the endpoint (`runAgent`).
+The fix: put them on the object the endpoint owns — the runner.
+
+### Key references
+
+- `src/lifecycle/agent-manager.ts` — stores `exec` and `registry`, relays them at lines 193–194.
+- `src/lifecycle/agent-runner.ts` — `RunContext` interface (line 125), `ConcreteAgentRunner` class (line 189), `runAgent()` free function (line 236).
+- `src/index.ts` — constructs both `ConcreteAgentRunner` and `AgentManager` (lines 148–157).
+- Phase 15 roadmap in `docs/architecture/architecture.md` § Step 3.
+
+## Design Overview
+
+### RunnerDeps — grouping runner-owned dependencies
+
+A new `RunnerDeps` interface groups the three dependencies that the runner owns:
+
+```typescript
+export interface RunnerDeps {
+  io: RunnerIO;
+  exec: ShellExec;
+  registry: AgentConfigLookup;
+}
+```
+
+`ConcreteAgentRunner` takes `RunnerDeps` at construction:
+
+```typescript
+export class ConcreteAgentRunner implements AgentRunner {
+  constructor(private readonly deps: RunnerDeps) {}
+
+  run(snapshot, type, prompt, options) {
+    return runAgent(snapshot, type, prompt, options, this.deps);
+  }
+}
+```
+
+`runAgent()` changes its last parameter from `io: RunnerIO` to `deps: RunnerDeps`:
+
+```typescript
+export async function runAgent(
+  snapshot: ParentSnapshot,
+  type: SubagentType,
+  prompt: string,
+  options: RunOptions,
+  deps: RunnerDeps,
+): Promise<RunResult> {
+  const effectiveCwd = options.context?.cwd ?? snapshot.cwd;
+  const env = await deps.io.detectEnv(deps.exec, effectiveCwd);
+  // ...
+  const cfg = assembleSessionConfig(type, ..., deps.registry, deps.io.assemblerIO);
+  // ...
+}
+```
+
+### RunContext shrinks
+
+`RunContext` loses `exec` and `registry`:
+
+```typescript
+export interface RunContext {
+  /** Override working directory (e.g. for worktree isolation). */
+  cwd?: string;
+  /** Parent session identity (file path + session ID). */
+  parentSession?: ParentSessionInfo;
+}
+```
+
+The `AgentRunner.run()` interface is unchanged — callers still pass `RunOptions` with `context: RunContext`.
+`ConcreteAgentRunner.run()` reads `exec` and `registry` from its own `deps` instead of from `options.context`.
+
+### AgentManager loses 2 fields
+
+`AgentManagerOptions` removes `exec` and `registry`.
+`AgentManager` removes the corresponding private fields and the `this.exec` / `this.registry` relay in `startAgent()`.
+The `context` object constructed in `startAgent()` shrinks from 4 fields to 2:
+
+```typescript
+context: {
+  cwd: record.worktreeState?.path,
+  parentSession: options.parentSession,
+},
+```
+
+### Wiring in index.ts
+
+```typescript
+const runner = new ConcreteAgentRunner({
+  io: runnerIO,
+  exec: (cmd, args, opts) => pi.exec(cmd, args, opts),
+  registry,
+});
+
+const manager = new AgentManager({
+  runner,
+  worktrees: new GitWorktreeManager(process.cwd()),
+  observer,
+  getMaxConcurrent: () => settings.maxConcurrent,
+  getRunConfig: () => settings,
+});
+```
+
+## Module-Level Changes
+
+### `src/lifecycle/agent-runner.ts`
+
+1. Add `RunnerDeps` interface (exported): `{ io: RunnerIO; exec: ShellExec; registry: AgentConfigLookup }`.
+2. Remove `exec` and `registry` from `RunContext`.
+   Update doc comment to reflect the 2 remaining per-call fields.
+3. Update `ConcreteAgentRunner` constructor: accept `RunnerDeps` instead of `RunnerIO`.
+4. Update `ConcreteAgentRunner.run()`: pass `this.deps` to `runAgent()`.
+5. Update `runAgent()`: change last parameter from `io: RunnerIO` to `deps: RunnerDeps`.
+   Replace `io.` references with `deps.io.`, `options.context.exec` with `deps.exec`, `options.context.registry` with `deps.registry`.
+
+### `src/lifecycle/agent-manager.ts`
+
+1. Remove `exec: ShellExec` and `registry: AgentTypeRegistry` from `AgentManagerOptions`.
+2. Remove `private readonly exec` and `private readonly registry` fields from `AgentManager`.
+3. Remove assignment of `this.exec` and `this.registry` in the constructor.
+4. Remove `exec: this.exec` and `registry: this.registry` from the `context` object in `startAgent()`.
+5. Remove `ShellExec` and `AgentTypeRegistry` imports (verify no other references first).
+
+### `src/index.ts`
+
+1. Move `exec` and `registry` from the `AgentManager` constructor call to `ConcreteAgentRunner`:
+   `new ConcreteAgentRunner({ io: runnerIO, exec: ..., registry })`.
+2. Remove `exec` and `registry` from the `AgentManager({...})` constructor argument.
+
+### `test/lifecycle/agent-runner.test.ts`
+
+1. Update all `runAgent(..., io)` calls to `runAgent(..., { io, exec, registry: mockAgentLookup })`.
+2. Remove `exec` and `registry` from `context:` objects in `RunOptions`.
+   `context: { exec, registry: mockAgentLookup }` → `context: {}` or `{}`.
+
+### `test/lifecycle/agent-runner-extension-tools.test.ts`
+
+1. Same pattern as `agent-runner.test.ts`: update `runAgent(..., io)` last param and strip `exec`/`registry` from `context:`.
+
+### `test/lifecycle/concrete-agent-runner.test.ts`
+
+1. Update `new ConcreteAgentRunner(io)` → `new ConcreteAgentRunner({ io, exec: vi.fn(), registry })`.
+2. Remove `exec` and `registry` from the `context:` in `runner.run()` call options.
+
+### `test/lifecycle/agent-manager.test.ts`
+
+1. Remove `exec: vi.fn()` and `registry: testRegistry` from `createManager()` factory.
+2. Remove the `testRegistry` construction and `AgentTypeRegistry` import if no other references exist.
+
+### `test/helpers/runner-io.ts`
+
+1. No structural changes needed — `createRunnerIO()` returns the `RunnerIO` shape, which is unchanged.
+   However, add a `createRunnerDeps()` convenience factory that bundles `{ io: createRunnerIO(), exec: vi.fn(), registry: createAgentLookup() }` for runner test files.
+
+### `docs/architecture/architecture.md`
+
+1. Update the `RunContext` code block in § "RunOptions (12 fields → extract RunContext)" to show only `cwd` and `parentSession`.
+2. Update the field-count description (4 → 2 per-call fields).
+3. Mark Step 3 as complete in the Phase 15 roadmap.
+
+## Test Impact Analysis
+
+1. No new test surfaces are needed — this is a pure mechanical refactoring (moving constructor parameters).
+   The existing runner and manager test suites fully cover the behavior.
+2. No existing tests become redundant — all tests exercise the same interactions, just with deps flowing through a different path.
+3. Existing `agent-manager.test.ts` tests remain as-is in coverage scope.
+   They verify `AgentManager` behavior (spawning, queueing, abort, etc.) independent of runner deps.
+4. Existing `agent-runner.test.ts` and `concrete-agent-runner.test.ts` tests remain.
+   They verify `runAgent()` and `ConcreteAgentRunner` behavior.
+   Call-site patterns change but assertions stay the same.
+
+## TDD Order
+
+1. **Add `RunnerDeps` interface and update `runAgent()` parameter** — define `RunnerDeps`, change `runAgent()`'s last param from `io` to `deps`, update internal references.
+   Update `agent-runner.test.ts` and `agent-runner-extension-tools.test.ts` call sites.
+   Commit: `refactor: add RunnerDeps and update runAgent parameter (#231)`
+
+2. **Update `ConcreteAgentRunner` to accept `RunnerDeps`** — change constructor from `RunnerIO` to `RunnerDeps`, update `.run()` to pass `this.deps`.
+   Update `concrete-agent-runner.test.ts`.
+   Add `createRunnerDeps()` helper to `test/helpers/runner-io.ts`.
+   Commit: `refactor: ConcreteAgentRunner accepts RunnerDeps (#231)`
+
+3. **Remove `exec` and `registry` from `RunContext`** — shrink the interface to 2 fields, update doc comment.
+   Strip `exec`/`registry` from `context:` in all runner test call sites.
+   Run `pnpm run check` to verify no stale references.
+   Commit: `refactor: remove exec and registry from RunContext (#231)`
+
+4. **Remove `exec` and `registry` from `AgentManager`** — remove from `AgentManagerOptions`, remove class fields, remove relay in `startAgent()`, clean up imports.
+   Update `agent-manager.test.ts` factory.
+   Commit: `refactor: remove relay deps from AgentManager (#231)`
+
+5. **Update wiring in `index.ts`** — move `exec` and `registry` from `AgentManager` construction to `ConcreteAgentRunner` construction.
+   Commit: `refactor: wire exec and registry to ConcreteAgentRunner (#231)`
+
+6. **Update architecture docs** — update `RunContext` description and field counts, mark Step 3 complete.
+   Commit: `docs: update architecture for runner self-contained (#231)`
+
+## Risks and Mitigations
+
+1. **Test churn** — ~20 `runAgent()` call sites change their last parameter pattern.
+   Mitigation: mechanical find-and-replace; assertions stay identical.
+2. **Step ordering** — Steps 3 and 4 both remove `exec`/`registry` from different types.
+   If done in the wrong order, intermediate commits may not type-check.
+   Mitigation: Step 1–2 add the new path (`deps`), Step 3 removes from `RunContext` (runner side), Step 4 removes from `AgentManager` (manager side), Step 5 wires them together.
+   Each commit is independently valid.
+3. **Import cleanup** — removing `exec`/`registry` from `AgentManager` may leave unused imports (`ShellExec`, `AgentTypeRegistry`).
+   Mitigation: grep for other usages before removing; `pnpm run check` catches unused imports.
+
+## Open Questions
+
+- None — the issue scope is narrow and the design is straightforward.

package/docs/retro/0227-evolve-agent-record-into-agent.md

@@ -35,3 +35,46 @@ Test count went from 977 to 986 across 62 test files.
 - Biome auto-formatted several test files during the rename commit; re-staged and re-committed.
 - Pre-completion reviewer returned **WARN** for 4 stale diagram/table references in `architecture.md` and the `package-pi-subagents` skill table; all fixed before the final commit.
 - No deviations from the plan's behavior design; the `queueSteer` removal from manager interfaces worked exactly as anticipated in the retro notes.
+
+## Stage: Final Retrospective (2026-05-27T17:22:00Z)
+
+### Session summary
+
+Completed all stages in a single session: planning, 8 TDD steps, pre-completion review, shipping, and release as `pi-subagents-v10.1.0`.
+Three behaviors (`abort`, steer buffering, worktree setup) moved from `AgentManager` to `Agent`, followed by a codebase-wide rename (33 files).
+
+### Observations
+
+#### What went well
+
+- The "add behavior first, rename last" strategy kept behavior-adding commits small (1–2 files each) and the rename commit purely mechanical.
+- Planning identified that `queueSteer` could be removed from `AgentManagerLike` and `SteerToolManager` entirely — this simplified the delegation step and eliminated an unnecessary indirection layer.
+- Pre-completion reviewer caught 4 stale Mermaid diagram references and a skill table entry that the plan's step 8 did not anticipate; all fixed before shipping.
+
+#### What caused friction (agent side)
+
+1. `scope-drift` — Added `AgentInit` and `AgentStatus` to the `types.ts` re-export barrel during the rename step without verifying any file imports them from that path.
+   Impact: fallow flagged dead code, triggering a 4-call suppression trial (`unused-export` → `unused-types` → `unused-type`), then the user identified the real fix (remove the speculative re-exports entirely), requiring a follow-up `fix:` commit after docs were already done.
+2. `missing-context` — During the mechanical rename (step 7), `sed` commands matched `#test/helpers/make-record` but missed the relative import `"./helpers/make-record"` in `conversation-viewer.test.ts`.
+   Impact: `pnpm run check` caught it in 1 tool call; minimal rework.
+3. `missing-context` — The fallow skill documents `unused-export` as a suppression kind but not `unused-type`.
+   Impact: 3 wrong guesses before the correct suppression syntax.
+   Self-identified after fallow's error message suggested the correct kind name.
+
+#### What caused friction (user side)
+
+- The user's question about whether the fallow suppressions could be removed in a future step was a valuable prompt — it surfaced that the re-exports were speculative and could be removed immediately.
+  Earlier intervention (e.g., during the TDD stage when the suppressions were added) would have avoided the `fix:` commit.
+
+### Diagnostic details
+
+- **Model-performance correlation** — Pre-completion reviewer ran as `pre-completion-reviewer` subagent (default model); appropriate for judgment-heavy work (doc staleness, code design review).
+  No model mismatches.
+- **Feedback-loop gap analysis** — `pnpm run check` was run after every delegation step (steps 2, 4, 6, 7) and after every behavior-adding step (steps 1, 3, 5).
+  Verification was incremental throughout, not deferred to the end.
+  The `conversation-viewer.test.ts` import miss in step 7 was caught immediately by the type checker.
+
+### Changes made
+
+1. `.pi/skills/fallow/SKILL.md` — Added `unused-type` suppression example alongside existing `unused-export` example.
+2. `AGENTS.md` — Added "no speculative re-exports" rule to Code Style section.

package/docs/retro/0228-async-start-agent-dissolve-run-handle.md

@@ -0,0 +1,80 @@
+---
+issue: 228
+issue_title: "Convert startAgent to async/await, move run lifecycle to Agent (Phase 15, Step 2)"
+---
+
+# Retro: #228 — Convert startAgent to async/await, move run lifecycle to Agent
+
+## Stage: Planning (2026-05-27T20:00:00Z)
+
+### Session summary
+
+Planned the async `startAgent` conversion and decided to dissolve `RunHandle` into Agent methods rather than moving it as a separate class.
+Identified three preparatory steps (narrow promise type, add Agent methods, hoist worktree setup) that make the final async conversion a minimal diff.
+
+### Observations
+
+- The original issue proposed `Agent.createRunHandle()` as a factory, keeping RunHandle as a separate class.
+  Analysis showed 5 of 6 RunHandle concerns are Agent state mutations — RunHandle is doing work that belongs on Agent.
+  The clincher was `resume()` in `agent-manager.ts`: it duplicates RunHandle's pattern manually, and #232 wants to unify them.
+  Dissolving RunHandle gives both `startAgent` and `resume` the same primitives (`completeRun`, `failRun`, `releaseListeners`).
+- The synchronous-throw contract in `spawn()` for worktree failures requires hoisting `record.setupWorktree()` out of `startAgent` before the async conversion.
+  Without this prep step, async `startAgent` would turn the throw into a rejected promise that `spawn()` doesn't catch.
+- `promise: Promise<string>` → `Promise<void>` is safe because the resolved string is dead — every consumer reads `record.result` instead.
+  Only one test assertion reads the resolved value.
+- `completeRun`/`failRun` take `worktrees: WorktreeManager` as a parameter rather than storing it on Agent (ISP — only needed at run end, exactly two callers).
+
+## Stage: Implementation — TDD (2026-05-27T20:40:00Z)
+
+### Session summary
+
+Implemented all 6 TDD steps: narrowed `promise` to `Promise<void>`, added 6 run lifecycle methods to Agent (+19 tests), replaced `RunHandle` with Agent methods (-85 LOC), hoisted worktree setup to callers, converted `startAgent` to async/await, and updated architecture docs.
+Test count: 986 → 1005.
+
+### Observations
+
+- Step 1 (promise narrowing) required fixing 3 additional test files not listed in the plan: `make-agent.test.ts`, `service-adapter.test.ts`, `get-result-tool.test.ts`.
+  All were trivial `Promise.resolve("done")` → `Promise.resolve()` changes and a cast removal.
+- The lift-and-shift approach worked cleanly — each of the 5 implementation commits was small and independently green.
+  The most impactful commit was step 3 (replace RunHandle, -96/+6 lines) which was risk-free because step 2 had already introduced the Agent methods.
+- Pre-completion reviewer returned WARN for stale `AgentRecord` and `run-handle.ts` references in `architecture.md` class diagram and layout listing.
+  These were pre-existing staleness from #227's rename that wasn't fully propagated to Mermaid diagrams.
+  Fixed by amending the docs commit.
+
+## Stage: Final Retrospective (2026-05-27T21:46:00Z)
+
+### Session summary
+
+Completed all stages (plan, TDD, ship, retro) in a single session.
+Dissolved `RunHandle` into 6 Agent methods, converted `startAgent` to async/await, released as `pi-subagents-v10.2.0`.
+Test delta: 986 → 1005 (+19).
+
+### Observations
+
+#### What went well
+
+- The user's two redirecting questions during planning ("What's the change that makes this easier?"
+  and "Tell me more about RunHandle — is there something that should replace it?") transformed a mechanical "move the class" plan into a "dissolve the abstraction" plan.
+  The dissolve approach is architecturally superior and sets up #232 (resume unification) for free.
+- The lift-and-shift decomposition (introduce Agent methods alongside `RunHandle`, then swap and delete) produced 5 independently-green commits.
+  The riskiest commit (step 3: delete `RunHandle`, -96/+6 lines) was trivially safe because step 2 had already proven the replacement methods.
+
+#### What caused friction (agent side)
+
+- `premature-convergence` — The agent planned around the issue's proposed `Agent.createRunHandle()` factory without questioning whether `RunHandle` should exist as a separate class.
+  The user had to ask two redirecting questions to push the analysis deeper.
+  Impact: plan was rewritten before commit (no wasted implementation), but the user spent two turns guiding analysis the agent should have done proactively.
+- `missing-context` — Plan step 1 (narrow `Promise<string>` to `Promise<void>`) listed only `agent-manager.test.ts` for updates but missed 3 additional test files (`make-agent.test.ts`, `service-adapter.test.ts`, `get-result-tool.test.ts`) that construct `Promise<string>` values.
+  The testing skill says "grep for all test files" for type changes — this was not applied during planning.
+  Impact: caught by `pnpm run check` in the same step, no rework.
+
+#### What caused friction (user side)
+
+- No friction observed.
+  The user's questioning style (asking "what does it do?
+  who needs it?"
+  rather than prescribing the solution) was collaborative and effective.
+
+### Changes made
+
+1. `.pi/prompts/plan-issue.md` — added relocation-dissolution heuristic: when an issue proposes moving a class, list callers and fields touched to check if it should be dissolved into the owner instead.

package/docs/retro/0231-push-exec-registry-to-runner.md

@@ -0,0 +1,40 @@
+---
+issue: 231
+issue_title: "Push exec/registry relay deps to runner construction (Phase 15, Step 3)"
+---
+
+# Retro: #231 — Push exec/registry relay deps to runner construction
+
+## Stage: Planning (2026-05-27T21:53:10Z)
+
+### Session summary
+
+Produced a 6-step TDD plan to move `exec` and `registry` from `AgentManager` to `ConcreteAgentRunner` via a new `RunnerDeps` interface.
+The plan keeps `RunContext` (shrunk to 2 per-call fields) rather than dissolving it — #229 will likely dissolve it when `Agent.run()` calls the runner directly.
+
+### Observations
+
+- Confirmed `exec` and `registry` are pure relay deps on `AgentManager` — stored at construction, used only at lines 193–194 to forward into `runner.run()`.
+- Chose `RunnerDeps` bag over separate positional params on `ConcreteAgentRunner` and `runAgent()` — groups all three runner-owned deps (`io`, `exec`, `registry`) in one interface, and `runAgent()` stays at 5 parameters.
+- `AgentManagerOptions.registry` uses the concrete `AgentTypeRegistry` class; `RunContext.registry` uses the narrow `AgentConfigLookup` interface.
+  The new `RunnerDeps.registry` uses `AgentConfigLookup` (ISP).
+- Test churn is moderate (~20 `runAgent()` call sites change last param pattern) but mechanical — assertions stay identical.
+- Added a `createRunnerDeps()` test helper to `runner-io.ts` to reduce per-file boilerplate in runner tests.
+
+## Stage: Implementation — TDD (2026-05-27T22:05:32Z)
+
+### Session summary
+
+Implemented the 6-step plan in 4 commits (steps 3–5 merged).
+All 1005 tests pass; no test count change.
+Pre-completion reviewer returned PASS.
+
+### Observations
+
+- Plan steps 3, 4, and 5 could not be separate commits: removing `exec`/`registry` from `RunContext` (step 3) immediately caused TypeScript excess-property errors in `AgentManager` (step 4) and `index.ts` (step 5).
+  Merged all three into one commit.
+  The testing skill’s rule “when a TDD step changes an interface that has a single call site, the step must include updating that call site” applies.
+- Shrinking `RunContext` to all-optional fields made pre-existing `as never` casts in `test/helpers/manager-stubs.test.ts` unnecessary (eslint `no-unnecessary-type-assertion`).
+  Fixed as a lint cleanup in the doc commit.
+- The `sed`-based bulk replacement for `runAgent(..., io)` → `runAgent(..., { io, exec, registry: mockAgentLookup })` missed one multi-line call site (the `rejects.toThrow` test wrapping the call in `expect()`).
+  Caught immediately by the test run.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gotgenes/pi-subagents",
-  "version": "10.1.0",
+  "version": "10.2.1",
   "type": "module",
   "exports": {
     ".": "./src/service.ts"

package/src/index.ts

@@ -24,7 +24,7 @@ import { AgentTypeRegistry } from "#src/config/agent-types";
 import { loadCustomAgents } from "#src/config/custom-agents";
 import { SessionLifecycleHandler, ToolStartHandler } from "#src/handlers/index";
 import { AgentManager, type AgentManagerObserver } from "#src/lifecycle/agent-manager";
-import { ConcreteAgentRunner, type RunnerIO } from "#src/lifecycle/agent-runner";
+import { ConcreteAgentRunner, type RunnerDeps } from "#src/lifecycle/agent-runner";
 import { buildParentSnapshot } from "#src/lifecycle/parent-snapshot";
 import { GitWorktreeManager } from "#src/lifecycle/worktree";
 import { buildEventData, type NotificationDetails, NotificationManager } from "#src/observation/notification";
@@ -132,25 +132,27 @@ export default function (pi: ExtensionAPI) {
     },
   };
 
-  const runnerIO: RunnerIO = {
-    detectEnv,
-    getAgentDir,
-    createResourceLoader: (opts) => new DefaultResourceLoader(opts),
-    deriveSessionDir: deriveSubagentSessionDir,
-    createSessionManager: (cwd, dir) => SessionManager.create(cwd, dir),
-    createSettingsManager: (cwd, dir) => SdkSettingsManager.create(cwd, dir),
-    createSession: (opts) => createAgentSession(opts as any),
-    assemblerIO: {
-      preloadSkills,
-      buildAgentPrompt,
+  const runnerDeps: RunnerDeps = {
+    io: {
+      detectEnv,
+      getAgentDir,
+      createResourceLoader: (opts) => new DefaultResourceLoader(opts),
+      deriveSessionDir: deriveSubagentSessionDir,
+      createSessionManager: (cwd, dir) => SessionManager.create(cwd, dir),
+      createSettingsManager: (cwd, dir) => SdkSettingsManager.create(cwd, dir),
+      createSession: (opts) => createAgentSession(opts as any),
+      assemblerIO: {
+        preloadSkills,
+        buildAgentPrompt,
+      },
     },
+    exec: (cmd, args, opts) => pi.exec(cmd, args, opts),
+    registry,
   };
 
   const manager = new AgentManager({
-    runner: new ConcreteAgentRunner(runnerIO),
+    runner: new ConcreteAgentRunner(runnerDeps),
     worktrees: new GitWorktreeManager(process.cwd()),
-    exec: (cmd, args, opts) => pi.exec(cmd, args, opts),
-    registry,
     observer,
     getMaxConcurrent: () => settings.maxConcurrent,
     getRunConfig: () => settings,