killeros 2.0.17 → 2.0.19

package/killeros/handoff.ts

@@ -1,5 +1,6 @@
 import { contentText } from "@earendil-works/pi-ai";
 import { BorderedLoader, convertToLlm, type ExtensionAPI, type ExtensionCommandContext, serializeConversation, sessionEntryToContextMessages } from "@earendil-works/pi-coding-agent";
+import { reportError } from "./errors.ts";
 import type { GoalRuntime } from "./runtime.ts";
 import { safeTerminalText } from "./safe-terminal-text.ts";
 
@@ -81,12 +82,6 @@ function hasRequiredHandoffContent(document: string, focus: string): boolean {
   });
 }
 
-/** Reports a failed handoff through the session context that remains valid. */
-function reportHandoffError(ctx: ExtensionCommandContext, error: unknown): void {
-  const message = error instanceof Error ? error.message : String(error);
-  ctx.ui.notify(`Handoff failed: ${message}`, "error");
-}
-
 /** Generates and validates a handoff summary with optional cancellation. */
 async function generateHandoffSummary(
   ctx: ExtensionCommandContext,
@@ -96,9 +91,7 @@ async function generateHandoffSummary(
 ): Promise<string> {
   if (!ctx.model) throw new Error("No current model is available");
 
-  const auth = await ctx.modelRegistry.getApiKeyAndHeaders(ctx.model);
   signal?.throwIfAborted();
-  if (!auth.ok) throw new Error(auth.error);
 
   const response = await ctx.modelRegistry.complete(ctx.model, {
     systemPrompt: HANDOFF_SYSTEM_PROMPT,
@@ -108,9 +101,6 @@ async function generateHandoffSummary(
       timestamp: Date.now(),
     }],
   }, {
-    apiKey: auth.apiKey,
-    headers: auth.headers,
-    env: auth.env,
     maxTokens: 2_048,
     signal,
   });
@@ -173,7 +163,7 @@ export function registerHandoff(pi: ExtensionAPI, goalRuntime: GoalRuntime): voi
           throw new Error("The handoff summary did not contain every required section");
         }
       } catch (error) {
-        reportHandoffError(ctx, error);
+        reportError(ctx, "Handoff failed", error);
         return;
       }
 
@@ -191,7 +181,7 @@ export function registerHandoff(pi: ExtensionAPI, goalRuntime: GoalRuntime): voi
           },
           withSession: async (destination) => {
             if (setupFailure) {
-              reportHandoffError(destination, setupFailure.error);
+              reportError(destination, "Handoff failed", setupFailure.error);
               return;
             }
             destination.ui.notify("Handoff ready in a new session", "info");
@@ -199,7 +189,7 @@ export function registerHandoff(pi: ExtensionAPI, goalRuntime: GoalRuntime): voi
         });
       } catch (error) {
         try {
-          reportHandoffError(ctx, error);
+          reportError(ctx, "Handoff failed", error);
         } catch {
           throw error;
         }

package/killeros/hooks.ts

@@ -1,9 +1,13 @@
-import { spawn } from "node:child_process";
-import { existsSync, readFileSync } from "node:fs";
+import {
+  spawn,
+  type SpawnOptionsWithStdioTuple,
+} from "node:child_process";
+import { closeSync, existsSync, fstatSync, lstatSync, openSync, readSync, realpathSync } from "node:fs";
 import path from "node:path";
 import { StringDecoder } from "node:string_decoder";
 import { CONFIG_DIR_NAME, type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { reportError } from "./errors.ts";
+import { errorMessage, reportError } from "./errors.ts";
+import { safeTerminalText } from "./safe-terminal-text.ts";
 
 type KillerosHookEvent = "tool_call" | "tool_result" | "agent_settled";
 
@@ -26,52 +30,141 @@ interface HookExecutionResult {
   exitUnconfirmed: boolean;
 }
 
+interface HookOutputStream {
+  on(event: "data", listener: (chunk: Buffer | string) => void): unknown;
+}
+
+interface HookChildProcess {
+  readonly pid?: number;
+  readonly stdout: HookOutputStream;
+  readonly stderr: HookOutputStream;
+  kill(signal?: NodeJS.Signals | number): boolean;
+  on(event: "error", listener: (error: Error) => void): unknown;
+  once(event: "close", listener: (code: number | null) => void): unknown;
+}
+type HookSpawnOptions = SpawnOptionsWithStdioTuple<"ignore", "pipe", "pipe">;
+export type HookSpawnProcess = (command: string, options: HookSpawnOptions) => HookChildProcess;
+
+export interface ExecuteHookOptions {
+  command: string;
+  cwd: string;
+  environment: Record<string, string>;
+  timeoutMs?: number;
+  spawnProcess?: HookSpawnProcess;
+  signal?: AbortSignal;
+}
+
 const HOOK_EVENTS: readonly KillerosHookEvent[] = ["tool_call", "tool_result", "agent_settled"];
+const HOOK_CONFIG_LIMIT = 64 * 1024;
 const HOOK_OUTPUT_LIMIT = 16 * 1024;
 const HOOK_PAYLOAD_LIMIT = 8_000;
 const HOOK_TIMEOUT_MAX_MS = 300_000;
 
+// Reads executable project configuration through a bounded, project-local file descriptor.
+function readHookConfig(configPath: string, projectRoot: string): string {
+  const actualPath = realpathSync(configPath);
+  const expectedPath = path.join(realpathSync(projectRoot), CONFIG_DIR_NAME, "killeros-hooks.json");
+  const samePath = process.platform === "win32"
+    ? actualPath.toLowerCase() === expectedPath.toLowerCase()
+    : actualPath === expectedPath;
+  if (!samePath) {
+    throw new Error("Hook config must be stored in the real project .pi directory");
+  }
+
+  const linkedFile = lstatSync(configPath);
+  if (!linkedFile.isFile() || linkedFile.nlink !== 1) {
+    throw new Error("Hook config must be a regular, non-linked file");
+  }
+  if (linkedFile.size > HOOK_CONFIG_LIMIT) {
+    throw new Error(`Hook config exceeds ${HOOK_CONFIG_LIMIT} bytes`);
+  }
+
+  const descriptor = openSync(configPath, "r");
+  try {
+    const openedFile = fstatSync(descriptor);
+    if (!openedFile.isFile() || openedFile.nlink !== 1) {
+      throw new Error("Hook config must be a regular, non-linked file");
+    }
+    if (openedFile.dev !== linkedFile.dev || openedFile.ino !== linkedFile.ino) {
+      throw new Error("Hook config changed while being opened");
+    }
+
+    const contents = Buffer.alloc(HOOK_CONFIG_LIMIT + 1);
+    let bytesRead = 0;
+    while (bytesRead < contents.length) {
+      const count = readSync(descriptor, contents, bytesRead, contents.length - bytesRead, null);
+      if (count === 0) break;
+      bytesRead += count;
+    }
+    if (bytesRead > HOOK_CONFIG_LIMIT) {
+      throw new Error(`Hook config exceeds ${HOOK_CONFIG_LIMIT} bytes`);
+    }
+    return contents.toString("utf8", 0, bytesRead);
+  } finally {
+    closeSync(descriptor);
+  }
+}
+
+function isUnknownRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
 function loadKillerosHooks(ctx: ExtensionContext): KillerosHookConfig {
   const configPath = path.join(ctx.cwd, CONFIG_DIR_NAME, "killeros-hooks.json");
   if (!existsSync(configPath)) return {};
+  const displayPath = safeTerminalText(configPath).replaceAll("\n", "");
   if (!ctx.isProjectTrusted()) {
-    ctx.ui.notify(`Ignored untrusted project hooks in ${configPath}`, "warning");
+    ctx.ui.notify(`Ignored untrusted project hooks in ${displayPath}`, "warning");
     return {};
   }
 
   try {
-    const parsed = JSON.parse(readFileSync(configPath, "utf8")) as KillerosHookConfig;
+    const parsed: unknown = JSON.parse(readHookConfig(configPath, ctx.cwd));
+    if (!isUnknownRecord(parsed)) throw new Error("Hook config must contain a JSON object");
+    const parsedHooks = parsed.hooks;
+    if (parsedHooks !== undefined && !isUnknownRecord(parsedHooks)) {
+      throw new Error("Hook config hooks must contain a JSON object");
+    }
+
     const hooks: KillerosHookConfig["hooks"] = {};
     for (const event of HOOK_EVENTS) {
-      const candidates = parsed.hooks?.[event];
+      const candidates = parsedHooks?.[event];
       if (!Array.isArray(candidates)) continue;
-      hooks[event] = candidates.filter((hook, index) => {
-        if (event === "agent_settled" && hook?.matcher !== undefined) {
+      const accepted: KillerosHook[] = [];
+      for (const [index, candidate] of candidates.entries()) {
+        if (!isUnknownRecord(candidate)) {
+          ctx.ui.notify(`Ignored invalid ${event} hook ${index + 1} in ${displayPath}`, "warning");
+          continue;
+        }
+        const { command, matcher, timeoutMs } = candidate;
+        if (event === "agent_settled" && matcher !== undefined) {
           ctx.ui.notify(`Ignored ${event} hook ${index + 1}: matchers are only valid for tool events`, "warning");
-          return false;
+          continue;
         }
-        if (hook?.timeoutMs !== undefined && (!Number.isSafeInteger(hook.timeoutMs) || hook.timeoutMs <= 0 || hook.timeoutMs > HOOK_TIMEOUT_MAX_MS)) {
+        if (timeoutMs !== undefined && (typeof timeoutMs !== "number" || !Number.isSafeInteger(timeoutMs) || timeoutMs <= 0 || timeoutMs > HOOK_TIMEOUT_MAX_MS)) {
           ctx.ui.notify(`Ignored ${event} hook ${index + 1}: timeoutMs must be an integer from 1 to ${HOOK_TIMEOUT_MAX_MS}`, "warning");
-          return false;
+          continue;
         }
-        const valid = hook
-          && typeof hook.command === "string"
-          && hook.command.trim().length > 0
-          && (hook.matcher === undefined || typeof hook.matcher === "string");
-        if (!valid) {
-          ctx.ui.notify(`Ignored invalid ${event} hook ${index + 1} in ${configPath}`, "warning");
-          return false;
+        if (typeof command !== "string" || command.trim().length === 0
+          || matcher !== undefined && typeof matcher !== "string") {
+          ctx.ui.notify(`Ignored invalid ${event} hook ${index + 1} in ${displayPath}`, "warning");
+          continue;
         }
-        if (hook.matcher && hook.matcher !== "*") {
+        if (matcher && matcher !== "*") {
           try {
-            new RegExp(hook.matcher, "u");
+            new RegExp(matcher, "u");
           } catch {
-            ctx.ui.notify(`Ignored ${event} hook ${index + 1}: invalid matcher ${JSON.stringify(hook.matcher)}`, "warning");
-            return false;
+            ctx.ui.notify(`Ignored ${event} hook ${index + 1}: invalid matcher ${JSON.stringify(matcher)}`, "warning");
+            continue;
           }
         }
-        return true;
-      });
+        accepted.push({
+          command,
+          ...(matcher === undefined ? {} : { matcher }),
+          ...(timeoutMs === undefined ? {} : { timeoutMs }),
+        });
+      }
+      hooks[event] = accepted;
     }
     return { hooks };
   } catch (error) {
@@ -104,7 +197,7 @@ function appendBounded(output: HookOutputBuffer, chunk: Buffer | string): void {
   output.text += output.decoder.write(captured);
 }
 
-function terminateHookProcess(child: ReturnType<typeof spawn>, force: boolean): void {
+function terminateHookProcess(child: HookChildProcess, force: boolean): void {
   if (process.platform === "win32" && force && child.pid) {
     const killer = spawn("taskkill", ["/pid", String(child.pid), "/T", "/F"], {
       shell: false,
@@ -129,19 +222,48 @@ function terminateHookProcess(child: ReturnType<typeof spawn>, force: boolean):
   }
 }
 
+export function executeHook(options: ExecuteHookOptions): Promise<HookExecutionResult>;
+/** @deprecated Use the object-argument form. The positional adapter will be removed in the next major release. */
 export function executeHook(
   command: string,
   cwd: string,
   environment: Record<string, string>,
-  timeoutMs = 30_000,
-  spawnProcess: typeof spawn = spawn,
+  timeoutMs?: number,
+  spawnProcess?: HookSpawnProcess,
   signal?: AbortSignal,
+): Promise<HookExecutionResult>;
+export function executeHook(
+  optionsOrCommand: ExecuteHookOptions | string,
+  legacyCwd?: string,
+  legacyEnvironment?: Record<string, string>,
+  legacyTimeoutMs?: number,
+  legacySpawnProcess?: HookSpawnProcess,
+  legacySignal?: AbortSignal,
 ): Promise<HookExecutionResult> {
+  const options: ExecuteHookOptions = typeof optionsOrCommand === "string"
+    ? {
+        command: optionsOrCommand,
+        cwd: legacyCwd ?? process.cwd(),
+        environment: legacyEnvironment ?? {},
+        ...(legacyTimeoutMs === undefined ? {} : { timeoutMs: legacyTimeoutMs }),
+        ...(legacySpawnProcess === undefined ? {} : { spawnProcess: legacySpawnProcess }),
+        ...(legacySignal === undefined ? {} : { signal: legacySignal }),
+      }
+    : optionsOrCommand;
+  const {
+    command,
+    cwd,
+    environment,
+    timeoutMs = 30_000,
+    spawnProcess = spawn,
+    signal,
+  } = options;
   if (signal?.aborted) {
     return Promise.resolve({ code: 130, stdout: "", stderr: "", timedOut: false, cancelled: true, exitUnconfirmed: false });
   }
-  return new Promise((resolve) => {
-    const child = spawnProcess(command, {
+  let child;
+  try {
+    child = spawnProcess(command, {
       cwd,
       env: { ...process.env, ...environment },
       detached: process.platform !== "win32",
@@ -149,6 +271,10 @@ export function executeHook(
       stdio: ["ignore", "pipe", "pipe"],
       windowsHide: true,
     });
+  } catch (error) {
+    return Promise.resolve({ code: 1, stdout: "", stderr: errorMessage(error), timedOut: false, cancelled: false, exitUnconfirmed: false });
+  }
+  return new Promise((resolve) => {
     const stdout: HookOutputBuffer = { bytes: 0, decoder: new StringDecoder("utf8"), text: "" };
     const stderr: HookOutputBuffer = { bytes: 0, decoder: new StringDecoder("utf8"), text: "" };
     let completed = false;
@@ -163,6 +289,8 @@ export function executeHook(
       if (forceTimer) clearTimeout(forceTimer);
       if (settleTimer) clearTimeout(settleTimer);
       signal?.removeEventListener("abort", abort);
+      stdout.text += stdout.decoder.end();
+      stderr.text += stderr.decoder.end();
       resolve({
         code,
         stdout: stdout.text,
@@ -212,9 +340,9 @@ function hookEnvironment(event: KillerosHookEvent, toolName = "", payload: unkno
   };
 }
 
-function hookFailureMessage(hook: KillerosHook, result: HookExecutionResult): string {
+function hookFailureMessage(result: HookExecutionResult): string {
   const detail = result.stderr.trim() || result.stdout.trim() || `exit code ${result.code}`;
-  return `Hook failed${result.timedOut ? " (timed out)" : ""}${result.exitUnconfirmed ? " (process exit unconfirmed)" : ""}: ${hook.command}\n${detail}`;
+  return safeTerminalText(`Hook failed${result.timedOut ? " (timed out)" : ""}${result.exitUnconfirmed ? " (process exit unconfirmed)" : ""}\n${detail}`);
 }
 
 export function registerLifecycleHooks(pi: ExtensionAPI): void {
@@ -224,17 +352,17 @@ export function registerLifecycleHooks(pi: ExtensionAPI): void {
   pi.on("tool_call", async (event, ctx) => {
     for (const hook of config.hooks?.tool_call ?? []) {
       if (!matchesHook(hook, event.toolName)) continue;
-      const result = await executeHook(
-        hook.command,
-        ctx.cwd,
-        hookEnvironment("tool_call", event.toolName, event.input),
-        hook.timeoutMs,
-        spawn,
-        ctx.signal,
-      );
+      const result = await executeHook({
+        command: hook.command,
+        cwd: ctx.cwd,
+        environment: hookEnvironment("tool_call", event.toolName, event.input),
+        timeoutMs: hook.timeoutMs,
+        spawnProcess: spawn,
+        signal: ctx.signal,
+      });
       if (result.cancelled) return { block: true, reason: "Hook cancelled because the parent request was aborted" };
       if (result.code !== 0) {
-        const reason = hookFailureMessage(hook, result);
+        const reason = hookFailureMessage(result);
         ctx.ui.notify(reason, "error");
         return { block: true, reason };
       }
@@ -244,34 +372,34 @@ export function registerLifecycleHooks(pi: ExtensionAPI): void {
   pi.on("tool_result", async (event, ctx) => {
     for (const hook of config.hooks?.tool_result ?? []) {
       if (!matchesHook(hook, event.toolName)) continue;
-      const result = await executeHook(
-        hook.command,
-        ctx.cwd,
-        hookEnvironment("tool_result", event.toolName, {
+      const result = await executeHook({
+        command: hook.command,
+        cwd: ctx.cwd,
+        environment: hookEnvironment("tool_result", event.toolName, {
           input: event.input,
           isError: event.isError,
         }),
-        hook.timeoutMs,
-        spawn,
-        ctx.signal,
-      );
+        timeoutMs: hook.timeoutMs,
+        spawnProcess: spawn,
+        signal: ctx.signal,
+      });
       if (result.cancelled) break;
-      if (result.code !== 0) ctx.ui.notify(hookFailureMessage(hook, result), "error");
+      if (result.code !== 0) ctx.ui.notify(hookFailureMessage(result), "error");
     }
   });
 
   pi.on("agent_settled", async (_event, ctx) => {
     for (const hook of config.hooks?.agent_settled ?? []) {
-      const result = await executeHook(
-        hook.command,
-        ctx.cwd,
-        hookEnvironment("agent_settled"),
-        hook.timeoutMs,
-        spawn,
-        ctx.signal,
-      );
+      const result = await executeHook({
+        command: hook.command,
+        cwd: ctx.cwd,
+        environment: hookEnvironment("agent_settled"),
+        timeoutMs: hook.timeoutMs,
+        spawnProcess: spawn,
+        signal: ctx.signal,
+      });
       if (result.cancelled) break;
-      if (result.code !== 0) ctx.ui.notify(hookFailureMessage(hook, result), "error");
+      if (result.code !== 0) ctx.ui.notify(hookFailureMessage(result), "error");
     }
   });
 }

package/killeros/init-evidence.ts

@@ -60,7 +60,8 @@ async function collectCandidates(projectRoot: string): Promise<string[]> {
   const queue: Array<{ relativePath: string; depth: number }> = [{ relativePath: "", depth: 0 }];
   let directoriesRead = 0;
   while (queue.length && files.length < PATH_LIMIT && directoriesRead < DIRECTORY_LIMIT) {
-    const current = queue.shift()!;
+    const current = queue.shift();
+    if (!current) break;
     directoriesRead += 1;
     let entries;
     try {
@@ -270,7 +271,8 @@ export function listInitEvidence(index: InitEvidenceIndex, requestedPath = "."):
     const remainder = relativePath.slice(prefixWithSlash.length);
     if (!remainder) continue;
     found = true;
-    children.add(remainder.split("/")[0]!);
+    const child = remainder.split("/", 1)[0];
+    if (child) children.add(child);
   }
   if (!found) throw new Error(`${requestedPath} is not available to /init`);
   return [...children].sort((left, right) => left.localeCompare(right)).slice(0, PATH_LIMIT);

package/killeros/init-target.ts

@@ -3,6 +3,7 @@ import { constants } from "node:fs";
 import { promises as fs } from "node:fs";
 import path from "node:path";
 import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
+import { hasErrorCode } from "./errors.ts";
 
 const TARGET_LIMIT = 128 * 1024;
 const REQUIRED_GUIDANCE_HEADINGS = [
@@ -13,15 +14,17 @@ const REQUIRED_GUIDANCE_HEADINGS = [
   "## 4. Goal-Driven Execution",
 ] as const;
 
-export interface InitTargetBaseline {
-  exists: boolean;
-  content?: string;
-  digest?: string;
-  dev?: number;
-  ino?: number;
-  mode?: number;
-  nlink?: number;
-}
+export type InitTargetBaseline =
+  | { exists: false }
+  | {
+      exists: true;
+      content: string;
+      digest: string;
+      dev: number;
+      ino: number;
+      mode: number;
+      nlink: number;
+    };
 
 export interface InitInstallOperations {
   renameFile?: typeof fs.rename;
@@ -33,7 +36,7 @@ function digest(content: Buffer): string {
   return createHash("sha256").update(content).digest("hex");
 }
 
-async function captureExistingTarget(targetPath: string): Promise<InitTargetBaseline> {
+async function captureExistingTarget(targetPath: string): Promise<Extract<InitTargetBaseline, { exists: true }>> {
   const pathStat = await fs.lstat(targetPath);
   if (pathStat.isSymbolicLink() || !pathStat.isFile() || pathStat.nlink !== 1) {
     throw new Error("/init requires root AGENTS.md to be absent or a regular, non-linked file");
@@ -67,14 +70,14 @@ export async function captureInitTargetBaseline(targetPath: string): Promise<Ini
   try {
     return await captureExistingTarget(targetPath);
   } catch (error) {
-    if ((error as NodeJS.ErrnoException).code === "ENOENT") return { exists: false };
+    if (hasErrorCode(error, "ENOENT")) return { exists: false };
     throw error;
   }
 }
 
 function sameBaseline(left: InitTargetBaseline, right: InitTargetBaseline): boolean {
-  if (left.exists !== right.exists) return false;
-  if (!left.exists) return true;
+  if (!left.exists) return !right.exists;
+  if (!right.exists) return false;
   return left.digest === right.digest
     && left.dev === right.dev
     && left.ino === right.ino
@@ -82,7 +85,10 @@ function sameBaseline(left: InitTargetBaseline, right: InitTargetBaseline): bool
     && left.nlink === right.nlink;
 }
 
-async function installedCandidateMatches(targetPath: string, candidate: InitTargetBaseline): Promise<boolean> {
+async function installedCandidateMatches(
+  targetPath: string,
+  candidate: Extract<InitTargetBaseline, { exists: true }>,
+): Promise<boolean> {
   try {
     const pathStat = await fs.lstat(targetPath);
     if (pathStat.isSymbolicLink() || !pathStat.isFile() || pathStat.nlink !== 2) return false;
@@ -102,7 +108,7 @@ async function installedCandidateMatches(targetPath: string, candidate: InitTarg
       await handle.close();
     }
   } catch (error) {
-    if ((error as NodeJS.ErrnoException).code === "ENOENT") return false;
+    if (hasErrorCode(error, "ENOENT")) return false;
     throw error;
   }
 }
@@ -124,7 +130,9 @@ export function validateGeneratedGuidance(content: string): string | undefined {
   for (const heading of REQUIRED_GUIDANCE_HEADINGS) {
     const matches = [...content.matchAll(new RegExp(`^${heading.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&")}$`, "gmu"))];
     if (matches.length !== 1) return `generated guidance must contain ${heading} exactly once`;
-    const index = matches[0]!.index;
+    const match = matches[0];
+    if (!match) return `generated guidance must contain ${heading} exactly once`;
+    const index = match.index;
     if (index <= previous) return "generated guidance headings must occur in the required order";
     previous = index;
   }
@@ -141,7 +149,7 @@ async function pathExists(filePath: string): Promise<boolean> {
     await fs.lstat(filePath);
     return true;
   } catch (error) {
-    if ((error as NodeJS.ErrnoException).code === "ENOENT") return false;
+    if (hasErrorCode(error, "ENOENT")) return false;
     throw error;
   }
 }
@@ -170,7 +178,7 @@ export async function installInitAgentsFile(
     const heldPath = path.join(tempDirectory, "held.md");
     let held = false;
     let installed = false;
-    let candidate: InitTargetBaseline | undefined;
+    let candidate: Extract<InitTargetBaseline, { exists: true }> | undefined;
     let retainedRecovery: string | undefined;
     try {
       const handle = await fs.open(candidatePath, "wx", 0o600);
@@ -187,7 +195,7 @@ export async function installInitAgentsFile(
           await linkFile(candidatePath, targetPath);
           installed = true;
         } catch (error) {
-          if ((error as NodeJS.ErrnoException).code === "EEXIST") {
+          if (hasErrorCode(error, "EEXIST")) {
             throw new Error("/init target changed while /init was generating; the newer AGENTS.md was preserved");
           }
           throw error;
@@ -221,7 +229,7 @@ export async function installInitAgentsFile(
         await linkFile(candidatePath, targetPath);
         installed = true;
       } catch (error) {
-        if ((error as NodeJS.ErrnoException).code === "EEXIST") {
+        if (hasErrorCode(error, "EEXIST")) {
           retainedRecovery = recoveryPath(targetPath);
           await renameFile(heldPath, retainedRecovery);
           held = false;

package/killeros/init.ts

@@ -17,10 +17,12 @@ import {
   validateGeneratedGuidance,
 } from "./init-target.ts";
 import { resetInitRuntime, type GoalRuntime, type InitOutcome, type InitRuntime } from "./runtime.ts";
+import { safeTerminalText } from "./safe-terminal-text.ts";
 
 const INIT_WRITE_TOOL = "killeros_init_write";
 const INIT_CONFLICT_TOOL = "killeros_init_conflict";
 const INIT_SCOPED_TOOLS = [INIT_READ_TOOL, INIT_LIST_TOOL, INIT_WRITE_TOOL, INIT_CONFLICT_TOOL] as const;
+const INIT_SCOPED_TOOL_NAMES: ReadonlySet<string> = new Set(INIT_SCOPED_TOOLS);
 const INIT_GENERATED_CONTENT_LIMIT = 128 * 1024;
 
 export const INIT_WORKFLOW_PROMPT = `
@@ -48,13 +50,13 @@ After a successful write, read generated AGENTS.md once through killeros_init_re
 
 function setInitTools(pi: ExtensionAPI, initState: InitRuntime, active: boolean): void {
   if (active) {
-    initState.activeTools ??= pi.getActiveTools().filter((name) => !INIT_SCOPED_TOOLS.includes(name as (typeof INIT_SCOPED_TOOLS)[number]));
+    initState.activeTools ??= pi.getActiveTools().filter((name) => !INIT_SCOPED_TOOL_NAMES.has(name));
     pi.setActiveTools([...INIT_SCOPED_TOOLS]);
   } else if (initState.activeTools) {
     pi.setActiveTools(initState.activeTools);
     initState.activeTools = undefined;
   } else {
-    pi.setActiveTools(pi.getActiveTools().filter((name) => !INIT_SCOPED_TOOLS.includes(name as (typeof INIT_SCOPED_TOOLS)[number])));
+    pi.setActiveTools(pi.getActiveTools().filter((name) => !INIT_SCOPED_TOOL_NAMES.has(name)));
   }
 }
 
@@ -124,8 +126,9 @@ export function registerInitCommand(pi: ExtensionAPI, initState: InitRuntime, go
     executionMode: "sequential",
     async execute(_toolCallId, { reason }) {
       requirePending(initState);
-      initState.outcome = { kind: "policy-conflict", reason };
-      return { content: [{ type: "text" as const, text: `Root AGENTS.md was left unchanged: ${reason}` }], details: { reason } };
+      const safeReason = safeTerminalText(reason);
+      initState.outcome = { kind: "policy-conflict", reason: safeReason };
+      return { content: [{ type: "text" as const, text: `Root AGENTS.md was left unchanged: ${safeReason}` }], details: { reason: safeReason } };
     },
   });
 
@@ -141,7 +144,7 @@ export function registerInitCommand(pi: ExtensionAPI, initState: InitRuntime, go
   });
   pi.on("tool_call", (event) => {
     if (!initState.active) return;
-    if (!INIT_SCOPED_TOOLS.includes(event.toolName as (typeof INIT_SCOPED_TOOLS)[number])) {
+    if (!INIT_SCOPED_TOOL_NAMES.has(event.toolName)) {
       return { block: true, reason: "/init may use only its bounded evidence and terminal tools" };
     }
     if ((event.toolName === INIT_WRITE_TOOL || event.toolName === INIT_CONFLICT_TOOL) && initState.outcome.kind !== "pending") {
@@ -227,7 +230,7 @@ export function registerInitCommand(pi: ExtensionAPI, initState: InitRuntime, go
             JSON.stringify(initState.evidence.snapshot),
             "",
             "## Existing root AGENTS.md (protected policy; not untrusted evidence)",
-            JSON.stringify(initState.baseline.content ?? null),
+            JSON.stringify(initState.baseline.exists ? initState.baseline.content : null),
           ].join("\n"),
           display: false,
         }, { triggerTurn: true });
@@ -253,8 +256,14 @@ export function registerInitCommand(pi: ExtensionAPI, initState: InitRuntime, go
           break;
         case "cancelled":
           break;
-        default:
+        case "pending":
+        case "no-outcome":
           reportError(ctx, "/init did not generate AGENTS.md", "the model completed without a write or policy-conflict outcome");
+          break;
+        default: {
+          const exhaustive: never = outcome;
+          return exhaustive;
+        }
       }
     },
   });

package/killeros/notifications.ts

@@ -5,6 +5,7 @@ import {
   type ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
 import { errorMessage } from "./errors.ts";
+import { safeTerminalText } from "./safe-terminal-text.ts";
 import { createKillerosSettingsStore } from "./settings.ts";
 
 export interface NotificationPreferenceStore {
@@ -38,7 +39,7 @@ export function formatNotificationTitle(
 ): string {
   const directory = basename(cwd) || cwd;
   const base = sessionName ? `π - ${sessionName} - ${directory}` : `π - ${directory}`;
-  return enabled ? `${base} ${COMPLETION_BELL_GLYPH}` : base;
+  return safeTerminalText(enabled ? `${base} ${COMPLETION_BELL_GLYPH}` : base).replaceAll("\n", "");
 }
 
 export function registerCompletionNotifications(