killeros 2.0.5 → 2.0.7

package/CHANGELOG.md

@@ -4,6 +4,44 @@ All notable changes to KillerOS are documented here.
 
 ## [Unreleased]
 
+## [2.0.7] - 2026-08-13
+
+### Changed
+
+- Raised the supported and locked Pi baseline from 0.82.1 to the current matched 0.84.1 AI, coding-agent, and TUI packages.
+- Added a compact two-deck footer beneath the prompt and removed the work-trail widget.
+- Replaced the framed prompt and shuffled activity verbs with a focus-aware single-arrow editor and event-derived working copy.
+- Made settled timing entries report `Done`, `Stopped`, or `Failed` while keeping existing `Worked for` history readable.
+
+### Fixed
+
+- Separated response output from the prompt editor while keeping footer telemetry close beneath a quiet muted divider.
+- Kept `/variants` within the active terminal height, preserved the focused reasoning level across resizes, and initially focused the current level.
+- Rendered `/variants` controls from the same Pi keybinding manager that handles input, including installations with separate package module instances.
+- Rendered active, paused, and blocked `/goal` status text consistently in the footer's far-right slot.
+- Kept the private goal-update tool inactive outside active `/goal` runs and rendered its real execution errors instead of malformed blocker-audit fields.
+- Verified exact persisted paths for clearly declared file-deliverable goals before completion, while preserving model-reported completion for general objectives.
+- Accepted explicit `1`/`1` bounds for single-select questions and applied the same bounds validation before rendering and execution.
+- Prevented reload and branch navigation from preserving or reconstructing stale manual-compaction recovery eligibility; only Pi's live event in the current session can resume the interrupted goal safely.
+- Restricted goal deliverable verification to explicit destination phrases so source and reference paths cannot be reported as completed output.
+- Kept saved goals fully inactive in print and JSON modes, including the private update tool and shutdown checkpoints.
+- Rejected concurrent `/init` starts during preflight, cancelled pending preflight work on shutdown, and settled active `/init` command handlers when their session closes.
+
+## [2.0.6] - 2026-08-11
+
+### Added
+
+- Added a durable `✻ Worked for …` transcript line below each settled TUI response, including stopped and failed runs.
+- Added optional multi-select to the `question` tool with bounded checked options, one additive custom answer, a dedicated multi-word filter editor, and compact expandable results while preserving single-select defaults.
+
+### Changed
+
+- Automated GitHub releases after successful `main` CI version bumps, with package, lockfile, changelog, tag, and verified-commit checks plus a manual tag recovery path.
+
+### Fixed
+
+- Entered automatic `/goal` continuations into durable goal-turn state before dispatch so turn numbers advance and blocker audits work on Pi custom-message turns.
+
 ## [2.0.5] - 2026-08-11
 
 ### Added

package/Killeros.ts

@@ -1,4 +1,5 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { registerRequestActivity } from "./killeros/activity.ts";
 import { registerAliases, registerSlashAutocomplete } from "./killeros/commands.ts";
 import { registerConcisePrompt } from "./killeros/concise.ts";
 import { registerFooter } from "./killeros/footer.ts";
@@ -14,6 +15,7 @@ import { registerQuestionTool } from "./killeros/question.ts";
 import { createGoalRuntime, createInitRuntime } from "./killeros/runtime.ts";
 import { registerShellUi } from "./killeros/shell-ui.ts";
 import { registerVariants } from "./killeros/variants.ts";
+import { registerWorkedFor } from "./killeros/worked-for.ts";
 
 export { CONCISE_SYSTEM_PROMPT, isConciseEnabled, isConcisedEnabled } from "./killeros/concise.ts";
 export { contextPercentRemaining, formatCost, formatContextProgress } from "./killeros/footer.ts";
@@ -42,5 +44,7 @@ export default function Killeros(pi: ExtensionAPI, options: KillerosOptions = {}
   registerLifecycleHooks(pi);
   registerGoalSettlement(pi, goalRuntime, initRuntime);
   registerInitSettlement(pi, initRuntime);
+  registerRequestActivity(pi);
   registerCompletionNotifications(pi, options.completionNotifications);
+  registerWorkedFor(pi);
 }

package/README.md

@@ -5,7 +5,7 @@ A production-hardened Pi extension that combines a custom TUI, repository initia
 ## Requirements
 
 - Node.js `22.19.0` or later
-- Pi `0.82.1` or later
+- Pi `0.84.1` or later
 - Interactive TUI mode for the custom header, editor, footer, `question` tool, and `/init`
 
 The extension is strict TypeScript. Pi provides the runtime modules.
@@ -31,7 +31,7 @@ pi install git:github.com/KyrosHendrix/pi-KillerOS
 Pin an install to a release:
 
 ```bash
-pi install git:github.com/KyrosHendrix/pi-KillerOS@v2.0.5
+pi install git:github.com/KyrosHendrix/pi-KillerOS@v2.0.7
 ```
 
 Add `-l` to either command for a project-only install. Restart Pi after installing.
@@ -40,16 +40,17 @@ Add `-l` to either command for a project-only install. Restart Pi after installi
 
 - 52-column Compact startup card with inline version, polished model/provider identity, adjacent `/model`, directory, conditional Git branch, and a shuffled session-stable tip
 - Cohesive dark theme with coral accents and neutral tool-call containers across pending, success, and error states
-- Animated orange 12-frame activity glyph loop at 120 ms per frame, with orange shuffled Claude-adjacent verbs changing every 2.5 seconds, a gray `(esc to interrupt · thinking)` status with bold `esc`, and a quiet hidden-thinking label
-- Full-width framed multiline editor with a shuffled session-stable empty-state suggestion, Shift+Enter support, and slash-command autocomplete; KillerOS preserves an editor factory configured by another extension
-- Responsive footer with polished model/provider identity, plain-language context, and active goal state remaining; reasoning, Git branch, elapsed time, cost, and path cut down by available width
+- Animated orange 12-frame activity glyph loop at 120 ms per frame with contextual copy derived from request, tool, result, and response events, plus a quiet hidden-thinking label
+- Frameless multiline editor with one focus-aware `❯`, a shuffled session-stable empty-state suggestion, overflow-only scroll indicators, Shift+Enter support, and slash-command autocomplete; KillerOS preserves an editor factory configured by another extension
+- One compact TUI transcript line reporting truthful `Done`, `Stopped`, or `Failed` settlement with elapsed time while preserving older `✻ Worked for …` entries
+- Compact two-deck footer with session state above workspace state; model, context, and active goals stay prioritized as reasoning, time, cost, branch, and path reduce by available width
 - Pi-owned context compaction with active goals continuing from Pi's settled boundary after manual, threshold, and overflow compaction
 - Optional completion sounds after successful or failed settled requests, excluding manual aborts
 - `/variants` selector and direct reasoning-level arguments
 - Codex-style `/goal` with an interactive status/action panel, durable objectives, immediate pause and clear cancellation, automatic continuation, explicit completion, and durable blocker audits
 - Automatic `/init` guideline synthesis with a frozen safe evidence map, protected existing policy, and the four packaged behavioral sections adapted from `writing-great-guidelines`
-- `question` tool with height-bounded option windows, configured Pi keybindings, live option/input progress, proposal previews, custom answers, history, cancellation, and compact expandable transcript rendering
-- Mid-prompt slash completion with current Pi `0.82.1` commands, extensions, prompts, and skills; paths, URLs, and invalid commands remain plain text
+- `question` tool with single-select and opt-in bounded multi-select, height-bounded option windows, configured Pi keybindings, live option/input progress, proposal previews, custom answers, history, cancellation, and compact expandable transcript rendering
+- Mid-prompt slash completion with current Pi `0.84.1` commands, extensions, prompts, and skills; paths, URLs, and invalid commands remain plain text
 - Goal-aware `/clear` that confirms, aborts active work, waits for settlement, and starts a new session, plus `/exit` for graceful shutdown
 - Concise system-prompt guidance and supported native concise defaults that preserve explicit provider settings
 
@@ -70,7 +71,7 @@ Add `-l` to either command for a project-only install. Restart Pi after installi
 /exit                     Quit Pi gracefully
 ```
 
-`/goal` requires a saved session in TUI or RPC mode. Goal state is stored in versioned session entries on the active branch and restored after reload, resume, fork, or tree navigation. Active goals inject their unchanged objective every turn and continue one settled turn at a time. The model must use KillerOS’s private goal tool to mark verified completion. Blocking requires one stable lowercase blocker key recorded on three consecutive goal turns; a changed key, skipped turn, resume, or edit resets the streak. Final prose alone does not end the loop.
+`/goal` requires a saved session in TUI or RPC mode. Goal state is stored in versioned session entries on the active branch and restored after reload, resume, fork, or tree navigation. Active goals inject their unchanged objective every turn and continue one settled turn at a time. The model must use KillerOS’s private goal tool to report completion. For an objective that clearly asks to create, write, save, or generate a named file-like deliverable at one quoted absolute path, KillerOS saves that exact path with the goal and verifies that a regular file exists there before accepting completion. Other objectives retain model-reported completion. Blocking requires one stable lowercase blocker key recorded on three consecutive goal turns; a changed key, skipped turn, resume, or edit resets the streak. Final prose alone does not end the loop.
 
 `/goal pause` and `/goal clear` save paused or cleared state before aborting current goal work, so settlement cannot restart it. Aborted turns, provider failures, and continuation failures otherwise pause safely. Failed edit and replacement writes dispatch no edited objective; an active prior objective pauses fail-closed, while inactive durable state remains unchanged. Replacing unfinished work requires confirmation, and `/goal edit` requires TUI mode.
 
@@ -78,6 +79,12 @@ Add `-l` to either command for a project-only install. Restart Pi after installi
 
 The generated file uses the four behavioral sections adapted from `writing-great-guidelines`; no external skill installation is required. `/init` asks no setup questions, starts no second model process, writes no other file, and reloads Pi resources only after a successful write.
 
+### Interactive questions
+
+Single-select remains the default. Explicit `minSelections: 1` and `maxSelections: 1` are equivalent to omitting both bounds; other single-select bounds are rejected. An agent opts into multi-select with `mode: "multiple"` and may set `minSelections` and `maxSelections`; the custom answer counts as one selection.
+
+In multi-select, use Space or a visible number to toggle an option, `/` to filter, and Enter to submit. The filter accepts spaces; Enter applies it and Escape returns to the choices. Checked options remain selected when the filter changes. Select **Type a custom answer** with Enter to add or edit one custom item alongside checked options.
+
 Supported reasoning levels are `off`, `minimal`, `low`, `medium`, `high`, `xhigh`, and `max`. KillerOS limits choices to levels supported by the current model.
 
 ## Configuration
@@ -120,17 +127,17 @@ The package manifest lists Pi’s built-in modules as peer dependencies, so npm
 
 ## Publish
 
-The [`pi-package`](https://github.com/earendil-works/pi/blob/main/packages/coding-agent/docs/packages.md) keyword makes a published npm release visible in Pi’s package catalog.
+To create a GitHub release, update the version in `package.json` and `package-lock.json`, add the matching `CHANGELOG.md` section, and push the release commit to `main`. After the full CI workflow passes, the release workflow creates the matching tag and GitHub release from that verified commit.
 
-For a release, publish after the validation checks pass:
+Do not manually tag a normal release. If automation must recover a missing GitHub release, push the matching version tag; the same workflow validates the tag against the package and changelog before creating the release.
+
+The [`pi-package`](https://github.com/earendil-works/pi/blob/main/packages/coding-agent/docs/packages.md) keyword makes a published npm release visible in Pi’s package catalog. GitHub release automation does not publish to npm. Publish there separately after validation:
 
 ```bash
 npm login
 npm publish
 ```
 
-For later releases, choose `patch`, `minor`, or `major` with `npm version`, then publish and push the version commit and tag.
-
 ## Security
 
 Pi extensions run with your user permissions. Review the source before installing KillerOS globally. KillerOS executes lifecycle hook commands only for projects Pi marks as trusted; review `.pi/killeros-hooks.json` before enabling project trust.

package/killeros/activity.ts

@@ -0,0 +1,97 @@
+import type { ExtensionAPI, ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
+import { truncateToWidth } from "@earendil-works/pi-tui";
+
+export type ActivityMessage =
+  | { kind: "prompt" }
+  | { kind: "tool"; toolName: string }
+  | { kind: "tool-result"; failed: boolean }
+  | { kind: "responding" };
+
+function safeToolName(toolName: string): string {
+  const normalized = toolName.replace(/[\u0000-\u001F\u007F]+/gu, " ").replace(/\s+/gu, " ").trim();
+  return truncateToWidth(normalized || "tool", 32, "…");
+}
+
+export function formatActivityMessage(message: ActivityMessage, theme: Theme): string {
+  let verb: string;
+  let detail: string;
+
+  switch (message.kind) {
+    case "prompt":
+      verb = "Mapping…";
+      detail = "understanding request";
+      break;
+    case "tool-result":
+      verb = message.failed ? "Recovering…" : "Reviewing…";
+      detail = message.failed ? "tool failed" : "reading the result";
+      break;
+    case "responding":
+      verb = "Responding…";
+      detail = "assembling the answer";
+      break;
+    case "tool":
+      switch (message.toolName.trim().toLocaleLowerCase()) {
+        case "read":
+        case "grep":
+        case "find":
+        case "ls":
+          verb = "Inspecting…";
+          detail = "reading relevant code";
+          break;
+        case "edit":
+        case "write":
+          verb = "Changing…";
+          detail = "editing";
+          break;
+        case "bash":
+          verb = "Running…";
+          detail = "command";
+          break;
+        default:
+          verb = "Working…";
+          detail = `using ${safeToolName(message.toolName)}`;
+      }
+      break;
+  }
+
+  return `${theme.fg("accent", verb)} ${theme.fg("dim", `(${theme.bold("esc")} to interrupt · ${detail})`)}`;
+}
+
+export function registerRequestActivity(pi: ExtensionAPI): void {
+  let active = false;
+
+  const clear = (ctx?: ExtensionContext): void => {
+    if (ctx?.mode === "tui") {
+      ctx.ui.setWorkingMessage();
+    }
+    active = false;
+  };
+
+  pi.on("agent_start", (_event, ctx) => {
+    if (ctx.mode !== "tui") return;
+    active = true;
+    ctx.ui.setWorkingMessage(formatActivityMessage({ kind: "prompt" }, ctx.ui.theme));
+  });
+
+  pi.on("tool_execution_start", (event, ctx) => {
+    if (ctx.mode !== "tui" || !active) return;
+    ctx.ui.setWorkingMessage(formatActivityMessage({ kind: "tool", toolName: event.toolName }, ctx.ui.theme));
+  });
+
+  pi.on("tool_execution_end", (event, ctx) => {
+    if (ctx.mode !== "tui" || !active) return;
+    ctx.ui.setWorkingMessage(formatActivityMessage({ kind: "tool-result", failed: event.isError }, ctx.ui.theme));
+  });
+
+  pi.on("message_update", (event, ctx) => {
+    if (ctx.mode !== "tui" || !active || event.assistantMessageEvent.type !== "text_start") return;
+    ctx.ui.setWorkingMessage(formatActivityMessage({ kind: "responding" }, ctx.ui.theme));
+  });
+
+  pi.on("agent_settled", (_event, ctx) => {
+    if (ctx.mode !== "tui" || !active || !ctx.isIdle?.() || ctx.hasPendingMessages?.()) return;
+    clear(ctx);
+  });
+
+  pi.on("session_shutdown", (_event, ctx) => clear(ctx));
+}

package/killeros/footer.ts

@@ -125,6 +125,10 @@ function renderFooterRow(left: string, right: string, width: number): string {
   return ` ${clippedLeft}${gap}${clippedRight} `;
 }
 
+function renderFooter(rows: string[], width: number, theme: Theme): string[] {
+  return [theme.fg("borderMuted", "─".repeat(width)), ...rows];
+}
+
 function formatGoalElapsed(milliseconds: number): string {
   const totalSeconds = Number.isFinite(milliseconds) ? Math.max(0, Math.floor(milliseconds / 1_000)) : 0;
   if (totalSeconds < 60) return `${totalSeconds}s`;
@@ -138,15 +142,13 @@ function formatGoalElapsed(milliseconds: number): string {
   return `${hours}h ${minutes.toString().padStart(2, "0")}m ${seconds.toString().padStart(2, "0")}s`;
 }
 
-function formatActiveGoalFooter(state: GoalState | undefined, theme: Theme): string {
-  if (state?.status !== "active") return "";
-  return theme.fg("warning", `/goal is active (${formatGoalElapsed(goalElapsedMilliseconds(state))})`);
-}
-
 function formatGoalFooter(state: GoalState | undefined, theme: Theme): string {
   if (!state) return "";
-  if (state.status === "paused") return theme.fg("warning", "Ⅱ goal paused");
-  if (state.status === "blocked") return theme.fg("error", "! goal blocked");
+  if (state.status === "active") {
+    return theme.fg("warning", `/goal is active (${formatGoalElapsed(goalElapsedMilliseconds(state))})`);
+  }
+  if (state.status === "paused") return theme.fg("warning", "/goal is paused");
+  if (state.status === "blocked") return theme.fg("error", "/goal is blocked");
   return "";
 }
 
@@ -211,52 +213,36 @@ export function registerFooter(pi: ExtensionAPI, goalRuntime: GoalRuntime): void
           const signature = formatModel(model, theme);
           const fullDirectory = theme.fg("dim", cwd);
           const focusedDirectory = theme.fg("dim", compactDirectory(cwd));
-          const activeGoal = formatActiveGoalFooter(goalRuntime.state, theme);
           const goal = formatGoalFooter(goalRuntime.state, theme);
-          const rich = joinFooterParts([
+          const primary = joinFooterParts([
             signature,
             level,
             context,
-            goal,
-            branch ? theme.fg("dim", branch) : "",
+          ], theme);
+          const primaryFocused = joinFooterParts([signature, context], theme);
+          const session = joinFooterParts([
             theme.fg("dim", formatTime(Date.now() - sessionStart)),
             theme.fg("dim", formatCost(getSessionCost(ctx))),
           ], theme);
-          const focused = joinFooterParts([signature, context, goal], theme);
-
-          if (activeGoal) {
-            if (footerRowFits(rich, activeGoal, width)) {
-              return [renderFooterRow(rich, activeGoal, width)];
-            }
-            if (footerRowFits(focused, activeGoal, width)) {
-              return [renderFooterRow(focused, activeGoal, width)];
-            }
-            if (footerRowFits(context, activeGoal, width)) {
-              return [renderFooterRow(context, activeGoal, width)];
-            }
-            return [renderFooterRow("", activeGoal, width)];
-          }
-
-          if (footerRowFits(rich, fullDirectory, width)) {
-            return [renderFooterRow(rich, fullDirectory, width)];
-          }
-          if (footerRowFits(rich, focusedDirectory, width)) {
-            return [renderFooterRow(rich, focusedDirectory, width)];
-          }
-          if (footerRowFits(focused, focusedDirectory, width)) {
-            return [renderFooterRow(focused, focusedDirectory, width)];
-          }
-          if (footerRowFits(focused, "", width)) {
-            return [renderFooterRow(focused, "", width)];
-          }
-          if (goal) {
-            const essentialGoal = joinFooterParts([context, goal], theme);
-            if (footerRowFits(essentialGoal, "", width)) return [renderFooterRow(essentialGoal, "", width)];
-            return [renderFooterRow(goal, context, width)];
-          }
-
           const essentialModel = formatModel(model, theme, false);
-          return [renderFooterRow(essentialModel, context, width)];
+          const primaryRow = footerRowFits(primary, session, width)
+            ? renderFooterRow(primary, session, width)
+            : footerRowFits(primary, "", width)
+              ? renderFooterRow(primary, "", width)
+              : footerRowFits(primaryFocused, "", width)
+                ? renderFooterRow(primaryFocused, "", width)
+                : renderFooterRow(essentialModel, context, width);
+          const branchLabel = branch ? theme.fg("dim", branch) : "";
+          const workspaceRight = goal || fullDirectory;
+          const secondaryRow = footerRowFits(branchLabel, workspaceRight, width)
+            ? renderFooterRow(branchLabel, workspaceRight, width)
+            : goal
+              ? renderFooterRow("", goal, width)
+              : footerRowFits(branchLabel, focusedDirectory, width)
+                ? renderFooterRow(branchLabel, focusedDirectory, width)
+                : renderFooterRow(branchLabel, "", width);
+
+          return renderFooter([primaryRow, secondaryRow], width, theme);
         },
       };
     });