killeros 2.1.25 → 2.1.27

package/CHANGELOG.md

@@ -4,6 +4,34 @@ All notable changes to KillerOS are documented here.
 
 ## [Unreleased]
 
+## [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
+
+- Restored Pi lifecycle loading, blocked footer Git status from invoking configured filesystem monitors, and kept replaced `/init` guidance at a disclosed recovery path so late writes remain recoverable.
+- Preserved Unicode blocker evidence when restoring goals, rejected cancelled goal updates before completion is saved, and read untracked symlink destinations instead of their targets in change receipts.
+- Kept `/init` isolated from proactive compaction, refreshed Git filter safeguards for each receipt scan, and preserved compaction recovery after cancelled session replacements.
+
 ## [2.1.25] - 2026-09-06
 
 ### 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);
+  const goalCompaction = registerGoalSettlement(pi, goalRuntime);
   registerAutoCompaction(pi, { goal: goalCompaction });
-  registerInitSettlement(pi, initRuntime);
   registerRequestActivity(pi);
   registerCompletionNotifications(pi, options.completionNotifications);
 }

package/README.md

@@ -6,8 +6,7 @@ A TypeScript extension for the [Pi coding agent](https://github.com/earendil-wor
 
 - 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.
+- `/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.25`. Add `-l` to install only for the current project. Restart Pi after installing.
+Pin a release by appending its tag, for example `@v2.1.27`. 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.25`. 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
 

package/killeros/auto-compaction.ts

@@ -288,6 +288,4 @@ export function registerAutoCompaction(
   pi.on("session_start", resetForLifecycle);
   pi.on("session_shutdown", resetForLifecycle);
   pi.on("session_tree", resetForLifecycle);
-  pi.on("session_before_switch", resetForLifecycle);
-  pi.on("session_before_fork", resetForLifecycle);
 }

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;
@@ -119,49 +132,16 @@ function missingFile(error: unknown): boolean {
   return error !== null && typeof error === "object" && "code" in error && error.code === "ENOENT";
 }
 
-type FilterConfiguration = { names: readonly string[]; sources: ReadonlyMap<string, Buffer> };
 type Repository = {
   root: string;
   gitDirectory: string;
   commonDirectory: string;
   objectDirectory: string;
-  filterConfiguration: FilterConfiguration;
   blobCache: Map<string, Buffer>;
   blobCacheBytes: number;
 };
 const repositoryCache = new Map<string, Promise<Repository>>();
 
-async function loadFilterConfiguration(root: string, gitDirectory: string): Promise<FilterConfiguration> {
-  const records = decode(await runGit(root, ["config", "--null", "--show-origin", "--name-only", "--list"])).split("\0");
-  const names = new Set<string>();
-  const sourcePaths = new Set<string>([path.join(gitDirectory, "HEAD")]);
-  for (let index = 0; index + 1 < records.length; index += 2) {
-    const origin = records[index];
-    const key = records[index + 1];
-    if (origin?.startsWith("file:")) sourcePaths.add(path.resolve(root, origin.slice("file:".length)));
-    if (key && /^filter\..*\.(clean|process)$/u.test(key)) names.add(key.slice("filter.".length, key.lastIndexOf(".")));
-  }
-  const sources = new Map<string, Buffer>();
-  for (const sourcePath of sourcePaths) sources.set(sourcePath, await readBoundedFile(sourcePath, GIT_OUTPUT_LIMIT));
-  return { names: [...names], sources };
-}
-
-async function currentFilterNames(repo: Repository): Promise<readonly string[]> {
-  for (const [sourcePath, previous] of repo.filterConfiguration.sources) {
-    try {
-      if (!(await readBoundedFile(sourcePath, GIT_OUTPUT_LIMIT)).equals(previous)) {
-        repo.filterConfiguration = await loadFilterConfiguration(repo.root, repo.gitDirectory);
-        break;
-      }
-    } catch (error) {
-      if (!missingFile(error)) throw error;
-      repo.filterConfiguration = await loadFilterConfiguration(repo.root, repo.gitDirectory);
-      break;
-    }
-  }
-  return repo.filterConfiguration.names;
-}
-
 async function repository(cwd: string): Promise<Repository> {
   const cached = repositoryCache.get(cwd);
   if (cached) return cached;
@@ -174,7 +154,6 @@ async function repository(cwd: string): Promise<Repository> {
       gitDirectory,
       commonDirectory,
       objectDirectory: path.join(commonDirectory, "objects"),
-      filterConfiguration: await loadFilterConfiguration(root, gitDirectory),
       blobCache: new Map(),
       blobCacheBytes: 0,
     };
@@ -278,13 +257,15 @@ function discardMonitor(monitor: RepositoryMonitor): void {
 }
 
 async function snapshot(repo: Repository, paths?: readonly string[]): Promise<Snapshot> {
-  const filterNames = await currentFilterNames(repo);
+  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");
@@ -295,12 +276,13 @@ async function snapshot(repo: Repository, paths?: readonly string[]): Promise<Sn
     if (record.startsWith("? ")) {
       const filePath = record.slice(2);
       if (!filePath || filePath.endsWith("/")) continue;
+      const stats = await lstat(path.join(repo.root, ...filePath.split("/")));
       files.set(filePath, {
         ...files.get(filePath),
         path: filePath,
         indexMode: undefined,
         indexObjectId: undefined,
-        mode: "100644",
+        mode: stats.isSymbolicLink() ? "120000" : stats.mode & 0o111 ? "100755" : "100644",
         contentObjectId: undefined,
       });
       continue;
@@ -426,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;
 }
@@ -451,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;
 }
@@ -657,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;
       }
 

package/killeros/footer.ts

@@ -4,6 +4,7 @@ import { type ExtensionAPI, type ExtensionContext, type Theme, type ThemeColor }
 import { truncateToWidth, visibleWidth, type TUI } from "@earendil-works/pi-tui";
 import { isCodexFastEnabled, subscribeCodexFast } from "./codex-fast-state.ts";
 import { formatCwd, formatTime, modelDisplayName, padRight } from "./display.ts";
+import { PASSIVE_GIT_CONFIG_ARGS, passiveGitCommand, passiveGitEnv, passiveStatusSafetyArgs, samePassiveFilters } from "./passive-git-status.ts";
 import { goalElapsedMilliseconds } from "./goal-state.ts";
 import type { GoalRuntime, GoalState } from "./runtime.ts";
 import { safeTerminalText } from "./safe-terminal-text.ts";
@@ -35,42 +36,90 @@ type GitStatusExecutor = (
   callback: (error: Error | null, stdout: string) => void,
 ) => unknown;
 
-/** Resolves changed-file counts with a bounded asynchronous Git status process. */
+/** Resolves changed-file counts with a bounded asynchronous Git status process in a trusted project. */
 export function resolveGitFileChanges(
   cwd: string,
   execute: GitStatusExecutor = execFile,
+  trusted = true,
 ): Promise<GitFileChanges | undefined> {
+  if (!trusted) return Promise.resolve(undefined);
   return new Promise((resolve) => {
-    execute(
-      "git",
-      ["-C", cwd, "status", "--porcelain=v1", "-z", "--untracked-files=all"],
-      {
-        encoding: "utf8",
-        env: { ...process.env, GIT_OPTIONAL_LOCKS: "0" },
-        maxBuffer: 4 * 1024 * 1024,
-        timeout: GIT_STATUS_TIMEOUT_MS,
-        windowsHide: true,
-      },
-      (error, stdout) => {
+    let gitCommand: string;
+    try {
+      const found = passiveGitCommand(cwd);
+      if (!found) {
+        resolve(undefined);
+        return;
+      }
+      gitCommand = found;
+    } catch {
+      resolve(undefined);
+      return;
+    }
+    const options = {
+      encoding: "utf8" as const,
+      env: passiveGitEnv(),
+      maxBuffer: 4 * 1024 * 1024,
+      timeout: GIT_STATUS_TIMEOUT_MS,
+      windowsHide: true as const,
+    };
+    const verifyFiltersUnchanged = (before: string, done: (unchanged: boolean) => void): void => {
+      try {
+        execute(gitCommand, ["-C", cwd, ...PASSIVE_GIT_CONFIG_ARGS], options, (error, after) => {
+          done(!error && samePassiveFilters(before, after));
+        });
+      } catch {
+        done(false);
+      }
+    };
+    const runStatus = (config: string, args: string[]): void => {
+      try {
+        execute(gitCommand, args, options, (error, stdout) => {
+          if (error) {
+            resolve(undefined);
+            return;
+          }
+          verifyFiltersUnchanged(config, (unchanged) => {
+            if (!unchanged) {
+              resolve(undefined);
+              return;
+            }
+
+          const changes: GitFileChanges = { modified: 0, added: 0, deleted: 0 };
+          const entries = stdout.split("\0");
+          for (let index = 0; index < entries.length; index += 1) {
+            const entry = entries[index];
+            if (!entry) continue;
+            const status = entry.slice(0, 2);
+            if (status.includes("D")) changes.deleted += 1;
+            else if (status === "??" || status.includes("A")) changes.added += 1;
+            else changes.modified += 1;
+            if (status.includes("R") || status.includes("C")) index += 1;
+          }
+          resolve(changes);
+          });
+        });
+      } catch {
+        resolve(undefined);
+      }
+    };
+
+    try {
+      execute(gitCommand, ["-C", cwd, ...PASSIVE_GIT_CONFIG_ARGS], options, (error, config) => {
         if (error) {
           resolve(undefined);
           return;
         }
-
-        const changes: GitFileChanges = { modified: 0, added: 0, deleted: 0 };
-        const entries = stdout.split("\0");
-        for (let index = 0; index < entries.length; index += 1) {
-          const entry = entries[index];
-          if (!entry) continue;
-          const status = entry.slice(0, 2);
-          if (status.includes("D")) changes.deleted += 1;
-          else if (status === "??" || status.includes("A")) changes.added += 1;
-          else changes.modified += 1;
-          if (status.includes("R") || status.includes("C")) index += 1;
+        const safetyArgs = passiveStatusSafetyArgs(config);
+        if (!safetyArgs) {
+          resolve(undefined);
+          return;
         }
-        resolve(changes);
-      },
-    );
+        runStatus(config, ["-C", cwd, ...safetyArgs, "status", "--porcelain=v1", "-z", "--untracked-files=all"]);
+      });
+    } catch {
+      resolve(undefined);
+    }
   });
 }
 
@@ -389,7 +438,7 @@ export function registerFooter(pi: ExtensionAPI, goalRuntime: GoalRuntime): void
         if (JSON.stringify(changes) === JSON.stringify(gitFileChanges)) return;
         gitFileChanges = changes;
         tui.requestRender();
-      });
+      }, (cwd) => resolveGitFileChanges(cwd, execFile, ctx.isProjectTrusted()));
       const unsubscribe = footerData.onBranchChange(() => {
         gitStatus.request();
         tui.requestRender();