killeros 2.0.6 → 2.0.8

package/killeros/goals.ts

@@ -1,4 +1,6 @@
 import { StringEnum } from "@earendil-works/pi-ai";
+import { lstatSync } from "node:fs";
+import path from "node:path";
 import { type ExtensionAPI, type ExtensionCommandContext, type ExtensionContext, type ThemeColor } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
@@ -7,10 +9,11 @@ import { BoundedText } from "./bounded-text.ts";
 import { formatTime, formatTokens } from "./display.ts";
 import { reportError } from "./errors.ts";
 import { resolvePersonalInstructions } from "./personal-instructions.ts";
-import type { GoalBlockerAudit, GoalRuntime, GoalState, GoalStatus, InitRuntime } from "./runtime.ts";
+import type { GoalBlockerAudit, GoalFileVerification, GoalRuntime, GoalState, GoalStatus, InitRuntime } from "./runtime.ts";
 
 const GOAL_ENTRY_TYPE = "killeros-goal";
 const GOAL_CONTINUATION_TYPE = "killeros-goal-continuation";
+const GOAL_UPDATE_TOOL = "killeros_goal_update";
 const GOAL_OBJECTIVE_LIMIT = 4_000;
 const GOAL_VERSION = 1;
 
@@ -29,7 +32,6 @@ interface GoalTransitionOptions {
 
 interface RestoredGoalState {
   state?: GoalState;
-  recoveryProven: boolean;
 }
 
 const GoalUpdateParams = Type.Object({
@@ -52,6 +54,7 @@ const GoalUpdateParams = Type.Object({
 interface GoalUpdateDetails {
   status: "complete" | "blocked" | "blocker-audit";
   evidence: string;
+  verification?: "file" | "model-reported";
   blockerKey?: string;
   streak?: number;
 }
@@ -64,6 +67,41 @@ function finiteNonNegative(value: unknown): value is number {
   return typeof value === "number" && Number.isFinite(value) && value >= 0;
 }
 
+function isGoalFileVerification(value: unknown): value is GoalFileVerification {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value as Partial<GoalFileVerification>;
+  return candidate.kind === "file"
+    && typeof candidate.path === "string"
+    && candidate.path === candidate.path.trim()
+    && isAbsoluteFilePath(candidate.path);
+}
+
+function isAbsoluteFilePath(value: string): boolean {
+  if (!value || /^(?:https?|file):\/\//iu.test(value) || /[\\\/]$/u.test(value)) return false;
+  return path.isAbsolute(value) || path.win32.isAbsolute(value);
+}
+
+function inferGoalVerification(objective: string): GoalFileVerification | undefined {
+  const destination = /\b(?:create|write|save|generate)\b[^\r\n]{0,160}?\b(?:file|document|markdown|report|spreadsheet|presentation|image)\b\s+(?:to|at|as|destination(?:\s+is)?|output(?:\s+(?:to|at))?)\b\s*(?:`([^`\r\n]+)`|"([^"\r\n]+)"|'([^'\r\n]+)'|([A-Za-z]:\\[^\s,;]+|\/[^\s,;]+))/giu;
+  const paths = [...objective.matchAll(destination)]
+    .map((match) => (match[1] ?? match[2] ?? match[3] ?? match[4] ?? "").trim())
+    .filter(isAbsoluteFilePath);
+  const unique = [...new Set(paths)];
+  return unique.length === 1 ? { kind: "file", path: unique[0]! } : undefined;
+}
+
+function verifyGoalDeliverable(verification: GoalFileVerification): void {
+  let artifact: ReturnType<typeof lstatSync>;
+  try {
+    artifact = lstatSync(verification.path);
+  } catch {
+    throw new Error(`Goal deliverable is not a regular file at the required path: ${verification.path}`);
+  }
+  if (!artifact.isFile()) {
+    throw new Error(`Goal deliverable is not a regular file at the required path: ${verification.path}`);
+  }
+}
+
 function isGoalBlockerAudit(value: unknown, turns: number, status: GoalStatus): value is GoalBlockerAudit {
   if (!value || typeof value !== "object") return false;
   const candidate = value as Partial<GoalBlockerAudit>;
@@ -92,6 +130,7 @@ function parseGoalState(value: unknown): GoalState | undefined {
     || !finiteNonNegative(candidate.baselineTokens)
     || candidate.activeStartedAt !== undefined && !finiteNonNegative(candidate.activeStartedAt)
     || candidate.result !== undefined && typeof candidate.result !== "string"
+    || candidate.verification !== undefined && !isGoalFileVerification(candidate.verification)
     || candidate.blockerAudit !== undefined && !isGoalBlockerAudit(candidate.blockerAudit, candidate.turns!, candidate.status)
     || candidate.resumeAfterManualCompaction !== undefined && candidate.resumeAfterManualCompaction !== true
     || candidate.resumeAfterManualCompaction === true && candidate.status !== "paused") {
@@ -112,6 +151,7 @@ function parseGoalState(value: unknown): GoalState | undefined {
     result: candidate.result,
     resumeAfterManualCompaction: candidate.resumeAfterManualCompaction,
     blockerAudit: candidate.blockerAudit,
+    verification: candidate.verification,
   };
 }
 
@@ -130,19 +170,17 @@ function restoreGoalState(ctx: ExtensionContext): RestoredGoalState {
     if (entry?.type !== "custom" || entry.customType !== GOAL_ENTRY_TYPE) continue;
     const data = entry.data as Partial<GoalEntryData> | undefined;
     if (!data || data.version !== GOAL_VERSION || data.state === null) {
-      return { state: undefined, recoveryProven: false };
+      return { state: undefined };
     }
     const restored = parseGoalState(data.state);
-    if (!restored) return { state: undefined, recoveryProven: false };
+    if (!restored) return { state: undefined };
     const state = restored.status === "active"
       ? { ...restored, activeStartedAt: Date.now() }
       : { ...restored, activeStartedAt: undefined };
-    const recoveryProven = state.status === "paused"
-      && state.resumeAfterManualCompaction === true
-      && entries.slice(index + 1).some((candidate) => candidate.type === "compaction");
-    return { state, recoveryProven };
+    if (state.status === "paused") state.resumeAfterManualCompaction = undefined;
+    return { state };
   }
-  return { state: undefined, recoveryProven: false };
+  return { state: undefined };
 }
 
 export function goalElapsedMilliseconds(state: GoalState, now = Date.now()): number {
@@ -173,6 +211,21 @@ function sumGoalTokens(ctx: ExtensionContext): number {
   return total;
 }
 
+function setGoalUpdateToolActive(pi: ExtensionAPI, active: boolean): void {
+  const api = pi as ExtensionAPI & { getActiveTools?: () => string[]; setActiveTools?: (names: string[]) => void };
+  if (!api.getActiveTools || !api.setActiveTools) return;
+  const activeTools = api.getActiveTools();
+  const isActive = activeTools.includes(GOAL_UPDATE_TOOL);
+  if (active === isActive) return;
+  api.setActiveTools(active
+    ? [...activeTools, GOAL_UPDATE_TOOL]
+    : activeTools.filter((name) => name !== GOAL_UPDATE_TOOL));
+}
+
+function syncGoalUpdateTool(pi: ExtensionAPI, runtime: GoalRuntime): void {
+  setGoalUpdateToolActive(pi, runtime.state?.status === "active");
+}
+
 function persistGoalState(
   pi: ExtensionAPI,
   runtime: GoalRuntime,
@@ -182,6 +235,7 @@ function persistGoalState(
   const data: GoalEntryData = { version: GOAL_VERSION, event, state: state ?? null };
   pi.appendEntry(GOAL_ENTRY_TYPE, data);
   runtime.state = state;
+  syncGoalUpdateTool(pi, runtime);
   runtime.persistenceRetryNeeded = false;
   runtime.requestRender?.();
 }
@@ -276,6 +330,7 @@ export function pauseGoalAfterFailure(
       result: reason,
       resumeAfterManualCompaction: undefined,
     } : undefined;
+    syncGoalUpdateTool(pi, runtime);
     runtime.persistenceRetryNeeded = true;
     runtime.continuationScheduled = false;
     runtime.requestRender?.();
@@ -301,6 +356,7 @@ function pauseGoalForPossibleManualCompaction(
       result: reason,
       resumeAfterManualCompaction: true,
     } : undefined;
+    syncGoalUpdateTool(pi, runtime);
     runtime.persistenceRetryNeeded = true;
     runtime.continuationScheduled = false;
     runtime.requestRender?.();
@@ -465,7 +521,7 @@ export function registerGoal(
   });
 
   pi.registerTool<typeof GoalUpdateParams, GoalUpdateDetails>({
-    name: "killeros_goal_update",
+    name: GOAL_UPDATE_TOOL,
     label: "Goal update",
     description: "Mark the active KillerOS long-running goal complete after verification, or record the same blocker key on three consecutive goal turns before blocking it.",
     parameters: GoalUpdateParams,
@@ -478,10 +534,14 @@ export function registerGoal(
       const evidence = params.evidence.trim();
       if (!evidence) throw new Error("Goal evidence must not be empty");
       if (params.status === "complete") {
+        if (state.verification) verifyGoalDeliverable(state.verification);
+        const verification = state.verification ? "file" : "model-reported";
         transitionGoal(pi, runtime, "complete", "complete", evidence, { resetBlockedAudit: true });
         return {
-          content: [{ type: "text", text: `Goal marked complete: ${evidence}` }],
-          details: { status: "complete", evidence },
+          content: [{ type: "text", text: state.verification
+            ? `Goal verified complete at ${state.verification.path}: ${evidence}`
+            : `Goal marked complete (model-reported): ${evidence}` }],
+          details: { status: "complete", evidence, verification },
         };
       }
       if (!runtime.goalTurnInFlight) throw new Error("A blocker audit can only be recorded during an active KillerOS goal turn");
@@ -516,7 +576,12 @@ export function registerGoal(
     renderCall(args, theme) {
       return new Text(`${theme.fg("toolTitle", theme.bold("goal "))}${theme.fg("muted", args.status)}`, 0, 0);
     },
-    renderResult(result, options, theme) {
+    renderResult(result, options, theme, context) {
+      if (context?.isError) {
+        const first = result.content[0];
+        const message = first?.type === "text" ? first.text : "Goal update failed";
+        return new BoundedText(theme.fg("error", message), options.expanded ? undefined : 3);
+      }
       const details = result.details;
       if (!details) return new BoundedText(theme.fg("dim", "Goal updated"));
       const label = details.status === "complete" ? "✓ Complete" : details.status === "blocked" ? "! Blocked" : `! Blocker audit ${details.streak}/3`;
@@ -527,7 +592,8 @@ export function registerGoal(
 
   const restoreGoal = (ctx: ExtensionContext): void => {
     const restored = restoreGoalState(ctx);
-    runtime.state = restored.state;
+    runtime.state = isGoalModeSupported(ctx) ? restored.state : undefined;
+    syncGoalUpdateTool(pi, runtime);
     runtime.continuationScheduled = false;
     runtime.continuationHeld = false;
     runtime.goalTurnInFlight = false;
@@ -536,9 +602,7 @@ export function registerGoal(
     runtime.lastStopReason = undefined;
     runtime.lastError = undefined;
     runtime.requestRender?.();
-    if (restored.recoveryProven) {
-      recoverGoalAfterManualCompaction(pi, runtime, initState, ctx);
-    } else if (runtime.state?.status === "active") {
+    if (runtime.state?.status === "active") {
       setImmediate(() => scheduleGoalContinuation(pi, runtime, initState, ctx));
     }
   };
@@ -561,6 +625,7 @@ export function registerGoal(
       }
     }
     runtime.state = undefined;
+    syncGoalUpdateTool(pi, runtime);
     runtime.continuationScheduled = false;
     runtime.continuationHeld = false;
     runtime.goalTurnInFlight = false;
@@ -680,6 +745,7 @@ export function registerGoal(
             ctx.ui.notify("Goal pause saved. Goal remains paused. Automatic compaction recovery is off.", "info");
           } catch (error) {
             runtime.state = checkpoint;
+            syncGoalUpdateTool(pi, runtime);
             runtime.persistenceRetryNeeded = true;
             runtime.continuationScheduled = false;
             runtime.requestRender?.();
@@ -798,6 +864,7 @@ export function registerGoal(
           activeStartedAt: now,
           blockedAuditStartTurn: current.turns,
           blockerAudit: undefined,
+          verification: inferGoalVerification(objective),
           result: undefined,
           resumeAfterManualCompaction: undefined,
         };
@@ -869,6 +936,7 @@ export function registerGoal(
         turns: 0,
         blockedAuditStartTurn: 0,
         baselineTokens: sumGoalTokens(ctx),
+        verification: inferGoalVerification(objective),
       };
       try {
         persistGoalState(pi, runtime, unfinished ? "replace" : "set", state);

package/killeros/init.ts

@@ -133,8 +133,10 @@ export function registerInitCommand(pi: ExtensionAPI, initState: InitRuntime, go
 
   pi.on("session_start", () => setInitTools(pi, initState, false));
   pi.on("session_shutdown", () => {
+    const settle = initState.settle;
     setInitTools(pi, initState, false);
     resetInitRuntime(initState);
+    settle?.({ kind: "cancelled" });
   });
   pi.on("before_agent_start", () => {
     if (initState.active) setInitTools(pi, initState, true);
@@ -160,7 +162,7 @@ export function registerInitCommand(pi: ExtensionAPI, initState: InitRuntime, go
         ctx.ui.notify("/init requires interactive TUI mode", "error");
         return;
       }
-      if (initState.active) {
+      if (initState.active || initState.starting) {
         ctx.ui.notify("/init is already running", "warning");
         return;
       }
@@ -172,28 +174,45 @@ export function registerInitCommand(pi: ExtensionAPI, initState: InitRuntime, go
         ctx.ui.notify("Trust this project before running /init", "error");
         return;
       }
-      await ctx.waitForIdle();
+      const starting = Symbol();
+      initState.starting = starting;
+      try {
+        await ctx.waitForIdle();
+      } catch (error) {
+        if (initState.starting !== starting) return;
+        initState.starting = undefined;
+        reportError(ctx, "/init could not wait for active work", error);
+        return;
+      }
+      if (initState.starting !== starting) return;
 
       let projectRoot: string;
       try {
         projectRoot = await fs.realpath(ctx.cwd);
       } catch (error) {
+        if (initState.starting !== starting) return;
+        initState.starting = undefined;
         reportError(ctx, "/init could not resolve the project root", error);
         return;
       }
+      if (initState.starting !== starting) return;
       const targetPath = path.join(projectRoot, "AGENTS.md");
       try {
         const [{ index: evidence }, baseline] = await Promise.all([
           buildInitEvidence(projectRoot),
           captureInitTargetBaseline(targetPath),
         ]);
+        if (initState.starting !== starting) return;
         initState.active = true;
         initState.projectRoot = projectRoot;
         initState.targetPath = targetPath;
         initState.evidence = evidence;
         initState.baseline = baseline;
         initState.outcome = { kind: "pending" };
+        initState.starting = undefined;
       } catch (error) {
+        if (initState.starting !== starting) return;
+        initState.starting = undefined;
         reportError(ctx, "/init could not capture safe repository evidence", error);
         return;
       }
@@ -234,6 +253,8 @@ export function registerInitCommand(pi: ExtensionAPI, initState: InitRuntime, go
         case "policy-conflict":
           ctx.ui.notify(`/init left AGENTS.md unchanged: ${outcome.reason}`, "warning");
           break;
+        case "cancelled":
+          break;
         default:
           reportError(ctx, "/init did not generate AGENTS.md", "the model completed without a write or policy-conflict outcome");
       }

package/killeros/question.ts

@@ -1,5 +1,10 @@
 import { StringEnum } from "@earendil-works/pi-ai";
-import { type ExtensionAPI, type ThemeColor } from "@earendil-works/pi-coding-agent";
+import {
+  type ExtensionAPI,
+  type ExtensionContext,
+  type ThemeColor,
+  type ToolDefinition,
+} from "@earendil-works/pi-coding-agent";
 import {
   decodeKittyPrintable,
   Editor,
@@ -9,7 +14,7 @@ import {
   wrapTextWithAnsi,
   type EditorTheme,
 } from "@earendil-works/pi-tui";
-import { Type } from "typebox";
+import { Type, type Static } from "typebox";
 import { BoundedText } from "./bounded-text.ts";
 
 const OptionSchema = Type.Object({
@@ -31,16 +36,42 @@ const QuestionParams = Type.Object({
   minSelections: Type.Optional(Type.Integer({
     minimum: 1,
     maximum: 10,
-    description: "Minimum answers required in multiple mode; defaults to 1",
+    description: "Minimum answers required in multiple mode; defaults to 1. Single mode accepts only an explicit 1/1 bounds pair",
   })),
   maxSelections: Type.Optional(Type.Integer({
     minimum: 1,
     maximum: 10,
-    description: "Maximum answers allowed in multiple mode; defaults to all options plus one custom answer",
+    description: "Maximum answers allowed in multiple mode; defaults to all options plus one custom answer. Single mode accepts only an explicit 1/1 bounds pair",
   })),
 });
 
-type QuestionMode = "single" | "multiple";
+export type QuestionParamsValue = Static<typeof QuestionParams>;
+
+type NormalizedQuestionSelection =
+  | { mode: "single"; minSelections: 1; maxSelections: 1 }
+  | { mode: "multiple"; minSelections: number; maxSelections: number };
+
+function normalizeQuestionSelection(params: QuestionParamsValue): NormalizedQuestionSelection {
+  const mode = params.mode ?? "single";
+  if (mode === "single") {
+    const hasSelectionBounds = params.minSelections !== undefined || params.maxSelections !== undefined;
+    if (hasSelectionBounds && (params.minSelections !== 1 || params.maxSelections !== 1)) {
+      throw new Error("Single-select question bounds must be omitted or both be 1");
+    }
+    return { mode, minSelections: 1, maxSelections: 1 };
+  }
+
+  const maximumAvailable = params.options.length + 1;
+  const minSelections = params.minSelections ?? 1;
+  const maxSelections = params.maxSelections ?? maximumAvailable;
+  if (minSelections > maxSelections) {
+    throw new Error("Question minimum selections cannot exceed maximum selections");
+  }
+  if (maxSelections > maximumAvailable) {
+    throw new Error(`Question allows at most ${maximumAvailable} selections including one custom answer`);
+  }
+  return { mode, minSelections, maxSelections };
+}
 
 interface DisplayOption {
   label: string;
@@ -69,7 +100,11 @@ interface MultipleQuestionDetails {
   cancelled?: boolean;
 }
 
-type QuestionDetails = SingleQuestionDetails | MultipleQuestionDetails;
+export type QuestionDetails = SingleQuestionDetails | MultipleQuestionDetails;
+
+export interface QuestionRunner {
+  ask(params: QuestionParamsValue, signal: AbortSignal | undefined, ctx: ExtensionContext): Promise<QuestionDetails>;
+}
 
 type QuestionSelection =
   | { kind: "selected"; answer: string; originalIndex: number }
@@ -184,7 +219,7 @@ class MultipleResultText {
   invalidate(): void {}
 }
 
-export function registerQuestionTool(pi: ExtensionAPI): void {
+export function registerQuestionTool(pi: ExtensionAPI): QuestionRunner {
   const customInputHistory: string[] = [];
   let customInputHistoryBytes = 0;
   const clearCustomInputHistory = (): void => {
@@ -216,7 +251,7 @@ export function registerQuestionTool(pi: ExtensionAPI): void {
   pi.on("session_tree", clearCustomInputHistory);
   pi.on("session_shutdown", clearCustomInputHistory);
 
-  pi.registerTool<typeof QuestionParams, QuestionDetails>({
+  const questionTool: ToolDefinition<typeof QuestionParams, QuestionDetails> = {
     name: "question",
     label: "Question",
     description: `Ask one interactive multiple-choice question. Provide 1-9 concise options. Single-select is the default; opt into bounded multi-select with mode "multiple". The user can filter options or type a custom answer. Filter queries are limited to ${FILTER_QUERY_MAX_CHARACTERS.toLocaleString()} characters and ${FILTER_QUERY_MAX_BYTES.toLocaleString()} bytes.`,
@@ -229,20 +264,7 @@ export function registerQuestionTool(pi: ExtensionAPI): void {
     executionMode: "sequential",
 
     async execute(_toolCallId, params, signal, _onUpdate, ctx) {
-      const mode: QuestionMode = params.mode ?? "single";
-      const hasSelectionBounds = params.minSelections !== undefined || params.maxSelections !== undefined;
-      if (mode === "single" && hasSelectionBounds) {
-        throw new Error("Question selection bounds require mode \"multiple\"");
-      }
-      const maximumAvailable = params.options.length + 1;
-      const minSelections = params.minSelections ?? 1;
-      const maxSelections = params.maxSelections ?? maximumAvailable;
-      if (minSelections > maxSelections) {
-        throw new Error("Question minimum selections cannot exceed maximum selections");
-      }
-      if (maxSelections > maximumAvailable) {
-        throw new Error(`Question allows at most ${maximumAvailable} selections including one custom answer`);
-      }
+      const { mode, minSelections, maxSelections } = normalizeQuestionSelection(params);
       if (ctx.mode !== "tui") throw new Error("The question tool requires interactive TUI mode");
       if (signal?.aborted) throw new Error("Question cancelled before it opened");
 
@@ -703,9 +725,8 @@ export function registerQuestionTool(pi: ExtensionAPI): void {
     },
 
     renderCall(args, theme, context) {
-      const multiple = args.mode === "multiple";
-      const minimum = args.minSelections ?? 1;
-      const maximum = args.maxSelections ?? args.options.length + 1;
+      const { mode, minSelections: minimum, maxSelections: maximum } = normalizeQuestionSelection(args);
+      const multiple = mode === "multiple";
       if (!context.expanded) {
         const title = multiple ? "question (multi-select) " : "question ";
         const detail = multiple ? `${args.options.length} options · choose ${minimum}–${maximum}` : `${args.options.length} option${args.options.length === 1 ? "" : "s"}`;
@@ -740,5 +761,14 @@ export function registerQuestionTool(pi: ExtensionAPI): void {
       }
       return new BoundedText(`${theme.fg("success", "✓ ")}${theme.fg("accent", answer)}`);
     },
-  });
+  };
+  pi.registerTool(questionTool);
+
+  return {
+    async ask(params, signal, ctx): Promise<QuestionDetails> {
+      const result = await questionTool.execute("killeros-workflow-gate", params, signal, undefined, ctx);
+      if (!result.details) throw new Error("Question did not return a structured result");
+      return result.details;
+    },
+  };
 }

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;
   });
 }