@galda/cli 0.10.34 → 0.10.36

package/bin/manager-for-ai.mjs

@@ -118,8 +118,18 @@ await import(pathToFileURL(join(ROOT, 'engine', 'server.mjs')).href);
 // public build will default it to the deployed relay. See relay/DEPLOY.md.
 if (process.env.RELAY_URL) {
   const { spawn } = await import('node:child_process');
-  const relay = spawn(process.execPath, [join(ROOT, 'engine', 'relay-client.mjs')], { stdio: 'inherit', env: process.env });
-  const stop = () => { try { relay.kill(); } catch { /* already gone */ } };
+  const { superviseRelay } = await import(pathToFileURL(join(ROOT, 'engine', 'relay-supervisor.mjs')).href);
+  // Supervise the relay-client: if the CHILD exits (uncaught throw, single-
+  // instance lock refuse) we bring it back with backoff, otherwise the app goes
+  // silently offline ("Unsent"). A tight crash loop (a config/lock error) trips a
+  // circuit breaker so we stop hammering and say why. relay-client heals its own
+  // dropped socket; this heals the whole process dying. See engine/relay-supervisor.mjs.
+  const sup = superviseRelay({
+    spawn: () => spawn(process.execPath, [join(ROOT, 'engine', 'relay-client.mjs')], { stdio: 'inherit', env: process.env }),
+    log: ({ code, signal, delayMs }) => say(`relay-client exited (code ${code ?? 'n/a'}${signal ? `, ${signal}` : ''}) — restarting in ${Math.round(delayMs / 1000)}s`),
+    onGiveUp: () => say('relay-client keeps exiting immediately — giving up; run `npx @galda/cli --signin` or check RELAY_URL'),
+  });
+  const stop = () => sup.stop();
   process.on('exit', stop);
   for (const sig of ['SIGINT', 'SIGTERM']) process.on(sig, () => { stop(); process.exit(0); });
   say(`relay: connecting to ${process.env.RELAY_URL} — your fixed URL goes live once you sign in`);

package/engine/lib.mjs

@@ -906,6 +906,73 @@ export function hasTestRelevantChanges(changedFiles) {
   return files.some((f) => !DOC_ONLY_RE.test(f));
 }
 
+// Extract the set of FAILING test titles from a `node --test` (or TAP) run.
+// The gate needs NAMES, not just a count, so it can tell a NEW failure (this
+// change's fault) from one that was ALREADY red on the base (e.g. a known-red
+// like persist-failure that fails even on clean origin/main — CLAUDE.md).
+// node --test prints `✖ <title> (1234.5ms)` (both inline and again under the
+// `✖ failing tests:` summary header, which carries no title and is skipped);
+// TAP prints `not ok N - <title>` (a `# SKIP`/`# TODO` directive is not a
+// failure). Titles are de-duplicated and sorted for a stable set-diff.
+export function parseFailingTestNames(text) {
+  const out = new Set();
+  const stripMs = (s) => s.replace(/\s*\(\d[\d.]*m?s\)\s*$/i, '').trim();
+  for (const raw of String(text ?? '').split('\n')) {
+    const line = raw.trim();
+    if (!line) continue;
+    let m = line.match(/^[✖✗✘×]\s+(.*)$/);
+    if (m) {
+      const title = stripMs(m[1].trim());
+      if (!title || /^failing tests:?$/i.test(title)) continue; // summary header
+      out.add(title);
+      continue;
+    }
+    m = line.match(/^not ok\s+\d+\s*-?\s*(.*)$/i);
+    if (m) {
+      if (/#\s*(SKIP|TODO)\b/i.test(line)) continue; // directive, not a real failure
+      const title = stripMs(m[1].replace(/\s+#.*$/, '').trim());
+      if (title) out.add(title);
+    }
+  }
+  return [...out].sort();
+}
+
+// Compare the CURRENT run's failing tests against the BASE (pre-change) run's
+// so the review gate blocks ONLY on failures this change introduced. A test
+// that was already red on the base is pre-existing noise (unrelated to the
+// goal) — it must not knock a proof-verified goal back to blocked/Failed.
+// Callers should treat an EMPTY baseline as "unknown" and fall back to the old
+// block-on-any-red behaviour (fail closed) — see verifyGate.
+export function classifyTestGate({ current = [], baseline = [] } = {}) {
+  const base = new Set(baseline);
+  const cur = [...new Set((current ?? []).filter(Boolean))];
+  const newFailures = cur.filter((t) => !base.has(t)).sort();
+  const preExisting = cur.filter((t) => base.has(t)).sort();
+  return { newFailures, preExisting, blocked: newFailures.length > 0 };
+}
+
+// The verification-gate decision (Masa 2026-07-19: "検証/proof は Failed を作らない").
+// PROOF IS ADVISORY: a UI goal whose screenshot could not be captured
+// (proofMissing) or whose pixel heuristic could not auto-confirm the target
+// (proofFailing) is NOT blocked — the work is done and reaches Review with a
+// note; proof adds confidence, it never subtracts a correct result. What still
+// blocks a goal from Review: newly-failing tests (testsFailing — the caller has
+// already made this baseline-aware via classifyTestGate), a promised-but-undone
+// task (nothingVerifiable = a passCondition with no file change and no proof),
+// and the opt-in requireVerifyPass gate (verifyFail, off by default). Pure so
+// the whole gate decision is unit-tested rather than living only inside the
+// server's big async verifyGate.
+export function classifyVerifyGate({
+  testsFailing = false, proofMissing = false, proofFailing = false,
+  nothingVerifiable = false, verifyFail = false,
+} = {}) {
+  const blocked = Boolean(testsFailing || nothingVerifiable || verifyFail);
+  const kind = testsFailing ? 'test' : nothingVerifiable ? 'noop' : verifyFail ? 'verify' : null;
+  // Advisory note surfaced on the review even when the goal is NOT blocked.
+  const proofAdvisory = proofMissing ? 'missing' : proofFailing ? 'unconfirmed' : null;
+  return { blocked, kind, proofAdvisory };
+}
+
 // Whether to ALSO capture a BASELINE ("before") shot for a before/after
 // comparison. Only worth attempting when the baseline is a genuinely
 // different checkout of the code than the one just captured as "after" — a
@@ -1308,6 +1375,22 @@ export function classifyComposerIntentHeuristic(text) {
   return 'unsure';                          // both or neither → let the LLM decide
 }
 
+// Chat-driven play/pause (Masa: "チャットで再生一時停止はおせる"). A DETERMINISTIC,
+// conservative match — no LLM, no cost — that only fires when the WHOLE message
+// is a short, command-like pause/resume order. Anchored ^…$ with only polite
+// suffixes allowed after the keyword, plus a length cap, so a described request
+// that merely contains the word ("止めてほしいバグを直して", "start building the
+// login") is never mistaken for a control command. Returns 'pause'|'resume'|null.
+const PAUSE_INTENT_RE = /^(一時停止|いったん停止|一旦停止|停止|止めて|とめて|ストップ|作業を?止めて|全部止めて|全部停止|pause|stop)(?:\s*(して|してください|ください|でお願いします?|お願いします?|please|now))?[\s。.!！、,]*$/i;
+const RESUME_INTENT_RE = /^(再開|再生|再スタート|続けて|続きから|続行|resume|restart|start|play|go)(?:\s*(して|してください|ください|お願いします?|please|now))?[\s。.!！、,]*$/i;
+export function detectPauseIntent(text) {
+  const t = (text || '').trim();
+  if (!t || t.length > 24) return null; // a control command is short; long text is a real request
+  if (PAUSE_INTENT_RE.test(t)) return 'pause';
+  if (RESUME_INTENT_RE.test(t)) return 'resume';
+  return null;
+}
+
 // The one prompt that BOTH classifies and (for chat) writes the reply in the
 // requester's language — one Haiku round-trip, not two. The model returns a
 // single line of JSON: {"intent":"chat|task","reply":"…"}.
@@ -1907,7 +1990,42 @@ export const WORKFLOW_BUCKETS = ['todo', 'doing', 'review', 'done'];
 // Tools a `claude -p` worker may call (--allowedTools). TodoWrite must stay
 // in this list — it's how the UI's To-do section (sendTodos / SSE 'todos')
 // gets any data at all; without it workers can never emit {kind:'todos'}.
-export const WORKER_TOOLS = 'Edit,Write,Read,Glob,Grep,Skill,TodoWrite,Bash(node:*),Bash(npm:*),Bash(npx:*)';
+//
+// Bash was locked to node/npm/npx, which produced the "works in Claude Code,
+// fails here" class: a goal that legitimately needs python, a build tool, or
+// even a read-only `git log` would just fail — an error a plain Claude Code
+// session never hits. Widened here to the common legitimate commands.
+//
+// Honest note on what this list does and does NOT buy: it is friction control,
+// not a security boundary. Bash(node:*) already permits arbitrary execution
+// (`node -e "..."` can touch the network, delete files, anything), so the old
+// narrow list contained nothing — it only blocked honest direct commands.
+// Real isolation would need an OS sandbox (codex runs with --sandbox; the
+// claude-code worker does not). Given that, the exclusions below are posture,
+// not a wall:
+//   - git WRITE ops (commit/push/reset/checkout) are left off the fast path so
+//     the worker does not fight the Manager, which owns git in the worktree
+//     (the worker prompt already says "do not commit"). Read-only git is on.
+//   - rm / curl / wget stay off the fast path. (They are reachable via node
+//     anyway; keeping them non-first-class is a stated-posture choice. Whether
+//     to simplify to a blanket `Bash` — technically equivalent risk — is a
+//     customer-safety decision for Masa, not a silent flip here.)
+const WORKER_BASH = [
+  // JS/TS runtimes and package managers
+  'node', 'npm', 'npx', 'pnpm', 'yarn', 'bun', 'deno',
+  // other languages a task might actually need
+  'python', 'python3', 'pip', 'pip3', 'pytest', 'go', 'cargo', 'rustc',
+  'ruby', 'bundle', 'make',
+  // build/test/lint runners invoked directly
+  'tsc', 'jest', 'vitest', 'eslint', 'prettier',
+  // read-only git — inspect history/diffs like you would locally
+  'git status', 'git log', 'git diff', 'git show', 'git branch',
+  'git blame', 'git ls-files', 'git rev-parse',
+  // read/inspect shell utilities (file EDITS still go through Edit/Write)
+  'cat', 'ls', 'head', 'tail', 'wc', 'find', 'grep', 'rg',
+  'sed', 'awk', 'sort', 'uniq', 'diff', 'echo', 'which', 'env', 'pwd', 'date',
+].map((c) => `Bash(${c}:*)`).join(',');
+export const WORKER_TOOLS = `Edit,Write,Read,Glob,Grep,Skill,TodoWrite,${WORKER_BASH}`;
 
 // ---- SKILL picker ----------------------------------------------------------
 // Parse the YAML frontmatter of a SKILL.md / command .md and pull out `name`

package/engine/relay-supervisor.mjs

@@ -0,0 +1,113 @@
+// Launcher-side supervisor for the relay-client CHILD process.
+//
+// Why this exists (2026-07-18 incident): the launcher (bin/manager-for-ai.mjs)
+// spawns engine/relay-client.mjs exactly ONCE and only kills it when the parent
+// goes down — there was no path the other way (child dies -> bring it back).
+// relay-client already self-heals a dropped SOCKET (backoff reconnect, capped at
+// 15s), but when the whole PROCESS exits — an uncaught throw, or the single-
+// instance lock refusing to start — nothing respawns it, so the user's app
+// silently goes offline and every new goal shows "Unsent – tap to resend". This
+// is the customer-facing half of the fix (the operator's own box is now kept up
+// by a launchd KeepAlive job; npx users have no launchd, only this launcher).
+//
+// Split into a PURE policy reducer (relayRespawnDecision) and an impure driver
+// (superviseRelay) that owns spawn()/timers/clock — same shape as
+// relayReconnectDecision in engine/lib.mjs. The policy is unit-tested without any
+// real process; the driver is integration-tested with a fake child.
+
+// Fresh supervisor state. `delayMs` is the last backoff used; `quickExits` counts
+// consecutive exits that happened inside the "quick-crash" window; `gaveUp` latches
+// once the circuit breaker trips.
+export const relaySupervisorInit = { delayMs: 0, quickExits: 0, gaveUp: false };
+
+// Decide what to do when the supervised child exits. Pure — no clock, no I/O.
+//
+//   state : previous supervisor state (start from relaySupervisorInit)
+//   event : { uptimeMs } — how long the child that just exited had been alive
+//   opts  : tunables (defaults match the relay socket backoff feel)
+//     minMs   floor delay for the first / a reset respawn        (1s)
+//     maxMs   ceiling the exponential backoff saturates at       (15s)
+//     quickMs a child that lived less than this "crash-looped"   (10s)
+//     limit   consecutive quick exits before we give up          (5)
+//
+// Returns { restart, delayMs, gaveUp, state }.
+// - A child that lived past `quickMs` is treated as having made progress: the
+//   backoff and the quick-exit counter both reset (a healthy long run should not
+//   inherit a punishing delay from an earlier bad patch).
+// - Consecutive quick exits escalate the delay (min, 2x, 4x, ... capped at max)
+//   and, once they reach `limit`, trip the circuit breaker so we stop hammering a
+//   config/lock error forever. The caller logs why and stands down.
+export function relayRespawnDecision(state, event, opts = {}) {
+  const { minMs = 1000, maxMs = 15000, quickMs = 10000, limit = 5 } = opts;
+  const prev = Number(state?.delayMs);
+  const lastDelay = Number.isFinite(prev) ? prev : 0;
+  const uptimeMs = Number(event?.uptimeMs) || 0;
+  const quick = uptimeMs < quickMs;
+  const quickExits = quick ? (Number(state?.quickExits) || 0) + 1 : 0;
+
+  if (quickExits >= limit) {
+    return { restart: false, delayMs: 0, gaveUp: true, state: { delayMs: lastDelay, quickExits, gaveUp: true } };
+  }
+
+  const delayMs = quick
+    ? (lastDelay < minMs ? minMs : Math.min(lastDelay * 2, maxMs))
+    : minMs;
+  return { restart: true, delayMs, gaveUp: false, state: { delayMs, quickExits, gaveUp: false } };
+}
+
+// Drive a respawning child. Impure: owns spawn()/timers/clock, all injectable so
+// the loop is testable with a fake child and fast delays.
+//
+//   spawn     () => ChildProcess-like (must emit 'exit' and have .kill())
+//   now       () => ms clock (default Date.now)
+//   setTimer/clearTimer  timer fns (default global setTimeout/clearTimeout)
+//   log       ({ code, signal, delayMs }) => void  — a respawn was scheduled
+//   onGiveUp  () => void                           — circuit breaker tripped
+//   opts      passed through to relayRespawnDecision
+//
+// Returns { stop, child, state } — stop() suppresses further respawns (normal
+// shutdown) and kills the current child.
+export function superviseRelay({
+  spawn,
+  now = () => Date.now(),
+  setTimer = setTimeout,
+  clearTimer = clearTimeout,
+  log = () => {},
+  onGiveUp = () => {},
+  opts,
+} = {}) {
+  let shuttingDown = false;
+  let state = { ...relaySupervisorInit };
+  let child = null;
+  let startedAt = 0;
+  let timer = null;
+
+  const start = () => {
+    startedAt = now();
+    child = spawn();
+    child.on('exit', (code, signal) => {
+      child = null;
+      if (shuttingDown) return; // parent asked us to stop — don't fight it
+      const uptimeMs = now() - startedAt;
+      const decision = relayRespawnDecision(state, { uptimeMs }, opts);
+      state = decision.state;
+      if (!decision.restart) { onGiveUp(); return; }
+      log({ code, signal, delayMs: decision.delayMs });
+      timer = setTimer(start, decision.delayMs);
+      if (timer && typeof timer.unref === 'function') timer.unref();
+    });
+  };
+
+  const stop = () => {
+    shuttingDown = true;
+    if (timer) { clearTimer(timer); timer = null; }
+    try { child?.kill(); } catch { /* already gone */ }
+  };
+
+  start();
+  return {
+    stop,
+    get child() { return child; },
+    get state() { return state; },
+  };
+}