@linzumi/cli 1.0.150 → 1.0.152

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

@@ -216,7 +216,15 @@ async function runSessionCase(caseInput) {
       }
       throw new Error(step.message ?? 'scripted snapshot failure');
     },
-    onTurnTerminal: (turnId, outcome, reason, retryableEmptyTurn, autoResume, fate) => {
+    onTurnTerminal: (
+      turnId,
+      outcome,
+      reason,
+      retryableEmptyTurn,
+      autoResume,
+      fate,
+      freshSessionResume
+    ) => {
       trace.push({
         t: 'terminal',
         turnId,
@@ -224,6 +232,10 @@ async function runSessionCase(caseInput) {
         reason: reason ?? null,
         retryableEmptyTurn: retryableEmptyTurn === true,
         autoResumeMidStreamStall: autoResume === true,
+        // #3455 leg 4 (Greptile P2): the second-stall fresh-session flag is
+        // part of the compared terminal surface, so a future divergence in
+        // the ReScript reducer goes red here, not just in the TS e2e tests.
+        freshSessionResumeMidStreamStall: freshSessionResume === true,
         fate: fate ?? null,
       });
     },

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

@@ -66,6 +66,29 @@ import {
   terminalFailureRetryableStamp,
 } from './src/terminalFailureRetry';
 import { readLocalConfig, readLocalSignupAuth } from './src/localConfig';
+import {
+  ADT_BINDING_ACK_EVENT,
+  ADT_FRAME_ENTRY_KIND,
+  ADT_FRAME_EVENT,
+  ADT_STREAM_BINDING_KEY,
+  ADT_STREAM_V1_CAPABILITY,
+  adoptAdtStreamBinding,
+  adtBindingRefusalMessage,
+  adtFrameContentDigest,
+  adtFrameEntryData,
+  adtFrameTelemetry,
+  adtFrameWirePayload,
+  adtObserveOutboxEntry,
+  adtRejectionTelemetry,
+  classifyAdtAppendRejection,
+  fenceAdtEmitter,
+  finishAdtStream,
+  makeAdtFrameEmitter,
+  parseAdtStreamBinding,
+  pollAdtInterval,
+  pushAdtDelta,
+  utf8ByteLength,
+} from './src/pipeline/contracts';
 
 const jsonHelpers = {
   isJsonObject,
@@ -102,6 +125,27 @@ function outcome(run) {
   }
 }
 
+// --- adt_stream_v1 (Part C CLI-first leg): the adt protocol core rides
+// THIS oracle (its charter: the TS protocol modules; the zero-raw-JS
+// ratchet forbids a new sibling .mjs). Case ops are namespaced 'adt*'
+// where they would collide.
+const adtRowEntryKinds = {
+  postStreamedRow: 'pipeline.post_streamed_row',
+  streamSnapshot: 'pipeline.stream_snapshot',
+  finalizeRow: 'pipeline.finalize_row',
+  postCompletedRow: 'pipeline.post_completed_row',
+  messageState: 'pipeline.message_state',
+};
+
+const adtFrameOut = (frame) =>
+  frame === null
+    ? null
+    : {
+        entryData: adtFrameEntryData(frame),
+        wirePayload: adtFrameWirePayload(frame),
+        telemetry: adtFrameTelemetry(frame),
+      };
+
 function handle(testCase) {
   switch (testCase.op) {
     case 'jsonHelper': {
@@ -159,6 +203,114 @@ function handle(testCase) {
       const signupAuth = outcome(() => readLocalSignupAuth(path));
       return { config, signupAuth };
     }
+    case 'adtConstants':
+      return {
+        capability: ADT_STREAM_V1_CAPABILITY,
+        bindingKey: ADT_STREAM_BINDING_KEY,
+        frameEvent: ADT_FRAME_EVENT,
+        bindingAckEvent: ADT_BINDING_ACK_EVENT,
+        frameEntryKind: ADT_FRAME_ENTRY_KIND,
+      };
+    case 'parseBinding': {
+      const parsed = parseAdtStreamBinding(testCase.value);
+      return parsed.ok
+        ? { ok: true, binding: parsed.binding }
+        : { ok: false, reason: parsed.reason };
+    }
+    case 'refusalMessage':
+      return { message: adtBindingRefusalMessage(testCase.reason) };
+    case 'adopt': {
+      const adoption = adoptAdtStreamBinding(
+        testCase.binding,
+        testCase.sourceSeq,
+        testCase.nowMs ?? 0
+      );
+      if (adoption.kind === 'accepted') {
+        return {
+          kind: 'accepted',
+          ackPayload: adoption.ackPayload,
+          sourceSeq: adoption.session.sourceSeq,
+        };
+      }
+      if (adoption.kind === 'refused') {
+        return { kind: 'refused', reason: adoption.reason, message: adoption.message };
+      }
+      return { kind: 'absent' };
+    }
+    case 'emitterRun': {
+      const parsed = parseAdtStreamBinding(testCase.binding);
+      if (!parsed.ok) {
+        return { refused: parsed.reason };
+      }
+      const emitter = makeAdtFrameEmitter(parsed.binding, testCase.startMs ?? 0);
+      const results = [];
+      for (const step of testCase.steps) {
+        switch (step.op) {
+          case 'delta':
+            results.push(adtFrameOut(pushAdtDelta(emitter, step.chunk, step.nowMs)));
+            break;
+          case 'poll':
+            results.push(adtFrameOut(pollAdtInterval(emitter, step.nowMs)));
+            break;
+          case 'finish':
+            results.push(adtFrameOut(finishAdtStream(emitter, step.nowMs)));
+            break;
+          case 'fence':
+            fenceAdtEmitter(emitter);
+            results.push(null);
+            break;
+          default:
+            results.push({ unknownStep: String(step.op) });
+        }
+      }
+      return {
+        results,
+        final: {
+          cumulative: emitter.cumulative,
+          nextFrameIndex: emitter.nextFrameIndex,
+          emittedFrameCount: emitter.emittedFrameCount,
+          terminalEmitted: emitter.terminalEmitted,
+          fenced: emitter.fenced,
+        },
+      };
+    }
+    case 'tapRun': {
+      const adoption = adoptAdtStreamBinding(
+        testCase.binding,
+        testCase.sourceSeq,
+        testCase.startMs ?? 0
+      );
+      if (adoption.kind !== 'accepted') {
+        return { adoption: adoption.kind };
+      }
+      const session = adoption.session;
+      const results = testCase.entries.map((entry) =>
+        adtObserveOutboxEntry(
+          session,
+          entry.kind,
+          entry.data,
+          entry.nowMs ?? 0,
+          adtRowEntryKinds
+        ).map((frame) => adtFrameOut(frame))
+      );
+      return {
+        results,
+        final: {
+          trackedItemKey: session.trackedItemKey ?? null,
+          lastBody: session.lastBody,
+          done: session.done,
+        },
+      };
+    }
+    case 'classifyRejection':
+      return { reason: classifyAdtAppendRejection(testCase.value) };
+    case 'rejectionTelemetry':
+      return adtRejectionTelemetry(testCase.frame, testCase.reason);
+    case 'digest':
+      return {
+        digest: adtFrameContentDigest(testCase.frame),
+        byteLen: utf8ByteLength(testCase.frame.body),
+      };
     default:
       return { threw: true, message: 'unknown op ' + String(testCase.op) };
   }