killeros 2.1.26 → 2.1.28

package/killeros/passive-git-status.ts

@@ -0,0 +1,206 @@
+import { accessSync, constants, existsSync, realpathSync, statSync } from "node:fs";
+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;
+
+function searchPathEntries(env: NodeJS.ProcessEnv): string[] {
+  const values: string[] = [];
+  for (const [key, value] of Object.entries(env)) {
+    if (key.toLowerCase() === "path" && typeof value === "string") values.push(value);
+  }
+  const entries: string[] = [];
+  for (const value of values) entries.push(...value.split(path.delimiter));
+  return entries;
+}
+
+function pathExtensionEntries(env: NodeJS.ProcessEnv): string[] {
+  let raw: string | undefined;
+  for (const [key, value] of Object.entries(env)) {
+    if (key.toLowerCase() === "pathext" && typeof value === "string") {
+      raw = value;
+      break;
+    }
+  }
+  raw ??= ".COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH;.MSC;.CPL";
+  return raw.split(";").map((entry) => entry.trim()).filter(Boolean).map((entry) => entry.startsWith(".") ? entry : `.${entry}`);
+}
+
+function unquoted(entry: string): string {
+  if (entry.length >= 2) {
+    const first = entry[0];
+    const last = entry[entry.length - 1];
+    if ((first === '"' && last === '"') || (first === "'" && last === "'")) return entry.slice(1, -1);
+  }
+  return entry;
+}
+
+function inspectedRoot(cwd: string): string | undefined {
+  if (!cwd || typeof cwd !== "string") return undefined;
+  let start: string;
+  try {
+    start = path.resolve(cwd);
+  } catch {
+    return undefined;
+  }
+  let base: string;
+  try {
+    base = realpathSync(start);
+  } catch {
+    base = start;
+  }
+  let current = base;
+  for (;;) {
+    try {
+      if (existsSync(path.join(current, ".git"))) {
+        try {
+          return realpathSync(current);
+        } catch {
+          return current;
+        }
+      }
+    } catch {
+      // Unreadable directory: keep walking toward the filesystem root.
+    }
+    const parent = path.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return base;
+}
+
+function insideInspected(candidate: string, root: string): boolean {
+  if (process.platform === "win32") {
+    const normalizedCandidate = path.win32.normalize(candidate).toLowerCase();
+    const normalizedRoot = path.win32.normalize(root).toLowerCase();
+    const trimmed = normalizedRoot.length > 3 && normalizedRoot.endsWith(path.win32.sep)
+      ? normalizedRoot.slice(0, -1)
+      : normalizedRoot;
+    if (normalizedCandidate === trimmed) return true;
+    return normalizedCandidate.startsWith(`${trimmed}${path.win32.sep}`);
+  }
+  const normalizedCandidate = path.normalize(candidate);
+  const normalizedRoot = path.normalize(root);
+  const trimmed = normalizedRoot.length > 1 && normalizedRoot.endsWith(path.sep)
+    ? normalizedRoot.slice(0, -1)
+    : normalizedRoot;
+  if (normalizedCandidate === trimmed) return true;
+  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.
+export function passiveGitCommand(cwd: string, env: NodeJS.ProcessEnv = process.env): string | undefined {
+  const root = inspectedRoot(cwd);
+  if (!root) return undefined;
+  const entries = searchPathEntries(env);
+  if (entries.length === 0) return undefined;
+  const windows = process.platform === "win32";
+  const baseNames = windows ? ["git", ...pathExtensionEntries(env).map((extension) => `git${extension}`)] : ["git"];
+  for (const raw of entries) {
+    if (raw === "" || raw.trim() === "") continue;
+    const directory = unquoted(raw);
+    if (directory === "" || directory.trim() === "") continue;
+    if (!path.isAbsolute(directory)) continue;
+    for (const base of baseNames) {
+      const candidate = path.join(directory, base);
+      try {
+        if (!statSync(candidate).isFile()) continue;
+      } catch {
+        continue;
+      }
+      if (!windows) {
+        try {
+          accessSync(candidate, constants.X_OK);
+        } catch {
+          continue;
+        }
+      }
+      let resolved: string;
+      try {
+        resolved = realpathSync(candidate);
+      } catch {
+        continue;
+      }
+      if (!path.isAbsolute(resolved)) continue;
+      if (insideInspected(resolved, root)) continue;
+      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.
+export function passiveGitEnv(base: NodeJS.ProcessEnv = process.env): NodeJS.ProcessEnv {
+  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") {
+      env[key] = "";
+      hasPath = true;
+    }
+  }
+  if (!hasPath) env.PATH = "";
+  return env;
+}

package/killeros/personal-instructions.ts

@@ -3,7 +3,6 @@ import os from "node:os";
 import path from "node:path";
 import { StringDecoder } from "node:string_decoder";
 import { getAgentDir, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import type { InitRuntime } from "./runtime.ts";
 
 const PERSONAL_INSTRUCTIONS_FILE = "AGENTS.local.md";
 const PERSONAL_INSTRUCTIONS_LIMIT = 32 * 1024;
@@ -107,9 +106,9 @@ export function resolvePersonalInstructions(cwd: string): string | undefined {
   return `<personal_instructions>\n${content}\n</personal_instructions>`;
 }
 
-export function registerPersonalInstructions(pi: ExtensionAPI, initState: InitRuntime): void {
+export function registerPersonalInstructions(pi: ExtensionAPI): void {
   pi.on("before_agent_start", (event, ctx) => {
-    if (initState.active || !ctx.isProjectTrusted()) return;
+    if (!ctx.isProjectTrusted()) return;
     const personal = resolvePersonalInstructions(ctx.cwd);
     if (!personal) return;
     return {

package/killeros/runtime.ts

@@ -1,26 +1,42 @@
-import type { InitEvidenceIndex } from "./init-evidence.ts";
-import type { InitTargetBaseline } from "./init-target.ts";
+export type GoalStatus = "active" | "paused" | "blocked" | "complete";
 
-export type InitOutcome =
-  | { kind: "pending" }
-  | { kind: "written"; recoveryPath?: string }
-  | { kind: "policy-conflict"; reason: string }
-  | { kind: "cancelled" }
-  | { kind: "no-outcome" };
+export type GoalTurnPhase = "ready" | "in-flight" | "authorized";
 
-export interface InitRuntime {
-  active: boolean;
-  starting?: symbol;
-  targetPath?: string;
-  projectRoot?: string;
-  activeTools?: string[];
-  evidence?: InitEvidenceIndex;
-  baseline?: InitTargetBaseline;
-  outcome: InitOutcome;
-  settle?: (outcome: InitOutcome) => void;
+export interface GoalContinueReport {
+  turn: number;
+  evidence: string;
+  nextAction: string;
 }
 
-export type GoalStatus = "active" | "paused" | "blocked" | "complete";
+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;
@@ -51,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 & (
@@ -91,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 {
@@ -99,36 +127,24 @@ export interface GoalRuntime {
   continuationHeld: boolean;
   goalTurnInFlight: boolean;
   agentEndObserved: boolean;
+  goalTurn?: GoalTurnExecution;
   automaticCompaction?: AutomaticGoalCompaction;
   persistenceRetryNeeded: boolean;
   lastStopReason?: string;
   lastError?: string;
+  lifecycleGeneration: number;
   requestRender?: () => void;
 }
 
-export function createInitRuntime(): InitRuntime {
-  return { active: false, outcome: { kind: "pending" } };
-}
-
 export function createGoalRuntime(): GoalRuntime {
   return {
     continuationScheduled: false,
     continuationHeld: false,
     goalTurnInFlight: false,
     agentEndObserved: false,
+    goalTurn: undefined,
     automaticCompaction: undefined,
     persistenceRetryNeeded: false,
+    lifecycleGeneration: 0,
   };
 }
-
-export function resetInitRuntime(state: InitRuntime): void {
-  state.active = false;
-  state.starting = undefined;
-  state.targetPath = undefined;
-  state.projectRoot = undefined;
-  state.activeTools = undefined;
-  state.evidence = undefined;
-  state.baseline = undefined;
-  state.outcome = { kind: "pending" };
-  state.settle = undefined;
-}

package/killeros/shell-ui.ts

@@ -24,6 +24,7 @@ import {
   type SlashCommandResolver,
 } from "./commands.ts";
 import { reportError } from "./errors.ts";
+import { passiveGitCommand, passiveGitEnv } from "./passive-git-status.ts";
 
 function readPackageVersion(path: string | URL): string | undefined {
   try {
@@ -47,7 +48,6 @@ const STARTUP_TIPS = [
   "Type / to browse every command available in this session.",
   "Run /notification to enable a terminal bell when work settles.",
   "Run /goal <objective> to keep long-running work moving across turns.",
-  "Run /init to generate root AGENTS.md from bounded repository evidence.",
   "Run /handoff [focus] to continue work in a fresh linked session.",
   "Run /codex-fast to toggle priority requests for Codex models.",
   "Run /clear to start a fresh session after confirmation.",
@@ -67,13 +67,22 @@ const EDITOR_SUGGESTIONS = [
   'Try "draft an implementation plan for <feature>"',
 ] as const;
 
-export function resolveGitBranch(cwd: string): Promise<string | undefined> {
+export function resolveGitBranch(cwd: string, trusted = true): Promise<string | undefined> {
+  if (!trusted) return Promise.resolve(undefined);
+  let gitCommand: string | undefined;
+  try {
+    gitCommand = passiveGitCommand(cwd);
+  } catch {
+    return Promise.resolve(undefined);
+  }
+  if (!gitCommand) return Promise.resolve(undefined);
   return new Promise((resolve) => {
     execFile(
-      "git",
+      gitCommand,
       ["-C", cwd, "rev-parse", "--abbrev-ref", "HEAD"],
       {
         encoding: "utf8",
+        env: passiveGitEnv(),
         maxBuffer: 64 * 1024,
         timeout: 500,
         windowsHide: true,
@@ -132,7 +141,7 @@ class PiStartupHeader {
     this.ctx = ctx;
     this.tip = tip;
     this.tui = tui;
-    void resolveGitBranch(ctx.cwd).then((branch) => {
+    void resolveGitBranch(ctx.cwd, ctx.isProjectTrusted()).then((branch) => {
       if (this.disposed) return;
       this.branch = branch;
       this.tui.requestRender();

package/killeros/worked-for.ts

@@ -142,7 +142,8 @@ function parseV4(data: Record<string, unknown>): WorkedForEntryDataV4 | undefine
   const checks: CheckAttempt[] = [];
   for (const check of data.checks) {
     if (!record(check) || check.outcome !== "passed" && check.outcome !== "failed") return undefined;
-    const label = CHECK_LABELS.find((candidate) => candidate === check.label);
+    const label = CHECK_LABELS.find((candidate) => candidate === check.label)
+      ?? (check.label === "node --test (focused)" ? "node --test (focused)" : undefined);
     if (!label) return undefined;
     checks.push({ label, outcome: check.outcome });
   }
@@ -321,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` : "";
@@ -337,7 +338,7 @@ export function registerWorkedFor(
   });
 
   pi.on("agent_start", async (_event, ctx) => {
-    if (ctx.mode !== "tui" || active) return;
+    if (ctx.mode !== "tui" || active || !ctx.isProjectTrusted()) return;
     const state: ActiveReceipt = {
       startedAt: now(),
       startedTokens: sessionTokenTotal(ctx),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "killeros",
-  "version": "2.1.26",
+  "version": "2.1.28",
   "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",