owlrunkit 0.19.0 → 0.19.2

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

@@ -31,8 +31,10 @@ const EVENT_SCHEMA = "OwlCodaRunKitTeamProjectEventV1";
 const EVENT_SCHEMA_V2 = "OwlCodaRunKitTeamProjectEventV2";
 const EVENT_SCHEMA_V3 = "OwlCodaRunKitTeamProjectEventV3";
 const EVENT_SCHEMA_V4 = "OwlCodaRunKitTeamProjectEventV4";
+const EVENT_SCHEMA_V5 = "OwlCodaRunKitTeamProjectEventV5";
 const STATUS_SCHEMA_V1 = "OwlCodaRunKitTeamProjectStatusV1";
 const STATUS_SCHEMA_V2 = "OwlCodaRunKitTeamProjectStatusV2";
+const STATUS_SCHEMA_V3 = "OwlCodaRunKitTeamProjectStatusV3";
 
 const DEFINITION_KEYS = [
   "schemaVersion",
@@ -124,6 +126,12 @@ const EVENT_KEYS = Object.freeze({
     "toAgentId", "state", "summary", "completedUnits", "evidenceRefs",
     "blockerRefs", "decisionRefs", "nextAction", "sourceFingerprint",
   ],
+  work_item_scope_revised: [
+    "schemaVersion", "eventId", "type", "occurredAt", "revisionId",
+    "supersedesRevisionId", "assignmentId", "workItemId", "ownerAgentId",
+    "previousOwnedPaths", "ownedPaths", "previousMeasurable", "measurable",
+    "reason", "evidenceRefs",
+  ],
 });
 
 function canonical(value) {
@@ -617,6 +625,7 @@ function staleHandoffsForTakeover({ loaded, status, agentId, responsibilities })
           "source_delivery_imported",
           "upstream_reopened",
           "responsibility_transferred",
+          "work_item_scope_revised",
         ].includes(row.event.type)
       ));
       let reason = "superseded_by_current_truth";
@@ -646,13 +655,16 @@ function staleHandoffsForTakeover({ loaded, status, agentId, responsibilities })
     .sort((left, right) => compareIdentifiers(left.eventId, right.eventId));
 }
 
-function validateTimestamp(value) {
+function normalizeTimestamp(value) {
   if (typeof value !== "string"
-    || !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/u.test(value)
+    || !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?Z$/u.test(value)
     || Number.isNaN(Date.parse(value))) {
-    throw new Error("Team project event occurredAt must be an ISO-8601 UTC timestamp.");
+    throw new Error(
+      "Team project event occurredAt must be an ISO-8601 UTC timestamp "
+      + "(YYYY-MM-DDTHH:mm:ssZ or YYYY-MM-DDTHH:mm:ss.sssZ).",
+    );
   }
-  return value;
+  return new Date(value).toISOString();
 }
 
 function validateEventShape(value, definition) {
@@ -660,10 +672,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]
+  if (![EVENT_SCHEMA, EVENT_SCHEMA_V2, EVENT_SCHEMA_V3, EVENT_SCHEMA_V4, EVENT_SCHEMA_V5]
     .includes(value.schemaVersion)) {
     throw new Error(
-      `Team project event schemaVersion must be ${EVENT_SCHEMA}, ${EVENT_SCHEMA_V2}, ${EVENT_SCHEMA_V3}, or ${EVENT_SCHEMA_V4}.`,
+      `Team project event schemaVersion must be ${EVENT_SCHEMA}, ${EVENT_SCHEMA_V2}, ${EVENT_SCHEMA_V3}, ${EVENT_SCHEMA_V4}, or ${EVENT_SCHEMA_V5}.`,
     );
   }
   if (value.type === "rework_returned" && value.schemaVersion !== EVENT_SCHEMA_V2) {
@@ -684,8 +696,14 @@ function validateEventShape(value, definition) {
       `${EVENT_SCHEMA_V4} is reserved for upstream_reopened and responsibility_transferred events.`,
     );
   }
+  if (value.type === "work_item_scope_revised" && value.schemaVersion !== EVENT_SCHEMA_V5) {
+    throw new Error(`work_item_scope_revised requires schemaVersion ${EVENT_SCHEMA_V5}.`);
+  }
+  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.`);
+  }
   safeIdentifier(value.eventId, "eventId");
-  validateTimestamp(value.occurredAt);
+  const normalizedOccurredAt = normalizeTimestamp(value.occurredAt);
   const workItemIds = new Set(definition.workItems.map(row => row.id));
   const gateIds = new Set(definition.integrationGates.map(row => row.id));
   const assertWorkItem = (id) => {
@@ -700,6 +718,7 @@ function validateEventShape(value, definition) {
     "source_delivery_imported",
     "upstream_reopened",
     "responsibility_transferred",
+    "work_item_scope_revised",
     "verification_deferred",
   ].includes(value.type)) {
     assertWorkItem(value.workItemId);
@@ -712,6 +731,7 @@ function validateEventShape(value, definition) {
     "source_delivery_imported",
     "upstream_reopened",
     "responsibility_transferred",
+    "work_item_scope_revised",
   ].includes(value.type)) {
     safeIdentifier(value.assignmentId, "assignmentId");
   }
@@ -962,8 +982,41 @@ function validateEventShape(value, definition) {
       && !/^(?:sha256:)?[a-f0-9]{64}$/u.test(value.sourceFingerprint)) {
       throw new Error("Responsibility transfer sourceFingerprint is invalid.");
     }
+  } else if (value.type === "work_item_scope_revised") {
+    safeIdentifier(value.revisionId, "revisionId");
+    if (value.supersedesRevisionId !== undefined) {
+      safeIdentifier(value.supersedesRevisionId, "supersedesRevisionId");
+    }
+    safeIdentifier(value.ownerAgentId, "ownerAgentId");
+    const previousOwnedPaths = validateLeaseOwnedPaths(value.previousOwnedPaths);
+    const ownedPaths = validateLeaseOwnedPaths(value.ownedPaths);
+    const validateMeasurable = (measurable, label) => {
+      if (measurable === null) return null;
+      if (!isRecord(measurable)) throw new Error(`${label} must be an object or null.`);
+      assertAllowedKeys(measurable, label, ["unit", "total"]);
+      nonEmptyString(measurable.unit, `${label} unit`);
+      if (!Number.isSafeInteger(measurable.total) || measurable.total < 1) {
+        throw new Error(`${label} total must be a positive integer.`);
+      }
+      return { unit: measurable.unit, total: measurable.total };
+    };
+    const previousMeasurable = validateMeasurable(
+      value.previousMeasurable,
+      "Previous WorkItem measurable",
+    );
+    const measurable = validateMeasurable(value.measurable, "Revised WorkItem measurable");
+    nonEmptyString(value.reason, "WorkItem scope revision reason");
+    stringArray(value.evidenceRefs, "WorkItem scope revision evidenceRefs");
+    return {
+      ...structuredClone(value),
+      occurredAt: normalizedOccurredAt,
+      previousOwnedPaths,
+      ownedPaths,
+      previousMeasurable,
+      measurable,
+    };
   }
-  return structuredClone(value);
+  return { ...structuredClone(value), occurredAt: normalizedOccurredAt };
 }
 
 function projectEvents(definition, records) {
@@ -979,12 +1032,15 @@ function projectEvents(definition, records) {
   const verifications = new Map();
   const dataCandidates = [];
   const sourceDeliveries = [];
+  const scopeRevisions = new Map();
+  const scopeRevisionHistory = new Map(definition.workItems.map(row => [row.id, []]));
   const seenAssignments = new Set();
   const seenReworks = new Set();
   const seenReopens = new Set();
   const seenTransfers = new Set();
   const seenDecisions = new Set();
   const seenDeliveries = new Set();
+  const seenScopeRevisions = new Set();
   const seenFactIds = new Set(records.map(row => row.event.eventId));
 
   for (const { event, ref } of records) {
@@ -1052,7 +1108,8 @@ function projectEvents(definition, records) {
       }
       if (gatePasses.has(event.dueGateId)) {
         throw new Error(
-          `Deferred verification cannot target integration gate ${event.dueGateId}; gate already passed.`,
+          `Deferred verification cannot target integration gate ${event.dueGateId}; gate already passed. `
+          + "Create a successor project with project successor, or define a new unpassed gate before deferring.",
         );
       }
       verifications.set(event.verificationId, {
@@ -1098,6 +1155,38 @@ function projectEvents(definition, records) {
       }
       seenDeliveries.add(event.deliveryId);
       sourceDeliveries.push({ ...event, ref });
+    } else if (event.type === "work_item_scope_revised") {
+      if (seenScopeRevisions.has(event.revisionId)) {
+        throw new Error(`Duplicate WorkItem scope revision ${event.revisionId}.`);
+      }
+      const baseWorkItem = definition.workItems.find(row => row.id === event.workItemId);
+      const previous = scopeRevisions.get(event.workItemId) ?? null;
+      const currentAssignment = assignments.get(event.workItemId) ?? null;
+      const currentOwnedPaths = previous?.ownedPaths ?? baseWorkItem.ownedPaths;
+      const currentMeasurable = previous
+        ? previous.measurable
+        : baseWorkItem.measurable ?? null;
+      if (event.supersedesRevisionId !== previous?.revisionId) {
+        throw new Error(
+          `WorkItem scope revision ${event.revisionId} must supersede current revision ${previous?.revisionId ?? "none"}.`,
+        );
+      }
+      if (canonical(event.previousOwnedPaths) !== canonical(currentOwnedPaths)
+        || canonical(event.previousMeasurable) !== canonical(currentMeasurable)) {
+        throw new Error(
+          `WorkItem scope revision ${event.revisionId} does not bind the current scope.`,
+        );
+      }
+      if (currentAssignment?.assignmentId !== event.assignmentId
+        || currentAssignment.agentId !== event.ownerAgentId) {
+        throw new Error(
+          `WorkItem scope revision ${event.revisionId} does not bind the current assignment and owner.`,
+        );
+      }
+      seenScopeRevisions.add(event.revisionId);
+      const revision = { ...event, ref };
+      scopeRevisions.set(event.workItemId, revision);
+      scopeRevisionHistory.get(event.workItemId).push(revision);
     } else if (event.type === "upstream_reopened") {
       if (seenReopens.has(event.reopenId)) {
         throw new Error(`Duplicate upstream reopen ${event.reopenId}.`);
@@ -1273,6 +1362,26 @@ function projectEvents(definition, records) {
     verifications,
     dataCandidates,
     sourceDeliveries,
+    scopeRevisions,
+    scopeRevisionHistory,
+  };
+}
+
+function definitionWithScopeRevisions(definition, state) {
+  return {
+    ...definition,
+    workItems: definition.workItems.map((item) => {
+      const revision = state.scopeRevisions.get(item.id) ?? null;
+      if (!revision) return item;
+      const { measurable: _baseMeasurable, ...base } = item;
+      return {
+        ...base,
+        ownedPaths: [...revision.ownedPaths],
+        ...(revision.measurable === null
+          ? {}
+          : { measurable: structuredClone(revision.measurable) }),
+      };
+    }),
   };
 }
 
@@ -1610,7 +1719,9 @@ function completedWorkItemIds(definition, state) {
     for (const item of definition.workItems) {
       if (completed.has(item.id)) continue;
       const checkpoint = state.checkpoints.get(item.id) ?? null;
+      const scopeRevision = state.scopeRevisions.get(item.id) ?? null;
       if (checkpoint?.state !== "completed"
+        || (scopeRevision && compareEventFacts(checkpoint, scopeRevision) <= 0)
         || invalidatingReopensForWorkItem(state, item.id).length > 0
         || item.dependencies.some(id => !completed.has(id))) continue;
       completed.add(item.id);
@@ -1620,8 +1731,28 @@ function completedWorkItemIds(definition, state) {
   return completed;
 }
 
+function hasBoundVerificationReceipt(evidenceRefs) {
+  return evidenceRefs.some(ref => (
+    /(?:quick[^\s]*receipt|receipt[^\s]*quick|formal[^\s]*(?:receipt|check|closeout)|(?:receipt|check|closeout)[^\s]*formal|closeout-receipt)/iu
+      .test(ref)
+  ));
+}
+
+function verificationReceiptWarning(workItem) {
+  if (!["verifying", "completed"].includes(workItem.status)
+    || hasBoundVerificationReceipt(workItem.evidenceRefs)) return null;
+  return {
+    code: "no_bound_verification_receipt",
+    workItemId: workItem.workItemId,
+    message: "No Quick or Formal receipt reference is bound to the current verification state.",
+    truthRefs: uniqueSorted(workItem.truthRefs),
+  };
+}
+
 function projectStatus(definition, records, workspaceRoot = null) {
+  const projectDefinition = definition;
   const state = projectEvents(definition, records);
+  definition = definitionWithScopeRevisions(definition, state);
   const completed = completedWorkItemIds(definition, state);
   let workItems = definition.workItems.map((item) => {
     const assignment = state.assignments.get(item.id) ?? null;
@@ -1629,6 +1760,8 @@ function projectStatus(definition, records, workspaceRoot = null) {
     const handoff = state.handoffs.get(item.id) ?? 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 latestScopeRevision = scopeRevisionHistory.at(-1) ?? null;
     const latestSourceDeliveryFact = sourceDeliveries.at(-1) ?? null;
     const latestSourceDelivery = sourceDeliveryProjection(sourceDeliveries.at(-1) ?? null);
     const currentRework = rework?.assignmentId === assignment?.assignmentId ? rework : null;
@@ -1640,8 +1773,19 @@ function projectStatus(definition, records, workspaceRoot = null) {
     const currentTransfer = state.transfers.get(item.id)?.assignmentId === assignment?.assignmentId
       ? state.transfers.get(item.id)
       : null;
-    const effectiveCheckpoint = invalidatingReopens.length === 0 ? checkpoint : null;
-    let latestFact = [effectiveCheckpoint, handoff, currentRework, currentReopen, currentTransfer]
+    const scopeInvalidatesCheckpoint = checkpoint && latestScopeRevision
+      && compareEventFacts(checkpoint, latestScopeRevision) <= 0;
+    const effectiveCheckpoint = invalidatingReopens.length === 0 && !scopeInvalidatesCheckpoint
+      ? checkpoint
+      : null;
+    let latestFact = [
+      effectiveCheckpoint,
+      handoff,
+      currentRework,
+      currentReopen,
+      currentTransfer,
+      latestScopeRevision,
+    ]
       .reduce((latest, fact) => latestEventFact(latest, fact), null);
     if (currentTransfer && latestFact?.occurredAt === currentTransfer.occurredAt) {
       latestFact = currentTransfer;
@@ -1656,7 +1800,13 @@ function projectStatus(definition, records, workspaceRoot = null) {
       && latestFact?.eventId === activeHandoff.eventId
       && latestHandoffFact?.eventId !== activeHandoff.eventId;
     const projectedFact = handoffSupersededByDelivery
-      ? [effectiveCheckpoint, currentRework, currentReopen, currentTransfer]
+      ? [
+          effectiveCheckpoint,
+          currentRework,
+          currentReopen,
+          currentTransfer,
+          latestScopeRevision,
+        ]
         .reduce((latest, fact) => latestEventFact(latest, fact), null)
       : latestFact;
     const pendingHandoff = activeHandoff
@@ -1672,6 +1822,7 @@ function projectStatus(definition, records, workspaceRoot = null) {
     if (projectedFact?.type === "checkpoint_recorded") status = effectiveCheckpoint.state;
     if (projectedFact?.type === "responsibility_transferred") status = projectedFact.state;
     if (projectedFact?.type === "upstream_reopened") status = "active";
+    if (projectedFact?.type === "work_item_scope_revised") status = "active";
     if (assignment && unresolvedDependencies.length > 0
       && !["completed", "failed"].includes(status)) status = "waiting_dependency";
     if (executionTruth && (executionTruth.status !== "bound"
@@ -1705,6 +1856,7 @@ function projectStatus(definition, records, workspaceRoot = null) {
       ...reopenFacts.map(row => row.ref),
       ...(currentTransfer ? [currentTransfer.ref] : []),
       ...sourceDeliveries.map(row => row.ref),
+      ...scopeRevisionHistory.map(row => row.ref),
     ];
     const projectedRework = reworkProjection(
       currentRework,
@@ -1712,7 +1864,11 @@ function projectStatus(definition, records, workspaceRoot = null) {
         ? assignmentEvents.findIndex(row => row.assignmentId === currentRework.assignmentId) + 1
         : null,
     );
-    const latestSummary = ["rework_returned", "upstream_reopened"].includes(projectedFact?.type)
+    const latestSummary = [
+      "rework_returned",
+      "upstream_reopened",
+      "work_item_scope_revised",
+    ].includes(projectedFact?.type)
       ? projectedFact.reason
       : projectedFact?.summary ?? null;
     const checkpointLikeFact = ["checkpoint_recorded", "responsibility_transferred"]
@@ -1737,6 +1893,19 @@ function projectStatus(definition, records, workspaceRoot = null) {
         : unresolvedDependencies.map(id => `work-item:${id}`),
       decisionRefs: checkpointLikeFact ? checkpointLikeFact.decisionRefs : [],
       progress: measured,
+      ownedPaths: [...item.ownedPaths],
+      measurable: item.measurable ? structuredClone(item.measurable) : null,
+      scopeRevision: latestScopeRevision
+        ? {
+            revisionId: latestScopeRevision.revisionId,
+            supersedesRevisionId: latestScopeRevision.supersedesRevisionId ?? null,
+            occurredAt: latestScopeRevision.occurredAt,
+            ownerAgentId: latestScopeRevision.ownerAgentId,
+            reason: latestScopeRevision.reason,
+            evidenceRefs: [...latestScopeRevision.evidenceRefs],
+            truthRef: latestScopeRevision.ref,
+          }
+        : null,
       summary: latestSummary,
       nextAction: projectedFact?.nextAction ?? null,
       pendingHandoff,
@@ -1950,6 +2119,7 @@ function projectStatus(definition, records, workspaceRoot = null) {
     };
   });
   const sourceDeliveries = state.sourceDeliveries.map(sourceDeliveryProjection);
+  const warnings = workItems.map(verificationReceiptWarning).filter(Boolean);
   let overall = "planned";
   if (workItems.every(row => row.status === "completed")
     && integrationGates.every(row => row.status === "passed")
@@ -1957,7 +2127,7 @@ function projectStatus(definition, records, workspaceRoot = null) {
   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 status = {
-    schemaVersion: STATUS_SCHEMA_V2,
+    schemaVersion: STATUS_SCHEMA_V3,
     status: "team_project_status",
     projectId: definition.projectId,
     objective: definition.objective,
@@ -1976,7 +2146,11 @@ function projectStatus(definition, records, workspaceRoot = null) {
     integrationGates,
     dataCandidates,
     sourceDeliveries,
-    projectTruthHash: sha256(canonical({ definition, events: records.map(row => row.event) })),
+    warnings,
+    projectTruthHash: sha256(canonical({
+      definition: projectDefinition,
+      events: records.map(row => row.event),
+    })),
     authorizationGranted: false,
   };
   return { ...status, ...deriveProjectDriverSummary(status) };
@@ -1986,7 +2160,8 @@ function validateEventAgainstState(event, definition, records, workspaceRoot) {
   const normalized = validateEventShape(event, definition);
   const state = projectEvents(definition, records);
   const status = projectStatus(definition, records, workspaceRoot);
-  const workItem = definition.workItems.find(row => row.id === normalized.workItemId);
+  const effectiveDefinition = definitionWithScopeRevisions(definition, state);
+  const workItem = effectiveDefinition.workItems.find(row => row.id === normalized.workItemId);
   if (normalized.type === "agent_assigned") {
     if (normalized.executionRunId !== undefined) {
       const executionTruth = executionTruthFor(workspaceRoot, normalized);
@@ -2016,7 +2191,7 @@ function validateEventAgainstState(event, definition, records, workspaceRoot) {
       if (projected.workItemId === normalized.workItemId
         || projected.assignmentId === null
         || ["completed", "failed"].includes(projected.status)) continue;
-      const other = definition.workItems.find(row => row.id === projected.workItemId);
+      const other = effectiveDefinition.workItems.find(row => row.id === projected.workItemId);
       if (pathsOverlap(workItem.ownedPaths, other.ownedPaths)) {
         throw new Error(
           `Owned paths overlap active assignment ${projected.assignmentId}: ${normalized.workItemId} <> ${projected.workItemId}.`,
@@ -2043,6 +2218,16 @@ function validateEventAgainstState(event, definition, records, workspaceRoot) {
     if (normalized.state === "completed" && unresolved.length > 0) {
       throw new Error(`Completed checkpoint has unresolved dependencies: ${unresolved.join(", ")}.`);
     }
+    if (normalized.state === "verifying") {
+      const history = state.assignmentHistory.get(normalized.workItemId) ?? [];
+      const prior = history.at(-2) ?? null;
+      if (!prior || prior.agentId === current.agentId) {
+        throw new Error(
+          "Independent verification requires a different current owner from the implementation owner. "
+          + `Record a handoff to the verifier, then run: npx --no-install owlrunkit project assign --workspace ${JSON.stringify(workspaceRoot)} --assignment-id <verifier-assignment-id> --at <ISO-UTC> --work-item ${normalized.workItemId} --agent <verifier-agent> --supersedes ${current.assignmentId}`,
+        );
+      }
+    }
     const executionTruth = status.workItems.find(
       row => row.workItemId === normalized.workItemId,
     ).executionTruth;
@@ -2107,7 +2292,7 @@ function validateEventAgainstState(event, definition, records, workspaceRoot) {
       if (otherProjection.workItemId === normalized.workItemId
         || otherProjection.assignmentId === null
         || ["completed", "failed"].includes(otherProjection.status)) continue;
-      const other = definition.workItems.find(row => row.id === otherProjection.workItemId);
+      const other = effectiveDefinition.workItems.find(row => row.id === otherProjection.workItemId);
       if (pathsOverlap(workItem.ownedPaths, other.ownedPaths)) {
         throw new Error(
           `Owned paths overlap active assignment ${otherProjection.assignmentId}: ${normalized.workItemId} <> ${otherProjection.workItemId}.`,
@@ -2155,7 +2340,7 @@ function validateEventAgainstState(event, definition, records, workspaceRoot) {
       if (otherProjection.workItemId === normalized.workItemId
         || otherProjection.assignmentId === null
         || ["completed", "failed"].includes(otherProjection.status)) continue;
-      const other = definition.workItems.find(row => row.id === otherProjection.workItemId);
+      const other = effectiveDefinition.workItems.find(row => row.id === otherProjection.workItemId);
       if (pathsOverlap(workItem.ownedPaths, other.ownedPaths)) {
         throw new Error(
           `Owned paths overlap active assignment ${otherProjection.assignmentId}: ${normalized.workItemId} <> ${otherProjection.workItemId}.`,
@@ -2220,9 +2405,54 @@ function validateEventAgainstState(event, definition, records, workspaceRoot) {
     }
     if (state.gatePasses.has(normalized.dueGateId)) {
       throw new Error(
-        `Deferred verification cannot target integration gate ${normalized.dueGateId}; gate already passed.`,
+        `Deferred verification cannot target integration gate ${normalized.dueGateId}; gate already passed. `
+        + "Create a successor project with: npx --no-install owlrunkit project successor --workspace <directory> --transition-id <id> --at <ISO-UTC> --definition <project.json> --reason <text>; or define a new unpassed gate before deferring.",
+      );
+    }
+  } else if (normalized.type === "work_item_scope_revised") {
+    const current = state.assignments.get(normalized.workItemId) ?? null;
+    const currentRevision = state.scopeRevisions.get(normalized.workItemId) ?? null;
+    const currentScope = currentRevision?.ownedPaths ?? workItem.ownedPaths;
+    const currentMeasurable = currentRevision
+      ? currentRevision.measurable
+      : workItem.measurable ?? null;
+    const projected = status.workItems.find(row => row.workItemId === normalized.workItemId);
+    if (!current
+      || current.assignmentId !== normalized.assignmentId
+      || current.agentId !== normalized.ownerAgentId) {
+      throw new Error("WorkItem scope revision must bind the current assignment and owner.");
+    }
+    if (["completed", "failed"].includes(projected?.status)) {
+      throw new Error("WorkItem scope revision requires a non-terminal WorkItem.");
+    }
+    if (normalized.supersedesRevisionId !== currentRevision?.revisionId) {
+      throw new Error(
+        `WorkItem scope revision must supersede current revision ${currentRevision?.revisionId ?? "none"}.`,
       );
     }
+    if (canonical(normalized.previousOwnedPaths) !== canonical(currentScope)
+      || canonical(normalized.previousMeasurable) !== canonical(currentMeasurable)) {
+      throw new Error("WorkItem scope revision does not bind the current scope.");
+    }
+    if (canonical(normalized.ownedPaths) === canonical(currentScope)
+      && canonical(normalized.measurable) === canonical(currentMeasurable)) {
+      throw new Error("WorkItem scope revision must change ownedPaths or measurable truth.");
+    }
+    for (const otherProjection of status.workItems) {
+      if (otherProjection.workItemId === normalized.workItemId
+        || otherProjection.assignmentId === null
+        || ["completed", "failed"].includes(otherProjection.status)) continue;
+      const otherRevision = state.scopeRevisions.get(otherProjection.workItemId) ?? null;
+      const otherDefinition = effectiveDefinition.workItems.find(
+        row => row.id === otherProjection.workItemId,
+      );
+      const otherOwnedPaths = otherRevision?.ownedPaths ?? otherDefinition.ownedPaths;
+      if (pathsOverlap(normalized.ownedPaths, otherOwnedPaths)) {
+        throw new Error(
+          `Revised owned paths overlap active assignment ${otherProjection.assignmentId}: ${normalized.workItemId} <> ${otherProjection.workItemId}.`,
+        );
+      }
+    }
   } else if (normalized.type === "verification_closed") {
     const verification = state.verifications.get(normalized.verificationId);
     if (!verification || verification.closed) {
@@ -2376,7 +2606,7 @@ export function assignTeamProjectV1({
   if (executionWorkItemId !== undefined) event.executionWorkItemId = executionWorkItemId;
 
   const recorded = appendTeamProjectEventV1({ workspaceRoot, event });
-  const status = readTeamProjectStatusV1({ workspaceRoot });
+  const status = readTeamProjectStatusV3({ workspaceRoot });
   if (recorded.resumed) {
     const current = status.workItems.find(row => row.workItemId === workItemId);
     if (current?.assignmentId !== assignmentId) {
@@ -3010,7 +3240,7 @@ export function integrateTeamProjectV1({
     evidenceRefs,
   };
   const recorded = appendTeamProjectEventV1({ workspaceRoot, event });
-  const status = readTeamProjectStatusV1({ workspaceRoot });
+  const status = readTeamProjectStatusV3({ workspaceRoot });
   const gate = status.integrationGates.find(row => row.gateId === gateId);
   return {
     status: "team_project_integration",
@@ -3021,6 +3251,7 @@ export function integrateTeamProjectV1({
     resumed: recorded.resumed,
     gateStatus: gate?.status ?? null,
     overall: status.overall,
+    deliveryDisposition: status.deliveryDisposition,
     projectTruthHash: status.projectTruthHash,
     nextAction: status.nextAction,
     nextActorId: status.nextActorId,
@@ -3064,7 +3295,7 @@ export function checkpointTeamProjectV1({
     ...(sourceFingerprint === undefined ? {} : { sourceFingerprint }),
   };
   const recorded = appendTeamProjectEventV1({ workspaceRoot, event });
-  const status = readTeamProjectStatusV1({ workspaceRoot });
+  const status = readTeamProjectStatusV3({ workspaceRoot });
   if (recorded.resumed) {
     const loaded = loadProject(workspaceRoot);
     const stateProjection = projectEvents(loaded.definition, loaded.events);
@@ -3094,6 +3325,89 @@ export function checkpointTeamProjectV1({
     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 reviseTeamProjectWorkItemScopeV1({
+  workspaceRoot,
+  revisionId,
+  occurredAt,
+  assignmentId,
+  workItemId,
+  ownerAgentId,
+  ownedPaths,
+  measurable = null,
+  reason,
+  evidenceRefs = [],
+}) {
+  safeIdentifier(revisionId, "revisionId");
+  const loaded = loadProject(workspaceRoot);
+  const state = projectEvents(loaded.definition, loaded.events);
+  const baseWorkItem = loaded.definition.workItems.find(row => row.id === workItemId);
+  if (!baseWorkItem) throw new Error(`Unknown team project WorkItem: ${workItemId}.`);
+  const existing = loaded.events.find(row => (
+    row.event.type === "work_item_scope_revised"
+    && row.event.revisionId === revisionId
+  ))?.event ?? null;
+  let event;
+  if (existing) {
+    const requested = {
+      occurredAt: normalizeTimestamp(occurredAt),
+      assignmentId,
+      workItemId,
+      ownerAgentId,
+      ownedPaths: validateLeaseOwnedPaths(ownedPaths),
+      measurable,
+      reason,
+      evidenceRefs,
+    };
+    for (const key of Object.keys(requested)) {
+      if (canonical(existing[key]) !== canonical(requested[key])) {
+        throw new Error(`Cannot resume WorkItem scope revision ${revisionId}; ${key} differs.`);
+      }
+    }
+    event = existing;
+  } else {
+    const previous = state.scopeRevisions.get(workItemId) ?? null;
+    event = {
+      schemaVersion: EVENT_SCHEMA_V5,
+      eventId: `work-item-scope-revised-${revisionId}`,
+      type: "work_item_scope_revised",
+      occurredAt,
+      revisionId,
+      ...(previous ? { supersedesRevisionId: previous.revisionId } : {}),
+      assignmentId,
+      workItemId,
+      ownerAgentId,
+      previousOwnedPaths: [...(previous?.ownedPaths ?? baseWorkItem.ownedPaths)],
+      ownedPaths,
+      previousMeasurable: structuredClone(
+        previous ? previous.measurable : baseWorkItem.measurable ?? null,
+      ),
+      measurable,
+      reason,
+      evidenceRefs,
+    };
+  }
+  const recorded = appendTeamProjectEventV1({ workspaceRoot, event });
+  const status = readTeamProjectStatusV3({ workspaceRoot });
+  const workItem = status.workItems.find(row => row.workItemId === workItemId);
+  return {
+    status: "team_project_work_item_scope_revised",
+    revisionId,
+    workItemId,
+    ownedPaths: [...workItem.ownedPaths],
+    measurable: structuredClone(workItem.measurable),
+    eventId: recorded.eventId,
+    eventPath: recorded.eventPath,
+    eventSha256: recorded.eventSha256,
+    resumed: recorded.resumed,
+    projectTruthHash: status.projectTruthHash,
     nextAction: status.nextAction,
     nextActorId: status.nextActorId,
     authorizationGranted: false,
@@ -3106,14 +3420,59 @@ function legacyWorkItemProjection(workItem) {
   const {
     latestSourceDelivery: _latestSourceDelivery,
     invalidatedByReopenIds: _invalidatedByReopenIds,
+    ownedPaths: _ownedPaths,
+    measurable: _measurable,
+    scopeRevision: _scopeRevision,
     ...legacy
   } = workItem;
   return legacy;
 }
 
+function statusV2WorkItemProjection(workItem) {
+  if (workItem === null) return null;
+  const {
+    ownedPaths: _ownedPaths,
+    measurable: _measurable,
+    scopeRevision: _scopeRevision,
+    ...v2
+  } = workItem;
+  return v2;
+}
+
+function statusV3CompletionProjection(status) {
+  if (status.overall !== "completed") {
+    return { ...status, deliveryDisposition: "work_in_progress" };
+  }
+  const dominantGap = {
+    kind: "release_authority",
+    id: "release-authority",
+    title: "Separate release authority",
+    workItemId: null,
+    agentId: null,
+    reason: "Project work ledger is complete, but Git, release, deployment, production, and business authority remain outside Project Driver.",
+    truthRefs: uniqueSorted([
+      "project/definition.json",
+      ...status.integrationGates.flatMap(gate => gate.truthRefs),
+    ]),
+  };
+  const nextAction = "Obtain separate Git/release/deployment authority if activation is intended; otherwise stop.";
+  return {
+    ...status,
+    deliveryDisposition: "code_complete_without_release_authority",
+    headline: `code_complete_without_release_authority: work ledger completed; authorizationGranted=false; next: ${nextAction}`,
+    dominantGap,
+    nextAction,
+    nextActorId: null,
+  };
+}
+
 export function readTeamProjectStatusV1({ workspaceRoot }) {
   const loaded = loadProject(workspaceRoot);
-  const { sourceDeliveries: _sourceDeliveries, ...legacy } = projectStatus(
+  const {
+    sourceDeliveries: _sourceDeliveries,
+    warnings: _warnings,
+    ...legacy
+  } = projectStatus(
     loaded.definition,
     loaded.events,
     loaded.root,
@@ -3128,8 +3487,27 @@ export function readTeamProjectStatusV1({ workspaceRoot }) {
 
 export function readTeamProjectStatusV2({ workspaceRoot }) {
   const loaded = loadProject(workspaceRoot);
+  const { warnings: _warnings, ...v2 } = projectStatus(
+    loaded.definition,
+    loaded.events,
+    loaded.root,
+  );
   return {
-    ...projectStatus(loaded.definition, loaded.events, loaded.root),
+    ...v2,
+    schemaVersion: STATUS_SCHEMA_V2,
+    workItems: v2.workItems.map(statusV2WorkItemProjection),
+    exitCode: 0,
+  };
+}
+
+export function readTeamProjectStatusV3({ workspaceRoot }) {
+  const loaded = loadProject(workspaceRoot);
+  return {
+    ...statusV3CompletionProjection(projectStatus(
+      loaded.definition,
+      loaded.events,
+      loaded.root,
+    )),
     exitCode: 0,
   };
 }
@@ -3307,8 +3685,8 @@ export function buildTeamProjectTakeoverV2({ workspaceRoot, agentId }) {
     projectNextAction: status.nextAction,
     projectNextActorId: status.nextActorId,
     agentId,
-    currentResponsibility: current,
-    allResponsibilities: responsibilities,
+    currentResponsibility: statusV2WorkItemProjection(current),
+    allResponsibilities: responsibilities.map(statusV2WorkItemProjection),
     pendingHandoff,
     staleHandoffs,
     currentSourceDelivery,
@@ -3356,6 +3734,29 @@ export function buildTeamProjectTakeoverV1(input) {
   };
 }
 
+export function buildTeamProjectTakeoverV3(input) {
+  const legacy = buildTeamProjectTakeoverV2(input);
+  const status = readTeamProjectStatusV3({ workspaceRoot: input.workspaceRoot });
+  const byId = new Map(status.workItems.map(row => [row.workItemId, row]));
+  return {
+    ...legacy,
+    schemaVersion: "OwlCodaRunKitTeamProjectTakeoverV3",
+    projectHeadline: status.headline,
+    dominantGap: status.dominantGap,
+    projectNextAction: status.nextAction,
+    projectNextActorId: status.nextActorId,
+    currentResponsibility: legacy.currentResponsibility
+      ? byId.get(legacy.currentResponsibility.workItemId) ?? null
+      : null,
+    allResponsibilities: legacy.allResponsibilities
+      .map(row => byId.get(row.workItemId))
+      .filter(Boolean),
+    deliveryDisposition: status.deliveryDisposition,
+    warnings: status.warnings,
+    authorizationGranted: false,
+  };
+}
+
 export function formatTeamProjectStatusHumanV1(status) {
   const nextAction = status.nextAction === null ? "none" : singleLine(status.nextAction);
   return [
@@ -3382,7 +3783,9 @@ export function formatTeamProjectStatusHumanV2(status) {
   return [
     status.headline,
     `Project: ${status.projectId} — ${singleLine(status.objective)}`,
-    `State: ${status.overall}`,
+    `Work ledger: ${status.overall}${status.deliveryDisposition === "code_complete_without_release_authority"
+      ? `; 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"}`,
@@ -3395,6 +3798,9 @@ export function formatTeamProjectStatusHumanV2(status) {
     `Source deliveries: ${status.sourceDeliveries.length}${latestSourceDelivery
       ? `; latest ${latestSourceDelivery.deliveryId} (${latestSourceDelivery.overlayStatus}, ${latestSourceDelivery.deliveryCandidateFingerprint})`
       : ""}`,
+    ...(status.warnings?.length > 0
+      ? [`Warnings: ${status.warnings.map(row => `${row.code}:${row.workItemId}`).join(", ")}`]
+      : []),
     `Next: ${nextAction}${status.nextActorId ? ` (owner ${status.nextActorId})` : ""}`,
     "",
   ].join("\n");
@@ -3411,6 +3817,9 @@ export function formatTeamProjectTakeoverHumanV2(takeover) {
   return [
     takeover.projectHeadline,
     `Project: ${takeover.projectId} — ${singleLine(takeover.objective)}`,
+    ...(takeover.deliveryDisposition
+      ? [`Delivery disposition: ${takeover.deliveryDisposition}`]
+      : []),
     `Agent: ${takeover.agentId}`,
     `Responsibility: ${responsibility?.workItemId ?? "none"}`,
     `Open decisions: ${takeover.unresolvedDecisions.map(row => row.decisionId).join(", ") || "none"}`,
@@ -3431,6 +3840,9 @@ export function formatTeamProjectTakeoverHumanV2(takeover) {
     `Agent next: ${agentNextAction}`,
     `Project next: ${projectNextAction}${takeover.projectNextActorId ? ` (owner ${takeover.projectNextActorId})` : ""}`,
     `State: ${takeover.overall}`,
+    ...(takeover.warnings?.length > 0
+      ? [`Warnings: ${takeover.warnings.map(row => `${row.code}:${row.workItemId}`).join(", ")}`]
+      : []),
     "",
   ].join("\n");
 }