@oh-my-pi/pi-coding-agent 16.2.2 → 16.2.4

package/src/advisor/config.ts

@@ -0,0 +1,256 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { isEnoent, logger } from "@oh-my-pi/pi-utils";
+import { type } from "arktype";
+import { YAML } from "bun";
+import { expandAtImports } from "../discovery/at-imports";
+import { BUILTIN_TOOL_NAMES, normalizeToolNames } from "../tools/builtin-names";
+import { collectConfigCandidates } from "./watchdog";
+
+/**
+ * One advisor declared in a `WATCHDOG.yml` file. `model` is a model selector
+ * with an optional `:level` thinking suffix (e.g. `x-ai/grok-code-fast:high`),
+ * resolved exactly like any other model override; `tools` is a subset of the
+ * read-only investigative tool names (default: all). `instructions` is the
+ * advisor's specialization, appended to the shared baseline.
+ */
+export interface AdvisorConfig {
+	name: string;
+	model?: string;
+	tools?: string[];
+	instructions?: string;
+}
+
+/**
+ * The result of walking the `WATCHDOG.yml`/`WATCHDOG.yaml` search path: the
+ * deduped advisor roster plus the concatenated top-level `instructions` baseline
+ * that is prepended (alongside `WATCHDOG.md`) to every advisor.
+ */
+export interface DiscoveredAdvisors {
+	advisors: AdvisorConfig[];
+	sharedInstructions: string | undefined;
+}
+
+const advisorEntrySchema = type({
+	name: "string",
+	"model?": "string",
+	"tools?": "string[]",
+	"instructions?": "string",
+});
+
+const watchdogYamlSchema = type({
+	"instructions?": "string",
+	"advisors?": advisorEntrySchema.array(),
+});
+
+/**
+ * Normalize an advisor name into a filesystem-/id-safe slug used for its
+ * transcript filename and session id: lowercase, non-alphanumerics collapsed to
+ * `-`, leading/trailing `-` trimmed. Falls back to `"advisor"` when nothing
+ * survives; callers dedupe collisions.
+ */
+export function slugifyAdvisorName(name: string): string {
+	const slug = name
+		.toLowerCase()
+		.replace(/[^a-z0-9]+/g, "-")
+		.replace(/^-+|-+$/g, "");
+	return slug || "advisor";
+}
+
+/** Built tool names, for validating an advisor's `tools` list. */
+const KNOWN_TOOL_NAMES = new Set<string>(BUILTIN_TOOL_NAMES);
+
+/**
+ * Keep only valid tool names from an advisor's `tools` list, dropping unknowns
+ * with a warning. The advisor is a full agent, so any built tool may be granted;
+ * the runtime further filters to what's actually available this session. An empty
+ * result (or no list) means "use the default subset" (read/grep/glob).
+ */
+function filterAdvisorTools(tools: string[] | undefined, sourcePath: string): string[] | undefined {
+	if (!tools || tools.length === 0) return undefined;
+	// Normalize legacy aliases (search→grep, find→glob) and dedupe before validating.
+	const filtered = normalizeToolNames(tools).filter(name => {
+		if (KNOWN_TOOL_NAMES.has(name)) return true;
+		logger.warn("Advisor config: dropping unknown tool", { path: sourcePath, tool: name });
+		return false;
+	});
+	return filtered.length > 0 ? filtered : undefined;
+}
+
+/**
+ * Discover advisor configs from `WATCHDOG.yml`/`WATCHDOG.yaml` files on the same
+ * user + project search path as `WATCHDOG.md`. Advisors are keyed by slug; a
+ * more-specific file (project leaf > project ancestor > user) replaces an earlier
+ * entry with the same slug. Top-level `instructions` across all files concatenate
+ * into the shared baseline. A malformed file is logged and skipped — never
+ * thrown — so a bad project config can't kill the session.
+ */
+export async function discoverAdvisorConfigs(cwd: string, agentDir?: string): Promise<DiscoveredAdvisors> {
+	const items = await collectConfigCandidates(cwd, agentDir, ["WATCHDOG.yml", "WATCHDOG.yaml"]);
+	const advisors = new Map<string, AdvisorConfig>();
+	const sharedParts: string[] = [];
+
+	for (const item of items) {
+		let parsed: unknown;
+		try {
+			parsed = YAML.parse(item.content);
+		} catch (err) {
+			logger.warn("Advisor config: failed to parse YAML", { path: item.path, error: String(err) });
+			continue;
+		}
+		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+			logger.warn("Advisor config: expected a YAML mapping", { path: item.path });
+			continue;
+		}
+		const result = watchdogYamlSchema(parsed);
+		if (result instanceof type.errors) {
+			logger.warn("Advisor config: invalid schema", { path: item.path, error: result.summary });
+			continue;
+		}
+
+		if (result.instructions?.trim()) {
+			const expanded = (await expandAtImports(result.instructions, item.path)).trim();
+			if (expanded) sharedParts.push(expanded);
+		}
+
+		for (const entry of result.advisors ?? []) {
+			const slug = slugifyAdvisorName(entry.name);
+			const instructions = entry.instructions?.trim()
+				? (await expandAtImports(entry.instructions, item.path)).trim() || undefined
+				: undefined;
+			advisors.set(slug, {
+				name: entry.name,
+				model: entry.model?.trim() || undefined,
+				tools: filterAdvisorTools(entry.tools, item.path),
+				instructions,
+			});
+		}
+	}
+
+	return {
+		advisors: [...advisors.values()],
+		sharedInstructions: sharedParts.length > 0 ? sharedParts.join("\n\n") : undefined,
+	};
+}
+
+/** Which level a `WATCHDOG.yml` lives at: the project root or the user agent dir. */
+export type AdvisorConfigScope = "project" | "user";
+
+/**
+ * The editable contents of a single `WATCHDOG.yml` file: the shared top-level
+ * `instructions` plus the advisor roster. Unlike {@link DiscoveredAdvisors}, this
+ * is one file's raw view (no cross-level merge, no `@import` expansion) so the
+ * config editor round-trips exactly what the user wrote.
+ */
+export interface WatchdogConfigDoc {
+	instructions?: string;
+	advisors: AdvisorConfig[];
+}
+
+/**
+ * Resolve the `WATCHDOG.yml` path for a scope: `project` → `<projectDir>/WATCHDOG.yml`
+ * (discovered by the project-level walk), `user` → `<agentDir>/WATCHDOG.yml` (the
+ * user-level candidate).
+ */
+export function advisorConfigFilePath(
+	scope: AdvisorConfigScope,
+	dirs: { projectDir: string; agentDir: string },
+): string {
+	return path.join(scope === "user" ? dirs.agentDir : dirs.projectDir, "WATCHDOG.yml");
+}
+
+/**
+ * Resolve which `WATCHDOG.{yml,yaml}` to edit for a scope: prefer the canonical
+ * `.yml`, but when only a `.yaml` exists for that scope, edit it in place so an
+ * existing `.yaml` user isn't shown a blank editor and left with two files at the
+ * same precedence. Falls back to `.yml` when neither exists.
+ */
+export async function resolveAdvisorConfigEditPath(
+	scope: AdvisorConfigScope,
+	dirs: { projectDir: string; agentDir: string },
+): Promise<string> {
+	const dir = scope === "user" ? dirs.agentDir : dirs.projectDir;
+	const yml = path.join(dir, "WATCHDOG.yml");
+	const yaml = path.join(dir, "WATCHDOG.yaml");
+	if (!(await Bun.file(yml).exists()) && (await Bun.file(yaml).exists())) return yaml;
+	return yml;
+}
+
+/**
+ * Load one `WATCHDOG.yml` file for editing — raw, un-merged, un-expanded. Missing,
+ * unparseable, or schema-invalid files yield an empty doc (never throws) so the
+ * editor opens cleanly on a fresh or broken file.
+ */
+export async function loadWatchdogConfigFile(filePath: string): Promise<WatchdogConfigDoc> {
+	let text: string;
+	try {
+		text = await Bun.file(filePath).text();
+	} catch (err) {
+		if (!isEnoent(err))
+			logger.warn("Advisor config: failed to read for edit", { path: filePath, error: String(err) });
+		return { advisors: [] };
+	}
+	let parsed: unknown;
+	try {
+		parsed = YAML.parse(text);
+	} catch (err) {
+		logger.warn("Advisor config: failed to parse for edit", { path: filePath, error: String(err) });
+		return { advisors: [] };
+	}
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return { advisors: [] };
+	const result = watchdogYamlSchema(parsed);
+	if (result instanceof type.errors) {
+		logger.warn("Advisor config: invalid schema for edit", { path: filePath, error: result.summary });
+		return { advisors: [] };
+	}
+	return {
+		instructions: result.instructions?.trim() ? result.instructions : undefined,
+		advisors: (result.advisors ?? []).map(a => ({
+			name: a.name,
+			model: a.model?.trim() || undefined,
+			tools: a.tools?.length ? [...a.tools] : undefined,
+			instructions: a.instructions?.trim() ? a.instructions : undefined,
+		})),
+	};
+}
+
+/**
+ * Serialize an editable doc back to block-style `WATCHDOG.yml` text via Bun's
+ * `YAML.stringify` (the same API the repo uses for other hand-editable config),
+ * omitting empty fields. Round-trips through {@link loadWatchdogConfigFile}.
+ * Returns `""` for an empty doc.
+ */
+export function serializeWatchdogConfig(doc: WatchdogConfigDoc): string {
+	const out: { instructions?: string; advisors?: AdvisorConfig[] } = {};
+	if (doc.instructions?.trim()) out.instructions = doc.instructions;
+	if (doc.advisors.length > 0) {
+		out.advisors = doc.advisors.map(a => {
+			const entry: AdvisorConfig = { name: a.name };
+			if (a.model?.trim()) entry.model = a.model;
+			if (a.tools?.length) entry.tools = [...a.tools];
+			if (a.instructions?.trim()) entry.instructions = a.instructions;
+			return entry;
+		});
+	}
+	if (out.instructions === undefined && out.advisors === undefined) return "";
+	const text = YAML.stringify(out, null, 2);
+	return text.endsWith("\n") ? text : `${text}\n`;
+}
+
+/**
+ * Write an editable doc to `WATCHDOG.yml`. An empty doc removes the file so
+ * discovery falls back to the legacy single-advisor path rather than leaving an
+ * empty config behind.
+ */
+export async function saveWatchdogConfigFile(filePath: string, doc: WatchdogConfigDoc): Promise<void> {
+	const content = serializeWatchdogConfig(doc);
+	if (!content.trim()) {
+		try {
+			await fs.rm(filePath, { force: true });
+		} catch (err) {
+			if (!isEnoent(err)) throw err;
+		}
+		return;
+	}
+	await Bun.write(filePath, content);
+}

package/src/advisor/index.ts

@@ -1,4 +1,5 @@
 export * from "./advise-tool";
+export * from "./config";
 export * from "./emission-guard";
 export * from "./runtime";
 export * from "./transcript-recorder";

package/src/advisor/runtime.ts

@@ -209,6 +209,7 @@ export class AdvisorRuntime {
 			includeToolIntent: true,
 			watchedRoles: true,
 			expandPrimaryContext: true,
+			expandEditDiffs: true,
 		});
 		if (!md.trim()) return null;
 		return `### Session update\n\n${md}`;
@@ -434,11 +435,20 @@ function obfuscateDetails(
 function obfuscateAdvisorMessage(obfuscator: SecretObfuscator, message: AgentMessage): AgentMessage {
 	switch (message.role) {
 		case "user":
-		case "developer":
-		case "toolResult": {
+		case "developer": {
 			const content = obfuscateTextualContent(obfuscator, message.content as TextualContent);
 			return content === message.content ? message : ({ ...(message as object), content } as AgentMessage);
 		}
+		case "toolResult": {
+			const msg = message as AgentMessage & {
+				content: TextualContent;
+				details?: Record<string, unknown>;
+			};
+			const content = obfuscateTextualContent(obfuscator, msg.content);
+			const details = obfuscateDetails(obfuscator, msg.details);
+			if (content === msg.content && details === msg.details) return message;
+			return { ...(message as object), content, details } as AgentMessage;
+		}
 		case "assistant":
 			return obfuscateAssistantMessage(obfuscator, message as AssistantMessage) as AgentMessage;
 		case "custom":

package/src/advisor/transcript-recorder.ts

@@ -14,6 +14,23 @@ export const ADVISOR_TRANSCRIPT_FILENAME = `${ADVISOR_TRANSCRIPT_STEM}.jsonl`;
 
 const JSONL_SUFFIX = ".jsonl";
 
+/**
+ * Transcript filename for an advisor: `__advisor.jsonl` for the legacy/default
+ * advisor (empty slug), `__advisor.<slug>.jsonl` for a named advisor. The `.`
+ * separator keeps named files out of the output manager's `-<n>` bump namespace.
+ */
+export function advisorTranscriptFilename(slug: string): string {
+	return slug ? `${ADVISOR_TRANSCRIPT_STEM}.${slug}${JSONL_SUFFIX}` : ADVISOR_TRANSCRIPT_FILENAME;
+}
+
+/** Whether a filename is any advisor transcript (`__advisor.jsonl` or `__advisor.<slug>.jsonl`). */
+export function isAdvisorTranscriptName(name: string): boolean {
+	return (
+		name === ADVISOR_TRANSCRIPT_FILENAME ||
+		(name.startsWith(`${ADVISOR_TRANSCRIPT_STEM}.`) && name.endsWith(JSONL_SUFFIX))
+	);
+}
+
 /**
  * Append-only persister for an advisor agent's transcript.
  *
@@ -38,19 +55,25 @@ const JSONL_SUFFIX = ".jsonl";
 export class AdvisorTranscriptRecorder {
 	#manager: SessionManager | undefined;
 	#file: string | undefined;
+	#filename: string;
 	/** Serializes the async open/close against synchronous appends so records land in order. */
 	#queue: Promise<void>;
 
 	/**
+	 * @param filename Transcript filename within the session dir. Defaults to
+	 *   `__advisor.jsonl`; named advisors pass `__advisor.<slug>.jsonl` via
+	 *   {@link advisorTranscriptFilename}.
 	 * @param after Optional barrier the queue starts behind — used on the advisor
 	 *   on→off→on toggle so a fresh recorder's first `open` waits for the prior
-	 *   recorder's `close` and the two never hold the same `__advisor.jsonl` at once.
+	 *   recorder's `close` and the two never hold the same file at once.
 	 */
 	constructor(
 		private readonly resolveSessionFile: () => string | undefined,
 		private readonly resolveCwd: () => string,
+		filename: string = ADVISOR_TRANSCRIPT_FILENAME,
 		after?: Promise<unknown>,
 	) {
+		this.#filename = filename;
 		this.#queue = after
 			? after.then(
 					() => {},
@@ -83,7 +106,7 @@ export class AdvisorTranscriptRecorder {
 		}
 		const sessionFile = this.resolveSessionFile();
 		if (!sessionFile?.endsWith(JSONL_SUFFIX)) return;
-		const file = path.join(sessionFile.slice(0, -JSONL_SUFFIX.length), ADVISOR_TRANSCRIPT_FILENAME);
+		const file = path.join(sessionFile.slice(0, -JSONL_SUFFIX.length), this.#filename);
 		const cwd = this.resolveCwd();
 		this.#enqueue(async () => {
 			if (file !== this.#file) {

package/src/advisor/watchdog.ts

@@ -31,79 +31,105 @@ export function formatAdvisorContextPrompt(
 }
 
 /**
- * Discover and load WATCHDOG.md files walking up from cwd, project .omp folder, and user agent dir.
- * Returns formatted watchdog file blocks ready to be appended to the advisor system prompt.
+ * A readable config candidate discovered on the watchdog/advisor search path,
+ * with raw (un-expanded) content and its position metadata.
  */
-export async function discoverWatchdogFiles(cwd: string, agentDir?: string): Promise<string[]> {
+export interface ConfigCandidate {
+	path: string;
+	content: string;
+	level: "user" | "project";
+	depth: number;
+}
+
+/**
+ * Walk the watchdog/advisor config search path — the user agent dir plus every
+ * directory from `cwd` up to the repo root (or home), probing both `<F>` and
+ * `.omp/<F>` for each given filename — and return the readable candidates with
+ * their raw content, sorted user-first then project ancestor→leaf (depth
+ * descending, so the leaf directory is most specific/last). Shared by
+ * {@link discoverWatchdogFiles} and `discoverAdvisorConfigs`. Content is returned
+ * verbatim (no `@import` expansion); callers expand what they need.
+ */
+export async function collectConfigCandidates(
+	cwd: string,
+	agentDir: string | undefined,
+	filenames: string[],
+): Promise<ConfigCandidate[]> {
 	const home = os.homedir();
 	const resolvedAgentDir = agentDir ?? getAgentDir();
-	const userPath = resolvedAgentDir ? path.resolve(resolvedAgentDir, "WATCHDOG.md") : null;
+	const userPaths = new Set<string>();
 	let repoRoot: string | null = null;
 	try {
 		repoRoot = await repo.root(cwd);
 	} catch (err) {
-		logger.debug("Failed to resolve git root for watchdog discovery", { err: String(err) });
+		logger.debug("Failed to resolve git root for config discovery", { err: String(err) });
 	}
 
 	const candidates = new Set<string>();
 
-	// 1. User level: ~/.omp/WATCHDOG.md (or active profile agent dir)
+	// 1. User level: ~/.omp/<F> (or active profile agent dir)
 	if (resolvedAgentDir) {
-		candidates.add(path.resolve(resolvedAgentDir, "WATCHDOG.md"));
+		for (const filename of filenames) {
+			const userPath = path.resolve(resolvedAgentDir, filename);
+			candidates.add(userPath);
+			userPaths.add(userPath);
+		}
 	}
 
 	// 2. Project levels (both standalone and native config .omp/): walk up from cwd to repoRoot / home
 	let current = cwd;
 	while (true) {
-		candidates.add(path.resolve(current, ".omp", "WATCHDOG.md"));
-		candidates.add(path.resolve(current, "WATCHDOG.md"));
-
+		for (const filename of filenames) {
+			candidates.add(path.resolve(current, ".omp", filename));
+			candidates.add(path.resolve(current, filename));
+		}
 		if (current === (repoRoot ?? home)) break;
 		const parent = path.dirname(current);
 		if (parent === current) break;
 		current = parent;
 	}
 
-	const items: Array<{ path: string; content: string; level: "user" | "project"; depth: number }> = [];
-
+	const items: ConfigCandidate[] = [];
 	for (const candidate of candidates) {
 		try {
 			const content = await Bun.file(candidate).text();
-			const expanded = await expandAtImports(content, candidate);
 			const parent = path.dirname(candidate);
 			const baseName = parent.split(path.sep).pop() ?? "";
-
-			const isUser = userPath !== null && candidate === userPath;
+			const isUser = userPaths.has(candidate);
 			const ownerDir = baseName === ".omp" ? path.dirname(parent) : parent;
 			const ownerBaseName = ownerDir.split(path.sep).pop() ?? "";
-
 			if (isUser || !ownerBaseName.startsWith(".") || baseName === ".omp") {
 				const relative = path.relative(cwd, ownerDir);
 				const depth = relative === "" ? 0 : relative.split(path.sep).filter(Boolean).length;
-				items.push({
-					path: candidate,
-					content: expanded,
-					level: isUser ? "user" : "project",
-					depth,
-				});
+				items.push({ path: candidate, content, level: isUser ? "user" : "project", depth });
 			}
 		} catch (err) {
 			if (!isEnoent(err)) {
-				logger.warn("Failed to read WATCHDOG.md candidate", { path: candidate, error: String(err) });
+				logger.warn("Failed to read config candidate", { path: candidate, error: String(err) });
 			}
 		}
 	}
 
-	// Sort files so that user level comes first, then project level sorted by depth (descending).
-	// This means user-level rules are first, then project-level rules from ancestor directories down to the leaf directory (depth 0 is last/most prominent).
+	// User level first, then project levels sorted by depth descending — ancestor
+	// directories first, the leaf (depth 0) last/most prominent.
 	items.sort((a, b) => {
-		if (a.level !== b.level) {
-			return a.level === "user" ? -1 : 1;
-		}
+		if (a.level !== b.level) return a.level === "user" ? -1 : 1;
 		return b.depth - a.depth;
 	});
 
-	return items.map(item => {
-		return `Especially pay attention to:\n<attention>\n${item.content}\n</attention>`;
-	});
+	return items;
+}
+
+/**
+ * Discover and load WATCHDOG.md files walking up from cwd, project .omp folder, and user agent dir.
+ * Returns formatted watchdog file blocks ready to be appended to the advisor system prompt.
+ */
+export async function discoverWatchdogFiles(cwd: string, agentDir?: string): Promise<string[]> {
+	const items = await collectConfigCandidates(cwd, agentDir, ["WATCHDOG.md"]);
+	const blocks: string[] = [];
+	for (const item of items) {
+		const expanded = await expandAtImports(item.content, item.path);
+		blocks.push(`Especially pay attention to:\n<attention>\n${expanded}\n</attention>`);
+	}
+	return blocks;
 }

package/src/autolearn/controller.ts

@@ -2,9 +2,9 @@
  * Auto-learn session controller (experimental).
  *
  * Subscribes to the session event stream and, after a substantive turn,
- * nudges the agent to capture reusable lessons. Default posture is passive
- * (a hidden reminder rides the next real turn); with `autolearn.autoContinue`
- * it auto-runs exactly one synthetic capture turn at stop.
+ * optionally auto-runs a synthetic capture turn. Passive mode is intentionally
+ * prompt-cache neutral: the standing system guidance remains available, but no
+ * hidden mid-session reminder is inserted into the conversation.
  *
  * Installed once per top-level session (taskDepth 0). The subscription lives
  * for the session's lifetime — `newSession` resets the session in place
@@ -14,11 +14,9 @@ import { logger } from "@oh-my-pi/pi-utils";
 import type { Settings } from "../config/settings";
 import autolearnGuidance from "../prompts/system/autolearn-guidance.md" with { type: "text" };
 import autolearnGuidanceLearn from "../prompts/system/autolearn-guidance-learn.md" with { type: "text" };
-import autolearnNudge from "../prompts/system/autolearn-nudge.md" with { type: "text" };
 import autolearnNudgeAutoContinue from "../prompts/system/autolearn-nudge-autocontinue.md" with { type: "text" };
 import type { AgentSession, AgentSessionEvent } from "../session/agent-session";
 
-const AUTOLEARN_NUDGE_PASSIVE = autolearnNudge.trim();
 const AUTOLEARN_NUDGE_AUTOCONTINUE = autolearnNudgeAutoContinue.trim();
 const DEFAULT_MIN_TOOL_CALLS = 5;
 
@@ -110,28 +108,21 @@ export class AutoLearnController {
 		// auto-continue would compete with it.
 		if (startedInGoalMode || this.#session.getGoalModeState()?.enabled) return;
 
-		// Auto-run a capture turn only when explicitly enabled; otherwise the
-		// hidden reminder rides the next real turn passively.
-		//
-		// The two paths get DIFFERENT nudge text:
-		// - Auto-continue spawns a synthetic turn with the nudge as its only
-		//   user-role payload, so the prompt must be terminal — it tells the
-		//   agent to capture and STOP, and must not be read as the user's
-		//   reply to any pending question. Without that contract, the agent
-		//   conflates the synthetic prompt with user approval and resumes
-		//   prior work (e.g. commits/pushes an unanswered "want me to push?"
-		//   question — #3504).
-		// - Passive mode appends the nudge to the user's real next message,
-		//   so the agent must answer the user normally and treat the capture
-		//   as additive — not as the whole turn's job.
+		// Auto-run a capture turn only when explicitly enabled. Passive mode used to
+		// queue a hidden custom message for the next real turn, but that mutates the
+		// persisted conversation prefix after providers have cached it. The standing
+		// auto-learn system guidance is stable; keep passive mode to that guidance
+		// so Anthropic prompt-cache prefixes survive long sessions.
 		const autoContinue = this.#settings.get("autolearn.autoContinue") === true;
-		const content = autoContinue ? AUTOLEARN_NUDGE_AUTOCONTINUE : AUTOLEARN_NUDGE_PASSIVE;
+		if (!autoContinue) return;
+
+		const content = AUTOLEARN_NUDGE_AUTOCONTINUE;
 		// Arm suppression synchronously: the synthetic capture turn's agent_end
 		// fires inside sendCustomMessage (before it resolves), so the flag must be
 		// set before then. Disarm when no turn actually started — a deferred/queued
 		// dispatch or a failed send produces no agent_end, and a latched flag would
 		// otherwise swallow the next real stop.
-		if (autoContinue) this.#suppressNext = true;
+		this.#suppressNext = true;
 
 		this.#session
 			.sendCustomMessage(
@@ -141,7 +132,7 @@ export class AutoLearnController {
 					display: false,
 					attribution: "user",
 				},
-				{ deliverAs: "nextTurn", triggerTurn: autoContinue },
+				{ deliverAs: "nextTurn", triggerTurn: true },
 			)
 			.then(started => {
 				if (!started) this.#suppressNext = false;

package/src/autoresearch/index.ts

@@ -320,6 +320,11 @@ export const createAutoresearchExtension: ExtensionFactory = api => {
 		runtime.lastRunDuration = pendingRun?.durationSeconds ?? runtime.lastRunDuration;
 		runtime.lastRunAsi = pendingRun?.parsedAsi ?? runtime.lastRunAsi;
 		const state = runtime.state;
+		// `event.systemPrompt` is typed `string[]`, but upstream code paths can leave
+		// it unset (issue #3665). Coerce defensively so the autoresearch block still
+		// renders — the model just loses the upstream prefix for this turn, which is
+		// strictly better than crashing the handler.
+		const basePrompt = Array.isArray(event.systemPrompt) ? event.systemPrompt.join("\n\n") : "";
 		const currentSegmentResults = currentResults(state.results, state.currentSegment);
 		const baselineMetric = findBaselineMetric(state.results, state.currentSegment);
 		const baselineRunNumber = findBaselineRunNumber(state.results, state.currentSegment);
@@ -358,7 +363,7 @@ export const createAutoresearchExtension: ExtensionFactory = api => {
 			return {
 				systemPrompt: [
 					prompt.render(setupPromptTemplate, {
-						base_system_prompt: event.systemPrompt.join("\n\n"),
+						base_system_prompt: basePrompt,
 						has_goal: goal.trim().length > 0,
 						goal,
 						working_dir: ctx.cwd,
@@ -373,7 +378,7 @@ export const createAutoresearchExtension: ExtensionFactory = api => {
 		return {
 			systemPrompt: [
 				prompt.render(promptTemplate, {
-					base_system_prompt: event.systemPrompt.join("\n\n"),
+					base_system_prompt: basePrompt,
 					has_goal: goal.trim().length > 0,
 					goal,
 					working_dir: ctx.cwd,

package/src/cli/gc-cli.ts

@@ -434,17 +434,24 @@ function sessionIdFromSessionPath(sessionPath: string): string | undefined {
 }
 
 function sessionIdFromSessionText(text: string): string | undefined {
-	const line = text
-		.split(/\r?\n/)
-		.find(candidate => candidate.trim().length > 0)
-		?.trim();
-	if (!line) return undefined;
-	try {
-		const record = JSON.parse(line) as { type?: unknown; id?: unknown };
-		return record.type === "session" && typeof record.id === "string" && record.id.length > 0 ? record.id : undefined;
-	} catch {
-		return undefined;
+	let sawTitleSlot = false;
+	for (const rawLine of text.split(/\r?\n/)) {
+		const line = rawLine.trim();
+		if (!line) continue;
+		try {
+			const record = JSON.parse(line) as { type?: unknown; id?: unknown };
+			if (!sawTitleSlot && record.type === "title") {
+				sawTitleSlot = true;
+				continue;
+			}
+			return record.type === "session" && typeof record.id === "string" && record.id.length > 0
+				? record.id
+				: undefined;
+		} catch {
+			return undefined;
+		}
 	}
+	return undefined;
 }
 
 async function archivedSessionIdFromFile(file: string): Promise<string | undefined> {