one-code-extension 0.4.1 → 0.6.0

package/extensions/lib/argument-hints.ts

@@ -0,0 +1,190 @@
+/**
+ * Claude Code's argument hint in the prompt: once the input is a slash command
+ * that takes an argument plus one space (`/btw `), a dim placeholder for it
+ * (`[question]`) follows the cursor until the user types the argument
+ * (findings §34). A command file with an `arguments` list and no
+ * `argument-hint` gets a progressive hint instead: the names not typed yet.
+ *
+ * pi shows an extension command's hint nowhere (its `registerCommand` has no
+ * hint field), so a command extension announces its hint on
+ * ARGUMENT_HINT_CHANNEL (`announceArgumentHint`, or `registerLocalCommand`'s
+ * `argumentHint` option) and the branding extension's prompt editor draws it.
+ * pi's own built-ins get theirs from PI_BUILTIN_HINTS.
+ *
+ * Every command that takes an argument has a hint: Claude Code's text where
+ * Claude Code has the same command, else our own syntax in its bracket style
+ * (`[optional]`, `<required>`). A command with no argument has none, as in
+ * Claude Code.
+ *
+ * Pure: no pi imports.
+ */
+
+import { visibleWidth } from "./tui-render.ts";
+
+export const ARGUMENT_HINT_CHANNEL = "one-code:argument-hint";
+
+export interface ArgumentHint extends CommandHint {
+	/** The command name, without the slash. */
+	command: string;
+}
+
+/** What the prompt knows about one command's argument. */
+export interface CommandHint {
+	/** The placeholder shown after `/<command> `, e.g. `[question]`. */
+	hint?: string;
+	/** A command file's `arguments` names, for the progressive hint. */
+	argNames?: string[];
+}
+
+/** The slice of pi's ExtensionAPI an announcement needs. */
+export interface HintEmitter {
+	events: { emit(channel: string, data: unknown): unknown };
+	on?(event: "session_start", handler: () => void): unknown;
+}
+
+/**
+ * Announce `/command`'s hint now and again at every `session_start`, so it
+ * reaches the prompt editor whether the command registers at load or during
+ * `session_start`. Repeats are harmless: the editor keeps one hint per command.
+ */
+export function announceArgumentHint(pi: HintEmitter, command: string, hint: string | CommandHint): void {
+	const payload: ArgumentHint = { command, ...(typeof hint === "string" ? { hint } : hint) };
+	const emit = () => pi.events.emit(ARGUMENT_HINT_CHANNEL, payload);
+	emit();
+	pi.on?.("session_start", emit);
+}
+
+/**
+ * pi's built-in commands that take an argument. Claude Code's text where it has
+ * the same command (`/model`, `/compact`, `/export`, and `/rename` for pi's
+ * `/name`); pi's own `argumentHint` otherwise.
+ */
+export const PI_BUILTIN_HINTS: Readonly<Record<string, string>> = {
+	model: "[model]",
+	compact: "<optional custom summarization instructions>",
+	export: "[filename]",
+	name: "[name]",
+	thinking: "<level>",
+	login: "<provider>",
+	bug: "<description>",
+};
+
+/**
+ * A command file's hint (a SKILL.md, a plugin or template command): its
+ * `argument-hint` string, and its `arguments` names (a space-separated string
+ * or a list; numeric names are dropped, as they clash with `$0`, `$1`).
+ * Undefined when it has neither.
+ */
+export function frontmatterCommandHint(frontmatter: Record<string, unknown> | undefined): CommandHint | undefined {
+	const raw = frontmatter?.["argument-hint"];
+	const hint = typeof raw === "string" && raw.trim() ? raw.trim() : undefined;
+	const names = frontmatter?.arguments;
+	const list = typeof names === "string" ? names.split(/\s+/) : Array.isArray(names) ? names : [];
+	const argNames = list.filter((n): n is string => typeof n === "string" && n.trim() !== "" && !/^\d+$/.test(n));
+	if (!hint && argNames.length === 0) return undefined;
+	return { ...(hint && { hint }), ...(argNames.length > 0 && { argNames }) };
+}
+
+/** The words typed so far, quotes grouping (Claude Code's `parseArguments`, minus shell expansion). */
+export function typedArguments(text: string): string[] {
+	return [...text.matchAll(/"([^"]*)"|'([^']*)'|(\S+)/g)].map((m) => m[1] ?? m[2] ?? m[3]);
+}
+
+/**
+ * The placeholder to draw after the cursor for the editor's `text`, or
+ * undefined. Claude Code's rule: the input is `/<command> ` and nothing more
+ * shows the command's hint; failing that, a command with `arguments` names
+ * shows the names not typed yet whenever the input ends in a space.
+ */
+export function hintForInput(text: string, commands: ReadonlyMap<string, CommandHint>): string | undefined {
+	if (!text.startsWith("/")) return undefined;
+	const space = text.indexOf(" ");
+	if (space === -1) return undefined;
+	const command = commands.get(text.slice(1, space));
+	if (!command) return undefined;
+	if (command.hint && text.length === space + 1) return command.hint;
+	if (command.argNames?.length && text.endsWith(" ")) {
+		const remaining = command.argNames.slice(typedArguments(text.slice(space + 1)).length);
+		return remaining.length > 0 ? remaining.map((name) => `[${name}]`).join(" ") : undefined;
+	}
+	return undefined;
+}
+
+/** The fake end-of-text cursor pi-tui's editor draws: an inverse space. */
+const END_CURSOR = "\x1b[7m \x1b[0m";
+
+/**
+ * The editor's rendered lines with `placeholder` (already painted; its visible
+ * width is measured) drawn into the blank padding after the end-of-text cursor
+ * on the first content line. The line keeps its width. No-op when there is no
+ * end cursor on that line or too little padding after it, so an unexpected
+ * render shape shows no hint rather than a corrupted line.
+ */
+export function applyArgumentHint(lines: string[], placeholder: string): string[] {
+	const line = lines[1];
+	if (line === undefined) return lines;
+	const at = line.lastIndexOf(END_CURSOR);
+	if (at === -1) return lines;
+	const tail = line.slice(at + END_CURSOR.length);
+	const width = visibleWidth(placeholder);
+	if (!/^ *$/.test(tail.slice(0, width)) || tail.length < width) return lines;
+	const out = lines.slice();
+	out[1] = line.slice(0, at + END_CURSOR.length) + placeholder + tail.slice(width);
+	return out;
+}
+
+/** One argument completion, as pi's `getArgumentCompletions` returns them. */
+export interface ArgumentCompletion {
+	value: string;
+	label: string;
+	description?: string;
+}
+
+/**
+ * The completions that extend what was typed, or null to close the menu. pi's
+ * editor answers Enter on an open argument menu by applying the selection,
+ * not by submitting, so offering the value already typed in full (`/doctor
+ * report`) took a second Enter to run the command; an exact match is left
+ * out, and with nothing longer the menu stays shut and Enter submits.
+ */
+export function extendingCompletions(prefix: string, options: readonly ArgumentCompletion[]): ArgumentCompletion[] | null {
+	const typed = prefix.trim().toLowerCase();
+	return dropExactMatch(prefix, options.filter((option) => option.value.startsWith(typed)));
+}
+
+/**
+ * When an item's value is exactly what was typed (case-blind), only the items
+ * that extend it, or null when none does: Enter then submits the typed
+ * argument instead of applying some other item a completer returned without
+ * filtering (`/auto-mode`). A value is compared as given, so a completion that
+ * carries the separator to a required next argument (`"stop "`) still extends
+ * a typed `stop`. With no exact item, `items` pass unchanged.
+ */
+export function dropExactMatch<T extends { value: string }>(prefix: string | undefined, items: readonly T[]): T[] | null {
+	const typed = (prefix ?? "").trim().toLowerCase();
+	if (!items.some((item) => item.value.toLowerCase() === typed)) return items.length ? [...items] : null;
+	const longer = items.filter((item) => {
+		const value = item.value.toLowerCase();
+		return value !== typed && value.startsWith(typed);
+	});
+	return longer.length ? longer : null;
+}
+
+type Completer<T extends { value: string }> = (prefix: string) => T[] | null | Promise<T[] | null>;
+
+/**
+ * A command's completer with the exact match left out (see
+ * `extendingCompletions`), so a fully typed argument runs on the first Enter.
+ * `registerLocalCommand` applies it to every local command.
+ */
+export function withoutExactMatch<T extends { value: string }>(complete: Completer<T>): Completer<T> {
+	const settle = (prefix: string, items: T[] | null): T[] | null => (items ? dropExactMatch(prefix, items) : items);
+	return (prefix) => {
+		const items = complete(prefix);
+		// Any thenable, not only a native Promise.
+		if (items && typeof (items as PromiseLike<T[] | null>).then === "function") {
+			return Promise.resolve(items).then((resolved) => settle(prefix, resolved));
+		}
+		return settle(prefix, items as T[] | null);
+	};
+}

package/extensions/lib/atomic-write.ts

@@ -1,5 +1,5 @@
 /**
- * Atomic JSON file writes (pure fs, no pi imports).
+ * Atomic JSON and text file writes (pure fs, no pi imports).
  *
  * Write to a temp sibling, then rename over the target — a reader never sees a
  * partially written file, and a crash mid-write leaves the target untouched.
@@ -14,9 +14,13 @@ import { dirname } from "node:path";
 let sequence = 0;
 
 export function writeJsonAtomic(path: string, data: unknown, options: { mode?: number } = {}): void {
+	writeTextAtomic(path, `${JSON.stringify(data, null, 2)}\n`, options);
+}
+
+export function writeTextAtomic(path: string, text: string, options: { mode?: number } = {}): void {
 	mkdirSync(dirname(path), { recursive: true });
 	const tmp = `${path}.tmp-${process.pid}-${++sequence}`;
-	writeFileSync(tmp, `${JSON.stringify(data, null, 2)}\n`, options.mode !== undefined ? { mode: options.mode } : undefined);
+	writeFileSync(tmp, text, options.mode !== undefined ? { mode: options.mode } : undefined);
 	renameSync(tmp, path);
 }
 

package/extensions/lib/auto-memory.ts

@@ -0,0 +1,75 @@
+/**
+ * Whether auto-memory is on: Claude Code's `autoMemoryEnabled` setting and its
+ * `CLAUDE_CODE_DISABLE_AUTO_MEMORY` override (pure fs, no pi imports).
+ *
+ * Off means the system prompt has no memory section, the MEMORY.md index is
+ * not loaded, and the memory folder is neither created nor offered by
+ * `/memory`. The `/memory` panel's "Auto-memory" row toggles the setting in
+ * One Code's user settings. The value is read once and pinned for the
+ * process, like the config mode: the system prompt must stay byte-stable, so
+ * a change applies from the next start.
+ */
+
+import os from "node:os";
+import { readSettingsFile, settingsSources } from "./claude-settings.ts";
+
+/** The settings key, as Claude Code spells it. */
+export const AUTO_MEMORY_KEY = "autoMemoryEnabled";
+export const AUTO_MEMORY_ENV = "CLAUDE_CODE_DISABLE_AUTO_MEMORY";
+
+const TRUTHY = new Set(["1", "true", "yes", "on"]);
+const FALSY = new Set(["0", "false", "no", "off"]);
+
+/**
+ * What `CLAUDE_CODE_DISABLE_AUTO_MEMORY` decides: a truthy value turns
+ * auto-memory off, a defined falsy one forces it on, anything else leaves it
+ * to the settings.
+ */
+export function autoMemoryFromEnv(env: Record<string, string | undefined> = process.env): boolean | undefined {
+	const raw = env[AUTO_MEMORY_ENV]?.trim().toLowerCase();
+	if (raw === undefined || raw === "") return undefined;
+	if (TRUTHY.has(raw)) return false;
+	if (FALSY.has(raw)) return true;
+	return undefined;
+}
+
+/**
+ * `autoMemoryEnabled` from the settings ladder the mode reads (the last file
+ * that sets it wins, managed policy last), ignoring the env override.
+ * Default on.
+ */
+export function savedAutoMemory(cwd: string, home: string = os.homedir()): boolean {
+	return savedAutoMemorySource(cwd, home).enabled;
+}
+
+/** `savedAutoMemory` and the settings file that decides it (undefined: the default). */
+export function savedAutoMemorySource(cwd: string, home: string = os.homedir()): { enabled: boolean; path?: string } {
+	let decided: { enabled: boolean; path?: string } = { enabled: true };
+	for (const [, path] of settingsSources(cwd, home)) {
+		const value = readSettingsFile(path)?.[AUTO_MEMORY_KEY];
+		if (typeof value === "boolean") decided = { enabled: value, path };
+	}
+	return decided;
+}
+
+export function readAutoMemory(cwd: string, home: string = os.homedir(), env: Record<string, string | undefined> = process.env): boolean {
+	return autoMemoryFromEnv(env) ?? savedAutoMemory(cwd, home);
+}
+
+const AUTO_MEMORY_SLOT = Symbol.for("one-code:auto-memory");
+
+/**
+ * Whether auto-memory is on for this process: read once (for the first
+ * session's cwd), then pinned for every extension. Tests that need the other
+ * value call `resetAutoMemoryForTest` first.
+ */
+export function autoMemoryEnabled(cwd: string = process.cwd()): boolean {
+	const slot = globalThis as { [AUTO_MEMORY_SLOT]?: boolean };
+	return (slot[AUTO_MEMORY_SLOT] ??= readAutoMemory(cwd));
+}
+
+export function resetAutoMemoryForTest(enabled?: boolean): void {
+	const slot = globalThis as { [AUTO_MEMORY_SLOT]?: boolean };
+	if (enabled === undefined) delete slot[AUTO_MEMORY_SLOT];
+	else slot[AUTO_MEMORY_SLOT] = enabled;
+}

package/extensions/lib/bash-parser.ts

@@ -0,0 +1,84 @@
+/**
+ * The tree-sitter bash grammar, loaded once per process (pure apart from
+ * loading the WASM files).
+ *
+ * Loading is asynchronous (about 5 ms: the web-tree-sitter runtime, then the
+ * grammar); parsing after that is synchronous, so the permission gate and the
+ * guards stay synchronous. Loading starts when this module is first imported.
+ * A hook that parses awaits {@link bashParserReady} first; until the promise
+ * settles, and forever if loading failed, {@link parseBash} returns undefined
+ * and every caller treats the command as unparseable (findings §30).
+ *
+ * The loaded parser lives on `globalThis`, not in module state: jiti gives
+ * each extension its own instance of this module (findings §3), and five
+ * extensions parse bash. It is a cache of a pure function, so sharing it
+ * changes no behaviour, only how often the grammar is loaded.
+ *
+ * The grammar file is tree-sitter-bash's release WASM, vendored under
+ * `grammars/` (MIT, `grammars/LICENSE-tree-sitter-bash`): the npm package
+ * builds a native addon on install, which this package never uses.
+ */
+
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { Language, Parser, type Tree } from "web-tree-sitter";
+
+interface BashParserState {
+	ready: Promise<void>;
+	parser?: Parser;
+	/** Why loading failed, once it has. */
+	error?: string;
+}
+
+const STATE_KEY = Symbol.for("one-code.bash-parser");
+
+const GRAMMAR_PATH = join(dirname(fileURLToPath(import.meta.url)), "grammars", "tree-sitter-bash.wasm");
+
+function state(): BashParserState {
+	const store = globalThis as { [STATE_KEY]?: BashParserState };
+	let current = store[STATE_KEY];
+	if (!current) {
+		const created: BashParserState = { ready: Promise.resolve() };
+		created.ready = load(created);
+		store[STATE_KEY] = created;
+		current = created;
+	}
+	return current;
+}
+
+async function load(target: BashParserState): Promise<void> {
+	try {
+		const runtimeWasm = createRequire(import.meta.url).resolve("web-tree-sitter/web-tree-sitter.wasm");
+		await Parser.init({ locateFile: () => runtimeWasm });
+		const parser = new Parser();
+		parser.setLanguage(await Language.load(GRAMMAR_PATH));
+		target.parser = parser;
+	} catch (error) {
+		target.error = `the bash grammar failed to load (${error instanceof Error ? error.message : String(error)})`;
+	}
+}
+
+// Start loading on import, so the grammar is ready long before the first
+// tool call; hooks still await it.
+state();
+
+/** Settles once the grammar has loaded or failed to load. Never rejects. */
+export function bashParserReady(): Promise<void> {
+	return state().ready;
+}
+
+/** Why the grammar is unavailable: still loading, or the load error. Undefined once it is ready. */
+export function bashParserUnavailable(): string | undefined {
+	const current = state();
+	if (current.parser) return undefined;
+	return current.error ?? "the bash grammar is still loading";
+}
+
+/**
+ * Parse `command` into a syntax tree, or undefined when the grammar is not
+ * loaded. The caller must `delete()` the tree: it lives in WASM memory.
+ */
+export function parseBash(command: string): Tree | undefined {
+	return state().parser?.parse(command) ?? undefined;
+}

package/extensions/lib/btw-fork.ts

@@ -0,0 +1,93 @@
+/**
+ * The `/btw` panel's `f to fork` request, sent to the subagents extension over
+ * pi.events (extensions share no module state). Claude Code's key spawns a
+ * fork subagent: it inherits the conversation, then the side question and its
+ * answer, takes the question as its task, runs in the background and reports
+ * back as a task notification.
+ *
+ * The subagents extension sets `handled` synchronously inside its listener, so
+ * the emitter can tell "nobody listens" (the extension is not loaded) from a
+ * fork still starting; `respond` settles the request once.
+ */
+
+import { randomBytes } from "node:crypto";
+import type { Message } from "@earendil-works/pi-ai";
+import { commandInputBlock, commandStdoutBlock } from "./local-command.ts";
+import { cutPlainText } from "./tui-render.ts";
+
+export const BTW_FORK_CHANNEL = "one-code:btw-fork";
+
+/** The started fork, or why it could not start. */
+export type BtwForkResult = { name: string; taskId: string } | { error: string };
+
+export interface BtwForkRequest {
+	/** The command context of the open panel (the listener reads cwd, session and model from it). */
+	ctx: unknown;
+	/** The side question: the fork's task. */
+	question: string;
+	/** The question and answer, appended to the fork's inherited conversation. */
+	messages: Message[];
+	/** Set by the listener before it returns. */
+	handled?: boolean;
+	respond: (result: BtwForkResult) => void;
+}
+
+/** Emit a fork request and wait for its answer; an error result when no listener took it. */
+export function requestBtwFork(
+	events: { emit(channel: string, data: unknown): void },
+	request: Omit<BtwForkRequest, "respond" | "handled">,
+): Promise<BtwForkResult> {
+	return new Promise((resolve) => {
+		const payload: BtwForkRequest = { ...request, respond: resolve };
+		events.emit(BTW_FORK_CHANNEL, payload);
+		if (!payload.handled) resolve({ error: "Forking needs the subagents extension, which is not loaded." });
+	});
+}
+
+/**
+ * The fork's base name, Claude Code's rule: the question's first three words,
+ * hyphen-joined, lowercased, cut to `[a-z0-9-]` and 24 characters; `fork`
+ * when nothing is left. "does reading outside project…" becomes
+ * `does-reading-outside`. A taken name is suffixed by the caller.
+ */
+export function btwForkName(question: string): string {
+	const slug = question
+		.trim()
+		.split(/\s+/)
+		.slice(0, 3)
+		.join("-")
+		.toLowerCase()
+		.replace(/[^a-z0-9-]/g, "")
+		.replace(/-+/g, "-")
+		.replace(/^-|-$/g, "")
+		.slice(0, 24);
+	return slug || "fork";
+}
+
+/** Claude Code's transcript line for a started fork: `⑂ forked <name> (<last 4 of the id>)`. */
+export function btwForkedLine(name: string, taskId: string): string {
+	return `⑂ forked ${name} (${taskId.slice(-4)})`;
+}
+
+/**
+ * A fork's task description, Claude Code's rule (findings §29): the question
+ * with whitespace collapsed, cut to 49 characters plus `…` past 50.
+ */
+export function btwForkDescription(question: string): string {
+	return cutPlainText(question.trim().replace(/\s+/g, " "), 50);
+}
+
+/**
+ * What the main conversation is told when a fork starts: Claude Code's
+ * local-command breadcrumb for `/btw <question>` and its stdout, the forked
+ * line (findings §40), as two bare text blocks on the next user message. No
+ * caveat block precedes them, unlike other local commands.
+ */
+export function btwForkRecord(name: string, taskId: string, question: string): string[] {
+	return [commandInputBlock("btw", question.trim()), commandStdoutBlock(btwForkedLine(name, taskId))];
+}
+
+/** A fork's task id, Claude Code's shape: `a<name>-<16 hex>` (`awhat-word-is-477c2d9e80467f14`). */
+export function btwForkTaskId(name: string): string {
+	return `a${name}-${randomBytes(8).toString("hex")}`;
+}

package/extensions/lib/child-extensions.ts

@@ -0,0 +1,52 @@
+/**
+ * The curated extensions every in-process child session loads: a subagent
+ * (subagents/runner.ts) and a workflow agent (workflow/agent-session.ts) alike.
+ * They go in through `additionalExtensionPaths`, which the loader loads even
+ * under `noExtensions`. Broadly Claude Code's model: a child gets project
+ * context, file freshness and a working toolset (search, skills, web, notebook),
+ * but NOT the frontier chrome (banner, spinner, recap) or the orchestration
+ * extensions. Nested spawning is an injected tool instead (subagents/index.ts).
+ *
+ * `lsp` is deliberately NOT here (matching Claude Code, findings §17.3): a child
+ * session is torn down with the raw `AgentSession.dispose()`, which never fires
+ * `session_shutdown`, so lsp's cleanup would never run and any language server
+ * it started would leak for the life of the parent session. MCP is not listed
+ * either: its tools are shared in from the parent as customTools
+ * (lib/mcp-share.ts `watchMcpTools`), not reconnected.
+ *
+ * Order mirrors the package's load order: kept-thinking first (the first
+ * `context` hook, before anything reads the messages), the ledger's request
+ * side next (it cuts the request to its tail before anything injects), then
+ * the reminder and deferral sinks (system-reminder, tool-search), before
+ * anything emitting on their channels (the bus does not replay), then
+ * context-management and compaction as in the main session (a child's requests
+ * carry the same thinking edit, and a fork that crosses its threshold is
+ * summarized by replaying its own last request, not by pi's uncached default
+ * summarizer), then the ledger's payload side, after every hook that shapes
+ * the tail and before cache-marks. A child has its own event bus (pi's
+ * resource loader makes one per loader), so its captures never reach the
+ * parent's side calls. A fork's file is a copy of the parent's, records included, so
+ * its first request extends the parent's last one and reads its cache. A caller that loads these must set the
+ * loader's `noContextFiles`, because claude-context injects `# claudeMd` itself.
+ */
+
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const EXTENSIONS_DIR = join(dirname(fileURLToPath(import.meta.url)), "..");
+
+// A name with a slash is a child-specific entry file: `tool-call-corruption/child`
+// blocks damaged OpenRouter calls like the main session's, before the hook and
+// permission gates (which load after these paths), but prints nothing. The
+// shell tools are One Code's, as in the main session: without them a child ran
+// pi's built-in bash (timeout in seconds, no default) while a fork advertised
+// ours (milliseconds), and had no PowerShell tool. A child binds without a UI
+// (mode "print"), so `run_in_background` runs blocking there and nothing a
+// child starts outlives it (Claude Code kills an agent's shells as it exits).
+export const CHILD_EXTENSIONS = [
+	"kept-thinking", "ledger", "system-reminder", "tool-search", "context-management", "compaction", "ledger/wire", "cache-marks", "claude-context", "tool-call-corruption/child",
+	"file-tracker", "search-tools", "skill", "bash/child", "powershell/child", "web", "web-fetch", "notebook",
+];
+
+export const CHILD_EXTENSION_PATHS = CHILD_EXTENSIONS.map((name) =>
+	name.includes("/") ? join(EXTENSIONS_DIR, `${name}.ts`) : join(EXTENSIONS_DIR, name, "index.ts"));

package/extensions/lib/child-writes.ts

@@ -0,0 +1,45 @@
+/**
+ * A subagent's or workflow agent's file edits, announced to the parent session.
+ *
+ * An in-process child keeps its own file tracker, so a file the parent read and
+ * a child then edited looks to the parent like a change "on disk" by someone
+ * else, and the parent's notice said so (the user, a formatter, a command).
+ * The child runners publish each successful edit, write or notebook edit on
+ * the parent's bus; the parent's file-tracker names the child in its notice
+ * instead. The file stays stale either way, so the parent still re-reads
+ * before editing it.
+ */
+
+import { isWritingTool, pathArgument } from "../auto-mode/paths.ts";
+import { resolveToolPath } from "./tool-path.ts";
+
+export const CHILD_WROTE_CHANNEL = "one-code:child-wrote";
+
+export interface ChildWrote {
+	/** Absolute path of the file the child changed. */
+	path: string;
+	/** The child's name or description, for the notice; undefined when unknown. */
+	agent?: string;
+}
+
+/**
+ * Tracks a child session's tool calls and returns the changed file when one of
+ * its file-writing calls (edit, write, notebook_edit) ends without an error,
+ * resolved as the child's tools resolved it (lib/tool-path.ts), which is how
+ * the parent's file-tracker keys it.
+ */
+export function childWriteWatcher(cwd: string) {
+	const started = new Map<string, string>();
+	return (event: { type?: string; toolName?: string; toolCallId?: string; args?: unknown; isError?: boolean }): string | undefined => {
+		if (!event.toolCallId || !event.toolName || !isWritingTool(event.toolName)) return undefined;
+		if (event.type === "tool_execution_start") {
+			const path = pathArgument(event.args as Record<string, unknown> | undefined);
+			if (path) started.set(event.toolCallId, resolveToolPath(path, cwd));
+			return undefined;
+		}
+		if (event.type !== "tool_execution_end") return undefined;
+		const path = started.get(event.toolCallId);
+		started.delete(event.toolCallId);
+		return event.isError ? undefined : path;
+	};
+}