killeros 2.0.22 → 2.1.23

package/killeros/commands.ts

@@ -70,7 +70,7 @@ const BUILTIN_COMMANDS: ReadonlyArray<{ name: string; description: string }> = [
 ];
 
 const COMMAND_SYNTAX_HINTS: Readonly<Record<string, string>> = {
-  goal: "/goal [objective|clear|edit|pause|resume]",
+  goal: "/goal [objective|pause|resume|clear]",
   handoff: "/handoff [next-session focus]",
   variants: "/variants [level]",
   model: "/model [provider/model]",

package/killeros/display.ts

@@ -40,12 +40,14 @@ export function formatTime(milliseconds: number): string {
 
 export function formatTokens(value: number): string {
   if (!Number.isFinite(value)) return "0";
-  const amount = Math.max(0, value);
-  if (amount < 1_000) return `${Math.round(amount)}`;
-  if (amount >= 1_000_000) {
-    const precision = amount >= 10_000_000 ? 0 : 1;
-    return `${Number((amount / 1_000_000).toFixed(precision))}M`;
+  const rounded = Math.round(Math.max(0, value));
+  if (rounded < 1_000) return `${rounded}`;
+  if (rounded >= 1_000_000) {
+    const precision = rounded >= 10_000_000 ? 0 : 1;
+    return `${Number((rounded / 1_000_000).toFixed(precision))}M`;
   }
-  const precision = amount >= 100_000 ? 0 : 1;
-  return `${Number((amount / 1_000).toFixed(precision))}k`;
+  const precision = rounded >= 100_000 ? 0 : 1;
+  const inK = Number((rounded / 1_000).toFixed(precision));
+  if (inK >= 1_000) return `${Number((rounded / 1_000_000).toFixed(1))}M`;
+  return `${inK}k`;
 }

package/killeros/footer.ts

@@ -1,4 +1,5 @@
 import { execFile } from "node:child_process";
+import { watch } from "node:fs";
 import { type ExtensionAPI, type ExtensionContext, type Theme, type ThemeColor } from "@earendil-works/pi-coding-agent";
 import { truncateToWidth, visibleWidth, type TUI } from "@earendil-works/pi-tui";
 import { isCodexFastEnabled, subscribeCodexFast } from "./codex-fast-state.ts";
@@ -9,24 +10,45 @@ import { safeTerminalText } from "./safe-terminal-text.ts";
 import { LEVEL_COLORS, type ThinkingLevel } from "./variants.ts";
 
 const GIT_STATUS_REFRESH_INTERVAL_MS = 30_000;
+const GIT_STATUS_TIMEOUT_MS = 5_000;
+const GIT_STATUS_WATCH_DEBOUNCE_MS = 250;
+const GIT_STATUS_WATCH_INTERVAL_MS = 5_000;
 const CODEX_PROVIDER = "openai-codex";
 const colorDirectory = (text: string): string => `\x1B[38;2;240;248;154m${text}\x1B[39m`;
 
-interface GitFileChanges {
+export interface GitFileChanges {
   modified: number;
   added: number;
   deleted: number;
 }
 
-function resolveGitFileChanges(cwd: string): Promise<GitFileChanges | undefined> {
+type GitStatusExecutor = (
+  file: string,
+  args: string[],
+  options: {
+    encoding: "utf8";
+    env: NodeJS.ProcessEnv;
+    maxBuffer: number;
+    timeout: number;
+    windowsHide: true;
+  },
+  callback: (error: Error | null, stdout: string) => void,
+) => unknown;
+
+/** Resolves changed-file counts with a bounded asynchronous Git status process. */
+export function resolveGitFileChanges(
+  cwd: string,
+  execute: GitStatusExecutor = execFile,
+): Promise<GitFileChanges | undefined> {
   return new Promise((resolve) => {
-    execFile(
+    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: 1_000,
+        timeout: GIT_STATUS_TIMEOUT_MS,
         windowsHide: true,
       },
       (error, stdout) => {
@@ -72,9 +94,16 @@ function createGitRefresh<T>(
       return;
     }
     pending = true;
-    void resolveResult(cwd).then((result) => {
-      if (!disposed) onResult(result);
-    }).finally(() => {
+    let result: Promise<T | undefined>;
+    try {
+      result = resolveResult(cwd);
+    } catch {
+      result = Promise.resolve(undefined);
+    }
+    void result.then(
+      (value) => { if (!disposed) onResult(value); },
+      () => { if (!disposed) onResult(undefined); },
+    ).finally(() => {
       pending = false;
       if (!disposed && queued) {
         queued = false;
@@ -100,14 +129,20 @@ export function createGitStatusRefresh(
   return createGitRefresh(cwd, onCount, resolveCount);
 }
 
-function createGitFileChangesRefresh(
+/** Coalesces file-change scans and emits only successful results. */
+export function createGitFileChangesRefresh(
   cwd: string,
-  onChanges: (changes: GitFileChanges | undefined) => void,
+  onChanges: (changes: GitFileChanges) => void,
+  resolveChanges: (cwd: string) => Promise<GitFileChanges | undefined> = resolveGitFileChanges,
 ): { request: () => void; dispose: () => void } {
-  return createGitRefresh(cwd, onChanges, resolveGitFileChanges);
+  return createGitRefresh(cwd, (changes) => {
+    if (changes !== undefined) onChanges(changes);
+  }, resolveChanges);
 }
 
 type ScheduleFallback = (refresh: () => void, intervalMs: number) => () => void;
+type WatchDirectory = (cwd: string, onChange: () => void, onError: () => void) => () => void;
+type ScheduleDelay = (refresh: () => void, delayMs: number) => () => void;
 
 const scheduleFallback: ScheduleFallback = (refresh, intervalMs) => {
   const timer = setInterval(refresh, intervalMs);
@@ -115,6 +150,18 @@ const scheduleFallback: ScheduleFallback = (refresh, intervalMs) => {
   return () => clearInterval(timer);
 };
 
+const watchDirectory: WatchDirectory = (cwd, onChange, onError) => {
+  const watcher = watch(cwd, { recursive: true }, onChange);
+  watcher.on("error", onError);
+  return () => watcher.close();
+};
+
+const scheduleDelay: ScheduleDelay = (refresh, delayMs) => {
+  const timer = setTimeout(refresh, delayMs);
+  timer.unref?.();
+  return () => clearTimeout(timer);
+};
+
 /** Schedules the fallback Git scan independently from footer rendering. */
 export function scheduleGitStatusFallback(
   refresh: () => void,
@@ -123,6 +170,55 @@ export function scheduleGitStatusFallback(
   return schedule(refresh, GIT_STATUS_REFRESH_INTERVAL_MS);
 }
 
+/** Throttles filesystem changes and falls back silently when watching is unavailable. */
+export function scheduleGitStatusWatch(
+  cwd: string,
+  refresh: () => void,
+  startWatching: WatchDirectory = watchDirectory,
+  schedule: ScheduleDelay = scheduleDelay,
+): () => void {
+  let disposed = false;
+  let coolingDown = false;
+  let queued = false;
+  let stopTimer: (() => void) | undefined;
+  let stopWatching: (() => void) | undefined;
+  const stop = (): void => {
+    if (disposed) return;
+    disposed = true;
+    stopTimer?.();
+    stopTimer = undefined;
+    stopWatching?.();
+    stopWatching = undefined;
+  };
+  const changed = (): void => {
+    if (disposed) return;
+    if (stopTimer) {
+      if (coolingDown) queued = true;
+      return;
+    }
+    stopTimer = schedule(() => {
+      stopTimer = undefined;
+      if (disposed) return;
+      refresh();
+      coolingDown = true;
+      stopTimer = schedule(() => {
+        stopTimer = undefined;
+        coolingDown = false;
+        if (queued) {
+          queued = false;
+          changed();
+        }
+      }, GIT_STATUS_WATCH_INTERVAL_MS);
+    }, GIT_STATUS_WATCH_DEBOUNCE_MS);
+  };
+  try {
+    stopWatching = startWatching(cwd, changed, stop);
+  } catch {
+    disposed = true;
+  }
+  return stop;
+}
+
 export function formatCost(usd: number): string {
   if (!Number.isFinite(usd)) return "$—";
   return `$${usd.toFixed(2)}`;
@@ -258,7 +354,8 @@ function renderFooter(rows: string[], width: number, theme: Theme): string[] {
 function formatGoalFooter(state: GoalState | undefined, theme: Theme): string {
   if (!state) return "";
   if (state.status === "active") {
-    return theme.fg("warning", `/goal is active (${formatTime(goalElapsedMilliseconds(state, Date.now()))})`);
+    const turns = state.maxTurns === undefined ? "" : ` ${state.turns}/${state.maxTurns}`;
+    return theme.fg("warning", `/goal is active${turns} (${formatTime(goalElapsedMilliseconds(state, Date.now()))})`);
   }
   if (state.status === "paused") return theme.fg("warning", "/goal is paused");
   if (state.status === "blocked") return theme.fg("error", "/goal is blocked");
@@ -278,7 +375,6 @@ export function registerFooter(pi: ExtensionAPI, goalRuntime: GoalRuntime): void
   let cachedSessionCost = 0;
   let sessionCostDirty = true;
   let unsubscribeCodexFast: (() => void) | undefined;
-  let requestGitStatusRefresh: (() => void) | undefined;
   const resetSessionCost = (): void => {
     cachedSessionCost = 0;
     sessionCostDirty = true;
@@ -314,19 +410,19 @@ export function registerFooter(pi: ExtensionAPI, goalRuntime: GoalRuntime): void
         gitFileChanges = changes;
         tui.requestRender();
       });
-      requestGitStatusRefresh = gitStatus.request;
       const unsubscribe = footerData.onBranchChange(() => {
         gitStatus.request();
         tui.requestRender();
       });
       gitStatus.request();
+      const stopWatch = scheduleGitStatusWatch(ctx.cwd, gitStatus.request);
       const stopFallback = scheduleGitStatusFallback(gitStatus.request);
       return {
         dispose() {
           unsubscribe();
+          stopWatch();
           stopFallback();
           gitStatus.dispose();
-          if (requestGitStatusRefresh === gitStatus.request) requestGitStatusRefresh = undefined;
           if (activeTui === tui) activeTui = undefined;
         },
         invalidate() {},
@@ -393,12 +489,8 @@ export function registerFooter(pi: ExtensionAPI, goalRuntime: GoalRuntime): void
     thinkingLevel = event.level;
     activeTui?.requestRender();
   });
-  const refreshAfterActivity = (): void => {
-    invalidateSessionCost();
-    requestGitStatusRefresh?.();
-  };
-  pi.on("turn_end", refreshAfterActivity);
-  pi.on("session_compact", refreshAfterActivity);
+  pi.on("turn_end", invalidateSessionCost);
+  pi.on("session_compact", invalidateSessionCost);
   pi.on("session_tree", () => {
     resetSessionCost();
     activeTui?.requestRender();
@@ -408,7 +500,6 @@ export function registerFooter(pi: ExtensionAPI, goalRuntime: GoalRuntime): void
     unsubscribeCodexFast = undefined;
     resetSessionCost();
     activeTui = undefined;
-    requestGitStatusRefresh = undefined;
     goalRuntime.requestRender = undefined;
   });
 }

package/killeros/goal-command.ts

@@ -0,0 +1,23 @@
+import { validateGoalObjective } from "./goal-state.ts";
+
+export type GoalCommand =
+  | { kind: "status" }
+  | { kind: "objective"; objective: string }
+  | { kind: "pause" }
+  | { kind: "resume" }
+  | { kind: "clear" }
+  | { kind: "invalid"; message: string };
+
+/** Parses one raw /goal argument string into a closed command variant. */
+export function parseGoalCommand(args: string): GoalCommand {
+  const input = args.trim();
+  if (!input) return { kind: "status" };
+  const lowered = input.toLowerCase();
+  if (lowered === "pause") return { kind: "pause" };
+  if (lowered === "resume") return { kind: "resume" };
+  if (lowered === "clear") return { kind: "clear" };
+  const objective = validateGoalObjective(input);
+  return objective
+    ? { kind: "objective", objective }
+    : { kind: "invalid", message: "A goal objective may not exceed 4,000 characters" };
+}