@linzumi/cli 1.0.265 → 1.0.267

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@linzumi/cli",
-  "version": "1.0.265",
+  "version": "1.0.267",
   "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-core-commander-seams-parity-oracle.mjs

@@ -86,6 +86,9 @@ import {
   recoverRetainedTerminalDebt,
 } from './src/channelSession';
 import {adoptAdtStreamBinding, installAdtPublicationBinding} from './src/pipeline/contracts';
+import {createThreadOutbox} from './src/pipeline/outbox';
+import {enqueueTerminalDebtRepair} from './src/pipeline/integration';
+import {createHash} from 'node:crypto';
 
 // --- Placeholder + snapshot plumbing --------------------------------------------
 
@@ -534,9 +537,59 @@ async function handleRespawn(testCase) {
 
 // Spec: spec/commander-recovery-rules.md rule01 and rule05; retained terminal
 // debt is not an unknown provider-start ACK and cannot reset unrelated jobs.
+async function terminalDebtJournal(testCase) {
+  const control = testCase.control;
+  const logs = [];
+  const body = 'Synthetic completed answer.';
+  const outbox = createThreadOutbox({threadKey:'synthetic-terminal-debt', persistDir:scratch(),
+    push:async()=>{throw new Error('pending repair must not publish or resend provider work');},
+    builders:{'adt.terminal_attempt':{build:()=>{throw new Error('synthetic retained failure');}}},
+    retryDelaysMs:[], onPermanentFailure:()=>{}, log:(event,fields)=>logs.push({event,fields}),
+  });
+  try {
+    outbox.enqueue({kind:'adt.terminal_attempt',resolution:'must_ack',data:{seq:44,status:'processed',
+      turn_id:'synthetic-completed-turn',terminal_frame:{session_id:3600,lease_epoch:2,frame_index:40,
+      frame_kind:'terminal',assistant_phase:'final_answer',source_stream_key:'synthetic-rejected-key',body}}});
+    await outbox.flush(1000);
+    outbox.pause();
+    await outbox.journalSettled();
+    const gate = Promise.withResolvers();
+    const entered = Promise.withResolvers();
+    let settled = false;
+    let authority = true;
+    const barrierOutbox = {...outbox,
+      journalSettled:async()=>{entered.resolve();await gate.promise;await outbox.journalSettled();settled=true;},
+      terminalPublicationDebt:()=>!settled || control==='write-failure'
+        ? {kind:'unavailable',reason:'controlled journal not durable'} : outbox.terminalPublicationDebt(),
+    };
+    const repair = enqueueTerminalDebtRepair(barrierOutbox,{threadId:'synthetic-terminal-debt',sourceSeq:44,
+      sessionId:3600,originalLeaseEpoch:2,authoritativeTerminal:false,authorize:()=>authority,
+      binding:{session_id:3600,lease_epoch:4,next_frame_index:39,
+        checkpoint_config:{version:3,thresholds:{max_bytes:512,max_deltas:1,max_interval_ms:2000}},
+        final_checkpoint:{frame_index:38,source_stream_key:'synthetic-canonical-key',
+          body_sha256:createHash('sha256').update(body).digest('hex'),byte_len:Buffer.byteLength(body)}}},
+      (event,fields)=>logs.push({event,fields}));
+    const first = await Promise.race([entered.promise.then(()=>'waiting'),repair.then(()=>'finished')]);
+    const before = outbox.pendingTerminalEntries().length;
+    authority = control !== 'superseded';
+    gate.resolve();
+    const result = await repair;
+    return {first,before,count:outbox.pendingTerminalEntries().length,ready:result.kind==='ready',result,logs};
+  } finally {await outbox.close(0);}
+}
+
 async function terminalDebtStorm(testCase) {
-  const binding = {session_id: 3600, lease_epoch: 1, next_frame_index: 39,
+  const ackLease = testCase.control === 'newer-ack-lease' ? 2 : testCase.control === 'future-ack' ? 4 : 1;
+  const binding = {session_id: 3600, lease_epoch: ackLease, next_frame_index: 39,
     checkpoint_config: {version: 3, thresholds: {max_bytes: 1, max_deltas: 1, max_interval_ms: 2000}}};
+  // Spec: commander-recovery-rules authenticated-terminal-evidence. The
+  // retained frame and original ACK belong to one attempt across lease churn.
+  const retainedLease = testCase.control === 'newer-retained-lease' ? 2 : 1;
+  const body = 'Synthetic completed answer.';
+  const reconciledBinding = {...binding, lease_epoch: 3, final_checkpoint: {
+    frame_index: 38, source_stream_key: 'synthetic-canonical-key',
+    body_sha256: createHash('sha256').update(body).digest('hex'), byte_len: Buffer.byteLength(body),
+  }};
   const adopted = adoptAdtStreamBinding(binding, 44, 0);
   if (adopted.kind !== 'accepted') throw new Error('terminal debt fixture binding refused');
   const session = adopted.session;
@@ -544,6 +597,26 @@ async function terminalDebtStorm(testCase) {
   let resets = 0;
   let restarts = 0;
   let reconciliations = 0;
+  let repairs = 0;
+  const outbox = createThreadOutbox({threadKey:'synthetic-terminal-debt',
+    persistDir:scratch(),
+    push:async()=>{throw new Error('failed builder must not publish');},
+    builders:{'adt.terminal_attempt':{build:()=>{throw new Error('synthetic final rejection');}}},
+    retryDelaysMs:[], onPermanentFailure:()=>{}, log:(event,fields)=>logs.push({event,fields}),
+  });
+  try {
+  outbox.enqueue({kind:'adt.terminal_attempt',resolution:'must_ack',data:{seq:44,status:'processed',
+    turn_id:'synthetic-completed-turn',terminal_frame:{session_id:3600,lease_epoch:retainedLease,
+    frame_index:40,frame_kind:'terminal',assistant_phase:'final_answer',source_stream_key:'synthetic-rejected-key',body}}});
+  await outbox.flush(1000);
+  outbox.pause();
+  // Queue drain completion is distinct from durable journal settlement.
+  await outbox.journalSettled();
+  const durableDebt = outbox.terminalPublicationDebt();
+  if (typeof durableDebt !== 'object' || durableDebt.kind !== 'repair_needed' || durableDebt.count !== 1) {
+    throw new Error('warm repair fixture must have one durable failed terminal: ' + JSON.stringify(durableDebt));
+  }
+  const original = JSON.stringify(outbox.failedTerminalEntries());
   const transport = {
     push: async (_topic, event) => {
       if (event === 'adt_binding_ack') return {status: 'ok', response: {ok: true}};
@@ -551,7 +624,7 @@ async function terminalDebtStorm(testCase) {
         reconciliations += 1;
         if(testCase.control === 'repair-unavailable' && reconciliations > 1) return {status:'ok',response:{ok:true,adt:{verdict:'still_unavailable'}}};
         return {status: 'ok', response: {
-        ok: true, adt: {verdict: 'already_applied', binding: testCase.control === 'malformed-binding' ? {session_id: 3600} : binding},
+        ok: true, adt: {verdict: 'already_applied', binding: testCase.control === 'malformed-binding' ? {session_id: 3600} : reconciledBinding},
       }};
       }
       throw new Error('unexpected terminal-debt fixture event: ' + event);
@@ -560,7 +633,7 @@ async function terminalDebtStorm(testCase) {
   };
   const candidate = registerRequiredAdtCandidate({transport,
     identity: {thread_id: 'synthetic-terminal-debt', source_seq: 44, session_id: 3600,
-      lease_epoch: 1, checkpoint_config_version: 3},
+      lease_epoch: ackLease, checkpoint_config_version: 3},
     installFreshBinding: raw => {
       const fresh = adoptAdtStreamBinding(raw, 44, 0);
       if (fresh.kind !== 'accepted') return false;
@@ -569,17 +642,23 @@ async function terminalDebtStorm(testCase) {
     },
     publicationSession: () => testCase.localState === 'idle' ? undefined : session,
     failedTerminalEntries: () => {
-      const entries = [{entrySeq: 61, kind: 'adt.terminal_attempt',
-      data: {seq: 44, status: 'processed', turn_id: 'synthetic-completed-turn',
-        terminal_frame: {session_id: testCase.control === 'foreign-debt' ? 3601 : 3600, lease_epoch: 1, frame_index: 40,
-          frame_kind: 'terminal', assistant_phase: 'final_answer',
-          source_stream_key: 'synthetic-rejected-key', body: 'Synthetic completed answer.'}}}];
+      const entries = outbox.failedTerminalEntries().map(entry => ({...entry,data:{...entry.data,
+        ...(testCase.control === 'malformed-repair-presence' ? {terminal_repair:undefined} : {}),
+        terminal_frame:{...entry.data.terminal_frame,session_id:testCase.control === 'foreign-debt' ? 3601 : 3600,
+          lease_epoch:testCase.control === 'future-debt' ? 4 : testCase.control === 'fractional-debt' ? 1.5 : retainedLease}}}));
       if (testCase.control === 'missing-debt') return [];
       if (testCase.control === 'ambiguous-debt') return [...entries, {...entries[0], entrySeq: 62}];
       return entries;
     },
+    repairTerminalDebt:async (fresh,authoritativeTerminal,authorize,evidenceEpoch)=>{
+      if(evidenceEpoch !== retainedLease) throw new Error('repair callback received ACK lease instead of retained evidence');
+      const result=await enqueueTerminalDebtRepair(outbox,{threadId:'synthetic-terminal-debt',sourceSeq:44,
+        sessionId:3600,originalLeaseEpoch:evidenceEpoch,binding:fresh,authoritativeTerminal,authorize},()=>{});
+      if(result.kind!=='ready') throw new Error('actual repair selector refused: '+result.message);
+      repairs += 1;
+    },
     onUnrecoverable: () => {restarts += 1;},
-    log: event => logs.push(event),
+    log: (event,fields) => logs.push({event,fields}),
   });
   try {
     await acknowledgeRequiredAdtCandidate({topic: 'local_runner:fixture', payload: adopted.ackPayload, ticket: candidate});
@@ -590,12 +669,16 @@ async function terminalDebtStorm(testCase) {
       closeRequiredAdtAdmissionForDisconnect(transport);
       await reconcileRequiredAdtCandidates({transport, topic: 'local_runner:fixture'});
     }
-    return {resets, restarts, retained: findRequiredAdtCandidate(transport,
+    return {resets, restarts, repairs, originalUnchanged:JSON.stringify(outbox.failedTerminalEntries())===original,
+      corrections:outbox.pendingTerminalEntries().map(entry=>({originalLease:entry.data.terminal_repair?.original_lease_epoch,
+        lease:entry.data.terminal_frame?.lease_epoch,body:entry.data.terminal_frame?.body})),
+      retained: findRequiredAdtCandidate(transport,
       identity => identity.thread_id === 'synthetic-terminal-debt' && identity.source_seq === 44) === candidate,
       providerEffect: candidate.providerEffect, verdict: candidate.verdict,
       nextProviderAdmission: consumeRequiredAdtAdmission(candidate).kind,
       admission: requiredTransportFinalAdmission(transport).kind, logs};
   } finally {releaseRequiredAdtCandidate(candidate);}
+  } finally {await outbox.close(0);}
 }
 
 async function handle(testCase) {
@@ -603,24 +686,33 @@ async function handle(testCase) {
     case 'terminalDebtCold': {
       const events = [];
       let repairs = 0;
-      const identity = {thread_id:'synthetic-terminal-debt',source_seq:44,session_id:3600,lease_epoch:1,checkpoint_config_version:7};
-      const binding = {session_id:3600,lease_epoch:2,next_frame_index:39,checkpoint_config:{version:8,thresholds:{max_bytes:512,max_deltas:1,max_interval_ms:2000}}};
+      const retainedEpoch = ['ack-before-frame','binding-before-frame'].includes(testCase.control) ? 2 : 1;
+      const ackEpoch = ['ack-after-frame','binding-before-ack'].includes(testCase.control) ? 2 : 1;
+      const freshEpoch = testCase.control.startsWith('binding-before-') ? 1 : testCase.control.startsWith('ack-') ? 4 : 2;
+      const hasAnchor = testCase.control !== 'missing-anchor';
+      const ackVersion = ['ready','authoritative-terminal','missing-anchor'].includes(testCase.control) ? 7 : 9;
+      const identity = {thread_id:'synthetic-terminal-debt',source_seq:44,session_id:3600,lease_epoch:retainedEpoch,checkpoint_config_version:7};
+      const anchor = testCase.control === 'malformed-anchor' ? null : {...identity,
+        thread_id:testCase.control === 'foreign-anchor' ? 'foreign-thread' : identity.thread_id,
+        lease_epoch:testCase.control === 'fractional-anchor' ? 1.5 : ackEpoch,checkpoint_config_version:ackVersion};
+      const binding = {session_id:3600,lease_epoch:freshEpoch,next_frame_index:39,checkpoint_config:{version:8,thresholds:{max_bytes:512,max_deltas:1,max_interval_ms:2000}}};
       const transport = {push:async (_topic,event,payload) => {
         events.push(event);
         if(event === 'terminal_debt_identity') {
           if(testCase.control === 'disconnect') closeRequiredAdtAdmissionForDisconnect(transport);
-          return {status:'ok',response:{ok:true,identity:{...identity,...(testCase.control === 'foreign' ? {thread_id:'foreign-thread'} : {})}}};
+          return {status:'ok',response:{ok:true,identity:{...identity,...(hasAnchor ? {ack_identity:anchor} : {}),...(testCase.control === 'foreign' ? {thread_id:'foreign-thread'} : {})}}};
         }
         if(event === 'adt_binding_reconcile') {
-          if(payload.checkpoint_config_version !== 7 || payload.lease_epoch !== 1) throw new Error('cold lookup changed original generation');
-          return {status:'ok',response:{ok:true,adt:{verdict:'already_applied',binding}}};
+          if(payload.checkpoint_config_version !== ackVersion || payload.lease_epoch !== ackEpoch) throw new Error('cold lookup changed durable ACK identity');
+          return {status:'ok',response:{ok:true,adt:{verdict:testCase.control === 'authoritative-terminal' ? 'authoritative_terminal' : testCase.control === 'missing-anchor' ? 'applied' : 'already_applied',binding}}};
         }
         throw new Error('cold recovery attempted unexpected event: '+event);
       }};
       const pipeline = {
-        failedTerminalEntries:()=>[{entrySeq:61,kind:'adt.terminal_attempt',data:{seq:44,status:'processed',turn_id:'synthetic-completed-turn',terminal_frame:{session_id:3600,lease_epoch:1,frame_index:40,frame_kind:'terminal',assistant_phase:'final_answer',source_stream_key:'wrong-key',body:'Synthetic completed answer.'}}}],
+        failedTerminalEntries:()=>[{entrySeq:61,kind:'adt.terminal_attempt',data:{seq:44,status:'processed',turn_id:'synthetic-completed-turn',terminal_frame:{session_id:3600,lease_epoch:retainedEpoch,frame_index:40,frame_kind:'terminal',assistant_phase:'final_answer',source_stream_key:'wrong-key',body:'Synthetic completed answer.'}}}],
         repairTerminalDebt:async request => {
-          if(request.sessionId !== 3600 || request.originalLeaseEpoch !== 1 || request.sourceSeq !== 44 || request.binding !== binding || request.authoritativeTerminal) throw new Error('cold repair identity mismatch');
+          const terminal = testCase.control === 'authoritative-terminal';
+          if(request.sessionId !== 3600 || request.originalLeaseEpoch !== retainedEpoch || request.sourceSeq !== 44 || request.binding !== (terminal ? null : binding) || request.authoritativeTerminal !== terminal) throw new Error('cold repair identity mismatch');
           if(!request.authorize({seq:44})) throw new Error('cold repair unexpectedly unauthorized');
           repairs += 1;
           return {kind:'ready',id:'fixture',serializedData:'fixture'};
@@ -636,6 +728,8 @@ async function handle(testCase) {
     }
     case 'terminalDebtStorm':
       return await terminalDebtStorm(testCase);
+    case 'terminalDebtJournal':
+      return await terminalDebtJournal(testCase);
     case 'controlDispatch':
       return await handleControlDispatch(testCase);
     case 'staleness':