killeros 1.5.4 → 1.5.5

package/CHANGELOG.md

@@ -4,6 +4,23 @@ All notable changes to KillerOS are documented here.
 
 ## [Unreleased]
 
+## [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

package/README.md

@@ -45,7 +45,7 @@ Add `-l` to either command for a project-only install. Restart Pi after installi
 - 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 non-destructive context compaction at 30% remaining with a structured handoff; active goals continue after the saved summary
+- 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
@@ -99,11 +99,11 @@ KillerOS ships `planner`, `reviewer`, `scout`, and `security` as read-only roles
 
 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` + `task`, parallel `tasks`, or a sequential `chain` whose task text may include `{previous}`. 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.
+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`, `task` | `name`, `model`, `thinking`, `agentScope` |
+| 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 |
@@ -116,7 +116,7 @@ The tool supports a single `agent` + `task`, parallel `tasks`, or a sequential `
 | `resume` | `threadId` | `task` |
 | `close` | `threadId` | none |
 
-The three spawn shapes cannot be mixed. The `message` field is only valid with `action: "steer"`, and lifecycle actions reject spawn fields. 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`. 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:
+The three spawn shapes cannot be mixed. On a single spawn, `message` aliases `task`; supplying both is invalid. With `action: "steer"`, `message` remains required, and other lifecycle actions reject it. An unknown role name falls back to `worker` on a new spawn and reports that choice in the tool output. 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"}
@@ -170,7 +170,7 @@ KillerOS activates its packaged `killeros` theme when a TUI session starts. Tool
 
 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 30% remaining, it starts Pi compaction after the current run settles, so the active turn is not aborted. Manual `/compact` remains available, and the compaction summary keeps the goal, progress, decisions, next steps, and changed files.
+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.
 

package/killeros/context-compaction.ts

@@ -3,6 +3,7 @@ import type {
   ExtensionContext,
   SessionBeforeCompactEvent,
 } from "@earendil-works/pi-coding-agent";
+import { compact, SettingsManager } from "@earendil-works/pi-coding-agent";
 import { pauseGoalAfterFailure } from "./goals.ts";
 import type { CompactionRuntime, GoalRuntime } from "./runtime.ts";
 
@@ -21,7 +22,9 @@ const MAX_CONTEXT_ITEMS = 80;
 const MAX_FILES = 40;
 const MAX_PREVIOUS_SUMMARY = 6_000;
 const MAX_CUSTOM_INSTRUCTIONS = 4_000;
-const COMPACTION_STATE_TIMEOUT_MS = 60_000;
+const COMPACTION_STATE_TIMEOUT_MS = 5 * 60_000;
+const DETERMINISTIC_FALLBACK_PREFIX = "This summary was produced deterministically without model understanding. Verify its details before relying on it.";
+const COMPACTION_ACCURACY_WARNING = "Long threads and multiple compactions can cause the model to be less accurate. Start a new thread when possible to keep threads small and targeted.";
 
 type NotificationLevel = Parameters<ExtensionContext["ui"]["notify"]>[1];
 
@@ -231,6 +234,8 @@ function buildStructuredSummary(
   }
 
   return [
+    DETERMINISTIC_FALLBACK_PREFIX,
+    "",
     "# KillerOS Compaction Summary",
     "",
     ...(preparation.previousSummary?.trim()
@@ -256,6 +261,38 @@ function buildStructuredSummary(
   ].join("\n");
 }
 
+async function buildModelSummary(
+  event: SessionBeforeCompactEvent,
+  ctx: ExtensionContext,
+) {
+  const model = ctx.model;
+  if (!model) throw new Error("No model is available for compaction");
+
+  const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
+  if (!auth.ok) throw new Error(auth.error);
+
+  const provider = ctx.modelRegistry.getProvider(model.provider);
+  const streamFn = provider
+    ? provider.streamSimple.bind(provider)
+    : undefined;
+  const retry = SettingsManager.create(ctx.cwd, undefined, {
+    projectTrusted: ctx.isProjectTrusted(),
+  }).getRetrySettings();
+
+  return compact(
+    event.preparation,
+    model,
+    auth.apiKey,
+    auth.headers,
+    event.customInstructions,
+    event.signal,
+    ctx.thinkingLevel,
+    streamFn,
+    auth.env,
+    retry,
+  );
+}
+
 function exactPercentRemaining(ctx: ExtensionContext): number | null {
   let usage: ReturnType<ExtensionContext["getContextUsage"]>;
   try {
@@ -293,7 +330,7 @@ function isCurrentCompaction(runtime: CompactionRuntime, operationId: number): b
 }
 
 function armCompactionTimeout(runtime: CompactionRuntime, operationId: number): void {
-  // ponytail: recover stale state after 60s because Pi exposes no failed-compaction extension event; replace with that event if Pi adds one.
+  // ponytail: recover stale state after five minutes because Pi exposes no failed-compaction extension event; replace with that event if Pi adds one.
   const timer = setTimeout(() => {
     if (!isCurrentCompaction(runtime, operationId)) return;
     const onFailure = compactionFailureHandlers.get(runtime);
@@ -519,7 +556,7 @@ export function registerContextCompaction(
     requestAutomaticCompaction(pi, ctx, compactionRuntime, goalRuntime, percentRemaining);
   });
 
-  pi.on("session_before_compact", (event, ctx) => {
+  pi.on("session_before_compact", async (event, ctx) => {
     const expectedAutomaticHook = compactionRuntime.automaticCompactionAwaitingHook;
     const sessionGeneration = compactionRuntime.sessionGeneration;
     const operationId = markCompactionInFlight(
@@ -544,23 +581,34 @@ export function registerContextCompaction(
         },
     );
     if (operationId === null) return { cancel: true };
-    const goalObjective = goalRuntime.state?.status === "active"
-      ? goalRuntime.state.objective
-      : undefined;
-    const summary = buildStructuredSummary(event.preparation, goalObjective, event.customInstructions);
-
-    return {
-      compaction: {
-        summary,
-        firstKeptEntryId: event.preparation.firstKeptEntryId,
-        tokensBefore: event.preparation.tokensBefore,
-      },
-    };
+
+    try {
+      return { compaction: await buildModelSummary(event, ctx) };
+    } catch (error) {
+      if (event.signal.aborted) return { cancel: true };
+      notify(ctx, `Model compaction failed: ${errorMessage(error)}. Using the deterministic fallback.`, "warning");
+      const goalObjective = goalRuntime.state?.status === "active"
+        ? goalRuntime.state.objective
+        : undefined;
+      const summary = buildStructuredSummary(event.preparation, goalObjective, event.customInstructions);
+
+      return {
+        compaction: {
+          summary,
+          firstKeptEntryId: event.preparation.firstKeptEntryId,
+          tokensBefore: event.preparation.tokensBefore,
+          details: { killerosDeterministicFallback: true },
+        },
+      };
+    }
   });
 
-  pi.on("session_compact", () => {
+  pi.on("session_compact", (event, ctx) => {
     resetCompactionState(compactionRuntime);
     compactionFailureHandlers.delete(compactionRuntime);
     compactionRuntime.lastCompactionAt = Date.now();
+    if (asRecord(event.compactionEntry.details)?.killerosDeterministicFallback === true) {
+      notify(ctx, COMPACTION_ACCURACY_WARNING, "warning");
+    }
   });
 }

package/killeros/runtime.ts

@@ -81,6 +81,6 @@ export function createCompactionRuntime(): CompactionRuntime {
     automaticCompactionPending: false,
     compactionOperationId: 0,
     sessionGeneration: 0,
-    thresholdPercent: 30,
+    thresholdPercent: 40,
   };
 }