killeros 2.0.2 → 2.0.4

package/CHANGELOG.md

@@ -4,6 +4,40 @@ All notable changes to KillerOS are documented here.
 
 ## [Unreleased]
 
+## [2.0.4] - 2026-08-10
+
+### Changed
+
+- Rebuilt `/init` around a packaged four-section guideline-synthesis workflow that preserves compatible root policy without requiring an external skill.
+- Removed live blue slash-command coloring while retaining slash autocomplete, the framed multiline editor, and Shift+Enter.
+
+### Fixed
+
+- Prevented `/init` from reading Git-ignored files, known secrets, private keys, linked or non-regular files, other guidance, dependencies, and files outside its frozen evidence map.
+- Protected root `AGENTS.md` from concurrent replacement and reported incompatible policy conflicts without writing.
+- Made `/clear` confirm before aborting active work, wait for settlement, and then start the new session.
+- Preserved explicit Responses API verbosity and reasoning-summary settings while applying concise defaults only to absent fields.
+- Cancelled lifecycle hook process trees with bounded cleanup when Pi aborts the parent request.
+- Kept `/init` middleware from freezing shared tool input and preserved custom editors installed by other extensions.
+- Removed private Pi editor-state access in favor of public rendering contracts.
+
+## [2.0.3] - 2026-08-09
+
+### Added
+
+- Added an opt-in global completion sound with `/notification` and an enabled-state Nerd Font bell in the terminal tab title.
+- Moved active goal status to the footer's right side in warning yellow, replacing the path with `/goal is active (...)` and exact seconds.
+
+### Changed
+
+- Returned compaction timing, summary generation, manual instructions, retries, file tracking, and overflow recovery to Pi's public lifecycle.
+- Continued active goals only after Pi reaches its settled boundary and preserved `/goal` as the sole durable objective and status owner.
+
+### Fixed
+
+- Added fail-closed, revision-bound recovery after successful manual compaction, including reload and branch navigation recovery without reviving stale or explicitly paused goals.
+- Rendered question help from the effective selector keybindings across supported Pi versions.
+
 ## [2.0.2] - 2026-08-08
 
 ### Changed

package/Killeros.ts

@@ -1,27 +1,34 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { registerAliases, registerSlashAutocomplete } from "./killeros/commands.ts";
 import { registerConcisePrompt } from "./killeros/concise.ts";
-import { registerContextCompaction } from "./killeros/context-compaction.ts";
 import { registerFooter } from "./killeros/footer.ts";
 import { registerGoal, registerGoalSettlement } from "./killeros/goals.ts";
 import { registerLifecycleHooks } from "./killeros/hooks.ts";
 import { registerInitCommand, registerInitSettlement } from "./killeros/init.ts";
+import {
+  registerCompletionNotifications,
+  type CompletionNotificationDependencies,
+} from "./killeros/notifications.ts";
 import { registerPersonalInstructions } from "./killeros/personal-instructions.ts";
 import { registerQuestionTool } from "./killeros/question.ts";
-import { createCompactionRuntime, createGoalRuntime, createInitRuntime } from "./killeros/runtime.ts";
+import { createGoalRuntime, createInitRuntime } from "./killeros/runtime.ts";
 import { registerShellUi } from "./killeros/shell-ui.ts";
 import { registerVariants } from "./killeros/variants.ts";
 
-export { CONCISE_SYSTEM_PROMPT, isConcisedEnabled } from "./killeros/concise.ts";
-export { contextPercentRemaining } from "./killeros/context-compaction.ts";
-export { formatCost, formatContextProgress } from "./killeros/footer.ts";
+export { CONCISE_SYSTEM_PROMPT, isConciseEnabled, isConcisedEnabled } from "./killeros/concise.ts";
+export { contextPercentRemaining, formatCost, formatContextProgress } from "./killeros/footer.ts";
 export { executeHook } from "./killeros/hooks.ts";
-export { INIT_WORKFLOW_PROMPT, writeInitAgentsFile } from "./killeros/init.ts";
+export { INIT_WORKFLOW_PROMPT } from "./killeros/init.ts";
+export { buildInitEvidence, listInitEvidence, readInitEvidence } from "./killeros/init-evidence.ts";
+export { captureInitTargetBaseline, installInitAgentsFile, validateGeneratedGuidance, writeInitAgentsFile } from "./killeros/init-target.ts";
 
-export default function Killeros(pi: ExtensionAPI): void {
+export interface KillerosOptions {
+  completionNotifications?: CompletionNotificationDependencies;
+}
+
+export default function Killeros(pi: ExtensionAPI, options: KillerosOptions = {}): void {
   const initRuntime = createInitRuntime();
   const goalRuntime = createGoalRuntime();
-  const compactionRuntime = createCompactionRuntime();
   registerShellUi(pi);
   registerConcisePrompt(pi);
   registerGoal(pi, goalRuntime, initRuntime);
@@ -33,7 +40,7 @@ export default function Killeros(pi: ExtensionAPI): void {
   registerVariants(pi);
   registerInitCommand(pi, initRuntime, goalRuntime);
   registerLifecycleHooks(pi);
-  registerContextCompaction(pi, compactionRuntime, goalRuntime);
-  registerGoalSettlement(pi, goalRuntime, initRuntime, compactionRuntime);
+  registerGoalSettlement(pi, goalRuntime, initRuntime);
   registerInitSettlement(pi, initRuntime);
+  registerCompletionNotifications(pi, options.completionNotifications);
 }

package/README.md

@@ -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.2
+pi install git:github.com/KyrosHendrix/pi-KillerOS@v2.0.4
 ```
 
 Add `-l` to either command for a project-only install. Restart Pi after installing.
@@ -41,16 +41,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
-- Framed multiline editor with Shift+Enter support and live command-blue highlighting for recognized slash command prefixes
+- Framed multiline editor with 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
-- Automatic model-backed context compaction at 40% remaining; active goals continue after the saved summary
+- 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, pause, resume, edit, confirmed panel clearing, automatic continuation, and explicit completion
-- Claude Code-style `/init` that scans the repository and generates a concise root `AGENTS.md` without setup questions
+- 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
-- `/clear` for a confirmed new session, plus `/exit` for graceful shutdown
-- Concise system-prompt guidance without modifying completed assistant messages
+- 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
 
 ## Commands
 
@@ -64,13 +65,16 @@ Add `-l` to either command for a project-only install. Restart Pi after installi
 /goal clear               Remove the current goal
 /variants                 Open the reasoning-level selector
 /variants high            Set a reasoning level directly
+/notification             Configure the completion sound
 /clear                    Start a new session after confirmation
 /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 or a blocker repeated across at least three goal turns; final prose alone does not end the loop. Aborted turns, provider failures, and continuation failures pause safely. Replacing unfinished work requires confirmation, and `/goal edit` requires TUI mode.
 
-`/init` builds a bounded project map, reads high-value manifests, documentation, and CI configuration, and lets the active model inspect additional implementation files before generating root `AGENTS.md`. Existing `AGENTS.md` and `CLAUDE.md` content is intentionally excluded so stale guidance is not inherited. The command asks no setup questions, starts no second model process, writes only `AGENTS.md`, and reloads Pi resources when finished.
+`/init` freezes a safe project-file map and exposes only dedicated read and list operations while it generates root `AGENTS.md`. Git-ignored files, known secret paths, private-key formats, other guidance, dependencies, links, non-regular files, and files outside that map are unavailable. Existing root `AGENTS.md` is separate protected policy: compatible rules are preserved, a real policy conflict leaves it unchanged with a reason, and any concurrent target change aborts installation without replacing the newer file.
+
+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.
 
 Supported reasoning levels are `off`, `minimal`, `low`, `medium`, `high`, `xhigh`, and `max`. KillerOS limits choices to levels supported by the current model.
 
@@ -78,21 +82,25 @@ Supported reasoning levels are `off`, `minimal`, `low`, `medium`, `high`, `xhigh
 
 KillerOS activates its packaged `killeros` theme when a TUI session starts. Tool-call backgrounds stay neutral across pending, successful, and failed states; restrained text and icons preserve status visibility.
 
-KillerOS displays session costs in USD. The footer uses Pi's human-readable model name when available, keeps the provider visually secondary, and renders context as `percent left (tokens)` without a progress bar. Active, paused, and blocked goals remain visible; completed goals remain in transcript history and `/goal` status rather than the footer. At narrow widths, context pressure and actionable goal state take priority.
+The completion sound is a global user preference stored in Pi's agent directory and is off by default. Run `/notification` in TUI mode to enable or disable it; enabling does not play a preview. Enabled TUI tabs append `󰂚`, which requires a Nerd Font in the terminal tab UI. An unsupported font may show a box without affecting sound. KillerOS uses the terminal's audible bell and cannot produce sound when the terminal disables it.
+
+KillerOS displays session costs in USD. The footer uses Pi's human-readable model name when available, keeps the provider visually secondary, and renders context as `percent left (tokens)` without a progress bar. An active goal replaces the right-side path with warning-yellow `/goal is active (...)` and keeps exact seconds in minute and hour formats. Paused and blocked goals retain their existing placement; completed goals remain in transcript history and `/goal` status rather than the footer. At narrow widths, context pressure and actionable goal state take priority.
+
+Pi decides when compaction runs and Pi writes the summary, applies manual focus instructions, tracks files, retries summarization, and handles overflow recovery. KillerOS does not add a second threshold or replace Pi's summary. Active `/goal` work continues from Pi's settled boundary, after Pi finishes retries, compaction, and queued work.
 
-KillerOS checks context after each agent turn. At 40% remaining, it starts Pi's model-backed compaction after the current run settles, so the active turn is not aborted. Manual `/compact` uses the same model path and keeps custom focus instructions. If model compaction is unavailable or exhausts its retries, KillerOS uses the disclosed deterministic fallback and warns that repeated compaction can reduce accuracy.
+Manual `/compact` aborts the current goal turn before summarization, so KillerOS records an honest temporary pause for that exact goal revision. After Pi saves the manual summary, KillerOS resumes that revision automatically. A failed or cancelled manual compaction stays paused; run `/goal pause` during the pause to cancel automatic recovery.
 
 For trusted projects, KillerOS loads `AGENTS.local.md` after Pi's shared repository context. A one-line `@path` or `@~/path` file imports personal guidance from another location.
 
-Lifecycle hooks are loaded from `.pi/killeros-hooks.json` at session start. Supported event keys are `tool_call`, `tool_result`, and `agent_settled`; matchers are JavaScript regular expressions over Pi tool names. Hook commands run from the repository root with `KILLEROS_EVENT`, `KILLEROS_TOOL`, and `KILLEROS_PAYLOAD` environment variables. Failed `tool_call` hooks block the tool, while later-event failures notify the user.
+Lifecycle hooks are loaded from `.pi/killeros-hooks.json` at session start. Supported event keys are `tool_call`, `tool_result`, and `agent_settled`; matchers are JavaScript regular expressions over Pi tool names. Hook commands run from the repository root with `KILLEROS_EVENT`, `KILLEROS_TOOL`, and `KILLEROS_PAYLOAD` environment variables. Failed `tool_call` hooks block the tool, while later-event failures notify the user. Aborting the parent request stops the hook process tree with bounded graceful and forced cleanup without reporting cancellation as a hook failure.
 
 ## Behavior by mode
 
 | Mode | Behavior |
 |---|---|
-| TUI | All features are available |
-| RPC | Goal set/view/pause/resume/clear and concise prompt guidance work; TUI components, `/goal edit`, and `/init` are disabled |
-| Print/JSON | Concise prompt guidance works; interactive questions, `/goal`, and `/init` fail explicitly |
+| TUI | All features are available, including the completion sound and tab-title indicator |
+| RPC | Goal set/view/pause/resume/clear and concise prompt guidance work; TUI components, `/goal edit`, `/init`, completion sounds, and the title indicator are disabled |
+| Print/JSON | Concise prompt guidance works; interactive questions, `/goal`, and `/init` fail explicitly; completion sounds and the title indicator are disabled |
 
 ## Validation
 

package/killeros/commands.ts

@@ -8,8 +8,9 @@ async function confirmNewSession(ctx: ExtensionCommandContext): Promise<boolean>
 
 export function registerAliases(pi: ExtensionAPI): void {
   const startNewSession = async (_args: string, ctx: ExtensionCommandContext): Promise<void> => {
-    await ctx.waitForIdle();
     if (!await confirmNewSession(ctx)) return;
+    if (!ctx.isIdle()) ctx.abort();
+    await ctx.waitForIdle();
     await ctx.newSession();
   };
   pi.registerCommand("clear", { description: "Start a new session after confirmation", handler: startNewSession });
@@ -54,13 +55,6 @@ const BUILTIN_COMMANDS: ReadonlyArray<{ name: string; description: string }> = [
   { name: "quit", description: "Quit Pi" },
 ];
 
-export function availableCommandNames(pi: ExtensionAPI): ReadonlySet<string> {
-  return new Set([
-    ...BUILTIN_COMMANDS.map((command) => command.name),
-    ...pi.getCommands().map((command) => command.name),
-  ]);
-}
-
 const COMMAND_SYNTAX_HINTS: Readonly<Record<string, string>> = {
   goal: "/goal [objective|clear|edit|pause|resume]",
   variants: "/variants [level]",

package/killeros/concise.ts

@@ -41,22 +41,26 @@ function applyConciseModelSettings(payload: unknown, api: unknown, modelId: unkn
   const supportsVerbosity = api === "openai-codex-responses"
     || api === "openai-responses" && typeof modelId === "string" && /^gpt-5(?:[.-]|$)/u.test(modelId);
   let updated = payload;
-  if (supportsVerbosity) {
-    updated = {
-      ...updated,
-      text: { ...(isRecord(payload.text) ? payload.text : {}), verbosity: "low" },
-    };
+  const text = isRecord(payload.text) ? payload.text : undefined;
+  if (supportsVerbosity && !Object.hasOwn(text ?? {}, "verbosity")) {
+    updated = { ...updated, text: { ...(text ?? {}), verbosity: "low" } };
   }
-  if (supportsSummary && isRecord(payload.reasoning)) {
-    updated = { ...updated, reasoning: { ...payload.reasoning, summary: "concise" } };
+  const reasoning = isRecord(payload.reasoning) ? payload.reasoning : undefined;
+  if (supportsSummary && reasoning && !Object.hasOwn(reasoning, "summary")) {
+    updated = { ...updated, reasoning: { ...reasoning, summary: "concise" } };
   }
   return updated;
 }
 
-export function isConcisedEnabled(): boolean {
+export function isConciseEnabled(): boolean {
   return true;
 }
 
+/** @deprecated Use isConciseEnabled instead. */
+export function isConcisedEnabled(): boolean {
+  return isConciseEnabled();
+}
+
 export function registerConcisePrompt(pi: ExtensionAPI): void {
   pi.on("before_agent_start", (event) => ({
     systemPrompt: `${event.systemPrompt}\n\n${CONCISE_SYSTEM_PROMPT}`,

package/killeros/footer.ts

@@ -12,6 +12,20 @@ export function formatCost(usd: number): string {
   return `$${usd.toFixed(2)}`;
 }
 
+export function contextPercentRemaining(ctx: ExtensionContext): number | null {
+  let usage: ReturnType<ExtensionContext["getContextUsage"]>;
+  try {
+    usage = ctx.getContextUsage();
+  } catch {
+    return null;
+  }
+  if (!usage || !Number.isFinite(usage.contextWindow) || usage.contextWindow <= 0) return null;
+  if (usage.tokens === null || !Number.isFinite(usage.tokens)) return null;
+
+  const percentRemaining = ((usage.contextWindow - Math.max(0, usage.tokens)) / usage.contextWindow) * 100;
+  return Math.round(Math.max(0, Math.min(100, percentRemaining)));
+}
+
 export function formatContextProgress(tokensUsed: number | null, contextWindow: number, theme: Theme): string {
   if (tokensUsed === null || !Number.isFinite(tokensUsed)) return theme.fg("dim", "—% left (—)");
   const windowSize = Number.isFinite(contextWindow) && contextWindow > 0 ? contextWindow : 128_000;
@@ -111,9 +125,26 @@ function renderFooterRow(left: string, right: string, width: number): string {
   return ` ${clippedLeft}${gap}${clippedRight} `;
 }
 
+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`;
+
+  const seconds = totalSeconds % 60;
+  const totalMinutes = Math.floor(totalSeconds / 60);
+  if (totalMinutes < 60) return `${totalMinutes}m ${seconds.toString().padStart(2, "0")}s`;
+
+  const hours = Math.floor(totalMinutes / 60);
+  const minutes = totalMinutes % 60;
+  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 === "active") return theme.fg("accent", `✻ goal · ${formatTime(goalElapsedMilliseconds(state))}`);
   if (state.status === "paused") return theme.fg("warning", "Ⅱ goal paused");
   if (state.status === "blocked") return theme.fg("error", "! goal blocked");
   return "";
@@ -180,6 +211,7 @@ 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([
             signature,
@@ -192,6 +224,19 @@ export function registerFooter(pi: ExtensionAPI, goalRuntime: GoalRuntime): void
           ], 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)];
           }