killeros 2.0.5 → 2.0.7

package/killeros/runtime.ts

@@ -5,10 +5,12 @@ export type InitOutcome =
   | { kind: "pending" }
   | { kind: "written" }
   | { kind: "policy-conflict"; reason: string }
+  | { kind: "cancelled" }
   | { kind: "no-outcome" };
 
 export interface InitRuntime {
   active: boolean;
+  starting?: symbol;
   targetPath?: string;
   projectRoot?: string;
   activeTools?: string[];
@@ -26,6 +28,11 @@ export interface GoalBlockerAudit {
   lastTurn: number;
 }
 
+export interface GoalFileVerification {
+  kind: "file";
+  path: string;
+}
+
 export interface GoalState {
   version: 1;
   revision: number;
@@ -41,6 +48,7 @@ export interface GoalState {
   result?: string;
   resumeAfterManualCompaction?: true;
   blockerAudit?: GoalBlockerAudit;
+  verification?: GoalFileVerification;
 }
 
 export interface GoalRuntime {
@@ -71,6 +79,7 @@ export function createGoalRuntime(): GoalRuntime {
 
 export function resetInitRuntime(state: InitRuntime): void {
   state.active = false;
+  state.starting = undefined;
   state.targetPath = undefined;
   state.projectRoot = undefined;
   state.activeTools = undefined;

package/killeros/shell-ui.ts

@@ -2,7 +2,6 @@ import { execFile } from "node:child_process";
 import { readFileSync } from "node:fs";
 import {
   CustomEditor,
-  DynamicBorder,
   VERSION,
   type ExtensionAPI,
   type ExtensionContext,
@@ -10,9 +9,7 @@ import {
   type Theme,
 } from "@earendil-works/pi-coding-agent";
 import {
-  Container,
   CURSOR_MARKER,
-  Text,
   truncateToWidth,
   visibleWidth,
   wrapTextWithAnsi,
@@ -182,7 +179,7 @@ function isBorderLine(line: string): boolean {
 
 function isScrolledTopBorder(line: string): boolean {
   const unstyled = stripAnsi(line);
-  return unstyled.includes("↑") || unstyled.includes(".");
+  return unstyled.includes("↑");
 }
 
 class PiCodeEditor extends CustomEditor {
@@ -219,10 +216,9 @@ class PiCodeEditor extends CustomEditor {
 
   override render(width: number): string[] {
     if (width <= 0) return [];
-    if (width < 4) return super.render(width).map((line) => truncateToWidth(line, width, ""));
-    const innerWidth = width - 2;
+    const innerWidth = Math.max(1, width - 2);
     const lines = super.render(innerWidth);
-    if (lines.length < 2) return lines.map((line) => truncateToWidth(line, width, ""));
+    if (lines.length < 2) return ["", ...lines.map((line) => truncateToWidth(line, width, ""))];
     let bottomBorderIndex = lines.length - 1;
     for (let index = lines.length - 1; index >= 1; index -= 1) {
       if (isBorderLine(lines[index] ?? "")) {
@@ -231,44 +227,40 @@ class PiCodeEditor extends CustomEditor {
       }
     }
 
-    const gray = (text: string): string => this.runtimeTheme.fg("dim", text);
-    const framed: string[] = [];
+    const dim = (text: string): string => this.runtimeTheme.fg("dim", text);
+    const rendered: string[] = [];
     const top = stripAnsi(lines[0] ?? "");
     const isScrolledHeader = isScrolledTopBorder(lines[0] ?? "");
     if (isScrolledHeader) {
       const count = top.match(/↑\s*(\d+)/)?.[1] ?? "";
-      const indicator = `${gray("─── ↑ ")}${count}${gray(" more ")}${gray("─".repeat(Math.max(0, width - 12 - count.length)))}`;
-      framed.push(truncateToWidth(indicator, width, ""));
-    } else {
-      framed.push(gray("─".repeat(width)));
+      rendered.push(truncateToWidth(dim(`  ↑ ${count} more`), width, ""));
     }
 
     for (let index = 1; index < bottomBorderIndex; index += 1) {
       const isPromptLine = index === 1 && !isScrolledHeader;
-      const prefix = isPromptLine ? gray("❯\u00A0") : "  ";
+      const prefix = isPromptLine
+        ? this.runtimeTheme.fg(this.focused ? "accent" : "dim", "❯\u00A0")
+        : "  ";
       let content = lines[index] ?? "";
       if (isPromptLine && this.getText() === "") {
         const first = this.suggestion.slice(0, 1);
         const rest = this.suggestion.slice(1);
         const cursorMarker = this.focused ? CURSOR_MARKER : "";
-        content = `${cursorMarker}\x1B[7m${gray(first)}\x1B[27m${gray(rest)}`;
+        content = `${cursorMarker}\x1B[7m${dim(first)}\x1B[27m${dim(rest)}`;
       }
-      framed.push(`${prefix}${padRight(content, innerWidth)}`);
+      rendered.push(`${prefix}${padRight(content, innerWidth)}`);
     }
 
     const bottom = stripAnsi(lines[bottomBorderIndex] ?? "");
     if (bottom.includes("↓")) {
       const count = bottom.match(/↓\s*(\d+)/)?.[1] ?? "";
-      const indicator = `${gray("─── ↓ ")}${count}${gray(" more ")}${gray("─".repeat(Math.max(0, width - 12 - count.length)))}`;
-      framed.push(truncateToWidth(indicator, width, ""));
-    } else {
-      framed.push(gray("─".repeat(width)));
+      rendered.push(truncateToWidth(dim(`  ↓ ${count} more`), width, ""));
     }
 
     for (let index = bottomBorderIndex + 1; index < lines.length; index += 1) {
-      framed.push(`  ${padRight(lines[index] ?? "", innerWidth)}`);
+      rendered.push(`  ${padRight(lines[index] ?? "", innerWidth)}`);
     }
-    return framed.map((line) => truncateToWidth(line, width, ""));
+    return ["", ...rendered.map((line) => truncateToWidth(line, width, ""))];
   }
 }
 
@@ -277,39 +269,11 @@ const ACTIVITY_FRAMES = [
   "✽", "✻", "✶", "✱", "✢", "·",
 ] as const;
 const ACTIVITY_FRAME_INTERVAL_MS = 120;
-const ACTIVITY_WORDS = ["Brewing", "Pondering", "Tinkering", "Wrangling", "Noodling", "Cooking"] as const;
-
-function formatActivityMessage(word: string, theme: Theme): string {
-  return `${theme.fg("accent", `${word}…`)} ${theme.fg("dim", `(${theme.bold("esc")} to interrupt · thinking)`)}`;
-}
 
 let killerosEditorFactory: ReturnType<ExtensionContext["ui"]["getEditorComponent"]>;
 
 export function registerShellUi(pi: ExtensionAPI): void {
   let activeHeader: PiStartupHeader | undefined;
-  let activityDeck: string[] = [];
-  let lastActivityWord: string | undefined;
-  let activityTimer: ReturnType<typeof setInterval> | undefined;
-  const refillActivityDeck = (): void => {
-    activityDeck = [...ACTIVITY_WORDS];
-    for (let index = activityDeck.length - 1; index > 0; index -= 1) {
-      const swapIndex = Math.floor(Math.random() * (index + 1));
-      [activityDeck[index], activityDeck[swapIndex]] = [activityDeck[swapIndex]!, activityDeck[index]!];
-    }
-    if (activityDeck.length > 1 && activityDeck.at(-1) === lastActivityWord) {
-      [activityDeck[0], activityDeck[activityDeck.length - 1]] = [activityDeck.at(-1)!, activityDeck[0]!];
-    }
-  };
-  const nextActivityWord = (): string => {
-    if (activityDeck.length === 0) refillActivityDeck();
-    const word = activityDeck.pop() ?? ACTIVITY_WORDS[0];
-    lastActivityWord = word;
-    return word;
-  };
-  const clearActivityTimer = (): void => {
-    if (activityTimer) clearInterval(activityTimer);
-    activityTimer = undefined;
-  };
 
   pi.on("session_start", (_event, ctx) => {
     if (ctx.mode !== "tui") return;
@@ -321,7 +285,6 @@ export function registerShellUi(pi: ExtensionAPI): void {
         activeHeader = new PiStartupHeader(pi, ctx, startupTip, tui);
         return activeHeader;
       });
-      clearActivityTimer();
       ctx.ui.setWorkingIndicator({
         frames: ACTIVITY_FRAMES.map((frame) => ctx.ui.theme.fg("accent", frame)),
         intervalMs: ACTIVITY_FRAME_INTERVAL_MS,
@@ -339,25 +302,8 @@ export function registerShellUi(pi: ExtensionAPI): void {
     }
   });
 
-  pi.on("agent_start", (_event, ctx) => {
-    if (ctx.mode !== "tui") return;
-    clearActivityTimer();
-    const updateWorkingWord = (): void => ctx.ui.setWorkingMessage(formatActivityMessage(nextActivityWord(), ctx.ui.theme));
-    updateWorkingWord();
-    activityTimer = setInterval(updateWorkingWord, 2_500);
-    activityTimer.unref?.();
-  });
-
-  pi.on("agent_end", (_event, ctx) => {
-    clearActivityTimer();
-    if (ctx.mode === "tui") ctx.ui.setWorkingMessage();
-  });
-
   pi.on("session_shutdown", () => {
-    clearActivityTimer();
     activeHeader?.dispose();
     activeHeader = undefined;
-    activityDeck = [];
-    lastActivityWord = undefined;
   });
 }

package/killeros/variants.ts

@@ -1,9 +1,9 @@
-import { DynamicBorder, keyHint, type ExtensionAPI, type ExtensionContext, type ThemeColor } from "@earendil-works/pi-coding-agent";
-import { Container, SelectList, Text, truncateToWidth } from "@earendil-works/pi-tui";
+import { DynamicBorder, type ExtensionAPI, type ExtensionContext, type ThemeColor } from "@earendil-works/pi-coding-agent";
+import { SelectList, truncateToWidth } from "@earendil-works/pi-tui";
 
-export type ThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+export type ThinkingLevel = ReturnType<ExtensionAPI["getThinkingLevel"]>;
 
-const ALL_LEVELS: readonly ThinkingLevel[] = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
+const ALL_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"] as const satisfies readonly ThinkingLevel[];
 const LEVEL_LABELS: Readonly<Record<ThinkingLevel, string>> = {
   off: "Off",
   minimal: "Minimal",
@@ -42,7 +42,7 @@ const LEVEL_ALIASES: Readonly<Record<string, ThinkingLevel>> = {
 };
 
 function isThinkingLevel(value: string): value is ThinkingLevel {
-  return (ALL_LEVELS as readonly string[]).includes(value);
+  return ALL_LEVELS.some((level) => level === value);
 }
 
 function resolveThinkingLevel(input: string): ThinkingLevel | undefined {
@@ -96,40 +96,82 @@ export function registerVariants(pi: ExtensionAPI): void {
         ctx.ui.notify(`${modelLabel(ctx.model)} does not support extended reasoning`, "info");
         return;
       }
-      const current = pi.getThinkingLevel() as ThinkingLevel;
+      const current = pi.getThinkingLevel();
       const items = supported.map((level) => ({
         value: level,
         label: level === current ? `${LEVEL_LABELS[level]} ← current` : LEVEL_LABELS[level],
         description: LEVEL_DESCRIPTIONS[level],
       }));
-      const selected = await ctx.ui.custom<ThinkingLevel | null>((tui, theme, _keybindings, done) => {
-        const container = new Container();
-        container.addChild(new DynamicBorder((text: string) => theme.fg("accent", text)));
-        container.addChild(new Text(theme.fg("accent", theme.bold("Thinking variants")), 1, 0));
-        container.addChild(new Text(theme.fg("dim", `Model: ${modelLabel(ctx.model)}`), 1, 0));
-        container.addChild(new Text("", 0, 0));
-        const selectList = new SelectList(items, Math.min(items.length, 10), {
-          selectedPrefix: (text) => theme.fg("accent", text),
-          selectedText: (text) => theme.fg("accent", text),
-          description: (text) => theme.fg("muted", text),
-          scrollInfo: (text) => theme.fg("dim", text),
-          noMatch: (text) => theme.fg("warning", text),
-        });
-        selectList.onSelect = (item) => done(isThinkingLevel(item.value) ? item.value : null);
-        selectList.onCancel = () => done(null);
-        container.addChild(selectList);
-        container.addChild(new Text("", 0, 0));
-        container.addChild(new Text(
-          theme.fg("dim", `${keyHint("tui.select.up", "up")} • ${keyHint("tui.select.down", "down")} • ${keyHint("tui.select.confirm", "select")} • ${keyHint("tui.select.cancel", "cancel")}`),
-          1,
-          0,
-        ));
-        container.addChild(new DynamicBorder((text: string) => theme.fg("accent", text)));
+      const selected = await ctx.ui.custom<ThinkingLevel | null>((tui, theme, keybindings, done) => {
+        const listTheme = {
+          selectedPrefix: (text: string) => theme.fg("accent", text),
+          selectedText: (text: string) => theme.fg("accent", text),
+          description: (text: string) => theme.fg("muted", text),
+          scrollInfo: (text: string) => theme.fg("dim", text),
+          noMatch: (text: string) => theme.fg("warning", text),
+        };
+        let selectList: SelectList | undefined;
+        let visibleOptionRows = 0;
+
+        const chromeFor = (rowBudget: number): "full" | "compact" | "none" => (
+          rowBudget >= 8 ? "full" : rowBudget >= 4 ? "compact" : "none"
+        );
+        const visibleRowsFor = (rowBudget: number): number => {
+          const chrome = chromeFor(rowBudget);
+          const chromeRows = chrome === "full" ? 5 : chrome === "compact" ? 2 : 0;
+          const availableListRows = Math.max(1, rowBudget - chromeRows);
+          return availableListRows >= items.length
+            ? items.length
+            : Math.max(1, availableListRows - 1);
+        };
+        const ensureSelectList = (nextVisibleOptionRows: number): SelectList => {
+          if (selectList && visibleOptionRows === nextVisibleOptionRows) return selectList;
+          const selectedValue = selectList?.getSelectedItem()?.value ?? current;
+          const nextSelectList = new SelectList(items, nextVisibleOptionRows, listTheme);
+          const selectedIndex = items.findIndex((item) => item.value === selectedValue);
+          nextSelectList.setSelectedIndex(Math.max(0, selectedIndex));
+          nextSelectList.onSelect = (item) => done(isThinkingLevel(item.value) ? item.value : null);
+          nextSelectList.onCancel = () => done(null);
+          selectList = nextSelectList;
+          visibleOptionRows = nextVisibleOptionRows;
+          return nextSelectList;
+        };
+
+        const border = new DynamicBorder((text: string) => theme.fg("accent", text));
+        const title = ` ${theme.fg("accent", theme.bold("Thinking variants"))}`;
+        const model = ` ${theme.fg("dim", `Model: ${modelLabel(ctx.model)}`)}`;
+        const keyHint = (keybinding: Parameters<typeof keybindings.getKeys>[0], description: string): string => {
+          const keyText = keybindings.getKeys(keybinding)
+            .join("/")
+            .split("/")
+            .map((key) => key.split("+").map((part) => process.platform === "darwin" && part.toLocaleLowerCase() === "alt" ? "option" : part).join("+"))
+            .join("/");
+          return theme.fg("dim", keyText) + theme.fg("muted", ` ${description}`);
+        };
+        const controls = ` ${theme.fg("dim", `${keyHint("tui.select.up", "up")} • ${keyHint("tui.select.down", "down")} • ${keyHint("tui.select.confirm", "select")} • ${keyHint("tui.select.cancel", "cancel")}`)}`;
+
+        const render = (width: number): string[] => {
+          const rowBudget = Math.max(0, tui.terminal.rows);
+          if (width <= 0 || rowBudget === 0) return [];
+          const chrome = chromeFor(rowBudget);
+          const list = ensureSelectList(visibleRowsFor(rowBudget));
+          const lines: string[] = [];
+
+          if (chrome === "full") lines.push(...border.render(width));
+          if (chrome !== "none") lines.push(title);
+          if (chrome === "full") lines.push(model);
+          lines.push(...list.render(width));
+          if (chrome !== "none") lines.push(controls);
+          if (chrome === "full") lines.push(...border.render(width));
+
+          return lines.slice(0, rowBudget).map((line) => truncateToWidth(line, width, ""));
+        };
+
         return {
-          render: (width) => container.render(width).map((line) => truncateToWidth(line, width, "")),
-          invalidate: () => container.invalidate(),
+          render,
+          invalidate: () => selectList?.invalidate(),
           handleInput: (data) => {
-            selectList.handleInput(data);
+            ensureSelectList(visibleRowsFor(Math.max(1, tui.terminal.rows))).handleInput(data);
             tui.requestRender();
           },
         };

package/killeros/worked-for.ts

@@ -0,0 +1,135 @@
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { StopReason } from "@earendil-works/pi-ai";
+import { Text } from "@earendil-works/pi-tui";
+
+const WORKED_FOR_ENTRY_TYPE = "killeros-worked-for";
+
+interface WorkedForEntryDataV1 {
+  version: 1;
+  milliseconds: number;
+}
+
+export type WorkedForOutcome = "done" | "stopped" | "failed";
+
+interface WorkedForEntryDataV2 {
+  version: 2;
+  milliseconds: number;
+  outcome: WorkedForOutcome;
+}
+
+type WorkedForEntryData = WorkedForEntryDataV1 | WorkedForEntryDataV2;
+
+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 }>;
+
+function isWorkedForOutcome(value: unknown): value is WorkedForOutcome {
+  return value === "done" || value === "stopped" || value === "failed";
+}
+
+export function formatWorkedForDuration(milliseconds: number): string {
+  const boundedMilliseconds = Number.isFinite(milliseconds) ? Math.max(0, milliseconds) : 0;
+  const totalSeconds = Math.max(1, Math.floor(boundedMilliseconds / 1_000));
+  if (totalSeconds < 60) return `${totalSeconds}s`;
+
+  const totalMinutes = Math.floor(totalSeconds / 60);
+  if (totalMinutes < 60) {
+    return `${totalMinutes}m ${(totalSeconds % 60).toString().padStart(2, "0")}s`;
+  }
+
+  return `${Math.floor(totalMinutes / 60)}h ${(totalMinutes % 60).toString().padStart(2, "0")}m`;
+}
+
+function parseWorkedForEntryData(data: unknown): WorkedForEntryData | undefined {
+  if (!data || typeof data !== "object" || Array.isArray(data)) return undefined;
+  if (!("version" in data) || !("milliseconds" in data)) return undefined;
+  if (typeof data.milliseconds !== "number" || !Number.isFinite(data.milliseconds) || data.milliseconds < 0) {
+    return undefined;
+  }
+  if (data.version === 1) return { version: 1, milliseconds: data.milliseconds };
+  if (data.version !== 2 || !("outcome" in data) || !isWorkedForOutcome(data.outcome)) {
+    return undefined;
+  }
+  return { version: 2, milliseconds: data.milliseconds, outcome: data.outcome };
+}
+
+export function workedForOutcome(stopReason: StopReason | undefined): WorkedForOutcome {
+  if (stopReason === "stop") return "done";
+  if (stopReason === "aborted") return "stopped";
+  return "failed";
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+export function registerWorkedFor(
+  pi: ExtensionAPI,
+  now: () => number = Date.now,
+): void {
+  let startedAt: number | undefined;
+  let stopReason: StopReason | undefined;
+
+  pi.registerEntryRenderer<WorkedForEntryData>(WORKED_FOR_ENTRY_TYPE, (entry, _options, theme) => {
+    const data = parseWorkedForEntryData(entry.data);
+    if (!data) return undefined;
+    if (data.version === 1) {
+      return new Text(
+        theme.fg("dim", `✻ Worked for ${formatWorkedForDuration(data.milliseconds)}`),
+        0,
+        0,
+      );
+    }
+    const outcome = OUTCOMES[data.outcome];
+    return new Text(
+      `${theme.fg(outcome.color, `${outcome.marker} ${outcome.label}`)}${theme.fg("dim", ` · ${formatWorkedForDuration(data.milliseconds)}`)}`,
+      0,
+      0,
+    );
+  });
+
+  pi.on("session_start", () => {
+    startedAt = undefined;
+    stopReason = undefined;
+  });
+
+  pi.on("agent_start", (_event, ctx) => {
+    if (ctx.mode !== "tui" || startedAt !== undefined) return;
+    startedAt = now();
+  });
+
+  pi.on("agent_end", (event, ctx) => {
+    if (ctx.mode !== "tui" || startedAt === undefined) return;
+    for (let index = event.messages.length - 1; index >= 0; index -= 1) {
+      const message = event.messages[index];
+      if (message?.role !== "assistant") continue;
+      stopReason = message.stopReason;
+      break;
+    }
+  });
+
+  pi.on("agent_settled", (_event, ctx) => {
+    if (ctx.mode !== "tui" || startedAt === undefined) return;
+    if (!ctx.isIdle() || ctx.hasPendingMessages()) return;
+    const milliseconds = Math.max(0, now() - startedAt);
+    const outcome = workedForOutcome(stopReason);
+    startedAt = undefined;
+    stopReason = undefined;
+    try {
+      pi.appendEntry<WorkedForEntryDataV2>(WORKED_FOR_ENTRY_TYPE, {
+        version: 2,
+        milliseconds,
+        outcome,
+      });
+    } catch (error) {
+      ctx.ui.notify(`Worked-for timing could not be saved: ${errorMessage(error)}`, "error");
+    }
+  });
+
+  pi.on("session_shutdown", () => {
+    startedAt = undefined;
+    stopReason = undefined;
+  });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "killeros",
-  "version": "2.0.5",
+  "version": "2.0.7",
   "description": "TUI, goals, and workflow automation for the Pi coding agent",
   "type": "module",
   "keywords": [
@@ -42,14 +42,15 @@
     ]
   },
   "peerDependencies": {
-    "@earendil-works/pi-ai": ">=0.82.1",
-    "@earendil-works/pi-coding-agent": ">=0.82.1",
-    "@earendil-works/pi-tui": ">=0.82.1",
+    "@earendil-works/pi-ai": ">=0.84.1",
+    "@earendil-works/pi-coding-agent": ">=0.84.1",
+    "@earendil-works/pi-tui": ">=0.84.1",
     "typebox": ">=1.1.38 <2"
   },
   "devDependencies": {
-    "@earendil-works/pi-coding-agent": "0.82.1",
-    "@earendil-works/pi-tui": "0.82.1",
+    "@earendil-works/pi-ai": "0.84.1",
+    "@earendil-works/pi-coding-agent": "0.84.1",
+    "@earendil-works/pi-tui": "0.84.1",
     "@types/node": "24.12.4",
     "typebox": "1.1.38",
     "typescript": "5.9.3"