@linzumi/cli 1.0.256 → 1.0.257

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@linzumi/cli",
-  "version": "1.0.256",
+  "version": "1.0.257",
   "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

@@ -78,6 +78,14 @@ import {
   staleStartInstanceAgeMs,
   staleStartInstanceWindowMs,
 } from './src/runner';
+import {
+  registerRequiredAdtCandidate, acknowledgeRequiredAdtCandidate,
+  consumeRequiredAdtAdmission, closeRequiredAdtAdmissionForDisconnect,
+  reconcileRequiredAdtCandidates, requiredTransportFinalAdmission,
+  findRequiredAdtCandidate, releaseRequiredAdtCandidate,
+  recoverRetainedTerminalDebt,
+} from './src/channelSession';
+import {adoptAdtStreamBinding, installAdtPublicationBinding} from './src/pipeline/contracts';
 
 // --- Placeholder + snapshot plumbing --------------------------------------------
 
@@ -524,8 +532,110 @@ async function handleRespawn(testCase) {
 
 // --- Dispatch --------------------------------------------------------------------------------
 
+// 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 terminalDebtStorm(testCase) {
+  const binding = {session_id: 3600, lease_epoch: 1, next_frame_index: 39,
+    checkpoint_config: {version: 3, thresholds: {max_bytes: 1, max_deltas: 1, max_interval_ms: 2000}}};
+  const adopted = adoptAdtStreamBinding(binding, 44, 0);
+  if (adopted.kind !== 'accepted') throw new Error('terminal debt fixture binding refused');
+  const session = adopted.session;
+  const logs = [];
+  let resets = 0;
+  let restarts = 0;
+  let reconciliations = 0;
+  const transport = {
+    push: async (_topic, event) => {
+      if (event === 'adt_binding_ack') return {status: 'ok', response: {ok: true}};
+      if (event === 'adt_binding_reconcile') {
+        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},
+      }};
+      }
+      throw new Error('unexpected terminal-debt fixture event: ' + event);
+    },
+    hardReset: () => {resets += 1; return true;},
+  };
+  const candidate = registerRequiredAdtCandidate({transport,
+    identity: {thread_id: 'synthetic-terminal-debt', source_seq: 44, session_id: 3600,
+      lease_epoch: 1, checkpoint_config_version: 3},
+    installFreshBinding: raw => {
+      const fresh = adoptAdtStreamBinding(raw, 44, 0);
+      if (fresh.kind !== 'accepted') return false;
+      if (testCase.localState === 'idle') return false;
+      return installAdtPublicationBinding(session, fresh.session.binding, true).kind === 'accepted';
+    },
+    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.'}}}];
+      if (testCase.control === 'missing-debt') return [];
+      if (testCase.control === 'ambiguous-debt') return [...entries, {...entries[0], entrySeq: 62}];
+      return entries;
+    },
+    onUnrecoverable: () => {restarts += 1;},
+    log: event => logs.push(event),
+  });
+  try {
+    await acknowledgeRequiredAdtCandidate({topic: 'local_runner:fixture', payload: adopted.ackPayload, ticket: candidate});
+    if (testCase.control !== 'unconsumed-provider' && consumeRequiredAdtAdmission(candidate).kind !== 'admitted') throw new Error('fixture provider was not admitted');
+    session.emitter.fenced = true;
+    session.done = true;
+    for (let reconnect = 0; reconnect < 3; reconnect += 1) {
+      closeRequiredAdtAdmissionForDisconnect(transport);
+      await reconcileRequiredAdtCandidates({transport, topic: 'local_runner:fixture'});
+    }
+    return {resets, restarts, 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);}
+}
+
 async function handle(testCase) {
   switch (testCase.op) {
+    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 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'} : {})}}};
+        }
+        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}}};
+        }
+        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.'}}}],
+        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');
+          if(!request.authorize({seq:44})) throw new Error('cold repair unexpectedly unauthorized');
+          repairs += 1;
+          return {kind:'ready',id:'fixture',serializedData:'fixture'};
+        },
+      };
+      try {
+        await recoverRetainedTerminalDebt({transport,topic:'local_runner:fixture',threadId:identity.thread_id,pipeline,log:()=>{}});
+        return {events,repairs};
+      } finally {
+        const candidate = findRequiredAdtCandidate(transport, value => value.thread_id === identity.thread_id);
+        if(candidate !== undefined) releaseRequiredAdtCandidate(candidate);
+      }
+    }
+    case 'terminalDebtStorm':
+      return await terminalDebtStorm(testCase);
     case 'controlDispatch':
       return await handleControlDispatch(testCase);
     case 'staleness':

package/scripts/build-core-integration-parity-oracle.mjs

@@ -45,7 +45,7 @@ import {
   preReduceSnapshotItems,
   rawSnapshotItemsForTurn,
 } from './src/pipeline/integration';
-import { outboxEntryKinds } from './src/pipeline/contracts';
+import { outboxEntryKinds, adoptAdtStreamBinding } from './src/pipeline/contracts';
 import { phoenixPushErrors } from './src/phoenix';
 import {
   rememberTurnTraceparent,
@@ -306,8 +306,74 @@ async function runSessionCase(caseInput) {
   return { trace };
 }
 
+// Spec: spec/adt-final-answer-identity-rules.md, rules 1–3.
+// Actual producer/outbox boundary; assertions remain in the ReScript owner.
+async function runFinalCheckpointIdentity(input) {
+  const adoption = adoptAdtStreamBinding({session_id: 3600, lease_epoch: 1, next_frame_index: 37,
+    checkpoint_config: {version: 3, thresholds: {max_bytes: 1, max_deltas: 1, max_interval_ms: 2000}}}, 44, Date.now());
+  if (adoption.kind !== 'accepted') throw new Error('fixture_adoption_refused');
+  const pushes = [];
+  const logs = [];
+  let finishProvider;
+  const providerTerminal = new Promise(resolve => {finishProvider = resolve;});
+  const pipeline = createSessionPipeline({
+    instanceId: 'synthetic-yc-identity', threadKey: 'synthetic-final-identity', persistDir: undefined,
+    messageStateReplyShape: {kind: 'inner_response'},
+    wire: () => ({workspaceSlug: 'fixture', channelSlug: 'office', kandanThreadId: 'fixture-thread',
+      codexThreadId: 'fixture-provider-thread', rootSeq: 1}),
+    runnerPayload: (eventType, codexThreadId, sourceSeq, extra) => ({metadata: {local_codex_runner: {
+      ...extra, event_type: eventType, codex_thread_id: codexThreadId, source_message_seq: sourceSeq,
+    }}}),
+    sourceSeqForTurn: () => 44,
+    adtAuthorityForSourceSeq: seq => seq === 44 ? adoption.session : undefined,
+    resolveSnapshot: async () => ({items: mergeSnapshotItems(input.readItems, input.sessionItems)}),
+    onTurnTerminal: () => finishProvider(),
+    log: (event, fields) => logs.push({event, fields}), statsIntervalMs: 0,
+    push: async (event, payload) => {
+      pushes.push({event, payload});
+      if (event === 'terminal_attempt') return {terminal_attempt: {
+        frame: {accepted: true}, message_state: {disposition: 'applied', thread_id: 'fixture-thread', source_seq: 44},
+      }};
+      return {seq: pushes.length, accepted: true};
+    },
+  });
+  try {
+    pipeline.submitNotification('item/agentMessage/delta', {threadId: 'fixture-provider-thread',
+      turnId: 'fixture-turn', itemId: 'msg-live-final', delta: input.body});
+    pipeline.submitNotification('item/completed', {threadId: 'fixture-provider-thread', turnId: 'fixture-turn',
+      item: {id: 'msg-live-final', type: 'agentMessage', text: input.body, phase: 'final_answer'}});
+    await pipeline.flushOutbox(1000);
+    pipeline.submitNotification('turn/completed', {threadId: 'fixture-provider-thread', turn: {id: 'fixture-turn'}});
+    await providerTerminal;
+    await pipeline.flushOutbox(1000);
+    const metrics = pipeline.metrics();
+    return {
+      standalone: pushes.filter(push => push.event === 'adt_frame').map(push => push.payload),
+      terminals: pushes.filter(push => push.event === 'terminal_attempt').map(push => push.payload.terminal_frame),
+      depth: metrics.depth, failures: metrics.totalPermanentFailures,
+      faults: logs.filter(log => /rejected|refused|failed/.test(log.event)),
+    };
+  } finally { await pipeline.close(1000); }
+}
+
 async function runCase(input) {
   switch (input.kind) {
+    // Spec: spec/commander-recovery-rules.md authenticated terminal evidence.
+    case 'terminalRepairReceipt': {
+      const remembered = [];
+      const builder = createSessionPipelineBuilders({
+        instanceId: 'terminal-repair-fixture',
+        wire: () => ({workspaceSlug: 'synthetic', channelSlug: 'synthetic',
+          kandanThreadId: 'repair-thread', codexThreadId: 'provider-thread'}),
+        runnerPayload: () => ({}),
+        messageStateReplyShape: {kind: 'full_reply'},
+        log: () => {},
+      })['adt.terminal_attempt'];
+      const context = {remember: (key, value) => remembered.push({key, value}), recall: () => undefined};
+      const verdict = builder.replyPolicy.adjudicateReply(input.data, input.reply, context);
+      if (verdict.kind === 'accept') builder.onReply(input.data, input.reply, context);
+      return {accepted: verdict.kind === 'accept', remembered};
+    }
     case 'constants':
       return {
         defaultOutboxMaxInFlightPushes,
@@ -325,6 +391,8 @@ async function runCase(input) {
       return mergeSnapshotItems(input.readItems, input.sessionItems);
     case 'sessionRun':
       return runSessionCase(input);
+    case 'finalCheckpointIdentity':
+      return runFinalCheckpointIdentity(input);
     default:
       return { error: 'unknown case kind ' + String(input.kind) };
   }

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

@@ -41,8 +41,10 @@ import {
   mkdtempSync,
   mkdirSync,
   readdirSync,
+  rmSync,
   readFileSync,
   realpathSync,
+  renameSync,
   statSync,
   writeFileSync,
 } from 'node:fs';
@@ -95,8 +97,10 @@ import {
 import {
   outboxJournalPath,
   recoverOutboxJournal,
+  createOutboxJournal,
 } from './src/pipeline/outboxJournal';
 import { createThreadOutbox } from './src/pipeline/outbox';
+import { createSessionPipelineBuilders, enqueueTerminalDebtRepair } from './src/pipeline/integration';
 import {
   applyResumeDispatchOutcome,
   commitLiveAcceptedSourceSeq,
@@ -484,6 +488,29 @@ function handleOutboxJournal(testCase) {
   return substitute({ recovered, events }, dir, dirPlaceholder);
 }
 
+// Spec: spec/commander-recovery-rules.md rule01. Failed terminal publication
+// remains evidence/debt, never ordinary replay or an acknowledged terminal.
+async function handleFailedTerminalJournal(testCase) {
+  const dir = scratch();
+  const path = join(dir, 'failed-terminal.outbox.jsonl');
+  try {
+    writeFileSync(path, testCase.contents, 'utf8');
+    const events = [];
+    let recovered = recoverOutboxJournal(path, collectingLog(events, dir));
+    if (testCase.compact) {
+      const snapshot = recovered;
+      const journal = createOutboxJournal({path, compactionThreshold: 1,
+        snapshot: () => snapshot, log: collectingLog(events, dir)});
+      journal.appendAck(63);
+      await journal.settled();
+      await journal.close();
+      recovered = recoverOutboxJournal(path, collectingLog(events, dir));
+    }
+    return {pendingEntries: recovered.pendingEntries,
+      failedTerminalEntries: recovered.failedTerminalEntries, counters: recovered.counters, events};
+  } finally {rmSync(dir, {recursive: true, force: true});}
+}
+
 // --- Outbox flow scenarios ---------------------------------------------------------------------
 
 function buildersFromSpec(spec, recordedReplies) {
@@ -548,6 +575,14 @@ async function runOutboxPhaseInner(phase, shared) {
   const events = [];
   const log = collectingLog(events, shared.dir);
   let nowMs = phase.nowMs ?? 1_000;
+  const builders = buildersFromSpec(phase.builders ?? shared.builders, recordedReplies);
+  if (phase.terminalRepairBuilder === true) {
+    builders['adt.terminal_attempt'] = createSessionPipelineBuilders({
+      instanceId: 'repair-fixture', wire: () => ({workspaceSlug: 'synthetic', channelSlug: 'synthetic',
+        kandanThreadId: shared.threadKey, codexThreadId: 'synthetic-provider'}),
+      runnerPayload: () => ({}), messageStateReplyShape: {kind: 'full_reply'}, log,
+    })['adt.terminal_attempt'];
+  }
   const outbox = createThreadOutbox({
     threadKey: phase.threadKey ?? shared.threadKey,
     push: async (event, payload, timeoutMs, onSent) => {
@@ -570,7 +605,7 @@ async function runOutboxPhaseInner(phase, shared) {
       }
       throw failure;
     },
-    builders: buildersFromSpec(phase.builders ?? shared.builders, recordedReplies),
+    builders,
     persistDir: shared.persistDir,
     retryDelaysMs: phase.retryDelaysMs ?? [1, 1],
     isRetryBudgetExempt: (error) => error.name === 'ScriptedBudgetExempt',
@@ -613,6 +648,13 @@ async function runOutboxPhaseInner(phase, shared) {
           )
         );
         break;
+      case 'cycleReceipt': {
+        const receipt = outbox.recallDurableFact(action.key);
+        if(receipt === null || typeof receipt !== 'object') throw new Error('cyclic receipt fixture missing stored object');
+        receipt.cycle = receipt;
+        results.push({defined:false});
+        break;
+      }
       case 'pause':
         results.push(outcome(() => outbox.pause()));
         break;
@@ -654,6 +696,52 @@ async function runOutboxPhaseInner(phase, shared) {
         await outbox.journalSettled();
         results.push({ defined: false });
         break;
+      // Spec: spec/commander-recovery-rules.md. Only this scenario's fresh
+      // scratch directory is moved; a real filesystem refusal tests both implementations.
+      case 'blockJournalWrites':
+      case 'restoreJournalWrites': {
+        await outbox.journalSettled();
+        const blocked = shared.persistDir + '.blocked';
+        if (action.fn === 'blockJournalWrites') renameSync(shared.persistDir, blocked);
+        else renameSync(blocked, shared.persistDir);
+        results.push({defined: false});
+        break;
+      }
+      case 'appendUncertainTail':
+      case 'blockJournalCompaction':
+      case 'blockRekeyDestination':
+      case 'restoreJournalCompaction': {
+        await outbox.journalSettled();
+        const path = outboxJournalPath(shared.persistDir, shared.threadKey);
+        if (action.fn === 'blockRekeyDestination') mkdirSync(outboxJournalPath(shared.persistDir, action.threadKey));
+        else if (action.fn === 'appendUncertainTail') appendFileSync(path, '{"t":"kv","key":', 'utf8');
+        else if (action.fn === 'blockJournalCompaction') mkdirSync(path + '.tmp');
+        else renameSync(path + '.tmp', path + '.blocked-compaction');
+        results.push({defined: false});
+        break;
+      }
+      case 'failedTerminalEntries':
+        results.push({failedTerminalEntries: outbox.failedTerminalEntries()});
+        break;
+      case 'terminalPublicationDebt':
+        results.push({terminalPublicationDebt: outbox.terminalPublicationDebt()});
+        break;
+      case 'rememberDurableFact':
+        outbox.rememberDurableFact(action.key, action.value);
+        await outbox.journalSettled();
+        results.push({defined: false});
+        break;
+      case 'rememberWithoutSettle':
+        outbox.rememberDurableFact(action.key, action.value);
+        results.push({defined: false});
+        break;
+      case 'repairTerminalDebt':
+        results.push({repair: await enqueueTerminalDebtRepair(outbox, {
+          threadId: shared.threadKey, sourceSeq: 44, sessionId: 3600, originalLeaseEpoch: 1,
+          binding: action.binding, authoritativeTerminal: action.authoritativeTerminal === true,
+          authorize: () => true,
+        }, log)});
+        break;
       case 'rekeyJournal':
         results.push(outcome(() => outbox.rekeyJournal(action.threadKey)));
         await outbox.journalSettled();
@@ -855,6 +943,8 @@ async function handle(testCase) {
       return handleQuarantine(testCase);
     case 'outboxJournal':
       return handleOutboxJournal(testCase);
+    case 'failedTerminalJournal':
+      return await handleFailedTerminalJournal(testCase);
     case 'outboxScenario':
       return await handleOutboxScenario(testCase);
     case 'keystoneScenario':
@@ -892,6 +982,11 @@ await build({
     loader: 'ts',
   },
   bundle: true,
+  // Same production ESM/CJS bridge as the existing core integration oracle;
+  // the shared typed terminal-repair validator reaches CommanderNode bindings.
+  banner: {
+    js: "import { createRequire as __queueOracleCreateRequire } from 'node:module';\nconst require = __queueOracleCreateRequire(import.meta.url);",
+  },
   platform: 'node',
   target: 'node20',
   format: 'esm',