one-code-extension 0.1.4 → 0.3.1

package/extensions/lib/favorites.ts

@@ -0,0 +1,43 @@
+/**
+ * Favorited plugins/skills for the /plugins panel (pure fs, no pi imports).
+ *
+ * `<plugin root>/favorites.json`: `{plugins: string[], skills: string[]}`.
+ * Favorited rows float to the top of the Installed tab.
+ */
+
+import { join } from "node:path";
+import { readJsonFile, writeJsonAtomic } from "./atomic-write.ts";
+
+const FILE = "favorites.json";
+
+export interface Favorites {
+	plugins: string[];
+	skills: string[];
+}
+
+export type FavoriteKind = "plugin" | "skill";
+
+function strings(value: unknown): string[] {
+	return Array.isArray(value) ? value.filter((v): v is string => typeof v === "string") : [];
+}
+
+export function readFavorites(root: string): Favorites {
+	const parsed = readJsonFile<{ plugins?: unknown; skills?: unknown }>(join(root, FILE));
+	return { plugins: strings(parsed?.plugins), skills: strings(parsed?.skills) };
+}
+
+/** Toggle; returns the new favorited state. */
+export function toggleFavorite(root: string, kind: FavoriteKind, key: string): boolean {
+	const path = join(root, FILE);
+	const existing = readJsonFile<Record<string, unknown>>(path) ?? {};
+	const current: Favorites = { plugins: strings(existing.plugins), skills: strings(existing.skills) };
+	const list = kind === "plugin" ? current.plugins : current.skills;
+	const favorited = !list.includes(key);
+	const next = favorited ? [...list, key] : list.filter((k) => k !== key);
+	writeJsonAtomic(path, {
+		...existing,
+		plugins: kind === "plugin" ? next : current.plugins,
+		skills: kind === "skill" ? next : current.skills,
+	});
+	return favorited;
+}

package/extensions/lib/fetch-timeout.ts

@@ -0,0 +1,15 @@
+/**
+ * fetch with a hard timeout (pure, no pi imports) — the AbortController +
+ * unref'd timer boilerplate the plugin-marketplace fetches share.
+ */
+
+export async function fetchWithTimeout(url: string, timeoutMs: number, init?: RequestInit): Promise<Response> {
+	const controller = new AbortController();
+	const timer = setTimeout(() => controller.abort(), timeoutMs);
+	timer.unref?.();
+	try {
+		return await fetch(url, { ...init, signal: controller.signal });
+	} finally {
+		clearTimeout(timer);
+	}
+}

package/extensions/lib/frontmatter.ts

@@ -0,0 +1,31 @@
+/**
+ * Frontmatter parsing that never throws the file away. pi's `parseFrontmatter`
+ * is strict YAML and throws on the kind of thing agent/skill/command authors
+ * write by hand (an unquoted colon in a description, a stray tab); a bare
+ * `catch` around it silently dropped the whole file (documented trap #7). The
+ * lenient fallback reads simple `key: value` lines so the file still loads with
+ * whatever could be salvaged. Shared by agents, skills and plugin commands.
+ */
+
+import { parseFrontmatter } from "@earendil-works/pi-coding-agent";
+
+export function parseFrontmatterLoosely(content: string): { frontmatter: Record<string, unknown>; body: string } {
+	try {
+		const parsed = parseFrontmatter(content) as { frontmatter?: Record<string, unknown>; body: string };
+		return { frontmatter: parsed.frontmatter ?? {}, body: parsed.body };
+	} catch {
+		// Fall through to the lenient path.
+	}
+
+	const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
+	if (!match) return { frontmatter: {}, body: content };
+
+	const frontmatter: Record<string, unknown> = {};
+	for (const line of match[1].split(/\r?\n/)) {
+		const keyValue = line.match(/^([A-Za-z_][A-Za-z0-9_-]*):\s*(.*)$/);
+		if (!keyValue) continue;
+		const value = keyValue[2].trim().replace(/^["']|["']$/g, "");
+		if (value) frontmatter[keyValue[1]] = value;
+	}
+	return { frontmatter, body: match[2] };
+}

package/extensions/lib/git.ts

@@ -1,8 +1,15 @@
 /** Shared git helpers — pure functions only (safe to import across extensions). */
 
-import { existsSync } from "node:fs";
-import { dirname, join } from "node:path";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { basename, dirname, isAbsolute, join, resolve } from "node:path";
 
+/**
+ * The nearest checkout root at or above `startDir`: the directory holding a
+ * `.git` entry (a directory for a main checkout, a file for a linked worktree
+ * or a submodule). This is the bound for walking up a checkout (context files,
+ * banner listing); for the repository a directory *belongs to*, which linked
+ * worktrees share with their main checkout, use `findProjectRoot`.
+ */
 export function findGitRoot(startDir: string): string | undefined {
 	let dir = startDir;
 	while (true) {
@@ -12,3 +19,38 @@ export function findGitRoot(startDir: string): string | undefined {
 		dir = parent;
 	}
 }
+
+/**
+ * The repository `startDir` belongs to — the checkout root, except that a
+ * linked worktree (`git worktree add`, including a subagent's isolation
+ * worktree in a tmpdir) resolves to its MAIN checkout, so every worktree of one
+ * repository shares one project identity (auto-memory dir, per-repo settings,
+ * project trust). A submodule keeps its own root. Pure filesystem: the linked
+ * worktree's `.git` is a file reading `gitdir: <main>/.git/worktrees/<name>`.
+ */
+export function findProjectRoot(startDir: string): string | undefined {
+	const root = findGitRoot(startDir);
+	if (!root) return undefined;
+	return linkedWorktreeMainRoot(root) ?? root;
+}
+
+/** For a linked worktree root, the main checkout it belongs to; undefined otherwise. Exported for tests. */
+export function linkedWorktreeMainRoot(root: string): string | undefined {
+	const dotGit = join(root, ".git");
+	let gitdir: string;
+	try {
+		if (!statSync(dotGit).isFile()) return undefined;
+		const match = /^gitdir:\s*(.+?)\s*$/m.exec(readFileSync(dotGit, "utf-8"));
+		if (!match) return undefined;
+		gitdir = match[1];
+	} catch {
+		return undefined;
+	}
+	const absolute = isAbsolute(gitdir) ? gitdir : resolve(root, gitdir);
+	// <main>/.git/worktrees/<name> → <main>. A submodule's gitdir points into
+	// <super>/.git/modules/<name> and is left alone.
+	const worktrees = dirname(absolute);
+	const mainDotGit = dirname(worktrees);
+	if (basename(worktrees) !== "worktrees" || basename(mainDotGit) !== ".git") return undefined;
+	return dirname(mainDotGit);
+}

package/extensions/lib/hook-gate.ts

@@ -0,0 +1,90 @@
+/**
+ * Hook gate for in-process agent sessions (pure), shared by the subagent and
+ * workflow runners — the child half of `hooks/subagent-bridge.ts`.
+ *
+ * A child session is built with `noExtensions: true`, so the `hooks` extension
+ * never loads inside it. This inline extension forwards the child's
+ * `tool_call` / `tool_result` to the parent's hooks extension over the bridge
+ * and applies what comes back exactly as the parent applies it to its own
+ * calls: a PreToolUse block denies the call with the hook's reason; an
+ * updatedInput is applied IN PLACE so the guards after this one (worktree
+ * isolation, the permission gate) judge the rewritten input, as Claude Code
+ * does; PreToolUse context is queued on the child's reminder channel (the child
+ * loads system-reminder), so it lands inside the tool result; PostToolUse
+ * block/replacement/context are written into the result content.
+ *
+ * Fail OPEN, like the parent's own dispatch: hooks are the user's automation,
+ * not the safety gate — a missing or throwing bridge leaves the call to the
+ * permission gate behind it. (The permission bridge, by contrast, fails closed.)
+ */
+
+import type { InlineExtension } from "@earendil-works/pi-coding-agent";
+import { applyPostToolUseOutcome } from "../hooks/protocol.ts";
+import type { ChildHookCall, HookBridge } from "../hooks/subagent-bridge.ts";
+import { REMINDER_CHANNEL } from "./reminders.ts";
+
+/** Tools the runtime itself injects; never run hooks for them. */
+const DEFAULT_INTERNAL_TOOLS = new Set(["structured_output"]);
+
+export interface HookGateOptions {
+	/** The child's agent type for the payload's `agent_type`, resolved per session id by the runner. */
+	agentTypeOf?: (sessionId: string | undefined) => string | undefined;
+	neverGate?: Set<string>;
+}
+
+export function hookGateFactory(getBridge: () => HookBridge | undefined, options: HookGateOptions = {}): InlineExtension {
+	const neverGate = options.neverGate ?? DEFAULT_INTERNAL_TOOLS;
+	return {
+		name: "agent-hook-gate",
+		hidden: true,
+		factory: (pi) => {
+			const describe = (toolName: string, input: unknown, ctx: { cwd?: string; sessionManager?: { getSessionId?: () => string; getSessionFile?: () => string | undefined } } | undefined, fallbackCwd: string): ChildHookCall => {
+				const sessionId = ctx?.sessionManager?.getSessionId?.();
+				return {
+					toolName,
+					input: (input ?? {}) as Record<string, unknown>,
+					cwd: ctx?.cwd ?? fallbackCwd,
+					sessionId,
+					transcriptPath: ctx?.sessionManager?.getSessionFile?.() ?? undefined,
+					agentType: options.agentTypeOf?.(sessionId),
+				};
+			};
+
+			pi.on("tool_call", async (event, ctx) => {
+				if (neverGate.has(event.toolName)) return undefined;
+				try {
+					const bridge = getBridge();
+					if (!bridge) return undefined;
+					const call = describe(event.toolName, event.input, ctx as never, process.cwd());
+					const outcome = await bridge.preToolUse(call);
+					if (outcome.block) return { block: true, reason: `PreToolUse hook: ${outcome.block.reason}` };
+					if (outcome.updatedInput) Object.assign(event.input as Record<string, unknown>, outcome.updatedInput);
+					if (outcome.additionalContext) pi.events.emit(REMINDER_CHANNEL, { text: outcome.additionalContext });
+				} catch {
+					// Fail open: a broken hook pipeline must never take the child's turn down.
+				}
+				return undefined;
+			});
+
+			pi.on("tool_result", async (event, ctx) => {
+				if (neverGate.has(event.toolName)) return undefined;
+				try {
+					const bridge = getBridge();
+					if (!bridge) return undefined;
+					const outcome = await bridge.postToolUse({
+						...describe(event.toolName, event.input, ctx as never, process.cwd()),
+						content: event.content,
+						isError: event.isError,
+					});
+					// Same assembly as the parent's tool_result handler; the parent already
+					// framed additionalContext as a <system-reminder>.
+					const content = applyPostToolUseOutcome(event.content, outcome);
+					if (!content) return undefined;
+					return { content, isError: event.isError };
+				} catch {
+					return undefined;
+				}
+			});
+		},
+	};
+}

package/extensions/lib/interrupt.ts

@@ -0,0 +1,94 @@
+/**
+ * Read how an agent run ended off its last assistant message.
+ *
+ * pi marks the assistant message it was streaming with `stopReason: "aborted"`
+ * when the user hits Esc (or otherwise calls `ctx.abort()`), and with
+ * `stopReason: "error"` when the provider call failed; a run that completed
+ * carries "stop"/"toolUse"/etc. instead. Claude Code keys its InterruptedByUser
+ * line off the same abort signal (ERROR_MESSAGE_USER_ABORT on the last
+ * assistant message). Duck-typed so the extensions that need it can share it
+ * without pulling in pi's message types.
+ *
+ * **One abort is mislabelled.** An abort that lands between a stored tool
+ * result and the next stream start (the tool saw the signal and returned
+ * "Command aborted"; the loop still has a queued steer to deliver, so it calls
+ * the provider with the signal already aborted) comes back as an assistant
+ * message with EMPTY content, `stopReason: "error"` and `errorMessage: "This
+ * operation was aborted"` — the fetch layer's AbortError, not pi's "aborted"
+ * label (measured over RPC on pi 0.85.0, STEERING-REVIEW-2026-09-05 L1;
+ * upstream ask docs/upstream_prs.md #18). The run's abort signal is still the
+ * ground truth, and `ctx.signal` at `agent_end` is that signal (pi's
+ * `activeRun` outlives the event), so callers pass `ctx.signal?.aborted` and
+ * an `error` stop on an aborted run reads as "aborted": the user stopped the
+ * turn, and everything downstream (the Interrupted line, the notifier's
+ * post-abort hold, the Stop-hook skip) treats it as it treats Esc. Matching
+ * the error text was rejected: three libraries' wordings, any of which can
+ * change under us.
+ *
+ * **One turn is not one run.** `agent_end` fires per low-level run, and pi
+ * continues on its own afterwards in three cases: an auto-retry of a transient
+ * provider error, an auto-compaction followed by a retry, and a queued
+ * follow-up message. `agent_settled` is the one event meaning pi will not
+ * continue by itself, and it carries no messages — so anything that reports a
+ * turn as finished listens on `agent_settled` and keeps a `RunOutcomeLatch` to
+ * carry the outcome over from the runs' `agent_end`. Findings §3.
+ */
+
+/** How the last assistant message of a run ended. */
+export type RunOutcome = "ok" | "aborted" | "error";
+
+/** The only fields of a run's messages any of this reads. */
+export interface RunMessage {
+	role: string;
+	stopReason?: string;
+}
+
+/**
+ * Classify a run from its messages; a run with no assistant message counts as
+ * "ok". `signalAborted` is the run's abort signal at `agent_end`
+ * (`ctx.signal?.aborted`): it turns an `error` stop into "aborted" (see the
+ * header) and leaves a completed stop alone — a signal aborted after the final
+ * message landed did not interrupt anything.
+ */
+export function runOutcome(messages: ReadonlyArray<RunMessage> | undefined, signalAborted = false): RunOutcome {
+	if (!messages) return "ok";
+	for (let i = messages.length - 1; i >= 0; i--) {
+		const message = messages[i];
+		if (message.role !== "assistant") continue;
+		if (message.stopReason === "aborted") return "aborted";
+		if (message.stopReason === "error") return signalAborted ? "aborted" : "error";
+		return "ok";
+	}
+	return "ok";
+}
+
+/** The last assistant message in a turn was aborted by the user. */
+export function wasInterrupted(messages: ReadonlyArray<RunMessage> | undefined, signalAborted = false): boolean {
+	return runOutcome(messages, signalAborted) === "aborted";
+}
+
+/**
+ * Carries the last run's outcome from `agent_end` to `agent_settled`.
+ *
+ * Empty reads as `undefined` rather than "ok", so "no run ended in this turn"
+ * stays distinguishable from "a run finished cleanly". A settle with nothing
+ * recorded means the turn produced no response at all, and a caller gating on
+ * `=== "ok"` then holds off by construction instead of treating the stale
+ * default as success. `take()` empties the latch, so the next turn starts clean
+ * whether or not this turn's outcome was read.
+ */
+export class RunOutcomeLatch {
+	private outcome: RunOutcome | undefined;
+
+	/** `agent_end`: record how that run ended (pass `ctx.signal?.aborted`), replacing any earlier run's. */
+	record(messages: ReadonlyArray<RunMessage> | undefined, signalAborted = false): void {
+		this.outcome = runOutcome(messages, signalAborted);
+	}
+
+	/** `agent_settled`: the settled turn's outcome, or undefined if no run ended. */
+	take(): RunOutcome | undefined {
+		const outcome = this.outcome;
+		this.outcome = undefined;
+		return outcome;
+	}
+}

package/extensions/lib/mcp-overrides.ts

@@ -0,0 +1,61 @@
+/**
+ * Persisted "disabled MCP server" overrides (pure-ish — touches only ~/.onecode).
+ *
+ * The /mcp panel's Disable/Enable action persists across sessions here rather
+ * than by mutating the user's `~/.claude.json` or a plugin's `.mcp.json`: those
+ * are Claude Code's / a plugin's config, which One Code only ever reads (the
+ * "own state, borrowed config" rule — docs/decisions/memory-state.md). A
+ * disabled server is still discovered and listed; the mcp extension just skips
+ * connecting it, and the panel offers Enable to bring it back.
+ *
+ * Scope mirrors the settings layout: a server configured in the user file
+ * (`~/.claude.json`) disables at user scope so it stays disabled everywhere;
+ * anything project/local/plugin disables per-repo so it doesn't leak across
+ * projects. Reads merge both scopes.
+ */
+
+import os from "node:os";
+import { readJsonFile } from "./atomic-write.ts";
+import { oneCodeProjectSettingsPath, oneCodeSettingsPath, readSettingsForWrite, writeSettings } from "./one-code-settings.ts";
+
+const KEY = "disabledMcpServers";
+
+export type McpDisableScope = "user" | "project";
+
+function stringArray(value: unknown): string[] {
+	return Array.isArray(value) ? value.filter((v): v is string => typeof v === "string") : [];
+}
+
+function namesAt(path: string): string[] {
+	// Lenient on the READ path: a malformed settings file must not abort MCP
+	// startup (review M11). The write path below stays strict so it never
+	// clobbers a file it could not parse.
+	return stringArray(readJsonFile<Record<string, unknown>>(path)?.[KEY]);
+}
+
+/** Server names disabled at either scope, merged. */
+export function readDisabledMcpServers(
+	cwd: string,
+	home: string = os.homedir(),
+	env: NodeJS.ProcessEnv = process.env,
+): Set<string> {
+	return new Set([...namesAt(oneCodeSettingsPath(home, env)), ...namesAt(oneCodeProjectSettingsPath(cwd, home, env))]);
+}
+
+/** Add or remove a server from the disabled list at the given scope. */
+export function setMcpServerDisabled(
+	name: string,
+	disabled: boolean,
+	scope: McpDisableScope,
+	cwd: string,
+	home: string = os.homedir(),
+	env: NodeJS.ProcessEnv = process.env,
+): void {
+	const path = scope === "user" ? oneCodeSettingsPath(home, env) : oneCodeProjectSettingsPath(cwd, home, env);
+	const file = readSettingsForWrite(path);
+	const set = new Set(stringArray(file[KEY]));
+	if (disabled) set.add(name);
+	else set.delete(name);
+	file[KEY] = [...set].sort();
+	writeSettings(path, file);
+}

package/extensions/lib/mcp-share.ts

@@ -0,0 +1,25 @@
+/**
+ * Channel the mcp extension uses to publish its live tool definitions so the
+ * subagent runner can inject them into in-process child sessions as customTools —
+ * the child then reaches MCP servers through the parent's already-open
+ * connections instead of connecting its own (Claude Code's shared-services model).
+ *
+ * The definitions' execute() closes over the parent mcp extension's live
+ * connection map, so they must only ever be used in the same process.
+ */
+
+import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
+
+export const MCP_TOOLS_CHANNEL = "one-code:mcp-tools";
+
+export interface McpToolsPayload {
+	/** Every MCP tool currently registered on the parent session (re-published as servers connect). */
+	tools: ToolDefinition[];
+	/**
+	 * True on the final publish, when every configured server has connected or
+	 * failed (also emitted with zero tools when no servers are configured).
+	 * Consumers spawning children early can wait for this instead of snapshotting
+	 * a still-connecting set.
+	 */
+	settled?: boolean;
+}

package/extensions/lib/mcp-status.ts

@@ -0,0 +1,34 @@
+/**
+ * Cross-extension MCP status channel (pure types/constants, no pi imports).
+ *
+ * jiti gives every extension file its own module instance, so the /plugins
+ * panel cannot import the mcp extension's connection state directly. Instead:
+ * the panel emits MCP_STATUS_REQUEST_CHANNEL, and the mcp extension replies on
+ * MCP_STATUS_CHANNEL with a snapshot (same data its /mcp command formats).
+ * The reply is synchronous and in-process, but the request/reply shape also
+ * covers the ordering problem — the bus does not replay, and the panel opens
+ * long after the mcp extension's connect events fired.
+ */
+
+export const MCP_STATUS_REQUEST_CHANNEL = "one-code:mcp-status-request";
+export const MCP_STATUS_CHANNEL = "one-code:mcp-status";
+
+export type McpStatusKind = "connected" | "failed" | "authNeeded" | "connecting" | "disabled";
+
+export interface McpServerStatus {
+	name: string;
+	status: McpStatusKind;
+	/** Failure reason / missing env var, for the row's detail text. */
+	detail?: string;
+	toolCount?: number;
+	/** Set when a plugin's .mcp.json contributed this server. */
+	pluginName?: string;
+	/** Where the server was configured (".mcp.json", "~/.claude.json", plugin path…). */
+	source?: string;
+}
+
+export interface McpStatusEvent {
+	servers: McpServerStatus[];
+	/** False while the startup connect is still in flight. */
+	settled: boolean;
+}

package/extensions/lib/memory.ts

@@ -18,7 +18,8 @@
 
 import os from "node:os";
 import { join } from "node:path";
-import { findGitRoot } from "./git.ts";
+import { findProjectRoot } from "./git.ts";
+import { claudeUserDir } from "./paths.ts";
 
 /** Claude Code's project-directory slug: every char outside [A-Za-z0-9-] becomes "-". */
 export function projectSlug(projectRoot: string): string {
@@ -31,16 +32,18 @@ export function projectSlug(projectRoot: string): string {
  * worktrees and subdirectories share one memory directory), else the cwd.
  */
 export function memoryDir(home: string, projectRoot: string): string {
-	return join(home, ".claude", "projects", projectSlug(projectRoot), "memory");
+	return join(claudeUserDir(home), "projects", projectSlug(projectRoot), "memory");
 }
 
 /**
  * `memoryDir` composed with the actual project-root resolution every caller
- * needs: the git repository root when there is one (shared by worktrees and
- * subdirectories), else `cwd` itself. `home` defaults to `os.homedir()`.
+ * needs: the git repository root when there is one — a linked worktree
+ * (including a subagent's isolation worktree) resolves to its main checkout, so
+ * worktrees and subdirectories share one directory — else `cwd` itself. `home`
+ * defaults to `os.homedir()`.
  */
 export function projectMemoryDir(cwd: string, home: string = os.homedir()): string {
-	return memoryDir(home, findGitRoot(cwd) ?? cwd);
+	return memoryDir(home, findProjectRoot(cwd) ?? cwd);
 }
 
 /**
@@ -94,6 +97,38 @@ export const INDEX_NEAR_LIMIT_REMINDER = `MEMORY.md is approaching its load limi
 
 export const INDEX_OVER_LIMIT_ERROR = `MEMORY.md is over its load limit (${INDEX_MAX_LINES} lines / 25KB): everything past the limit is dropped the next time it is loaded. The write succeeded, but rewrite the index now — one line per entry, move detail into topic files, merge or drop stale entries.`;
 
+/**
+ * Claude Code's soft size limit for a context file (CLAUDE.md/AGENTS.md/ONECODE.md):
+ * over ~40k chars it warns at startup that the file is bloating the context, and
+ * points at `/memory` to trim it. Distinct from the MEMORY.md *index* load limit
+ * above — this is about the instruction files the model reads every turn.
+ */
+export const CLAUDE_MD_CHAR_LIMIT = 40_000;
+
+/**
+ * CC's over-limit warning for a context file, or null when within the limit.
+ * `name` is the file's basename (e.g. `CLAUDE.md`); `chars` is its length. The
+ * `N.Nk` rendering matches CC's "over the 40.0k-char limit (55.4k chars)".
+ */
+export function claudeMdLimitWarning(name: string, chars: number): string | null {
+	if (chars <= CLAUDE_MD_CHAR_LIMIT) return null;
+	const k = (n: number) => `${(n / 1000).toFixed(1)}k`;
+	return `${name} is over the ${k(CLAUDE_MD_CHAR_LIMIT)}-char limit (${k(chars)} chars) · /memory to free up context`;
+}
+
+/**
+ * The combined-size warning: when several instruction files each fit but together
+ * blow the budget. `totalChars` is the sum across every instruction file One Code
+ * sends (CLAUDE.md family / AGENTS.md fallback / ONECODE.md). Returns null within
+ * the limit. The caller suppresses this when a single file already tripped
+ * `claudeMdLimitWarning`, so a lone bloated file is named once, not twice.
+ */
+export function combinedLimitWarning(totalChars: number): string | null {
+	if (totalChars <= CLAUDE_MD_CHAR_LIMIT) return null;
+	const k = (n: number) => `${(n / 1000).toFixed(1)}k`;
+	return `Project instructions total ${k(totalChars)} chars, over the ${k(CLAUDE_MD_CHAR_LIMIT)}-char limit · /memory to free up context`;
+}
+
 /**
  * Claude Code stamps bookkeeping fields into a memory file's frontmatter at
  * write time: node_type, the writing session's id, and a modified timestamp
@@ -136,7 +171,7 @@ export function stampFrontmatter(content: string, sessionId: string, modifiedIso
  * tier), so the prompt stays byte-stable across turns for a given cwd.
  *
  * `verbose` selects the long, explicit spec (Claude Code's Haiku memory prompt,
- * adapted) for the mid/low tiers; frontier gets the compact version.
+ * adapted) for the workhorse/cheap/tiny tiers; frontier gets the compact version.
  */
 export function memoryPromptSection(dir: string, verbose = false): string {
 	return verbose ? verboseMemorySection(dir) : compactMemorySection(dir);