kc-beta 0.5.5 → 0.6.0

package/src/agent/tools/sandbox-exec.js

@@ -1,8 +1,26 @@
 import { spawn } from "node:child_process";
 import { BaseTool, ToolResult } from "./base.js";
+import { SHARED_COORDINATION_PATHS } from "../workspace.js";
 
 const MAX_OUTPUT = 10_000;
 
+// H6: detect sandbox_exec commands that touch shared coordination files.
+// Doesn't block — just prepends a warning to the tool result. In session
+// 6304673afaa0 we observed 8+ subagents doing `cat catalog.json | python`
+// and `json.dump()` to overwrite catalog.json directly, racing each other
+// because sandbox_exec bypasses the workspace-file lock (B9). The warning
+// nudges the LLM toward workspace_file / rule_catalog which ARE lock-safe.
+function detectSharedFileWrites(command) {
+  if (!command) return [];
+  const hits = new Set();
+  for (const shared of SHARED_COORDINATION_PATHS) {
+    // Match both bare and quoted forms (e.g. rules/catalog.json or "rules/catalog.json")
+    const re = new RegExp(shared.replace(/\//g, "\\/").replace(/\./g, "\\."));
+    if (re.test(command)) hits.add(shared);
+  }
+  return Array.from(hits);
+}
+
 /**
  * Execute shell commands in the workspace directory.
  * Uses child_process.spawn so pipes, redirects, && all work.
@@ -59,6 +77,11 @@ export class SandboxExecTool extends BaseTool {
       ? this._workspace.projectDir
       : this._workspace.cwd;
 
+    // H6: warn before the command runs when it touches shared files. The
+    // warning becomes part of the tool result so the LLM sees it on every
+    // subsequent call and self-corrects toward workspace_file / rule_catalog.
+    const sharedHits = detectSharedFileWrites(command);
+
     try {
       const { output, code } = await this._run(command, effectiveCwd);
       let result = output;
@@ -68,6 +91,13 @@ export class SandboxExecTool extends BaseTool {
       if (code !== 0) {
         result += `\n[exit code: ${code}]`;
       }
+      if (sharedHits.length > 0) {
+        const prefix =
+          `⚠️  This command touches shared coordination file(s): ${sharedHits.join(", ")}.\n` +
+          `   sandbox_exec writes bypass workspace file locking (B9).\n` +
+          `   Under concurrent subagents this races — use workspace_file or rule_catalog instead.\n\n`;
+        result = prefix + result;
+      }
       return new ToolResult(result, code !== 0);
     } catch (err) {
       if (err.message === "timeout") {

package/src/agent/workspace.js

@@ -8,6 +8,32 @@ import { generateTraceId } from "./version-manager.js";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const GITIGNORE_TEMPLATE = path.resolve(__dirname, "../../template/workspace.gitignore");
 
+// B9: Shared coordination files. Any writer touching these paths MUST go
+// through Workspace.withFileLock() so concurrent writers (main agent +
+// subagents + sandbox_exec) serialize. Observed in session 6304673afaa0:
+// 8+ engines rewriting catalog.json in a 60-second window with no
+// coordination, thrashing rule counts 464 → 364 → 736 → 307.
+//
+// Matching is done via path-suffix — a writer passing "rules/catalog.json"
+// or an absolute path ending in rules/catalog.json both match. Subpaths
+// like "rules/manifest.json" also match with their own distinct lock.
+export const SHARED_COORDINATION_PATHS = [
+  "rules/catalog.json",
+  "rules/manifest.json",
+  "refs/manifest.json",
+  "session-state.json",
+  "tasks.json",
+];
+
+export function isSharedCoordinationPath(relOrAbsPath) {
+  if (!relOrAbsPath) return false;
+  const norm = relOrAbsPath.replace(/\\/g, "/");
+  for (const p of SHARED_COORDINATION_PATHS) {
+    if (norm === p || norm.endsWith("/" + p)) return true;
+  }
+  return false;
+}
+
 /**
  * Per-session workspace directory with path traversal protection.
  * Each agent session gets its own directory under the workspace root.
@@ -92,6 +118,82 @@ export class Workspace {
     return resolved;
   }
 
+  /**
+   * B9: Execute `fn` while holding an exclusive lock on `relPath`. Use for
+   * any shared coordination file that multiple engines (main + subagents +
+   * sandbox_exec) could write. The lock is implemented as a sibling
+   * `<resolved>.lock` file created atomically via `O_CREAT | O_EXCL`,
+   * which is POSIX-guaranteed-atomic on any local filesystem. Stale
+   * lockfiles (mtime older than `staleMs`) are force-removed so a crashed
+   * holder doesn't block the whole workspace forever.
+   *
+   * Subagents and the parent share the same workspace directory, so their
+   * lockfiles collide correctly — no special IPC needed. Works across
+   * engine instances in the same Node process (async contention) and
+   * across Node processes (sibling CLI invocations).
+   *
+   * @template T
+   * @param {string} relPath - workspace-relative path being protected
+   * @param {() => Promise<T>|T} fn - critical section
+   * @param {{timeoutMs?: number, retryMs?: number, staleMs?: number}} [opts]
+   * @returns {Promise<T>}
+   */
+  async withFileLock(relPath, fn, { timeoutMs = 10_000, retryMs = 50, staleMs = 60_000 } = {}) {
+    const target = this.resolvePath(relPath);
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    const lockPath = target + ".lock";
+    const start = Date.now();
+
+    while (true) {
+      let fd;
+      try {
+        fd = fs.openSync(lockPath, fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL, 0o600);
+      } catch (e) {
+        if (e.code !== "EEXIST") throw e;
+        // Lockfile exists. Check if stale — a crashed holder left it behind.
+        try {
+          const st = fs.statSync(lockPath);
+          if (Date.now() - st.mtimeMs > staleMs) {
+            try { fs.unlinkSync(lockPath); } catch { /* raced against another stealer */ }
+            continue;
+          }
+        } catch {
+          // Lockfile vanished between EEXIST and stat — retry to acquire.
+          continue;
+        }
+        if (Date.now() - start > timeoutMs) {
+          throw new Error(`Timeout acquiring lock on ${relPath} after ${timeoutMs}ms (held by another engine)`);
+        }
+        await new Promise((r) => setTimeout(r, retryMs));
+        continue;
+      }
+
+      // Acquired. Record holder metadata inside the lockfile — useful for
+      // debugging: `cat rules/catalog.json.lock` shows pid + acquired-at.
+      try {
+        fs.writeSync(fd, Buffer.from(`${process.pid}|${Date.now()}|${this.sessionId}\n`));
+      } catch { /* best-effort */ }
+      try { fs.closeSync(fd); } catch { /* already closed */ }
+
+      try {
+        return await fn();
+      } finally {
+        try { fs.unlinkSync(lockPath); } catch { /* already gone, stale-reaped, or permission issue */ }
+      }
+    }
+  }
+
+  /**
+   * Convenience: run `fn` under a shared-coordination lock when the path
+   * is a known shared file. Otherwise runs `fn` directly without lock.
+   * Lets callsites uniformly wrap their writes without knowing which
+   * paths are shared.
+   */
+  async withSharedLockIfApplicable(relPath, fn) {
+    if (isSharedCoordinationPath(relPath)) return this.withFileLock(relPath, fn);
+    return fn();
+  }
+
   /**
    * Auto-commit a workspace write. Silently no-ops if the path is gitignored,
    * if there's nothing to commit, or if git isn't available. Returns the trace
@@ -108,22 +210,74 @@ export class Workspace {
 
     if (!this._gitAvailable) return traceId;
 
+    // B5: Serialize concurrent git operations. Two sub-agents committing
+    // at the same time used to race on .git/index.lock — one would fail
+    // silently ("fatal: Unable to create '.git/index.lock': File exists"),
+    // its auto-commit lost but its workspace write still on disk so
+    // downstream readers see the change without commit history.
+    //
+    // withGitSyncLock is a synchronous best-effort wrapper around
+    // withFileLock — using flock-on-sibling-.lock-file semantics but
+    // implemented inline since autoCommit is sync. A dedicated gitlock
+    // file (not a real git lockfile) coordinates across engines.
+    this._withGitSyncLock(() => {
+      try {
+        const r = spawnSync("git", ["add", "--", relPath], {
+          cwd: this.path,
+          stdio: "ignore",
+        });
+        if (r.status !== 0) return; // gitignored or other add error — skip commit
+        const msg = `[${this._currentPhase}] ${opLabel} ${relPath} [trace:${traceId}]`;
+        spawnSync("git", ["commit", "-m", msg, "--allow-empty-message"], {
+          cwd: this.path,
+          stdio: "ignore",
+        });
+        // Status doesn't matter — "nothing to commit" is fine.
+      } catch {
+        // Never let a git failure break a workspace write.
+      }
+    });
+    return traceId;
+  }
+
+  /**
+   * B5: Synchronous gitops lock. Mirror of withFileLock but sync to fit
+   * autoCommit's existing call signature. Times out and proceeds anyway
+   * after 5s — we'd rather lose one commit than deadlock a write.
+   */
+  _withGitSyncLock(fn, { timeoutMs = 5_000, staleMs = 30_000 } = {}) {
+    const lockPath = path.join(this.path, ".git", "kc-commit.lock");
+    const start = Date.now();
+    let acquired = false;
+    while (Date.now() - start < timeoutMs) {
+      try {
+        const fd = fs.openSync(lockPath, fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL, 0o600);
+        try { fs.writeSync(fd, Buffer.from(`${process.pid}|${Date.now()}\n`)); } catch { /* best effort */ }
+        try { fs.closeSync(fd); } catch { /* ignore */ }
+        acquired = true;
+        break;
+      } catch (e) {
+        if (e.code !== "EEXIST" && e.code !== "ENOENT") break; // ENOENT: .git dir missing — proceed unlocked
+        // Check for stale
+        try {
+          const st = fs.statSync(lockPath);
+          if (Date.now() - st.mtimeMs > staleMs) {
+            try { fs.unlinkSync(lockPath); } catch { /* race with another stealer */ }
+            continue;
+          }
+        } catch {
+          continue; // vanished, retry
+        }
+        // Busy-wait briefly
+        const deadline = Date.now() + 20;
+        while (Date.now() < deadline) { /* spin */ }
+      }
+    }
     try {
-      const r = spawnSync("git", ["add", "--", relPath], {
-        cwd: this.path,
-        stdio: "ignore",
-      });
-      if (r.status !== 0) return traceId; // gitignored or other add error — skip commit
-      const msg = `[${this._currentPhase}] ${opLabel} ${relPath} [trace:${traceId}]`;
-      spawnSync("git", ["commit", "-m", msg, "--allow-empty-message"], {
-        cwd: this.path,
-        stdio: "ignore",
-      });
-      // Status doesn't matter — "nothing to commit" is fine.
-    } catch {
-      // Never let a git failure break a workspace write.
+      fn();
+    } finally {
+      if (acquired) { try { fs.unlinkSync(lockPath); } catch { /* already gone */ } }
     }
-    return traceId;
   }
 
   /**

package/src/cli/components.js

@@ -1,8 +1,21 @@
 import React, { useState, useEffect, useRef, useCallback } from "react";
 import { Box, Text, useInput, useApp, useStdout } from "ink";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, resolve } from "node:path";
 
 const h = React.createElement;
 
+// A4: Resolve once at module load (package.json doesn't change mid-session).
+// Lazy-safe via try/catch so dev-mode from odd cwd never breaks the TUI.
+const KC_VERSION = (() => {
+  try {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const pkg = JSON.parse(readFileSync(resolve(here, "..", "..", "package.json"), "utf-8"));
+    return pkg.version;
+  } catch { return null; }
+})();
+
 // --- Cooking spinner ---
 
 const COOKING_WORDS = [
@@ -32,15 +45,36 @@ export function CookingSpinner({ status }) {
 
 const LENAT_QUOTE = "Intelligence is ten million rules.";
 
+// F7: rolling 30-sample window for CTX smoothing + peak tracking. 30
+// samples × observed update cadence (~1/sec during active turns) ≈ a
+// 30-second smoothed view, which absorbs the small spikes from
+// transient tool-result embeddings that made the old "instantaneous"
+// display jumpy. Peak stays at the highest seen this session.
+const CTX_SAMPLE_WINDOW = 30;
+
 export function StatusBar({ sessionId, phase, contextTokens, contextLimit }) {
-  const pct = contextLimit ? Math.round((contextTokens / contextLimit) * 100) : 0;
+  const samplesRef = useRef([]);
+  const peakRef = useRef(0);
+
+  // Push current sample + cap the ring
+  const samples = samplesRef.current;
+  samples.push(contextTokens || 0);
+  if (samples.length > CTX_SAMPLE_WINDOW) samples.shift();
+  const smoothed = samples.length > 0
+    ? Math.round(samples.reduce((a, b) => a + b, 0) / samples.length)
+    : 0;
+  if ((contextTokens || 0) > peakRef.current) peakRef.current = contextTokens || 0;
+  const peak = peakRef.current;
+
+  const pct = contextLimit ? Math.round((smoothed / contextLimit) * 100) : 0;
   const ctxColor = pct > 80 ? "red" : pct > 60 ? "yellow" : "green";
-  const ctxLabel = contextTokens >= 1000
-    ? `${(contextTokens / 1000).toFixed(1)}k`
-    : `${contextTokens || 0}`;
-  const limitLabel = contextLimit >= 1000
-    ? `${(contextLimit / 1000).toFixed(0)}k`
-    : `${contextLimit || 0}`;
+  const fmt = (n) => n >= 1000 ? `${(n / 1000).toFixed(1)}k` : `${n || 0}`;
+  const ctxLabel = fmt(smoothed);
+  const limitLabel = fmt(contextLimit || 0);
+  // F7: peak shown when meaningfully higher than smoothed (by at least
+  // 5% of the limit) so users see "we hit high water, currently back
+  // down." Otherwise skip to keep the bar compact.
+  const showPeak = contextLimit > 0 && (peak - smoothed) / contextLimit > 0.05;
 
   // Soft-threshold hint — shows up before auto-windowing kicks in at ~70%
   // so users know they can run /compact to reduce context more aggressively
@@ -55,6 +89,7 @@ export function StatusBar({ sessionId, phase, contextTokens, contextLimit }) {
     phase ? h(Text, { color: "cyan" }, ` ${phase.toUpperCase()}`) : null,
     h(Text, { color: "green" }, "  ●  "),
     h(Text, { color: ctxColor }, `CTX: ${ctxLabel}/${limitLabel} (${pct}%)`),
+    showPeak ? h(Text, { dimColor: true }, ` · peak ${fmt(peak)}`) : null,
     compactHint ? h(Text, { color: ctxColor }, compactHint) : null,
     h(Text, { dimColor: true }, `  · ${LENAT_QUOTE}`),
   );
@@ -100,7 +135,7 @@ export function WelcomeBanner({ projectDir, pendingInputCount = 0 } = {}) {
   return h(Box, { flexDirection: "column", marginBottom: 1, borderStyle: "round", borderColor: "gray", paddingLeft: 1, paddingRight: 1 },
     h(Box, null,
       h(Text, { bold: true }, "KC AGENT CLI"),
-      h(Text, { dimColor: true }, "  (beta)"),
+      h(Text, { dimColor: true }, KC_VERSION ? `  v${KC_VERSION}  (beta)` : "  (beta)"),
     ),
     h(Text, { dimColor: true }, "Hope you never know what KC was."),
     h(Text, null, ""),
@@ -114,6 +149,17 @@ export function WelcomeBanner({ projectDir, pendingInputCount = 0 } = {}) {
       ? h(Text, { color: "cyan" }, `📥 ${pendingInputCount} new file(s) pending in input/ — run /schedule for details`)
       : null,
     h(Text, null, ""),
+    // H7: priority-phrasing nudge. If the developer has multiple inputs
+    // with mixed roles (authoritative vs supporting), KC treats them
+    // equally unless told otherwise — which led to the reg 02 starvation
+    // + reg 03-10 bloat in session 6304673afaa0. Prompt explicit up-front.
+    h(Text, { dimColor: true, color: "cyan" },
+      "💡 Tip: If your inputs include BOTH authoritative and supporting"),
+    h(Text, { dimColor: true, color: "cyan" },
+      "   sources, say so at session start — e.g. \"prioritize rules/01 and"),
+    h(Text, { dimColor: true, color: "cyan" },
+      "   rules/02 as core; rules/03-10 are supporting context only.\""),
+    h(Text, null, ""),
     h(Text, { dimColor: true }, "Product of Memium / kitchen-engineer42"),
   );
 }
@@ -134,7 +180,14 @@ export function WelcomeBanner({ projectDir, pendingInputCount = 0 } = {}) {
  */
 const RECENT_PREVIEW_LINES = 4;
 
-export function ToolBlock({ name, input, output, isError, isRunning, isRecent = true }) {
+// B0.5: React.memo — ToolBlock renders the heaviest subtree in the TUI
+// (multi-line Box + colored Text + per-line Box wrappers). Without memo,
+// every `setMessages` / `setStreamingText` causes React to re-render ALL
+// 50 visible ToolBlocks even though none of their props changed. Ink
+// then diffs the result against the prior render. Memo lets us skip
+// that work for untouched rows. The props are small primitives + short
+// strings — shallow equality is the right comparator.
+function ToolBlockImpl({ name, input, output, isError, isRunning, isRecent = true }) {
   const borderColor = isRunning ? "yellow" : isError ? "red" : "green";
   const outStr = typeof output === "string" ? output : "";
   const lines = outStr ? outStr.split("\n") : [];
@@ -191,6 +244,8 @@ export function ToolBlock({ name, input, output, isError, isRunning, isRecent =
   );
 }
 
+export const ToolBlock = React.memo(ToolBlockImpl);
+
 // --- Message display ---
 
 export function MessageBlock({ role, content, toolName, toolInput, toolOutput, toolIsError }) {
@@ -242,29 +297,122 @@ export function MessagesList({ messages }) {
 
 // --- Input prompt ---
 
-export function InputPrompt({ value, onChange, onSubmit, isActive }) {
+/**
+ * F3: cursor-aware input with arrow-key support.
+ *
+ * - Left/Right: move cursor within the current line. Cursor position is
+ *   internal state (not hoisted) so the parent's onChange contract
+ *   stays stable.
+ * - Up/Down: when the input is empty (OR cursor is at start/end), walk
+ *   through a session-local history buffer of the user's past
+ *   submissions. Non-destructive: editing a recalled line doesn't mutate
+ *   the history entry.
+ * - Home/End (or Ctrl-A/Ctrl-E): jump cursor to start/end.
+ * - Backspace/Delete: deletes at cursor position (not always end-of-line).
+ *
+ * History is in-memory only (`historyRef`) — not persisted across sessions,
+ * per v0.6.0 plan item F3 "keep simple." Cleared on `/clear`.
+ */
+export function InputPrompt({ value, onChange, onSubmit, isActive, placeholderRight = null }) {
+  const [cursor, setCursor] = useState(value.length);
+  const historyRef = useRef([]); // session-local submission history
+  const historyIdxRef = useRef(null); // index while browsing history; null = live editing
+
+  // Keep cursor in range when value changes externally (e.g. recall).
+  useEffect(() => {
+    if (cursor > value.length) setCursor(value.length);
+  }, [value, cursor]);
+
   useInput((input, key) => {
     if (!isActive) return;
 
+    // Submit
     if (key.return) {
-      onSubmit(value);
+      const v = value;
+      if (v.trim()) historyRef.current.push(v);
+      historyIdxRef.current = null;
+      setCursor(0);
+      onSubmit(v);
       return;
     }
+
+    // Backspace at cursor
     if (key.backspace || key.delete) {
-      onChange(value.slice(0, -1));
+      if (cursor === 0) return;
+      const next = value.slice(0, cursor - 1) + value.slice(cursor);
+      onChange(next);
+      setCursor(cursor - 1);
+      historyIdxRef.current = null;
       return;
     }
-    // Skip control characters
+
+    // Arrow keys
+    if (key.leftArrow) {
+      if (cursor > 0) setCursor(cursor - 1);
+      return;
+    }
+    if (key.rightArrow) {
+      if (cursor < value.length) setCursor(cursor + 1);
+      return;
+    }
+    if (key.upArrow) {
+      const hist = historyRef.current;
+      if (hist.length === 0) return;
+      const idx = historyIdxRef.current == null ? hist.length : historyIdxRef.current;
+      const nextIdx = Math.max(0, idx - 1);
+      historyIdxRef.current = nextIdx;
+      const recalled = hist[nextIdx] || "";
+      onChange(recalled);
+      setCursor(recalled.length);
+      return;
+    }
+    if (key.downArrow) {
+      const hist = historyRef.current;
+      if (historyIdxRef.current == null) return;
+      const nextIdx = historyIdxRef.current + 1;
+      if (nextIdx >= hist.length) {
+        historyIdxRef.current = null;
+        onChange("");
+        setCursor(0);
+        return;
+      }
+      historyIdxRef.current = nextIdx;
+      const recalled = hist[nextIdx] || "";
+      onChange(recalled);
+      setCursor(recalled.length);
+      return;
+    }
+
+    // Home/End — Ctrl-A / Ctrl-E (terminal convention)
+    if (key.ctrl && input === "a") { setCursor(0); return; }
+    if (key.ctrl && input === "e") { setCursor(value.length); return; }
+
+    // Skip other control combos
     if (key.ctrl || key.meta || key.escape) return;
-    // Append printable characters
+
+    // Printable characters insert at cursor
     if (input) {
-      onChange(value + input);
+      const next = value.slice(0, cursor) + input + value.slice(cursor);
+      onChange(next);
+      setCursor(cursor + input.length);
+      historyIdxRef.current = null;
     }
   }, { isActive });
 
+  // Render: split the value at the cursor so the block-cursor appears
+  // inline, not just at the end.
+  const before = value.slice(0, cursor);
+  const after = value.slice(cursor);
+
   return h(Box, null,
     h(Text, { dimColor: true }, "❯ "),
-    h(Text, null, value),
-    isActive ? h(Text, { color: "gray" }, "█") : null,
+    h(Text, null, before),
+    isActive
+      ? h(Text, { color: "gray", inverse: true }, after.length > 0 ? after[0] : " ")
+      : null,
+    h(Text, null, after.length > 0 ? after.slice(1) : ""),
+    placeholderRight
+      ? h(Box, { marginLeft: 2 }, h(Text, { dimColor: true, color: "cyan" }, placeholderRight))
+      : null,
   );
 }