killeros 1.5.7 → 2.0.0

package/CHANGELOG.md

@@ -2,65 +2,40 @@
 
 All notable changes to KillerOS are documented here.
 
-## [Unreleased]
+## [2.0.0] - 2026-08-07
 
-## [1.5.7] - 2026-08-06
-
-### Fixed
+### Changed
 
-- Stopped runaway subagents at 64 turns or 2,000,000 reported tokens by default while preserving Pi's built-in model retries and the 30-minute wall limit.
-- Kept in-flight model retries labeled `Running`, exposed requested stops as terminal at once, and kept failed or limited children out of the **Active** list.
-- Replaced the frozen queued spawn result with a static launch receipt so only the separate live widget claims current state and usage.
+- Focused the package, runtime, tests, and documentation on KillerOS's current TUI, repository initialization, long-running goals, reasoning controls, interactive questions, command aliases, and concise-response guidance.
 
-## [1.5.6] - 2026-08-05
+## [1.5.8] - 2026-08-07
 
 ### Fixed
 
-- Rejected unknown named subagent roles before child launch and returned the available roles instead of falling back to the write-capable `worker`.
-- Kept the real child-boundary test isolated from parent Pi session variables and added direct coverage for inline parallel and chain spawns.
-- Clarified and tested the shared `message` field limits: 20,000 characters for a spawn task alias and 4,000 characters for steering.
+- Bounded question filter input to 4,000 characters and 16,000 UTF-8 bytes, with a clear rejection notice for excess input.
+- Reported goal start, resume, and edit success only after continuation dispatch succeeded, and paused the goal when dispatch failed.
 
 ## [1.5.5] - 2026-08-05
 
-### Added
-
-- Added live background subagent progress with queued, running, and completed states plus per-child and batch usage.
-- Added inline subagent roles for single, parallel, and chain spawns, bounded their tools to those active for the parent, and kept them scoped to one non-resumable spawn.
-- Added `message` as a single-spawn task alias and visible fallback to `worker` for unknown named roles.
-
 ### Changed
 
 - Replaced default deterministic context compaction with model-backed summaries at 40% remaining context, preserved manual focus prompts, and disclosed deterministic fallback after model retries fail.
 
 ### Fixed
 
-- Warned when a settled or failed background subagent handoff cannot reach the parent and pointed users to `list` and `collect` for recovery.
 - Overrode vulnerable transitive `brace-expansion` and `undici` versions with patched releases in the development and CI install tree.
 
 ## [1.5.4] - 2026-08-04
 
-### Added
-
-- Added named child sessions with `wait` and `resume`, persisted lifecycle records, real `/subagents` controls, empty-response failure, a 30-minute default wall time, bounded process-exit cleanup, and serialized shared-worktree writers.
-
 ### Fixed
 
 - Added guarded automatic context compaction at 30% remaining, with structured summaries and goal continuation after the compaction is saved.
-- Kept the parent-facing cancellation reason when a steer was already in flight: aborting the parent turn after a steer now reports `abort` on the settled thread and result and no longer triggers a replacement follow-up turn for the cancelled batch.
-- Isolated host update callbacks in child-process and tool telemetry paths so a throwing callback cannot crash the host, strand the result promise, or fail a settled batch.
-- Rejected steering explicitly once 20 messages are pending for a thread instead of silently dropping the oldest steers; task-size overflow is also rejected before mutation, and bounded steering history keeps the earliest messages.
-- `interrupt all` now also stops queued children of the batch, matching `interrupt` on one thread and parent-turn abort, so queued writers cannot run after a stop command.
-- Recreated the subagent thread registry on `session_start`, stopped old children, and fenced old callbacks so embedding hosts that keep the extension instance between sessions can still spawn children without stale follow-ups.
 
 ## [1.5.3] - 2026-08-03
 
 ### Fixed
 
-- Returned spawned thread IDs immediately and delivered completed handoffs as Pi follow-ups, making active `inspect`, `steer`, and `interrupt` actions reachable through normal parent turns.
-- Ignored provider-generated `threadId` values during spawn argument preparation and TUI rendering while retaining strict action validation during execution.
-- Connected Pi's parent cancellation signal to active child processes so Escape stops the subagent, suppresses replacement follow-up turns, and returns control to the terminal.
-- Made `/exit` abort an active run before requesting Pi's graceful shutdown, and made session teardown await bounded background-child settlement.
-- Corrected the README cancellation contract so it matches active-child termination.
+- Made `/exit` abort an active run before requesting Pi's graceful shutdown.
 
 ## [1.5.2] - 2026-08-03
 
@@ -68,10 +43,6 @@ All notable changes to KillerOS are documented here.
 
 - Hardened always-on concise guidance around low-friction action, visible multi-turn state, evidence-backed outcomes, material ambiguity, diagnostic resets, and explicit safety and correctness precedence.
 
-### Fixed
-
-- Resolved bundled subagent role discovery from the package `agents/` directory; the module-relative path broke when subagent modules moved under `killeros/` in v1.5.0, leaving fresh installs with `Unknown subagent "<role>". Available: none`.
-
 ## [1.5.1] - 2026-08-03
 
 ### Changed
@@ -80,8 +51,6 @@ All notable changes to KillerOS are documented here.
 
 ### Fixed
 
-- Replaced the `subagent` tool's top-level union with a provider-compatible object schema, fixing request rejection by Console Go and other providers that require function schemas with `type: "object"`.
-- Kept strict action-specific subagent validation at runtime, including single, parallel, chain, steering, interruption, collection, and closure requests.
 - Scoped native concise settings to supported Responses APIs while leaving completion and unrelated provider payloads unchanged.
 
 ## [1.5.0] - 2026-08-03
@@ -89,99 +58,19 @@ All notable changes to KillerOS are documented here.
 ### Changed
 
 - Split the main extension into feature modules under `killeros/` while keeping `Killeros.ts` as the stable entry point.
-- Moved subagent modules under `killeros/` and kept root re-export files for existing deep imports.
-
-### Fixed
-
-- Hardened the subagent schema and runtime checks with action-specific request shapes.
-- Invalid fields now fail before role discovery, project confirmation, thread creation, or child launch.
-- The TUI no longer shows parallel schedules for malformed subagent requests.
-- Kept valid single, parallel, chain, lifecycle, steering, interruption, collection, and closure behavior unchanged.
 
 ## [1.4.9] - 2026-08-02
 
 ### Changed
 
-- Parallel batches with write-capable roles now use one shared slot by default; `writerConcurrency` above `1` opts into concurrent shared-worktree writes only when path ownership is proven. Reader-only batches reject `writerConcurrency` because it does not apply.
-- Added an 8 MiB ceiling for one child JSONL record, bounded thread retention with inspectable tombstones, and scoped atomic `/init` reads and writes.
-
-## [1.4.7] - 2026-08-01
-
-### Fixed
-
-- Serialized every write-capable task in a parallel batch in input order instead of rejecting batches with multiple writers.
-- Added opt-in `writerConcurrency` scheduling for independent batches while keeping serialization as the safe default and documenting shared-worktree conflict responsibility.
-- Parent tool-call aborts now settle only queued tasks; active children finish naturally, and session directories remain until child exit is confirmed.
-- Settled queued tasks on interrupted parallel batches and documented the shared-worktree execution model.
-- Restricted the `message` parameter to `action: "steer"` and added focused regression coverage.
-
-## [1.4.6] - 2026-08-01
-
-### Fixed
-
-- Made the registered task schema use the same ten-task limit as runtime validation.
-- Kept one isolated Pi session ID and session directory across steering restarts so a child retains its conversation.
-- Bound retained trace, stderr, and returned text, and spooled large JSONL lines to temporary storage without stopping the child or reporting a retention cutoff as `limited`.
-- Kept explicit embedding resource guards and user stops visible as terminal states.
-
-## [1.4.5] - 2026-08-01
-
-### Fixed
-
-- Removed the child-budget extension, its read-tool budget, and the default 250,000-token/$5 quota.
-- Removed default child wall-time, trace, stderr, returned-output, and model-output-length stops; role `timeoutMs` and other child guards are opt-in, while the parser retains a finite JSONL-record ceiling.
-- Removed forced early-report prompt text so roles can finish their assigned work naturally.
-- Treat model stop reason `length` as a completed child process instead of inventing a KillerOS `limited` result.
-- Documented the child lifecycle contract: children complete naturally; explicit user interruptions, configured guards, and real child-process failures remain visible.
-
-## [1.4.3] - 2026-08-01
-
-### Fixed
-
-- Added child-runtime tool budgets for read-only roles, with a soft finalization nudge and hard blocking for read and web tools after 32 calls.
-- Added bounded child report instructions and kept read-tool budgets cumulative across steering restarts.
-- Lowered the default child quota to 250,000 tokens and $5, and exposed child tool-call counts in results.
-
-## [1.4.2] - 2026-08-01
-
-### Added
-
-- Added named child threads with inspectable lifecycle state, Active/Done views, steering, interruption, collection, and closure controls.
-- Added isolated child-process resource guards for wall time, JSONL lines, retained trace, stderr, output, token quota, cost quota, task count, and concurrency.
-
-### Changed
-
-- Replaced routine child turn limits with natural completion plus named resource guards.
-- Preserved partial traces and handoffs when a child fails, stops, or reaches a limit.
+- Scoped atomic `/init` reads and writes.
 
 ## [1.4.1] - 2026-08-01
 
-### Added
-
-- Added per-invocation child model selection and separate thinking-effort controls, with visible `inherit` placeholders in every bundled role.
-- Added focused `debugger`, `documenter`, `security`, and `tester` roles with explicit access boundaries, skill discovery, and web research guidance.
-- Added child web research through the separately installed `pi-web-access` package and exposed search, source-check, fetch, and stored-content tools to every bundled role.
-
-### Fixed
-
-- Made child timeout and forced-termination fallbacks settle even when no other event-loop handles remain.
-- Kept streamed child thinking within the retained trace budget without terminating successful invocations.
-- Preserved model IDs containing colons and validated thinking levels through Pi's model capabilities, including models that do not support `off`.
-- Bounded unterminated JSONL lines while preserving fragmented UTF-8 handling.
-
 ### Changed
 
-- Expanded the bundled role roster while keeping read-only auditors separate from write-capable implementation roles.
 - Hardened CI with Node floor/LTS checks, locked-dependency auditing, dependency review, package-content validation, and CodeQL analysis.
 
-## [1.4.0] - 2026-08-01
-
-### Added
-
-- Pi-native `subagent` tool with isolated JSONL child processes, single/parallel/chain modes, streamed TUI status, aggregate usage, and abort propagation.
-- Bundled Markdown roles for read-only scouting, planning, and review plus one serialized write-capable worker.
-- Strict role, tool, model, trust, precedence, concurrency, turn, timeout, trace, stderr, and output enforcement.
-
 ## [1.3.0] - 2026-07-31
 
 ### Added

package/Killeros.ts

@@ -1,13 +1,5 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { registerSubagentTool } from "./killeros/subagents.ts";
-import {
-  createSubagentControlApi,
-  registerAliases,
-  registerSlashAutocomplete,
-  registerSubagentCommand,
-  type SubagentControlApi,
-  type SubagentToolLike,
-} from "./killeros/commands.ts";
+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";
@@ -35,22 +27,6 @@ export default function Killeros(pi: ExtensionAPI): void {
   registerGoal(pi, goalRuntime, initRuntime);
   registerPersonalInstructions(pi, initRuntime);
   registerQuestionTool(pi);
-  let subagentTool: SubagentToolLike | undefined;
-  const registrationPi = new Proxy(pi, {
-    get(target, property, receiver) {
-      if (property === "registerTool") {
-        return (tool: Parameters<ExtensionAPI["registerTool"]>[0]) => {
-          if (tool.name === "subagent") subagentTool = tool as unknown as SubagentToolLike;
-          return target.registerTool(tool);
-        };
-      }
-      return Reflect.get(target, property, receiver);
-    },
-  });
-  const subagents = registerSubagentTool(registrationPi);
-  const subagentControl = (subagents as unknown as SubagentControlApi | undefined)
-    ?? (subagentTool ? createSubagentControlApi(subagentTool) : undefined);
-  registerSubagentCommand(pi, subagentControl);
   registerAliases(pi);
   registerSlashAutocomplete(pi);
   registerFooter(pi, goalRuntime);

package/README.md

@@ -1,220 +1,130 @@
-# KillerOS
-
-A production-hardened Pi extension that combines a custom TUI, isolated subagents, repository initialization, long-running goals, reasoning controls, interactive questions, command aliases, and concise-response guidance.
-
-## Requirements
-
-- Node.js `22.19.0` or later
-- Pi `0.82.1` or later
-- `pi-web-access` for child-agent web search and URL fetching (`pi install npm:pi-web-access`)
-- Interactive TUI mode for the custom header, editor, footer, `question` tool, and `/init`
-
-The extension is strict TypeScript. Pi provides the runtime modules; `pi-web-access` provides the child web tools.
-
-## Install
-
-### npm
-
-Install KillerOS and its separate child-web-tools peer:
-
-```bash
-pi install npm:killeros
-pi install npm:pi-web-access
-```
-
-### Git
-
-Install the latest commit:
-
-```bash
-pi install git:github.com/KyrosHendrix/pi-KillerOS
-```
-
-Pin an install to a release:
-
-```bash
-pi install git:github.com/KyrosHendrix/pi-KillerOS@v1.5.4
-```
-
-Add `-l` to either command for a project-only install. Restart Pi after installing.
-
-## Features
-
-- 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
-- Coral Spark activity indicator with Claude-adjacent verbs that advance between agent runs and a quiet hidden-thinking label
-- Framed multiline editor with Shift+Enter support
-- 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
-- `/variants` selector and direct reasoning-level arguments
-- Codex-style `/goal` for durable long-running objectives with pause, resume, edit, clear, automatic continuation, and explicit completion
-- Pi-native `subagent` tool with named, inspectable child threads, Markdown roles, explicit read/write boundaries, parent controls, natural completion, and cancellation propagation
-- Claude Code-style `/init` that scans the repository and generates a concise root `AGENTS.md` without setup questions
-- `question` tool with filtering, proposal previews, keyboard selection, custom answers, history, cancellation, and resize-safe rendering
-- Mid-prompt slash completion with current Pi `0.82.1` commands, extensions, prompts, and skills
-- `/clear` for a confirmed new session, plus `/exit` for graceful shutdown
-- Concise system-prompt guidance without modifying completed assistant messages
-
-## Commands
-
-```text
-/init                     Generate root AGENTS.md from repository evidence
-/goal                     View the current long-running goal
-/goal <objective>         Set an objective and start working
-/goal edit                Edit and reactivate the current goal
-/goal pause               Stop automatic continuation
-/goal resume              Resume automatic continuation
-/goal clear               Remove the current goal
-/variants                 Open the reasoning-level selector
-/variants high            Set a reasoning level directly
-/subagents                Open child-thread selectors in TUI mode
-/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.
-
-Supported reasoning levels are `off`, `minimal`, `low`, `medium`, `high`, `xhigh`, and `max`. KillerOS limits choices to levels supported by the current model.
-
-## Subagents
-
-KillerOS ships `planner`, `reviewer`, `scout`, and `security` as read-only roles plus focused write-capable `debugger`, `documenter`, and `tester` roles; `worker` remains the general-purpose implementation role. Each invocation rediscovers Markdown roles with this precedence:
-
-| Role | Access | Focus |
-|---|---|---|
-| `debugger` | write | Reproduce failures, fix root causes, and verify regressions |
-| `documenter` | write | Keep repository documentation accurate and audience-focused |
-| `planner` | read | Turn repository constraints into an executable implementation route |
-| `reviewer` | read | Report proven correctness, security, and regression risks |
-| `scout` | read | Map unfamiliar code and return an evidence trail |
-| `security` | read | Audit trust boundaries and report concrete security findings |
-| `tester` | write | Add focused coverage and run deterministic verification |
-| `worker` | write | Execute the assigned repository change |
-
-1. Bundled: `<killeros>/agents/*.md`
-2. Personal: `~/.pi/agent/agents/*.md`
-3. Trusted project: `<repo>/.pi/agents/*.md`
-
-The default `agentScope: "user"` uses bundled and personal roles. Use `"project"` or `"both"` to opt into trusted project roles; a selected project override requires interactive confirmation. Role frontmatter requires `name`, `description`, `access`, and an explicit `tools` list. Optional fields are `model`, `thinking`, and `timeoutMs`. Every bundled role shows `model: inherit` and `thinking: inherit` as editable placeholders. Replace them with an available `provider/model` and a separate thinking level when you want to pin a role; `off`, `minimal`, `low`, `medium`, `high`, `xhigh`, and `max` are checked against that model’s supported capabilities.
-
-The tool supports a single `agent` plus `task` or its `message` alias, parallel `tasks`, or a sequential `chain` whose task text may include `{previous}`. `agent` may be a role name or an inline `{name, description, access, tools}` role for one spawn. Inline tools must be active for the parent, and inline role settings are not saved or resumable. Each task may set a `name`; names are unique within the parent session without regard to case and are passed to child Pi as `--name`. Read-only-only batches run concurrently, up to four at a time. Batches with write-capable roles are serialized in the shared worktree with one shared slot. Reader-only batches reject `writerConcurrency` because it does not apply. A call can also set `model` and `thinking` for every task, overriding role settings; use `inherit` to fall back to each role and then the active parent model.
-
-| Action | Required fields | Allowed optional fields |
-|---|---|---|
-| omitted / `spawn` single | `agent`, one of `task` or `message` | `name`, `model`, `thinking`, `agentScope` |
-| omitted / `spawn` parallel | `tasks` | per-task `name`, `writerConcurrency`, `model`, `thinking`, `agentScope` |
-| omitted / `spawn` chain | `chain` | per-task `name`, `model`, `thinking`, `agentScope` |
-| `list` | none | none |
-| `inspect` | `threadId` | none |
-| `wait` | none | `threadId`, `all: true`, `timeoutMs` |
-| `steer` | `threadId`, `message` | none |
-| `interrupt` one | `threadId` | none |
-| `interrupt` all | `all: true` | none |
-| `collect` | `threadId` | none |
-| `resume` | `threadId` | `task` |
-| `close` | `threadId` | none |
-
-The three spawn shapes cannot be mixed. On a single spawn, `message` aliases `task` with the same 20,000-character limit; supplying both is invalid. With `action: "steer"`, `message` remains required and has a 4,000-character limit, while other lifecycle actions reject it. An unknown named role fails before child launch and reports the available roles. The `wait` action defaults to all queued or active children, waits up to 30 seconds by default, and never stops a child when it times out. The `resume` action keeps the same thread ID, name, session ID, and session directory and increments `attempt`; it requires the original named role and rejects inline roles. KillerOS rejects malformed requests before role discovery, project confirmation, thread creation, or child launch. The TUI shows a parallel or shared-pool schedule only after shape validation; malformed calls show `invalid request` instead of queued work. For example:
-
-```json
-{"agent":"reviewer","task":"Review the change","name":"auth-audit","model":"provider/model","thinking":"high"}
-```
-
-Spawn returns the generated thread IDs immediately while the children continue in the background. The completed spawn card is a static launch receipt; the separate live widget shows current state and usage until the batch settles. This lets the parent use `list`, `inspect`, `wait`, `steer`, `interrupt`, `collect`, `resume`, and `close` in later tool calls. Compact thread records persist through Pi custom session entries. On parent restart, an active record restores as `orphaned`; `close` removes the child session only after confirmed process exit. When the batch settles, KillerOS delivers its bounded handoff as a Pi follow-up and triggers the parent turn. A batch cancelled by parent Escape remains inspectable but does not trigger a replacement turn.
-
-Use the separate `model` and `thinking` fields for new configuration. The older `provider/model:thinking` model form remains accepted. Children run as isolated `pi --mode json -p` processes with a private `--session-dir` and `--session-id`, plus explicit local tools and `web_search`, `source_check`, `fetch_content`, and `get_search_content`. Steering restarts the same child session, so the child keeps its prior conversation. Each child explicitly loads `npm:pi-web-access`, discovers available skills, and keeps arbitrary extensions and prompt templates disabled; project-local skills load only when the parent project is trusted. Every bundled role is instructed to load the most relevant `SKILL.md` and report useful evidence. An empty final assistant response is a failure. Each child stops at the first default limit reached: 64 turns, 2,000,000 reported tokens, or 30 minutes. Dollar quotas remain opt-in. Each JSONL record still has a bounded 8 MiB parser ceiling. KillerOS bounds retained trace, stderr, and returned text and spills a large JSONL line to temporary storage; retention never stops a child or marks it `limited`. The parent limits each request to ten tasks, read-only-only batches to four concurrent readers, and bounds role files, task input, and combined parent output. Embedding options can adjust the turn, token, wall-time, and other named resource guards. Aborting the originating parent turn stops its queued and active children; explicit `interrupt` actions and session shutdown also terminate active children and use a bounded 10-second process-exit wait.
-
-The command grammar is:
-
-```text
-/subagents
-/subagents list
-/subagents inspect <id-or-name>
-/subagents wait [<id-or-name>] [timeout-ms]
-/subagents steer <id-or-name> <message>
-/subagents interrupt <id-or-name|all>
-/subagents collect <id-or-name>
-/subagents resume <id-or-name> [task]
-/subagents close <id-or-name>
-```
-
-Bare `/subagents` opens TUI selectors. RPC, JSON, and print modes require an explicit verb and never open a UI prompt.
-
-### Thread lifecycle
-
-Each delegated task creates a named child thread. Its contract records the parent ID, child ID, role, prompt, model, requested capability boundary, trace, usage, and result state. Roles define the child’s access and tools; they do not own lifecycle controls or grant new filesystem powers. The parent owns scope, waits, inspection, steering, collection, and closure.
-
-Threads move through `queued`, `active`, `done`, `failed`, `stopped`, `orphaned`, and `closed`. The parent renders separate **Active** and **Done** lists. Active threads show their name, task, model, usage, and direct controls. Done threads keep their handoff and trace available until the parent closes them.
-
-The parent can inspect a thread’s prompt, role, model, tools, trace, usage, and handoff; wait for one named or ID child or all queued and active children; steer an active or queued thread with a bounded follow-up (at most 20 pending messages; further steering is rejected explicitly until the child restarts or drains the queue); interrupt one child or all active and queued children; collect a concise handoff into parent context; resume a terminal or orphaned child; and close a finished, stopped, or orphaned thread. An interrupt preserves the partial trace, states the reason, and reports the handoff as partial rather than successful. Closing removes a thread from the active workspace; heavy trace and result payloads are evicted as needed under the bounded retention budget, leaving a small inspectable tombstone.
-
-A child completes only when it returns usable final assistant text. The default child limits are 64 turns, 2,000,000 reported tokens, and 30 minutes; dollar quotas remain opt-in, and every JSONL record has an 8 MiB parser ceiling. Explicit embedding options can adjust those limits or add output, trace, stderr, JSONL, or cost guards; each guard reports its cause and returns partial work clearly. The parent still bounds task count, reader concurrency, role files, task input, and combined parent output. Aborting the originating parent turn settles queued work as cancelled and terminates active children; explicit `interrupt` actions and real child-process failures remain visible. Session shutdown also terminates active children and waits up to 10 seconds for confirmed process exit.
-
-The replacement lifecycle has nine phases:
-
-1. **Dispatch:** create a named thread and store its contract before launch.
-2. **Track:** maintain lifecycle states and Active/Done visibility.
-3. **Inspect:** keep the trace in the child thread, not the parent context.
-4. **Steer:** append a bounded parent follow-up to an active or queued thread.
-5. **Interrupt:** stop one or all active or queued children while preserving partial work.
-6. **Collect:** return a concise handoff while retaining the expanded trace.
-7. **Guard:** stop at the default turn, token, or wall-time limit and honor explicit resource-limit overrides.
-8. **Close:** remove a finished or stopped thread from the workspace while retaining a small inspectable tombstone; heavy payloads may be evicted under the retention budget.
-9. **Prove:** test identity, visibility, controls, natural completion, guards, partial handoffs, bounded retention, and closure.
-
-## Configuration
-
-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. When a goal exists, the footer adds its active time or terminal state; at narrow widths, context pressure and goal state take priority.
-
-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.
-
-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.
-
-## Behavior by mode
-
-| Mode | Behavior |
-|---|---|
-| TUI | All features are available, including confirmation for trusted project subagents |
-| RPC | Goal set/view/pause/resume/clear, subagents, and concise prompt guidance work; TUI components, `/goal edit`, and `/init` are disabled |
-| Print/JSON | Concise prompt guidance works; interactive questions, `/goal`, `/init`, and project-role confirmation fail explicitly |
-
-## Validation
-
-Before release, run:
-
-```bash
-npm ci
-npm run check
-npm test
-npm pack --dry-run
-pi -ne -e . --mode rpc
-```
-
-The package manifest lists Pi’s built-in modules as peer dependencies, so npm does not bundle a second copy.
-
-## 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.
-
-For a release, publish after the validation checks pass:
-
-```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 and write-capable subagents run with your user permissions. Review the source before installing it globally. KillerOS executes lifecycle hook commands and reads project agent roles only for projects Pi marks as trusted; review `.pi/killeros-hooks.json` and `.pi/agents/*.md` before enabling project trust.
-
-## License
-
-[MIT](LICENSE) © 2026 KyrosHendrix
+# KillerOS
+
+A production-hardened Pi extension that combines a custom TUI, repository initialization, long-running goals, reasoning controls, interactive questions, command aliases, and concise-response guidance.
+
+## Requirements
+
+- Node.js `22.19.0` or later
+- Pi `0.82.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.
+
+## Install
+
+### npm
+
+Install KillerOS:
+
+```bash
+pi install npm:killeros
+```
+
+### Git
+
+Install the latest commit:
+
+```bash
+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.0
+```
+
+Add `-l` to either command for a project-only install. Restart Pi after installing.
+
+## Features
+
+- 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
+- Coral Spark activity indicator with Claude-adjacent verbs that advance between agent runs and a quiet hidden-thinking label
+- Framed multiline editor with Shift+Enter support
+- 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
+- `/variants` selector and direct reasoning-level arguments
+- Codex-style `/goal` for durable long-running objectives with pause, resume, edit, clear, automatic continuation, and explicit completion
+- Claude Code-style `/init` that scans the repository and generates a concise root `AGENTS.md` without setup questions
+- `question` tool with filtering, proposal previews, keyboard selection, custom answers, history, cancellation, and resize-safe rendering
+- Mid-prompt slash completion with current Pi `0.82.1` commands, extensions, prompts, and skills
+- `/clear` for a confirmed new session, plus `/exit` for graceful shutdown
+- Concise system-prompt guidance without modifying completed assistant messages
+
+## Commands
+
+```text
+/init                     Generate root AGENTS.md from repository evidence
+/goal                     View the current long-running goal
+/goal <objective>         Set an objective and start working
+/goal edit                Edit and reactivate the current goal
+/goal pause               Stop automatic continuation
+/goal resume              Resume automatic continuation
+/goal clear               Remove the current goal
+/variants                 Open the reasoning-level selector
+/variants high            Set a reasoning level directly
+/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.
+
+Supported reasoning levels are `off`, `minimal`, `low`, `medium`, `high`, `xhigh`, and `max`. KillerOS limits choices to levels supported by the current model.
+
+## Configuration
+
+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. When a goal exists, the footer adds its active time or terminal state; at narrow widths, context pressure and goal state take priority.
+
+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.
+
+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.
+
+## 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 |
+
+## Validation
+
+Before release, run:
+
+```bash
+npm ci
+npm run check
+npm test
+npm pack --dry-run
+pi -ne -e . --mode rpc
+```
+
+The package manifest lists Pi’s built-in modules as peer dependencies, so npm does not bundle a second copy.
+
+## 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.
+
+For a release, publish after the validation checks pass:
+
+```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.
+
+## License
+
+[MIT](LICENSE) © 2026 KyrosHendrix