killeros 2.1.27 → 2.1.29

package/killeros/passive-git-status.ts

@@ -1,21 +1,40 @@
+import { createHash } from "node:crypto";
 import { accessSync, constants, existsSync, realpathSync, statSync } from "node:fs";
+import { lstat, open, readlink } from "node:fs/promises";
 import path from "node:path";
 
-// Passive Git inspection disables fsmonitor, known clean/process filters,
-// promisor fetches, and repository-supplied Git executables. Config discovery
-// and status run in separate Git processes, so a filter configured between
-// them would be absent from the safety overrides. Automatic Git children run
-// without PATH resolution, and each scan rejects results when the effective
-// filter set changed. Absolute filter commands remain possible, so product
-// callers run these scans only after project trust is granted.
-//
-// Executable discovery itself is passive: it never starts a command shell,
-// locator process, or other helper executable, and never executes a bare
-// program name. It scans absolute search-path entries for an absolute Git
-// path outside the inspected repository and fails closed when none exists.
-export const PASSIVE_GIT_CONFIG_ARGS = ["config", "--includes", "--null", "--name-only", "--list"] as const;
-
-const SAFE_FILTER_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]*$/u;
+const WORKTREE_CONTENT_LIMIT = 128 * 1024 * 1024;
+const PASSIVE_METADATA_ARGS = ["-c", "core.fsmonitor=false"] as const;
+
+export type PassiveGitRunner = (args: readonly string[]) => Promise<Buffer>;
+
+export type PassiveWorktreeFile = {
+  path: string;
+  headMode?: string;
+  headObjectId?: string;
+  indexMode?: string;
+  indexObjectId?: string;
+  mode?: string;
+  content?: Buffer;
+  contentObjectId?: string;
+};
+
+export type PassiveWorktreeSnapshot = {
+  head: string;
+  files: Map<string, PassiveWorktreeFile>;
+};
+
+type IndexEntry = {
+  mode: string;
+  objectId: string;
+  eolAttributes: string;
+  ctimeNanoseconds: bigint;
+  mtimeNanoseconds: bigint;
+  size: bigint;
+  skipWorktree: boolean;
+};
+
+type TreeEntry = { mode: string; objectId: string };
 
 function searchPathEntries(env: NodeJS.ProcessEnv): string[] {
   const values: string[] = [];
@@ -101,13 +120,7 @@ function insideInspected(candidate: string, root: string): boolean {
   return normalizedCandidate.startsWith(`${trimmed}${path.sep}`);
 }
 
-// Absolute Git binary outside the inspected repository, or undefined when
-// no safe candidate exists. Never starts a helper process and never
-// returns a bare command name, so opening a repository cannot execute a
-// repository-local locator or Git executable. Empty and relative
-// search-path entries are ignored because they can resolve against the
-// current directory. A candidate that resolves through a link returns its
-// final path only when that path is also outside the repository.
+/** Returns an absolute Git binary outside the inspected repository without starting a locator process. */
 export function passiveGitCommand(cwd: string, env: NodeJS.ProcessEnv = process.env): string | undefined {
   const root = inspectedRoot(cwd);
   if (!root) return undefined;
@@ -118,8 +131,7 @@ export function passiveGitCommand(cwd: string, env: NodeJS.ProcessEnv = process.
   for (const raw of entries) {
     if (raw === "" || raw.trim() === "") continue;
     const directory = unquoted(raw);
-    if (directory === "" || directory.trim() === "") continue;
-    if (!path.isAbsolute(directory)) continue;
+    if (directory === "" || directory.trim() === "" || !path.isAbsolute(directory)) continue;
     for (const base of baseNames) {
       const candidate = path.join(directory, base);
       try {
@@ -140,60 +152,15 @@ export function passiveGitCommand(cwd: string, env: NodeJS.ProcessEnv = process.
       } catch {
         continue;
       }
-      if (!path.isAbsolute(resolved)) continue;
-      if (insideInspected(resolved, root)) continue;
-      return resolved;
+      if (path.isAbsolute(resolved) && !insideInspected(resolved, root)) return resolved;
     }
   }
   return undefined;
 }
 
-// Lists effective clean/process filter drivers in discovery order, or
-// undefined when discovery output is incomplete or names a driver the
-// safety overrides cannot represent.
-export function passiveFilterNames(config: string): string[] | undefined {
-  const records = config.split("\0");
-  if (records.at(-1) !== "") return undefined;
-  const names = new Set<string>();
-  for (const key of records) {
-    if (!key) continue;
-    const name = /^filter\.(.*)\.(?:clean|process)$/us.exec(key)?.[1];
-    if (name === undefined) continue;
-    if (!SAFE_FILTER_NAME.test(name)) return undefined;
-    names.add(name);
-  }
-  return [...names];
-}
-
-// Builds safe overrides from null-delimited `git config --name-only --list`
-// output. Returns undefined when output is incomplete or names an unsafe
-// filter, so the caller skips the status call.
-export function passiveStatusSafetyArgs(config: string): string[] | undefined {
-  const names = passiveFilterNames(config);
-  if (!names) return undefined;
-  return ["-c", "core.fsmonitor=false", ...names.flatMap((name) => ["-c", `filter.${name}.clean=`, "-c", `filter.${name}.process=`, "-c", `filter.${name}.required=false`])];
-}
-
-export function samePassiveFilters(before: string, after: string): boolean {
-  const earlier = passiveFilterNames(before);
-  const later = passiveFilterNames(after);
-  if (!earlier || !later) return false;
-  if (earlier.length !== later.length) return false;
-  const ordered = [...later].sort();
-  return [...earlier].sort().every((name, index) => name === ordered[index]);
-}
-
-// Environment for automatic Git children: no optional locks, no lazy fetch
-// from a promisor remote, and no PATH so a filter command that becomes
-// effective after discovery cannot resolve a bare command name. Absolute
-// filter paths are still possible; trusted-project callers detect mid-scan
-// config changes with samePassiveFilters and skip those results.
+/** Environment for automatic Git children, with locks, lazy fetches, and PATH command resolution disabled. */
 export function passiveGitEnv(base: NodeJS.ProcessEnv = process.env): NodeJS.ProcessEnv {
-  const env: NodeJS.ProcessEnv = {
-    ...base,
-    GIT_OPTIONAL_LOCKS: "0",
-    GIT_NO_LAZY_FETCH: "1",
-  };
+  const env: NodeJS.ProcessEnv = { ...base, GIT_OPTIONAL_LOCKS: "0", GIT_NO_LAZY_FETCH: "1" };
   let hasPath = false;
   for (const key of Object.keys(env)) {
     if (key.toLowerCase() === "path") {
@@ -204,3 +171,176 @@ export function passiveGitEnv(base: NodeJS.ProcessEnv = process.env): NodeJS.Pro
   if (!hasPath) env.PATH = "";
   return env;
 }
+
+function decode(buffer: Buffer): string {
+  return new TextDecoder("utf-8", { fatal: true }).decode(buffer);
+}
+
+function parseIndex(output: Buffer): Map<string, IndexEntry> {
+  const text = decode(output);
+  const pattern = /([0-7]{6}) ([0-9a-f]{40}(?:[0-9a-f]{24})?) ([0-3])\t([^\t]*)\t([^\0]*)\0  ctime: (\d+):(\d+)\n  mtime: (\d+):(\d+)\n  dev: \d+\tino: \d+\n  uid: \d+\tgid: \d+\n  size: (\d+)\tflags: ([0-9a-f]+)\n/gu;
+  const entries = new Map<string, IndexEntry>();
+  let end = 0;
+  for (const match of text.matchAll(pattern)) {
+    if (match.index !== end) throw new Error("invalid index metadata");
+    end = match.index + match[0].length;
+    const [, mode, objectId, stage, eolAttributes, filePath, ctimeSeconds, ctimeNanoseconds, mtimeSeconds, mtimeNanoseconds, size, flags] = match;
+    if (!mode || !objectId || !stage || eolAttributes === undefined || filePath === undefined || !ctimeSeconds || !ctimeNanoseconds || !mtimeSeconds || !mtimeNanoseconds || !size || !flags || stage !== "0") {
+      throw new Error("unsupported index entry");
+    }
+    entries.set(filePath, {
+      mode,
+      objectId,
+      eolAttributes: eolAttributes.trim(),
+      ctimeNanoseconds: BigInt(ctimeSeconds) * 1_000_000_000n + BigInt(ctimeNanoseconds),
+      mtimeNanoseconds: BigInt(mtimeSeconds) * 1_000_000_000n + BigInt(mtimeNanoseconds),
+      size: BigInt(size),
+      skipWorktree: (Number.parseInt(flags, 16) & 0x40000000) !== 0,
+    });
+  }
+  if (end !== text.length) throw new Error("incomplete index metadata");
+  return entries;
+}
+
+function parseTree(output: Buffer): Map<string, TreeEntry> {
+  const entries = new Map<string, TreeEntry>();
+  for (const record of decode(output).split("\0")) {
+    if (!record) continue;
+    const match = /^([0-7]{6}) (?:blob|commit) ([0-9a-f]{40}(?:[0-9a-f]{24})?)\t([^\0]+)$/u.exec(record);
+    if (!match?.[1] || !match[2] || !match[3]) throw new Error("invalid tree entry");
+    entries.set(match[3], { mode: match[1], objectId: match[2] });
+  }
+  return entries;
+}
+
+function parsePaths(output: Buffer): string[] {
+  const records = decode(output).split("\0");
+  if (records.at(-1) !== "") throw new Error("incomplete path list");
+  return records.slice(0, -1);
+}
+
+async function readFileState(root: string, entry: IndexEntry | undefined, filePath: string, remaining: number): Promise<{ mode: string; content?: Buffer; statsMatch: boolean }> {
+  const absolutePath = path.join(root, ...filePath.split("/"));
+  const stats = await lstat(absolutePath, { bigint: true });
+  const mode = stats.isSymbolicLink() ? "120000" : stats.isFile() ? stats.mode & 0o111n ? "100755" : "100644" : "";
+  if (!mode) throw new Error("unsupported worktree entry");
+  const statsMatch = entry !== undefined
+    && entry.mode === mode
+    && entry.size === stats.size
+    && entry.ctimeNanoseconds === stats.ctimeNs
+    && entry.mtimeNanoseconds === stats.mtimeNs;
+  if (statsMatch) return { mode, statsMatch };
+  if (!stats.isSymbolicLink() && stats.size > BigInt(remaining)) throw new Error("worktree content limit exceeded");
+  const content = stats.isSymbolicLink() ? Buffer.from(await readlink(absolutePath)) : await readBounded(absolutePath, remaining);
+  return { mode, content, statsMatch };
+}
+
+async function readBounded(filePath: string, limit: number): Promise<Buffer> {
+  const handle = await open(filePath, "r");
+  try {
+    const stats = await handle.stat();
+    if (!stats.isFile() || stats.size > limit) throw new Error("worktree content limit exceeded");
+    const content = Buffer.alloc(stats.size + 1);
+    let length = 0;
+    while (length < content.length) {
+      const { bytesRead } = await handle.read(content, length, content.length - length, length);
+      if (bytesRead === 0) break;
+      length += bytesRead;
+    }
+    if (length > stats.size) throw new Error("worktree changed while reading");
+    return content.subarray(0, length);
+  } finally {
+    await handle.close();
+  }
+}
+
+function blobObjectId(content: Buffer, length: number): string {
+  const algorithm = length === 64 ? "sha256" : "sha1";
+  return createHash(algorithm).update(`blob ${content.length}\0`).update(content).digest("hex");
+}
+
+function matchesIndex(content: Buffer, entry: IndexEntry, autoCrlf: string): boolean {
+  if (blobObjectId(content, entry.objectId.length) === entry.objectId) return true;
+  if (entry.mode === "120000" || !content.includes(Buffer.from("\r\n"))) return false;
+  const attributes = entry.eolAttributes;
+  if (attributes === "-text") return false;
+  const automatic = attributes.startsWith("text=auto") || !attributes;
+  if (!attributes && !["true", "input"].includes(autoCrlf)) return false;
+  if (automatic) {
+    // Match Git's convert_is_binary heuristic, including its terminal EOF exception.
+    let printable = 0;
+    let nonprintable = 0;
+    for (let index = 0; index < content.length; index += 1) {
+      const byte = content[index];
+      if (byte === 0 || byte === 13 && content[index + 1] !== 10) return false;
+      if (byte === 13 || byte === 10 || byte === 26 && index === content.length - 1) continue;
+      if (byte === 127 || byte < 32 && ![8, 9, 12, 27].includes(byte)) nonprintable += 1;
+      else printable += 1;
+    }
+    if (Math.floor(printable / 128) < nonprintable) return false;
+  }
+  const normalized = Buffer.from(content.toString("latin1").replaceAll("\r\n", "\n"), "latin1");
+  return blobObjectId(normalized, entry.objectId.length) === entry.objectId;
+}
+
+/**
+ * Reads index and tree metadata with Git, then inspects worktree files with Node.
+ * No Git command in this path asks Git to convert worktree content, so clean and process filters cannot start.
+ */
+export async function inspectWorktreeWithoutFilters(root: string, runGit: PassiveGitRunner): Promise<PassiveWorktreeSnapshot> {
+  const [indexOutput, untrackedOutput, resolvedHead, autoCrlfOutput] = await Promise.all([
+    runGit([...PASSIVE_METADATA_ARGS, "ls-files", "--cached", "--debug", "-z", "--full-name",
+      "--format=%(objectmode) %(objectname) %(stage)%x09%(eolattr)%x09%(path)"]),
+    runGit([...PASSIVE_METADATA_ARGS, "ls-files", "--others", "--exclude-standard", "-z", "--full-name"]),
+    runGit(["rev-parse", "--verify", "HEAD"]).then(decode, () => ""),
+    runGit(["config", "--type=bool-or-str", "--default", "false", "--get", "core.autocrlf"]),
+  ]);
+  const autoCrlf = decode(autoCrlfOutput).trim().toLowerCase();
+  const head = resolvedHead.trim();
+  if (head && !/^[0-9a-f]{40}(?:[0-9a-f]{24})?$/u.test(head)) throw new Error("invalid HEAD");
+  const index = parseIndex(indexOutput);
+  const tree = head ? parseTree(await runGit(["ls-tree", "-r", "-z", "--full-tree", head])) : new Map<string, TreeEntry>();
+  const files = new Map<string, PassiveWorktreeFile>();
+  let contentBytes = 0;
+
+  for (const filePath of new Set([...tree.keys(), ...index.keys()])) {
+    const headEntry = tree.get(filePath);
+    const indexEntry = index.get(filePath);
+    if (headEntry?.mode === "160000" || indexEntry?.mode === "160000") continue;
+    const staged = headEntry?.mode !== indexEntry?.mode || headEntry?.objectId !== indexEntry?.objectId;
+    let mode: string | undefined;
+    let content: Buffer | undefined;
+    let worktreeChanged = false;
+    if (indexEntry && !indexEntry.skipWorktree) {
+      try {
+        const state = await readFileState(root, indexEntry, filePath, WORKTREE_CONTENT_LIMIT - contentBytes);
+        mode = process.platform === "win32" && indexEntry.mode !== "120000" ? indexEntry.mode : state.mode;
+        content = state.content;
+        if (content) contentBytes += content.length;
+        worktreeChanged = !state.statsMatch && (mode !== indexEntry.mode || !content || !matchesIndex(content, indexEntry, autoCrlf));
+      } catch (error) {
+        if (error !== null && typeof error === "object" && "code" in error && error.code === "ENOENT") worktreeChanged = true;
+        else throw error;
+      }
+    }
+    if (!staged && !worktreeChanged) continue;
+    files.set(filePath, {
+      path: filePath,
+      headMode: headEntry?.mode,
+      headObjectId: headEntry?.objectId,
+      indexMode: indexEntry?.mode,
+      indexObjectId: indexEntry?.objectId,
+      mode: worktreeChanged ? mode : indexEntry?.mode,
+      ...(worktreeChanged && content ? { content } : indexEntry ? { contentObjectId: indexEntry.objectId } : {}),
+    });
+  }
+
+  for (const filePath of parsePaths(untrackedOutput)) {
+    const state = await readFileState(root, undefined, filePath, WORKTREE_CONTENT_LIMIT - contentBytes);
+    if (!state.content) throw new Error("missing untracked content");
+    contentBytes += state.content.length;
+    const previous = files.get(filePath);
+    files.set(filePath, { ...previous, path: filePath, mode: state.mode, content: state.content, contentObjectId: undefined });
+  }
+  return { head: head || "(initial)", files };
+}

package/killeros/runtime.ts

@@ -1,5 +1,43 @@
 export type GoalStatus = "active" | "paused" | "blocked" | "complete";
 
+export type GoalTurnPhase = "ready" | "in-flight" | "authorized";
+
+export interface GoalContinueReport {
+  turn: number;
+  evidence: string;
+  nextAction: string;
+}
+
+export type GoalTurnDecision =
+  | {
+      kind: "continue";
+      turn: number;
+      evidence: string;
+      nextAction: string;
+    }
+  | {
+      kind: "blocker-audit";
+      turn: number;
+      blockerKey: string;
+      streak: number;
+      evidence: string;
+    }
+  | {
+      kind: "blocked";
+      turn: number;
+      blockerKey: string;
+      streak: 3;
+      evidence: string;
+    }
+  | {
+      kind: "complete";
+      turn: number;
+      evidence: string;
+      verification: "file" | "model-reported";
+    };
+
+export type GoalPendingDecision = Extract<GoalTurnDecision, { kind: "continue" | "blocker-audit" }>;
+
 export interface GoalBlockerAudit {
   key: string;
   streak: number;
@@ -29,6 +67,11 @@ export interface GoalStateCommon {
   baselineTokens: number;
   verification?: GoalFileVerification;
   maxTurns?: number;
+  turnPhase?: GoalTurnPhase;
+  turnDecision?: GoalPendingDecision;
+  lastDecision?: GoalTurnDecision;
+  lastContinueReport?: GoalContinueReport;
+  stopReason?: string;
 }
 
 export type GoalState = GoalStateCommon & (
@@ -69,6 +112,13 @@ export interface AutomaticGoalCompaction {
   pausedRevision: number;
   outcome: AutomaticGoalCompactionOutcome;
   turnSettled: boolean;
+  turn: number;
+  resumeSameTurn: boolean;
+}
+
+export interface GoalTurnExecution {
+  turn: number;
+  revision: number;
 }
 
 export interface GoalRuntime {
@@ -77,10 +127,12 @@ export interface GoalRuntime {
   continuationHeld: boolean;
   goalTurnInFlight: boolean;
   agentEndObserved: boolean;
+  goalTurn?: GoalTurnExecution;
   automaticCompaction?: AutomaticGoalCompaction;
   persistenceRetryNeeded: boolean;
   lastStopReason?: string;
   lastError?: string;
+  lifecycleGeneration: number;
   requestRender?: () => void;
 }
 
@@ -90,7 +142,9 @@ export function createGoalRuntime(): GoalRuntime {
     continuationHeld: false,
     goalTurnInFlight: false,
     agentEndObserved: false,
+    goalTurn: undefined,
     automaticCompaction: undefined,
     persistenceRetryNeeded: false,
+    lifecycleGeneration: 0,
   };
 }

package/killeros/worked-for.ts

@@ -322,7 +322,7 @@ export function registerWorkedFor(
   pi.registerEntryRenderer<WorkedForEntryData>(WORKED_FOR_ENTRY_TYPE, (entry, options, theme) => {
     const data = parseWorkedForEntryData(entry.data);
     if (!data) return undefined;
-    if (data.version === 1) return new Text(theme.fg("dim", `✻ Worked for ${formatWorkedForDuration(data.milliseconds)}`), 1, 0);
+    if (data.version === 1) return new Text(theme.fg("dim", `Worked for ${formatWorkedForDuration(data.milliseconds)}`), 1, 0);
     if (data.version === 4) return new WorkedForV4Component(data, options.expanded, theme);
     const outcome = OUTCOMES[data.outcome];
     const tokens = data.version === 3 ? ` · ↑ ${formatTokens(data.tokens)} tokens` : "";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "killeros",
-  "version": "2.1.27",
+  "version": "2.1.29",
   "description": "TUI, goals, and workflow automation for the Pi coding agent",
   "type": "module",
   "keywords": [

package/themes/killeros.json

@@ -16,7 +16,8 @@
     "success": "#8fa88b",
     "error": "#c8786c",
     "warning": "#bda36c",
-    "pink": "#b98aa5"
+    "pink": "#b98aa5",
+    "teal": "#6FAEB2"
   },
   "colors": {
     "accent": "coral",
@@ -36,7 +37,7 @@
     "userMessageText": "text",
     "customMessageBg": "surface",
     "customMessageText": "text",
-    "customMessageLabel": "coralBright",
+    "customMessageLabel": "teal",
     "toolPendingBg": "surface",
     "toolSuccessBg": "surface",
     "toolErrorBg": "surface",