mancode 0.6.2 → 0.6.4

package/dist/{chunk-44UHUCE6.js → chunk-7HPP3KYG.js}

@@ -1163,7 +1163,11 @@ function parseOperationJournal(value) {
   return journal;
 }
 function assertOperationJournalTransition(previous, next, options) {
-  assertJournalIdentityIsStable(previous, next);
+  assertJournalIdentityIsStable(
+    previous,
+    next,
+    options.reframeCheckpointReplacement
+  );
   assertStepProgresses(previous.steps, next.steps);
   if (previous.state === next.state) return;
   if (!allowedOperationTransitions(previous.state).has(next.state)) {
@@ -1335,10 +1339,40 @@ function parseTimestamp2(value, label) {
   }
   return value;
 }
-function assertJournalIdentityIsStable(previous, next) {
-  if (previous.operationId !== next.operationId || previous.type !== next.type || previous.primaryStoreId !== next.primaryStoreId || previous.checkoutId !== next.checkoutId || previous.actorId !== next.actorId || previous.sessionId !== next.sessionId || JSON.stringify(previous.authorizationBasis) !== JSON.stringify(next.authorizationBasis) || previous.recoveryPayloadDigest !== next.recoveryPayloadDigest || previous.startedAt !== next.startedAt || JSON.stringify(previous.secondaryReservations) !== JSON.stringify(next.secondaryReservations) || JSON.stringify(previous.entityLocks) !== JSON.stringify(next.entityLocks) || JSON.stringify(previous.expectedRevisions) !== JSON.stringify(next.expectedRevisions)) {
+function assertJournalIdentityIsStable(previous, next, replacement) {
+  if (previous.operationId !== next.operationId || previous.type !== next.type || previous.primaryStoreId !== next.primaryStoreId || previous.checkoutId !== next.checkoutId || previous.actorId !== next.actorId || previous.sessionId !== next.sessionId || JSON.stringify(previous.authorizationBasis) !== JSON.stringify(next.authorizationBasis) || previous.startedAt !== next.startedAt || JSON.stringify(previous.secondaryReservations) !== JSON.stringify(next.secondaryReservations)) {
     throw new Error("operation journal identity fields are immutable");
   }
+  if (replacement === void 0) {
+    if (previous.recoveryPayloadDigest !== next.recoveryPayloadDigest || JSON.stringify(previous.entityLocks) !== JSON.stringify(next.entityLocks) || JSON.stringify(previous.expectedRevisions) !== JSON.stringify(next.expectedRevisions)) {
+      throw new Error("operation journal identity fields are immutable");
+    }
+    return;
+  }
+  assertReframeCheckpointReplacement(previous, next, replacement);
+}
+function assertReframeCheckpointReplacement(previous, next, replacement) {
+  assertUlid(replacement.fromCheckpointId, "reframe replacement checkpointId");
+  assertUlid(replacement.toCheckpointId, "reframe replacement checkpointId");
+  if (replacement.fromCheckpointId === replacement.toCheckpointId || previous.type !== "reframe" || next.type !== "reframe" || previous.state !== "repair_required" || next.state !== "repair_required" || previous.secondaryReservations.length !== 0 || previous.recoveryPayloadDigest === void 0 || next.recoveryPayloadDigest === void 0 || previous.recoveryPayloadDigest === next.recoveryPayloadDigest || JSON.stringify(previous.steps) !== JSON.stringify(next.steps)) {
+    throw new Error("MANCODE_REFRAME_CHECKPOINT_REPLACEMENT_INVALID");
+  }
+  const fromKey = `checkpoint:${replacement.fromCheckpointId}`;
+  const toKey = `checkpoint:${replacement.toCheckpointId}`;
+  if (previous.entityLocks.filter((key) => key === fromKey).length !== 1 || previous.entityLocks.includes(toKey) || JSON.stringify(next.entityLocks) !== JSON.stringify(
+    previous.entityLocks.map((key) => key === fromKey ? toKey : key)
+  ) || previous.expectedRevisions[fromKey] !== 0 || previous.expectedRevisions[toKey] !== void 0) {
+    throw new Error("MANCODE_REFRAME_CHECKPOINT_REPLACEMENT_INVALID");
+  }
+  const expectedRevisions = Object.fromEntries(
+    Object.entries(previous.expectedRevisions).map(([key, revision]) => [
+      key === fromKey ? toKey : key,
+      revision
+    ])
+  );
+  if (JSON.stringify(next.expectedRevisions) !== JSON.stringify(expectedRevisions)) {
+    throw new Error("MANCODE_REFRAME_CHECKPOINT_REPLACEMENT_INVALID");
+  }
 }
 function assertStepProgresses(previous, next) {
   if (previous.length !== next.length) {
@@ -1722,6 +1756,93 @@ function parseTimestamp4(value, label) {
   return value;
 }
 
+// src/context/man-delivery-evidence.ts
+var MAN_VERIFICATION_SURFACES = /* @__PURE__ */ new Set([
+  "unit",
+  "component",
+  "handler",
+  "real_http",
+  "browser",
+  "device",
+  "external_service",
+  "manual_observation"
+]);
+function parseManEvidenceSubject(value) {
+  assertRecord(value, "man evidence subject");
+  assertKnownKeys(
+    value,
+    ["contentDigest", "environment"],
+    "man evidence subject"
+  );
+  if (typeof value.contentDigest !== "string" || !/^sha256:[a-f0-9]{64}$/.test(value.contentDigest)) {
+    throw new Error("MANCODE_MAN_EVIDENCE_SUBJECT_INVALID");
+  }
+  return {
+    contentDigest: value.contentDigest,
+    environment: text(value.environment)
+  };
+}
+function parseManVerificationSurface(value) {
+  if (typeof value !== "string" || !MAN_VERIFICATION_SURFACES.has(value))
+    throw new Error("MANCODE_MAN_VERIFICATION_SURFACE_INVALID");
+  return value;
+}
+function parseManReviewEvidence(value) {
+  assertRecord(value, "man review evidence");
+  assertKnownKeys(
+    value,
+    [
+      "subject",
+      "reviewer",
+      "direction",
+      "correctness",
+      "proportionality",
+      "nextAction",
+      "coverage"
+    ],
+    "man review evidence"
+  );
+  if (value.reviewer !== "independent" && value.reviewer !== "self")
+    throw new Error("MANCODE_MAN_REVIEWER_INVALID");
+  if (!Array.isArray(value.coverage))
+    throw new Error("MANCODE_MAN_REVIEW_COVERAGE_INVALID");
+  const ids = /* @__PURE__ */ new Set();
+  const coverage = value.coverage.map(
+    (item) => {
+      assertRecord(item, "man review coverage");
+      assertKnownKeys(
+        item,
+        ["acceptanceId", "status", "evidence"],
+        "man review coverage"
+      );
+      const acceptanceId = text(item.acceptanceId);
+      if (ids.has(acceptanceId) || item.status !== "met" && item.status !== "missing" && item.status !== "unverified") {
+        throw new Error("MANCODE_MAN_REVIEW_COVERAGE_INVALID");
+      }
+      ids.add(acceptanceId);
+      return {
+        acceptanceId,
+        status: item.status,
+        evidence: text(item.evidence)
+      };
+    }
+  );
+  return {
+    subject: parseManEvidenceSubject(value.subject),
+    reviewer: value.reviewer,
+    direction: text(value.direction),
+    correctness: text(value.correctness),
+    proportionality: text(value.proportionality),
+    nextAction: text(value.nextAction),
+    coverage
+  };
+}
+function text(value) {
+  if (typeof value !== "string" || !value.trim())
+    throw new Error("MANCODE_MAN_EVIDENCE_TEXT_REQUIRED");
+  return value;
+}
+
 // src/context/requirements-ledger.ts
 var REQUIREMENT_DIMENSIONS = [
   "platform",
@@ -2079,7 +2200,8 @@ function parseAcceptanceCriteria(value) {
         "requirementIds",
         "statement",
         "required",
-        "verificationRequirement"
+        "verificationRequirement",
+        "verificationSurfaces"
       ],
       "requirements ledger acceptance criterion"
     );
@@ -2094,6 +2216,11 @@ function parseAcceptanceCriteria(value) {
         "requirements ledger criterion verificationRequirement is invalid"
       );
     }
+    const verificationRequirement = item.verificationRequirement;
+    const verificationSurfaces = parseVerificationSurfaces(
+      item.verificationSurfaces,
+      verificationRequirement
+    );
     return {
       ...identity,
       criterionId: item.criterionId,
@@ -2106,10 +2233,40 @@ function parseAcceptanceCriteria(value) {
         "requirements ledger criterion statement"
       ),
       required: item.required,
-      verificationRequirement: item.verificationRequirement
+      verificationRequirement,
+      ...verificationSurfaces === void 0 ? {} : { verificationSurfaces }
     };
   });
 }
+function assertManDeliveryVerificationSurfaces(ledger) {
+  for (const criterion of ledger.acceptanceCriteria) {
+    if (criterion.required && criterion.verificationSurfaces === void 0) {
+      throw new Error(
+        `MANCODE_MAN_ACCEPTANCE_SURFACE_REQUIRED: ${criterion.displayId}`
+      );
+    }
+  }
+}
+function parseVerificationSurfaces(value, requirement) {
+  if (value === void 0) return void 0;
+  assertRecord(value, "requirements ledger acceptance verificationSurfaces");
+  assertKnownKeys(
+    value,
+    ["automated", "manual"],
+    "requirements ledger acceptance verificationSurfaces"
+  );
+  const automated = value.automated === void 0 ? void 0 : parseManVerificationSurface(value.automated);
+  const manual = value.manual === void 0 ? void 0 : parseManVerificationSurface(value.manual);
+  if (requirement === "automated" && (automated === void 0 || manual !== void 0) || requirement === "manual" && (automated !== void 0 || manual === void 0) || requirement === "hybrid" && (automated === void 0 || manual === void 0)) {
+    throw new Error(
+      "requirements ledger acceptance verificationSurfaces must match verificationRequirement slots"
+    );
+  }
+  return {
+    ...automated === void 0 ? {} : { automated },
+    ...manual === void 0 ? {} : { manual }
+  };
+}
 function parseBlockingUnknowns(value) {
   if (!Array.isArray(value)) {
     throw new Error("requirements ledger blockingUnknowns must be an array");
@@ -2342,7 +2499,8 @@ function parseReviewLedger(value) {
       "legacySource",
       "contentDigest",
       "lastOperationId",
-      "updatedAt"
+      "updatedAt",
+      "delivery"
     ],
     "review ledger"
   );
@@ -2357,6 +2515,7 @@ function parseReviewLedger(value) {
   }
   const taskRef = parseTaskRefValue(value.taskRef);
   const ledger = {
+    ...value.delivery === void 0 ? {} : { delivery: parseManReviewEvidence(value.delivery) },
     schemaVersion: 1,
     canonicalizationVersion: "mancode-jcs-v1",
     taskRef,
@@ -2394,6 +2553,8 @@ function parseReviewLedger(value) {
     updatedAt: parseTimestamp6(value.updatedAt, "review ledger updatedAt")
   };
   assertReviewLedgerShape(ledger);
+  if (taskRef.namespace === "shared" && ledger.delivery)
+    assertSharedTextSafe(JSON.stringify(ledger.delivery), "man module review");
   if (ledger.contentDigest !== reviewLedgerDigest(ledger)) {
     throw new Error(
       "review ledger contentDigest does not match canonical content"
@@ -2404,6 +2565,7 @@ function parseReviewLedger(value) {
 }
 function reviewLedgerDigest(ledger) {
   return digestCanonicalJson({
+    ...ledger.delivery === void 0 ? {} : { delivery: ledger.delivery },
     schemaVersion: ledger.schemaVersion,
     canonicalizationVersion: ledger.canonicalizationVersion,
     taskRef: ledger.taskRef,
@@ -3026,7 +3188,7 @@ function assertVerificationLedgerRequirements(ledger, requirements) {
     }
   }
 }
-function assertVerificationLedgerTransition(previous, next) {
+function assertVerificationLedgerTransition(previous, next, contentInvalidated = false) {
   if (next.revision !== previous.revision + 1) {
     throw new Error(
       "verification ledger revision must increase exactly once per mutation"
@@ -3046,7 +3208,9 @@ function assertVerificationLedgerTransition(previous, next) {
   if (previous.legacySource === null && next.legacySource !== null) {
     throw new Error("verification ledger cannot introduce a legacy source");
   }
-  if (!allowedVerificationTransitions(previous.status).has(next.status)) {
+  if (!allowedVerificationTransitions(
+    contentInvalidated ? "stale" : previous.status
+  ).has(next.status)) {
     throw new Error(
       `invalid verification ledger status transition: ${previous.status} -> ${next.status}`
     );
@@ -3168,6 +3332,8 @@ function parseEvidence(value, taskRef, kind) {
       "artifactRef",
       "confirmedByActorId",
       "confirmationSource",
+      "subject",
+      "surface",
       "updatedAt"
     ],
     `verification ledger ${kind} evidence`
@@ -3223,6 +3389,11 @@ function parseEvidence(value, taskRef, kind) {
     `verification ledger ${kind} evidence command`
   );
   if (taskRef.namespace === "shared") {
+    if (value.subject !== void 0)
+      assertSharedTextSafe(
+        parseManEvidenceSubject(value.subject).environment,
+        "man verification environment"
+      );
     if (summary !== null) {
       assertSharedTextSafe(
         summary,
@@ -3238,6 +3409,8 @@ function parseEvidence(value, taskRef, kind) {
   }
   return {
     evidenceId: value.evidenceId,
+    ...value.subject === void 0 ? {} : { subject: parseManEvidenceSubject(value.subject) },
+    ...value.surface === void 0 ? {} : { surface: parseManVerificationSurface(value.surface) },
     status,
     summary,
     command,
@@ -3625,7 +3798,7 @@ function allowedTransitions(from) {
 
 // src/context/workflow-metadata.ts
 var SUPPORTED_WORKFLOW_POLICY_VERSIONS = {
-  planning: [1, 2],
+  planning: [1, 2, 3],
   review: [1, 2],
   verification: [1]
 };
@@ -3848,6 +4021,9 @@ function assertWorkflowMetadataTransition(previous, next, operation) {
       "workflow metadata revision must increase exactly once per mutation"
     );
   }
+  if ((previous.governance.policyVersions.planning === 3 || next.governance.policyVersions.planning === 3) && previous.governance.policyVersions.planning !== next.governance.policyVersions.planning) {
+    throw new Error("MANCODE_MAN_DELIVERY_POLICY_IMMUTABLE");
+  }
   if (previous.workflowMode !== next.workflowMode || previous.visibility !== next.visibility || previous.coordination !== next.coordination || previous.taskRef.namespace !== next.taskRef.namespace || previous.taskRef.taskId !== next.taskRef.taskId || JSON.stringify(previous.parent) !== JSON.stringify(next.parent)) {
     throw new Error(
       "workflow mode, dimensions, TaskRef, and parent are immutable"
@@ -4127,6 +4303,9 @@ function parseLegacyCompatibility(value) {
   };
 }
 function assertWorkflowMetadataShape(metadata) {
+  if (metadata.governance.policyVersions.planning === 3 && metadata.workflowMode !== "man") {
+    throw new Error("MANCODE_MAN_DELIVERY_MODE_REQUIRED");
+  }
   if (metadata.workflowMode === "man") {
     if (metadata.coordination !== "single" || metadata.parent !== null) {
       throw new Error(
@@ -5947,15 +6126,6 @@ function serializeSchemaManifest(value) {
 function managedAdapterNames(inventory) {
   return MANAGED_ADAPTERS.filter((adapter) => inventory[adapter] !== void 0);
 }
-function parseSchemaManifestV1(value) {
-  const manifest = parseSchemaManifest(value);
-  if (manifest.manifestVersion !== 1) {
-    throw new Error(
-      `MANCODE_MANIFEST_VERSION_UNSUPPORTED: observed=${manifest.manifestVersion} supported=1 requiredWriter=0.3.x`
-    );
-  }
-  return manifest;
-}
 function parseSchemaManifestV2(value) {
   const manifest = parseSchemaManifest(value);
   if (manifest.manifestVersion !== 2) {
@@ -7234,7 +7404,6 @@ export {
   parseSchemaManifest,
   serializeSchemaManifest,
   managedAdapterNames,
-  parseSchemaManifestV1,
   parseSchemaManifestV2,
   assertSchemaManifestTransition,
   assertSchemaManifestPolicyUpgrade,
@@ -7280,11 +7449,14 @@ export {
   parseCheckpoint,
   parseCheckpointKind,
   checkpointDigest,
+  parseManVerificationSurface,
+  parseManReviewEvidence,
   parseRequirementsLedger,
   requirementsLedgerDigest,
   assertRequirementsLedgerTransition,
   requirementsAreReady,
   assertRequirementsScopeConsistent,
+  assertManDeliveryVerificationSurfaces,
   parseArtifactRef,
   parseReviewLedger,
   reviewLedgerDigest,
@@ -7339,4 +7511,4 @@ export {
   V3ContextStore,
   storedTaskAggregateDigest
 };
-//# sourceMappingURL=chunk-44UHUCE6.js.map
+//# sourceMappingURL=chunk-7HPP3KYG.js.map