@worca/app 1.3.0 → 1.4.0

package/src/core/run-harness.mjs

@@ -17,7 +17,7 @@ import { EventEmitter } from 'node:events';
 import { spawn } from 'node:child_process';
 import { homedir } from 'node:os';
 import { fileURLToPath } from 'node:url';
-import { join, basename, resolve, sep, relative } from 'node:path';
+import { join, basename, dirname, resolve, sep, relative } from 'node:path';
 import { existsSync, readdirSync, readFileSync } from 'node:fs';
 import { readFile, writeFile, readdir, mkdir, realpath, rename } from 'node:fs/promises';
 
@@ -40,8 +40,8 @@ import {
   pipelineCostLimitUsd, totalCostLimitUsd, costLimitResetPeriod,
   memoryCaps,
 } from './settings.mjs';
-import { mountDirs, mountMemory, syncBack, memoryTotals, validateMemoryScope, withStoreLock, memoryMountPath, MEMORY_RULES_REL, MEMORY_INJECTED_ENTRY } from './memory-sync.mjs';
-import { memoryRoot, renderMemoryBlock, bumpScopeState } from './memory-store.mjs';
+import { mountDirs, mountMemory, refreshMount, syncBack, memoryTotals, validateMemoryScope, withStoreLock, memoryRulesPath, memoryWorkPath, MEMORY_RULES_REL, MEMORY_INJECTED_ENTRY } from './memory-sync.mjs';
+import { memoryRoot, renderMemoryBlock, bumpScopeState, readScopeState, memoryScopeReport, renderDefragBrief } from './memory-store.mjs';
 import { readCostCapOverride, totalWindowSpendUsd, costWindowStart, recordCostDelta } from './cost-budget.mjs';
 import {
   writeRunManifest, readRunManifest, updateRunManifest, rmGuarded, rescueModifiedMounts,
@@ -55,7 +55,8 @@ import {
   probeClaudeCapabilities, explainUnspawnableClaude,
 } from './preflight.mjs';
 import { fanoutCap, mapWithCap } from './fanout.mjs';
-import { resolveStepModels, observeModelCost, resolveModelCost, modelCostConfig } from './config.mjs';
+import { resolveStepModels, observeModelCost, resolveModelCost, modelCostConfig, readTeamMetricsPrefs } from './config.mjs';
+import { bridgeCallsFor, forgetBridgeTag } from './bridge/telemetry.mjs';
 import { readGuardrailSet } from './guardrail-store.mjs';
 import { unionGuardrails, guardrailsToPermissionRules, mergePermissionRules } from './guardrails.mjs';
 import { collectRequiredSkills, validateSkills, injectSkills, pluginSkillDirs } from './skills.mjs';
@@ -71,27 +72,27 @@ import {
   REASON, pauseConsequences, describePauseReason,
 } from './failure-policy.mjs';
 import { recordRunMetrics } from './metrics/record.mjs';
+// Team policy (team-policy design §6–§7): the document a run's cost gates fold in, its
+// per-run state, and the off-policy findings the run log names at start.
+import { resolveProjectPolicy, resolveWorkspacePolicy } from './policy/sync.mjs';
+import { fieldsForRun, effectiveCap, deviationsFor } from './policy/effective.mjs';
+import { writePolicyState, hasPipelineOverride, readTotalAck } from './policy/state.mjs';
+import { installedPluginsMap, WORCA_VERSION as POLICY_WORCA_VERSION } from './policy/local.mjs';
+import { readSettings as readRawSettings } from './settings.mjs';
 
 // worca-cc repo root; holds skills/. fileURLToPath, never URL.pathname: the
 // latter is `/C:/…` on Windows and %-encoded everywhere (see DEFAULT_AGENTS_DIR
 // in agent-registry.mjs, which is the single source for the built-in agents dir).
 const REPO_ROOT = fileURLToPath(new URL('../../', import.meta.url));
 
-/**
- * §9.4 message enrichment: does a DISABLED plugin ship this agent key? Scans
- * lock entries with enabled === false, reading key fields from each plugin's
- * current/agents/*.meta.json. Returns the plugin name or null. try/catch
- * throughout: no resolvable home / no lock / broken current => null (callers
- * fall back to the generic "not installed" message).
- * @param {string} key
- * @returns {string|null}
- */
-function findDisabledPluginFor(key) {
+/** The disabled plugin that ships `<subdir>/<key>.meta.json`, or null. Shared by the
+ *  agent preflight (`agents`) and the orchestrator's script preflight (`scripts`). */
+export function findDisabledPluginFor(key, subdir = 'agents') {
   try {
     const lock = readPluginsLock();
     for (const name of Object.keys(lock).sort()) {
       if (!lock[name] || lock[name].enabled !== false) continue;
-      const dir = join(pluginCurrentDir(name), 'agents');
+      const dir = join(pluginCurrentDir(name), subdir);
       let files;
       try { files = readdirSync(dir); } catch { continue; }
       for (const f of files) {
@@ -318,6 +319,18 @@ function describeToolResults(raw) {
   return lines;
 }
 
+/** The tools whose `file_path` can be a memory write. */
+const MEMORY_WRITE_TOOLS = new Set(['Write', 'Edit', 'MultiEdit', 'NotebookEdit']);
+
+/** The human text of a tool_result block: a string, or the first text block; `<tool_use_error>`
+ *  tags stripped (the CLI wraps some errors in them). '' when there is none. */
+function toolResultText(block) {
+  const c = block?.content;
+  const raw = typeof c === 'string' ? c
+    : Array.isArray(c) ? (c.find((x) => x?.type === 'text' && typeof x.text === 'string')?.text || '') : '';
+  return raw.replace(/<\/?tool_use_error>/g, '').trim();
+}
+
 /** A short, human-readable target for a tool call (file, command, pattern…). */
 function toolTarget(name, input, projectDir) {
   if (!input || typeof input !== 'object') return '';
@@ -544,6 +557,9 @@ export function scrubErrorRows(snapshot) {
  * questions with their first option so downstream never sees gaps.
  */
 export function normalizeClarifyAnswer(payload, questions) {
+  // A form answer is `{form, version, values}` and is NEVER flattened here: the
+  // "fill with the first option" fallback below is legacy-kind only (spec §5).
+  if (payload && typeof payload === 'object' && typeof payload.form === 'string' && payload.values) return [];
   const arr = Array.isArray(payload?.answers)
     ? payload.answers
     : Array.isArray(payload)
@@ -677,7 +693,9 @@ export class RunHarness extends EventEmitter {
     this.pauseDetail = null;                 // the human detail behind pauseReason ('error': the clipped message)
     // Team metrics (§4.4 interventions). Resume runs on a NEW instance, so the counters are
     // stamped into the persisted resume point at every pause and re-seeded in resume().
-    this._metricsIv = { questions: 0, pauses: 0, resumes: 0, lastPauseReason: null, lastPauseDetail: null };
+    // pausedMs: time the run spent parked (paused, or dead between a crash and its resume);
+    // pausedAt: the pause stamp resume() measures from (null while running).
+    this._metricsIv = { questions: 0, pauses: 0, resumes: 0, pausedMs: 0, pausedAt: null, lastPauseReason: null, lastPauseDetail: null };
     this._metricsRecorded = false;
     this._setupDone = false;                 // run()/resume() flip this right before _engineRun (setup replay)
     this._rehydrated = true;                 // resume() clears this until the paused run is rehydrated (the 'resume' site)
@@ -699,12 +717,17 @@ export class RunHarness extends EventEmitter {
     this._askTail = null;       // serializes _ask: ONE prompt open at a time (recovery + step questions)
     this._recoverySeq = 0;      // monotonic id source for recovery prompts (determinism-safe)
     this.agentPrompts = null;
-    this.memory = null;          // { root, mount, dirs, baseline } after _mountMemory
+    this.memory = null;          // { root, mount, rules, dirs, baseline } after _mountMemory — mount = the WRITABLE copy (<pipeline.dir>/memory), rules = the read-only copy (<runCwd>/.claude/rules/worca)
     this.memoryBlock = '';       // the ## Worca memory pointer block, rendered once per mount (files load natively — no per-spawn re-render)
     this.memoryChanges = [];     // Change[] — the durable ledger's `changes`
     this._memoryWarned = new Set();
     this._memoryTail = null;     // per-run sync chain: one syncBack at a time (F1)
+    // Failed-write bookkeeping (memory-write-split design §4): executionId -> { calls: Map<toolUseId, key>,
+    // last: Map<key.id, { ...key, ok, reason }> }. Filled by _trackMemoryWrites from every stream frame,
+    // drained by _takeFailedMemoryWrites at sync time.
+    this._memoryWrites = new Map();
     this._ledgerSeq = 0;         // monotonic: two ledger writes must never share a temp name
+    this._pendingAudits = [];    // audit lines an engine hook queued before the pipeline dir existed (_resolveTopology runs first); run() appends them right after "Pipeline created"
     this.toolInstruction = '';
     // Cap for the in-worktree graphify build (macOS has no timeout(1)).
     // Resolution order: constructor option → WORCA_GRAPH_TIMEOUT_MS env → 120s.
@@ -749,7 +772,8 @@ export class RunHarness extends EventEmitter {
       // detached run throws TypeError on the first this.state.branches[key] = … .
       branches: {},
       checkpointRefs: {},
-      memoryMount: null, // <runCwd>/.claude/rules/worca after _mountMemory (native rules: inside every spawn's cwd)
+      memoryMount: null, // <pipeline.dir>/memory after _mountMemory — the WRITABLE copy agents edit (--add-dir on every spawn)
+      memoryRules: null, // <runCwd>/.claude/rules/worca — the read-only copy the CLI loads natively
       pauseReason: null,   // mirrors this.pauseReason so getState() (a deep clone of state) carries it live
       pauseDetail: null,   // mirrors this.pauseDetail
       // Sub-agent lifecycle records (rides the existing `state` snapshot; mirrored to
@@ -777,15 +801,29 @@ export class RunHarness extends EventEmitter {
       return false;
     }
     if (pq.validate) {
-      // A question that carries a validator (the Auto proposal) stays OPEN on a
-      // malformed payload (spec §5.4); the awaiting code receives the CLEAN value.
-      const clean = pq.validate(payload);
-      if (clean == null) {
+      const out = pq.validate(payload);
+      // Two validator flavours, deliberately: the Auto proposal's returns the
+      // CLEAN value or null (§5.4 — the question stays open, silently), while a
+      // form's gate 3 returns a RESULT OBJECT carrying the field errors that
+      // POST /api/answer owes the client as 422. Only the latter throws.
+      if (out && typeof out === 'object' && typeof out.ok === 'boolean') {
+        if (!out.ok) {
+          this._log('orchestrator', 'warn', `answer() rejected: invalid answer for ${id} — the question stays open`);
+          const err = new Error('invalid answer');
+          err.code = 'INVALID_ANSWER';
+          err.errors = Array.isArray(out.errors) ? out.errors : [];
+          throw err;
+        }
+        this.pendingQuestion = null;
+        pq.resolve(out.payload);
+        return true;
+      }
+      if (out == null) {
         this._log('orchestrator', 'warn', `answer() ignored: malformed payload for ${id} — the question stays open`);
         return false;
       }
       this.pendingQuestion = null;
-      pq.resolve(clean);
+      pq.resolve(out);
       return true;
     }
     this.pendingQuestion = null;
@@ -957,6 +995,7 @@ export class RunHarness extends EventEmitter {
       this.state.tools = tools;
       this.stepModels = stepModels;
       await this._resolveGuardrails();
+      await this._resolvePolicy();
       this._log(
         'preflight',
         'info',
@@ -1063,6 +1102,7 @@ export class RunHarness extends EventEmitter {
           `Preflight: using **${tools.tool}**${tools.kind ? ` (${tools.kind})` : ''}.`,
         );
       }
+      for (const line of this._pendingAudits.splice(0)) await appendAudit(this.pipeline.dir, line);
 
       // 3) Ensure a git repo + checkpoint commit (per member on a workspace run).
       if (this.isWorkspace) await this._ensureGitCheckpointAll();
@@ -1141,8 +1181,10 @@ export class RunHarness extends EventEmitter {
         await this._assembleContext(resolvedSkills);
       }
       this._checkAbort();
-      // 3f) Agent memory: mount the store into <runCwd>/.claude/rules/worca — the CLI loads it
-      // natively — and render the pointer block every spawn carries. Pure fs work, both modes,
+      // 3f) Agent memory: mount the store twice — the read-only rules copy into
+      // <runCwd>/.claude/rules/worca (the CLI loads it natively) and the writable copy into
+      // <pipeline.dir>/memory (every spawn's --add-dir; the sync-back reads it) — and render the
+      // pointer block every spawn carries, naming the writable copy. Pure fs work, both modes,
       // mock included. AFTER 3e: the assembly rewrites injectedPaths and the mount registers
       // itself into that map.
       await this._mountMemory();
@@ -1315,7 +1357,21 @@ export class RunHarness extends EventEmitter {
       this.state.stepper = safeParse(row.stepper);
       this.state.tools = safeParse(row.tools);
       this.state.branch = safeParse(row.branch);
-      this.state.steps = (steps || []).map((s) => ({ ...s, runningSince: null }));
+      // Parked time (autonomy = active ÷ (wall − paused)). A paused row is measured from the
+      // stamp _completePaused wrote into the point; an interrupted row from the last heartbeat
+      // (the last time the dead process was seen alive — reconcileStaleRunning keeps it for
+      // this). A point written before the stamp existed falls back to the row's updated_at.
+      // The same anchor closes every step clock a crash left running: the tail up to the
+      // anchor is real work that the crash never folded, the rest of the gap is parked.
+      const iv = rp.interventions && typeof rp.interventions === 'object' ? rp.interventions : {};
+      const anchor = Date.parse(row.status === 'interrupted' ? (row.heartbeat_at || row.updated_at) : (iv.pausedAt || row.updated_at));
+      const now = Date.now();
+      const parkedMs = Number.isFinite(anchor) ? Math.max(0, now - anchor) : 0;
+      this.state.steps = (steps || []).map((s) => {
+        if (s.runningSince == null || !Number.isFinite(anchor)) return { ...s, runningSince: null };
+        return { ...s, activeMs: (s.activeMs || 0) + Math.max(0, Math.min(anchor, now) - s.runningSince), runningSince: null };
+      });
+      this.state.totalActiveMs = sumStepActive(this.state.steps);
       this.baseName = row.base_name;
       this.planDatePrefix = row.date_prefix;
       this.pipeline = { id: row.id, dir: rp.pipelineDir, promptText: row.prompt || '' };
@@ -1325,10 +1381,10 @@ export class RunHarness extends EventEmitter {
       this.stepModels = rp.stepModels || null;
       this.workflowId = rp.workflowId || this.workflowId;
       // Pauses are counted only in _completePaused, so a crash-resume of an `interrupted`
-      // run adds a resume but no pause (§4.4 decision 6).
-      const iv = rp.interventions && typeof rp.interventions === 'object' ? rp.interventions : {};
+      // run adds a resume but no pause (§4.4 decision 6). The stamp is consumed here.
       this._metricsIv = {
         questions: iv.questions | 0, pauses: iv.pauses | 0, resumes: (iv.resumes | 0) + 1,
+        pausedMs: (Number.isFinite(iv.pausedMs) ? iv.pausedMs : 0) + parkedMs, pausedAt: null,
         lastPauseReason: iv.lastPauseReason ?? null, lastPauseDetail: iv.lastPauseDetail ?? null,
       };
       // The saved point carries the pause that produced it; a resumed run is running.
@@ -1340,6 +1396,7 @@ export class RunHarness extends EventEmitter {
       this.guardrailsId = rp.guardrailsId || this.guardrailsId;
       this.state.guardrailsId = this.guardrailsId;
       await this._resolveGuardrails();
+      await this._resolvePolicy();
       // Restore the EFFECTIVE instruction from the resume point — by dispatch time
       // run() has replaced the detect-time tools.instruction with the in-worktree
       // graph-build outcome (worktreeGraphInstruction() or ''). Falling back to
@@ -1738,6 +1795,74 @@ export class RunHarness extends EventEmitter {
    * LATEST definition. A missing/deleted set fails OPEN to the Permissive
    * (empty) policy with a loud warn — never an abort.
    */
+  /**
+   * Team policy (design §6, §9): the document that governs this run, folded for its kind
+   * (workspaceRuns for a workspace target), plus the off-policy findings the run log names
+   * once. Cache-first: only a project with no cache at all pays one bounded fetch. A missing,
+   * unreadable or unsupported policy means local settings apply — loudly, never an abort.
+   * Sets `this.policyRun` = { home, sha, fields, deviations, unattended } or null.
+   */
+  async _resolvePolicy() {
+    this.policyRun = null;
+    this._policyPersisted = false;
+    this._policyWarned = new Set();
+    let r;
+    try {
+      r = this.isWorkspace
+        ? await resolveWorkspacePolicy(this.workspace?.id, { discover: 'if-missing' })
+        : await resolveProjectPolicy(this.projectDir, { discover: 'if-missing' });
+    } catch (err) {
+      this._log('policy', 'warn', `team policy could not be read (${err?.message || err}); your local settings apply`);
+      return;
+    }
+    if (!r.ok) {
+      if (r.reason === 'delegate-invalid' || r.reason === 'home-stale' || r.reason === 'unsupported' || r.code === 'DOC_UNKNOWN') {
+        this._log('policy', 'warn', `team policy not applied — ${r.detail || r.reason}; your local settings apply`);
+      }
+      return;
+    }
+    const fields = fieldsForRun(r.doc, { workspaceRun: this.isWorkspace });
+    let installed = {};
+    try { installed = installedPluginsMap(); } catch { /* no plugins root yet */ }
+    let metricsRecord = null;
+    try { const tm = readTeamMetricsPrefs(projectKey(this.projectDir)); metricsRecord = tm ? tm.record !== false : null; } catch { /* optional */ }
+    const stepModels = Object.entries(this.stepModels || {}).map(([role, sel]) => ({ role, model: sel?.model }));
+    const deviations = deviationsFor(fields, {
+      guardrailsId: this.guardrailsId, guardrailSet: this.guardrails ? { settings: this.guardrails } : null,
+      stepModels, installed, worcaVersion: POLICY_WORCA_VERSION, metricsRecord,
+    });
+    this.policyRun = { home: r.home, homeDir: r.homeDir, sha: r.sha, fields, deviations: deviations.map((d) => d.code), unattended: !!this.auto };
+    for (const w of r.warnings || []) this._log('policy', 'warn', `team policy ${r.home}: ${w}`);
+    const cap = fields['cost.pipelineLimitUsd'];
+    const tot = fields['cost.totalLimitUsd'];
+    const caps = [cap ? `pipeline cap $${Number(cap.value).toFixed(2)} (${cap.kind}${cap.kind === 'soft' ? `, ${cap.onBreach || 'pause'}` : ''})` : null,
+      tot ? `total cap $${Number(tot.value).toFixed(2)} (${tot.kind})` : null].filter(Boolean).join(' · ');
+    this._log('policy', 'info', `team policy ${r.home}${r.sha ? ` @ ${String(r.sha).slice(0, 7)}` : ''}${r.delegated ? ` (followed by ${r.from})` : ''}${this.isWorkspace && Object.keys(r.doc.workspaceRuns || {}).length ? ' · workspace-run values' : ''}${caps ? ` · ${caps}` : ''}`);
+    for (const d of deviations) this._log('policy', d.level === 'warn' ? 'warn' : 'info', `off-policy: ${d.text}`);
+    if (this.auto && ((cap?.kind === 'soft' && (cap.onBreach || 'pause') === 'pause') || (tot?.kind === 'soft' && (tot.onBreach || 'pause') === 'pause'))) {
+      this._log('policy', 'info', 'unattended run: a team soft cap warns instead of pausing (nobody can click "continue past")');
+    }
+    // Workspace runs never union member policies (design §6): say so once when a member is tighter.
+    if (this.isWorkspace && cap) {
+      for (const m of this.members || []) {
+        try {
+          const mr = await resolveProjectPolicy(m.projectDir, { discover: false });
+          if (!mr.ok || mr.home === r.home) continue;
+          const mc = fieldsForRun(mr.doc)['cost.pipelineLimitUsd'];
+          if (mc && mc.value < cap.value) this._log('policy', 'info', `member ${mr.from} carries a tighter pipeline cap ($${Number(mc.value).toFixed(2)}, ${mr.home}); the workspace policy applies to this run`);
+        } catch { /* informational only */ }
+      }
+    }
+  }
+
+  /** First persist of the run's policy state (needs the pipeline row); later writes merge. */
+  _persistPolicyState(patch = {}) {
+    if (!this.pipeline?.id || !this.policyRun) return;
+    const base = this._policyPersisted ? {} : { home: this.policyRun.home, sha: this.policyRun.sha, deviations: this.policyRun.deviations, unattended: this.policyRun.unattended };
+    this._policyPersisted = true;
+    try { writePolicyState(this.pipeline.id, { ...base, ...patch }); } catch (err) { this._log('policy', 'warn', `could not record policy state: ${err?.message || err}`); }
+  }
+
   async _resolveGuardrails() {
     let set = await readGuardrailSet(this.guardrailsId || 'permissive');
     if (!set) {
@@ -1858,7 +1983,7 @@ export class RunHarness extends EventEmitter {
     if (!this.pipeline?.dir) return;
     try { await this._mountMemoryUnguarded({ resume }); }
     catch (err) {
-      this.memory = null; this.memoryBlock = ''; this.state.memoryMount = null;
+      this.memory = null; this.memoryBlock = ''; this.state.memoryMount = null; this.state.memoryRules = null;
       if (existsSync(this._memoryLedgerPath())) await this._writeMemoryLedger({ neutralised: true });
       const why = String(err?.message || err).split('\n')[0];
       // A defragment run IS its mount (B8): rethrow, and run()'s setup failure policy parks the run
@@ -1874,9 +1999,11 @@ export class RunHarness extends EventEmitter {
   }
 
   /**
-   * Mount the memory store into this run at `<runCwd>/.claude/rules/worca` — INSIDE the cwd of
-   * every spawn, where Claude Code discovers rules natively (run root on a detached workspace
-   * run, the primary worktree otherwise). Always recomputed, never the ledger's absolute path.
+   * Mount the memory store into this run twice: the read-only rules copy at
+   * `<runCwd>/.claude/rules/worca` (where Claude Code discovers rules natively — run root on a
+   * detached workspace run, the primary worktree otherwise) and the writable copy at
+   * `<pipeline.dir>/memory` (the sync-back mount, outside every checkout). Always recomputed,
+   * never the ledger's absolute paths.
    * On resume, the previous segment's ledger is read first and its mount is synced back BEFORE
    * anything else (§5 "resume of a paused run"): the sync is pure fs and needs neither git nor
    * the tracked guard, so a guard that fails only NOW (git broken, the previous segment's agent
@@ -1884,10 +2011,15 @@ export class RunHarness extends EventEmitter {
    */
   async _mountMemoryUnguarded({ resume }) {
     const root = memoryRoot();
-    // Pre-setup there is no run cwd, and the LIVE checkout must never take a mount.
+    // Pre-setup there is no run cwd, and the LIVE checkout must never take a rules copy.
     const cwd = this.runCwd || null;
     if (!cwd || cwd === this.projectDir) throw new Error('no run cwd to mount into');
-    const mount = memoryMountPath(cwd);
+    if (!this.pipeline?.dir) throw new Error('no pipeline dir for the writable memory copy');
+    // Two copies (memory-write-split design D1): the READ-ONLY rules copy inside the cwd, where Claude
+    // Code loads it and refuses every write (`.claude` is a protected path); the WRITABLE copy — the
+    // sync-back mount — under the pipeline dir, outside every checkout, reached by --add-dir.
+    const rules = memoryRulesPath(cwd);
+    const mount = memoryWorkPath(this.pipeline.dir);
     // §8.8 scope of the record: 'runRoot' when the cwd IS the run root, else the member whose
     // checkout is the cwd (the primary member on single and legacy-workspace runs).
     const scope = (this.runRoot && cwd === this.runRoot) ? 'runRoot'
@@ -1900,9 +2032,9 @@ export class RunHarness extends EventEmitter {
       try { ledger = JSON.parse(await readFile(this._memoryLedgerPath(), 'utf8')); } catch { ledger = null; }
       if (ledger && ledger.baseline && Array.isArray(ledger.dirs)) {
         this.memoryChanges = Array.isArray(ledger.changes) ? ledger.changes : [];
-        // A run paused BEFORE the native-rules revision still has its files at the ledger's
-        // old path (<pipeline.dir>/memory): sync THAT dir once, so nothing the interrupted
-        // execution wrote is lost; the recomputed path is used from here on.
+        // The interrupted segment's writes live at the LEDGER's mount: this dir since the write
+        // split, the in-checkout `.claude/rules/worca` for a run paused before it (a pause keeps the
+        // checkout, so that dir is still there). Sync whichever exists; the recomputed paths are used from here on.
         const prev = (typeof ledger.mount === 'string' && ledger.mount !== mount && existsSync(ledger.mount)) ? ledger.mount : mount;
         try {
           await this._syncMemoryWith({ mount: prev, dirs: ledger.dirs, baseline: ledger.baseline, nodeId: 'resume', executionId: null, agentKey: null, label: 'the interrupted execution' });
@@ -1911,12 +2043,11 @@ export class RunHarness extends EventEmitter {
           // through onError). If it ever does: do NOT remount over unsynced writes; keep the
           // PREVIOUS mount + baseline so the next execution's sync retries them.
           this._log('memory', 'warn', `memory: the interrupted execution's writes could not be synced (${err?.message || err}); keeping the previous mount`);
-          this.memory = { root, mount: prev, dirs: ledger.dirs, baseline: ledger.baseline };
-          this.state.memoryMount = prev;
-          // Register ONLY when the kept mount is the one inside this run's cwd: a mount there must
-          // stay excluded from the commit and removed at teardown, while the pre-revision
-          // <pipeline.dir>/memory path is outside every checkout and needs no §8.8 record.
-          if (prev === mount) await this._registerMemoryMount(scope);
+          this.memory = { root, mount: prev, rules: null, dirs: ledger.dirs, baseline: ledger.baseline };
+          this.state.memoryMount = prev; this.state.memoryRules = null;
+          // Register in every case: the rules copy of the interrupted segment (if any) is still inside
+          // the checkout and must stay excluded from the commit and removed at teardown. Idempotent.
+          await this._registerMemoryMount(scope);
           this._refreshMemoryBlock();
           return;
         }
@@ -1938,16 +2069,20 @@ export class RunHarness extends EventEmitter {
     // EBUSY past the retries) leaves files under the cwd, and only the §8.8 entry keeps them out
     // of the commit and gets them removed at teardown. Idempotent, harmless on failure.
     await this._registerMemoryMount(scope);
-    // gitIgnore: the mount now lives INSIDE a checkout an AGENT runs git in. `<mount>/.gitignore`
-    // = `*` makes it invisible to an agent's own `git add -A`, to a staging pre-commit hook, to
-    // snapshotWorktreePatch's bare `git add -A` and to the reviewer's `git status`. The §8.8
-    // `:(exclude)` pathspec stays as defence in depth. Harmless at a non-git run root.
-    const m = await mountMemory({ root, mount, dirs, onError, gitIgnore: true });
-    this.memory = { root, mount, dirs, baseline: m.baseline };
+    // The WRITABLE copy: a full copy of the mounted scopes (agents edit existing files in place;
+    // syncBack diffs it against this baseline). Outside git — no sentinel.
+    const m = await mountMemory({ root, mount, dirs, onError });
+    // The READ-ONLY rules copy: the same files where the CLI discovers them. Its baseline is
+    // irrelevant (nothing syncs back from it). `<rules>/.gitignore` = `*` keeps it out of an agent's
+    // own `git add -A`, a staging pre-commit hook, snapshotWorktreePatch's bare `git add -A` and the
+    // reviewer's `git status`; the §8.8 `:(exclude)` pathspec stays as defence in depth.
+    await mountMemory({ root, mount: rules, dirs, onError, gitIgnore: true });
+    this.memory = { root, mount, rules, dirs, baseline: m.baseline };
     this.state.memoryMount = mount;
+    this.state.memoryRules = rules;
     this._refreshMemoryBlock();
     await this._writeMemoryLedger();
-    this._log('memory', 'info', `Memory mounted at ${mount}: ${m.files} file(s) across ${dirs.length} scope(s)`);
+    this._log('memory', 'info', `Memory mounted: ${m.files} file(s) across ${dirs.length} scope(s) — loaded from ${rules}, written to ${mount}`);
   }
 
   /**
@@ -1996,8 +2131,11 @@ export class RunHarness extends EventEmitter {
     if (!this.memory) return Promise.resolve(null);
     const job = async () => {
       if (!this.memory) return null;
+      // Every frame of the execution has arrived (the runner resolved before _afterExecution); a
+      // null executionId is the run-end sync and drains what unfinished executions left behind.
+      const failed = this._takeFailedMemoryWrites(ctx.executionId ?? null);
       try {
-        return await this._syncMemoryWith({ ...this.memory, nodeId: ctx.nodeId, executionId: ctx.executionId, agentKey: nc?.key ?? null, label: nc?.key || ctx.label || ctx.nodeId });
+        return await this._syncMemoryWith({ ...this.memory, nodeId: ctx.nodeId, executionId: ctx.executionId, agentKey: nc?.key ?? null, label: nc?.key || ctx.label || ctx.nodeId, failed });
       } catch (err) {
         this._log('memory', 'warn', `memory sync failed after ${ctx.executionId}: ${err?.message || err}`);
         return null;
@@ -2007,7 +2145,7 @@ export class RunHarness extends EventEmitter {
     return this._memoryTail;
   }
 
-  async _syncMemoryWith({ mount, dirs, baseline, nodeId, executionId, agentKey, label }) {
+  async _syncMemoryWith({ mount, dirs, baseline, nodeId, executionId, agentKey, label, failed = [] }) {
     const now = new Date().toISOString();
     const res = await syncBack({
       root: memoryRoot(), mount, dirs, baseline, source: `${this.memoryScope ? 'defrag' : 'run'}:${this.pipeline.id}`, now,
@@ -2018,26 +2156,119 @@ export class RunHarness extends EventEmitter {
     // an OLD instance can never race a resumed one because the scheduler drains in-flight
     // executions before the run reports 'paused' (scheduler.mjs, the pause drain).
     if (this.memory && this.memory.mount === mount) this.memory.baseline = res.baseline;
-    if (res.total || res.rejected.length) {
+    if (res.total || res.rejected.length || failed.length) {
       this.memoryChanges.push({
         executionId, nodeId, agentKey, at: now,
-        added: res.added, modified: res.modified, deleted: res.deleted, rejected: res.rejected,
+        added: res.added, modified: res.modified, deleted: res.deleted, rejected: res.rejected, failed,
       });
       const head = `Memory: +${res.added.length} ~${res.modified.length} -${res.deleted.length}` +
-        `${res.rejected.length ? ` (${res.rejected.length} rejected)` : ''} by ${label}`;
-      const name = (r) => `${r.scope}/${r.name}.md`;
+        `${res.rejected.length ? ` (${res.rejected.length} rejected)` : ''}${failed.length ? ` (${failed.length} failed)` : ''} by ${label}`;
+      const name = (r) => `${r.scope ? `${r.scope}/` : ''}${r.name}.md`;
       const details = [
         ...res.added.map((r) => `added ${name(r)}`), ...res.modified.map((r) => `updated ${name(r)}`),
         ...res.deleted.map((r) => `deleted ${name(r)}`), ...res.rejected.map((r) => `rejected ${name(r)} — ${r.reason}`),
+        ...failed.map((r) => `failed ${name(r)} — ${r.reason}`),
       ];
       this._log('memory', 'info', `${head}: ${details.join('; ')}`, { nodeId, executionId });
+      // A failed write is the one memory outcome nobody asked for: warn, per file, so it is visible in
+      // the run log without opening the 300 KB transcript.
+      for (const r of failed) this._log('memory', 'warn', `memory: ${name(r)} written by ${label} never reached the store — ${r.reason}`, { nodeId, executionId });
       await appendAudit(this.pipeline.dir, `${head}: ${details.join('; ')}`).catch(() => {});
+      await this._recordFailedWrites(failed, now);
+    }
+    // The rules copy the NEXT execution loads must carry what this sync stored (the store is the
+    // authority: it also holds Ask/UI writes made mid-run). Non-destructive and per-file atomic, so
+    // a Task sub-agent spawning right now never reads a torn file; never touches the sentinel.
+    if (res.total && this.memory && this.memory.mount === mount && this.memory.rules) {
+      try {
+        const { failed: stale } = await withStoreLock(memoryRoot(), () => refreshMount({ root: memoryRoot(), mount: this.memory.rules, dirs, onError: (p, err) => this._memoryReadWarn(p, err) }));
+        if (stale.length) this._log('memory', 'warn', `memory: the rules copy could not be refreshed for ${stale.join(', ')} — the next agent loads the previous text`);
+      } catch (err) {
+        this._log('memory', 'warn', `memory: the rules copy could not be refreshed: ${err?.message || err}`);
+      }
     }
     if (this.memory && this.memory.mount === mount) await this._writeMemoryLedger();
     return res;
   }
 
-  /** `{ mount, dirs, baseline, changes }` — best-effort, atomic via temp + rename. */
+  /** Bump the `.state` counters of every scope a failed write named (memory-write-split design D9).
+   *  A write beside the scope dirs (`scope: ''`, or a rel that is not mounted) is reported but counted
+   *  against no scope. Best-effort: a counter that cannot be written is a warn line, never a throw. */
+  async _recordFailedWrites(failed, now) {
+    if (!failed.length || !this.memory) return;
+    const byRel = new Map();
+    for (const f of failed) if (f.scope) byRel.set(f.scope, (byRel.get(f.scope) || 0) + 1);
+    for (const [rel, n] of byRel) {
+      const d = this.memory.dirs.find((x) => x.rel === rel);
+      if (!d) continue;
+      try {
+        await withStoreLock(memoryRoot(), async () => {
+          const st = await readScopeState(memoryRoot(), d.scope);
+          await bumpScopeState(memoryRoot(), d.scope, { failedWrites: (Number(st.failedWrites) || 0) + n, lastFailedAt: now, lastFailedRunId: this.pipeline.id });
+        });
+      } catch (err) {
+        this._log('memory', 'warn', `memory: failed-write counter not updated for ${rel}: ${err?.message || err}`);
+      }
+    }
+  }
+
+  /** Classify a tool call's target: `{ id, where, scope, name }` when it sits under the writable copy
+   *  (`where: 'memory'`) or the read-only rules copy (`where: 'rules'`), else null. `scope` is the
+   *  mounted rel the path starts with, else its dirname inside the copy ('' at the copy's root) — a
+   *  write beside the scope dirs is still reported. Relative paths resolve against the run cwd, which
+   *  is every spawn's cwd. */
+  _memoryWriteKey(p) {
+    if (typeof p !== 'string' || !p || !this.memory) return null;
+    const abs = resolve(this.runCwd || this.workDir || this.projectDir, p);
+    for (const [where, base] of [['memory', this.memory.mount], ['rules', this.memory.rules]]) {
+      if (!base || !(abs === base || abs.startsWith(base + sep))) continue;
+      const rel = relative(base, abs).split(sep).join('/');
+      const d = this.memory.dirs.find((x) => rel === x.rel || rel.startsWith(`${x.rel}/`));
+      const dn = dirname(rel);
+      return { id: `${where}:${rel}`, where, scope: d ? d.rel : (dn === '.' ? '' : dn), name: basename(rel).replace(/\.md$/i, '') };
+    }
+    return null;
+  }
+
+  _trackMemoryWrites(raw, attr) {
+    if (!this.memory) return;
+    const content = raw?.message?.content;
+    if (!Array.isArray(content)) return;
+    const exec = attr?.executionId ?? '(no execution)';
+    for (const b of content) {
+      if (b?.type === 'tool_use' && MEMORY_WRITE_TOOLS.has(b.name) && typeof b.id === 'string') {
+        const key = this._memoryWriteKey(b.input?.file_path || b.input?.path || b.input?.notebook_path);
+        if (!key) continue;
+        const rec = this._memoryWrites.get(exec) || { calls: new Map(), last: new Map() };
+        rec.calls.set(b.id, key);
+        this._memoryWrites.set(exec, rec);
+      } else if (b?.type === 'tool_result' && typeof b.tool_use_id === 'string') {
+        const rec = this._memoryWrites.get(exec);
+        const key = rec?.calls.get(b.tool_use_id);
+        if (!key) continue;
+        // 400: the CLI's refusal quotes the absolute path and ends with the cause ("… which is a
+        // sensitive file.") — a deep run-root path must not clip the cause away.
+        rec.last.set(key.id, { ...key, ok: !b.is_error, reason: b.is_error ? clip(toolResultText(b), 400) : '' });
+      }
+    }
+  }
+
+  /** The keys whose LAST write outcome in `executionId` was an error, as `[{ scope, name, reason }]`
+   *  (a retry that succeeded clears the failure); that execution's bookkeeping is dropped. `null`
+   *  drains EVERY pending execution — the run-end sync, so an execution the run never finished
+   *  (stop, error) still reports (design D13). A rules-copy write names its own cause first. */
+  _takeFailedMemoryWrites(executionId) {
+    const recs = executionId == null ? [...this._memoryWrites.values()] : [this._memoryWrites.get(executionId)].filter(Boolean);
+    if (executionId == null) this._memoryWrites.clear(); else this._memoryWrites.delete(executionId);
+    const out = [];
+    for (const rec of recs) for (const v of rec.last.values()) {
+      if (v.ok) continue;
+      out.push({ scope: v.scope, name: v.name, reason: v.where === 'rules' ? `written into the read-only rules copy — ${v.reason}` : v.reason });
+    }
+    return out;
+  }
+
+  /** `{ mount, rules, dirs, baseline, changes }` — best-effort, atomic via temp + rename. */
   async _writeMemoryLedger({ neutralised = false } = {}) {
     if (!this.pipeline?.dir || (!this.memory && !neutralised)) return;
     const file = this._memoryLedgerPath();
@@ -2045,13 +2276,29 @@ export class RunHarness extends EventEmitter {
     // no baseline, so a later resume has nothing stale to diff against (a missing mount dir
     // must never read as "the run deleted every file").
     const payload = neutralised
-      ? { mount: null, dirs: [], baseline: {}, changes: this.memoryChanges }
-      : { mount: this.memory.mount, dirs: this.memory.dirs, baseline: this.memory.baseline, changes: this.memoryChanges };
+      ? { mount: null, rules: null, dirs: [], baseline: {}, changes: this.memoryChanges }
+      : { mount: this.memory.mount, rules: this.memory.rules, dirs: this.memory.dirs, baseline: this.memory.baseline, changes: this.memoryChanges };
     const tmp = `${file}.tmp-${process.pid}-${++this._ledgerSeq}`;
     try { await writeFile(tmp, `${JSON.stringify(payload, null, 2)}\n`, 'utf8'); await rename(tmp, file); }
     catch (err) { this._log('memory', 'warn', `memory ledger not written: ${err?.message || err}`); }
   }
 
+  /** The `## Memory health` section a defragment run appends to its task document: the reasons the
+   *  scope is flagged and the budgets a finished defragment must meet — read from the STORE (what
+   *  Settings → Memory shows), which the mount mirrors at this point. '' on every other run.
+   *  Best-effort: a store read failure costs the agent its brief, never the run. */
+  async _defragBrief() {
+    if (!this.memoryScope || !this.memory?.dirs?.length) return '';
+    try {
+      const caps = memoryCaps();
+      const { health } = await memoryScopeReport(memoryRoot(), this.memory.dirs[0].scope, caps, { onError: (p, err) => this._memoryReadWarn(p, err) });
+      return renderDefragBrief(health, caps);
+    } catch (err) {
+      this._log('memory', 'warn', `memory: the defragment brief could not be built: ${err?.message || err}`);
+      return '';
+    }
+  }
+
   /** A finished defragment run resets the scope's counters (spec §5, §7): called on the `done`
    *  arms only, after _buildResults' final sync. `this.memory.dirs[0]` is the one mounted scope.
    *  Amendment B31: a run whose ledger holds ANY rejected write did not produce the scope the
@@ -2069,7 +2316,7 @@ export class RunHarness extends EventEmitter {
     }
     const now = new Date().toISOString();
     try {
-      await withStoreLock(memoryRoot(), () => bumpScopeState(memoryRoot(), d.scope, { lastDefragAt: now, lastDefragRunId: this.pipeline.id, writesSinceDefrag: 0 }));
+      await withStoreLock(memoryRoot(), () => bumpScopeState(memoryRoot(), d.scope, { lastDefragAt: now, lastDefragRunId: this.pipeline.id, writesSinceDefrag: 0, failedWrites: 0, lastFailedAt: null, lastFailedRunId: null }));
       this._log('memory', 'info', `Memory: ${d.label} defragmented — write counter reset`);
       await appendAudit(this.pipeline.dir, `Memory: ${d.label} defragmented by this run.`).catch(() => {});
     } catch (err) {
@@ -2748,27 +2995,80 @@ export class RunHarness extends EventEmitter {
    *  raised limit or a window reset takes effect at the next step (F9). */
   _checkCostLimits() {
     if (!this.pipeline?.id) return;                    // pre-createPipeline: nothing to meter
-    const pipeLimit = pipelineCostLimitUsd();
+    this._persistPolicyState();                        // first boundary with a row: home/sha/deviations land
+    const teamFields = this.policyRun?.fields || {};
+    const home = this.policyRun?.home || null;
     // resume() rehydrates state.steps but not state.totalCostUsd, so the row
     // total reads $0 until the first cost event of the resumed run. Take the
     // larger of the two so a resumed over-cap pipeline cannot run one free step.
     const spentHere = Math.max(this.state.totalCostUsd || 0, sumStepCosts(this.state.steps));
-    if (pipeLimit != null && spentHere >= pipeLimit
-        && !readCostCapOverride(this.pipeline.id)) {
+    // Team policy (design §7): the tighter of the developer's cap and a soft team cap applies;
+    // a team default only starts the developer off. `binding` says whose number tripped.
+    const teamPipe = teamFields['cost.pipelineLimitUsd'] || null;
+    const pipe = effectiveCap({ local: pipelineCostLimitUsd(), team: teamPipe });
+    // The developer's own cap (or a team DEFAULT, which is the same thing): the existing
+    // pause + the existing per-pipeline override. A team-bound fold has no "own" cap here.
+    const ownCap = pipe.binding === 'team' ? null : pipe.cap;
+    if (ownCap != null && spentHere >= ownCap && !readCostCapOverride(this.pipeline.id)) {
       this._capReached(REASON.COST_PIPELINE,
-        `pipeline cost limit reached ($${spentHere.toFixed(2)} >= $${pipeLimit.toFixed(2)})`);
+        `pipeline cost limit reached ($${spentHere.toFixed(2)} >= $${ownCap.toFixed(2)})`);
+    }
+    // The team SOFT cap, whether or not it is the tighter number: the local override never
+    // bypasses it — only the team override ("continue past team cap") does.
+    if (teamPipe && teamPipe.kind === 'soft' && spentHere >= teamPipe.value && !hasPipelineOverride(this.pipeline.id)) {
+      const detail = `team cost cap reached ($${spentHere.toFixed(2)} >= $${Number(teamPipe.value).toFixed(2)}, ${home})`;
+      this._teamCapBreach('pipeline', teamPipe, detail, REASON.COST_PIPELINE_POLICY);
     }
-    const totalLimit = totalCostLimitUsd();
-    if (totalLimit != null) {
-      const period = costLimitResetPeriod();
-      const spent = totalWindowSpendUsd(costWindowStart(new Date(), period).getTime());
-      if (spent >= totalLimit) {
-        this._capReached(REASON.COST_TOTAL,
-          `total cost limit reached ($${spent.toFixed(2)} >= $${totalLimit.toFixed(2)} this ${period === 'weekly' ? 'week' : 'month'})`);
+    const period = this._effectiveResetPeriod();
+    const tot = effectiveCap({ local: totalCostLimitUsd(), team: teamFields['cost.totalLimitUsd'] || null });
+    if (tot.cap != null) {
+      const windowStartMs = costWindowStart(new Date(), period).getTime();
+      const spent = totalWindowSpendUsd(windowStartMs);
+      if (spent >= tot.cap) {
+        const w = period === 'weekly' ? 'week' : 'month';
+        if (tot.binding === 'team') {
+          const ack = readTotalAck(projectKey(this.policyRun.homeDir || this.projectDir), home, windowStartMs);
+          if (ack) {
+            // Acknowledged once for this window (design §7): the run proceeds and the record says so.
+            if (!this._policyWarned.has('total-ack')) { this._policyWarned.add('total-ack'); this._persistPolicyState({ overrides: ['total'], ...(ack.reason ? { reason: ack.reason } : {}) }); }
+          } else {
+            const detail = `team total cap reached ($${spent.toFixed(2)} >= $${tot.cap.toFixed(2)} this ${w}, ${home})`;
+            this._teamCapBreach('total', tot.team, detail, REASON.COST_TOTAL_POLICY);
+          }
+        } else {
+          this._capReached(REASON.COST_TOTAL,
+            `total cost limit reached ($${spent.toFixed(2)} >= $${tot.cap.toFixed(2)} this ${w})`);
+        }
       }
     }
   }
 
+  /** The reset period: the developer's when stored, else a team default, else monthly. */
+  _effectiveResetPeriod() {
+    const stored = readRawSettings().costLimitResetPeriod;
+    if (stored === 'weekly' || stored === 'monthly') return stored;
+    const team = this.policyRun?.fields?.['cost.resetPeriod'];
+    return team && (team.value === 'weekly' || team.value === 'monthly') ? team.value : costLimitResetPeriod();
+  }
+
+  /**
+   * A soft team cap was hit and nobody has continued past it. `onBreach: warn`, and any
+   * unattended (--yes) run, log ONE line and go on with `exceeded` recorded; otherwise the
+   * run pauses on the policy reason so the resume flow can offer "continue past".
+   */
+  _teamCapBreach(which, team, detail, reason) {
+    const breach = team?.onBreach || 'pause';
+    if (breach === 'warn' || this.auto) {
+      if (this._policyWarned.has(which)) return;
+      this._policyWarned.add(which);
+      const why = breach === 'warn' ? 'the policy says warn' : 'unattended run, nobody can continue past a pause';
+      this._log('policy', 'warn', `${detail} — continuing: ${why}`);
+      this._persistPolicyState({ exceeded: [which] });
+      return;
+    }
+    this._capReached(reason, detail);
+  }
+
   /** The BUDGET site (failure-policy.mjs): a cost cap was reached at a step
    *  boundary. Unlike the catch-block sites this throws itself — its caller is
    *  the boundary gate. The audit line is required: _completePaused suppresses
@@ -2908,7 +3208,8 @@ export class RunHarness extends EventEmitter {
    * Freezes the active-time clock while blocked on the user (active-time-only).
    * @returns {Promise<any>} the answer payload
    */
-  async _ask({ id, kind, questions, issues, recovery, agent, nodeId, wireId, executionId, deliveryNo, holdNo, workflow, validate }) {
+  async _ask({ id, kind, questions, issues, recovery, agent, nodeId, wireId, executionId, deliveryNo, holdNo, workflow,
+    askId, form, version, title, surface, data, layout, answerSchema, fileRefs, files, autoValues, validate }) {
     this._checkAbort();
     // No interactive prompt may OPEN on a pausing run. pause() rejects only the
     // prompt that is currently open; a queued ask (a parallel sibling's questions
@@ -2940,6 +3241,15 @@ export class RunHarness extends EventEmitter {
       ...(deliveryNo != null ? { deliveryNo } : {}),
       ...(holdNo != null ? { holdNo } : {}),
       ...(workflow !== undefined ? { workflow } : {}),
+      // The ask-form envelope (spec §4, ruling X1) rides the EXISTING 'question'
+      // frame — no new transport, no new slot. `id` (already emitted above) is the
+      // ANSWER token; `askId` is the route-safe file token and they are never
+      // interchangeable. `validate` and `autoValues` are arguments only and must
+      // never reach a socket.
+      ...(kind === 'form'
+        ? { askId, form, version, title, surface: surface || 'any', data, layout, answerSchema,
+            fileRefs: fileRefs || [], files: files || [] }
+        : {}),
     });
     this._metricsIv.questions += 1;
 
@@ -2956,6 +3266,13 @@ export class RunHarness extends EventEmitter {
           this._log('orchestrator', 'info', `auto-accepting workflow proposal ${id}`);
           return { decision: 'accept' };
         }
+        if (kind === 'form') {
+          // D10: a form ask is auto-answered with the form's AUTO ANSWER, which
+          // gate 1 proved passes gate 3 — so an unattended run neither hangs nor
+          // produces an invalid answer. No pending question is installed.
+          this._log('orchestrator', 'info', `auto-answering form ${id} (${form})`);
+          return { form, version, values: autoValues && typeof autoValues === 'object' ? autoValues : {} };
+        }
         if (kind === 'clarify' || kind === 'questions') {
           this._log('orchestrator', 'info', `auto-answering ${kind} ${id}`);
           return {
@@ -3604,6 +3921,7 @@ export class RunHarness extends EventEmitter {
     const cost = costCfg
       ? resolveModelCost(attr.model, rawCost, e.raw.usage, costCfg)
       : rawCost;
+    if (isResult) this._recordBridgeCalls(attr?.stepKey, attr?.executionId);
     if (Number.isFinite(cost)) this._recordCost(cost, attr?.stepKey);
     else if (isResult && !this.claude.mock) {
       // A {perMtok} model prices from tokens alone, so a result with no usage is
@@ -3629,6 +3947,12 @@ export class RunHarness extends EventEmitter {
       } catch { /* derived state — never fail the run over it */ }
     }
 
+    // Agent memory (memory-write-split design §4): pair every Write/Edit aimed at a memory directory
+    // with its tool_result, main stream and sub-agent frames alike (same cwd, same dirs), so a write
+    // the CLI refused — or that failed for any other reason — is reported at sync time instead of
+    // vanishing. Never throws; never mutates run state.
+    this._trackMemoryWrites(e.raw, attr);
+
     // Sub-agent attribution. A child (Task/Agent) event carries parent_tool_use_id
     // = the id of the parent's Task tool_use block; main-agent events carry null/
     // absent. parent_tool_use_id is a TOP-LEVEL stream-json field; the message-
@@ -4004,6 +4328,30 @@ export class RunHarness extends EventEmitter {
    * carries the figure.
    * @param {number} costUsd
    */
+  /**
+   * Model bridge (model-bridge-design.md §7.2/§8.6): the premium-request-
+   * initiating calls a node made through the bridge, read off the bridge's
+   * per-execution counter when the node's terminal `result` arrives and
+   * stamped on the step (`bridgeCalls`; `bridgeContinued` the tool-loop
+   * continuations). Nothing for a non-bridged node, so the step shape is
+   * unchanged there. Persisted through exec_meta (artifacts.mjs).
+   */
+  _recordBridgeCalls(stepKey, executionId) {
+    if (!executionId) return;
+    const calls = bridgeCallsFor(executionId);
+    if (!calls.initiated && !calls.continued) return;
+    forgetBridgeTag(executionId);
+    const key = stepKey
+      || (this.state.cycle ? `${this.state.phase}#${this.state.cycle}` : this.state.phase);
+    const step = this.state.steps.find((s) => s.key === key);
+    if (!step) return;
+    step.bridgeCalls = (step.bridgeCalls || 0) + calls.initiated;
+    step.bridgeContinued = (step.bridgeContinued || 0) + calls.continued;
+    this.state.updatedAt = new Date().toISOString();
+    this._emit('state', this.getState());
+    this._persist().catch(() => {});
+  }
+
   _recordCost(costUsd, stepKey = null) {
     if (!Number.isFinite(costUsd) || costUsd < 0) return;
     const key = stepKey
@@ -4133,6 +4481,7 @@ export class RunHarness extends EventEmitter {
     const rp = this.state.resumePoint;
     // ABOVE the `if (rp …)` — a pause counts whether or not the engine produced a resume point.
     this._metricsIv.pauses += 1;
+    this._metricsIv.pausedAt = new Date().toISOString();   // resume() measures the parked time from here
     this._metricsIv.lastPauseReason = this.pauseReason || null;
     // _setPauseReason (run-harness.mjs:820) always stores a string or null.
     this._metricsIv.lastPauseDetail = this.pauseDetail == null ? null : String(this.pauseDetail).slice(0, 400);