killeros 2.1.26 → 2.1.27

package/CHANGELOG.md

@@ -4,6 +4,26 @@ 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

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

@@ -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.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.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.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
 

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;
       }
 

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, "-c", "core.fsmonitor=false", "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();

package/killeros/goal-interface.ts

@@ -8,7 +8,7 @@ import { reportError } from "./errors.ts";
 import { parseGoalCommand } from "./goal-command.ts";
 import { GOAL_ENTRY_TYPE, GOAL_UPDATE_TOOL, isGoalModeSupported, isSavedSession, pauseGoalAfterFailure, persistGoalState, scheduleGoalContinuation, stopGoalRun, sumGoalTokens, syncGoalUpdateTool, transitionGoal, type GoalEntryData } from "./goal-runtime.ts";
 import { checkpointPausedGoalState, createNewGoalState, DEFAULT_GOAL_MAX_TURNS, GOAL_MAX_TURNS, goalElapsedMilliseconds, GOAL_VERSION, inferGoalVerification, parseGoalState, recordGoalBlockerAudit, transitionGoalState, verifyGoalDeliverable } from "./goal-state.ts";
-import type { GoalRuntime, GoalState, GoalStatus, InitRuntime } from "./runtime.ts";
+import type { GoalRuntime, GoalState, GoalStatus } from "./runtime.ts";
 import { safeTerminalText } from "./safe-terminal-text.ts";
 
 const GoalUpdateParams = Type.Object({
@@ -65,7 +65,6 @@ function goalStatusSummary(state: GoalState, ctx: ExtensionContext): string {
 export function registerGoalInterface(
   pi: ExtensionAPI,
   runtime: GoalRuntime,
-  initState: InitRuntime,
 ): void {
   pi.registerEntryRenderer<GoalEntryData>(GOAL_ENTRY_TYPE, (entry, options, theme) => {
     const data = entry.data;
@@ -286,10 +285,6 @@ export function registerGoalInterface(
       }
 
       if (command.kind === "resume") {
-        if (initState.active) {
-          ctx.ui.notify("Wait for /init to finish before resuming a goal", "error");
-          return;
-        }
         if (!runtime.state) {
           ctx.ui.notify("No goal is set", "info");
           return;
@@ -313,7 +308,7 @@ export function registerGoalInterface(
             const base = transitionGoalState(runtime.state, "active", undefined, { resetBlockedAudit: true }, Date.now());
             persistGoalState(pi, runtime, "resume", { ...base, maxTurns: renewed });
             runtime.continuationScheduled = false;
-            if (scheduleGoalContinuation(pi, runtime, initState, ctx)) ctx.ui.notify("Goal resumed", "info");
+            if (scheduleGoalContinuation(pi, runtime, ctx)) ctx.ui.notify("Goal resumed", "info");
           } catch (error) {
             reportError(ctx, "Goal could not be resumed", error);
           }
@@ -322,17 +317,13 @@ export function registerGoalInterface(
         try {
           transitionGoal(pi, runtime, "resume", "active", undefined, { resetBlockedAudit: true });
           runtime.continuationScheduled = false;
-          if (scheduleGoalContinuation(pi, runtime, initState, ctx)) ctx.ui.notify("Goal resumed", "info");
+          if (scheduleGoalContinuation(pi, runtime, ctx)) ctx.ui.notify("Goal resumed", "info");
         } catch (error) {
           reportError(ctx, "Goal could not be resumed", error);
         }
         return;
       }
 
-      if (initState.active) {
-        ctx.ui.notify("Wait for /init to finish before starting a goal", "error");
-        return;
-      }
       switch (command.kind) {
         case "objective":
           break;
@@ -364,7 +355,7 @@ export function registerGoalInterface(
       }
       if (waitError) {
         reportError(ctx, "Goal could not wait for the active turn", waitError);
-        scheduleGoalContinuation(pi, runtime, initState, ctx);
+        scheduleGoalContinuation(pi, runtime, ctx);
         return;
       }
       let verification: Awaited<ReturnType<typeof inferGoalVerification>>;
@@ -375,7 +366,7 @@ export function registerGoalInterface(
           reportError(ctx, "Goal could not be started", error);
         } else {
           reportError(ctx, "Goal could not be replaced", error);
-          scheduleGoalContinuation(pi, runtime, initState, ctx);
+          scheduleGoalContinuation(pi, runtime, ctx);
         }
         return;
       }
@@ -384,7 +375,7 @@ export function registerGoalInterface(
           maxTurns: DEFAULT_GOAL_MAX_TURNS,
         });
         persistGoalState(pi, runtime, unfinished ? "replace" : "set", state);
-        if (scheduleGoalContinuation(pi, runtime, initState, ctx)) {
+        if (scheduleGoalContinuation(pi, runtime, ctx)) {
           ctx.ui.notify("Goal active. KillerOS will continue until completion, a repeated blocker, or pause.", "info");
         }
       } catch (error) {