killeros 2.0.18 → 2.0.20

package/killeros/handoff.ts

@@ -1,10 +1,13 @@
 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 { errorMessage, reportError } from "./errors.ts";
 import type { GoalRuntime } from "./runtime.ts";
+import { createKillerosSettingsStore, type KillerosSettings } from "./settings.ts";
 import { safeTerminalText } from "./safe-terminal-text.ts";
 
 const HANDOFF_UNAVAILABLE = "/handoff is not available while an agent or /goal is running.";
+/** Output-token budget with headroom for reasoning traces plus all ten sections. */
+export const DEFAULT_HANDOFF_MAX_TOKENS = 8_192;
 const HANDOFF_SECTIONS = [
   "Objective",
   "Current state",
@@ -69,6 +72,20 @@ function sessionName(sourceName: string | undefined, focus: string, document: st
   return `${shortBase || "Handoff"} · handoff`;
 }
 
+/** Accepts only positive integers. */
+function isPositiveInt(value: unknown): value is number {
+  return typeof value === "number" && Number.isInteger(value) && value > 0;
+}
+
+function positiveIntOr(value: unknown, fallback: number): number {
+  return isPositiveInt(value) ? value : fallback;
+}
+
+/** Resolves the summary budget: explicit option first, then killeros.json, then the default. */
+export function resolveHandoffMaxTokens(settings: Readonly<KillerosSettings>, override?: number): number {
+  return positiveIntOr(override, positiveIntOr(settings.handoffMaxTokens, DEFAULT_HANDOFF_MAX_TOKENS));
+}
+
 /** Checks that the model returned every section needed to continue safely. */
 function hasRequiredHandoffContent(document: string, focus: string): boolean {
   if (focus && !document.includes(focus)) return false;
@@ -82,16 +99,16 @@ function hasRequiredHandoffContent(document: string, focus: string): boolean {
   });
 }
 
-/** Generates and validates a handoff summary with optional cancellation. */
-async function generateHandoffSummary(
+/** Generates a handoff summary; throws named errors for truncation and provider failures. */
+export async function generateHandoffSummary(
   ctx: ExtensionCommandContext,
   conversation: string,
   focus: string,
-  signal?: AbortSignal,
+  options: { maxTokens: number; signal?: AbortSignal },
 ): Promise<string> {
   if (!ctx.model) throw new Error("No current model is available");
 
-  signal?.throwIfAborted();
+  options.signal?.throwIfAborted();
 
   const response = await ctx.modelRegistry.complete(ctx.model, {
     systemPrompt: HANDOFF_SYSTEM_PROMPT,
@@ -101,10 +118,13 @@ async function generateHandoffSummary(
       timestamp: Date.now(),
     }],
   }, {
-    maxTokens: 2_048,
-    signal,
+    maxTokens: options.maxTokens,
+    signal: options.signal,
   });
   if (response.stopReason === "error") throw new Error(response.errorMessage || "Handoff summary failed");
+  if (response.stopReason === "length") {
+    throw new Error(`The handoff summary exceeded its ${options.maxTokens}-token output budget. Shorten the source session or raise the handoff token budget.`);
+  }
   if (response.stopReason !== "stop") throw new Error("The handoff summary did not finish");
 
   const summary = safeTerminalText(contentText(response.content)).trim();
@@ -113,7 +133,7 @@ async function generateHandoffSummary(
 }
 
 /** Registers the idle-only command that summarizes context into a child session. */
-export function registerHandoff(pi: ExtensionAPI, goalRuntime: GoalRuntime): void {
+export function registerHandoff(pi: ExtensionAPI, goalRuntime: GoalRuntime, handoffMaxTokens?: number): void {
   pi.registerCommand("handoff", {
     description: "Create a fresh session with a continuation handoff",
     handler: async (args, ctx) => {
@@ -136,6 +156,16 @@ export function registerHandoff(pi: ExtensionAPI, goalRuntime: GoalRuntime): voi
         const conversation = serializeConversation(convertToLlm(messages));
         if (!conversation.trim()) throw new Error("No usable session context is available");
         focus = safeTerminalText(args).trim();
+        let maxTokens = handoffMaxTokens;
+        if (!isPositiveInt(maxTokens)) {
+          let settings: KillerosSettings = {};
+          try {
+            settings = createKillerosSettingsStore().load();
+          } catch (error) {
+            ctx.ui.notify(`killeros.json could not be read; using the default handoff budget: ${errorMessage(error)}`, "warning");
+          }
+          maxTokens = resolveHandoffMaxTokens(settings);
+        }
         const generation = ctx.mode === "tui"
           ? await ctx.ui.custom<HandoffGenerationResult>((tui, theme, _keybindings, done) => {
             const loader = new BorderedLoader(tui, theme, "Generating handoff...");
@@ -146,12 +176,12 @@ export function registerHandoff(pi: ExtensionAPI, goalRuntime: GoalRuntime): voi
               done(result);
             };
             loader.onAbort = () => finish({ kind: "cancelled" });
-            generateHandoffSummary(ctx, conversation, focus, loader.signal)
+            generateHandoffSummary(ctx, conversation, focus, { maxTokens, signal: loader.signal })
               .then((summary) => finish({ kind: "summary", summary }))
               .catch((error: unknown) => finish({ kind: "error", error }));
             return loader;
           })
-          : { kind: "summary", summary: await generateHandoffSummary(ctx, conversation, focus) } as const;
+          : { kind: "summary", summary: await generateHandoffSummary(ctx, conversation, focus, { maxTokens }) } as const;
         if (generation.kind === "cancelled") {
           ctx.ui.notify("Handoff cancelled", "info");
           return;

package/killeros/hooks.ts

@@ -1,4 +1,7 @@
-import { spawn } from "node:child_process";
+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";
@@ -27,6 +30,30 @@ 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;
@@ -78,6 +105,10 @@ function readHookConfig(configPath: string, projectRoot: string): string {
   }
 }
 
+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 {};
@@ -88,38 +119,52 @@ function loadKillerosHooks(ctx: ExtensionContext): KillerosHookConfig {
   }
 
   try {
-    const parsed = JSON.parse(readHookConfig(configPath, ctx.cwd)) 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) {
+        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");
-          return false;
+          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) {
@@ -152,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,
@@ -177,18 +222,46 @@ 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 });
   }
-  let child;
+  let child: HookChildProcess;
   try {
     child = spawnProcess(command, {
       cwd,
@@ -279,14 +352,14 @@ 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(result);
@@ -299,17 +372,17 @@ 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(result), "error");
     }
@@ -317,14 +390,14 @@ export function registerLifecycleHooks(pi: ExtensionAPI): void {
 
   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(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

@@ -22,6 +22,7 @@ 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 = `
@@ -49,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)));
   }
 }
 
@@ -143,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") {
@@ -229,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 });
@@ -255,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/personal-instructions.ts

@@ -1,9 +1,8 @@
-import { closeSync, existsSync, openSync, readFileSync, readSync } from "node:fs";
+import { closeSync, openSync, readSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { StringDecoder } from "node:string_decoder";
-import { fileURLToPath } from "node:url";
-import { CONFIG_DIR_NAME, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { type ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import type { InitRuntime } from "./runtime.ts";
 
 const PERSONAL_INSTRUCTIONS_FILE = "AGENTS.local.md";
@@ -42,7 +41,7 @@ export function resolvePersonalInstructions(cwd: string): string | undefined {
   const importMatch = local.trim().match(/^@(.+)$/u);
   let content = local;
   if (importMatch) {
-    const requestedPath = importMatch[1]!.trim();
+    const requestedPath = (importMatch[1] ?? "").trim();
     const importedPath = requestedPath.startsWith("~/") || requestedPath.startsWith("~\\")
       ? path.join(os.homedir(), requestedPath.slice(2))
       : path.resolve(cwd, requestedPath);

package/killeros/question.ts

@@ -1,7 +1,6 @@
 import { StringEnum } from "@earendil-works/pi-ai";
 import {
   type ExtensionAPI,
-  type ExtensionContext,
   type ThemeColor,
   type ToolDefinition,
 } from "@earendil-works/pi-coding-agent";
@@ -165,7 +164,9 @@ function boundedQuestionLines(question: string, width: number, rowLimit: number)
   const wrapped = wrapTextWithAnsi(question.replace(/\s+/gu, " ").trim(), width);
   if (wrapped.length <= rowLimit) return wrapped;
   const visible = wrapped.slice(0, rowLimit);
-  visible[rowLimit - 1] = truncateToWidth(visible[rowLimit - 1]!, width, "…");
+  const finalIndex = rowLimit - 1;
+  const finalLine = visible[finalIndex];
+  if (finalLine !== undefined) visible[finalIndex] = truncateToWidth(finalLine, width, "…");
   return visible;
 }
 
@@ -173,12 +174,12 @@ function compactMultipleAnswers(answers: readonly string[], width: number): stri
   const prefix = "✓ ";
   if (answers.length === 0) return truncateToWidth(prefix + "No answers", width, "…");
   const visible: string[] = [];
-  for (let index = 0; index < answers.length; index += 1) {
+  for (const [index, answer] of answers.entries()) {
     const remaining = answers.length - index - 1;
-    const candidate = [...visible, oneLine(answers[index]!)].join(", ");
+    const candidate = [...visible, oneLine(answer)].join(", ");
     const suffix = remaining > 0 ? `, +${remaining} more` : "";
     if (visibleWidth(prefix + candidate + suffix) > width) break;
-    visible.push(oneLine(answers[index]!));
+    visible.push(oneLine(answer));
   }
   if (visible.length === answers.length) return prefix + visible.join(", ");
   const hidden = answers.length - visible.length;
@@ -228,7 +229,8 @@ export function registerQuestionTool(pi: ExtensionAPI): void {
     if (bytes > CUSTOM_INPUT_HISTORY_BYTES) return false;
     const existingIndex = customInputHistory.indexOf(value);
     if (existingIndex >= 0) {
-      customInputHistoryBytes -= Buffer.byteLength(customInputHistory[existingIndex]!, "utf8");
+      const existing = customInputHistory[existingIndex];
+      if (existing !== undefined) customInputHistoryBytes -= Buffer.byteLength(existing, "utf8");
       customInputHistory.splice(existingIndex, 1);
     }
     while (customInputHistory.length >= CUSTOM_INPUT_HISTORY_LIMIT || customInputHistoryBytes + bytes > CUSTOM_INPUT_HISTORY_BYTES) {
@@ -329,7 +331,11 @@ export function registerQuestionTool(pi: ExtensionAPI): void {
         const selectedCount = (): number => selectedOriginalIndices.size + (customAnswer === undefined ? 0 : 1);
         const orderedMultipleSelection = () => {
           const selectedIndices = [...selectedOriginalIndices].sort((left, right) => left - right);
-          const predefined = selectedIndices.map((index) => params.options[index - 1]!.label);
+          const predefined = selectedIndices.map((index) => {
+            const option = params.options[index - 1];
+            if (!option) throw new Error("Question selection no longer matches an available option");
+            return option.label;
+          });
           return {
             answers: customAnswer === undefined ? predefined : [...predefined, customAnswer],
             selectedIndices,
@@ -640,7 +646,8 @@ export function registerQuestionTool(pi: ExtensionAPI): void {
               lines.push(...(draftLines.length > 0 ? draftLines : [editMode === "filter" ? "Type a filter" : "Type an answer"]).slice(-contentRows));
             } else {
               for (let index = start; index < end; index += 1) {
-                const option = visibleOptions[index]!;
+                const option = visibleOptions[index];
+                if (!option) continue;
                 const color: ThemeColor = index === optionIndex ? "accent" : "text";
                 lines.push(theme.fg(color, truncateToWidth(optionLabel(option, index), width, "…")));
               }