@os-eco/overstory-cli 0.7.0 → 0.7.3

package/src/commands/log.ts

@@ -176,6 +176,23 @@ async function resolveTranscriptPath(
 	logsBase: string,
 	agentName: string,
 ): Promise<string | null> {
+	// Check SessionStore for a runtime-provided transcript path
+	try {
+		const { store } = openSessionStore(join(projectRoot, ".overstory"));
+		try {
+			const session = store.getByName(agentName);
+			if (session?.transcriptPath) {
+				if (await Bun.file(session.transcriptPath).exists()) {
+					return session.transcriptPath;
+				}
+			}
+		} finally {
+			store.close();
+		}
+	} catch {
+		// Non-fatal: fall through to legacy resolution
+	}
+
 	// Check cached path first
 	const cachePath = join(logsBase, agentName, ".transcript-path");
 	const cacheFile = Bun.file(cachePath);
@@ -194,6 +211,17 @@ async function resolveTranscriptPath(
 	const directPath = join(claudeProjectsDir, projectKey, `${sessionId}.jsonl`);
 	if (await Bun.file(directPath).exists()) {
 		await Bun.write(cachePath, directPath);
+		// Save discovered path to SessionStore for future lookups
+		try {
+			const { store: writeStore } = openSessionStore(join(projectRoot, ".overstory"));
+			try {
+				writeStore.updateTranscriptPath(agentName, directPath);
+			} finally {
+				writeStore.close();
+			}
+		} catch {
+			// Non-fatal: cache write failure should not break transcript resolution
+		}
 		return directPath;
 	}
 
@@ -205,6 +233,17 @@ async function resolveTranscriptPath(
 			const candidate = join(claudeProjectsDir, project, `${sessionId}.jsonl`);
 			if (await Bun.file(candidate).exists()) {
 				await Bun.write(cachePath, candidate);
+				// Save discovered path to SessionStore for future lookups
+				try {
+					const { store: writeStore } = openSessionStore(join(projectRoot, ".overstory"));
+					try {
+						writeStore.updateTranscriptPath(agentName, candidate);
+					} finally {
+						writeStore.close();
+					}
+				} catch {
+					// Non-fatal: cache write failure should not break transcript resolution
+				}
 				return candidate;
 			}
 		}
@@ -331,6 +370,76 @@ export async function autoRecordExpertise(params: {
 	return recordedDomains;
 }
 
+interface AppliedRecordsData {
+	taskId: string | null;
+	agentName: string;
+	capability: string;
+	records: Array<{ id: string; domain: string }>;
+}
+
+/**
+ * Append outcome entries to the mulch records that were applied when this agent was spawned.
+ *
+ * At spawn time, sling.ts writes .overstory/agents/{name}/applied-records.json listing
+ * the mx-* IDs from the prime output. At session-end, this function reads that file,
+ * appends a "success" outcome to each record, and deletes the file.
+ *
+ * @returns Number of records successfully updated.
+ */
+export async function appendOutcomeToAppliedRecords(params: {
+	mulchClient: MulchClient;
+	agentName: string;
+	capability: string;
+	taskId: string | null;
+	projectRoot: string;
+}): Promise<number> {
+	const appliedRecordsPath = join(
+		params.projectRoot,
+		".overstory",
+		"agents",
+		params.agentName,
+		"applied-records.json",
+	);
+	const appliedFile = Bun.file(appliedRecordsPath);
+	if (!(await appliedFile.exists())) return 0;
+
+	let data: AppliedRecordsData;
+	try {
+		data = JSON.parse(await appliedFile.text()) as AppliedRecordsData;
+	} catch {
+		return 0;
+	}
+
+	const { records } = data;
+	if (!records || records.length === 0) return 0;
+
+	const taskSuffix = params.taskId ? ` for task ${params.taskId}` : "";
+	const outcome = {
+		status: "success" as const,
+		agent: params.agentName,
+		notes: `Applied by ${params.capability} agent ${params.agentName}${taskSuffix}. Session completed.`,
+	};
+
+	let appended = 0;
+	for (const { id, domain } of records) {
+		try {
+			await params.mulchClient.appendOutcome(domain, id, outcome);
+			appended++;
+		} catch {
+			// Non-fatal per record
+		}
+	}
+
+	try {
+		const { unlink } = await import("node:fs/promises");
+		await unlink(appliedRecordsPath);
+	} catch {
+		// Non-fatal: file may already be gone
+	}
+
+	return appended;
+}
+
 /**
  * Core implementation for the log command.
  */
@@ -388,29 +497,28 @@ async function runLog(opts: {
 			logger.toolStart(toolName, toolInput ?? {});
 			updateLastActivity(config.project.root, opts.agent);
 
-			// When --stdin is used, also write to EventStore for structured observability
-			if (opts.stdin) {
-				try {
-					const eventsDbPath = join(config.project.root, ".overstory", "events.db");
-					const eventStore = createEventStore(eventsDbPath);
-					const filtered = toolInput
-						? filterToolArgs(toolName, toolInput)
-						: { args: {}, summary: toolName };
-					eventStore.insert({
-						runId: null,
-						agentName: opts.agent,
-						sessionId,
-						eventType: "tool_start",
-						toolName,
-						toolArgs: JSON.stringify(filtered.args),
-						toolDurationMs: null,
-						level: "info",
-						data: JSON.stringify({ summary: filtered.summary }),
-					});
-					eventStore.close();
-				} catch {
-					// Non-fatal: EventStore write should not break hook execution
-				}
+			// Always write to EventStore for structured observability
+			// (works for both Claude Code --stdin and Pi runtime --tool-name agents)
+			try {
+				const eventsDbPath = join(config.project.root, ".overstory", "events.db");
+				const eventStore = createEventStore(eventsDbPath);
+				const filtered = toolInput
+					? filterToolArgs(toolName, toolInput)
+					: { args: {}, summary: toolName };
+				eventStore.insert({
+					runId: null,
+					agentName: opts.agent,
+					sessionId,
+					eventType: "tool_start",
+					toolName,
+					toolArgs: JSON.stringify(filtered.args),
+					toolDurationMs: null,
+					level: "info",
+					data: JSON.stringify({ summary: filtered.summary }),
+				});
+				eventStore.close();
+			} catch {
+				// Non-fatal: EventStore write should not break hook execution
 			}
 			break;
 		}
@@ -419,79 +527,78 @@ async function runLog(opts: {
 			logger.toolEnd(toolName, 0);
 			updateLastActivity(config.project.root, opts.agent);
 
-			// When --stdin is used, write to EventStore and correlate with tool-start
-			if (opts.stdin) {
-				try {
-					const eventsDbPath = join(config.project.root, ".overstory", "events.db");
-					const eventStore = createEventStore(eventsDbPath);
-					const filtered = toolInput
-						? filterToolArgs(toolName, toolInput)
-						: { args: {}, summary: toolName };
-					eventStore.insert({
-						runId: null,
-						agentName: opts.agent,
-						sessionId,
-						eventType: "tool_end",
-						toolName,
-						toolArgs: JSON.stringify(filtered.args),
-						toolDurationMs: null,
-						level: "info",
-						data: JSON.stringify({ summary: filtered.summary }),
-					});
-					const correlation = eventStore.correlateToolEnd(opts.agent, toolName);
-					if (correlation) {
-						logger.toolEnd(toolName, correlation.durationMs);
-					}
-					eventStore.close();
-				} catch {
-					// Non-fatal: EventStore write should not break hook execution
+			// Always write to EventStore for structured observability
+			// (works for both Claude Code --stdin and Pi runtime --tool-name agents)
+			try {
+				const eventsDbPath = join(config.project.root, ".overstory", "events.db");
+				const eventStore = createEventStore(eventsDbPath);
+				const filtered = toolInput
+					? filterToolArgs(toolName, toolInput)
+					: { args: {}, summary: toolName };
+				eventStore.insert({
+					runId: null,
+					agentName: opts.agent,
+					sessionId,
+					eventType: "tool_end",
+					toolName,
+					toolArgs: JSON.stringify(filtered.args),
+					toolDurationMs: null,
+					level: "info",
+					data: JSON.stringify({ summary: filtered.summary }),
+				});
+				const correlation = eventStore.correlateToolEnd(opts.agent, toolName);
+				if (correlation) {
+					logger.toolEnd(toolName, correlation.durationMs);
 				}
+				eventStore.close();
+			} catch {
+				// Non-fatal: EventStore write should not break hook execution
+			}
 
-				// Throttled token snapshot recording
-				if (sessionId) {
-					try {
-						// Throttle check
-						const snapshotMarkerPath = join(logsBase, opts.agent, ".last-snapshot");
-						const SNAPSHOT_INTERVAL_MS = 30_000;
-						const snapshotMarkerFile = Bun.file(snapshotMarkerPath);
-						let shouldSnapshot = true;
-
-						if (await snapshotMarkerFile.exists()) {
-							const lastTs = Number.parseInt(await snapshotMarkerFile.text(), 10);
-							if (!Number.isNaN(lastTs) && Date.now() - lastTs < SNAPSHOT_INTERVAL_MS) {
-								shouldSnapshot = false;
-							}
+			// Throttled token snapshot recording (requires sessionId from --stdin; skipped for Pi agents)
+			if (sessionId) {
+				try {
+					// Throttle check
+					const snapshotMarkerPath = join(logsBase, opts.agent, ".last-snapshot");
+					const SNAPSHOT_INTERVAL_MS = 30_000;
+					const snapshotMarkerFile = Bun.file(snapshotMarkerPath);
+					let shouldSnapshot = true;
+
+					if (await snapshotMarkerFile.exists()) {
+						const lastTs = Number.parseInt(await snapshotMarkerFile.text(), 10);
+						if (!Number.isNaN(lastTs) && Date.now() - lastTs < SNAPSHOT_INTERVAL_MS) {
+							shouldSnapshot = false;
 						}
+					}
 
-						if (shouldSnapshot) {
-							const resolvedTranscriptPath = await resolveTranscriptPath(
-								config.project.root,
-								sessionId,
-								logsBase,
-								opts.agent,
-							);
-							if (resolvedTranscriptPath) {
-								const usage = await parseTranscriptUsage(resolvedTranscriptPath);
-								const cost = estimateCost(usage);
-								const metricsDbPath = join(config.project.root, ".overstory", "metrics.db");
-								const metricsStore = createMetricsStore(metricsDbPath);
-								metricsStore.recordSnapshot({
-									agentName: opts.agent,
-									inputTokens: usage.inputTokens,
-									outputTokens: usage.outputTokens,
-									cacheReadTokens: usage.cacheReadTokens,
-									cacheCreationTokens: usage.cacheCreationTokens,
-									estimatedCostUsd: cost,
-									modelUsed: usage.modelUsed,
-									createdAt: new Date().toISOString(),
-								});
-								metricsStore.close();
-								await Bun.write(snapshotMarkerPath, String(Date.now()));
-							}
+					if (shouldSnapshot) {
+						const resolvedTranscriptPath = await resolveTranscriptPath(
+							config.project.root,
+							sessionId,
+							logsBase,
+							opts.agent,
+						);
+						if (resolvedTranscriptPath) {
+							const usage = await parseTranscriptUsage(resolvedTranscriptPath);
+							const cost = estimateCost(usage);
+							const metricsDbPath = join(config.project.root, ".overstory", "metrics.db");
+							const metricsStore = createMetricsStore(metricsDbPath);
+							metricsStore.recordSnapshot({
+								agentName: opts.agent,
+								inputTokens: usage.inputTokens,
+								outputTokens: usage.outputTokens,
+								cacheReadTokens: usage.cacheReadTokens,
+								cacheCreationTokens: usage.cacheCreationTokens,
+								estimatedCostUsd: cost,
+								modelUsed: usage.modelUsed,
+								createdAt: new Date().toISOString(),
+							});
+							metricsStore.close();
+							await Bun.write(snapshotMarkerPath, String(Date.now()));
 						}
-					} catch {
-						// Non-fatal: snapshot recording should not break tool-end handling
 					}
+				} catch {
+					// Non-fatal: snapshot recording should not break tool-end handling
 				}
 			}
 			break;
@@ -642,29 +749,44 @@ async function runLog(opts: {
 							// Non-fatal: mulch learn/record should not break session-end handling
 						}
 					}
-				}
 
-				// Write session-end event to EventStore when --stdin is used
-				if (opts.stdin) {
-					try {
-						const eventsDbPath = join(config.project.root, ".overstory", "events.db");
-						const eventStore = createEventStore(eventsDbPath);
-						eventStore.insert({
-							runId: null,
-							agentName: opts.agent,
-							sessionId,
-							eventType: "session_end",
-							toolName: null,
-							toolArgs: null,
-							toolDurationMs: null,
-							level: "info",
-							data: transcriptPath ? JSON.stringify({ transcriptPath }) : null,
-						});
-						eventStore.close();
-					} catch {
-						// Non-fatal: EventStore write should not break session-end
+					// Append outcomes to applied mulch records (outcome feedback loop).
+					// Reads applied-records.json written by sling.ts at spawn time.
+					if (!PERSISTENT_CAPABILITIES.has(agentSession.capability)) {
+						try {
+							const mulchClient = createMulchClient(config.project.root);
+							await appendOutcomeToAppliedRecords({
+								mulchClient,
+								agentName: opts.agent,
+								capability: agentSession.capability,
+								taskId,
+								projectRoot: config.project.root,
+							});
+						} catch {
+							// Non-fatal
+						}
 					}
 				}
+
+				// Always write session-end event to EventStore (not just when --stdin is used)
+				try {
+					const eventsDbPath = join(config.project.root, ".overstory", "events.db");
+					const eventStore = createEventStore(eventsDbPath);
+					eventStore.insert({
+						runId: null,
+						agentName: opts.agent,
+						sessionId,
+						eventType: "session_end",
+						toolName: null,
+						toolArgs: null,
+						toolDurationMs: null,
+						level: "info",
+						data: transcriptPath ? JSON.stringify({ transcriptPath }) : null,
+					});
+					eventStore.close();
+				} catch {
+					// Non-fatal: EventStore write should not break session-end
+				}
 			}
 			// Clear the current session marker
 			{

package/src/commands/logs.test.ts

@@ -1,8 +1,9 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { mkdir, rm, writeFile } from "node:fs/promises";
+import { mkdir, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { ValidationError } from "../errors.ts";
+import { cleanupTempDir } from "../test-helpers.ts";
 import type { LogEvent } from "../types.ts";
 import { logsCommand } from "./logs.ts";
 
@@ -51,7 +52,7 @@ describe("logsCommand", () => {
 
 		// Clean up temp directory
 		try {
-			await rm(tmpDir, { recursive: true, force: true });
+			await cleanupTempDir(tmpDir);
 		} catch {
 			// Ignore cleanup errors
 		}

package/src/commands/mail.test.ts

@@ -6,13 +6,14 @@
  */
 
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { mkdir, mkdtemp, readdir, rm } from "node:fs/promises";
+import { mkdir, mkdtemp, readdir } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { createEventStore } from "../events/store.ts";
 import { stripAnsi } from "../logging/color.ts";
 import { createMailClient } from "../mail/client.ts";
 import { createMailStore } from "../mail/store.ts";
+import { cleanupTempDir } from "../test-helpers.ts";
 import type { StoredEvent } from "../types.ts";
 import { AUTO_NUDGE_TYPES, isDispatchNudge, mailCommand, shouldAutoNudge } from "./mail.ts";
 
@@ -70,7 +71,7 @@ describe("mailCommand", () => {
 		process.stdout.write = origWrite;
 		process.stderr.write = origStderrWrite;
 		process.chdir(origCwd);
-		await rm(tempDir, { recursive: true, force: true });
+		await cleanupTempDir(tempDir);
 	});
 
 	describe("list", () => {
@@ -773,6 +774,7 @@ describe("mailCommand", () => {
 					lastActivity: new Date().toISOString(),
 					escalationLevel: 0,
 					stalledSince: null,
+					transcriptPath: null,
 				},
 				{
 					id: "session-builder-1",
@@ -791,6 +793,7 @@ describe("mailCommand", () => {
 					lastActivity: new Date().toISOString(),
 					escalationLevel: 0,
 					stalledSince: null,
+					transcriptPath: null,
 				},
 				{
 					id: "session-builder-2",
@@ -809,6 +812,7 @@ describe("mailCommand", () => {
 					lastActivity: new Date().toISOString(),
 					escalationLevel: 0,
 					stalledSince: null,
+					transcriptPath: null,
 				},
 				{
 					id: "session-scout-1",
@@ -827,6 +831,7 @@ describe("mailCommand", () => {
 					lastActivity: new Date().toISOString(),
 					escalationLevel: 0,
 					stalledSince: null,
+					transcriptPath: null,
 				},
 			];
 
@@ -1147,6 +1152,7 @@ describe("mailCommand", () => {
 					lastActivity: new Date().toISOString(),
 					escalationLevel: 0,
 					stalledSince: null,
+					transcriptPath: null,
 				});
 			}
 

package/src/commands/metrics.test.ts

@@ -1,8 +1,9 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { mkdtemp, rm } from "node:fs/promises";
+import { mkdtemp } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { createMetricsStore } from "../metrics/store.ts";
+import { cleanupTempDir } from "../test-helpers.ts";
 import type { SessionMetrics } from "../types.ts";
 import { metricsCommand } from "./metrics.ts";
 
@@ -44,7 +45,7 @@ describe("metricsCommand", () => {
 	afterEach(async () => {
 		process.stdout.write = originalWrite;
 		process.chdir(originalCwd);
-		await rm(tempDir, { recursive: true, force: true });
+		await cleanupTempDir(tempDir);
 	});
 
 	function output(): string {
@@ -366,7 +367,7 @@ describe("formatDuration helper", () => {
 	afterEach(async () => {
 		process.stdout.write = originalWrite;
 		process.chdir(originalCwd);
-		await rm(tempDir, { recursive: true, force: true });
+		await cleanupTempDir(tempDir);
 	});
 
 	function output(): string {

package/src/commands/monitor.ts

@@ -16,7 +16,6 @@
 import { mkdir } from "node:fs/promises";
 import { join } from "node:path";
 import { Command } from "commander";
-import { deployHooks } from "../agents/hooks-deployer.ts";
 import { createIdentity, loadIdentity } from "../agents/identity.ts";
 import { createManifestLoader, resolveModel } from "../agents/manifest.ts";
 import { loadConfig } from "../config.ts";
@@ -111,8 +110,21 @@ async function startMonitor(opts: { json: boolean; attach: boolean }): Promise<v
 			store.updateState(MONITOR_NAME, "completed");
 		}
 
+		// Resolve model and runtime early (needed for deployConfig and spawn)
+		const manifestLoader = createManifestLoader(
+			join(projectRoot, config.agents.manifestPath),
+			join(projectRoot, config.agents.baseDir),
+		);
+		const manifest = await manifestLoader.load();
+		const resolvedModel = resolveModel(config, manifest, "monitor", "sonnet");
+		const runtime = getRuntime(undefined, config);
+
 		// Deploy monitor-specific hooks to the project root's .claude/ directory.
-		await deployHooks(projectRoot, MONITOR_NAME, "monitor");
+		await runtime.deployConfig(projectRoot, undefined, {
+			agentName: MONITOR_NAME,
+			capability: "monitor",
+			worktreePath: projectRoot,
+		});
 
 		// Create monitor identity if first run
 		const identityBaseDir = join(projectRoot, ".overstory", "agents");
@@ -129,15 +141,6 @@ async function startMonitor(opts: { json: boolean; attach: boolean }): Promise<v
 			});
 		}
 
-		// Resolve model from config > manifest > fallback
-		const manifestLoader = createManifestLoader(
-			join(projectRoot, config.agents.manifestPath),
-			join(projectRoot, config.agents.baseDir),
-		);
-		const manifest = await manifestLoader.load();
-		const resolvedModel = resolveModel(config, manifest, "monitor", "sonnet");
-		const runtime = getRuntime(undefined, config);
-
 		// Spawn tmux session at project root with Claude Code (interactive mode).
 		const agentDefPath = join(projectRoot, ".overstory", "agent-defs", "monitor.md");
 		const agentDefFile = Bun.file(agentDefPath);
@@ -179,6 +182,7 @@ async function startMonitor(opts: { json: boolean; attach: boolean }): Promise<v
 			lastActivity: new Date().toISOString(),
 			escalationLevel: 0,
 			stalledSince: null,
+			transcriptPath: null,
 		};
 
 		store.upsert(session);

package/src/commands/nudge.test.ts

@@ -1,10 +1,11 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { mkdirSync } from "node:fs";
-import { mkdtemp, rm } from "node:fs/promises";
+import { mkdtemp } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { createEventStore } from "../events/store.ts";
 import { createSessionStore } from "../sessions/store.ts";
+import { cleanupTempDir } from "../test-helpers.ts";
 import type { AgentSession, StoredEvent } from "../types.ts";
 
 /**
@@ -22,7 +23,7 @@ beforeEach(async () => {
 });
 
 afterEach(async () => {
-	await rm(tempDir, { recursive: true, force: true });
+	await cleanupTempDir(tempDir);
 });
 
 /**
@@ -57,6 +58,7 @@ function makeSession(overrides: Partial<AgentSession> = {}): AgentSession {
 		lastActivity: new Date().toISOString(),
 		escalationLevel: 0,
 		stalledSince: null,
+		transcriptPath: null,
 		...overrides,
 	};
 }

package/src/commands/prime.test.ts

@@ -1,5 +1,5 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { mkdir, mkdtemp, rm } from "node:fs/promises";
+import { mkdir, mkdtemp } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { cleanupTempDir, createTempGitRepo } from "../test-helpers.ts";
@@ -55,7 +55,7 @@ describe("primeCommand", () => {
 		process.stdout.write = originalWrite;
 		process.stderr.write = originalStderrWrite;
 		process.chdir(originalCwd);
-		await rm(tempDir, { recursive: true, force: true });
+		await cleanupTempDir(tempDir);
 	});
 
 	function output(): string {
@@ -167,6 +167,7 @@ recentTasks:
 					lastActivity: new Date().toISOString(),
 					escalationLevel: 0,
 					stalledSince: null,
+					transcriptPath: null,
 				},
 			];
 
@@ -204,6 +205,7 @@ recentTasks:
 					lastActivity: new Date().toISOString(),
 					escalationLevel: 0,
 					stalledSince: null,
+					transcriptPath: null,
 				},
 			];
 

package/src/commands/prime.ts

@@ -38,6 +38,8 @@ const OVERSTORY_GITIGNORE = `# Wildcard+whitelist: ignore everything, whitelist
 export interface PrimeOptions {
 	agent?: string;
 	compact?: boolean;
+	/** Override the instruction path referenced in agent activation context. Defaults to ".claude/CLAUDE.md". */
+	instructionPath?: string;
 }
 
 /**
@@ -138,6 +140,7 @@ async function healGitignore(overstoryDir: string): Promise<void> {
 export async function primeCommand(opts: PrimeOptions): Promise<void> {
 	const agentName = opts.agent ?? null;
 	const compact = opts.compact ?? false;
+	const instructionPath = opts.instructionPath ?? ".claude/CLAUDE.md";
 
 	// 1. Load config
 	const config = await loadConfig(process.cwd());
@@ -161,7 +164,7 @@ export async function primeCommand(opts: PrimeOptions): Promise<void> {
 	// 4. Output context (orchestrator or agent)
 	if (agentName !== null) {
 		// === Agent priming ===
-		await outputAgentContext(config, agentName, compact, expertiseOutput);
+		await outputAgentContext(config, agentName, compact, expertiseOutput, instructionPath);
 	} else {
 		// === Orchestrator priming ===
 		await outputOrchestratorContext(config, compact, expertiseOutput);
@@ -176,6 +179,7 @@ async function outputAgentContext(
 	agentName: string,
 	compact: boolean,
 	expertiseOutput: string | null,
+	instructionPath: string,
 ): Promise<void> {
 	const sections: string[] = [];
 
@@ -226,7 +230,7 @@ async function outputAgentContext(
 	if (boundSession) {
 		sections.push("\n## Activation");
 		sections.push(`You have a bound task: **${boundSession.taskId}**`);
-		sections.push("Read your overlay at `.claude/CLAUDE.md` and begin working immediately.");
+		sections.push(`Read your overlay at \`${instructionPath}\` and begin working immediately.`);
 		sections.push("Do not wait for dispatch mail. Your assignment was bound at spawn time.");
 	}