one-code-extension 0.4.1 → 0.6.0

package/extensions/background/switch-guard.ts

@@ -0,0 +1,56 @@
+/**
+ * What a session switch or quit would stop (pure). Running background tasks and
+ * scheduled jobs belong to the session: `/clear`, `/new`, `/resume`, a fork and
+ * quitting stop them. A `/reload` stops the running tasks only: it keeps the
+ * conversation, so the scheduled jobs come back from the branch
+ * (background/index.ts `armFromBranch`). pi lets an extension cancel a switch
+ * (`session_before_switch`, `session_before_fork`), so a switch asks first;
+ * reloading and quitting have no such hook, so the standing widget line says
+ * it up front.
+ */
+
+/** A running task or scheduled job, as the dialog and widget name it. */
+export interface SessionWork {
+	id: string;
+	label: string;
+}
+
+export const SWITCH_CANCEL = "Cancel";
+export const SWITCH_STOP = "Stop them and continue";
+
+/** At most this many items are named in the dialog; the rest are counted. */
+const MAX_NAMED = 6;
+
+const plural = (n: number, word: string) => `${n} ${word}${n === 1 ? "" : "s"}`;
+
+function counts(tasks: number, jobs: number): string {
+	const parts = [tasks > 0 ? plural(tasks, "background task") : "", jobs > 0 ? plural(jobs, "scheduled job") : ""].filter(Boolean);
+	return parts.join(" and ");
+}
+
+/**
+ * The confirm dialog's title, or undefined when nothing would be stopped.
+ * `action` names the switch ("Starting a new session"): pi reports /clear and
+ * /new alike, so the dialog cannot name the command.
+ */
+export function switchWarning(tasks: readonly SessionWork[], jobs: readonly SessionWork[], action: string): string | undefined {
+	if (tasks.length === 0 && jobs.length === 0) return undefined;
+	const items = [...tasks, ...jobs];
+	const named = items.slice(0, MAX_NAMED).map((item) => `  ${item.id}  ${item.label}`);
+	if (items.length > MAX_NAMED) named.push(`  … and ${items.length - MAX_NAMED} more`);
+	const one = items.length === 1;
+	const them = one ? "it" : "them";
+	return [
+		`${counts(tasks.length, jobs.length)} ${one ? "is" : "are"} still active. ${action} stops ${them}:`,
+		named.join("\n"),
+		tasks.length > 0 ? `Cancel to keep ${them} running; /tasks opens or stops a task.` : `Cancel to keep ${them}.`,
+	].join("\n\n");
+}
+
+/** The standing widget line while anything runs, or undefined when nothing does. */
+export function workWidgetLine(tasks: number, jobs: number): string | undefined {
+	if (tasks === 0 && jobs === 0) return undefined;
+	// A /reload stops only the running tasks; the jobs re-arm from the branch.
+	const stoppedBy = jobs === 0 ? "/clear, /reload or quitting" : tasks === 0 ? "/clear or quitting" : "/clear or quitting, the tasks by /reload too";
+	return ` ${counts(tasks, jobs)} · stopped by ${stoppedBy}${tasks > 0 ? " · /tasks to manage" : ""}`;
+}

package/extensions/background/wakeup.ts

@@ -1,80 +1,203 @@
 /**
- * schedule_wakeup helpers (pure) — Claude Code's self-paced /loop timer.
+ * schedule_wakeup (pure): Claude Code's self-paced `/loop` timer, 2.1.282
+ * (findings §21). A wakeup is a one-shot job in the session's CronStore
+ * (source "wakeup"), so cron_list shows it and
+ * one timer fires everything. Its cron names the target minute
+ * (`M H * * *`); the fire itself is the exact target time.
  *
- * A fired wakeup or loop tick is a RE-INVOCATION, not a notification: Claude
- * Code enqueues the scheduled prompt verbatim as the next turn's input, behind
- * a dim "Running scheduled task" line in the TUI (findings §21), so the model
- * reads its own task back exactly as it wrote it. These builders therefore
- * return the prompt as-is; the TUI shows the line (`scheduledTaskComponent`).
+ * `DynamicLoop` is Claude Code's loop core: one pending wakeup (a new one
+ * supersedes the rest), a 7-day age per prompt, `stop` cancelling every
+ * wakeup, and the keepalive: a turn that ran a wakeup and ended without
+ * scheduling the next gets one 1200 s fallback, and a second miss ends the
+ * loop. Texts are Claude Code's with our tool names.
  */
 
+import { type CronStore, RECURRING_MAX_AGE_MS } from "./cron.ts";
+
 export const MIN_DELAY_SECONDS = 60;
 export const MAX_DELAY_SECONDS = 3600;
+/** Claude Code's keepalive fallback delay and budget. */
+export const KEEPALIVE_DELAY_SECONDS = 1200;
+export const KEEPALIVE_BUDGET = 1;
 
 export function clampDelaySeconds(delay: number): number {
 	if (!Number.isFinite(delay)) return MIN_DELAY_SECONDS;
 	return Math.min(MAX_DELAY_SECONDS, Math.max(MIN_DELAY_SECONDS, Math.round(delay)));
 }
 
-export interface WakeupRequest {
-	delaySeconds: number;
-	prompt: string;
-	reason: string;
-	/** Nothing changed this tick (matches CC's /loop noop flag). Recorded for callers; no effect on scheduling. */
-	noop?: boolean;
+/** An env flag as Claude Code reads a boolean: unset is `fallback`, a false-like value is off. */
+export function envFlag(value: string | undefined, fallback: boolean): boolean {
+	if (value === undefined) return fallback;
+	return !["", "0", "false", "no", "off"].includes(value.trim().toLowerCase());
 }
 
-export interface ParsedLoop {
-	/** undefined = dynamic (model self-paces via schedule_wakeup); set = fixed interval. */
-	intervalSeconds?: number;
-	task: string;
+/** Keepalive is on unless `CLAUDE_CODE_LOOP_KEEPALIVE` turns it off. */
+export function keepaliveEnabled(env: NodeJS.ProcessEnv = process.env): boolean {
+	return envFlag(env.CLAUDE_CODE_LOOP_KEEPALIVE, true);
 }
 
-/**
- * Parse `/loop` arguments: a leading duration token (`5m`, `30s`, `2h`) selects
- * fixed-interval mode and the rest is the task; no duration selects dynamic
- * (self-paced) mode. `stop` / `status` are handled by the caller, not here.
- */
-export function parseLoopArgs(raw: string): ParsedLoop {
-	const m = raw.trim().match(/^(\d+)\s*(s|m|h)\b\s*([\s\S]*)$/i);
-	if (m) {
-		const n = Number(m[1]);
-		const unit = m[2].toLowerCase();
-		const seconds = unit === "h" ? n * 3600 : unit === "m" ? n * 60 : n;
-		return { intervalSeconds: seconds, task: m[3].trim() };
-	}
-	return { task: raw.trim() };
+export interface WakeupSchedule {
+	scheduledFor: number;
+	clampedDelaySeconds: number;
+	wasClamped: boolean;
+	/** The store's job id, so a cron_delete of it is matched when the branch is replayed. */
+	jobId?: string;
+	/** When this prompt's loop started: its age carries across a /reload. */
+	startedAt: number;
 }
 
-/** The turn input a fixed-interval `/loop` tick delivers: the task, verbatim (CC's cron fire). */
-export function buildLoopMessage(task: string): string {
-	return task;
+interface PromptAge {
+	startedAt: number;
+	lastScheduledFor: number;
+	agedOut?: boolean;
 }
 
-/**
- * The opening turn of a dynamic (self-paced) `/loop`: the user's command, so it
- * reads as their instruction — drive schedule_wakeup, pass the task back each
- * time. Unframed: it is the user's `/loop`, not a harness event.
- */
-export function buildDynamicLoopPrompt(task: string): string {
-	return [
-		"Self-paced loop started. Work the task below now. When this iteration is done, call schedule_wakeup to schedule the next one — choose delaySeconds by what you're waiting for, and pass the same task back as `prompt`. End the loop with schedule_wakeup {stop: true} when the task is complete or the user says to stop.",
-		"",
-		task,
-	].join("\n");
+export class DynamicLoop {
+	/** The wakeup prompt whose turn is running, for the keepalive (Claude Code's in-flight tick). */
+	inFlight: string | null = null;
+	private misses = 0;
+	private readonly ages = new Map<string, PromptAge>();
+
+	constructor(
+		private readonly store: CronStore,
+		private readonly maxAgeMs = RECURRING_MAX_AGE_MS,
+	) {}
+
+	/** When the loop for `prompt` started, if it is running. */
+	chainStart(prompt: string): number | undefined {
+		return this.ages.get(prompt)?.startedAt;
+	}
+
+	/** A pending wakeup exists. */
+	hasPending(): boolean {
+		return this.store.list().some((job) => job.source === "wakeup");
+	}
+
+	/**
+	 * Claude Code's shared scheduling step: null when the loop for this prompt
+	 * is past its maximum age, which ends it.
+	 */
+	schedule(delaySeconds: number, prompt: string, now: number, viaKeepalive = false): WakeupSchedule | null {
+		if (!viaKeepalive) this.misses = 0;
+		this.store.deleteWhere((job) => job.source === "wakeup");
+		const age = this.ages.get(prompt);
+		const stale = age !== undefined && now > age.lastScheduledFor + MAX_DELAY_SECONDS * 1000;
+		const startedAt = age === undefined || stale ? now : age.startedAt;
+		if (this.maxAgeMs > 0 && now - startedAt >= this.maxAgeMs) {
+			if (!age?.agedOut) this.ages.set(prompt, { startedAt, lastScheduledFor: now - (MAX_DELAY_SECONDS - MIN_DELAY_SECONDS) * 1000, agedOut: true });
+			return null;
+		}
+		const clamped = clampDelaySeconds(delaySeconds);
+		const wasClamped = !(delaySeconds >= MIN_DELAY_SECONDS && delaySeconds <= MAX_DELAY_SECONDS);
+		const scheduledFor = now + clamped * 1000;
+		const target = new Date(scheduledFor);
+		const created = this.store.create({ cron: `${target.getMinutes()} ${target.getHours()} * * *`, prompt, recurring: false, source: "wakeup", fireAt: scheduledFor }, now);
+		this.ages.set(prompt, { startedAt, lastScheduledFor: scheduledFor });
+		if (viaKeepalive) this.misses++;
+		return { scheduledFor, clampedDelaySeconds: clamped, wasClamped, startedAt, ...(created.ok ? { jobId: created.job.id } : {}) };
+	}
+
+	/**
+	 * Take back a pending wakeup's loop state from the branch (a /reload, a
+	 * /tree switch): its age, and whether the keepalive armed it, which spends
+	 * the loop's one fallback.
+	 */
+	restoreChain(prompt: string, startedAt: number, scheduledFor: number, viaKeepalive: boolean): void {
+		this.ages.set(prompt, { startedAt, lastScheduledFor: scheduledFor });
+		this.misses = viaKeepalive ? 1 : 0;
+	}
+
+	/**
+	 * `stop: true`: cancel every pending wakeup; the count is the result's.
+	 * The cancelled prompts and the one in flight forget their age, so a
+	 * restarted loop gets a fresh 7 days (Claude Code's `forgetChainStart`).
+	 */
+	stop(): number {
+		const cancelled = this.store.deleteWhere((job) => job.source === "wakeup");
+		for (const job of cancelled) this.ages.delete(job.prompt);
+		if (this.inFlight !== null) this.ages.delete(this.inFlight);
+		this.inFlight = null;
+		this.misses = 0;
+		return cancelled.length;
+	}
+
+	/**
+	 * A turn ended. When it ran a wakeup and left none pending, re-arm once at
+	 * the keepalive delay; past the budget the loop ends.
+	 */
+	settle(now: number, keepalive = keepaliveEnabled()): "none" | "armed" | "ended" {
+		const prompt = this.inFlight;
+		this.inFlight = null;
+		if (prompt === null || !keepalive || this.hasPending()) return "none";
+		if (this.misses >= KEEPALIVE_BUDGET) return "ended";
+		return this.schedule(KEEPALIVE_DELAY_SECONDS, prompt, now, true) ? "armed" : "ended";
+	}
+
+	clear(): void {
+		this.inFlight = null;
+		this.misses = 0;
+		this.ages.clear();
+	}
 }
 
-/** The turn input a fired wakeup delivers: the scheduled prompt, verbatim (CC re-invokes with it). */
-export function buildWakeupMessage(request: WakeupRequest): string {
-	return request.prompt;
+// ── Model-facing text (Claude Code 2.1.282, our tool names) ────────────────
+
+export function formatScheduled(result: WakeupSchedule, now: number): string {
+	const at = new Date(result.scheduledFor).toTimeString().slice(0, 8);
+	const inSeconds = Math.max(0, Math.round((result.scheduledFor - now) / 1000));
+	const clamped = result.wasClamped ? ` (clamped to ${result.clampedDelaySeconds}s from your requested value)` : "";
+	return `Next wakeup scheduled for ${at} (in ${inSeconds}s)${clamped}. Nothing more to do this turn — the harness re-invokes you when the wakeup fires or a task-notification arrives.`;
 }
 
-export function describeSchedule(request: WakeupRequest): string {
-	const clamped = clampDelaySeconds(request.delaySeconds);
-	const minutes = Math.round((clamped / 60) * 10) / 10;
-	const adjusted =
-		clamped !== request.delaySeconds
-			? ` (adjusted from ${request.delaySeconds}s — the allowed range is ${MIN_DELAY_SECONDS}-${MAX_DELAY_SECONDS}s)`
-			: "";
-	return `Wake-up scheduled in ${clamped}s (~${minutes}min)${adjusted}: ${request.reason}`;
+export const AGED_OUT_RESULT = "Wakeup not scheduled. The loop reached its maximum duration — the loop has ended; do not re-issue.";
+
+export function formatStopped(cancelled: number): string {
+	const monitor = "If you armed a monitor for this loop, task_stop it now; otherwise nothing more to do this turn.";
+	if (cancelled === 0) {
+		return `Loop stopped — any dynamic loop in this session is ended; there was no pending wakeup to cancel. If you are running a fixed-interval /loop (a recurring cron), it is NOT stopped by this call — cancel it with cron_delete. ${monitor}`;
+	}
+	return `Loop stopped — cancelled ${cancelled} pending wakeup(s); no further dynamic-loop wakeups scheduled. ${monitor}`;
 }
+
+export const WAKEUP_ERRORS = {
+	delayAndReason: "`delaySeconds` and `reason` are required when `stop` is not true.",
+	prompt: "`prompt` is required when `stop` is not true.",
+	noop: "`noop` is required when `stop` is not true.",
+} as const;
+
+/**
+ * Claude Code's description for a session whose prompt-cache TTL it cannot
+ * name (its third branch): One Code runs on any provider, so the 1-hour and
+ * 5-minute branches, which assume Anthropic billing, never apply as such.
+ */
+export const SCHEDULE_WAKEUP_DESCRIPTION = `Schedule when to resume work in /loop dynamic mode — the user invoked /loop without an interval, asking you to self-pace iterations of a specific task.
+
+Do NOT schedule a short-interval wakeup to poll for background work you started — when harness-tracked work finishes, you are re-invoked automatically, so polling is wasted. Instead schedule a long fallback (1200s+) so the loop survives if the work hangs or never notifies. The exception is external work the harness cannot track (a CI run, a deploy, a remote queue) — there, pick a delay matched to how fast that state actually changes.
+
+Pass the same /loop prompt back via \`prompt\` each turn so the next firing repeats the task. For an autonomous /loop (no user prompt), pass the literal sentinel \`<<autonomous-loop-dynamic>>\` as \`prompt\` instead — the runtime resolves it back to the autonomous-loop instructions at fire time. (There is a similar \`<<autonomous-loop>>\` sentinel for cron_create-based autonomous loops; do not confuse the two — schedule_wakeup always uses the \`-dynamic\` variant.) To end the loop, call this tool with \`stop: true\` (omit every other field) — the loop ends immediately and no further wakeups fire.
+
+Set \`noop: true\` if nothing changed — you checked and there's nothing to report ("no change", "still waiting", "quiet hold"). Set \`noop: false\` if something happened worth keeping — you edited a file, posted a message, advanced state, or surfaced a finding. Consecutive \`noop: true\` ticks are collapsed in the user's terminal view and tracked as a streak, so long quiet holds stay legible to the user without scrolling. Omit \`noop\` when stopping (\`stop: true\`).
+
+## Picking delaySeconds
+
+The Anthropic prompt cache decides how expensive a wake-up is: waking inside the cache TTL re-reads your conversation context cached (fast, cheap); waking past it re-reads everything uncached. The TTL depends on how the session is billed: Claude subscriber sessions get a 1-hour TTL (dropping to 5 minutes during usage overage), while API-key, Bedrock, and Vertex sessions default to 5 minutes.
+
+In either regime: never schedule extra wakeups just to keep the cache warm — they cost more than the cache miss they avoid. Match the delay to what you're actually waiting for: when actively polling external state the harness can't notify you about (a CI run, a deploy, a remote queue), pick the delay from how fast that state actually changes; for idle ticks with no specific signal to watch, default to **1200s–1800s** (20–30 min) — the user can always interrupt if they need you sooner.
+
+On a 5-minute TTL only, two refinements: under 300s (60s–270s) the cache stays warm, so prefer 270s over 300s when actively polling (300s is the worst-of-both — you pay the miss without amortizing it); and commit to 1200s+ rather than repeated ~300s waits, so one cache miss buys a long wait.
+
+The runtime clamps to [60, 3600], so you don't need to clamp yourself.
+
+## The reason field
+
+One short sentence on what you chose and why. Goes to telemetry and is shown back to the user. "watching CI run" beats "waiting." The user reads this to understand what you're doing without having to predict your cadence in advance — make it specific.
+`;
+
+export const SCHEDULE_WAKEUP_PARAMS = {
+	delaySeconds: "Seconds from now to wake up. Clamped to [60, 3600] by the runtime. Required unless `stop` is true.",
+	reason: "One short sentence explaining the chosen delay. Goes to telemetry and is shown to the user. Be specific. Required unless `stop` is true.",
+	prompt:
+		"The /loop input to fire on wake-up. Pass the same /loop input verbatim each turn so the next firing re-enters the skill and continues the loop. For autonomous /loop (no user prompt), pass the literal sentinel `<<autonomous-loop-dynamic>>` instead (the dynamic-pacing variant, not the cron_create-mode `<<autonomous-loop>>`). Required unless `stop` is true.",
+	stop: "Set to true to end the dynamic loop immediately instead of scheduling another wakeup. When true, all other fields are ignored and no further wakeups fire.",
+	noop: "true = nothing changed (you checked and there is nothing to report). false = something happened worth keeping (edited a file, posted a message, advanced state, surfaced a finding). Consecutive noop:true ticks are collapsed in the user's terminal view and tracked as a streak. Required unless `stop` is true.",
+} as const;

package/extensions/bash/background.ts

@@ -5,7 +5,7 @@
  * A background command spawns detached in its own process group, spools
  * stdout+stderr to memory (tail-capped) and to a log file when one is given,
  * and satisfies the BackgroundTask contract so task_output/task_stop work
- * unchanged. Robustness rules from docs/features/tools/records/background-bash.md: `output()`
+ * unchanged. Robustness rules from working-docs/features/tools/records/background-bash.md: `output()`
  * never returns an empty body for a finished task (an explicitly-marked
  * "(no output)" beats an ambiguous blank a weak model reads as failure), and
  * the completion callback receives exactly what `output()` returns, so the
@@ -13,9 +13,10 @@
  */
 
 import { createWriteStream } from "node:fs";
+import { StringDecoder } from "node:string_decoder";
 import type { BackgroundTask } from "../background/registry.ts";
 import { whenAborted } from "../lib/abort.ts";
-import { detachedSpawnOptions, KILL_GRACE_MS, stopProcessTree, waitForChildExit } from "../lib/process-tree.ts";
+import { detachedSpawnOptions, KILL_GRACE_MS, rememberProcessGroup, stopProcessTree, waitForChildExit } from "../lib/process-tree.ts";
 import { bashSpawnOrThrow, type ShellSpawn, spawnShellCommand } from "../lib/shell-spawn.ts";
 
 export const STORED_OUTPUT_CAP = 200_000;
@@ -35,6 +36,8 @@ export interface BashFinishSummary {
 	timedOut: boolean;
 	/** Exactly what task.output() returns — never empty. */
 	output: string;
+	/** The flushed spool, absent if writing it failed. */
+	logPath?: string;
 }
 
 export interface StartBackgroundBashOptions {
@@ -61,23 +64,33 @@ export function startBackgroundBash(options: StartBackgroundBashOptions): Backgr
 		...detachedSpawnOptions(),
 		stdio: ["ignore", "pipe", "pipe"],
 	});
+	rememberProcessGroup(child);
 
 	let stored = "";
+	let overflowed = false;
+	let spoolFailed = false;
 	let ended = false;
 	let stopRequested = false;
 	let timedOut = false;
 	const log = options.logPath ? createWriteStream(options.logPath, { flags: "a" }) : undefined;
 	log?.on("error", () => {
-		// Spooling to disk is best-effort; the in-memory tail stays authoritative.
+		// Never name a missing or partial file as the full output.
+		spoolFailed = true;
+		task.logPath = undefined;
 	});
 
-	const append = (chunk: Buffer) => {
-		const text = chunk.toString();
-		stored = tailCap(stored + text, STORED_OUTPUT_CAP);
-		log?.write(text);
+	// One streaming decoder per stream: a UTF-8 character split across two
+	// reads must not become two U+FFFD. The log gets the raw bytes.
+	const stdoutText = new StringDecoder("utf8");
+	const stderrText = new StringDecoder("utf8");
+	const appender = (decoder: StringDecoder) => (chunk: Buffer) => {
+		const text = stored + decoder.write(chunk);
+		overflowed ||= text.length > STORED_OUTPUT_CAP;
+		stored = tailCap(text, STORED_OUTPUT_CAP);
+		if (!spoolFailed) log?.write(chunk);
 	};
-	child.stdout?.on("data", append);
-	child.stderr?.on("data", append);
+	child.stdout?.on("data", appender(stdoutText));
+	child.stderr?.on("data", appender(stderrText));
 
 	let finish!: () => void;
 	const finished = new Promise<void>((resolve) => {
@@ -94,7 +107,9 @@ export function startBackgroundBash(options: StartBackgroundBashOptions): Backgr
 		startedAt: Date.now(),
 		logPath: options.logPath,
 		ownUI: true, // rendered live by the subagents panel's shell manager
-		output: () => stored || (task.status === "running" ? "" : EMPTY_OUTPUT_MARKER),
+		output: () => overflowed && !task.logPath
+			? `[The command's spool file could not be written, so only the last ${STORED_OUTPUT_CAP.toLocaleString("en-US")} characters of its output were kept.]\n${stored}`
+			: stored || (task.status === "running" ? "" : EMPTY_OUTPUT_MARKER),
 		stop: () => {
 			stopRequested = true;
 			// SIGTERM the tree, SIGKILL after the grace: a command that traps TERM
@@ -117,18 +132,39 @@ export function startBackgroundBash(options: StartBackgroundBashOptions): Backgr
 		if (ended) return;
 		ended = true;
 		if (timer) clearTimeout(timer);
-		task.status = status;
-		task.finishedAt = Date.now();
+		// An incomplete sequence at the very end decodes as U+FFFD, as it would have.
+		const rest = stdoutText.end() + stderrText.end();
+		if (rest) stored = tailCap(stored + rest, STORED_OUTPUT_CAP);
+		let completed = false;
 		const complete = () => {
+			if (completed) return;
+			completed = true;
+			task.status = status;
+			task.finishedAt = Date.now();
 			finish();
-			options.onFinished(task, { exitCode, signal, stopped: stopRequested, timedOut, output: task.output() });
+			options.onFinished(task, { exitCode, signal, stopped: stopRequested, timedOut, output: task.output(), logPath: task.logPath });
 		};
 		// end() flushes asynchronously; `finished` must not resolve while the
 		// log file is still short of what output() returns, or a reader sent to
-		// logPath by the completion notification can see a truncated file. The
-		// callback also fires if the stream errors, so this cannot hang.
-		if (log) log.end(complete);
-		else complete();
+		// logPath by the completion notification can see a truncated file.
+		// `close` follows a clean end and an error alike; a stuck stream (a
+		// write that never calls back) must not keep the task running, so after
+		// a second it is dropped and the partial file is no longer named.
+		if (log && !log.closed) {
+			const fallback = setTimeout(() => {
+				spoolFailed = true;
+				task.logPath = undefined;
+				log.destroy();
+				complete();
+			}, 1_000);
+			log.once("close", () => {
+				clearTimeout(fallback);
+				complete();
+			});
+			log.end();
+		} else {
+			complete();
+		}
 	};
 
 	// Exit plus a short stdio grace, not `close`: a descendant the stop missed

package/extensions/bash/child.ts

@@ -0,0 +1,7 @@
+/** One Code's bash tool for an in-process child session (lib/child-extensions.ts): the same tool, prints nothing. */
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { bashTool } from "./index.ts";
+
+export default function childBashExtension(pi: ExtensionAPI) {
+	bashTool(pi, { announce: false });
+}