flowviant 0.103.0 → 0.104.0

package/bin/lib/projectToolRuntimes.mjs

@@ -0,0 +1,138 @@
+/**
+ * WHAT EACH CLI TAKES OF THE REPO'S TOOLS, AND HOW A TURN IS PREPARED FOR IT
+ * (2026-09-26, SOLID F064).
+ *
+ * One row per runtime: whether it can take MCP servers at all, which MCP
+ * configurations it refuses (Codex takes no SSE), whether it takes the base
+ * branch's skills, and the runner-specific filesystem work a turn needs
+ * (Claude: a reviewed plugin carrying the base skills; Codex: an isolated
+ * CODEX_HOME). Split out of projectTools.mjs, where a capability table sat
+ * beside `runner === 'codex'` / `runner === 'claude'` branches in
+ * prepareAgentTools and a second copy of the SSE rule in toolReadout, so a
+ * new runtime or a transport change needed coordinated edits in three places.
+ * prepareAgentTools, toolReadout and runtimeOfferings.mjs (the Codex MCP
+ * report) all ask this table; the base-branch snapshot reader stays in
+ * projectTools.mjs. projectTools.test.mjs pins every transport word to here.
+ */
+
+import { existsSync, mkdirSync, readFileSync, readdirSync, symlinkSync, writeFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { homedir } from 'node:os';
+
+export const toml = (value) => JSON.stringify(String(value));
+
+/** Keep personal Codex files, but do not copy its project trust grants. An
+ * untrusted worktree's .codex/config.toml is ignored by Codex 0.156.1. */
+function isolatedCodexHome(dir, env, worktree) {
+  const source = resolve(env.CODEX_HOME || join(homedir(), '.codex'));
+  const dest = join(dir, 'codex-home');
+  mkdirSync(dest, { mode: 0o700 });
+  if (existsSync(source)) {
+    for (const name of readdirSync(source)) {
+      if (name === 'config.toml') continue;
+      symlinkSync(join(source, name), join(dest, name));
+    }
+  }
+  const configPath = join(source, 'config.toml');
+  const sourceConfig = existsSync(configPath) ? readFileSync(configPath, 'utf8') : '';
+  const topLevel = sourceConfig.split(/^\s*\[/m, 1)[0];
+  const personalDeveloperInstructions = /^\s*developer_instructions\s*=/m.test(topLevel);
+  // These sections alone grant a checkout permission to supply project
+  // settings. Keep every other personal setting, skill and session store.
+  const lines = sourceConfig.split('\n');
+  let inProject = false;
+  let config = lines.filter((line) => {
+    const header = /^\s*(?:\[\[([^\]]+)\]\]|\[([^\]]+)\])\s*(?:#.*)?$/.exec(line);
+    if (header) {
+      const section = header[1] ?? header[2];
+      inProject = section === 'projects' || section.startsWith('projects.');
+    }
+    return !inProject;
+  }).join('\n');
+  if (worktree) {
+    // Codex discovers these even in an untrusted project. Disable exactly the
+    // worktree skill paths; the person's ~/.codex/skills and config remain.
+    const worktreeSkills = [];
+    for (const sourceDir of ['.agents/skills', '.codex/skills', '.claude/skills']) {
+      const skillsDir = join(worktree, sourceDir);
+      if (!existsSync(skillsDir)) continue;
+      for (const name of readdirSync(skillsDir)) {
+        const skill = join(skillsDir, name, 'SKILL.md');
+        if (existsSync(skill)) worktreeSkills.push(skill);
+      }
+    }
+    if (worktreeSkills.length && /^\s*skills\.config\s*=/m.test(config))
+      throw new Error('Cannot isolate Codex project skills with inline skills.config');
+    for (const skill of worktreeSkills) config += `\n[[skills.config]]\npath = ${toml(skill)}\nenabled = false\n`;
+  }
+  writeFileSync(join(dest, 'config.toml'), config, { mode: 0o600 });
+  return { path: dest, personalDeveloperInstructions };
+}
+
+/** Claude takes the base branch's skills as a plugin written for this turn. */
+function reviewedClaudePlugin(dir, snapshot) {
+  if (!snapshot.skillFiles.length) return null;
+  const pluginDir = join(dir, 'reviewed-plugin');
+  mkdirSync(join(pluginDir, '.claude-plugin'), { recursive: true });
+  writeFileSync(join(pluginDir, '.claude-plugin/plugin.json'), JSON.stringify({ name: 'flowviant-reviewed', version: '1.0.0', description: 'Base-branch agent skills' }), { mode: 0o600 });
+  for (const { path, body } of snapshot.skillFiles) {
+    const dest = join(pluginDir, path.replace(/^\.claude\//, ''));
+    mkdirSync(join(dest, '..'), { recursive: true });
+    writeFileSync(dest, body, { mode: 0o600 });
+  }
+  return pluginDir;
+}
+
+/**
+ * The table. `refuseMcp(config)` names why this runtime cannot take one MCP
+ * configuration it otherwise could; `prepare(dir, snapshot, env, worktree)`
+ * returns the runner-specific part of prepareAgentTools' result.
+ */
+const TOOL_RUNTIMES = {
+  claude: {
+    mcp: true,
+    skills: true,
+    refuseMcp: () => null,
+    prepare: (dir, snapshot) => ({ pluginDir: reviewedClaudePlugin(dir, snapshot) }),
+  },
+  codex: {
+    mcp: true,
+    skills: true,
+    refuseMcp: (config) => (config.type === 'sse' ? 'Codex cannot take SSE MCP' : null),
+    prepare: (dir, _snapshot, env, worktree) => {
+      const isolated = isolatedCodexHome(dir, env, worktree);
+      return { codexHome: isolated.path, personalDeveloperInstructions: isolated.personalDeveloperInstructions };
+    },
+  },
+  antigravity: { mcp: false, skills: false },
+};
+
+/** An unknown runner (or 'none', when no CLI is installed) takes nothing. */
+const takesNothing = { mcp: false, skills: false };
+const rowFor = (runner) => (Object.hasOwn(TOOL_RUNTIMES, runner) ? TOOL_RUNTIMES[runner] : takesNothing);
+
+/** Pure mapping used before a future tool-attach gesture is offered. */
+export function runnerToolCapabilities(runner) {
+  const { mcp, skills } = rowFor(runner);
+  return { mcp, skills };
+}
+
+/** Why `runner` cannot take this MCP configuration, or null when it can. The
+ *  one answer both preparation (which drops it) and the readout (which says it)
+ *  read. */
+export function mcpRefusal(runner, config) {
+  const row = rowFor(runner);
+  if (!row.mcp) return runner === 'none' ? 'no installed CLI can take MCP' : `${runner} cannot take MCP`;
+  return row.refuseMcp?.(config) ?? null;
+}
+
+/** Why `runner` cannot take the base branch's skills, or null when it can. */
+export function skillsRefusal(runner) {
+  if (rowFor(runner).skills) return null;
+  return runner === 'none' ? 'no installed CLI can take instructions' : `${runner} cannot take instructions`;
+}
+
+/** The runner-specific files a turn needs, written under `dir`. */
+export function prepareForRunner(runner, dir, snapshot, env, worktree) {
+  return { pluginDir: null, codexHome: null, personalDeveloperInstructions: false, ...(rowFor(runner).prepare?.(dir, snapshot, env, worktree) ?? {}) };
+}

package/bin/lib/projectTools.mjs

@@ -1,15 +1,15 @@
 /** Repo-owned tool configuration, read from the base ref for every agent turn. */
 import { execFileSync } from 'node:child_process';
-import { accessSync, constants, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
-import { delimiter, isAbsolute, join, resolve } from 'node:path';
-import { homedir, tmpdir } from 'node:os';
+import { accessSync, constants, mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { delimiter, isAbsolute, join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { mcpRefusal, prepareForRunner, skillsRefusal, toml } from './projectToolRuntimes.mjs';
 
 const MAX_TOOLS = 40;
 const MAX_REPORT_TOOLS = 80; // 40 MCP servers plus 40 instruction directories
 const MAX_INSTRUCTION_FILES = 80;
 const MAX_INSTRUCTION_BYTES = 512 * 1024;
 const nameOk = (name) => /^[A-Za-z0-9_-]{1,80}$/.test(name) && name !== 'flowviant';
-const toml = (value) => JSON.stringify(String(value));
 const show = (root, ref, path) => {
   try {
     return execFileSync('git', ['show', `${ref}:${path}`], {
@@ -39,12 +39,6 @@ function referenced(value) {
   return [...String(value).matchAll(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g)].map((m) => m[1]);
 }
 
-/** Pure mapping used before a future tool-attach gesture is offered. */
-export function runnerToolCapabilities(runner) {
-  return ({ claude: { mcp: true, skills: true }, codex: { mcp: true, skills: true }, antigravity: { mcp: false, skills: false } })[runner]
-    ?? { mcp: false, skills: false };
-}
-
 export function readBaseTools(root, ref, env = process.env) {
   // Resolve once: a base branch may advance while the turn is being prepared.
   const commit = execFileSync('git', ['rev-parse', '--verify', ref], {
@@ -105,59 +99,10 @@ export function readBaseTools(root, ref, env = process.env) {
 
 const expand = (value, env) => String(value).replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g, (_, key) => env[key] ?? '');
 
-/** Keep personal Codex files, but do not copy its project trust grants. An
- * untrusted worktree's .codex/config.toml is ignored by Codex 0.156.1. */
-function isolatedCodexHome(dir, env, worktree) {
-  const source = resolve(env.CODEX_HOME || join(homedir(), '.codex'));
-  const dest = join(dir, 'codex-home');
-  mkdirSync(dest, { mode: 0o700 });
-  if (existsSync(source)) {
-    for (const name of readdirSync(source)) {
-      if (name === 'config.toml') continue;
-      symlinkSync(join(source, name), join(dest, name));
-    }
-  }
-  const configPath = join(source, 'config.toml');
-  const sourceConfig = existsSync(configPath) ? readFileSync(configPath, 'utf8') : '';
-  const topLevel = sourceConfig.split(/^\s*\[/m, 1)[0];
-  const personalDeveloperInstructions = /^\s*developer_instructions\s*=/m.test(topLevel);
-  // These sections alone grant a checkout permission to supply project
-  // settings. Keep every other personal setting, skill and session store.
-  const lines = sourceConfig.split('\n');
-  let inProject = false;
-  let config = lines.filter((line) => {
-    const header = /^\s*(?:\[\[([^\]]+)\]\]|\[([^\]]+)\])\s*(?:#.*)?$/.exec(line);
-    if (header) {
-      const section = header[1] ?? header[2];
-      inProject = section === 'projects' || section.startsWith('projects.');
-    }
-    return !inProject;
-  }).join('\n');
-  if (worktree) {
-    // Codex discovers these even in an untrusted project. Disable exactly the
-    // worktree skill paths; the person's ~/.codex/skills and config remain.
-    const worktreeSkills = [];
-    for (const sourceDir of ['.agents/skills', '.codex/skills', '.claude/skills']) {
-      const skillsDir = join(worktree, sourceDir);
-      if (!existsSync(skillsDir)) continue;
-      for (const name of readdirSync(skillsDir)) {
-        const skill = join(skillsDir, name, 'SKILL.md');
-        if (existsSync(skill)) worktreeSkills.push(skill);
-      }
-    }
-    if (worktreeSkills.length && /^\s*skills\.config\s*=/m.test(config))
-      throw new Error('Cannot isolate Codex project skills with inline skills.config');
-    for (const skill of worktreeSkills) config += `\n[[skills.config]]\npath = ${toml(skill)}\nenabled = false\n`;
-  }
-  writeFileSync(join(dest, 'config.toml'), config, { mode: 0o600 });
-  return { path: dest, personalDeveloperInstructions };
-}
-
 /** Temporary per-turn files are removed after the last retry. No personal CLI config is written. */
 export function prepareAgentTools(snapshot, runner, env = process.env, worktree = null) {
   const dir = mkdtempSync(join(tmpdir(), 'flowviant-agent-tools-'));
-  const caps = runnerToolCapabilities(runner);
-  const usable = snapshot.tools.filter((t) => t.state === 'ready' && caps.mcp && !(runner === 'codex' && t.config.type === 'sse'));
+  const usable = snapshot.tools.filter((t) => t.state === 'ready' && mcpRefusal(runner, t.config) == null);
   const mcpServers = {};
   const codexArgs = [];
   for (const { name, config } of usable) {
@@ -185,7 +130,7 @@ export function prepareAgentTools(snapshot, runner, env = process.env, worktree
   const mcpPath = join(dir, 'mcp.json');
   writeFileSync(mcpPath, JSON.stringify({ mcpServers }), { mode: 0o600 });
   const pointers = [];
-  for (const { path, body } of [...snapshot.instructions, ...(caps.skills ? snapshot.skillFiles : [])]) {
+  for (const { path, body } of [...snapshot.instructions, ...(skillsRefusal(runner) == null ? snapshot.skillFiles : [])]) {
     const dest = join(dir, path);
     mkdirSync(join(dest, '..'), { recursive: true });
     writeFileSync(dest, body, { mode: 0o600 });
@@ -195,28 +140,14 @@ export function prepareAgentTools(snapshot, runner, env = process.env, worktree
   const instructions = [baseInstructions,
     pointers.length ? `Base-branch instruction and skill copies (read the relevant nested files and skill files before acting):\n${pointers.join('\n')}` : '',
   ].filter(Boolean).join('\n\n');
-  const pluginDir = runner === 'claude' && snapshot.skillFiles.length ? join(dir, 'reviewed-plugin') : null;
-  if (pluginDir) {
-    mkdirSync(join(pluginDir, '.claude-plugin'), { recursive: true });
-    writeFileSync(join(pluginDir, '.claude-plugin/plugin.json'), JSON.stringify({ name: 'flowviant-reviewed', version: '1.0.0', description: 'Base-branch agent skills' }), { mode: 0o600 });
-    for (const { path, body } of snapshot.skillFiles) {
-      const dest = join(pluginDir, path.replace(/^\.claude\//, ''));
-      mkdirSync(join(dest, '..'), { recursive: true });
-      writeFileSync(dest, body, { mode: 0o600 });
-    }
-  }
-  let codexHome = null;
-  let personalDeveloperInstructions = false;
+  let prepared;
   try {
-    if (runner === 'codex') {
-      const isolated = isolatedCodexHome(dir, env, worktree);
-      codexHome = isolated.path;
-      personalDeveloperInstructions = isolated.personalDeveloperInstructions;
-    }
+    prepared = prepareForRunner(runner, dir, snapshot, env, worktree);
   } catch (error) {
     rmSync(dir, { recursive: true, force: true });
     throw error;
   }
+  const { pluginDir, codexHome, personalDeveloperInstructions } = prepared;
   return {
     mcpPath,
     codexArgs,
@@ -229,20 +160,14 @@ export function prepareAgentTools(snapshot, runner, env = process.env, worktree
 }
 
 export function toolReadout(snapshot, runner) {
-  const caps = runnerToolCapabilities(runner);
   const short = (reason) => reason == null ? null : String(reason).slice(0, 200);
   const mcp = snapshot.tools.map(({ name, config, state, reason }) => {
-    const unsupported = runner === 'codex' && config.type === 'sse';
-    return {
-      name, kind: 'mcp',
-      state: caps.mcp && !unsupported ? state : 'missing',
-      reason: short(!caps.mcp ? runner === 'none' ? 'no installed CLI can take MCP' : `${runner} cannot take MCP`
-        : unsupported ? 'Codex cannot take SSE MCP' : reason),
-    };
+    const refused = mcpRefusal(runner, config);
+    return { name, kind: 'mcp', state: refused ? 'missing' : state, reason: short(refused ?? reason) };
   });
+  const skillsRefused = skillsRefusal(runner);
   const instructions = snapshot.skills.map(({ path }) => ({
-    name: path.split('/')[2], kind: 'instruction', state: caps.skills ? 'ready' : 'missing',
-    reason: short(caps.skills ? null : runner === 'none' ? 'no installed CLI can take instructions' : `${runner} cannot take instructions`),
+    name: path.split('/')[2], kind: 'instruction', state: skillsRefused ? 'missing' : 'ready', reason: short(skillsRefused),
   }));
   return [...mcp, ...instructions].slice(0, MAX_REPORT_TOOLS);
 }

package/bin/lib/prompts.mjs

@@ -1,42 +1,15 @@
 /**
  * The operating-contract prompts — every system prompt and kickoff the daemon
- * hands a coding CLI, in one place. Split out of claude.mjs (which keeps the
- * permission sets and the turn plumbing) purely for size; claude.mjs
- * re-exports everything here, so no call site changed. These are strings and
- * nothing else: no imports, no environment, no I/O.
+ * hands a coding CLI, in one place. Split out of claude.mjs purely for size
+ * (the permission sets are claudePosture.mjs's, the turn plumbing runTurn.mjs's);
+ * every call site imports them from here. These are strings and
+ * nothing else: no environment, no I/O, and one import — the card-kind table
+ * (agentTaskKinds.mjs, itself pure data), which selects among them.
  */
 
-/**
- * A CARD'S KIND, READ THE ONE WAY THE DAEMON READS IT (0.97.0).
- *
- * `code` (the default), `design` or `research` — the server sends the key only
- * for the last two, so ABSENT IS CODE, and an unknown string (a newer server, a
- * typo) degrades to code: the one kind that changes nothing about how a card is
- * run. Every reader in this repo — the contract selector, the kickoff, the
- * spec, the posture, the post-turn artifact check — goes through this, so no
- * two of them can disagree about what an odd value means.
- */
-export const agentTaskKindOf = (v) => (v === 'design' || v === 'research' ? v : 'code');
-
-/**
- * …EXCEPT WHERE A TURN IS ABOUT TO SPAWN (2026-09-23). "Unknown degrades to
- * code" is right for every reader that only PRINTS the kind — the planner's
- * kickoff, the spec, a contract heading — and wrong for the one that picks a
- * POSTURE: code is the build turn, permissions skipped, so a kind a newer
- * server invented for a card that must not touch the code (a fourth kind, a
- * typo, `Design`) would have run as exactly the turn it exists to prevent. The
- * agent lane asks this first and refuses in words, relaying the word it was
- * handed. Absent, null and empty stay code — that is how a code card arrives.
- *
- * @returns {string|null} the unrecognised value, or null when the kind is one
- *   this daemon runs.
- */
-export const unknownAgentTaskKind = (v) =>
-  v === undefined || v === null || v === '' || v === 'code' || v === 'design' || v === 'research'
-    ? null
-    : String(v).replace(/[\u0000-\u001f\u007f]/g, '').slice(0, 40);
-
-
+// A card's kind is read through agentTaskKinds.mjs — the one table of what a
+// kind is. This file keeps only the STRINGS each kind is handed.
+import { agentTaskKindOf } from './agentTaskKinds.mjs';
 
 // Wiki-gen turn: the local Claude READS the repo (cwd) and writes/maintains the
 // knowledge VAULT — a plain directory of markdown files with [[wikilinks]]
@@ -450,7 +423,7 @@ Write plain Markdown for a person reading your reply in a chat tab.`;
  * bookkeeping reasons, which is the one thing it never does.
  *
  * SHAPE, NOT MEMBERSHIP. We do not check the name against the machine's skill
- * list: that list is only learned after a turn has run (runtimes.mjs), so
+ * list: that list is only learned after a turn has run (runtimeCapabilities.mjs), so
  * gating on it would make the first `/foo` of a machine's life behave
  * differently from the second. Instead this matches what a command can LOOK
  * like — one segment, no second slash — which leaves `/home/user/x.ts is
@@ -939,7 +912,7 @@ not only this card. Past tense, plain sentences, no commit shas and no card ids.
  * everything BEFORE the JSON — no commits, no trailer, one artifact.
  *
  * THE PROMPT IS THE QUALITY; THE POSTURE IS THE FENCE. The `design` posture
- * (claude.mjs) can write ONLY under `.flowviant/artifacts/` — "change no
+ * (claudePosture.mjs) can write ONLY under `.flowviant/artifacts/` — "change no
  * repository file" is enforced, not asked — and the daemon refuses to call the
  * turn delivered if no `.html` was written under it this turn.
  *
@@ -1071,10 +1044,23 @@ past tense, plain sentences, no card ids.`;
  * code, and code is `SYSTEM_AGENT` — the same object, so a code turn's system
  * prompt is byte-for-byte what it was before kinds existed.
  */
-export const SYSTEM_AGENT_FOR = (taskKind) => {
-  const k = agentTaskKindOf(taskKind);
-  return k === 'design' ? SYSTEM_AGENT_DESIGN : k === 'research' ? SYSTEM_AGENT_RESEARCH : SYSTEM_AGENT;
-};
+export const SYSTEM_AGENT_FOR = (taskKind) => AGENT_CONTRACTS[agentTaskKindOf(taskKind)];
+
+/**
+ * THE STRINGS EACH KIND IS HANDED, keyed by the kinds in agentTaskKinds.mjs —
+ * its contract, and (for a kind that changes nothing in the repository) the
+ * clause its kickoff says it hands back. A kind added there without a line
+ * here fails `agentTaskKinds.test.mjs`, never a turn.
+ */
+export const AGENT_CONTRACTS = Object.freeze({
+  code: SYSTEM_AGENT,
+  design: SYSTEM_AGENT_DESIGN,
+  research: SYSTEM_AGENT_RESEARCH,
+});
+export const AGENT_HANDS_BACK = Object.freeze({
+  design: 'a DESIGN card: it hands back a mockup',
+  research: 'a RESEARCH card: it hands back a write-up',
+});
 
 /**
  * The turn itself.
@@ -1102,7 +1088,7 @@ export const AGENT_TASK_KICKOFF = ({ agentName, task, position, total }) =>
       // is not said at all. The code branch above is byte-for-byte what every
       // turn got before kinds existed.
       `You are the agent "${safeName(agentName)}", working card ${position} of ${total} ` +
-      `in this run. This card is ${agentTaskKindOf(task?.taskKind) === 'design' ? 'a DESIGN card: it hands back a mockup' : 'a RESEARCH card: it hands back a write-up'}, ` +
+      `in this run. This card is ${AGENT_HANDS_BACK[agentTaskKindOf(task?.taskKind)]}, ` +
       `written under .flowviant/artifacts/, and changes nothing in the repository.\n\n` +
       `${fence('THE CARD', taskBlock(task))}\n\n` +
       `Do it, and end with the JSON object.`;

package/bin/lib/repoPath.mjs

@@ -0,0 +1,26 @@
+/**
+ * REPO IDENTITY BY PATH — whether two spellings name the same checkout. One
+ * home for the rule the instance lock (neighbour takeover, same-repo
+ * replacement) and the credential store (collisions, the login refusal, start
+ * resolution) both decide on. Split out (SOLID F057) because the two were
+ * hand-copied: a change to symlink or missing-path treatment made in one would
+ * let a lock and a credential disagree about which directory a daemon serves.
+ *
+ * Realpath first (symlinks and trailing slashes both resolve); a path that no
+ * longer exists falls back to its own spelling minus trailing slashes, so a
+ * deleted checkout still matches the lock or entry that names it.
+ */
+import { realpathSync } from 'node:fs';
+
+/** Same directory, whatever it is spelled as. A blank side matches nothing. */
+export function samePath(a, b) {
+  if (!a || !b) return false;
+  const norm = (v) => {
+    try {
+      return realpathSync(v);
+    } catch {
+      return String(v).replace(/\/+$/, '');
+    }
+  };
+  return norm(a) === norm(b);
+}

package/bin/lib/resources.mjs

@@ -18,7 +18,8 @@
  * ── AND SINCE 2026-09-14 THERE IS A SECOND READER, WHICH IS NOT TELEMETRY ──
  *
  * The paragraph above is about the SNAPSHOT and stands unchanged. What is added
- * below — `memAvailableBytes` and `pressureVerdict` — is read at the moment
+ * below — `memAvailableBytes` and `measurePressure`, judged by `pressureVerdict`
+ * in pressurePolicy.mjs — is read at the moment
  * this machine is about to spawn one more CLI, and it exists because it froze
  * somebody's computer: `MAX_CONCURRENT` had been enforced nowhere since
  * dispatch was deleted, the session-turn lane had no slice at all, and nothing
@@ -49,9 +50,6 @@ import { readFileSync, readdirSync, statfsSync } from 'node:fs';
 import { cpus, freemem, loadavg, platform } from 'node:os';
 import { MACHINE } from './config.mjs';
 
-const MiB = 1024 * 1024;
-const GiB = 1024 * MiB;
-
 const readFile = (p) => {
   try {
     return readFileSync(p, 'utf8').trim();
@@ -162,7 +160,7 @@ export function processTreeRssBytes(pid) {
  * pages is the nearest thing it will say out loud.
  *
  * The cgroup is asked SECOND and narrows rather than replaces, for the reason
- * `machineLimits` gives in config.mjs: a 4GB container on a 256GB box reads the
+ * `deriveMachineLimits` gives in machineLimits.mjs: a 4GB container on a 256GB box reads the
  * host through the os module, and oversubscribing there ends with the OOM
  * killer picking a victim by resident size — frequently not the offender.
  *
@@ -248,26 +246,6 @@ function darwinAvailableBytes() {
   return pages > 0 ? pages * page : null;
 }
 
-/** The guard off entirely — an escape hatch for a box whose operator knows
- *  better than the thresholds. Read per call, not captured at import, so it is
- *  true of the environment the daemon is in RIGHT NOW rather than the one it
- *  booted in. `absence` and `'0'` both mean the guard is on. */
-export function pressureGuardOff() {
-  return process.env.FLOWVIANT_NO_PRESSURE_GUARD === '1';
-}
-
-/** An operator's override, or the default. Positive finite numbers only: a
- *  typo'd `FLOWVIANT_MIN_FREE_MB=lots` must fall back to the default rather
- *  than turning every comparison into NaN, which compares false and would
- *  silently disable the guard it was trying to tune. */
-const envNum = (name, fallback) => {
-  const n = Number(process.env[name]);
-  return Number.isFinite(n) && n > 0 ? n : fallback;
-};
-
-const sizeWord = (n) =>
-  n >= GiB ? `${(n / GiB).toFixed(1)} GB` : `${Math.round(n / MiB)} MB`;
-
 /** How long one measurement stands. The reconcile loop asks several times a
  *  tick (one per admission point) and every answer would otherwise be a fresh
  *  /proc read — or, on macOS, a fresh `vm_stat` spawn, which is a process per
@@ -308,50 +286,10 @@ export function measurePressure() {
   return m;
 }
 
-/**
- * IS THIS A MOMENT TO START ANOTHER CLI? — null when there is nothing to say.
- *
- * TWO LEVELS, because the two lanes are not the same promise. `churn` is the
- * unattended work — agent turns, a Deploy press's planner, the wiki
- * cartographer — which nobody is sitting in front of and which the server will
- * cheerfully re-offer next poll, so it yields early and generously. A session
- * turn is `interactive`: somebody is watching a composer they just pressed
- * enter in, and deferring that is a visible stall, so it holds out until the
- * box is genuinely about to fall over.
- *
- * THE REASON IS MEASURED WORDS AND NOTHING ELSE. No adjectives about the
- * machine, no advice, no "try again in a few minutes" — a sentence naming the
- * number that fired, which is the only thing this side actually knows.
- *
- * An unreadable measurement contributes NO verdict: memory that could not be
- * read cannot refuse, and a load average this platform does not publish cannot
- * either. Ignorance never withholds.
- */
-export function pressureVerdict(level, measured) {
-  if (pressureGuardOff()) return null;
-  const m = measured ?? measurePressure();
-  const avail = Number.isFinite(m?.memAvailable) ? m.memAvailable : null;
-  if (level === 'interactive') {
-    const floor = envNum('FLOWVIANT_CRITICAL_FREE_MB', 400) * MiB;
-    if (avail !== null && avail < floor)
-      return { reason: `nearly out of memory — ${sizeWord(avail)} available` };
-    return null;
-  }
-  const total = Number.isFinite(m?.memTotal) && m.memTotal > 0 ? m.memTotal : 0;
-  // A fixed floor AND a proportional one, whichever is larger: 1 GB is the
-  // right reserve on a laptop and is nothing on a 256 GB box, where six per
-  // cent is the honest "the page cache is already being squeezed" line.
-  const floor = Math.max(envNum('FLOWVIANT_MIN_FREE_MB', 1024) * MiB, Math.round(total * 0.06));
-  if (avail !== null && avail < floor)
-    return { reason: `low memory — ${sizeWord(avail)} of ${sizeWord(total)} available` };
-  const cores = Number.isFinite(m?.cores) && m.cores > 0 ? m.cores : null;
-  const load = Number.isFinite(m?.load1) ? m.load1 : null;
-  if (load !== null && cores !== null && load > cores * envNum('FLOWVIANT_MAX_LOAD_PER_CORE', 4))
-    return {
-      reason: `cpu overloaded — load ${load.toFixed(1)} on ${cores} core${cores === 1 ? '' : 's'}`,
-    };
-  return null;
-}
+// THE VERDICT ITSELF — "is this a moment to start another CLI?" — lives in
+// pressurePolicy.mjs (2026-09-26), pure, with its thresholds passed in. This
+// module measures; admission.mjs hands the measurement and the live
+// environment's thresholds to it per decision.
 
 /** Free bytes on the volume holding the worktrees. */
 export function diskFreeBytes(path) {

package/bin/lib/resumeLost.mjs

@@ -0,0 +1,107 @@
+/**
+ * The resume-lost rule — when a resumed CLI turn found no conversation and
+ * runs once more fresh. ONE home for both lanes (the Workbench tab and the
+ * agent turn), split out of work.mjs because the agent lane called the
+ * classifier without the runtime and init evidence it needs (SOLID F001): a
+ * successful Claude answer that mentioned "session … not found" re-ran the
+ * whole card in a fresh conversation after the first run had already
+ * committed. The evidence is now part of the call's shape, not a default.
+ */
+
+/**
+ * A RESUME THAT FOUND NO CONVERSATION, in the CLI's own words.
+ *
+ * "Produced nothing" was the only signal the retry backstop had, and it is not
+ * the signal these failures give: Claude Code answers a dead `--resume` id with
+ * a result event carrying `errors: ['No conversation found with session ID: …']`
+ * AND writes the same line to stderr, so `out` is non-empty, the backstop never
+ * fired, and the turn SETTLED SUCCESSFULLY with the error as its answer. Every
+ * later message in that tab replied the same way — the marker file still held
+ * the dead id, nothing rewrote it (that only happens when an init event is
+ * seen, and there is none), and no surface offered a way to clear it. A tab
+ * bricked forever by its own CLI pruning its history, which it does on its own
+ * schedule.
+ *
+ * Matched on the CLI's phrasing rather than a code, because neither runtime
+ * gives one. Deliberately narrow: it must not swallow a rate limit or a
+ * permission refusal, both of which are real answers that should stand.
+ */
+const RESUME_LOST = [
+  /no conversation found/i,
+  /no session found/i,
+  /session .{0,80}not found/i,
+  /conversation .{0,80}not found/i,
+  /thread .{0,80}not found/i,
+  /trajectory not found/i,
+];
+/**
+ * …BUT ONLY WHEN THE CLI SAID IT, NOT WHEN THE REPLY DID (2026-09-24).
+ *
+ * Under `answerFromResult` a SUCCESSFUL turn's `out` is Claude's reply, and the
+ * patterns above were tested against all of it — so "the session cookie was not
+ * found because SameSite dropped it" threw away a real answer and re-ran the
+ * same message in a fresh, context-free conversation, whose init id then
+ * re-pinned the tab: the first run's edits and commits had already happened,
+ * the second repeated or misread them, and the tab's history was gone for good.
+ * Web debugging talk says "session … not found" all day.
+ *
+ * So the text alone is never the evidence. Claude Code emits `system.init` on
+ * EVERY turn that reached a conversation, and a dead `--resume` id fails before
+ * one is emitted — so for Claude, a lost conversation is the phrase AND no init
+ * event. Codex and agy give no such marker to this caller, so for them the
+ * phrase must BE the reply: a short line, the shape a CLI error takes, never a
+ * paragraph that happens to contain it.
+ */
+export const RESUME_LOST_MAX_CHARS = 400;
+export const resumeConversationLost = (text, { runtime, sawInit } = {}) => {
+  const t = String(text || '').trim();
+  if (!t || !RESUME_LOST.some((re) => re.test(t))) return false;
+  // Claude's evidence is the init event, and it must be SAID: a caller that
+  // passes no `sawInit` measured nothing, and an unmeasured init never
+  // authorises a second run of a turn that may already have committed.
+  if (runtime === 'claude') return sawInit === false;
+  // A caller that named no CLI measured nothing either.
+  if (typeof runtime !== 'string' || !runtime) return false;
+  return t.length <= RESUME_LOST_MAX_CHARS;
+};
+
+/**
+ * WHETHER A RESUMED TURN RUNS ONCE MORE FRESH — both lanes' whole question.
+ *
+ * A resume that came back EMPTY, or with only the CLI saying the conversation
+ * is gone. `sawInit` is whether THIS spawn's CLI emitted `system.init` (only
+ * Claude's does, and only Claude's is read). A fresh turn is never retried:
+ * `resume` false answers false whatever the text says.
+ */
+export const resumeRetriesFresh = ({ resume, out, runtime, sawInit }) =>
+  Boolean(resume) && (!String(out || '').trim() || resumeConversationLost(out, { runtime, sawInit }));
+
+/**
+ * ONE SPAWN, AND AT MOST ONE FRESH RETRY — the agent lane's whole sequence,
+ * with the init evidence measured HERE rather than by a flag each caller must
+ * remember to set and reset (the bug F001 was: the lane asked the rule
+ * without it). `onInit` is wrapped, so a caller's own init handler still runs;
+ * the retry is a fresh conversation (`resume: false`, no pinned thread) in the
+ * same place, and `beforeFresh` lets the caller drop what the first spawn
+ * taught it. `runTurn` is the caller's (runTurn.mjs); this module imports
+ * nothing.
+ *
+ * The Workbench tab keeps its own sequence: its evidence is the session id it
+ * persists, and a fresh retry must NOT clear it (last write heals the marker).
+ */
+export async function runTurnResumingOnce(runTurn, args, { resume, runtime, beforeFresh } = {}) {
+  let sawInit = false;
+  const callerInit = args.onInit;
+  const measured = {
+    ...args,
+    onInit: (i) => {
+      sawInit = true;
+      callerInit?.(i);
+    },
+  };
+  const out = await runTurn({ ...measured, resume });
+  if (!resumeRetriesFresh({ resume, out, runtime, sawInit })) return out;
+  beforeFresh?.();
+  sawInit = false;
+  return runTurn({ ...measured, resume: false, resumeThreadId: undefined });
+}