@sellable/mcp 0.1.771 → 0.1.772

package/dist/refill-run-loop.js

@@ -594,13 +594,22 @@ function actionSourceFingerprint(action) {
 }
 function fingerprintFromPlan(plan) {
     const packet = recordValue(plan.packet) ?? {};
+    const targetConfig = recordValue(plan.targetConfig) ?? recordValue(packet.targetConfig) ?? {};
+    const revisionInputs = recordValue(targetConfig.revisionInputs) ?? {};
     const action = firstAction(plan);
     const authority = action ? decodeRefillReadinessAuthority(action) : null;
     return {
-        planRevision: stringValue(plan.planRevision),
-        stateRevision: stringValue(plan.stateRevision) ?? stringValue(packet.stateRevision),
+        planRevision: stringValue(plan.planRevision) ??
+            stringValue(packet.planRevision) ??
+            stringValue(revisionInputs.planRevision),
+        stateRevision: stringValue(plan.stateRevision) ??
+            stringValue(packet.stateRevision) ??
+            stringValue(revisionInputs.stateRevision),
         targetShapeRevision: stringValue(packet.targetShapeRevision) ??
-            stringValue(packet.targetRevision),
+            stringValue(packet.targetRevision) ??
+            stringValue(plan.targetShapeRevision) ??
+            stringValue(plan.targetRevision) ??
+            stringValue(revisionInputs.targetShapeRevision),
         actionReadinessFingerprint: authority?.ok === true
             ? refillReadinessFingerprint(authority.value)
             : authority
@@ -1991,10 +2000,21 @@ function getPlanLine(plan) {
         fallbackSummary: stringValue(recordValue(itinerary.fallback)?.trigger) ?? "",
     };
 }
+function planRequiresEvergreenRevision(plan) {
+    const packet = recordValue(plan.packet) ?? {};
+    return Boolean(recordValue(plan.evergreen) ?? recordValue(packet.evergreen));
+}
 export function packetCoherenceFailure(plan) {
     const fingerprint = fingerprintFromPlan(plan);
-    if (!fingerprint.planRevision || !fingerprint.targetShapeRevision) {
-        return "missing_fingerprint";
+    if (!fingerprint.targetShapeRevision) {
+        return "missing_target_shape_revision";
+    }
+    // Active/plain campaign packets intentionally carry no planRevision.
+    // planRevision fingerprints the managed evergreen lane ordering and is
+    // emitted only when the planner returned an evergreen projection. Requiring
+    // it for every packet rejects valid active-campaign refills before g2.
+    if (planRequiresEvergreenRevision(plan) && !fingerprint.planRevision) {
+        return "missing_evergreen_plan_revision";
     }
     const action = firstAction(plan);
     const doneReason = doneReasonFromPlan(plan);
@@ -2742,7 +2762,7 @@ async function completeTerminal(input, deps, ctx, doneReasonInput, reportInput =
     };
 }
 async function gatePlan(input, deps, ctx) {
-    const plan = await deps.readPlan(refillPlanReadInput(input, { ctx, journal: false }));
+    let plan = await deps.readPlan(refillPlanReadInput(input, { ctx, journal: false }));
     if (plan.blocker === "workspace_access") {
         return {
             status: "blocked",
@@ -2762,23 +2782,41 @@ async function gatePlan(input, deps, ctx) {
         ctx.plan = plan;
         return completeTerminal(input, deps, ctx, "complete", { plan });
     }
-    const coherenceFailure = packetCoherenceFailure(plan);
+    let coherenceFailure = packetCoherenceFailure(plan);
+    if (coherenceFailure) {
+        // Packet assembly reads live planner state. Give a transiently split read
+        // one fresh, mutation-free chance to converge before classifying it as a
+        // durable planner defect.
+        const replanned = await deps.readPlan(refillPlanReadInput(input, { ctx, journal: false }));
+        if (canonicalReportingCoverageComplete(replanned)) {
+            ctx.plan = replanned;
+            return completeTerminal(input, deps, ctx, "complete", {
+                plan: replanned,
+            });
+        }
+        const replannedCoherenceFailure = packetCoherenceFailure(replanned);
+        if (!replannedCoherenceFailure) {
+            plan = replanned;
+            coherenceFailure = null;
+        }
+        else {
+            coherenceFailure = replannedCoherenceFailure;
+            plan = replanned;
+        }
+    }
     if (coherenceFailure) {
         await safeJournalAppend(ctx, deps, deps.journal.renderPlanSection({
             chosenSummary: `packet_incoherent: ${coherenceFailure}`,
             itinerarySummaries: [],
-            fallbackSummary: "replan once before blocking",
+            fallbackSummary: "fresh replan remained incoherent; terminalize and release the exact run",
         }));
-        return {
-            status: "blocked",
+        ctx.plan = plan;
+        return completeTerminal(input, deps, ctx, "blocked", {
             blocker: "packet_incoherent",
-            runId: ctx.runId,
-            fence: ctx.fence,
-            gate: ctx.gate,
             guidance: `Planner returned an incoherent packet: ${coherenceFailure}.`,
-            report: { coherenceFailure, plan },
-            journalPath: ctx.journalPath,
-        };
+            coherenceFailure,
+            plan,
+        });
     }
     const action = firstAction(plan);
     const doneReason = doneReasonFromPlan(plan);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sellable/mcp",
-  "version": "0.1.771",
+  "version": "0.1.772",
   "type": "module",
   "description": "Sellable MCP server for Claude Code, Codex, and Hermes campaign workflows",
   "main": "dist/index.js",