owlrunkit 0.19.2 → 0.21.0

package/scripts/runkit-contract/team-project.mjs

@@ -17,6 +17,8 @@ import {
   quickSnapshotFingerprintValid,
   validWorkspaceSnapshotShape,
 } from "../../packages/attest/src/quick-receipt-contract.mjs";
+import { readFileBytesBounded } from "../../packages/attest/src/formal.mjs";
+import { attestCoreBoundQuickReceiptDetailsFromBytes } from "./quick-attest.mjs";
 import {
   assertAllowedKeys,
   isRecord,
@@ -32,9 +34,12 @@ const EVENT_SCHEMA_V2 = "OwlCodaRunKitTeamProjectEventV2";
 const EVENT_SCHEMA_V3 = "OwlCodaRunKitTeamProjectEventV3";
 const EVENT_SCHEMA_V4 = "OwlCodaRunKitTeamProjectEventV4";
 const EVENT_SCHEMA_V5 = "OwlCodaRunKitTeamProjectEventV5";
+const EVENT_SCHEMA_V6 = "OwlCodaRunKitTeamProjectEventV6";
+const EVENT_SCHEMA_V7 = "OwlCodaRunKitTeamProjectEventV7";
 const STATUS_SCHEMA_V1 = "OwlCodaRunKitTeamProjectStatusV1";
 const STATUS_SCHEMA_V2 = "OwlCodaRunKitTeamProjectStatusV2";
 const STATUS_SCHEMA_V3 = "OwlCodaRunKitTeamProjectStatusV3";
+const STATUS_SCHEMA_V4 = "OwlCodaRunKitTeamProjectStatusV4";
 
 const DEFINITION_KEYS = [
   "schemaVersion",
@@ -55,6 +60,31 @@ const WORK_ITEM_STATES = new Set([
   "failed",
 ]);
 const VERIFICATION_DISPOSITIONS = new Set(["verified", "no_longer_required"]);
+const DELIVERY_STAGES = Object.freeze([
+  "source",
+  "integration",
+  "materialization",
+  "deployment",
+  "live_readback",
+  "product_acceptance",
+]);
+const DELIVERY_STAGE_OUTCOMES = Object.freeze({
+  source: new Set(["accepted", "rejected"]),
+  integration: new Set(["integrated", "rejected"]),
+  materialization: new Set(["materialized", "failed"]),
+  deployment: new Set(["deployed", "failed", "rolled_back"]),
+  live_readback: new Set(["passed", "failed"]),
+  product_acceptance: new Set(["accepted", "rejected", "deferred"]),
+});
+const DELIVERY_POSITIVE_OUTCOME = Object.freeze({
+  source: "accepted",
+  integration: "integrated",
+  materialization: "materialized",
+  deployment: "deployed",
+  live_readback: "passed",
+  product_acceptance: "accepted",
+});
+const EXTERNAL_GATE_STATUSES = new Set(["pending", "passed", "blocked", "deferred"]);
 const EVENT_KEYS = Object.freeze({
   agent_assigned: [
     "schemaVersion", "eventId", "type", "occurredAt", "assignmentId",
@@ -132,6 +162,28 @@ const EVENT_KEYS = Object.freeze({
     "previousOwnedPaths", "ownedPaths", "previousMeasurable", "measurable",
     "reason", "evidenceRefs",
   ],
+  external_gate_reconciled: [
+    "schemaVersion", "eventId", "type", "occurredAt", "reconciliationId",
+    "supersedesReconciliationId", "gateId", "title", "requiredFor",
+    "gateStatus", "ownerAgentId", "sourceAdapterId", "sourceRef",
+    "sourceSha256", "summary", "evidenceRefs", "authorizationGranted",
+  ],
+  delivery_lifecycle_recorded: [
+    "schemaVersion", "eventId", "type", "occurredAt", "recordId",
+    "supersedesRecordId", "stage", "stageStatus", "ownerAgentId",
+    "summary", "evidenceRefs", "externalGateIds", "authorizationGranted",
+  ],
+  work_item_evidence_requirement_set: [
+    "schemaVersion", "eventId", "type", "occurredAt", "policyId",
+    "supersedesPolicyId", "workItemId", "ownerAgentId", "requirement",
+    "reason", "evidenceRefs", "authorizationGranted",
+  ],
+  checkpoint_receipt_bound: [
+    "schemaVersion", "eventId", "type", "occurredAt", "checkpointId",
+    "assignmentId", "workItemId", "state", "summary", "completedUnits",
+    "evidenceRefs", "blockerRefs", "decisionRefs", "nextAction",
+    "sourceFingerprint", "receiptBinding", "authorizationGranted",
+  ],
 });
 
 function canonical(value) {
@@ -672,10 +724,10 @@ function validateEventShape(value, definition) {
     throw new Error("Team project event type is invalid.");
   }
   assertAllowedKeys(value, `Team project event ${value.eventId ?? "unknown"}`, EVENT_KEYS[value.type]);
-  if (![EVENT_SCHEMA, EVENT_SCHEMA_V2, EVENT_SCHEMA_V3, EVENT_SCHEMA_V4, EVENT_SCHEMA_V5]
+  if (![EVENT_SCHEMA, EVENT_SCHEMA_V2, EVENT_SCHEMA_V3, EVENT_SCHEMA_V4, EVENT_SCHEMA_V5, EVENT_SCHEMA_V6, EVENT_SCHEMA_V7]
     .includes(value.schemaVersion)) {
     throw new Error(
-      `Team project event schemaVersion must be ${EVENT_SCHEMA}, ${EVENT_SCHEMA_V2}, ${EVENT_SCHEMA_V3}, ${EVENT_SCHEMA_V4}, or ${EVENT_SCHEMA_V5}.`,
+      `Team project event schemaVersion must be ${EVENT_SCHEMA}, ${EVENT_SCHEMA_V2}, ${EVENT_SCHEMA_V3}, ${EVENT_SCHEMA_V4}, ${EVENT_SCHEMA_V5}, ${EVENT_SCHEMA_V6}, or ${EVENT_SCHEMA_V7}.`,
     );
   }
   if (value.type === "rework_returned" && value.schemaVersion !== EVENT_SCHEMA_V2) {
@@ -702,6 +754,27 @@ function validateEventShape(value, definition) {
   if (value.schemaVersion === EVENT_SCHEMA_V5 && value.type !== "work_item_scope_revised") {
     throw new Error(`${EVENT_SCHEMA_V5} is reserved for work_item_scope_revised events.`);
   }
+  const eventV6Types = new Set(["external_gate_reconciled", "delivery_lifecycle_recorded"]);
+  if (eventV6Types.has(value.type) && value.schemaVersion !== EVENT_SCHEMA_V6) {
+    throw new Error(`${value.type} requires schemaVersion ${EVENT_SCHEMA_V6}.`);
+  }
+  if (value.schemaVersion === EVENT_SCHEMA_V6 && !eventV6Types.has(value.type)) {
+    throw new Error(
+      `${EVENT_SCHEMA_V6} is reserved for external Gate and delivery lifecycle events.`,
+    );
+  }
+  const eventV7Types = new Set([
+    "work_item_evidence_requirement_set",
+    "checkpoint_receipt_bound",
+  ]);
+  if (eventV7Types.has(value.type) && value.schemaVersion !== EVENT_SCHEMA_V7) {
+    throw new Error(`${value.type} requires schemaVersion ${EVENT_SCHEMA_V7}.`);
+  }
+  if (value.schemaVersion === EVENT_SCHEMA_V7 && !eventV7Types.has(value.type)) {
+    throw new Error(
+      `${EVENT_SCHEMA_V7} is reserved for WorkItem evidence requirements and receipt binding.`,
+    );
+  }
   safeIdentifier(value.eventId, "eventId");
   const normalizedOccurredAt = normalizeTimestamp(value.occurredAt);
   const workItemIds = new Set(definition.workItems.map(row => row.id));
@@ -720,6 +793,8 @@ function validateEventShape(value, definition) {
     "responsibility_transferred",
     "work_item_scope_revised",
     "verification_deferred",
+    "work_item_evidence_requirement_set",
+    "checkpoint_receipt_bound",
   ].includes(value.type)) {
     assertWorkItem(value.workItemId);
   }
@@ -732,6 +807,7 @@ function validateEventShape(value, definition) {
     "upstream_reopened",
     "responsibility_transferred",
     "work_item_scope_revised",
+    "checkpoint_receipt_bound",
   ].includes(value.type)) {
     safeIdentifier(value.assignmentId, "assignmentId");
   }
@@ -1015,6 +1091,107 @@ function validateEventShape(value, definition) {
       previousMeasurable,
       measurable,
     };
+  } else if (value.type === "external_gate_reconciled") {
+    safeIdentifier(value.reconciliationId, "reconciliationId");
+    if (value.supersedesReconciliationId !== undefined) {
+      safeIdentifier(value.supersedesReconciliationId, "supersedesReconciliationId");
+    }
+    safeIdentifier(value.gateId, "external gateId");
+    nonEmptyString(value.title, "External Gate title");
+    if (!DELIVERY_STAGES.includes(value.requiredFor)) {
+      throw new Error("External Gate requiredFor must be a delivery stage.");
+    }
+    if (!EXTERNAL_GATE_STATUSES.has(value.gateStatus)) {
+      throw new Error("External Gate status is invalid.");
+    }
+    safeIdentifier(value.ownerAgentId, "External Gate ownerAgentId");
+    safeIdentifier(value.sourceAdapterId, "External Gate sourceAdapterId");
+    nonEmptyString(value.sourceRef, "External Gate sourceRef");
+    sha256Ref(value.sourceSha256, "External Gate sourceSha256");
+    nonEmptyString(value.summary, "External Gate summary");
+    stringArray(value.evidenceRefs, "External Gate evidenceRefs", { allowEmpty: false });
+    if (value.authorizationGranted !== false) {
+      throw new Error("External Gate authorizationGranted must remain false.");
+    }
+  } else if (value.type === "delivery_lifecycle_recorded") {
+    safeIdentifier(value.recordId, "delivery recordId");
+    if (value.supersedesRecordId !== undefined) {
+      safeIdentifier(value.supersedesRecordId, "supersedesRecordId");
+    }
+    if (!DELIVERY_STAGES.includes(value.stage)) {
+      throw new Error("Delivery lifecycle stage is invalid.");
+    }
+    if (!DELIVERY_STAGE_OUTCOMES[value.stage].has(value.stageStatus)) {
+      throw new Error(`Delivery lifecycle outcome is invalid for ${value.stage}.`);
+    }
+    safeIdentifier(value.ownerAgentId, "Delivery lifecycle ownerAgentId");
+    nonEmptyString(value.summary, "Delivery lifecycle summary");
+    stringArray(
+      value.evidenceRefs,
+      "Delivery lifecycle evidenceRefs",
+      { allowEmpty: false },
+    );
+    const gateIdsForRecord = stringArray(
+      value.externalGateIds,
+      "Delivery lifecycle externalGateIds",
+    );
+    for (const gateId of gateIdsForRecord) safeIdentifier(gateId, "externalGateId");
+    if (value.authorizationGranted !== false) {
+      throw new Error("Delivery lifecycle authorizationGranted must remain false.");
+    }
+  } else if (value.type === "work_item_evidence_requirement_set") {
+    safeIdentifier(value.policyId, "evidence policyId");
+    if (value.supersedesPolicyId !== undefined) {
+      safeIdentifier(value.supersedesPolicyId, "supersedesPolicyId");
+    }
+    safeIdentifier(value.ownerAgentId, "Evidence requirement ownerAgentId");
+    if (!new Set(["none", "quick"]).has(value.requirement)) {
+      throw new Error("WorkItem evidence requirement is invalid.");
+    }
+    nonEmptyString(value.reason, "WorkItem evidence requirement reason");
+    stringArray(
+      value.evidenceRefs,
+      "WorkItem evidence requirement evidenceRefs",
+      { allowEmpty: false },
+    );
+    if (value.authorizationGranted !== false) {
+      throw new Error("WorkItem evidence requirement authorizationGranted must remain false.");
+    }
+  } else if (value.type === "checkpoint_receipt_bound") {
+    safeIdentifier(value.checkpointId, "checkpointId");
+    if (!WORK_ITEM_STATES.has(value.state)) throw new Error("Checkpoint state is invalid.");
+    nonEmptyString(value.summary, "Checkpoint summary");
+    stringArray(value.evidenceRefs, "Checkpoint evidenceRefs");
+    stringArray(value.blockerRefs, "Checkpoint blockerRefs");
+    stringArray(value.decisionRefs, "Checkpoint decisionRefs");
+    nullableString(value.nextAction, "Checkpoint nextAction");
+    if (value.sourceFingerprint !== undefined
+      && !/^(?:sha256:)?[a-f0-9]{64}$/u.test(value.sourceFingerprint)) {
+      throw new Error("Checkpoint sourceFingerprint is invalid.");
+    }
+    if (value.completedUnits !== undefined
+      && (!Number.isSafeInteger(value.completedUnits) || value.completedUnits < 0)) {
+      throw new Error("Checkpoint completedUnits must be a non-negative integer.");
+    }
+    if (!isRecord(value.receiptBinding)) {
+      throw new Error("Checkpoint receiptBinding must be an object.");
+    }
+    assertAllowedKeys(value.receiptBinding, "Checkpoint receiptBinding", [
+      "kind", "receiptId", "receiptRef", "receiptSha256",
+      "sourceFingerprint", "attestationDecision", "issueCodes",
+    ]);
+    if (value.receiptBinding.kind !== "quick"
+      || value.receiptBinding.attestationDecision !== "GO") {
+      throw new Error("Checkpoint receiptBinding must be one GO Quick receipt.");
+    }
+    safeIdentifier(value.receiptBinding.receiptId, "Quick receiptId");
+    safeSourcePath(value.receiptBinding.receiptRef, "Quick receiptRef");
+    sha256Ref(value.receiptBinding.receiptSha256, "Quick receiptSha256");
+    sha256Ref(value.receiptBinding.sourceFingerprint, "Quick sourceFingerprint");
+    stringArray(value.receiptBinding.issueCodes, "Quick attestation issueCodes");
+    if (value.authorizationGranted !== false) {
+      throw new Error("Receipt-bound checkpoint authorizationGranted must remain false.");
+    }
   }
   return { ...structuredClone(value), occurredAt: normalizedOccurredAt };
 }
@@ -1034,6 +1211,10 @@ function projectEvents(definition, records) {
   const sourceDeliveries = [];
   const scopeRevisions = new Map();
   const scopeRevisionHistory = new Map(definition.workItems.map(row => [row.id, []]));
+  const externalGates = new Map();
+  const deliveryRecords = new Map();
+  const evidenceRequirements = new Map();
+  const receiptBindings = new Map();
   const seenAssignments = new Set();
   const seenReworks = new Set();
   const seenReopens = new Set();
@@ -1041,6 +1222,10 @@ function projectEvents(definition, records) {
   const seenDecisions = new Set();
   const seenDeliveries = new Set();
   const seenScopeRevisions = new Set();
+  const seenExternalGateReconciliations = new Set();
+  const seenDeliveryRecords = new Set();
+  const seenEvidencePolicies = new Set();
+  const seenReceiptBindings = new Set();
   const seenFactIds = new Set(records.map(row => row.event.eventId));
 
   for (const { event, ref } of records) {
@@ -1347,6 +1532,130 @@ function projectEvents(definition, records) {
       assignments.set(event.workItemId, assignment);
       assignmentHistory.get(event.workItemId).push(assignment);
       transfers.set(event.workItemId, { ...event, ref });
+    } else if (event.type === "external_gate_reconciled") {
+      if (seenExternalGateReconciliations.has(event.reconciliationId)) {
+        throw new Error(`Duplicate external Gate reconciliation ${event.reconciliationId}.`);
+      }
+      const previous = externalGates.get(event.gateId) ?? null;
+      if (event.supersedesReconciliationId !== previous?.reconciliationId) {
+        throw new Error(
+          `External Gate ${event.gateId} must supersede current reconciliation `
+          + `${previous?.reconciliationId ?? "none"}.`,
+        );
+      }
+      if (previous && previous.requiredFor !== event.requiredFor) {
+        throw new Error(
+          `External Gate ${event.gateId} cannot change required delivery stage.`,
+        );
+      }
+      seenExternalGateReconciliations.add(event.reconciliationId);
+      externalGates.set(event.gateId, { ...event, ref });
+    } else if (event.type === "delivery_lifecycle_recorded") {
+      if (seenDeliveryRecords.has(event.recordId)) {
+        throw new Error(`Duplicate delivery lifecycle record ${event.recordId}.`);
+      }
+      const previous = deliveryRecords.get(event.stage) ?? null;
+      if (event.supersedesRecordId !== previous?.recordId) {
+        throw new Error(
+          `Delivery stage ${event.stage} must supersede current record `
+          + `${previous?.recordId ?? "none"}.`,
+        );
+      }
+      const stageIndex = DELIVERY_STAGES.indexOf(event.stage);
+      const downstream = DELIVERY_STAGES.slice(stageIndex + 1)
+        .find(stage => deliveryRecords.has(stage));
+      if (downstream) {
+        throw new Error(
+          `Delivery stage ${event.stage} cannot change after downstream delivery truth already exists.`,
+        );
+      }
+      const decisionsResolved = [...decisions.values()].every(row => row.resolved !== null);
+      const stateSnapshot = {
+        checkpoints,
+        reopens,
+        scopeRevisions,
+      };
+      if (completedWorkItemIds(definition, stateSnapshot).size !== definition.workItems.length
+        || gatePasses.size !== definition.integrationGates.length
+        || !decisionsResolved) {
+        throw new Error("Delivery lifecycle requires a completed Project Driver work ledger.");
+      }
+      if (stageIndex > 0) {
+        const prerequisiteStage = DELIVERY_STAGES[stageIndex - 1];
+        const prerequisite = deliveryRecords.get(prerequisiteStage) ?? null;
+        const requiredOutcome = DELIVERY_POSITIVE_OUTCOME[prerequisiteStage];
+        if (prerequisite?.stageStatus !== requiredOutcome) {
+          throw new Error(
+            `Delivery stage ${event.stage} requires ${prerequisiteStage}=${requiredOutcome}.`,
+          );
+        }
+      }
+      const requiredGates = [...externalGates.values()]
+        .filter(gate => gate.requiredFor === event.stage)
+        .sort((left, right) => compareIdentifiers(left.gateId, right.gateId));
+      const unresolvedGate = requiredGates.find(gate => gate.gateStatus !== "passed");
+      if (unresolvedGate) {
+        throw new Error(
+          `Delivery stage ${event.stage} external Gate ${unresolvedGate.gateId} is `
+          + `${unresolvedGate.gateStatus}.`,
+        );
+      }
+      const requiredGateIds = requiredGates.map(gate => gate.gateId);
+      if (canonical(event.externalGateIds) !== canonical(requiredGateIds)) {
+        throw new Error(
+          `Delivery stage ${event.stage} must bind passed external Gates: `
+          + `${requiredGateIds.join(", ") || "none"}.`,
+        );
+      }
+      seenDeliveryRecords.add(event.recordId);
+      deliveryRecords.set(event.stage, { ...event, ref });
+    } else if (event.type === "work_item_evidence_requirement_set") {
+      if (seenEvidencePolicies.has(event.policyId)) {
+        throw new Error(`Duplicate WorkItem evidence policy ${event.policyId}.`);
+      }
+      const current = evidenceRequirements.get(event.workItemId) ?? null;
+      if (event.supersedesPolicyId !== current?.policyId) {
+        throw new Error(
+          `WorkItem ${event.workItemId} evidence policy must supersede `
+          + `${current?.policyId ?? "none"}.`,
+        );
+      }
+      const assignment = assignments.get(event.workItemId) ?? null;
+      if (assignment?.agentId !== event.ownerAgentId) {
+        throw new Error("WorkItem evidence policy must bind the current owner.");
+      }
+      const checkpoint = checkpoints.get(event.workItemId) ?? null;
+      if (checkpoint && ["completed", "failed"].includes(checkpoint.state)) {
+        throw new Error("WorkItem evidence policy cannot change terminal WorkItem truth.");
+      }
+      seenEvidencePolicies.add(event.policyId);
+      evidenceRequirements.set(event.workItemId, { ...event, ref });
+    } else if (event.type === "checkpoint_receipt_bound") {
+      if (seenReceiptBindings.has(event.checkpointId)) {
+        throw new Error(`Duplicate receipt-bound checkpoint ${event.checkpointId}.`);
+      }
+      const current = assignments.get(event.workItemId) ?? null;
+      if (current?.assignmentId !== event.assignmentId) {
+        throw new Error("Receipt-bound checkpoint must bind the current assignment.");
+      }
+      seenReceiptBindings.add(event.checkpointId);
+      const checkpoint = {
+        ...event,
+        type: "checkpoint_recorded",
+        evidenceRefs: uniqueSorted([
+          ...event.evidenceRefs,
+          event.receiptBinding.receiptRef,
+        ]),
+        ref,
+      };
+      checkpoints.set(event.workItemId, checkpoint);
+      receiptBindings.set(event.workItemId, {
+        ...structuredClone(event.receiptBinding),
+        checkpointId: event.checkpointId,
+        assignmentId: event.assignmentId,
+        occurredAt: event.occurredAt,
+        truthRef: ref,
+      });
     }
   }
   return {
@@ -1364,6 +1673,10 @@ function projectEvents(definition, records) {
     sourceDeliveries,
     scopeRevisions,
     scopeRevisionHistory,
+    externalGates,
+    deliveryRecords,
+    evidenceRequirements,
+    receiptBindings,
   };
 }
 
@@ -1749,6 +2062,103 @@ function verificationReceiptWarning(workItem) {
   };
 }
 
+function externalGateProjection(gate) {
+  return {
+    schemaVersion: "OwlCodaRunKitExternalGateV1",
+    gateId: gate.gateId,
+    title: gate.title,
+    requiredFor: gate.requiredFor,
+    gateStatus: gate.gateStatus,
+    blocking: gate.gateStatus !== "passed",
+    ownerAgentId: gate.ownerAgentId,
+    source: {
+      adapterId: gate.sourceAdapterId,
+      ref: gate.sourceRef,
+      sha256: gate.sourceSha256,
+    },
+    summary: gate.summary,
+    evidenceRefs: [...gate.evidenceRefs],
+    occurredAt: gate.occurredAt,
+    truthRefs: [gate.ref],
+    authorizationGranted: false,
+  };
+}
+
+function deliveryLifecycleProjection(overall, state) {
+  const stages = DELIVERY_STAGES.map((stage) => {
+    const record = state.deliveryRecords.get(stage) ?? null;
+    return {
+      stage,
+      status: record?.stageStatus ?? "pending",
+      recordId: record?.recordId ?? null,
+      ownerAgentId: record?.ownerAgentId ?? null,
+      summary: record?.summary ?? null,
+      evidenceRefs: [...(record?.evidenceRefs ?? [])],
+      externalGateIds: [...(record?.externalGateIds ?? [])],
+      occurredAt: record?.occurredAt ?? null,
+      truthRef: record?.ref ?? null,
+    };
+  });
+  let currentStage = overall === "completed"
+    ? "work_ledger_complete"
+    : "work_ledger_incomplete";
+  let nextRequiredStage = overall === "completed" ? DELIVERY_STAGES[0] : null;
+  let blockingStage = null;
+  if (overall === "completed") {
+    const projectedNames = {
+      source: "source_accepted",
+      integration: "integrated",
+      materialization: "materialized",
+      deployment: "deployed",
+      live_readback: "live_readback_passed",
+      product_acceptance: "product_accepted",
+    };
+    for (const stage of stages) {
+      if (stage.status === "pending") {
+        nextRequiredStage = stage.stage;
+        break;
+      }
+      if (stage.status !== DELIVERY_POSITIVE_OUTCOME[stage.stage]) {
+        blockingStage = stage.stage;
+        nextRequiredStage = stage.stage;
+        break;
+      }
+      currentStage = projectedNames[stage.stage];
+      nextRequiredStage = stage.stage === DELIVERY_STAGES.at(-1)
+        ? null
+        : DELIVERY_STAGES[DELIVERY_STAGES.indexOf(stage.stage) + 1];
+    }
+  }
+  const unresolvedGates = [...state.externalGates.values()]
+    .filter(gate => gate.gateStatus !== "passed")
+    .sort((left, right) => (
+      DELIVERY_STAGES.indexOf(left.requiredFor) - DELIVERY_STAGES.indexOf(right.requiredFor)
+      || compareIdentifiers(left.gateId, right.gateId)
+    ));
+  const nextStageIndex = nextRequiredStage === null
+    ? DELIVERY_STAGES.length
+    : DELIVERY_STAGES.indexOf(nextRequiredStage);
+  const blockingExternalGateIds = unresolvedGates
+    .filter(gate => DELIVERY_STAGES.indexOf(gate.requiredFor) <= nextStageIndex)
+    .map(gate => gate.gateId);
+  const lifecycleStatus = currentStage === "product_accepted"
+    && blockingExternalGateIds.length === 0
+    ? "completed"
+    : blockingStage !== null || blockingExternalGateIds.length > 0
+      ? "blocked"
+      : "in_progress";
+  return {
+    schemaVersion: "OwlCodaRunKitDeliveryLifecycleV1",
+    lifecycleStatus,
+    currentStage,
+    nextRequiredStage,
+    blockingStage,
+    blockingExternalGateIds,
+    stages,
+    authorizationGranted: false,
+  };
+}
+
 function projectStatus(definition, records, workspaceRoot = null) {
   const projectDefinition = definition;
   const state = projectEvents(definition, records);
@@ -1761,6 +2171,8 @@ function projectStatus(definition, records, workspaceRoot = null) {
     const rework = state.reworks.get(item.id) ?? null;
     const sourceDeliveries = state.sourceDeliveries.filter(row => row.workItemId === item.id);
     const scopeRevisionHistory = state.scopeRevisionHistory.get(item.id) ?? [];
+    const evidenceRequirementFact = state.evidenceRequirements.get(item.id) ?? null;
+    const receiptBindingFact = state.receiptBindings.get(item.id) ?? null;
     const latestScopeRevision = scopeRevisionHistory.at(-1) ?? null;
     const latestSourceDeliveryFact = sourceDeliveries.at(-1) ?? null;
     const latestSourceDelivery = sourceDeliveryProjection(sourceDeliveries.at(-1) ?? null);
@@ -1857,6 +2269,7 @@ function projectStatus(definition, records, workspaceRoot = null) {
       ...(currentTransfer ? [currentTransfer.ref] : []),
       ...sourceDeliveries.map(row => row.ref),
       ...scopeRevisionHistory.map(row => row.ref),
+      ...(evidenceRequirementFact ? [evidenceRequirementFact.ref] : []),
     ];
     const projectedRework = reworkProjection(
       currentRework,
@@ -1911,6 +2324,30 @@ function projectStatus(definition, records, workspaceRoot = null) {
       pendingHandoff,
       rework: projectedRework,
       latestSourceDelivery,
+      evidenceRequirement: evidenceRequirementFact
+        ? {
+            policyId: evidenceRequirementFact.policyId,
+            requirement: evidenceRequirementFact.requirement,
+            ownerAgentId: evidenceRequirementFact.ownerAgentId,
+            reason: evidenceRequirementFact.reason,
+            evidenceRefs: [...evidenceRequirementFact.evidenceRefs],
+            occurredAt: evidenceRequirementFact.occurredAt,
+            truthRef: evidenceRequirementFact.ref,
+          }
+        : {
+            policyId: null,
+            requirement: "none",
+            ownerAgentId: null,
+            reason: null,
+            evidenceRefs: [],
+            occurredAt: null,
+            truthRef: null,
+          },
+      boundVerificationReceipt: receiptBindingFact !== null
+        && receiptBindingFact.assignmentId === assignment?.assignmentId
+        && effectiveCheckpoint?.checkpointId === receiptBindingFact.checkpointId
+        ? structuredClone(receiptBindingFact)
+        : null,
       lastCheckpointAt: checkpoint?.occurredAt ?? null,
       evidenceRefs: projectedFact?.evidenceRefs ?? [],
       assignmentHistory: history,
@@ -2126,6 +2563,10 @@ function projectStatus(definition, records, workspaceRoot = null) {
     && openDecisions.length === 0) overall = "completed";
   else if (openDecisions.length > 0 || workItems.some(row => row.status === "failed")) overall = "active_with_blockers";
   else if (workItems.some(row => row.status !== "planned" || row.pendingHandoff !== null)) overall = "active";
+  const externalGates = [...state.externalGates.values()]
+    .map(externalGateProjection)
+    .sort((left, right) => compareIdentifiers(left.gateId, right.gateId));
+  const deliveryLifecycle = deliveryLifecycleProjection(overall, state);
   const status = {
     schemaVersion: STATUS_SCHEMA_V3,
     status: "team_project_status",
@@ -2147,6 +2588,8 @@ function projectStatus(definition, records, workspaceRoot = null) {
     dataCandidates,
     sourceDeliveries,
     warnings,
+    externalGates,
+    deliveryLifecycle,
     projectTruthHash: sha256(canonical({
       definition: projectDefinition,
       events: records.map(row => row.event),
@@ -2156,10 +2599,55 @@ function projectStatus(definition, records, workspaceRoot = null) {
   return { ...status, ...deriveProjectDriverSummary(status) };
 }
 
-function validateEventAgainstState(event, definition, records, workspaceRoot) {
+function validateEventAgainstState(
+  event,
+  definition,
+  records,
+  workspaceRoot,
+  { allowBoundReceipt = false } = {},
+) {
   const normalized = validateEventShape(event, definition);
   const state = projectEvents(definition, records);
   const status = projectStatus(definition, records, workspaceRoot);
+  if (normalized.schemaVersion === EVENT_SCHEMA_V6) {
+    projectEvents(definition, [
+      ...records,
+      { event: normalized, ref: `project/events/${normalized.eventId}.json` },
+    ]);
+    return normalized;
+  }
+  if (normalized.type === "work_item_evidence_requirement_set") {
+    projectEvents(definition, [
+      ...records,
+      { event: normalized, ref: `project/events/${normalized.eventId}.json` },
+    ]);
+    return normalized;
+  }
+  if (normalized.type === "checkpoint_receipt_bound") {
+    const {
+      receiptBinding: _receiptBinding,
+      authorizationGranted: _authorizationGranted,
+      checkpointId: _checkpointId,
+      ...checkpointFields
+    } = normalized;
+    const checkpointEvent = {
+      ...checkpointFields,
+      schemaVersion: EVENT_SCHEMA,
+      type: "checkpoint_recorded",
+    };
+    validateEventAgainstState(
+      checkpointEvent,
+      definition,
+      records,
+      workspaceRoot,
+      { allowBoundReceipt: true },
+    );
+    projectEvents(definition, [
+      ...records,
+      { event: normalized, ref: `project/events/${normalized.eventId}.json` },
+    ]);
+    return normalized;
+  }
   const effectiveDefinition = definitionWithScopeRevisions(definition, state);
   const workItem = effectiveDefinition.workItems.find(row => row.id === normalized.workItemId);
   if (normalized.type === "agent_assigned") {
@@ -2218,6 +2706,15 @@ function validateEventAgainstState(event, definition, records, workspaceRoot) {
     if (normalized.state === "completed" && unresolved.length > 0) {
       throw new Error(`Completed checkpoint has unresolved dependencies: ${unresolved.join(", ")}.`);
     }
+    const evidenceRequirement = state.evidenceRequirements.get(normalized.workItemId) ?? null;
+    if (!allowBoundReceipt
+      && ["verifying", "completed"].includes(normalized.state)
+      && evidenceRequirement?.requirement === "quick") {
+      throw new Error(
+        `WorkItem ${normalized.workItemId} requires a bound Quick receipt. `
+        + "Use project checkpoint --from-quick-receipt <receipt.json>.",
+      );
+    }
     if (normalized.state === "verifying") {
       const history = state.assignmentHistory.get(normalized.workItemId) ?? [];
       const prior = history.at(-2) ?? null;
@@ -3262,6 +3759,340 @@ export function integrateTeamProjectV1({
   };
 }
 
+export function reconcileExternalGateV1({
+  workspaceRoot,
+  reconciliationId,
+  occurredAt,
+  gateId,
+  title,
+  requiredFor,
+  gateStatus,
+  ownerAgentId,
+  sourceAdapterId,
+  sourceRef,
+  sourceSha256,
+  summary,
+  evidenceRefs = [],
+}) {
+  safeIdentifier(reconciliationId, "reconciliationId");
+  const loaded = loadProject(workspaceRoot);
+  const state = projectEvents(loaded.definition, loaded.events);
+  const existing = loaded.events.find(row => (
+    row.event.type === "external_gate_reconciled"
+    && row.event.reconciliationId === reconciliationId
+  ))?.event ?? null;
+  let event;
+  if (existing) {
+    const requested = {
+      occurredAt: normalizeTimestamp(occurredAt),
+      gateId,
+      title,
+      requiredFor,
+      gateStatus,
+      ownerAgentId,
+      sourceAdapterId,
+      sourceRef,
+      sourceSha256,
+      summary,
+      evidenceRefs,
+    };
+    for (const key of Object.keys(requested)) {
+      if (canonical(existing[key]) !== canonical(requested[key])) {
+        throw new Error(`Cannot resume external Gate reconciliation ${reconciliationId}; ${key} differs.`);
+      }
+    }
+    event = existing;
+  } else {
+    const previous = state.externalGates.get(gateId) ?? null;
+    event = {
+      schemaVersion: EVENT_SCHEMA_V6,
+      eventId: `external-gate-${reconciliationId}`,
+      type: "external_gate_reconciled",
+      occurredAt,
+      reconciliationId,
+      ...(previous ? { supersedesReconciliationId: previous.reconciliationId } : {}),
+      gateId,
+      title,
+      requiredFor,
+      gateStatus,
+      ownerAgentId,
+      sourceAdapterId,
+      sourceRef,
+      sourceSha256,
+      summary,
+      evidenceRefs,
+      authorizationGranted: false,
+    };
+  }
+  const recorded = appendTeamProjectEventV1({ workspaceRoot, event });
+  const status = readTeamProjectStatusV4({ workspaceRoot });
+  const gate = status.externalGates.find(row => row.gateId === gateId);
+  if (!gate || gate.gateStatus !== gateStatus) {
+    throw new Error(`External Gate reconciliation ${reconciliationId} is not current.`);
+  }
+  return {
+    status: "team_project_external_gate_reconciled",
+    reconciliationId,
+    supersedesReconciliationId: event.supersedesReconciliationId ?? null,
+    gateId,
+    gateStatus,
+    eventId: recorded.eventId,
+    eventPath: recorded.eventPath,
+    eventSha256: recorded.eventSha256,
+    resumed: recorded.resumed,
+    projectTruthHash: status.projectTruthHash,
+    dominantGap: status.dominantGap,
+    nextAction: status.nextAction,
+    nextActorId: status.nextActorId,
+    authorizationGranted: false,
+    exitCode: 0,
+  };
+}
+
+export function recordDeliveryLifecycleV1({
+  workspaceRoot,
+  recordId,
+  occurredAt,
+  stage,
+  stageStatus,
+  ownerAgentId,
+  summary,
+  evidenceRefs = [],
+  externalGateIds = [],
+}) {
+  safeIdentifier(recordId, "delivery recordId");
+  const loaded = loadProject(workspaceRoot);
+  const state = projectEvents(loaded.definition, loaded.events);
+  const existing = loaded.events.find(row => (
+    row.event.type === "delivery_lifecycle_recorded"
+    && row.event.recordId === recordId
+  ))?.event ?? null;
+  let event;
+  if (existing) {
+    const requested = {
+      occurredAt: normalizeTimestamp(occurredAt),
+      stage,
+      stageStatus,
+      ownerAgentId,
+      summary,
+      evidenceRefs,
+      externalGateIds,
+    };
+    for (const key of Object.keys(requested)) {
+      if (canonical(existing[key]) !== canonical(requested[key])) {
+        throw new Error(`Cannot resume delivery lifecycle record ${recordId}; ${key} differs.`);
+      }
+    }
+    event = existing;
+  } else {
+    const previous = state.deliveryRecords.get(stage) ?? null;
+    event = {
+      schemaVersion: EVENT_SCHEMA_V6,
+      eventId: `delivery-lifecycle-${recordId}`,
+      type: "delivery_lifecycle_recorded",
+      occurredAt,
+      recordId,
+      ...(previous ? { supersedesRecordId: previous.recordId } : {}),
+      stage,
+      stageStatus,
+      ownerAgentId,
+      summary,
+      evidenceRefs,
+      externalGateIds,
+      authorizationGranted: false,
+    };
+  }
+  const recorded = appendTeamProjectEventV1({ workspaceRoot, event });
+  const status = readTeamProjectStatusV4({ workspaceRoot });
+  const stageProjection = status.deliveryLifecycle.stages.find(row => row.stage === stage);
+  if (stageProjection?.recordId !== recordId) {
+    throw new Error(`Delivery lifecycle record ${recordId} is not current.`);
+  }
+  return {
+    status: "team_project_delivery_lifecycle_recorded",
+    recordId,
+    supersedesRecordId: event.supersedesRecordId ?? null,
+    stage,
+    stageStatus,
+    eventId: recorded.eventId,
+    eventPath: recorded.eventPath,
+    eventSha256: recorded.eventSha256,
+    resumed: recorded.resumed,
+    projectTruthHash: status.projectTruthHash,
+    deliveryLifecycle: status.deliveryLifecycle,
+    dominantGap: status.dominantGap,
+    nextAction: status.nextAction,
+    nextActorId: status.nextActorId,
+    authorizationGranted: false,
+    exitCode: 0,
+  };
+}
+
+export function setWorkItemEvidenceRequirementV1({
+  workspaceRoot,
+  policyId,
+  occurredAt,
+  workItemId,
+  ownerAgentId,
+  requirement,
+  reason,
+  evidenceRefs = [],
+}) {
+  safeIdentifier(policyId, "evidence policyId");
+  const loaded = loadProject(workspaceRoot);
+  const state = projectEvents(loaded.definition, loaded.events);
+  const existing = loaded.events.find(row => (
+    row.event.type === "work_item_evidence_requirement_set"
+    && row.event.policyId === policyId
+  ))?.event ?? null;
+  let event;
+  if (existing) {
+    const requested = {
+      occurredAt: normalizeTimestamp(occurredAt),
+      workItemId,
+      ownerAgentId,
+      requirement,
+      reason,
+      evidenceRefs,
+    };
+    for (const key of Object.keys(requested)) {
+      if (canonical(existing[key]) !== canonical(requested[key])) {
+        throw new Error(`Cannot resume WorkItem evidence policy ${policyId}; ${key} differs.`);
+      }
+    }
+    event = existing;
+  } else {
+    const previous = state.evidenceRequirements.get(workItemId) ?? null;
+    event = {
+      schemaVersion: EVENT_SCHEMA_V7,
+      eventId: `work-item-evidence-${policyId}`,
+      type: "work_item_evidence_requirement_set",
+      occurredAt,
+      policyId,
+      ...(previous ? { supersedesPolicyId: previous.policyId } : {}),
+      workItemId,
+      ownerAgentId,
+      requirement,
+      reason,
+      evidenceRefs,
+      authorizationGranted: false,
+    };
+  }
+  const recorded = appendTeamProjectEventV1({ workspaceRoot, event });
+  const status = readTeamProjectStatusV4({ workspaceRoot });
+  const workItem = status.workItems.find(row => row.workItemId === workItemId);
+  if (workItem?.evidenceRequirement.policyId !== policyId) {
+    throw new Error(`WorkItem evidence policy ${policyId} is not current.`);
+  }
+  return {
+    status: "team_project_work_item_evidence_requirement",
+    policyId,
+    supersedesPolicyId: event.supersedesPolicyId ?? null,
+    workItemId,
+    requirement,
+    eventId: recorded.eventId,
+    eventPath: recorded.eventPath,
+    eventSha256: recorded.eventSha256,
+    resumed: recorded.resumed,
+    projectTruthHash: status.projectTruthHash,
+    authorizationGranted: false,
+    exitCode: 0,
+  };
+}
+
+function attestQuickReceiptBinding(workspaceRoot, receiptPath) {
+  const root = realpathSync(workspaceRoot);
+  const { absolutePath, bytes } = readFileBytesBounded(receiptPath);
+  const result = attestCoreBoundQuickReceiptDetailsFromBytes({
+    receiptPath: absolutePath,
+    receiptBytes: bytes,
+    workspaceRoot: root,
+  });
+  if (result.attestation.decision !== "GO") {
+    throw new Error(
+      `Quick receipt attestation must be GO; got ${result.attestation.decision}: `
+      + `${result.attestation.issueCodes.join(", ") || "no issue code"}.`,
+    );
+  }
+  return {
+    kind: "quick",
+    receiptId: result.attestation.subjectRef.receiptId,
+    receiptRef: relativeToWorkspace(root, absolutePath),
+    receiptSha256: result.attestation.subjectRef.receiptSha256,
+    sourceFingerprint: result.sourceFingerprint,
+    attestationDecision: "GO",
+    issueCodes: [...result.attestation.issueCodes],
+  };
+}
+
+export function checkpointTeamProjectFromQuickReceiptV1({
+  workspaceRoot,
+  checkpointId,
+  occurredAt,
+  assignmentId,
+  workItemId,
+  state,
+  summary,
+  completedUnits,
+  evidenceRefs = [],
+  blockerRefs = [],
+  decisionRefs = [],
+  nextAction = null,
+  sourceFingerprint,
+  receiptPath,
+}) {
+  safeIdentifier(checkpointId, "checkpointId");
+  const receiptBinding = attestQuickReceiptBinding(workspaceRoot, receiptPath);
+  if (sourceFingerprint !== undefined
+    && sourceFingerprint !== receiptBinding.sourceFingerprint) {
+    throw new Error("Checkpoint sourceFingerprint differs from the Quick receipt.");
+  }
+  const event = {
+    schemaVersion: EVENT_SCHEMA_V7,
+    eventId: `checkpoint-receipt-${checkpointId}`,
+    type: "checkpoint_receipt_bound",
+    occurredAt,
+    checkpointId,
+    assignmentId,
+    workItemId,
+    state,
+    summary,
+    ...(completedUnits === undefined ? {} : { completedUnits }),
+    evidenceRefs: uniqueSorted([...evidenceRefs, receiptBinding.receiptRef]),
+    blockerRefs,
+    decisionRefs,
+    nextAction,
+    sourceFingerprint: receiptBinding.sourceFingerprint,
+    receiptBinding,
+    authorizationGranted: false,
+  };
+  const recorded = appendTeamProjectEventV1({ workspaceRoot, event });
+  const status = readTeamProjectStatusV4({ workspaceRoot });
+  const workItem = status.workItems.find(row => row.workItemId === workItemId);
+  if (workItem?.boundVerificationReceipt?.checkpointId !== checkpointId) {
+    throw new Error(`Receipt-bound checkpoint ${checkpointId} is not current.`);
+  }
+  return {
+    status: "team_project_checkpoint",
+    checkpointId,
+    assignmentId,
+    workItemId,
+    state,
+    receiptBinding,
+    eventId: recorded.eventId,
+    eventPath: recorded.eventPath,
+    eventSha256: recorded.eventSha256,
+    resumed: recorded.resumed,
+    projectTruthHash: status.projectTruthHash,
+    overall: status.overall,
+    warnings: status.warnings.filter(row => row.workItemId === workItemId),
+    nextAction: status.nextAction,
+    nextActorId: status.nextActorId,
+    authorizationGranted: false,
+    exitCode: 0,
+  };
+}
+
 export function checkpointTeamProjectV1({
   workspaceRoot,
   checkpointId,
@@ -3423,6 +4254,8 @@ function legacyWorkItemProjection(workItem) {
     ownedPaths: _ownedPaths,
     measurable: _measurable,
     scopeRevision: _scopeRevision,
+    evidenceRequirement: _evidenceRequirement,
+    boundVerificationReceipt: _boundVerificationReceipt,
     ...legacy
   } = workItem;
   return legacy;
@@ -3434,11 +4267,23 @@ function statusV2WorkItemProjection(workItem) {
     ownedPaths: _ownedPaths,
     measurable: _measurable,
     scopeRevision: _scopeRevision,
+    evidenceRequirement: _evidenceRequirement,
+    boundVerificationReceipt: _boundVerificationReceipt,
     ...v2
   } = workItem;
   return v2;
 }
 
+function statusV3WorkItemProjection(workItem) {
+  if (workItem === null) return null;
+  const {
+    evidenceRequirement: _evidenceRequirement,
+    boundVerificationReceipt: _boundVerificationReceipt,
+    ...v3
+  } = workItem;
+  return v3;
+}
+
 function statusV3CompletionProjection(status) {
   if (status.overall !== "completed") {
     return { ...status, deliveryDisposition: "work_in_progress" };
@@ -3466,11 +4311,106 @@ function statusV3CompletionProjection(status) {
   };
 }
 
+function statusV4DeliveryProjection(status) {
+  if (status.overall !== "completed") {
+    return {
+      ...status,
+      schemaVersion: STATUS_SCHEMA_V4,
+      deliveryDisposition: status.deliveryLifecycle.currentStage,
+    };
+  }
+  const dueGate = status.externalGates
+    .filter(gate => gate.blocking)
+    .sort((left, right) => (
+      DELIVERY_STAGES.indexOf(left.requiredFor) - DELIVERY_STAGES.indexOf(right.requiredFor)
+      || compareIdentifiers(left.gateId, right.gateId)
+    ))
+    .find(gate => status.deliveryLifecycle.blockingExternalGateIds.includes(gate.gateId))
+    ?? null;
+  if (dueGate) {
+    const dominantGap = {
+      kind: "external_gate",
+      id: dueGate.gateId,
+      title: dueGate.title,
+      workItemId: null,
+      agentId: dueGate.ownerAgentId,
+      reason: dueGate.summary,
+      truthRefs: uniqueSorted(dueGate.truthRefs),
+    };
+    const nextAction = `Reconcile external Gate ${dueGate.gateId}.`;
+    return {
+      ...status,
+      schemaVersion: STATUS_SCHEMA_V4,
+      deliveryDisposition: status.deliveryLifecycle.currentStage,
+      headline: `Dominant gap: external Gate ${dueGate.gateId} (${dueGate.title}); `
+        + `owner: ${dueGate.ownerAgentId}; blocker: ${singleLine(dueGate.summary)}; `
+        + `next: ${nextAction}`,
+      dominantGap,
+      nextAction,
+      nextActorId: dueGate.ownerAgentId,
+    };
+  }
+  if (status.deliveryLifecycle.nextRequiredStage !== null) {
+    const stage = status.deliveryLifecycle.nextRequiredStage;
+    const stageProjection = status.deliveryLifecycle.stages.find(row => row.stage === stage);
+    const dominantGap = {
+      kind: "delivery_stage",
+      id: stage,
+      title: `Delivery stage ${stage}`,
+      workItemId: null,
+      agentId: stageProjection?.ownerAgentId ?? null,
+      reason: stageProjection?.status === "pending"
+        ? `Delivery stage ${stage} has no evidence-bound record.`
+        : stageProjection?.summary ?? `Delivery stage ${stage} is not accepted.`,
+      truthRefs: uniqueSorted([
+        "project/definition.json",
+        ...(stageProjection?.truthRef ? [stageProjection.truthRef] : []),
+      ]),
+    };
+    const nextAction = `Record delivery stage ${stage}.`;
+    return {
+      ...status,
+      schemaVersion: STATUS_SCHEMA_V4,
+      deliveryDisposition: status.deliveryLifecycle.currentStage,
+      headline: `Dominant gap: delivery stage ${stage}; owner: `
+        + `${dominantGap.agentId ?? "unassigned"}; blocker: ${singleLine(dominantGap.reason)}; `
+        + `next: ${nextAction}`,
+      dominantGap,
+      nextAction,
+      nextActorId: dominantGap.agentId,
+    };
+  }
+  return {
+    ...status,
+    schemaVersion: STATUS_SCHEMA_V4,
+    deliveryDisposition: status.deliveryLifecycle.currentStage,
+    headline: "Delivery lifecycle complete through product acceptance; authorizationGranted=false.",
+    dominantGap: {
+      kind: "none",
+      id: null,
+      title: null,
+      workItemId: null,
+      agentId: null,
+      reason: null,
+      truthRefs: uniqueSorted([
+        "project/definition.json",
+        ...status.deliveryLifecycle.stages
+          .map(stage => stage.truthRef)
+          .filter(Boolean),
+      ]),
+    },
+    nextAction: null,
+    nextActorId: null,
+  };
+}
+
 export function readTeamProjectStatusV1({ workspaceRoot }) {
   const loaded = loadProject(workspaceRoot);
   const {
     sourceDeliveries: _sourceDeliveries,
     warnings: _warnings,
+    externalGates: _externalGates,
+    deliveryLifecycle: _deliveryLifecycle,
     ...legacy
   } = projectStatus(
     loaded.definition,
@@ -3487,7 +4427,12 @@ export function readTeamProjectStatusV1({ workspaceRoot }) {
 
 export function readTeamProjectStatusV2({ workspaceRoot }) {
   const loaded = loadProject(workspaceRoot);
-  const { warnings: _warnings, ...v2 } = projectStatus(
+  const {
+    warnings: _warnings,
+    externalGates: _externalGates,
+    deliveryLifecycle: _deliveryLifecycle,
+    ...v2
+  } = projectStatus(
     loaded.definition,
     loaded.events,
     loaded.root,
@@ -3501,9 +4446,27 @@ export function readTeamProjectStatusV2({ workspaceRoot }) {
 }
 
 export function readTeamProjectStatusV3({ workspaceRoot }) {
+  const loaded = loadProject(workspaceRoot);
+  const {
+    externalGates: _externalGates,
+    deliveryLifecycle: _deliveryLifecycle,
+    ...v3
+  } = projectStatus(
+    loaded.definition,
+    loaded.events,
+    loaded.root,
+  );
+  return {
+    ...statusV3CompletionProjection(v3),
+    workItems: v3.workItems.map(statusV3WorkItemProjection),
+    exitCode: 0,
+  };
+}
+
+export function readTeamProjectStatusV4({ workspaceRoot }) {
   const loaded = loadProject(workspaceRoot);
   return {
-    ...statusV3CompletionProjection(projectStatus(
+    ...statusV4DeliveryProjection(projectStatus(
       loaded.definition,
       loaded.events,
       loaded.root,
@@ -3783,9 +4746,7 @@ export function formatTeamProjectStatusHumanV2(status) {
   return [
     status.headline,
     `Project: ${status.projectId} — ${singleLine(status.objective)}`,
-    `Work ledger: ${status.overall}${status.deliveryDisposition === "code_complete_without_release_authority"
-      ? `; delivery: ${status.deliveryDisposition}`
-      : ""}`,
+    `Work ledger: ${status.overall}; Delivery: ${status.deliveryDisposition}`,
     `Work: ${status.counts.completed}/${status.counts.total} completed; ${status.counts.active} active; ${status.counts.waiting_dependency + status.counts.waiting_decision} waiting`,
     `Agents: ${status.agents.map(agent => agent.agentId).join(", ") || "none assigned"}`,
     `Open decisions: ${status.openDecisions.map(row => row.decisionId).join(", ") || "none"}`,
@@ -3801,7 +4762,7 @@ export function formatTeamProjectStatusHumanV2(status) {
     ...(status.warnings?.length > 0
       ? [`Warnings: ${status.warnings.map(row => `${row.code}:${row.workItemId}`).join(", ")}`]
       : []),
-    `Next: ${nextAction}${status.nextActorId ? ` (owner ${status.nextActorId})` : ""}`,
+    `Next: ${nextAction}${status.nextActorId ? ` (owner ${status.nextActorId})` : ""}; Authority: not granted for Git, release, deployment, production, or business actions.`,
     "",
   ].join("\n");
 }