total-recall-brain 3.41.6 → 3.42.0

package/scaffold/.agent/skills/total-recall/plugins/meta-harness/src/review.mjs

@@ -9,12 +9,16 @@
  */
 
 import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
 import { ADAPTER_CATALOG } from '../capability/index.mjs';
 import { appendThreadTurn, updateThread } from './threads.mjs';
 import { notifyAlert } from './alerts.mjs';
 import { dispatchWithReceipt } from './dispatch.mjs';
-import { resolvePool } from './pool.mjs';
+import { resolvePool, localExecutionNode } from './pool.mjs';
 import { lastJsonWith } from './json-reply.mjs';
+import { createWorktree, removeWorktree, commitAll, headCommit } from './worktree.mjs';
+import { forwardRemoteOperation } from './remote-operation.mjs';
 
 const MAX_DIFF = 30000;
 // Generated surfaces say nothing a reviewer can act on, and they crowd out the source.
@@ -27,25 +31,35 @@ const GENERATED = ['.cursorrules', '.cursor', 'openwiki', 'package-lock.json', '
  */
 export function extractGitDiff(options = {}) {
   const cwd = options.cwd || process.cwd();
-  const read = (args, extra = []) => spawnSync('git', ['diff', ...extra, ...args, '--', '.', ...GENERATED], { cwd, encoding: 'utf8', timeout: 15000, maxBuffer: 64 * 1024 * 1024 });
-  const done = (args, diff, target) => {
+  const run = args => spawnSync('git', args, { cwd, encoding: 'utf8', timeout: 15000, maxBuffer: 64 * 1024 * 1024 });
+  const read = (args, extra = []) => run(['diff', ...(extra.length ? extra : ['--binary']), ...args, '--', '.', ...GENERATED]);
+  const ref = value => {
+    const result = run(['rev-parse', '--verify', `${value}^{commit}`]);
+    if (result.status !== 0) throw new Error(String(result.stderr || 'Invalid review reference').trim());
+    return result.stdout.trim();
+  };
+  const done = (args, diff, target, snapshot) => {
     const stat = read(args, ['--stat']).stdout || '';
-    const untracked = spawnSync('git', ['ls-files', '-o', '--exclude-standard'], { cwd, encoding: 'utf8', timeout: 15000 }).stdout || '';
-    return { ok: true, diff, target, stat: stat.trim(), untracked: untracked.trim().split('\n').filter(Boolean) };
+    const untracked = snapshot.mode === 'working' ? run(['ls-files', '-o', '--exclude-standard', '-z', '--', '.', ...GENERATED]).stdout || '' : '';
+    return { ok: true, diff, target, stat: stat.trim(), untracked: untracked.split('\0').filter(Boolean), snapshot };
   };
   const explicit = options.staged === true ? ['--staged'] : (options.target || options.branch) ? [options.target || options.branch] : null;
   try {
     if (explicit) {
+      if (explicit[0] !== '--staged' && explicit[0].startsWith('-')) throw new Error('Review targets must be Git references, not options');
       const result = read(explicit);
       if (result.status !== 0) return { ok: false, error: String(result.stderr || 'git diff failed').trim(), diff: '' };
-      return done(explicit, result.stdout.trim(), explicit.join(' '));
+      let snapshot;
+      if (options.staged === true) snapshot = { mode: 'staged', ref: ref('HEAD') };
+      else if (explicit[0].includes('..')) snapshot = { mode: 'commit', ref: ref(explicit[0].split(/\.{2,3}/).at(-1) || 'HEAD') };
+      else snapshot = { mode: 'working', ref: ref(explicit[0]) };
+      return done(explicit, result.stdout.trim(), explicit.join(' '), snapshot);
     }
-    const branchRange = `${getDefaultBranch(cwd)}...HEAD`;
-    const branch = read([branchRange]);
-    if (branch.status === 0 && branch.stdout.trim()) return done([branchRange], branch.stdout.trim(), branchRange);
-    const working = read(['HEAD']);
+    const mergeBase = run(['merge-base', getDefaultBranch(cwd), 'HEAD']);
+    const base = mergeBase.status === 0 ? mergeBase.stdout.trim() : ref('HEAD');
+    const working = read([base]);
     if (working.status !== 0) return { ok: false, error: String(working.stderr || 'git diff failed').trim(), diff: '' };
-    return done(['HEAD'], working.stdout.trim(), 'HEAD');
+    return done([base], working.stdout.trim(), 'working tree', { mode: 'working', ref: base });
   } catch (error) {
     return { ok: false, error: error.message, diff: '' };
   }
@@ -55,12 +69,33 @@ function getDefaultBranch(cwd) {
   try {
     const res = spawnSync('git', ['symbolic-ref', 'refs/remotes/origin/HEAD'], { cwd, encoding: 'utf8', timeout: 3000 });
     if (res.status === 0 && res.stdout.includes('/')) {
-      return res.stdout.trim().split('/').pop();
+      return res.stdout.trim();
     }
   } catch {}
   return 'main';
 }
 
+/** Pin the selected diff in a disposable commit, so reviewers never read unrelated current files. */
+function reviewSnapshot(cwd, selection) {
+  const directory = createWorktree(cwd, { ref: selection.snapshot.ref, prefix: 'meta-harness-review-' });
+  try {
+    if (selection.snapshot.mode !== 'commit') {
+      if (selection.diff) {
+        const patch = spawnSync('git', ['apply', '--index', '--binary', '-'], { cwd: directory, input: `${selection.diff}\n`, encoding: 'utf8', timeout: 15000 });
+        if (patch.status !== 0) throw new Error(`Could not pin the selected review diff: ${String(patch.stderr || patch.error).trim()}`);
+      }
+      for (const file of selection.untracked) {
+        const source = path.resolve(cwd, file), destination = path.resolve(directory, file);
+        if (!source.startsWith(`${path.resolve(cwd)}${path.sep}`) || !destination.startsWith(`${directory}${path.sep}`) || !fs.lstatSync(source).isFile()) throw new Error(`Unsafe untracked review file: ${file}`);
+        fs.mkdirSync(path.dirname(destination), { recursive: true });
+        fs.copyFileSync(source, destination);
+      }
+      commitAll(directory, 'meta-harness: pin selected review snapshot');
+    }
+    return { directory, commit: headCommit(directory) };
+  } catch (error) { removeWorktree(cwd, directory); throw error; }
+}
+
 /**
  * Assign an adversarial reviewer from an alternative model family
  */
@@ -132,14 +167,17 @@ export function parseReviewVerdict(response) {
 }
 
 export async function executeCodeReview(options = {}) {
+  const remote = await forwardRemoteOperation('review', null, options);
+  if (remote) return remote;
+  localExecutionNode(options);
   const cwd = options.cwd || process.cwd();
   const author = options.author || null;
   const diffResult = extractGitDiff({ cwd, target: options.target, staged: options.staged });
   if (!diffResult.ok) throw new Error(`Failed to read the diff: ${diffResult.error}`);
-  if (!diffResult.diff) return { ok: true, verdict: 'NO_DIFF', target: diffResult.target, summary: `Nothing to review for ${diffResult.target}.` };
+  if (!diffResult.diff && !diffResult.untracked?.length) return { ok: true, verdict: 'NO_DIFF', target: diffResult.target, summary: `Nothing to review for ${diffResult.target}.` };
 
   const { ready, excluded } = await resolvePool(options);
-  const reviewer = options.reviewer ? (ready.find(h => h.id === options.reviewer) || { id: options.reviewer, name: options.reviewer }) : selectAdversarialReviewer(author, ready);
+  const reviewer = options.reviewer ? ready.find(h => h.id === options.reviewer) : selectAdversarialReviewer(author, ready);
   if (!reviewer) throw new Error(`No independent reviewer can take work right now: ${excluded.map(e => `${e.harness} (${e.reason})`).join(', ') || 'no other harness available'}`);
 
   const authorFamily = ADAPTER_CATALOG[author]?.family || null;
@@ -147,14 +185,17 @@ export async function executeCodeReview(options = {}) {
   if (author && (reviewer.id === author || (authorFamily && authorFamily === reviewerFamily))) throw new Error(`${reviewer.id} shares a model family with the author ${author}, so it cannot review this independently`);
   const independence = author ? 'verified' : 'unverified: the author was not named';
   const truncated = diffResult.diff.length > MAX_DIFF;
-  const result = await dispatchWithReceipt({
-    agent: reviewer.id, cwd, contextTask: options.task || `Review the code changes in ${diffResult.target}`,
+  const snapshot = reviewSnapshot(cwd, diffResult);
+  let result;
+  try { result = await dispatchWithReceipt({
+    agent: reviewer.id, node: 'local', cwd: snapshot.directory, contextCwd: cwd, contextTask: options.task || `Review the code changes in ${diffResult.target}`,
     prompt: buildReviewPrompt(diffResult.diff, { task: options.task, branch: options.branch || diffResult.target, stat: diffResult.stat, untracked: diffResult.untracked }),
-    permissions: { read: true, write: false }, allowUnknownAuth: true,
-  }, { dispatchFn: options.dispatchFn, role: 'Reviewer' });
+    permissions: { read: true, write: false }, allowUnknownAuth: options.allowUnknownAuth === true,
+  }, { dispatchFn: options.dispatchFn, role: 'Reviewer' }); }
+  finally { removeWorktree(cwd, snapshot.directory); }
   if (!result.ok) return { ok: false, target: diffResult.target, reviewer: reviewer.id, error: result.error, failureKind: result.failureKind, excluded };
 
-  const review = { ...parseReviewVerdict(result.response), reviewer: reviewer.id, reviewerName: reviewer.name || reviewer.id, author, target: diffResult.target, truncated, independence, timestamp: new Date().toISOString() };
+  const review = { ...parseReviewVerdict(result.response), reviewer: reviewer.id, reviewerName: reviewer.name || reviewer.id, author, target: diffResult.target, snapshotCommit: snapshot.commit, truncated, independence, node: 'local', workspace: cwd, ...(options.threadId ? { threadId: options.threadId } : {}), timestamp: new Date().toISOString() };
   let threadError;
   if (options.threadId) {
     try {

package/scaffold/.agent/skills/total-recall/plugins/meta-harness/src/router.mjs

@@ -19,13 +19,13 @@ import { inspectAgents } from './worker.mjs';
 import { inspectNode } from './executor.mjs';
 import { getModelCatalog, joinHarnessModels } from './model-catalog.mjs';
 import { readReceipts, activeQuotaWalls, activeCredentialBlocks } from './learner.mjs';
-import { resolvePool, exclusionReason } from './pool.mjs';
+import { resolvePool, exclusionReason, isLocalExecutionNode } from './pool.mjs';
 import { readCodexRateLimits, measuredWalls } from './telemetry.mjs';
 
 /**
  * Helper to safely query host Total Recall CLI without assumptions
  */
-function runHostCli(args = []) {
+function runHostCli(args = [], { captureFailure = false } = {}) {
   try {
     const totalRecallBin = process.env.TOTAL_RECALL_BIN || 'total-recall';
     const output = execFileSync(totalRecallBin, args, {
@@ -34,8 +34,9 @@ function runHostCli(args = []) {
       encoding: 'utf8'
     });
     return output.trim();
-  } catch {
-    return null;
+  } catch (error) {
+    // A failing owner often explains itself as JSON on stdout. Callers that need the reason read it here.
+    return captureFailure ? String(error.stdout || '').trim() || null : null;
   }
 }
 
@@ -136,7 +137,26 @@ export async function inspectQuotas(options = {}) {
     meteredQuota.quotaNote = `OpenRouter could not be reached: ${error.message}`;
     meteredQuota.status = 'unavailable';
   }
+  // Per-key usage says nothing about whether the account can pay. Only the account balance does.
+  try {
+    const management = options.openRouterManagementKey !== undefined ? options.openRouterManagementKey : runHostCli(['auth', 'secret', 'get', 'OPENROUTER_MANAGEMENT_KEY']);
+    if (management) {
+      const response = await (options.fetchImpl || fetch)('https://openrouter.ai/api/v1/credits', { headers: { Authorization: `Bearer ${management}` }, signal: AbortSignal.timeout(6000) });
+      if (!response.ok) throw new Error(`HTTP ${response.status}`);
+      const { total_credits: credits, total_usage: used } = (await response.json()).data || {};
+      if (typeof credits === 'number' && typeof used === 'number') {
+        meteredQuota.creditRemainingUSD = +(credits - used).toFixed(2);
+        meteredQuota.quotaNote = `Account balance $${meteredQuota.creditRemainingUSD} of $${credits}`;
+        if (credits - used <= 0) meteredQuota.status = 'exhausted';
+      }
+    }
+  } catch (error) {
+    meteredQuota.balanceError = `The OpenRouter balance could not be read: ${error.message}`;
+  }
   quotas.metered = meteredQuota;
+  if (meteredQuota.status === 'exhausted') for (const id of ['dsh', 'hermes', 'pi']) {
+    if (quotas[id]?.installed && !['needs_auth', 'blocked'].includes(quotas[id].status)) Object.assign(quotas[id], { status: 'exhausted', quotaNote: `Bills OpenRouter. ${meteredQuota.quotaNote}` });
+  }
 
   return { ok: true, timestamp: new Date().toISOString(), node: options.node || 'local', fleet: { ok: fleet.ok, error: fleet.error, machines: fleet.machines, answered: fleet.answered, nodes: fleet.nodes }, quotas };
 }
@@ -154,11 +174,12 @@ export async function getBenchmarks(options = {}) {
 }
 
 /** Ask the decision plugin to classify. Its failure is reported; the caller sees which classifier answered. */
-export function classifyWithDecision(task, run = args => runHostCli(args)) {
-  const questions = { complexity: { type: 'choice', prompt: 'How demanding is this software engineering task for a coding agent?', options: ['local', 'budget', 'frontier'] } };
+export function classifyWithDecision(task, run = args => runHostCli(args, { captureFailure: true })) {
+  const questions = { complexity: { type: 'choice', instructions: 'How demanding is this software engineering task for a coding agent?', criteria: { local: 'A small mechanical change a local model can make.', budget: 'Routine engineering with a clear path.', frontier: 'Architecture, security, or work across many files.' } } };
   const output = run(['decision', 'run', '--state', JSON.stringify({ task: task.slice(0, 2000) }), '--questions', JSON.stringify(questions), '--json']);
   if (!output) throw new Error('The decision plugin did not answer');
   const parsed = JSON.parse(output);
+  if (parsed.ok === false) throw new Error(parsed.error || 'The decision plugin reported a failure');
   const answer = parsed.answers?.complexity ?? parsed.decision?.answers?.complexity ?? parsed.result?.complexity;
   const tier = typeof answer === 'string' ? answer : answer?.choice;
   if (!['local', 'budget', 'frontier'].includes(tier)) throw new Error('The decision plugin returned no usable tier');
@@ -185,7 +206,11 @@ export async function routeTask(taskDescription, options = {}) {
       classifier = { source: 'heuristic', decisionError: String(error.message).slice(0, 300) };
     }
   }
-  const [quotaReport, pool, receipts] = await Promise.all([inspectQuotas(options), resolvePool(options), readReceipts()]);
+  // Plan-only routing on a selected node chooses from that node's harnesses, not this machine's.
+  const remote = options.node && !isLocalExecutionNode(options.node);
+  const inspected = remote ? (options.inspectNodeFn || inspectNode)(options.node) : null;
+  const scoped = remote ? { ...options, inspectNodeFn: () => inspected, inspect: () => inspected } : options;
+  const [quotaReport, pool, receipts] = await Promise.all([inspectQuotas(scoped), resolvePool(scoped), readReceipts()]);
   const quotas = quotaReport.quotas;
   const routing = selectOptimalHarness(taskDescription, pool.ready.map(h => h.id), quotas, { ...options, tierOverride: complexity.tier, empiricalScorecard: computeEmpiricalScorecard(receipts) });
   const selectedQuota = quotas[routing.selected] || {};

package/scaffold/.agent/skills/total-recall/plugins/meta-harness/src/termination.mjs

@@ -0,0 +1,24 @@
+/** A stopped run takes its agents, checkouts, unfinished branches and open threads with it. */
+import { stopActiveProcesses } from './worker.mjs';
+import { removeActiveWorktrees } from './worktree.mjs';
+import { failOpenThreads } from './coordinator.mjs';
+
+const SIGNALS = { SIGTERM: 143, SIGINT: 130, SIGHUP: 129 };
+let installed = false;
+
+export function stopOnTermination({ graceMs = 500 } = {}) {
+  if (installed) return;
+  installed = true;
+  let stopping = false;
+  for (const [signal, code] of Object.entries(SIGNALS)) process.on(signal, () => {
+    if (stopping) return;
+    stopping = true;
+    stopActiveProcesses('SIGTERM');
+    setTimeout(() => {
+      stopActiveProcesses('SIGKILL');
+      removeActiveWorktrees();
+      failOpenThreads();
+      process.exit(code);
+    }, graceMs);
+  });
+}

package/scaffold/.agent/skills/total-recall/plugins/meta-harness/src/threads.mjs

@@ -1,156 +1,119 @@
-/**
- * Meta Harness Multi-Platform Thread Manager
- * Unifies thread tracking and session supervision across integrated agent platforms:
- * agy, claude, codex, dsh, hermes, openclaw, cursor, devin, etc.
- *
- * Persists thread state, PR branch associations, turn history, and review status.
- */
-
+/** Thread state is canonical SSSS, mutated through the native kernel with optimistic concurrency. */
 import fs from 'node:fs';
-import path from 'node:path';
+import crypto from 'node:crypto';
 import { threadsFile } from './paths.mjs';
+import { PluginStateStore } from './ssss-store.mjs';
+
+const STATUSES = new Set(['active', 'review_pending', 'approved', 'completed', 'failed']);
+const identifier = /^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,127}$/;
+const storeForThreads = () => new PluginStateStore(threadsFile(), 'meta-harness');
+
+function validateThreads(value) {
+  if (!Array.isArray(value)) throw new Error('The thread store is corrupt: threads must be an array');
+  const ids = new Set();
+  for (const thread of value) {
+    if (!thread || typeof thread !== 'object' || !identifier.test(thread.id || '') || ids.has(thread.id)
+      || typeof thread.title !== 'string' || !STATUSES.has(thread.status) || !Array.isArray(thread.turns)
+      || thread.turns.some(turn => !turn || typeof turn !== 'object' || typeof turn.content !== 'string')) {
+      throw new Error('The thread store is corrupt: invalid thread identity, status or turns');
+    }
+    ids.add(thread.id);
+  }
+  return value;
+}
 
-/** A missing file is an empty store. A corrupt one is an error, so the next write cannot erase it. */
-export function readThreads() {
-  let content;
-  try { content = fs.readFileSync(threadsFile(), 'utf8'); }
-  catch (error) { if (error.code === 'ENOENT') return []; throw error; }
-  let parsed;
-  try { parsed = JSON.parse(content); }
-  catch { throw new Error(`The thread store ${threadsFile()} is corrupt. It was left in place; repair or move it.`); }
-  return Array.isArray(parsed) ? parsed : (parsed.threads || []);
+/** Existing JSON is read only for migration. The first mutation imports it through SSSS; it is never overwritten. */
+function readState(store) {
+  let value;
+  try { value = store.read(null); }
+  catch (error) { throw new Error(`The canonical thread store is corrupt or unsafe: ${error.message}`); }
+  if (value === null) {
+    let content;
+    try { content = fs.readFileSync(threadsFile(), 'utf8'); }
+    catch (error) { if (error.code === 'ENOENT') return { threads: [] }; throw error; }
+    try { value = JSON.parse(content); }
+    catch { throw new Error(`The thread store ${threadsFile()} is corrupt. It was left in place.`); }
+  }
+  const state = Array.isArray(value) ? { threads: value } : value;
+  if (!state || typeof state !== 'object') throw new Error('The thread store is corrupt: missing thread state');
+  validateThreads(state.threads);
+  return state;
 }
 
-/** Serialize read-modify-write across processes. A lock older than 30 seconds belongs to a dead process. */
-function withLock(work) {
-  const lock = `${threadsFile()}.lock`;
-  fs.mkdirSync(path.dirname(lock), { recursive: true, mode: 0o700 });
-  const deadline = Date.now() + 10000;
-  for (;;) {
-    try { fs.mkdirSync(lock); break; }
-    catch (error) {
-      if (error.code !== 'EEXIST') throw error;
-      try { if (Date.now() - fs.statSync(lock).mtimeMs > 30000) { fs.rmdirSync(lock); continue; } } catch { continue; }
-      if (Date.now() > deadline) throw new Error('The thread store is locked by another process');
-      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 50);
+export const threadDocumentPath = () => storeForThreads().documentPath;
+export function readThreads() { return readState(storeForThreads()).threads; }
+
+/** Native SSSS owns the mutation guard and leases. CAS retries reload state; no age-based lock stealing. */
+function mutate(work) {
+  for (let attempt = 0; attempt < 8; attempt += 1) {
+    const store = storeForThreads();
+    const state = readState(store);
+    const result = work(state.threads);
+    validateThreads(state.threads);
+    try {
+      store.write({ ...state, version: '2.0.0', updatedAt: new Date().toISOString(), threads: state.threads });
+      return structuredClone(result);
+    } catch (error) {
+      if (!String(error.message).includes('version conflict') || attempt === 7) throw error;
     }
   }
-  try { return work(); } finally { fs.rmdirSync(lock); }
 }
 
 export function writeThreads(threads) {
-  const file = threadsFile();
-  fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
-  const payload = {
-    version: '1.0.0',
-    updatedAt: new Date().toISOString(),
-    threads: Array.isArray(threads) ? threads : []
-  };
-  const temporary = `${file}.${process.pid}.tmp`;
-  fs.writeFileSync(temporary, JSON.stringify(payload, null, 2), { mode: 0o600 });
-  fs.renameSync(temporary, file);
+  validateThreads(threads);
+  return mutate(current => { current.splice(0, current.length, ...structuredClone(threads)); return current; });
 }
 
 export function listThreads(filter = {}) {
-  const threads = readThreads();
-  return threads
-    .filter(t => {
-      if (filter.platform && t.platform !== filter.platform) return false;
-      if (filter.status && t.status !== filter.status) return false;
-      if (filter.branch && t.branch !== filter.branch) return false;
-      return true;
-    })
+  return readThreads().filter(thread => (!filter.platform || thread.platform === filter.platform)
+    && (!filter.status || thread.status === filter.status) && (!filter.branch || thread.branch === filter.branch))
     .sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
 }
-
-export function getThread(id) {
-  const threads = readThreads();
-  return threads.find(t => t.id === id) || null;
-}
+export function getThread(id) { return readThreads().find(thread => thread.id === id) || null; }
 
 export function createThread(data = {}) {
-  return withLock(() => {
-  const threads = readThreads();
-  const now = new Date().toISOString();
-  const id = data.id || `thread-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`;
-
-  const thread = {
-    id,
-    title: String(data.title || 'Untitled Agent Thread').slice(0, 140),
-    task: String(data.task || data.title || '').trim(),
-    platform: data.platform || 'universal',
-    model: data.model || 'auto',
-    branch: data.branch || null,
-    worktreePath: data.worktreePath || null,
-    prNumber: data.prNumber || null,
-    prUrl: data.prUrl || null,
-    status: data.status || 'active', // 'active' | 'review_pending' | 'approved' | 'completed' | 'failed'
-    createdAt: now,
-    updatedAt: now,
-    turns: Array.isArray(data.turns) ? data.turns : [],
-    review: data.review || null,
-    summary: data.summary || null
-  };
-
-  threads.unshift(thread);
-  writeThreads(threads);
-  return thread;
+  const id = data.id || `thread-${crypto.randomUUID()}`;
+  return mutate(threads => {
+    if (threads.some(thread => thread.id === id)) throw new Error(`Thread already exists: ${id}`);
+    const now = new Date().toISOString();
+    const thread = {
+      ...data, id, title: String(data.title || 'Untitled Agent Thread').slice(0, 140),
+      task: String(data.task || data.title || '').trim(), platform: data.platform || 'universal', model: data.model || 'auto',
+      branch: data.branch || null, worktreePath: data.worktreePath || null, prNumber: data.prNumber || null, prUrl: data.prUrl || null,
+      status: data.status || 'active', createdAt: now, updatedAt: now,
+      turns: Array.isArray(data.turns) ? data.turns : [], review: data.review || null, summary: data.summary || null,
+    };
+    threads.unshift(thread);
+    return thread;
   });
 }
 
 export function appendThreadTurn(id, turn = {}) {
-  return withLock(() => {
-  const threads = readThreads();
-  const index = threads.findIndex(t => t.id === id);
-  if (index === -1) throw new Error(`Thread not found: ${id}`);
-
-  const now = new Date().toISOString();
-  const entry = {
-    role: turn.role || 'agent',
-    agent: turn.agent || 'unknown',
-    content: String(turn.content || '').slice(0, 50000),
-    timestamp: now
-  };
-
-  threads[index].turns.push(entry);
-  threads[index].updatedAt = now;
-  writeThreads(threads);
-  return threads[index];
+  return mutate(threads => {
+    const thread = threads.find(item => item.id === id);
+    if (!thread) throw new Error(`Thread not found: ${id}`);
+    const now = new Date().toISOString();
+    thread.turns.push({ role: turn.role || 'agent', agent: turn.agent || 'unknown', content: String(turn.content || '').slice(0, 50000), timestamp: now });
+    thread.updatedAt = now;
+    return thread;
   });
 }
 
 export function updateThread(id, updates = {}) {
-  return withLock(() => {
-  const threads = readThreads();
-  const index = threads.findIndex(t => t.id === id);
-  if (index === -1) throw new Error(`Thread not found: ${id}`);
-
-  const now = new Date().toISOString();
-  threads[index] = {
-    ...threads[index],
-    ...updates,
-    id, // protect immutable ID
-    updatedAt: now
-  };
-
-  writeThreads(threads);
-  return threads[index];
+  if (!updates || typeof updates !== 'object' || Array.isArray(updates)) throw new Error('Thread updates must be an object');
+  return mutate(threads => {
+    const index = threads.findIndex(thread => thread.id === id);
+    if (index < 0) throw new Error(`Thread not found: ${id}`);
+    threads[index] = { ...threads[index], ...updates, id, createdAt: threads[index].createdAt, updatedAt: new Date().toISOString() };
+    return threads[index];
   });
 }
-
-export function closeThread(id, resolution = 'completed') {
-  return updateThread(id, {
-    status: resolution,
-    closedAt: new Date().toISOString()
-  });
-}
-
+export function closeThread(id, resolution = 'completed') { return updateThread(id, { status: resolution, closedAt: new Date().toISOString() }); }
 export function deleteThread(id) {
-  return withLock(() => {
-    const threads = readThreads();
-    const filtered = threads.filter(t => t.id !== id);
-    if (filtered.length === threads.length) return false;
-    writeThreads(filtered);
+  return mutate(threads => {
+    const index = threads.findIndex(thread => thread.id === id);
+    if (index < 0) return false;
+    threads.splice(index, 1);
     return true;
   });
 }