killeros 2.1.26 → 2.1.28

package/CHANGELOG.md

@@ -4,6 +4,44 @@ All notable changes to KillerOS are documented here.
 
 ## [Unreleased]
 
+## [2.1.28] - 2026-09-15
+
+### Changed
+
+- Simplified goal presentation without changing goal behavior: transcript history shows one iconless event row per lifecycle change (`Goal started`, `Goal replaced`, `Goal paused`, `Goal resumed`, `Goal cleared`), progress and blocker outcomes render once through the goal tool result, the footer shows compact `/goal active · 1/20 · 10s` status, the `/goal` panel leads with status then objective then `Pause goal` / `Resume goal` / `Clear goal` actions, and duplicate TUI success notifications are suppressed while RPC confirmations remain. Active-goal labels use muted teal `#6FAEB2` through the packaged theme's extension-label role.
+- Removed the legacy `✻` marker from version-1 `Worked for …` transcript rows; stored entries are unchanged and remain readable.
+
+### Added
+
+- Appended the selected model ID as a gray `· <model-id>` suffix to every TUI activity working message, retained for the full request cycle and falling back to `unknown model` when no usable ID exists.
+
+### Fixed
+
+- Kept resumed blocked goals and goals paused by truncated provider errors readable after reload.
+- Made goal continuation explicit: each settled turn now needs one accepted `continue`, `complete`, or blocker decision. Missing decisions, repeated continuation reports, unavailable goal tools, and runtime failures pause without scheduling another turn; compaction recovery resumes the same logical turn.
+- Preserved accepted goal decisions across automatic compaction: a `continue` or blocker audit recorded before compaction now authorizes exactly one next turn instead of being discarded and re-decided. Duplicate compaction and settlement callbacks cannot start a second turn.
+- Scoped goal pause reasons to the current paused state: resume and manual pause no longer surface an earlier automatic reason, terminal states keep no pause reason, and contradictory persisted states fail closed instead of starting automatic work.
+
+## [2.1.27] - 2026-09-12
+
+### Added
+
+- Added `/codex-fast status` to report whether Codex fast mode is enabled without changing it.
+
+### Fixed
+
+- Restricted automatic startup, footer, and change-receipt Git scans to trusted projects, preventing repository executables and configuration races from launching commands before trust is granted.
+- Resolved passive Git executable discovery without starting a locator or repository executable. Footer and change-receipt scans now use an absolute Git path outside the inspected repository and report unavailable when none exists.
+- Closed the filter-configuration race in automatic Git inspection. Footer and change-receipt scans now run Git without `PATH` resolution, re-check effective filters after status, and skip results the scan cannot produce without an extension process or remote fetch. Change receipts no longer fetch missing objects from partial-clone remotes.
+- Stopped attaching single-file verification to goals that name several files. Multi-file goals now complete through the model-reported path.
+- Shared one passive Git status policy between footer telemetry and change receipts. Both scans now disable filesystem monitors and clean/process filters, and skip status when filter discovery is unavailable or unsafe.
+- Recorded focused Node test runs in response receipts without persisting their test paths.
+- Kept passive footer Git status from running configured filters, bounded loose and packed receipt blobs, and stopped stale `/handoff` summaries from replacing sessions with new work.
+
+### Removed
+
+- Removed `/init` and its `killeros_init_*` tools, prompts, workflow APIs, runtime state, and lifecycle handlers. Upgrading leaves existing `AGENTS.md` and recovery files untouched, and commands from other providers named `/init` pass through KillerOS unhandled.
+
 ## [2.1.26] - 2026-09-08
 
 ### Fixed

package/Killeros.ts

@@ -12,7 +12,6 @@ import { registerGoalRuntime } from "./killeros/goal-runtime.ts";
 import { registerGoalSettlement } from "./killeros/goal-settlement.ts";
 import { registerHandoff } from "./killeros/handoff.ts";
 import { registerLifecycleHooks } from "./killeros/hooks.ts";
-import { registerInitCommand, registerInitSettlement } from "./killeros/init.ts";
 import {
   registerCompletionNotifications,
   type CompletionNotificationDependencies,
@@ -20,15 +19,12 @@ import {
 import { registerCodexFastMode } from "./killeros/codex-fast.ts";
 import { registerPersonalInstructions } from "./killeros/personal-instructions.ts";
 import { registerQuestionTool } from "./killeros/question.ts";
-import { createGoalRuntime, createInitRuntime } from "./killeros/runtime.ts";
+import { createGoalRuntime } from "./killeros/runtime.ts";
 import { registerShellUi } from "./killeros/shell-ui.ts";
 import { registerWorkedFor } from "./killeros/worked-for.ts";
 
 export { contextPercentRemaining, formatCost, formatContextProgress } from "./killeros/footer.ts";
 export { executeHook } from "./killeros/hooks.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 interface KillerosOptions {
   completionNotifications?: CompletionNotificationDependencies;
   /** Output-token budget for /handoff summaries; invalid values fall back to killeros.json, then the default. */
@@ -36,25 +32,22 @@ export interface KillerosOptions {
 }
 
 export default function Killeros(pi: ExtensionAPI, options: KillerosOptions = {}): void {
-  const initRuntime = createInitRuntime();
   const goalRuntime = createGoalRuntime();
   const commandResolver = createSlashCommandResolver(pi);
   registerShellUi(pi, commandResolver);
-  registerGoalInterface(pi, goalRuntime, initRuntime);
-  registerGoalRuntime(pi, goalRuntime, initRuntime);
-  registerPersonalInstructions(pi, initRuntime);
+  registerGoalInterface(pi, goalRuntime);
+  registerGoalRuntime(pi, goalRuntime);
+  registerPersonalInstructions(pi);
   registerQuestionTool(pi);
   registerAliases(pi);
   registerHandoff(pi, goalRuntime, options.handoffMaxTokens);
   registerSlashAutocomplete(pi, commandResolver);
   registerFooter(pi, goalRuntime);
   registerCodexFastMode(pi);
-  registerInitCommand(pi, initRuntime, goalRuntime);
   registerLifecycleHooks(pi);
   registerWorkedFor(pi);
-  const goalCompaction = registerGoalSettlement(pi, goalRuntime, initRuntime);
-  registerAutoCompaction(pi, { goal: goalCompaction, isInitActive: () => initRuntime.active });
-  registerInitSettlement(pi, initRuntime);
+  const goalCompaction = registerGoalSettlement(pi, goalRuntime);
+  registerAutoCompaction(pi, { goal: goalCompaction });
   registerRequestActivity(pi);
   registerCompletionNotifications(pi, options.completionNotifications);
 }

package/README.md

@@ -5,9 +5,8 @@ A TypeScript extension for the [Pi coding agent](https://github.com/earendil-wor
 ## What you get
 
 - A custom TUI: startup masthead with versions, model, working directory, and Git branch; a dark theme with coral accents; a multiline editor with slash-command completion; a footer that tracks model, context, and goal state; settled task receipts with duration and token usage.
-- `/goal`: set an objective and Pi keeps working toward it across turns, compaction, reloads, and branch navigation. New goals pause after 20 turns; `/goal resume` grants another 20.
-- `/init`: generates a root `AGENTS.md` from repository evidence, preserving compatible existing rules.
-- `/codex-fast`: toggles the `priority` service tier on Codex requests.
+- `/goal`: set an objective and Pi keeps working toward it across turns, compaction, reloads, and branch navigation. Each turn must record `continue` with evidence and one next action, `complete`, or the existing blocker decision; otherwise the goal pauses. New goals pause after 20 turns; `/goal resume` grants another 20.
+- `/codex-fast`: toggles the `priority` service tier on Codex requests or reports its status.
 - `/handoff`: starts a fresh linked session carrying visible continuation context.
 - Automatic context compaction when remaining tokens drop below 15% of the window (configurable).
 - A `question` tool with single-select and multi-select modes.
@@ -19,7 +18,7 @@ A TypeScript extension for the [Pi coding agent](https://github.com/earendil-wor
 
 - Node.js 22.19.0+
 - Pi 0.85.0 or later within the 0.x release line
-- An interactive TUI session for the custom header, editor, footer, `question`, and `/init`
+- An interactive TUI session for the custom header, editor, footer, and `question`
 
 ## Install
 
@@ -33,18 +32,17 @@ Or from GitHub:
 pi install git:github.com/KyrosHendrix/pi-KillerOS
 ```
 
-Pin a release by appending its tag, for example `@v2.1.26`. Add `-l` to install only for the current project. Restart Pi after installing.
+Pin a release by appending its tag, for example `@v2.1.28`. Add `-l` to install only for the current project. Restart Pi after installing.
 
 ## Commands
 
 ```text
-/init                     Generate root AGENTS.md from repository evidence
 /goal                     View the current goal
 /goal <objective>        Set an objective
 /goal pause               Stop automatic continuation
 /goal resume              Resume automatic continuation
 /goal clear               Remove the current goal
-/codex-fast               Toggle Codex fast mode
+/codex-fast [status]      Toggle or report Codex fast mode
 /notification             Configure the completion sound
 /handoff [focus]          Fresh session with continuation context
 /clear                    New session after confirmation
@@ -56,8 +54,8 @@ Pin a release by appending its tag, for example `@v2.1.26`. Add `-l` to install
 | Mode | What works |
 | --- | --- |
 | TUI | Everything |
-| RPC | Goals, proactive compaction; no TUI components, `/init`, sounds, title indicator |
-| Print/JSON | No interactive questions, `/goal`, `/init`, or proactive compaction |
+| RPC | Goals, proactive compaction; no TUI components, sounds, title indicator |
+| Print/JSON | No interactive questions, `/goal`, or proactive compaction |
 
 ## Configuration
 
@@ -87,7 +85,7 @@ A direct quoted file target binds silent file proof:
 /goal Fix `killeros/footer.ts`, verified by npm test
 ```
 
-KillerOS captures the file baseline at goal start and only completes when the file is created or changed. New goals pause after 20 turns without warning. An explicit `/goal resume` on an exhausted goal grants another 20 turns; compaction recovery never grants turns. Restored goals keep their persisted limit.
+KillerOS captures the file baseline at goal start and only completes when the file is created or changed. A normal response never continues a goal by itself: the agent must record `continue`, `complete`, or a blocker decision through `killeros_goal_update`. Repeated continuation reports and unavailable goal tools pause the goal. New goals pause after 20 turns without warning. An explicit `/goal resume` on an exhausted goal grants another 20 turns; compaction recovery never grants turns. Restored goals keep their persisted limit.
 
 Completion sounds are off by default; change with `/notification` in TUI mode. The tab-title indicator requires a Nerd Font.
 

package/killeros/activity.ts

@@ -1,5 +1,6 @@
 import type { ExtensionAPI, ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
 import { truncateToWidth } from "@earendil-works/pi-tui";
+import { modelDisplayName } from "./display.ts";
 
 export type ActivityMessage =
   | { kind: "prompt" }
@@ -12,7 +13,7 @@ function safeToolName(toolName: string): string {
   return truncateToWidth(normalized || "tool", 32, "…");
 }
 
-export function formatActivityMessage(message: ActivityMessage, theme: Theme): string {
+export function formatActivityMessage(message: ActivityMessage, theme: Theme, modelId?: string): string {
   let verb: string;
   let detail: string;
 
@@ -58,38 +59,46 @@ export function formatActivityMessage(message: ActivityMessage, theme: Theme): s
     }
   }
 
-  return `${theme.fg("accent", verb)} ${theme.fg("dim", `(${theme.bold("esc")} to interrupt · ${detail})`)}`;
+  const suffix = modelDisplayName({ id: modelId }) || "unknown model";
+  return `${theme.fg("accent", verb)} ${theme.fg("dim", `(${theme.bold("esc")} to interrupt · ${detail})`)}${theme.fg("dim", ` · ${suffix}`)}`;
 }
 
 export function registerRequestActivity(pi: ExtensionAPI): void {
   let active = false;
+  let activeModel: string | undefined;
+
+  const render = (message: ActivityMessage, ctx: ExtensionContext): void => {
+    ctx.ui.setWorkingMessage(formatActivityMessage(message, ctx.ui.theme, activeModel));
+  };
 
   const clear = (ctx?: ExtensionContext): void => {
+    active = false;
+    activeModel = undefined;
     if (ctx?.mode === "tui") {
       ctx.ui.setWorkingMessage();
     }
-    active = false;
   };
 
   pi.on("agent_start", (_event, ctx) => {
     if (ctx.mode !== "tui") return;
+    if (!active) activeModel = ctx.model?.id;
     active = true;
-    ctx.ui.setWorkingMessage(formatActivityMessage({ kind: "prompt" }, ctx.ui.theme));
+    render({ kind: "prompt" }, ctx);
   });
 
   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));
+    render({ kind: "tool", toolName: event.toolName }, ctx);
   });
 
   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));
+    render({ kind: "tool-result", failed: event.isError }, ctx);
   });
 
   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));
+    render({ kind: "responding" }, ctx);
   });
 
   pi.on("agent_settled", (_event, ctx) => {

package/killeros/auto-compaction.ts

@@ -33,7 +33,6 @@ export interface AutoCompactionDependencies {
   loadPreference?: (ctx: ExtensionContext) => AutoCompactionPreference;
   getCompactionSettings?: (ctx: ExtensionContext) => CompactionSettings;
   goal?: AutoCompactionGoalHandlers;
-  isInitActive?: () => boolean;
 }
 
 type AutoCompactionRequest = {
@@ -193,7 +192,7 @@ export function registerAutoCompaction(
   };
 
   pi.on("turn_end", (_event, ctx) => {
-    if (!supportedMode(ctx) || dependencies.isInitActive?.() === true || request) return;
+    if (!supportedMode(ctx) || request) return;
 
     let preference: AutoCompactionPreference;
     let compactionSettings: CompactionSettings;

package/killeros/change-receipt.ts

@@ -1,16 +1,16 @@
 import { spawn } from "node:child_process";
-import { watch } from "node:fs";
-import { lstat, open, readFile, readlink } from "node:fs/promises";
+import { createReadStream, watch } from "node:fs";
+import { PASSIVE_GIT_CONFIG_ARGS, passiveGitCommand, passiveGitEnv, passiveStatusSafetyArgs, samePassiveFilters } from "./passive-git-status.ts";
+import { lstat, open, readlink } from "node:fs/promises";
 import path from "node:path";
-import { promisify } from "node:util";
-import { inflate } from "node:zlib";
+import { createInflate } from "node:zlib";
 
 const GIT_TIMEOUT_MS = 5_000;
 const GIT_OUTPUT_LIMIT = 16 * 1024 * 1024;
 const SNAPSHOT_CONTENT_LIMIT = 128 * 1024 * 1024;
 const MAX_DIFF_OPERATIONS = 500_000;
 const MAX_FILES = 20;
-const inflateAsync = promisify(inflate);
+const GIT_OBJECT_HEADER_LIMIT = 1_024;
 
 export type ChangeUnavailableReason = "not-git" | "timeout" | "too-large" | "error";
 
@@ -43,7 +43,12 @@ export const CHECK_LABELS = [
   ...GRADLE_CHECK_LABELS,
 ] as const;
 
-export type CheckLabel = typeof CHECK_LABELS[number];
+const FOCUSED_CHECK_LABEL = "node --test (focused)";
+const FOCUSED_TEST_UNSAFE_CHARACTERS = [
+  '"', "'", "`", "$", ";", "&", "|", "<", ">", "*", "?", "[", "]", "{", "}", "(", ")", "#", "!",
+] as const;
+
+export type CheckLabel = typeof CHECK_LABELS[number] | typeof FOCUSED_CHECK_LABEL;
 
 export interface ChangeReceiptCollection {
   finish(): Promise<ChangeSummary>;
@@ -61,11 +66,19 @@ class GitFailure extends Error {
   }
 }
 
-function runGit(cwd: string, args: readonly string[], input?: Buffer): Promise<Buffer> {
+function runGit(cwd: string, args: readonly string[], input?: Buffer, stdoutLimit = GIT_OUTPUT_LIMIT): Promise<Buffer> {
+  let gitCommand: string;
+  try {
+    const found = passiveGitCommand(cwd);
+    if (!found) return Promise.reject(new GitFailure("error"));
+    gitCommand = found;
+  } catch {
+    return Promise.reject(new GitFailure("error"));
+  }
   return new Promise((resolve, reject) => {
-    const child = spawn("git", args, {
+    const child = spawn(gitCommand, args, {
       cwd,
-      env: { ...process.env, GIT_OPTIONAL_LOCKS: "0" },
+      env: passiveGitEnv(),
       stdio: [input ? "pipe" : "ignore", "pipe", "pipe"],
       windowsHide: true,
     });
@@ -82,7 +95,7 @@ function runGit(cwd: string, args: readonly string[], input?: Buffer): Promise<B
     timer.unref();
     const capture = (chunks: Buffer[], isStdout: boolean) => (chunk: Buffer): void => {
       const nextBytes = (isStdout ? stdoutBytes : stderrBytes) + chunk.length;
-      if (nextBytes > GIT_OUTPUT_LIMIT) {
+      if (nextBytes > (isStdout ? stdoutLimit : GIT_OUTPUT_LIMIT)) {
         failure = new GitFailure("too-large");
         child.kill();
         return;
@@ -129,15 +142,6 @@ type Repository = {
 };
 const repositoryCache = new Map<string, Promise<Repository>>();
 
-async function loadFilterNames(root: string): Promise<readonly string[]> {
-  const records = decode(await runGit(root, ["config", "--null", "--name-only", "--list"])).split("\0");
-  const names = new Set<string>();
-  for (const key of records) {
-    if (key && /^filter\..*\.(clean|process)$/u.test(key)) names.add(key.slice("filter.".length, key.lastIndexOf(".")));
-  }
-  return [...names];
-}
-
 async function repository(cwd: string): Promise<Repository> {
   const cached = repositoryCache.get(cwd);
   if (cached) return cached;
@@ -253,13 +257,15 @@ function discardMonitor(monitor: RepositoryMonitor): void {
 }
 
 async function snapshot(repo: Repository, paths?: readonly string[]): Promise<Snapshot> {
-  const filterNames = await loadFilterNames(repo.root);
+  const config = decode(await runGit(repo.root, PASSIVE_GIT_CONFIG_ARGS));
+  const safetyArgs = passiveStatusSafetyArgs(config);
+  if (!safetyArgs) throw new GitFailure("error");
   const output = decode(await runGit(repo.root, [
-    "-c", "core.fsmonitor=false",
-    ...filterNames.flatMap((name) => ["-c", `filter.${name}.clean=`, "-c", `filter.${name}.process=`, "-c", `filter.${name}.required=false`]),
+    ...safetyArgs,
     "status", "--porcelain=v2", "--branch", "--no-ahead-behind", "-z", "--no-renames", "--untracked-files=all", "--ignore-submodules=all",
     ...(paths ? ["--", ...paths] : []),
   ]));
+  if (!samePassiveFilters(config, decode(await runGit(repo.root, PASSIVE_GIT_CONFIG_ARGS)))) throw new GitFailure("error");
   const records = output.split("\0").filter(Boolean);
   const headRecord = records.find((record) => record.startsWith("# branch.oid "));
   if (!headRecord) throw new Error("missing HEAD state");
@@ -402,24 +408,60 @@ function createMonitor(repo: Repository, initialSnapshot: Snapshot): RepositoryM
   return monitor;
 }
 
-async function looseBlob(objectDirectory: string, id: string): Promise<Buffer | undefined> {
+function boundedBlobSize(value: string, limit: number): number {
+  const size = Number(value);
+  if (!Number.isSafeInteger(size) || size > limit) throw new GitFailure("too-large");
+  return size;
+}
+
+async function looseBlob(objectDirectory: string, id: string, limit: number): Promise<Buffer | undefined> {
+  const source = createReadStream(path.join(objectDirectory, id.slice(0, 2), id.slice(2)));
+  const inflater = createInflate();
+  source.once("error", (error) => inflater.destroy(error));
+  source.pipe(inflater);
+  let header = Buffer.alloc(0);
+  let expectedSize: number | undefined;
+  let body: Buffer | undefined;
+  let bodyBytes = 0;
   try {
-    const inflated = await inflateAsync(await readFile(path.join(objectDirectory, id.slice(0, 2), id.slice(2))));
-    const separator = inflated.indexOf(0);
-    if (separator < 0 || !inflated.subarray(0, separator).toString("ascii").startsWith("blob ")) throw new Error("invalid blob");
-    return inflated.subarray(separator + 1);
+    for await (const chunk of inflater) {
+      let data = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      if (expectedSize === undefined) {
+        const separator = data.indexOf(0);
+        if (separator < 0) {
+          if (header.length + data.length > GIT_OBJECT_HEADER_LIMIT) throw new Error("invalid blob header");
+          header = header.length === 0 ? Buffer.from(data) : Buffer.concat([header, data]);
+          continue;
+        }
+        if (header.length + separator > GIT_OBJECT_HEADER_LIMIT) throw new Error("invalid blob header");
+        const headerBytes = header.length === 0 ? data.subarray(0, separator) : Buffer.concat([header, data.subarray(0, separator)]);
+        const match = /^blob ([0-9]+)$/u.exec(headerBytes.toString("ascii"));
+        if (!match) throw new Error("invalid blob");
+        expectedSize = boundedBlobSize(match[1], limit);
+        body = Buffer.alloc(expectedSize);
+        data = data.subarray(separator + 1);
+      }
+      if (!body || expectedSize === undefined || data.length > expectedSize - bodyBytes) throw new Error("invalid blob");
+      data.copy(body, bodyBytes);
+      bodyBytes += data.length;
+    }
+    if (expectedSize === undefined || !body || bodyBytes !== expectedSize) throw new Error("invalid blob");
+    return body;
   } catch (error) {
-    if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") return undefined;
+    if (missingFile(error)) return undefined;
     throw error;
+  } finally {
+    source.destroy();
+    inflater.destroy();
   }
 }
 
 function cacheBlob(repo: Repository, id: string, content: Buffer): void {
+  if (content.length > SNAPSHOT_CONTENT_LIMIT) return;
   if (repo.blobCacheBytes + content.length > SNAPSHOT_CONTENT_LIMIT) {
     repo.blobCache.clear();
     repo.blobCacheBytes = 0;
   }
-  if (content.length > SNAPSHOT_CONTENT_LIMIT) return;
   repo.blobCache.set(id, content);
   repo.blobCacheBytes += content.length;
 }
@@ -427,34 +469,42 @@ function cacheBlob(repo: Repository, id: string, content: Buffer): void {
 async function loadHeadBlobs(repo: Repository, ids: readonly string[]): Promise<Map<string, Buffer>> {
   const blobs = new Map<string, Buffer>();
   const missing: string[] = [];
+  let blobBytes = 0;
   for (const id of new Set(ids)) {
     const cached = repo.blobCache.get(id);
-    if (cached) {
+    if (cached !== undefined) {
+      if (cached.length > SNAPSHOT_CONTENT_LIMIT - blobBytes) throw new GitFailure("too-large");
+      blobBytes += cached.length;
       blobs.set(id, cached);
       continue;
     }
-    const content = await looseBlob(repo.objectDirectory, id);
-    if (content) {
+    const content = await looseBlob(repo.objectDirectory, id, SNAPSHOT_CONTENT_LIMIT - blobBytes);
+    if (content !== undefined) {
+      blobBytes += content.length;
       blobs.set(id, content);
       cacheBlob(repo, id, content);
     } else missing.push(id);
   }
   if (missing.length > 0) {
-    const output = await runGit(repo.root, ["cat-file", "--batch"], Buffer.from(`${missing.join("\n")}\n`));
+    const batchOutputLimit = SNAPSHOT_CONTENT_LIMIT + missing.reduce((total, id) => total + id.length + 32, 0);
+    const output = await runGit(repo.root, ["cat-file", "--batch"], Buffer.from(`${missing.join("\n")}\n`), batchOutputLimit);
     let offset = 0;
     for (const id of missing) {
       const headerEnd = output.indexOf(10, offset);
-      const match = /^([0-9a-f]+) blob (\d+)$/u.exec(output.subarray(offset, headerEnd).toString("ascii"));
+      if (headerEnd < 0 || headerEnd - offset > GIT_OBJECT_HEADER_LIMIT) throw new Error("invalid batch blob");
+      const match = /^([0-9a-f]+) blob ([0-9]+)$/u.exec(output.subarray(offset, headerEnd).toString("ascii"));
       if (!match || match[1] !== id) throw new Error("invalid batch blob");
-      const size = Number(match[2]);
+      const size = boundedBlobSize(match[2], SNAPSHOT_CONTENT_LIMIT - blobBytes);
       const start = headerEnd + 1;
       const end = start + size;
       if (output[end] !== 10) throw new Error("invalid batch body");
       const content = Buffer.from(output.subarray(start, end));
+      blobBytes += size;
       blobs.set(id, content);
       cacheBlob(repo, id, content);
       offset = end + 1;
     }
+    if (offset !== output.length) throw new Error("invalid batch blob");
   }
   return blobs;
 }
@@ -633,14 +683,36 @@ async function compare(repo: Repository, baseline: Snapshot, settlement: Snapsho
   return { state: "available", totalFiles: changes.length, additions, deletions, files: changes.slice(0, MAX_FILES), omittedFiles: Math.max(0, changes.length - MAX_FILES) };
 }
 
+function isFocusedTestFile(value: string): boolean {
+  if (value.startsWith("-") || value.startsWith("~") || path.posix.isAbsolute(value) || path.win32.isAbsolute(value)
+    || /^[A-Za-z][A-Za-z\d+.-]*:/u.test(value) || /[\s\p{Cc}]/u.test(value)
+    || FOCUSED_TEST_UNSAFE_CHARACTERS.some((character) => value.includes(character))) return false;
+  const segments = value.split(/[\\/]/u);
+  const filename = segments.at(-1);
+  return segments.every((segment) => segment.length > 0 && segment !== "." && segment !== "..")
+    && filename !== undefined
+    && filename.includes(".test.")
+    && /\.(?:js|cjs|mjs|ts|cts|mts)$/u.test(filename);
+}
+
 export function recognizedCheck(command: unknown, failed: boolean): CheckAttempt | undefined {
   if (typeof command !== "string") return undefined;
   const normalized = command.replace(/^[\t ]+|[\t ]+$/gu, "");
+  const outcome = failed ? "failed" : "passed";
   const label = CHECK_LABELS.find((candidate) => normalized === candidate);
-  return label ? { label, outcome: failed ? "failed" : "passed" } : undefined;
+  if (label) return { label, outcome };
+  const focused = /^node --test(?: --experimental-strip-types)? ([^ \t]+)$/u.exec(normalized);
+  if (!focused?.[1] || !isFocusedTestFile(focused[1])) return undefined;
+  return { label: FOCUSED_CHECK_LABEL, outcome };
 }
 
-export async function beginChangeReceipt(cwd: string): Promise<ChangeReceiptCollection> {
+export async function beginChangeReceipt(cwd: string, trusted = true): Promise<ChangeReceiptCollection> {
+  if (!trusted) {
+    return {
+      finish: async () => ({ state: "unavailable", reason: "error" }),
+      dispose: async () => undefined,
+    };
+  }
   try {
     const repo = await repository(cwd);
     let monitor = repositoryMonitors.get(repo.root);

package/killeros/codex-fast.ts

@@ -10,10 +10,15 @@ function isRequestPayload(value: unknown): value is RequestPayload {
 
 export function registerCodexFastMode(pi: ExtensionAPI): void {
   pi.registerCommand("codex-fast", {
-    description: "Toggle Codex fast mode",
+    description: "Toggle or report Codex fast mode",
     handler: async (args, ctx) => {
-      if (args.trim()) {
-        ctx.ui.notify("Usage: /codex-fast", "error");
+      const trimmed = args.trim();
+      if (trimmed === "status") {
+        ctx.ui.notify(`Codex fast mode: ${isCodexFastEnabled() ? "enabled" : "disabled"}`, "info");
+        return;
+      }
+      if (trimmed) {
+        ctx.ui.notify("Usage: /codex-fast [status]", "error");
         return;
       }