@linzumi/cli 1.0.101 → 1.0.103

package/README.md

@@ -58,7 +58,7 @@ Install the CLI or run it with `npx`:
 ```bash
 npm install -g @linzumi/cli@latest
 npx -y @linzumi/cli@latest signup
-npx -y @linzumi/cli@1.0.101 --version
+npx -y @linzumi/cli@1.0.103 --version
 linzumi --version
 ```
 

package/dist/index.js

@@ -1471,7 +1471,7 @@ To kick the agent off:
 `,L=Buffer.byteLength(P,"utf8");if(L>s)return l("runner_diagnostics.spool_entry_dropped",{reason:"entry_too_large",entry_bytes:L,max_entry_bytes:s}),!1;uSe(n,{recursive:!0}),m(u)+L>i&&f(),_(L);let D=w()?`
 `:"";return sSe(u,`${D}${P}`,"utf8"),!0}catch(R){return l("runner_diagnostics.spool_failed",{error:R instanceof Error?R.message:String(R)}),!1}},v=k=>{let R=[],P=lSe(k,"utf8");for(let L of P.split(`
 `))if(L.trim()!=="")try{let D=JSON.parse(L);D!==null&&typeof D=="object"&&R.push({parsed:D,raw:L})}catch{}return R};return{append:S,drain:async k=>{if(c)return{uploadedBatches:0,uploadedEntries:0,remainingBatches:p().length,skipped:!0};c=!0;let R=0,P=0;try{f(),_(0);let L=a()-o;for(let D of p()){let j;try{j=v(D)}catch(Z){l("runner_diagnostics.spool_batch_unreadable",{file:D,error:Z instanceof Error?Z.message:String(Z)}),y(D,"unreadable");continue}let q=j.filter(Z=>{let fe=ISe(Z.parsed);return fe===void 0||fe>=L});if(q.length===0){y(D,"empty_or_expired");continue}let E=oP(D,".jsonl"),B=q.map(Z=>Z.raw).join(`
-`),z=q.map(Z=>Z.parsed.spooled_at).filter(Z=>typeof Z=="string"),W={bundle_name:"runner-diagnostics-spool",exported_at:new Date(a()).toISOString(),idempotency_key:E,diagnostics:{kind:"runner_diagnostic_log",spool_batch:!0,idempotency_key:E,entry_count:q.length,...z.length===0?{}:{first_spooled_at:z[0],last_spooled_at:z[z.length-1]}},telemetry_ndjson:B};try{await k(W)}catch(Z){l("runner_diagnostics.spool_upload_failed",{file:D,remaining_batches:p().length,error:Z instanceof Error?Z.message:String(Z)});break}R+=1,P+=q.length;try{h9(D)}catch(Z){l("runner_diagnostics.spool_delete_failed",{file:D,error:Z instanceof Error?Z.message:String(Z)})}}}catch(L){l("runner_diagnostics.spool_drain_failed",{error:L instanceof Error?L.message:String(L)})}finally{c=!1}return{uploadedBatches:R,uploadedEntries:P,remainingBatches:p().length,skipped:!1}},pendingBatchFiles:p}}var ySe,xSe,_Se,bSe,wSe,g9,SSe,kSe,x9=F(()=>{"use strict";Xy();ySe=32*1024*1024,xSe=10080*60*1e3,_Se=4*1024*1024,bSe=1024*1024,wSe="spool.jsonl",g9=/^batch-(\d{1,16})-[0-9a-f-]+\.jsonl$/;SSe=/\b([A-Z][A-Z0-9_]{1,})=("[^"\n]*"|'[^'\n]*'|[^\s"'`;,)\]}]+)/g,kSe=/(?:\/(?:[A-Za-z0-9._@~+-]|%[0-9A-Fa-f]{2})+){2,}/g});var jt,sP,ea=F(()=>{"use strict";jt="1.0.101",sP=`linzumi ${jt}`});import{closeSync as b9,existsSync as dP,mkdirSync as RSe,openSync as w9,readFileSync as v9,renameSync as ESe,unlinkSync as gd,writeFileSync as DSe,writeSync as S9}from"node:fs";import{dirname as k9,join as MSe}from"node:path";function uP(e){return e instanceof hs||e instanceof Error&&e.name===T9&&"lockPath"in e&&"heldBy"in e}function cP(e,n=Wn(),t){let r=t===void 0?encodeURIComponent(e):dd(t);return MSe(k9(n),"runners",`${r}.lock`)}function u0(e){let n=cP(e.machineId,e.configPath,e.linzumiUrl),t=e.isPidAlive??A9,r=e.now??(()=>new Date),o=e.killPid??KSe,i=r().toISOString(),s={version:1,machineId:e.machineId,runnerId:e.runnerId,pid:e.pid??process.pid,cwd:e.cwd,workspace:e.workspace,...e.linzumiUrl===void 0?{}:{linzumiUrl:qn(e.linzumiUrl)},...e.launchSource===void 0?{}:{launchSource:e.launchSource},startedAt:i,heartbeatAt:i,cliVersion:e.cliVersion??jt,...e.gracefulUpdateDrain===!0?{gracefulUpdateDrain:!0}:{}};LSe(e.machineId,e.configPath,e.linzumiUrl,t,r,o,e.onTakeover),jSe(n,s,t,r,o,e.onTakeover,e.beforeReadExistingLock,e.beforeReplaceStaleLock);let a=()=>P9(n,s,r),d=setInterval(a,C9);return d.unref(),{path:n,record:s,heartbeat:a,release:()=>{clearInterval(d),D9(n,s)}}}function P9(e,n,t){try{let r=l0(e);if(r===void 0||r.machineId!==n.machineId||r.runnerId!==n.runnerId||r.pid!==n.pid||r.startedAt!==n.startedAt)return;let o={...r,heartbeatAt:t().toISOString()},i=`${e}.tmp`;DSe(i,`${JSON.stringify(o,null,2)}
+`),z=q.map(Z=>Z.parsed.spooled_at).filter(Z=>typeof Z=="string"),W={bundle_name:"runner-diagnostics-spool",exported_at:new Date(a()).toISOString(),idempotency_key:E,diagnostics:{kind:"runner_diagnostic_log",spool_batch:!0,idempotency_key:E,entry_count:q.length,...z.length===0?{}:{first_spooled_at:z[0],last_spooled_at:z[z.length-1]}},telemetry_ndjson:B};try{await k(W)}catch(Z){l("runner_diagnostics.spool_upload_failed",{file:D,remaining_batches:p().length,error:Z instanceof Error?Z.message:String(Z)});break}R+=1,P+=q.length;try{h9(D)}catch(Z){l("runner_diagnostics.spool_delete_failed",{file:D,error:Z instanceof Error?Z.message:String(Z)})}}}catch(L){l("runner_diagnostics.spool_drain_failed",{error:L instanceof Error?L.message:String(L)})}finally{c=!1}return{uploadedBatches:R,uploadedEntries:P,remainingBatches:p().length,skipped:!1}},pendingBatchFiles:p}}var ySe,xSe,_Se,bSe,wSe,g9,SSe,kSe,x9=F(()=>{"use strict";Xy();ySe=32*1024*1024,xSe=10080*60*1e3,_Se=4*1024*1024,bSe=1024*1024,wSe="spool.jsonl",g9=/^batch-(\d{1,16})-[0-9a-f-]+\.jsonl$/;SSe=/\b([A-Z][A-Z0-9_]{1,})=("[^"\n]*"|'[^'\n]*'|[^\s"'`;,)\]}]+)/g,kSe=/(?:\/(?:[A-Za-z0-9._@~+-]|%[0-9A-Fa-f]{2})+){2,}/g});var jt,sP,ea=F(()=>{"use strict";jt="1.0.103",sP=`linzumi ${jt}`});import{closeSync as b9,existsSync as dP,mkdirSync as RSe,openSync as w9,readFileSync as v9,renameSync as ESe,unlinkSync as gd,writeFileSync as DSe,writeSync as S9}from"node:fs";import{dirname as k9,join as MSe}from"node:path";function uP(e){return e instanceof hs||e instanceof Error&&e.name===T9&&"lockPath"in e&&"heldBy"in e}function cP(e,n=Wn(),t){let r=t===void 0?encodeURIComponent(e):dd(t);return MSe(k9(n),"runners",`${r}.lock`)}function u0(e){let n=cP(e.machineId,e.configPath,e.linzumiUrl),t=e.isPidAlive??A9,r=e.now??(()=>new Date),o=e.killPid??KSe,i=r().toISOString(),s={version:1,machineId:e.machineId,runnerId:e.runnerId,pid:e.pid??process.pid,cwd:e.cwd,workspace:e.workspace,...e.linzumiUrl===void 0?{}:{linzumiUrl:qn(e.linzumiUrl)},...e.launchSource===void 0?{}:{launchSource:e.launchSource},startedAt:i,heartbeatAt:i,cliVersion:e.cliVersion??jt,...e.gracefulUpdateDrain===!0?{gracefulUpdateDrain:!0}:{}};LSe(e.machineId,e.configPath,e.linzumiUrl,t,r,o,e.onTakeover),jSe(n,s,t,r,o,e.onTakeover,e.beforeReadExistingLock,e.beforeReplaceStaleLock);let a=()=>P9(n,s,r),d=setInterval(a,C9);return d.unref(),{path:n,record:s,heartbeat:a,release:()=>{clearInterval(d),D9(n,s)}}}function P9(e,n,t){try{let r=l0(e);if(r===void 0||r.machineId!==n.machineId||r.runnerId!==n.runnerId||r.pid!==n.pid||r.startedAt!==n.startedAt)return;let o={...r,heartbeatAt:t().toISOString()},i=`${e}.tmp`;DSe(i,`${JSON.stringify(o,null,2)}
 `,"utf8"),ESe(i,e)}catch{}}function yd(e,n,t){if(!n(e.pid))return{state:"dead"};let r=e.heartbeatAt??e.startedAt,o=Date.parse(r);return Number.isNaN(o)||t().getTime()-o>ASe?{state:"wedged",reason:e.heartbeatAt===void 0?"missing_heartbeat":"stale_heartbeat"}:{state:"live"}}function I9(e,n,t,r){return t!==c0||e.launchSource!==c0?!1:r.state!=="live"?!0:$Se(n,e.cliVersion)>0}function $Se(e,n){let t=_9(e),r=_9(n);for(let o=0;o<3;o++){let i=t.core[o],s=r.core[o];if(i===void 0||s===void 0)throw new Error(`compareCliVersions: unexpected undefined at core index ${o}`);if(i!==s)return i>s?1:-1}return t.prerelease.length===0&&r.prerelease.length===0?0:t.prerelease.length===0?1:r.prerelease.length===0?-1:OSe(t.prerelease,r.prerelease)}function _9(e){let n=e.trim().replace(/^v/i,"").split("+",1)[0]??"",t=n.indexOf("-"),r=t===-1?n:n.slice(0,t),o=t===-1?"":n.slice(t+1),i=r.split("."),s=[aP(i[0]),aP(i[1]),aP(i[2])],a=o===""?[]:o.split(".").filter(d=>d!=="");return{core:s,prerelease:a}}function aP(e){let n=Number.parseInt(e??"",10);return Number.isInteger(n)&&n>=0?n:0}function OSe(e,n){let t=Math.max(e.length,n.length);for(let r=0;r<t;r++){let o=e[r],i=n[r];if(o===void 0)return-1;if(i===void 0)return 1;let s=Number.parseInt(o,10),a=Number.parseInt(i,10),d=s.toString()===o,u=a.toString()===i;if(d&&u){if(s!==a)return s>a?1:-1}else{if(d!==u)return d?-1:1;if(o!==i)return o>i?1:-1}}return 0}function R9(e,n,t,r,o){try{r(n.pid)}catch(i){let s=i!==null&&typeof i=="object"&&"code"in i?i.code:void 0;if(s!=="ESRCH")throw s==="EPERM"||s==="EACCES"?new Error(`Cannot take over the runner lock at ${e}: its holder process (pid ${n.pid}) is owned by another user and cannot be stopped. Stop that process, or remove the lock file, then retry.`):i}o?.({lockPath:e,holderPid:n.pid,holderRunnerId:n.runnerId,reason:t})}function LSe(e,n,t,r,o,i,s){if(t===void 0||yr(t)!==yr(Bt))return;let a=cP(e,n),d=l0(a);if(d!==void 0){if(yd(d,r,o).state==="live")throw new hs(a,d);E9(a,r,()=>{let u=dP(a)?lP(a):void 0;if(u===void 0)return;let c=yd(u,r,o);if(c.state==="live")throw new hs(a,u);c.state==="wedged"&&R9(a,u,c.reason,i,s),gd(a)})}}function jSe(e,n,t,r,o,i,s,a){if(d0(e,n))return;s?.();let d=l0(e);if(d===void 0){if(d0(e,n))return;throw new Error(`another Linzumi runner lock appeared while starting: ${e}`)}if(yd(d,t,r).state==="live")throw new hs(e,d);a?.(),E9(e,t,()=>{let u=dP(e)?lP(e):void 0;if(u!==void 0){let c=yd(u,t,r);if(c.state==="live")throw new hs(e,u);c.state==="wedged"&&R9(e,u,c.reason,o,i),gd(e)}if(!d0(e,n))throw new Error(`another Linzumi runner lock appeared while starting: ${e}`)})}function d0(e,n){RSe(k9(e),{recursive:!0});try{let t=w9(e,"wx");try{S9(t,`${JSON.stringify(n,null,2)}
 `)}finally{b9(t)}return!0}catch(t){if(Bc(t,"EEXIST"))return!1;throw t}}function E9(e,n,t){let r=`${e}.replace`;for(;;)try{let o=w9(r,"wx");try{S9(o,`${process.pid}
 `),t()}finally{b9(o),gd(r)}return}catch(o){if(Bc(o,"EEXIST")){let i=FSe(r);if(i===void 0)continue;if(n(i))throw new Error(["another Linzumi runner is already replacing a stale runner lock",`lock: ${e}`,"Wait for that startup to finish, then retry."].join(`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@linzumi/cli",
-  "version": "1.0.101",
+  "version": "1.0.103",
   "description": "Linzumi CLI \u2014 point a Codex agent at the real code on your laptop, with your team watching and steering from shared threads.",
   "type": "module",
   "bin": {

package/scripts/build-queue-parity-oracle.mjs

@@ -0,0 +1,899 @@
+// Spec: kandan/plans/2026-07-10-compute-nodes-rescript-commander-zero-ts-program.md
+// (M3 cluster 5, queues-watermarks).
+// Relationship: Builds the TS-side PARITY ORACLE for the queues/watermarks
+// cluster of the ReScript commander port, the sibling of
+// build-config-identity-parity-oracle.mjs (cluster 2). The oracle bundles
+// the REAL TS queue/watermark modules (kandanQueue.ts,
+// pendingKandanMessageQueue.ts, appliedSourceSeqWatermark.ts,
+// durableInboundQueue.ts, controlQuarantine.ts, resumeKeystone.ts +
+// threadReconcilerLock.ts/leaseEpochGuard.ts, pipeline/outbox.ts +
+// pipeline/outboxJournal.ts) behind the cluster 1/2 one-shot batch driver:
+// a JSON array of cases on stdin, a JSON array of results on stdout. The
+// ReScript package's QueueParityConformance drives the SAME scripted
+// inputs through the ported modules in its own scratch directories and
+// asserts per-action outcome equivalence AND byte-identical durable files
+// (inbound-queue logs, commander-outbox journals, withheld-ack records,
+// quarantine evidence) - the cross-impl round-trip contract that lets both
+// commanders share ~/.linzumi through M4.
+//
+// Determinism: every source of nondeterminism is pinned per case - clocks
+// come from a fixed `nowMs` (the queue/outbox/keystone seams are all
+// injectable), scripted push outcomes resolve in order, and scratch paths
+// are normalized through the "$DIR" placeholder in both directions. Retry
+// delays in scripted outbox scenarios are millisecond-scale so a scenario
+// settles fast without changing the ladder's shape.
+//
+// SECRETS: the oracle only ever sees the conformance suite's synthetic
+// payloads; nothing here logs case contents.
+//
+// The output is a local test artifact (.differential/ is gitignored, never
+// published) and stays unminified for debuggability.
+import { mkdir } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { build } from 'esbuild';
+
+const packageRoot = dirname(dirname(fileURLToPath(import.meta.url)));
+
+const driverSource = `
+import {
+  appendFileSync,
+  mkdtempSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  realpathSync,
+  statSync,
+  writeFileSync,
+} from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, relative } from 'node:path';
+import {
+  codexInputForQueuedKandanMessage,
+  formatQueuedKandanMessage,
+  interruptQueuedMessages,
+  normalizeCodexSteerInput,
+  queuedKandanMessageSourceSeqs,
+  steerInputText,
+} from './src/kandanQueue';
+import {
+  createPendingKandanMessageQueue,
+  dequeuePendingKandanMessage,
+  drainAllPendingKandanMessages,
+  enqueuePendingKandanMessage,
+  interruptPendingKandanMessages,
+  listPendingKandanMessages,
+  pendingKandanMessageQueueHasSeq,
+  pendingKandanMessageQueueLength,
+  requeuePendingKandanMessageFront,
+} from './src/pendingKandanMessageQueue';
+import {
+  commitAppliedSourceSeq,
+  createInFlightSourceSeqGuard,
+  highestProcessedSourceSeq,
+  parseResumeReconcileEntries,
+  parseServerMessageStateRows,
+  reconcileAppliedSourceSeq,
+  resumeReconcileServerRows,
+  shouldApplySourceSeq,
+  sourceSeqAppliedOrInFlight,
+  threadSourceSeqWatermarkKey,
+} from './src/appliedSourceSeqWatermark';
+import {
+  createDurableInboundThreadQueue,
+  defaultDeadLetterPolicy,
+  durableInboundQueuePath,
+  foldQueueRecords,
+  shouldDeadLetter,
+} from './src/durableInboundQueue';
+import {
+  controlQuarantineFilePath,
+  createControlQuarantine,
+  fileWithheldControlAckStore,
+  withheldControlAckStorePath,
+} from './src/controlQuarantine';
+import {
+  outboxJournalPath,
+  recoverOutboxJournal,
+} from './src/pipeline/outboxJournal';
+import { createThreadOutbox } from './src/pipeline/outbox';
+import {
+  applyResumeDispatchOutcome,
+  commitLiveAcceptedSourceSeq,
+  drainResumeQueue,
+  receiveResumeMessage,
+} from './src/resumeKeystone';
+import { createLeaseEpochRegistry, isFencedClaim } from './src/leaseEpochGuard';
+import { createThreadReconcilerLock } from './src/threadReconcilerLock';
+
+// --- Placeholder + snapshot plumbing --------------------------------------------
+
+const dirPlaceholder = '$DIR';
+
+function scratch() {
+  // realpath so macOS /var -> /private/var never splits the two impls'
+  // placeholder substitution.
+  return realpathSync(mkdtempSync(join(tmpdir(), 'linzumi-queue-oracle-')));
+}
+
+function substitute(value, from, to) {
+  if (typeof value === 'string') {
+    return value.split(from).join(to);
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => substitute(entry, from, to));
+  }
+  if (typeof value === 'object' && value !== null) {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, entry]) => [
+        substitute(key, from, to),
+        substitute(entry, from, to),
+      ])
+    );
+  }
+  return value;
+}
+
+function snapshotFiles(dir) {
+  const files = {};
+  const walk = (current) => {
+    for (const name of readdirSync(current).sort()) {
+      const full = join(current, name);
+      if (statSync(full).isDirectory()) {
+        walk(full);
+      } else {
+        files[relative(dir, full)] = readFileSync(full, 'utf8');
+      }
+    }
+  };
+  walk(dir);
+  return files;
+}
+
+function outcome(run) {
+  try {
+    const value = run();
+    return value === undefined ? { defined: false } : { defined: true, value };
+  } catch (error) {
+    return {
+      threw: true,
+      message: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
+function collectingLog(events, dir) {
+  return (event, payload) => {
+    events.push({ event, payload: substitute(payload, dir, dirPlaceholder) });
+  };
+}
+
+// --- Queued-message pure transforms ------------------------------------------------
+
+function handleQueuedMessage(testCase) {
+  switch (testCase.fn) {
+    case 'normalizeCodexSteerInput':
+      return outcome(() => normalizeCodexSteerInput(testCase.input));
+    case 'steerInputText':
+      return outcome(() => steerInputText(testCase.input));
+    case 'format':
+      return outcome(() => formatQueuedKandanMessage(testCase.message));
+    case 'codexInput':
+      return outcome(() => codexInputForQueuedKandanMessage(testCase.message));
+    case 'sourceSeqs':
+      return outcome(() => queuedKandanMessageSourceSeqs(testCase.message));
+    case 'interrupt':
+      return outcome(() =>
+        interruptQueuedMessages(testCase.queue, testCase.throughSeq ?? undefined)
+      );
+    default:
+      return { threw: true, message: 'unknown queuedMessage fn ' + String(testCase.fn) };
+  }
+}
+
+// --- Pending FIFO ---------------------------------------------------------------------
+
+function handlePendingQueue(testCase) {
+  const queue = createPendingKandanMessageQueue();
+  const results = (testCase.actions ?? []).map((action) => {
+    switch (action.fn) {
+      case 'enqueue':
+        return outcome(() => enqueuePendingKandanMessage(queue, action.message));
+      case 'dequeue':
+        return outcome(() => dequeuePendingKandanMessage(queue));
+      case 'requeueFront':
+        return outcome(() => requeuePendingKandanMessageFront(queue, action.message));
+      case 'drainAll':
+        return outcome(() => drainAllPendingKandanMessages(queue));
+      case 'interrupt':
+        return outcome(() =>
+          interruptPendingKandanMessages(queue, action.throughSeq ?? undefined)
+        );
+      case 'hasSeq':
+        return outcome(() => pendingKandanMessageQueueHasSeq(queue, action.seq));
+      case 'list':
+        return outcome(() => listPendingKandanMessages(queue));
+      case 'length':
+        return outcome(() => pendingKandanMessageQueueLength(queue));
+      default:
+        return { threw: true, message: 'unknown pendingQueue fn ' + String(action.fn) };
+    }
+  });
+  return { results };
+}
+
+// --- Watermark pure semantics -----------------------------------------------------------
+
+function watermarkMemStore(calls) {
+  const map = new Map();
+  return {
+    initial: (key) => map.get(key),
+    onAdvance: (key, seq) => {
+      calls.push({ call: 'onAdvance', key, seq });
+      const existing = map.get(key);
+      if (existing === undefined || seq > existing) {
+        map.set(key, seq);
+      }
+    },
+    flush: () => {
+      calls.push({ call: 'flush' });
+    },
+    dump: () => Object.fromEntries(map),
+  };
+}
+
+function handleWatermark(testCase) {
+  switch (testCase.fn) {
+    case 'shouldApply':
+      return outcome(() =>
+        shouldApplySourceSeq(testCase.applied ?? undefined, testCase.sourceSeq)
+      );
+    case 'key':
+      return outcome(() =>
+        threadSourceSeqWatermarkKey(testCase.workspace, testCase.channel, testCase.threadId)
+      );
+    case 'highestProcessed':
+      return outcome(() => highestProcessedSourceSeq(testCase.rows));
+    case 'reconcile':
+      return outcome(() =>
+        reconcileAppliedSourceSeq(testCase.local ?? undefined, testCase.rows)
+      );
+    case 'parseRows':
+      return outcome(() => parseServerMessageStateRows(testCase.value));
+    case 'parseResumeReconcile':
+      return outcome(() => parseResumeReconcileEntries(testCase.value));
+    case 'resumeReconcileRows':
+      return outcome(() => resumeReconcileServerRows(testCase.entry));
+    case 'isFencedClaim':
+      return outcome(() =>
+        isFencedClaim(testCase.held ?? undefined, testCase.control ?? undefined)
+      );
+    case 'guardScenario': {
+      const calls = [];
+      const store = watermarkMemStore(calls);
+      const guard = createInFlightSourceSeqGuard();
+      const results = (testCase.actions ?? []).map((action) => {
+        switch (action.fn) {
+          case 'mark':
+            return outcome(() => guard.mark(action.key, action.seq));
+          case 'has':
+            return outcome(() => guard.has(action.key, action.seq));
+          case 'clearSeq':
+            return outcome(() => guard.clearSeq(action.key, action.seq));
+          case 'clearThread':
+            return outcome(() => guard.clearThread(action.key));
+          case 'commit':
+            return outcome(() => commitAppliedSourceSeq(store, action.key, action.seq));
+          case 'commitLiveAccepted':
+            return outcome(() =>
+              commitLiveAcceptedSourceSeq({
+                store,
+                watermarkKey: action.key,
+                sourceSeq: action.seq,
+              })
+            );
+          case 'appliedOrInFlight':
+            return outcome(() =>
+              sourceSeqAppliedOrInFlight(
+                store.initial(action.key),
+                guard,
+                action.key,
+                action.seq
+              )
+            );
+          default:
+            return { threw: true, message: 'unknown guard fn ' + String(action.fn) };
+        }
+      });
+      return { results, storeCalls: calls, store: store.dump() };
+    }
+    default:
+      return { threw: true, message: 'unknown watermark fn ' + String(testCase.fn) };
+  }
+}
+
+// --- Durable inbound queue --------------------------------------------------------------
+
+function normalizeEntry(entry) {
+  return entry === undefined ? undefined : { ...entry };
+}
+
+function handleInboundQueue(testCase) {
+  if (testCase.fn === 'foldLines') {
+    return outcome(() => foldQueueRecords(testCase.lines));
+  }
+  if (testCase.fn === 'shouldDeadLetter') {
+    return outcome(() =>
+      shouldDeadLetter(testCase.entry, testCase.policy ?? defaultDeadLetterPolicy, testCase.nowMs)
+    );
+  }
+  if (testCase.fn === 'path') {
+    process.env.LINZUMI_INBOUND_QUEUE_DIR = testCase.envDir ?? '';
+    const result = outcome(() =>
+      durableInboundQueuePath(testCase.workspace, testCase.channel, testCase.threadId)
+    );
+    delete process.env.LINZUMI_INBOUND_QUEUE_DIR;
+    return result;
+  }
+  // Scripted lifecycle in a scratch dir. fsync spies record ORDERING facts
+  // (an 'fsync' event lands in the stream before the action result is
+  // recorded), proving fsync-before-return (#2974) on BOTH impls.
+  const dir = scratch();
+  const path = join(dir, 'thread.log');
+  if (testCase.initialContents !== undefined) {
+    writeFileSync(path, testCase.initialContents, 'utf8');
+  }
+  const events = [];
+  const log = collectingLog(events, dir);
+  const deps = {
+    fsyncFd: () => {
+      events.push({ event: 'spy.fsync_data' });
+    },
+    fsyncDirFd: () => {
+      events.push({ event: 'spy.fsync_dir' });
+    },
+  };
+  let queue = createDurableInboundThreadQueue(path, log, deps);
+  const results = (testCase.actions ?? []).map((action) => {
+    switch (action.fn) {
+      case 'enqueue': {
+        const result = outcome(() =>
+          queue.enqueue(action.sourceSeq, action.kind ?? 'live', action.payload ?? {}, action.nowMs)
+        );
+        events.push({ event: 'action.enqueue_returned', sourceSeq: action.sourceSeq });
+        return result;
+      }
+      case 'ack':
+        return outcome(() => queue.ack(action.sourceSeq));
+      case 'recordAttempt':
+        return outcome(() => queue.recordAttempt(action.sourceSeq));
+      case 'deadLetter':
+        return outcome(() => normalizeEntry(queue.deadLetter(action.sourceSeq)));
+      case 'compact':
+        return outcome(() => queue.compact());
+      case 'entries':
+        return outcome(() => queue.entries().map(normalizeEntry));
+      case 'ackedEntries':
+        return outcome(() => queue.ackedEntries().map(normalizeEntry));
+      case 'head':
+        return outcome(() => normalizeEntry(queue.head()));
+      case 'highWater':
+        return outcome(() => queue.highWaterSourceSeq());
+      case 'tornTail':
+        return outcome(() => queue.tornTail());
+      case 'reconciledTornTail':
+        return outcome(() => queue.reconciledTornTail());
+      case 'appendRaw':
+        // Simulate a crash-torn tail / foreign bytes.
+        return outcome(() => appendFileSync(path, action.raw, 'utf8'));
+      case 'reload': {
+        // Simulated SIGKILL + restart: a fresh handle folds the same file.
+        queue = createDurableInboundThreadQueue(path, log, deps);
+        return { defined: false };
+      }
+      default:
+        return { threw: true, message: 'unknown inboundQueue fn ' + String(action.fn) };
+    }
+  });
+  return substitute(
+    { results, events, files: snapshotFiles(dir) },
+    dir,
+    dirPlaceholder
+  );
+}
+
+// --- Control quarantine -------------------------------------------------------------------
+
+function handleQuarantine(testCase) {
+  if (testCase.fn === 'paths') {
+    return {
+      store: outcome(() => withheldControlAckStorePath('$STATE', testCase.runnerId)),
+      quarantine: outcome(() => controlQuarantineFilePath('$STATE', testCase.runnerId)),
+    };
+  }
+  const dir = scratch();
+  const storePath = join(dir, 'withheld-acks.json');
+  const quarantinePath = join(dir, 'quarantined-controls.jsonl');
+  if (testCase.initialStoreContents !== undefined) {
+    writeFileSync(storePath, testCase.initialStoreContents, 'utf8');
+  }
+  if (testCase.initialQuarantineContents !== undefined) {
+    writeFileSync(quarantinePath, testCase.initialQuarantineContents, 'utf8');
+  }
+  const events = [];
+  const emitted = [];
+  const log = collectingLog(events, dir);
+  const writeErrors = [];
+  const store = fileWithheldControlAckStore(storePath, (message) =>
+    writeErrors.push(message)
+  );
+  let epoch = testCase.epoch ?? undefined;
+  const quarantine = createControlQuarantine({
+    store,
+    quarantineFilePath: quarantinePath,
+    log,
+    emitRunnerEvent: (payload) => {
+      emitted.push(substitute(payload, dir, dirPlaceholder));
+    },
+    currentEpoch: () => epoch,
+    ...(testCase.limit === undefined ? {} : { limit: testCase.limit }),
+    now: () => new Date(testCase.nowMs ?? 0),
+  });
+  const results = (testCase.rejections ?? []).map((rejection) => {
+    if (rejection.setEpoch !== undefined) {
+      epoch = rejection.setEpoch === null ? undefined : rejection.setEpoch;
+    }
+    return outcome(() =>
+      quarantine.onControlRejected(
+        rejection.control,
+        new Error(rejection.message ?? 'scripted rejection')
+      )
+    );
+  });
+  return substitute(
+    { results, events, emitted, writeErrors, files: snapshotFiles(dir) },
+    dir,
+    dirPlaceholder
+  );
+}
+
+// --- Outbox journal (recover-from-bytes) -----------------------------------------------------
+
+function normalizeRecovered(recovered) {
+  return {
+    pendingEntries: recovered.pendingEntries,
+    kv: Object.fromEntries(recovered.kv),
+    counters: recovered.counters,
+  };
+}
+
+function handleOutboxJournal(testCase) {
+  if (testCase.fn === 'path') {
+    return outcome(() => outboxJournalPath('$PERSIST', testCase.threadKey));
+  }
+  // recover: fold the given journal bytes.
+  const dir = scratch();
+  const path = join(dir, 'thread.outbox.jsonl');
+  if (testCase.contents !== undefined) {
+    writeFileSync(path, testCase.contents, 'utf8');
+  }
+  const events = [];
+  const recovered = outcome(() =>
+    normalizeRecovered(recoverOutboxJournal(path, collectingLog(events, dir)))
+  );
+  return substitute({ recovered, events }, dir, dirPlaceholder);
+}
+
+// --- Outbox flow scenarios ---------------------------------------------------------------------
+
+function buildersFromSpec(spec, recordedReplies) {
+  const builders = {};
+  for (const [kind, config] of Object.entries(spec ?? {})) {
+    builders[kind] = {
+      build: (data) => {
+        if (config.mode === 'skip') {
+          return { skip: true, reason: String(data.skipReason ?? 'scripted-skip') };
+        }
+        if (config.mode === 'fail') {
+          throw new Error(String(data.failMessage ?? 'scripted-build-failure'));
+        }
+        return {
+          event: 'evt:' + kind,
+          payload: { ...data },
+          ...(config.timeoutMs === undefined ? {} : { timeoutMs: config.timeoutMs }),
+        };
+      },
+      ...(config.onReply === 'record'
+        ? {
+            onReply: (data, reply) => {
+              recordedReplies.push({ kind, data, reply });
+            },
+          }
+        : {}),
+      ...(config.coalesce === 'concat-bodies'
+        ? {
+            coalesce: (older, newer) => ({
+              ...newer,
+              body: String(older.body ?? '') + '|' + String(newer.body ?? ''),
+            }),
+          }
+        : {}),
+    };
+  }
+  return builders;
+}
+
+async function runOutboxPhase(phase, shared) {
+  // The outbox unrefs its retry timers by design (a pending backoff must
+  // never hold the runner process open), so a one-shot driver awaiting a
+  // flush across a backoff would see its event loop empty. Keep it alive
+  // for the phase.
+  const keepAlive = setInterval(() => {}, 25);
+  try {
+    return await runOutboxPhaseInner(phase, shared);
+  } finally {
+    clearInterval(keepAlive);
+  }
+}
+
+async function runOutboxPhaseInner(phase, shared) {
+  const pushScript = [...(phase.pushScript ?? [])];
+  const pushes = [];
+  const permanentFailures = [];
+  const recordedReplies = [];
+  const events = [];
+  const log = collectingLog(events, shared.dir);
+  let nowMs = phase.nowMs ?? 1_000;
+  const outbox = createThreadOutbox({
+    threadKey: phase.threadKey ?? shared.threadKey,
+    push: async (event, payload, timeoutMs, onSent) => {
+      const step = pushScript.shift() ?? { kind: 'fail', message: 'push script exhausted' };
+      pushes.push({
+        event,
+        payload,
+        hasTimeout: timeoutMs !== undefined,
+      });
+      onSent?.();
+      if (step.delayMs !== undefined) {
+        await new Promise((resolve) => setTimeout(resolve, step.delayMs));
+      }
+      if (step.kind === 'ack') {
+        return step.reply ?? { ok: true };
+      }
+      const failure = new Error(String(step.message ?? 'scripted push failure'));
+      if (step.budgetExempt === true) {
+        failure.name = 'ScriptedBudgetExempt';
+      }
+      throw failure;
+    },
+    builders: buildersFromSpec(phase.builders ?? shared.builders, recordedReplies),
+    persistDir: shared.persistDir,
+    retryDelaysMs: phase.retryDelaysMs ?? [1, 1],
+    isRetryBudgetExempt: (error) => error.name === 'ScriptedBudgetExempt',
+    onPermanentFailure: (entry, error) => {
+      permanentFailures.push({
+        entrySeq: entry.entrySeq,
+        kind: entry.kind,
+        error: error.message,
+      });
+    },
+    log,
+    now: () => nowMs,
+    ...(phase.maxInFlightPushes === undefined
+      ? {}
+      : { maxInFlightPushes: phase.maxInFlightPushes }),
+    ...(phase.journalCompactionThreshold === undefined
+      ? {}
+      : { journalCompactionThreshold: phase.journalCompactionThreshold }),
+    ...(phase.journalRecoveryMaxAgeMs === undefined
+      ? {}
+      : { journalRecoveryMaxAgeMs: phase.journalRecoveryMaxAgeMs }),
+  });
+
+  const results = [];
+  for (const action of phase.actions ?? []) {
+    switch (action.fn) {
+      case 'advanceNow':
+        nowMs += action.byMs;
+        results.push({ defined: false });
+        break;
+      case 'enqueue':
+        results.push(
+          outcome(() =>
+            outbox.enqueue({
+              kind: action.kind,
+              data: action.data ?? {},
+              ...(action.coalesceKey === undefined ? {} : { coalesceKey: action.coalesceKey }),
+              resolution: action.resolution ?? 'must_ack',
+            })
+          )
+        );
+        break;
+      case 'pause':
+        results.push(outcome(() => outbox.pause()));
+        break;
+      case 'resume':
+        results.push(outcome(() => outbox.resume()));
+        break;
+      case 'flush': {
+        try {
+          await outbox.flush(action.timeoutMs);
+          results.push({ flushed: true });
+        } catch (error) {
+          results.push({
+            flushed: false,
+            message: error instanceof Error ? error.message : String(error),
+          });
+        }
+        break;
+      }
+      case 'metrics': {
+        const metrics = outbox.metrics();
+        results.push({
+          defined: true,
+          value: {
+            depth: metrics.depth,
+            totalEnqueued: metrics.totalEnqueued,
+            totalAcked: metrics.totalAcked,
+            totalRetried: metrics.totalRetried,
+            totalDroppedBestEffort: metrics.totalDroppedBestEffort,
+            totalPermanentFailures: metrics.totalPermanentFailures,
+            totalExpiredOnRecovery: metrics.totalExpiredOnRecovery,
+            journalDegraded: metrics.journalDegraded,
+            paused: metrics.paused,
+            ackedInWindow: metrics.pushLatency?.ackedInWindow ?? 0,
+          },
+        });
+        break;
+      }
+      case 'journalSettled':
+        await outbox.journalSettled();
+        results.push({ defined: false });
+        break;
+      case 'rekeyJournal':
+        results.push(outcome(() => outbox.rekeyJournal(action.threadKey)));
+        await outbox.journalSettled();
+        break;
+      case 'sleep':
+        await new Promise((resolve) => setTimeout(resolve, action.ms));
+        results.push({ defined: false });
+        break;
+      case 'close':
+        await outbox.close(action.timeoutMs);
+        results.push({ defined: false });
+        break;
+      default:
+        results.push({ threw: true, message: 'unknown outbox fn ' + String(action.fn) });
+    }
+  }
+  // Make phase end deterministic: everything journaled so far is on disk.
+  await outbox.journalSettled();
+  return {
+    results,
+    pushes,
+    permanentFailures,
+    recordedReplies,
+    // Log EVENT NAMES in order (payloads carry timing values that legally
+    // differ across impls; names + counts are the stable contract).
+    logEvents: events.map((entry) => entry.event),
+  };
+}
+
+async function handleOutboxScenario(testCase) {
+  const dir = scratch();
+  // Cross-impl seed: files the OTHER impl wrote (journal bytes), laid down
+  // before any phase so recovery reads foreign-written bytes.
+  for (const [relPath, contents] of Object.entries(testCase.initialFiles ?? {})) {
+    const full = join(dir, relPath);
+    mkdirSync(join(full, '..'), { recursive: true });
+    writeFileSync(full, contents, 'utf8');
+  }
+  const shared = {
+    dir,
+    persistDir: testCase.inMemory === true ? undefined : join(dir, 'commander-outbox'),
+    threadKey: testCase.threadKey ?? 'linzumi:42:thread-a',
+    builders: testCase.builders ?? {},
+  };
+  const phases = [];
+  for (const phase of testCase.phases ?? []) {
+    phases.push(await runOutboxPhase(phase, shared));
+  }
+  return substitute(
+    { phases, files: snapshotFiles(dir) },
+    dir,
+    dirPlaceholder
+  );
+}
+
+// --- Resume keystone flow scenarios ----------------------------------------------------------
+
+async function handleKeystoneScenario(testCase) {
+  const dir = scratch();
+  const path = join(dir, 'thread.log');
+  if (testCase.initialContents !== undefined) {
+    writeFileSync(path, testCase.initialContents, 'utf8');
+  }
+  const events = [];
+  const log = collectingLog(events, dir);
+  const queue = createDurableInboundThreadQueue(path, log);
+  const storeCalls = [];
+  const store = watermarkMemStore(storeCalls);
+  if (typeof testCase.initialWatermark === 'number') {
+    store.onAdvance(testCase.watermarkKey, testCase.initialWatermark);
+    storeCalls.length = 0;
+  }
+  const lock = createThreadReconcilerLock();
+  const leases = createLeaseEpochRegistry();
+  const guard = createInFlightSourceSeqGuard();
+  const deadLetters = [];
+  const dispatchScript = [...(testCase.dispatchScript ?? [])];
+  const dispatchCalls = [];
+  const dispatch = async (sourceSeq, payload) => {
+    dispatchCalls.push({ sourceSeq, payload });
+    const step = dispatchScript.shift() ?? { outcome: 'ignored' };
+    return step.outcome;
+  };
+  const onDeadLetter = (args) => {
+    deadLetters.push({
+      threadId: args.threadId,
+      sourceSeq: args.sourceSeq,
+      reason: args.reason,
+      attempts: args.attempts,
+      alreadyPublished: args.alreadyPublished,
+    });
+  };
+  const results = [];
+  for (const step of testCase.steps ?? []) {
+    if (step.fn === 'receive') {
+      const outcomeValue = await receiveResumeMessage({
+        queue,
+        store,
+        lock,
+        leases,
+        threadId: testCase.threadId,
+        watermarkKey: testCase.watermarkKey,
+        sourceSeq: step.sourceSeq,
+        kind: step.kind ?? 'live',
+        payload: step.payload ?? {},
+        leaseEpoch: step.leaseEpoch ?? undefined,
+        dispatch,
+        serverRows: step.serverRows ?? [],
+        log,
+        nowMs: step.nowMs ?? 1_000,
+        ...(step.policy === undefined ? {} : { policy: step.policy }),
+        onlyDispatchUnattempted: step.onlyDispatchUnattempted ?? false,
+        onDeadLetter,
+        inFlightGuard: guard,
+      });
+      results.push({ receive: outcomeValue });
+    } else if (step.fn === 'drain') {
+      const dispatched = await drainResumeQueue({
+        queue,
+        store,
+        lock,
+        threadId: testCase.threadId,
+        watermarkKey: testCase.watermarkKey,
+        serverRows: step.serverRows ?? [],
+        dispatch,
+        log,
+        nowMs: step.nowMs ?? 1_000,
+        ...(step.policy === undefined ? {} : { policy: step.policy }),
+        onlyDispatchUnattempted: step.onlyDispatchUnattempted ?? false,
+        onTornTailUnrecoverable: (threadId) => {
+          deadLetters.push({ threadId, tornTailSurfaced: true });
+        },
+        onDeadLetter,
+        inFlightGuard: guard,
+      });
+      results.push({ drained: dispatched });
+    } else if (step.fn === 'executionCommit') {
+      // The turn EXECUTED to a terminal: the live path commits the floor
+      // (I58 execution-confirm) and clears the in-flight guard.
+      const advanced = commitLiveAcceptedSourceSeq({
+        store,
+        watermarkKey: testCase.watermarkKey,
+        sourceSeq: step.sourceSeq,
+      });
+      guard.clearSeq(testCase.watermarkKey, step.sourceSeq);
+      results.push({ executionCommit: advanced });
+    } else if (step.fn === 'workerDeath') {
+      guard.clearThread(testCase.watermarkKey);
+      results.push({ workerDeath: true });
+    } else if (step.fn === 'applyOutcome') {
+      await applyResumeDispatchOutcome({
+        queue,
+        store,
+        watermarkKey: testCase.watermarkKey,
+        sourceSeq: step.sourceSeq,
+        threadId: testCase.threadId,
+        outcome: step.outcome,
+        log,
+        nowMs: step.nowMs ?? 1_000,
+        ...(step.policy === undefined ? {} : { policy: step.policy }),
+        onDeadLetter,
+        inFlightGuard: guard,
+      });
+      results.push({ applied: step.outcome });
+    } else {
+      results.push({ threw: true, message: 'unknown keystone fn ' + String(step.fn) });
+    }
+  }
+  return substitute(
+    {
+      results,
+      dispatchCalls,
+      deadLetters,
+      storeCalls,
+      store: store.dump(),
+      liveEntries: queue.entries().map((entry) => ({ ...entry })),
+      ackedEntries: queue.ackedEntries().map((entry) => ({ ...entry })),
+      logEvents: events.map((entry) => entry.event),
+      files: snapshotFiles(dir),
+    },
+    dir,
+    dirPlaceholder
+  );
+}
+
+// --- Dispatch --------------------------------------------------------------------------------
+
+async function handle(testCase) {
+  switch (testCase.op) {
+    case 'queuedMessage':
+      return handleQueuedMessage(testCase);
+    case 'pendingQueue':
+      return handlePendingQueue(testCase);
+    case 'watermark':
+      return handleWatermark(testCase);
+    case 'inboundQueue':
+      return handleInboundQueue(testCase);
+    case 'quarantine':
+      return handleQuarantine(testCase);
+    case 'outboxJournal':
+      return handleOutboxJournal(testCase);
+    case 'outboxScenario':
+      return await handleOutboxScenario(testCase);
+    case 'keystoneScenario':
+      return await handleKeystoneScenario(testCase);
+    default:
+      return { threw: true, message: 'unknown op ' + String(testCase.op) };
+  }
+}
+
+let stdin = '';
+process.stdin.setEncoding('utf8');
+for await (const chunk of process.stdin) {
+  stdin += chunk;
+}
+const cases = JSON.parse(stdin);
+const results = [];
+for (const testCase of cases) {
+  results.push(await handle(testCase));
+}
+// Exit only after stdout is fully flushed: scripted outbox scenarios can
+// leave unref'd timers alive, so the driver exits explicitly - but a bare
+// process.exit(0) truncates large result arrays mid-pipe.
+process.stdout.write(JSON.stringify(results), () => {
+  process.exit(0);
+});
+`;
+
+await mkdir(join(packageRoot, '.differential'), { recursive: true });
+
+await build({
+  stdin: {
+    contents: driverSource,
+    resolveDir: packageRoot,
+    sourcefile: 'queue-parity-driver.ts',
+    loader: 'ts',
+  },
+  bundle: true,
+  platform: 'node',
+  target: 'node20',
+  format: 'esm',
+  outfile: join(packageRoot, '.differential/queue-parity-oracle.mjs'),
+  minify: false,
+  sourcemap: false,
+  legalComments: 'none',
+  external: ['ws', 'undici', 'blessed', '@anthropic-ai/claude-agent-sdk'],
+});

package/scripts/bump-cli-version.mjs

@@ -12,7 +12,7 @@
 //      publishes @linzumi/cli@<new-version> to npm.
 //
 // The package version is pinned in several places (package.json,
-// src/version.ts, README.md, and version-pinning tests). This script rewrites
+// src/version.ts, README.md, the public alias manifest, and version-pinning tests). This script rewrites
 // every known site, FAILS LOUDLY if any expected pattern is missing, and then
 // scans package.json/src/README/test/scripts/bin for any leftover
 // old-version string - so a future, not-yet-listed pin site cannot silently
@@ -71,6 +71,7 @@ if (!/^\d+\.\d+\.\d+(-[0-9A-Za-z][0-9A-Za-z.-]*)?$/.test(newVersion)) {
 
 const packageRoot =
   explicitRoot ?? dirname(dirname(fileURLToPath(import.meta.url)));
+const aliasPackageRoot = join(dirname(packageRoot), 'linzumi');
 
 let manifest;
 
@@ -96,6 +97,24 @@ if (oldVersion === newVersion) {
 // the bump aborts; add new entries here when a new pin site appears (the
 // leftover scan below is what tells you one appeared).
 const knownSites = [
+  {
+    file: '../linzumi/package.json',
+    description: 'public alias manifest version',
+    pattern: `"version": "${oldVersion}"`,
+    replacement: `"version": "${newVersion}"`,
+  },
+  {
+    file: '../linzumi/package.json',
+    description: 'public alias exact canonical dependency',
+    pattern: `"@linzumi/cli": "${oldVersion}"`,
+    replacement: `"@linzumi/cli": "${newVersion}"`,
+  },
+  {
+    file: '../../pnpm-lock.yaml',
+    description: 'public alias lockfile dependency specifier',
+    pattern: `specifier: ${oldVersion}\n        version: link:../linzumi-cli`,
+    replacement: `specifier: ${newVersion}\n        version: link:../linzumi-cli`,
+  },
   {
     file: 'package.json',
     description: 'npm package manifest version',
@@ -209,6 +228,11 @@ function scanTargets() {
   const roots = ['src', 'test', 'scripts', 'bin'];
   const files = ['package.json', 'README.md'];
 
+  // Spec: plans/2026-07-12-linzumi-unscoped-npm-package-spec.md
+  // The alias version and canonical dependency are one release invariant.
+  files.push(relative(packageRoot, join(aliasPackageRoot, 'package.json')));
+  files.push('../../pnpm-lock.yaml');
+
   for (const root of roots) {
     const rootPath = join(packageRoot, root);
     let entries;