killeros 2.0.18 → 2.0.19

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,14 +222,42 @@ 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 });
   }
@@ -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

@@ -42,7 +42,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

@@ -165,7 +165,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 +175,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 +230,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 +332,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 +647,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, "…")));
               }

package/killeros/runtime.ts

@@ -38,31 +38,63 @@ export interface GoalFileVerification {
   baseline: GoalFileBaseline;
 }
 
-export interface GoalState {
+export interface GoalStateCommon {
   version: 1;
   revision: number;
   objective: string;
-  status: GoalStatus;
   createdAt: number;
   updatedAt: number;
   activeMilliseconds: number;
-  activeStartedAt?: number;
   turns: number;
   blockedAuditStartTurn: number;
   baselineTokens: number;
-  result?: string;
-  resumeAfterManualCompaction?: true;
-  blockerAudit?: GoalBlockerAudit;
   verification?: GoalFileVerification;
 }
 
+export type GoalState = GoalStateCommon & (
+  | {
+      status: "active";
+      activeStartedAt: number;
+      result?: string;
+      blockerAudit?: GoalBlockerAudit;
+      resumeAfterManualCompaction?: never;
+    }
+  | {
+      status: "paused";
+      activeStartedAt?: never;
+      result?: string;
+      blockerAudit?: GoalBlockerAudit;
+      resumeAfterManualCompaction?: true;
+    }
+  | {
+      status: "blocked";
+      activeStartedAt?: never;
+      result: string;
+      blockerAudit?: GoalBlockerAudit;
+      resumeAfterManualCompaction?: never;
+    }
+  | {
+      status: "complete";
+      activeStartedAt?: never;
+      result: string;
+      blockerAudit?: never;
+      resumeAfterManualCompaction?: never;
+    }
+);
+
+export interface AutomaticGoalCompaction {
+  pausedRevision: number;
+  compactionSucceeded: boolean;
+  turnSettled: boolean;
+}
+
 export interface GoalRuntime {
   state?: GoalState;
   continuationScheduled: boolean;
   continuationHeld: boolean;
   goalTurnInFlight: boolean;
   agentEndObserved: boolean;
-  automaticCompaction?: "pending";
+  automaticCompaction?: AutomaticGoalCompaction;
   persistenceRetryNeeded: boolean;
   lastStopReason?: string;
   lastError?: string;

package/killeros/settings.ts

@@ -2,6 +2,7 @@ import { randomUUID } from "node:crypto";
 import { mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { hasErrorCode } from "./errors.ts";
 
 export type KillerosSettings = Record<string, unknown>;
 
@@ -10,15 +11,17 @@ export interface KillerosSettingsStore {
   update(patch: Readonly<Record<string, unknown>>): void;
 }
 
+function isSettings(value: unknown): value is KillerosSettings {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
 function readStoredSettings(settingsPath: string): KillerosSettings {
   try {
     const parsed: unknown = JSON.parse(readFileSync(settingsPath, "utf8"));
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-      throw new Error("KillerOS settings must contain a JSON object");
-    }
-    return parsed as KillerosSettings;
+    if (!isSettings(parsed)) throw new Error("KillerOS settings must contain a JSON object");
+    return parsed;
   } catch (error) {
-    if ((error as NodeJS.ErrnoException).code === "ENOENT") return {};
+    if (hasErrorCode(error, "ENOENT")) return {};
     throw error;
   }
 }

package/killeros/shell-ui.ts

@@ -25,14 +25,19 @@ import {
 } from "./commands.ts";
 import { reportError } from "./errors.ts";
 import { formatModel } from "./footer.ts";
-import { LEVEL_COLORS, type ThinkingLevel } from "./variants.ts";
+import { LEVEL_COLORS } from "./variants.ts";
 
 const COMPACT_HEADER_MAX_WIDTH = 52;
 
 function readPackageVersion(path: string | URL): string | undefined {
   try {
-    const value = JSON.parse(readFileSync(path, "utf8")) as { version?: unknown };
-    return typeof value.version === "string" ? value.version : undefined;
+    const value: unknown = JSON.parse(readFileSync(path, "utf8"));
+    return typeof value === "object"
+      && value !== null
+      && "version" in value
+      && typeof value.version === "string"
+      ? value.version
+      : undefined;
   } catch {
     return undefined;
   }
@@ -93,7 +98,11 @@ function shuffledDeck(values: readonly string[]): string[] {
   const deck = [...values];
   for (let index = deck.length - 1; index > 0; index -= 1) {
     const swapIndex = Math.floor(Math.random() * (index + 1));
-    [deck[index], deck[swapIndex]] = [deck[swapIndex]!, deck[index]!];
+    const current = deck[index];
+    const swap = deck[swapIndex];
+    if (current === undefined || swap === undefined) continue;
+    deck[index] = swap;
+    deck[swapIndex] = current;
   }
   return deck;
 }
@@ -152,7 +161,7 @@ class PiStartupHeader {
     const innerWidth = panelWidth - 4;
     const version = KILLEROS_VERSION ? theme.fg("dim", ` (v${KILLEROS_VERSION})`) : "";
     const identity = `${theme.fg("dim", "›")} ${theme.fg("text", theme.bold("KillerOS"))}${version}`;
-    const thinkingLevel = this.pi.getThinkingLevel() as ThinkingLevel;
+    const thinkingLevel = this.pi.getThinkingLevel();
     const reasoning = this.ctx.model?.reasoning === false
       ? theme.fg("thinkingOff", "no reasoning")
       : theme.fg(LEVEL_COLORS[thinkingLevel], thinkingLevel);