@markjaquith/agency 2.30.1 → 2.32.0

package/src/commands/task.test.ts

@@ -61,10 +61,43 @@ describe("task creation input", () => {
 			"Description (optional): ",
 			"Parent epic: (none),delivery",
 			"Task type: single-phase,multi-phase",
-			"Writable repository: agency",
 		])
 	})
 
+	test("asks for a repository only when more than one is available", async () => {
+		await mkdir(join(root, "repos/web"), { recursive: true })
+		const prompts: string[] = []
+		const interaction: TaskInteraction = {
+			text: () => Effect.fail(new Error("unexpected text prompt")),
+			select: (prompt, choices) => {
+				prompts.push(`${prompt}: ${choices.join(",")}`)
+				return Effect.succeed(prompt === "Task type" ? "single-phase" : "web")
+			},
+		}
+
+		await runTestEffect(
+			task(
+				{
+					subcommand: "new",
+					args: ["multi-repo"],
+					ticketUrl: "",
+					description: "",
+					cwd: root,
+					silent: true,
+				},
+				interaction,
+			),
+		)
+
+		expect(prompts).toEqual([
+			"Task type: single-phase,multi-phase",
+			"Writable repository: agency,web",
+		])
+		expect(
+			await Bun.file(join(root, "tasks/multi-repo/TASK.md")).text(),
+		).toContain("repo: web")
+	})
+
 	test("keeps scripted creation non-interactive and permits no ticket URL", async () => {
 		const interaction: TaskInteraction = {
 			text: () => Effect.fail(new Error("unexpected text prompt")),

package/src/commands/task.ts

@@ -1,5 +1,4 @@
 import { Effect } from "effect"
-import { createInterface } from "node:readline/promises"
 import type { BaseCommandOptions } from "../utils/command"
 import { TaskService } from "../services/TaskService"
 import { EpicService } from "../services/EpicService"
@@ -51,17 +50,10 @@ const defaultInteraction = (
 ): TaskInteraction => ({
 	text: (prompt) =>
 		Effect.tryPromise({
-			try: async () => {
-				const input = createInterface({
-					input: process.stdin,
-					output: process.stderr,
-				})
-				try {
-					return await input.question(prompt)
-				} finally {
-					input.close()
-				}
-			},
+			try: async () =>
+				(
+					await (await import("../utils/interactive-loader")).loadInteractive()
+				).promptText(prompt),
 			catch: (cause) => new Error("Failed to read task input", { cause }),
 		}),
 	select: (prompt, choices) =>
@@ -157,14 +149,18 @@ export const task = (options: TaskOptions, interaction?: TaskInteraction) =>
 							),
 						)
 					}
-					const selected = yield* activeInteraction.select(
-						"Writable repository",
-						records.map((record) => record.alias),
-					)
-					if (!selected) {
-						return yield* Effect.fail(new Error("Task creation cancelled"))
+					if (records.length === 1) {
+						repo = records[0]!.alias
+					} else {
+						const selected = yield* activeInteraction.select(
+							"Writable repository",
+							records.map((record) => record.alias),
+						)
+						if (!selected) {
+							return yield* Effect.fail(new Error("Task creation cancelled"))
+						}
+						repo = selected
 					}
-					repo = selected
 				}
 
 				const record = yield* tasks.create(
@@ -410,7 +406,7 @@ Subcommands:
   create <id>           Create a task without prompting
   list                  List tasks
   show <id>             Show a task
-  status <id> <status>  Set open, done, or dropped
+  status <id> <status>  Set open, working, done, or dropped
   update <id>           Update task metadata
   rename <id> <new-id>  Rename a task and update graph references
   move <id>             Move a task with --epic or --no-epic

package/src/commands/work.test.ts

@@ -6,7 +6,6 @@ import { EpicService } from "../services/EpicService"
 import { TaskService } from "../services/TaskService"
 import { PhaseService } from "../services/PhaseService"
 import { WorktreeService } from "../services/WorktreeService"
-import { ClaimService } from "../services/ClaimService"
 import { ReadinessService } from "../services/ReadinessService"
 import { IntegrationService } from "../services/IntegrationService"
 import { captureErrors, captureLogs } from "../test-utils"
@@ -45,6 +44,8 @@ const multiPhaseWorkspace: ExecutionWorkspace = {
 	operations: [],
 }
 
+const taskDirectory = "/workbase/tasks/example"
+
 interface HarnessOptions {
 	readonly workspace?: ExecutionWorkspace
 	readonly materializeError?: Error
@@ -54,7 +55,9 @@ interface HarnessOptions {
 		string,
 		{
 			command: readonly [string, ...string[]]
+			autoCommand?: readonly [string, ...string[]]
 			resumeCommand?: readonly [string, ...string[]]
+			autoResumeCommand?: readonly [string, ...string[]]
 			environment?: Record<string, string>
 		}
 	>
@@ -66,7 +69,7 @@ interface HarnessOptions {
 	readonly registeredWorkbases?: readonly string[]
 	readonly existingDirectories?: readonly string[]
 	readonly guardError?: Error
-	readonly readyTargetIds?: readonly string[]
+	readonly workTargetIds?: readonly string[]
 	readonly opencodeIntegrationState?: "managed" | "customized"
 }
 
@@ -161,35 +164,11 @@ const createHarness = (options: HarnessOptions = {}) => {
 			return Effect.void
 		},
 	}
-	const claims = {
-		inspect: (taskId: string, phaseId?: string) =>
-			Effect.succeed({
-				target: {
-					kind: phaseId ? "phase" : "task",
-					taskId,
-					phaseId,
-					path: phaseId
-						? `/workbase/tasks/${taskId}/phases/${phaseId}/PHASE.md`
-						: `/workbase/tasks/${taskId}/TASK.md`,
-					label: phaseId ? `phase '${taskId}/${phaseId}'` : `task '${taskId}'`,
-				},
-				revision: "0".repeat(64),
-				data: {},
-			}),
-		claim: (input: { taskId: string; phaseId?: string }) => {
-			statusUpdates.push(
-				input.phaseId
-					? `phase:${input.taskId}:${input.phaseId}:working`
-					: `task:${input.taskId}:working`,
-			)
-			return Effect.succeed({ revision: "1".repeat(64) })
-		},
-	}
 	const readiness = {
-		getReadyWorkTargetIds: () =>
+		getWorkTargetIds: () =>
 			Effect.succeed(
 				new Set(
-					options.readyTargetIds ?? [
+					options.workTargetIds ?? [
 						...(options.epicRecords ?? []).map(
 							(record: any) => `epic:${record.id}`,
 						),
@@ -271,7 +250,6 @@ const createHarness = (options: HarnessOptions = {}) => {
 				Effect.provideService(EpicService, epics as never),
 				Effect.provideService(TaskService, tasks as never),
 				Effect.provideService(PhaseService, phases as never),
-				Effect.provideService(ClaimService, claims as never),
 				Effect.provideService(ReadinessService, readiness as never),
 				Effect.provideService(IntegrationService, integrations as never),
 			) as Effect.Effect<void, unknown, never>,
@@ -338,7 +316,7 @@ describe("work command", () => {
 		})
 	})
 
-	test("offers only graph-ready targets to the interactive chooser", async () => {
+	test("offers only launchable targets to the interactive chooser", async () => {
 		const harness = createHarness({
 			taskRecords: [
 				{
@@ -352,7 +330,7 @@ describe("work command", () => {
 					data: { status: "open" },
 				},
 			],
-			readyTargetIds: ["execution-unit:task/ready"],
+			workTargetIds: ["execution-unit:task/ready"],
 		})
 		let labels: readonly string[] = []
 		const pick: PickWorkTarget = (choices) => {
@@ -392,6 +370,7 @@ describe("work command", () => {
 			cwd: "/workbase/epics/delivery",
 			directory: ".",
 			opencode: true,
+			auto: true,
 		})
 
 		expect(harness.events).toEqual(["probe:opencode", "launch:opencode"])
@@ -435,7 +414,7 @@ describe("work command", () => {
 		})
 
 		expect(harness.shownTasks).toEqual(["delivery"])
-		expect(harness.launches[0]?.cwd).toBe(singlePhaseWorkspace.writablePath)
+		expect(harness.launches[0]?.cwd).toBe(taskDirectory)
 	})
 
 	test("treats a positional value as a task ID when it is not a directory", async () => {
@@ -448,7 +427,7 @@ describe("work command", () => {
 		})
 
 		expect(harness.shownTasks).toEqual(["delivery"])
-		expect(harness.launches[0]?.cwd).toBe(singlePhaseWorkspace.writablePath)
+		expect(harness.launches[0]?.cwd).toBe(taskDirectory)
 	})
 
 	test("launches a multi-phase task agent without materializing", async () => {
@@ -458,6 +437,7 @@ describe("work command", () => {
 			cwd: "/workbase/tasks/delivery",
 			directory: ".",
 			opencode: true,
+			auto: true,
 		})
 
 		expect(harness.events).toEqual(["probe:opencode", "launch:opencode"])
@@ -482,6 +462,7 @@ describe("work command", () => {
 			cwd: "/workbase/tasks/example/phases/implementation/code/agency/src",
 			directory: ".",
 			opencode: true,
+			auto: true,
 		})
 
 		expect(harness.events).toEqual([
@@ -496,7 +477,7 @@ describe("work command", () => {
 				"--prompt",
 				"Start the task. Read /workbase/tasks/example/TASK.md and /workbase/tasks/example/phases/implementation/PHASE.md.",
 			],
-			cwd: multiPhaseWorkspace.writablePath,
+			cwd: taskDirectory,
 		})
 		expect(harness.statusUpdates).toEqual([
 			"phase:example:implementation:working",
@@ -516,7 +497,7 @@ describe("work command", () => {
 		})
 
 		expect(harness.events[0]).toBe("materialize")
-		expect(harness.launches[0]?.cwd).toBe(singlePhaseWorkspace.writablePath)
+		expect(harness.launches[0]?.cwd).toBe(taskDirectory)
 		expect(harness.launchEnvironments[0]?.OPENCODE_CONFIG).toBe(
 			"/workbase/.opencode/opencode.jsonc",
 		)
@@ -552,7 +533,7 @@ describe("work command", () => {
 			"probe:opencode",
 			"launch:opencode",
 		])
-		expect(harness.launches[0]?.cwd).toBe(multiPhaseWorkspace.writablePath)
+		expect(harness.launches[0]?.cwd).toBe(taskDirectory)
 	})
 
 	test("requires an explicit target when input is disabled", async () => {
@@ -678,7 +659,7 @@ describe("work command", () => {
 		expect(harness.events).toEqual([])
 	})
 
-	test("launches OpenCode in the writable checkout with explicit context", async () => {
+	test("launches OpenCode in the task directory with explicit context", async () => {
 		const harness = createHarness()
 
 		await harness.run({ taskId: "example", opencode: true })
@@ -691,14 +672,11 @@ describe("work command", () => {
 		expect(harness.launches).toEqual([
 			{
 				cli: "opencode",
-				args: [
-					"opencode",
-					"--prompt",
-					"Start the task. Read /workbase/tasks/example/TASK.md.",
-				],
-				cwd: singlePhaseWorkspace.writablePath,
+				args: ["opencode"],
+				cwd: taskDirectory,
 			},
 		])
+		expect(harness.launchEnvironments[0]?.AGENCY_PROMPT).toBe("")
 		expect(harness.statusUpdates).toEqual(["task:example:working"])
 		expect(harness.launchEnvironments[0]?.OPENCODE_CONFIG).toBe(
 			"/workbase/.opencode/opencode.jsonc",
@@ -709,6 +687,21 @@ describe("work command", () => {
 		])
 	})
 
+	test("sends the generated prompt only with --auto", async () => {
+		const harness = createHarness()
+
+		await harness.run({ taskId: "example", opencode: true, auto: true })
+
+		expect(harness.launches[0]?.args).toEqual([
+			"opencode",
+			"--prompt",
+			"Start the task. Read /workbase/tasks/example/TASK.md.",
+		])
+		expect(harness.launchEnvironments[0]?.AGENCY_PROMPT).toBe(
+			"Start the task. Read /workbase/tasks/example/TASK.md.",
+		)
+	})
+
 	test("resumes OpenCode deterministically when a session identity exists", async () => {
 		const harness = createHarness({ workspace: multiPhaseWorkspace })
 		process.env.AGENCY_SESSION_ID = "existing-session"
@@ -717,6 +710,7 @@ describe("work command", () => {
 				taskId: "example",
 				phaseId: "implementation",
 				opencode: true,
+				auto: true,
 			})
 		} finally {
 			delete process.env.AGENCY_SESSION_ID
@@ -730,16 +724,17 @@ describe("work command", () => {
 				"--prompt",
 				"Start the task. Read /workbase/tasks/example/TASK.md and /workbase/tasks/example/phases/implementation/PHASE.md.",
 			],
-			cwd: multiPhaseWorkspace.writablePath,
+			cwd: taskDirectory,
 		})
 	})
 
-	test("expands a named runner with shared context and claim identity", async () => {
+	test("expands a named runner with shared context", async () => {
 		const harness = createHarness({
 			available: { codex: true },
 			runners: {
 				custom: {
-					command: ["codex", "--task", "{task}", "{prompt}"],
+					command: ["codex"],
+					autoCommand: ["codex", "--task", "{task}", "{prompt}"],
 					environment: {
 						CUSTOM_TARGET: "{target}",
 						AGENCY_TARGET: "cannot-override",
@@ -748,7 +743,7 @@ describe("work command", () => {
 			},
 		})
 
-		await harness.run({ taskId: "example", runner: "custom" })
+		await harness.run({ taskId: "example", runner: "custom", auto: true })
 
 		expect(harness.probes).toEqual(["codex"])
 		expect(harness.launches[0]).toEqual({
@@ -759,7 +754,7 @@ describe("work command", () => {
 				"example",
 				"Start the task. Read /workbase/tasks/example/TASK.md.",
 			],
-			cwd: singlePhaseWorkspace.writablePath,
+			cwd: taskDirectory,
 		})
 		expect(harness.launchEnvironments[0]).toMatchObject({
 			AGENCY_RUNNER: "custom",
@@ -768,7 +763,7 @@ describe("work command", () => {
 			AGENCY_TARGET: "execution-unit:task/example",
 			AGENCY_TASK_ID: "example",
 			AGENCY_PHASE_ID: "",
-			AGENCY_CLAIM_REVISION: "1".repeat(64),
+			AGENCY_CLAIM_REVISION: "",
 			CUSTOM_TARGET: "execution-unit:task/example",
 		})
 	})
@@ -778,7 +773,8 @@ describe("work command", () => {
 			available: { agent: true },
 			runners: {
 				custom: {
-					command: ["agent", "{prompt}"],
+					command: ["agent"],
+					autoCommand: ["agent", "{prompt}"],
 					environment: {
 						VISIBLE: "{task}",
 						API_TOKEN: "do-not-print",
@@ -797,11 +793,10 @@ describe("work command", () => {
 		const printed = JSON.parse(output.join("\n"))
 
 		expect(harness.launches).toEqual([])
-		expect(printed.cwd).toBe(singlePhaseWorkspace.writablePath)
-		expect(printed.argv).toEqual([
-			"agent",
-			"Start the task. Read /workbase/tasks/example/TASK.md.",
-		])
+		expect(harness.statusUpdates).toEqual([])
+		expect(printed.cwd).toBe(taskDirectory)
+		expect(printed.argv).toEqual(["agent"])
+		expect(printed.environment.AGENCY_PROMPT).toBe("")
 		expect(printed.environment.VISIBLE).toBe("example")
 		expect(printed.environment.API_TOKEN).toBeUndefined()
 	})
@@ -816,16 +811,21 @@ describe("work command", () => {
 		expect(printed.environment.OPENCODE_CONFIG).toBe(
 			"/workbase/.opencode/opencode.jsonc",
 		)
+		const edit = {
+			"*": "deny",
+			"tasks/example/code/agency/**": "allow",
+			"code/agency/**": "allow",
+		}
 		expect(JSON.parse(printed.environment.OPENCODE_CONFIG_CONTENT)).toEqual({
 			permission: {
 				external_directory: { "/workbase/**": "allow" },
-				edit: { "../**": "deny" },
+				edit,
 			},
 			agent: {
-				build: { permission: { edit: { "../**": "deny" } } },
-				plan: { permission: { edit: { "../**": "deny" } } },
-				general: { permission: { edit: { "../**": "deny" } } },
-				explore: { permission: { edit: { "../**": "deny" } } },
+				build: { permission: { edit } },
+				plan: { permission: { edit } },
+				general: { permission: { edit } },
+				explore: { permission: { edit } },
 			},
 		})
 	})
@@ -848,8 +848,8 @@ describe("work command", () => {
 		expect(harness.probes).toEqual(["opencode", "claude"])
 		expect(harness.launches[0]).toEqual({
 			cli: "claude",
-			args: ["claude", "Start the task. Read /workbase/tasks/example/TASK.md."],
-			cwd: singlePhaseWorkspace.writablePath,
+			args: ["claude"],
+			cwd: taskDirectory,
 		})
 		expect(harness.launchEnvironments[0]?.OPENCODE_CONFIG).toBeUndefined()
 	})
@@ -873,8 +873,8 @@ describe("work command", () => {
 		expect(harness.probes).toEqual(["claude"])
 		expect(harness.launches[0]).toEqual({
 			cli: "claude",
-			args: ["claude", "Start the task. Read /workbase/tasks/example/TASK.md."],
-			cwd: singlePhaseWorkspace.writablePath,
+			args: ["claude"],
+			cwd: taskDirectory,
 		})
 	})
 
@@ -911,7 +911,7 @@ describe("work command", () => {
 			verboseHarness.run({ taskId: "example", verbose: true }),
 		)
 		expect(verboseLogs).toEqual([
-			"Launching command: opencode --prompt 'Start the task. Read /workbase/tasks/example/TASK.md.' (cwd: /workbase/tasks/example/code/agency)",
+			"Launching command: opencode (cwd: /workbase/tasks/example)",
 		])
 		expect(verboseHarness.materializeOptions[0]?.verbose).toBe(true)
 

package/src/commands/work.ts

@@ -7,7 +7,6 @@ import { WorkbaseService } from "../services/WorkbaseService"
 import { EpicService } from "../services/EpicService"
 import { TaskService } from "../services/TaskService"
 import { PhaseService } from "../services/PhaseService"
-import { ClaimService } from "../services/ClaimService"
 import { ReadinessService } from "../services/ReadinessService"
 import { IntegrationService } from "../services/IntegrationService"
 import { createLoggers } from "../utils/effect"
@@ -39,6 +38,7 @@ interface WorkOptions extends BaseCommandOptions {
 	readonly claude?: boolean
 	readonly runner?: string
 	readonly printCommand?: boolean
+	readonly auto?: boolean
 	readonly force?: boolean
 }
 
@@ -105,7 +105,6 @@ export const work = (
 		const epics = yield* EpicService
 		const tasks = yield* TaskService
 		const phases = yield* PhaseService
-		const claims = yield* ClaimService
 		const readiness = yield* ReadinessService
 		const integrations = yield* IntegrationService
 		const { log, verboseLog } = createLoggers(options)
@@ -207,13 +206,13 @@ export const work = (
 				taskRecords,
 				phaseRecords,
 			)
-			const readyTargetIds = options.force
+			const workTargetIds = options.force
 				? null
-				: yield* readiness.getReadyWorkTargetIds(root)
+				: yield* readiness.getWorkTargetIds(root)
 			const choices = options.force
 				? allChoices
 				: allChoices.filter((choice) =>
-						readyTargetIds!.has(targetNodeId(choice.target)),
+						workTargetIds!.has(targetNodeId(choice.target)),
 					)
 			if (choices.length === 0) {
 				return yield* Effect.fail(
@@ -227,6 +226,7 @@ export const work = (
 
 		let prompt: string
 		let launchPath: string
+		let writablePath: string | undefined
 		if (target.kind === "epic") {
 			prompt = `Work on the epic. Read ${target.path}.`
 			launchPath = dirname(target.path)
@@ -250,7 +250,8 @@ export const work = (
 			prompt = workspace.phasePath
 				? `Start the task. Read ${workspace.taskPath} and ${workspace.phasePath}.`
 				: `Start the task. Read ${workspace.taskPath}.`
-			launchPath = workspace.writablePath
+			launchPath = dirname(workspace.taskPath)
+			writablePath = workspace.writablePath
 		}
 
 		const explicitlyRequested = Boolean(
@@ -267,22 +268,22 @@ export const work = (
 		const sessionId =
 			process.env.AGENCY_SESSION_ID ?? `${process.pid}-${Date.now()}`
 		const resume = process.env.AGENCY_SESSION_ID !== undefined
-		let claimRevision = ""
-		let variables = {
-			prompt,
+		const variables = {
+			prompt: options.auto ? prompt : "",
 			workbase: root,
 			target: targetNodeId(target),
 			task: target.kind === "epic" ? "" : target.taskId,
 			phase: target.kind === "phase" ? target.phaseId : "",
 			claimant,
 			sessionId,
-			claimRevision,
+			claimRevision: "",
 		}
 		let resolved = resolveRunnerCommand(
 			runner,
 			config.runners,
 			variables,
 			resume,
+			options.auto,
 		)
 		let cli = resolved.argv[0]!
 		let available = yield* fs.runCommand(["which", cli], {
@@ -294,35 +295,26 @@ export const work = (
 			runner === "opencode"
 		) {
 			runner = "claude"
-			resolved = resolveRunnerCommand(runner, config.runners, variables, resume)
+			resolved = resolveRunnerCommand(
+				runner,
+				config.runners,
+				variables,
+				resume,
+				options.auto,
+			)
 			cli = resolved.argv[0]!
 			available = yield* fs.runCommand(["which", cli], { captureOutput: true })
 		}
 		if (available.exitCode !== 0) {
 			return yield* Effect.fail(new Error(`${cli} CLI tool not found`))
 		}
-		if (
-			target.kind === "phase" ||
-			(target.kind === "task" && !target.multiPhase)
-		) {
-			const phaseId = target.kind === "phase" ? target.phaseId : undefined
-			const current = yield* claims.inspect(target.taskId, phaseId, root)
-			const acquired = yield* claims.claim(
-				{
-					taskId: target.taskId,
-					...(phaseId ? { phaseId } : {}),
-					claimant,
-					runner,
-					sessionId,
-					revision: current.revision,
-				},
-				root,
-			)
-			claimRevision = acquired.revision
-		}
-
-		variables = { ...variables, claimRevision }
-		resolved = resolveRunnerCommand(runner, config.runners, variables, resume)
+		resolved = resolveRunnerCommand(
+			runner,
+			config.runners,
+			variables,
+			resume,
+			options.auto,
+		)
 		cli = resolved.argv[0]!
 		const environment = {
 			...resolved.environment,
@@ -333,7 +325,17 @@ export const work = (
 			const execution =
 				target.kind === "phase" ||
 				(target.kind === "task" && !target.multiPhase)
-			const edit = { [execution ? "../**" : "*"]: "deny" as const }
+			const edit = execution
+				? {
+						"*": "deny" as const,
+						...Object.fromEntries(
+							[root, launchPath].map((base) => [
+								join(relative(base, writablePath!), "**").split(sep).join("/"),
+								"allow" as const,
+							]),
+						),
+					}
+				: { "*": "deny" as const }
 			environment.OPENCODE_CONFIG_CONTENT = JSON.stringify({
 				permission: {
 					external_directory: { [join(root, "**")]: "allow" },
@@ -361,6 +363,11 @@ export const work = (
 			)
 			return
 		}
+		if (target.kind === "phase") {
+			yield* phases.setStatus(target.taskId, target.phaseId, "working", root)
+		} else if (target.kind === "task" && !target.multiPhase) {
+			yield* tasks.setStatus(target.taskId, "working", root)
+		}
 		for (const [key, value] of Object.entries(environment)) {
 			process.env[key] = value
 		}
@@ -438,7 +445,7 @@ export const workPrepare = (options: WorkOptions = {}) =>
 	})
 
 export const help = `
-Usage: agency work [<directory-or-task-id> | --epic <epic-id>] [--runner <name>]
+Usage: agency work [<directory-or-task-id> | --epic <epic-id>] [--runner <name>] [--auto]
        agency work prepare [target] [--dry-run] [--json]
 
 Launch an agent for an epic, task, or phase. With no directory, select one
@@ -458,6 +465,7 @@ Options:
   --workbase <target>  Select a workbase by ID, name, or path
   --cwd <path>         Resolve context from a specific directory
   --runner <name>      Select a configured runner or built-in preset
+  --auto               Send the generated context prompt to the runner
   --print-command      Print cwd, argv, and non-secret environment without launch
   --opencode           Require the OpenCode preset
   --claude             Require the Claude Code preset

package/src/opentui.d.ts

@@ -0,0 +1 @@
+declare module "@opentui/solid/preload"

package/src/services/DoctorService.ts

@@ -170,6 +170,17 @@ export class DoctorService extends Effect.Service<DoctorService>()(
 									`Configured runner '${name}'`,
 								] as const,
 						),
+						...Object.entries(config.runners ?? {}).flatMap(([name, runner]) =>
+							runner.autoCommand
+								? [
+										[
+											`integration.runner.${name}.auto`,
+											runner.autoCommand,
+											`Configured runner '${name}' auto`,
+										] as const,
+									]
+								: [],
+						),
 						...Object.entries(config.runners ?? {}).flatMap(([name, runner]) =>
 							runner.resumeCommand
 								? [
@@ -181,6 +192,17 @@ export class DoctorService extends Effect.Service<DoctorService>()(
 									]
 								: [],
 						),
+						...Object.entries(config.runners ?? {}).flatMap(([name, runner]) =>
+							runner.autoResumeCommand
+								? [
+										[
+											`integration.runner.${name}.auto-resume`,
+											runner.autoResumeCommand,
+											`Configured runner '${name}' auto resume`,
+										] as const,
+									]
+								: [],
+						),
 						...(config.delivery
 							? [
 									[

package/src/services/EpicService.test.ts

@@ -34,6 +34,9 @@ describe("EpicService", () => {
 
 		expect(created.content).toContain("ticketUrl:")
 		expect(created.content).toContain("tasks: []")
+		expect(created.content).toContain(
+			"# Workspace Orchestration\n\n## Outcome\n\nDescribe the epic outcome.\n\n## Plan\n\nDescribe the current approach.\n\n## Important Decisions\n\nRecord consequential decisions and their rationale.",
+		)
 
 		const records = await runTestEffect(
 			EpicService.pipe(Effect.flatMap((service) => service.list(root))),