killeros 2.1.22 → 2.1.24

package/killeros/hooks.ts

@@ -1,4 +1,3 @@
-import { createHash } from "node:crypto";
 import {
   spawn,
   type SpawnOptionsWithStdioTuple,
@@ -9,8 +8,6 @@ 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 { errorMessage, reportError } from "./errors.ts";
-import { GOAL_CHECK_NAME_PATTERN } from "./goal-state.ts";
-import type { GoalCompletionCheck } from "./runtime.ts";
 import { safeTerminalText } from "./safe-terminal-text.ts";
 
 type KillerosHookEvent = "tool_call" | "tool_result" | "agent_settled";
@@ -21,14 +18,8 @@ interface KillerosHook {
   timeoutMs?: number;
 }
 
-interface KillerosGoalCheck {
-  command: string;
-  timeoutMs?: number;
-}
-
 interface KillerosHookConfig {
   hooks?: Partial<Record<KillerosHookEvent, KillerosHook[]>>;
-  goalChecks?: Record<string, KillerosGoalCheck>;
 }
 
 interface HookExecutionResult {
@@ -70,8 +61,6 @@ const HOOK_OUTPUT_LIMIT = 16 * 1024;
 const HOOK_PAYLOAD_LIMIT = 8_000;
 const HOOK_TIMEOUT_DEFAULT_MS = 30_000;
 const HOOK_TIMEOUT_MAX_MS = 300_000;
-const GOAL_CHECK_LIMIT = 32;
-const GOAL_CHECK_COMMAND_LIMIT = 8_000;
 
 // Reads executable project configuration through a bounded, project-local file descriptor.
 function readHookConfig(configPath: string, projectRoot: string): string {
@@ -122,12 +111,11 @@ function isUnknownRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
-function loadKillerosConfig(ctx: ExtensionContext, strictGoalChecks = false): KillerosHookConfig {
+function loadKillerosConfig(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()) {
-    if (strictGoalChecks) throw new Error("Goal completion checks require a trusted project");
     ctx.ui.notify(`Ignored untrusted project hooks in ${displayPath}`, "warning");
     return {};
   }
@@ -181,34 +169,8 @@ function loadKillerosConfig(ctx: ExtensionContext, strictGoalChecks = false): Ki
       hooks[event] = accepted;
     }
 
-    let goalChecks: Record<string, KillerosGoalCheck> | undefined;
-    try {
-      const candidates = parsed.goalChecks;
-      if (candidates !== undefined) {
-        if (!isUnknownRecord(candidates)) throw new Error("goalChecks must contain a JSON object");
-        const entries = Object.entries(candidates);
-        if (entries.length > GOAL_CHECK_LIMIT) throw new Error(`goalChecks may contain at most ${GOAL_CHECK_LIMIT} checks`);
-        goalChecks = {};
-        for (const [name, candidate] of entries) {
-          if (!GOAL_CHECK_NAME_PATTERN.test(name)) throw new Error(`Invalid goal check name: ${JSON.stringify(name)}`);
-          if (!isUnknownRecord(candidate)) throw new Error(`Goal check ${name} must contain a JSON object`);
-          const { command, timeoutMs } = candidate;
-          if (typeof command !== "string" || command.trim().length < 1 || command.trim().length > GOAL_CHECK_COMMAND_LIMIT) {
-            throw new Error(`Goal check ${name} command must contain 1 to ${GOAL_CHECK_COMMAND_LIMIT} characters`);
-          }
-          if (timeoutMs !== undefined && (typeof timeoutMs !== "number" || !Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > HOOK_TIMEOUT_MAX_MS)) {
-            throw new Error(`Goal check ${name} timeoutMs must be an integer from 1 to ${HOOK_TIMEOUT_MAX_MS}`);
-          }
-          goalChecks[name] = { command: command.trim(), ...(timeoutMs === undefined ? {} : { timeoutMs }) };
-        }
-      }
-    } catch (error) {
-      if (strictGoalChecks) throw error;
-      reportError(ctx, `Invalid ${CONFIG_DIR_NAME}/killeros-hooks.json goalChecks`, error);
-    }
-    return { hooks, ...(goalChecks === undefined ? {} : { goalChecks }) };
+    return { hooks };
   } catch (error) {
-    if (strictGoalChecks) throw error;
     reportError(ctx, `Invalid ${CONFIG_DIR_NAME}/killeros-hooks.json`, error);
     return {};
   }
@@ -427,48 +389,6 @@ function hookFailureMessage(result: HookExecutionResult): string {
   return safeTerminalText(`Hook failed${result.timedOut ? " (timed out)" : ""}${result.exitUnconfirmed ? " (process exit unconfirmed)" : ""}\n${detail}`);
 }
 
-function goalCheckHash(check: KillerosGoalCheck): string {
-  return createHash("sha256")
-    .update(JSON.stringify({ command: check.command, timeoutMs: check.timeoutMs ?? HOOK_TIMEOUT_DEFAULT_MS }))
-    .digest("hex");
-}
-
-/** Lists validated completion-check names without exposing their definitions. */
-export function listGoalCompletionChecks(ctx: ExtensionContext): readonly string[] {
-  if (!ctx.isProjectTrusted()) throw new Error("Goal completion checks require a trusted project");
-  return Object.keys(loadKillerosConfig(ctx, true).goalChecks ?? {}).sort();
-}
-
-export function resolveGoalCompletionCheck(ctx: ExtensionContext, name: string): GoalCompletionCheck {
-  if (!GOAL_CHECK_NAME_PATTERN.test(name)) throw new Error("Invalid goal completion check name");
-  if (!ctx.isProjectTrusted()) throw new Error("Goal completion checks require a trusted project");
-  const check = loadKillerosConfig(ctx, true).goalChecks?.[name];
-  if (!check) throw new Error(`Unknown goal completion check: ${safeTerminalText(name)}`);
-  return { kind: "named-command", name, configHash: goalCheckHash(check) };
-}
-
-export async function runGoalCompletionCheck(
-  ctx: ExtensionContext,
-  bound: GoalCompletionCheck,
-  signal?: AbortSignal,
-): Promise<void> {
-  if (!ctx.isProjectTrusted()) throw new Error("Goal completion checks require a trusted project");
-  const check = loadKillerosConfig(ctx, true).goalChecks?.[bound.name];
-  if (!check) throw new Error(`Unknown goal completion check: ${safeTerminalText(bound.name)}`);
-  if (goalCheckHash(check) !== bound.configHash) {
-    throw new Error(`Goal completion check ${safeTerminalText(bound.name)} changed; run /goal check ${safeTerminalText(bound.name)} to approve it`);
-  }
-  const result = await executeHook({
-    command: check.command,
-    cwd: ctx.cwd,
-    environment: { KILLEROS_EVENT: "goal_check", KILLEROS_GOAL_CHECK: bound.name },
-    timeoutMs: check.timeoutMs,
-    signal,
-  });
-  if (result.cancelled) throw new Error(`Goal completion check ${safeTerminalText(bound.name)} was cancelled`);
-  if (result.code !== 0) throw new Error(hookFailureMessage(result).replace(/^Hook failed/u, `Goal completion check ${safeTerminalText(bound.name)} failed`));
-}
-
 export function registerLifecycleHooks(pi: ExtensionAPI): void {
   let config: KillerosHookConfig = {};
   pi.on("session_start", (_event, ctx) => { config = loadKillerosConfig(ctx); });

package/killeros/runtime.ts

@@ -39,12 +39,6 @@ export interface GoalFileVerification {
   baseline: GoalFileBaseline;
 }
 
-export interface GoalCompletionCheck {
-  kind: "named-command";
-  name: string;
-  configHash: string;
-}
-
 export interface GoalStateCommon {
   version: 1;
   revision: number;
@@ -56,7 +50,6 @@ export interface GoalStateCommon {
   blockedAuditStartTurn: number;
   baselineTokens: number;
   verification?: GoalFileVerification;
-  completionCheck?: GoalCompletionCheck;
   maxTurns?: number;
 }
 

package/killeros/worked-for.ts

@@ -12,7 +12,7 @@ import {
   type ChangedFile,
   type CheckAttempt,
 } from "./change-receipt.ts";
-import { formatTokens } from "./display.ts";
+import { formatTokens, modelDisplayName } from "./display.ts";
 import { errorMessage } from "./errors.ts";
 import { safeTerminalText } from "./safe-terminal-text.ts";
 
@@ -47,15 +47,16 @@ export interface WorkedForEntryDataV4 {
   changes: ChangeSummary;
   checks: CheckAttempt[];
   omittedChecks: { passed: number; failed: number };
+  model?: string;
 }
 
 type WorkedForEntryData = WorkedForEntryDataV1 | WorkedForEntryDataV2 | WorkedForEntryDataV3 | WorkedForEntryDataV4;
 
 const OUTCOMES = {
-  done: { marker: "✓", label: "Done", color: "success" },
-  stopped: { marker: "■", label: "Stopped", color: "warning" },
-  failed: { marker: "×", label: "Failed", color: "error" },
-} as const satisfies Record<WorkedForOutcome, { marker: string; label: string; color: string }>;
+  done: { label: "Done", color: "success" },
+  stopped: { label: "■ Stopped", color: "warning" },
+  failed: { label: "× Failed", color: "error" },
+} as const satisfies Record<WorkedForOutcome, { label: string; color: string }>;
 
 function isWorkedForOutcome(value: unknown): value is WorkedForOutcome {
   return value === "done" || value === "stopped" || value === "failed";
@@ -121,6 +122,12 @@ function parseChanges(value: unknown): ChangeSummary | undefined {
   };
 }
 
+function parseModelName(value: unknown): string | undefined {
+  if (typeof value !== "string" || value.length > 200) return undefined;
+  const sanitized = safeTerminalText(value).replaceAll("\n", "").trim();
+  return sanitized || undefined;
+}
+
 function parseV4(data: Record<string, unknown>): WorkedForEntryDataV4 | undefined {
   try {
     if (Buffer.byteLength(JSON.stringify(data), "utf8") > MAX_PAYLOAD_BYTES) return undefined;
@@ -139,6 +146,7 @@ function parseV4(data: Record<string, unknown>): WorkedForEntryDataV4 | undefine
     if (!label) return undefined;
     checks.push({ label, outcome: check.outcome });
   }
+  const model = parseModelName(data.model);
   return {
     version: 4,
     milliseconds: data.milliseconds,
@@ -147,6 +155,7 @@ function parseV4(data: Record<string, unknown>): WorkedForEntryDataV4 | undefine
     changes,
     checks,
     omittedChecks: { passed: data.omittedChecks.passed, failed: data.omittedChecks.failed },
+    ...(model ? { model } : {}),
   };
 }
 
@@ -210,8 +219,10 @@ class WorkedForV4Component implements Component {
     if (width <= 0) return [];
     const { data, theme } = this;
     const outcome = OUTCOMES[data.outcome];
+    const headline = theme.fg(outcome.color, outcome.label);
+    const modelSuffix = data.model ? ` · ${data.model}` : "";
     const lines = [
-      `${theme.fg(outcome.color, `${outcome.marker} ${outcome.label}`)}${theme.fg("dim", ` · ${formatWorkedForDuration(data.milliseconds)} · ↑ ${formatTokens(data.tokens)} tokens`)}`,
+      `${headline}${theme.fg("dim", ` · ${formatWorkedForDuration(data.milliseconds)} · ↑ ${formatTokens(data.tokens)} tokens${modelSuffix}`)}`,
     ];
     if (data.changes.state === "unavailable") lines.push(theme.fg("dim", "  Changes unavailable"));
     else if (data.changes.totalFiles === 0) lines.push(theme.fg("dim", "  No files changed"));
@@ -272,8 +283,22 @@ type ActiveReceipt = {
   collection: Promise<ChangeReceiptCollection>;
   checks: CheckAttempt[];
   omittedChecks: { passed: number; failed: number };
+  modelProvider: string | undefined;
+  modelId: string | undefined;
+  modelMismatch: boolean;
 };
 
+function receiptModelName(
+  settled: ActiveReceipt,
+  model: ExtensionContext["model"],
+): string | undefined {
+  if (settled.modelMismatch || settled.modelProvider === undefined || settled.modelId === undefined) return undefined;
+  if (!model || model.provider !== settled.modelProvider || model.id !== settled.modelId) return undefined;
+  const resolved = modelDisplayName(model);
+  if (!resolved || resolved.length > 200) return undefined;
+  return resolved;
+}
+
 function fitPayload(data: WorkedForEntryDataV4): WorkedForEntryDataV4 {
   if (data.changes.state === "unavailable") return data;
   const changes = { ...data.changes, files: [...data.changes.files] };
@@ -300,7 +325,8 @@ export function registerWorkedFor(
     if (data.version === 4) return new WorkedForV4Component(data, options.expanded, theme);
     const outcome = OUTCOMES[data.outcome];
     const tokens = data.version === 3 ? ` · ↑ ${formatTokens(data.tokens)} tokens` : "";
-    return new Text(`${theme.fg(outcome.color, `${outcome.marker} ${outcome.label}`)}${theme.fg("dim", ` · ${formatWorkedForDuration(data.milliseconds)}${tokens}`)}`, 0, 0);
+    const headline = theme.fg(outcome.color, outcome.label);
+    return new Text(`${headline}${theme.fg("dim", ` · ${formatWorkedForDuration(data.milliseconds)}${tokens}`)}`, 0, 0);
   });
 
   pi.on("session_start", async () => {
@@ -319,12 +345,35 @@ export function registerWorkedFor(
       collection: collect(ctx.cwd),
       checks: [],
       omittedChecks: { passed: 0, failed: 0 },
+      modelProvider: undefined,
+      modelId: undefined,
+      modelMismatch: false,
     };
     active = state;
     const collection = await state.collection;
     if (active !== state) await collection.dispose();
   });
 
+  pi.on("message_end", (event, ctx) => {
+    if (ctx.mode !== "tui" || !active) return;
+    if (event.message.role !== "assistant") return;
+    const provider: unknown = event.message.provider;
+    const modelId: unknown = event.message.model;
+    if (typeof provider !== "string" || typeof modelId !== "string") {
+      active.modelMismatch = true;
+      return;
+    }
+    if (active.modelProvider === undefined || active.modelId === undefined) {
+      active.modelProvider = provider;
+      active.modelId = modelId;
+    } else if (active.modelProvider !== provider || active.modelId !== modelId) {
+      active.modelMismatch = true;
+    }
+    if (event.message.responseModel !== undefined && event.message.responseModel !== modelId) {
+      active.modelMismatch = true;
+    }
+  });
+
   pi.on("tool_result", (event: ToolResultEvent, ctx) => {
     if (ctx.mode !== "tui" || !active || event.toolName !== "bash" && event.toolName !== "powershell") return;
     const check = recognizedCheck(event.input.command, event.isError);
@@ -347,8 +396,9 @@ export function registerWorkedFor(
     if (ctx.mode !== "tui" || !active) return;
     const settled = active;
     active = undefined;
+    const model = receiptModelName(settled, ctx.model);
     const changes = await (await settled.collection).finish();
-    if (changes.state === "unavailable" && changes.reason !== "not-git" && !collectionNoticeShown) {
+    if (changes.state === "unavailable" && changes.reason !== "not-git" && changes.reason !== "timeout" && !collectionNoticeShown) {
       collectionNoticeShown = true;
       ctx.ui.notify(`Change receipt unavailable: ${changes.reason}`, "warning");
     }
@@ -361,6 +411,7 @@ export function registerWorkedFor(
       changes,
       checks: settled.checks,
       omittedChecks: settled.omittedChecks,
+      ...(model ? { model } : {}),
     });
     try {
       pi.appendEntry<WorkedForEntryDataV4>(WORKED_FOR_ENTRY_TYPE, data);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "killeros",
-  "version": "2.1.22",
+  "version": "2.1.24",
   "description": "TUI, goals, and workflow automation for the Pi coding agent",
   "type": "module",
   "keywords": [
@@ -44,15 +44,16 @@
     ]
   },
   "peerDependencies": {
-    "@earendil-works/pi-ai": ">=0.84.3 <1",
-    "@earendil-works/pi-coding-agent": ">=0.84.3 <1",
-    "@earendil-works/pi-tui": ">=0.84.3 <1",
+    "@earendil-works/pi-ai": ">=0.85.0 <1",
+    "@earendil-works/pi-coding-agent": ">=0.85.0 <1",
+    "@earendil-works/pi-tui": ">=0.85.0 <1",
     "typebox": ">=1.1.38 <2"
   },
   "devDependencies": {
-    "@earendil-works/pi-ai": "0.84.3",
-    "@earendil-works/pi-coding-agent": "0.84.3",
-    "@earendil-works/pi-tui": "0.84.3",
+    "@earendil-works/pi-ai": "0.85.0",
+    "@earendil-works/pi-coding-agent": "0.85.0",
+    "@earendil-works/pi-server": "0.85.0",
+    "@earendil-works/pi-tui": "0.85.0",
     "@types/node": "24.12.4",
     "eslint": "^10.9.1",
     "typebox": "1.3.20",

package/killeros/goal-history.ts

@@ -1,71 +0,0 @@
-import { formatTime, formatTokens } from "./display.ts";
-import { parseGoalState } from "./goal-state.ts";
-import type { GoalState } from "./runtime.ts";
-import { safeTerminalText } from "./safe-terminal-text.ts";
-
-const GOAL_ENTRY_TYPE = "killeros-goal";
-const VALID_GOAL_EVENTS: ReadonlySet<string> = new Set([
-  "set", "replace", "edit", "check", "limit", "turn", "pause", "resume",
-  "blocker-audit", "blocked", "complete", "error", "clear", "checkpoint",
-]);
-function isUnknownRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-function tokenUsage(entry: Record<string, unknown>): number | undefined {
-  if (entry.type === "message" && isUnknownRecord(entry.message)
-    && (entry.message.role === "assistant" || entry.message.role === "toolResult")
-    && isUnknownRecord(entry.message.usage)
-    && typeof entry.message.usage.totalTokens === "number"
-    && Number.isFinite(entry.message.usage.totalTokens)
-    && entry.message.usage.totalTokens >= 0) {
-    return entry.message.usage.totalTokens;
-  }
-  if ((entry.type === "compaction" || entry.type === "branch_summary")
-    && isUnknownRecord(entry.usage)
-    && typeof entry.usage.totalTokens === "number"
-    && Number.isFinite(entry.usage.totalTokens)
-    && entry.usage.totalTokens >= 0) {
-    return entry.usage.totalTokens;
-  }
-  return undefined;
-}
-
-function preview(value: string): string {
-  const safe = safeTerminalText(value).replaceAll("\n", " ").trim();
-  const characters = [...safe];
-  return characters.length <= 160 ? safe : `${characters.slice(0, 159).join("")}…`;
-}
-
-function eventDetail(event: string, state: GoalState): string {
-  if (event === "check") return state.completionCheck ? `check ${state.completionCheck.name}` : "check cleared";
-  if (event === "limit") return state.maxTurns === undefined ? "limit cleared" : `limit ${state.maxTurns}`;
-  if (event === "blocker-audit" && state.blockerAudit) {
-    return `Blocker ${state.blockerAudit.streak}/3: ${state.blockerAudit.evidence ?? state.blockerAudit.key}`;
-  }
-  return state.result || state.objective;
-}
-
-/** Projects branch entries into the latest bounded goal-history rows. */
-export function formatGoalHistory(entries: readonly unknown[], count: number): string | undefined {
-  const lines: string[] = [];
-  let tokens = 0;
-  let previousState: GoalState | undefined;
-  for (const value of entries) {
-    if (!isUnknownRecord(value)) continue;
-    const usage = tokenUsage(value);
-    if (usage !== undefined) {
-      tokens += usage;
-      continue;
-    }
-    if (value.type !== "custom" || value.customType !== GOAL_ENTRY_TYPE || !isUnknownRecord(value.data)) continue;
-    const event = value.data.event;
-    if (typeof event !== "string" || !VALID_GOAL_EVENTS.has(event)) continue;
-    const state = value.data.state === null ? previousState : parseGoalState(value.data.state);
-    if (!state) continue;
-    if (value.data.state !== null) previousState = state;
-    if (event === "turn" || event === "checkpoint") continue;
-    lines.push(`+${formatTime(Math.max(0, state.updatedAt - state.createdAt))}  ${event}  turn ${state.turns}  ${formatTokens(Math.max(0, tokens - state.baselineTokens))} tokens  ${preview(eventDetail(event, state))}`);
-  }
-  return lines.length ? lines.slice(-count).join("\n") : undefined;
-}