@zq-silk/yui 0.15.11 → 0.16.0

package/dist/task/draftPlan.js

@@ -1,25 +1,4 @@
-import { RUNTIME_OBSERVATION_TASK_EVENT } from "../runtime/runtimeObservation.js";
 import { SYSTEM_LEADER_ROLE } from "../role/systemRoles.js";
-/**
- * Runtime Task-event types that are emitted with a Role but no Turn in their
- * payload. Each one is still only exempted when its `roleName` resolves to the
- * Leader — the `runtime.` prefix is never exempted, and a type absent from this
- * set keeps disqualifying the Draft.
- *
- * Turn lifecycle events are deliberately not listed: they use one generic type
- * per transition and name the Turn in their payload, so the guard resolves that
- * Turn's own purpose instead of trusting the type. Listing invented
- * `turn.planning-*` types would have exempted nothing while silently
- * disqualifying every Draft that ever held a planning conversation.
- */
-export const PLANNING_ROLE_EVENT_TYPES = new Set([
-    "runtime.session-stop-requested",
-    "runtime.session-termination",
-    // Written by the liveness/host-exit paths, which admit a Draft planning Turn.
-    // Its payload carries the Role and embeds the Turn only inside the serialized
-    // observation, so it is resolved as Role-scoped rather than by that blob.
-    "runtime.process-exit-observed"
-]);
 export function assertDraftTaskExecutionFree(store, task) {
     if (task.status !== "draft") {
         throw new Error(`Task is not a Draft: ${task.id}/${task.status}.`);
@@ -168,35 +147,3 @@ function firstDraftExecutionFact(store, task) {
     // of delivery authority. The domain records above own delivery facts.
     return undefined;
 }
-/**
- * Whether one runtime/Turn Task event belongs to this Draft's own planning
- * conversation.
- *
- * The binding the event carries decides this, never its type prefix:
- *
- * - it names a Turn → that Turn must exist on this Task and be `planning`;
- * - it names no Turn → its exact type must be Role-scoped by construction and
- *   its `roleName` must be the Leader, the only Role a Draft may run.
- *
- * Everything else stays disqualifying, so an unrecognized type, a foreign Role
- * or a Turn reference that cannot be resolved fails closed.
- */
-function isDraftPlanningEvent(store, task, event) {
-    // Several emitters write an absent Turn as an empty string, so only a
-    // non-empty id counts as a reference worth resolving.
-    const runId = event.payload["runId"];
-    if (typeof runId === "string" && runId !== "") {
-        return store.getRun(task.id, runId)?.purpose === "planning";
-    }
-    // A canonical runtime observation is the event normal delivery writes for
-    // session.started/conversation.observed/turn.accepted and every terminal. It
-    // names its Turn in the same payload field as everything else and was
-    // resolved above; only an unfenced host-level observation reaches here, where
-    // the Role still has to prove it. Admitting this one type by its own binding
-    // is not the same as admitting the `runtime.` prefix.
-    if (event.type !== RUNTIME_OBSERVATION_TASK_EVENT
-        && !PLANNING_ROLE_EVENT_TYPES.has(event.type)) {
-        return false;
-    }
-    return event.payload["roleName"] === SYSTEM_LEADER_ROLE;
-}

package/dist/task/nextAction.js

@@ -1,11 +1,11 @@
 import { createHash } from "node:crypto";
+import { actionableExecutionLaneRecoveries } from "../execution/executionHealth.js";
 import { governingWorkItemDeliveries, workItemDeliverySettled } from "../integration/deliveryObligation.js";
 import { isCompletedTaskReviewEvidenceFromRuns } from "../review/reviewAcceptance.js";
-import { actionableExecutionLaneRecoveries } from "../execution/executionHealth.js";
 import { sameTaskFinalReviewContract } from "../review/taskFinalReviewContract.js";
 import { resolveRecordedTaskFinalReviewContract } from "../review/taskFinalReviewContractResolution.js";
-import { draftWorkItemDependencyIssue } from "./draftPlan.js";
 import { currentWorkItemCandidate, currentWorkItemExecutionGroup, governingWorkItemCandidate } from "../workItem/workItem.js";
+import { draftWorkItemDependencyIssue } from "./draftPlan.js";
 const OPEN_WORK_ITEM_STATUSES = new Set(["open"]);
 export function projectNextAction(facts) {
     const { task } = facts;
@@ -150,7 +150,7 @@ export function projectNextAction(facts) {
         }
         return buildAction(facts, {
             kind: "integrate-work-item",
-            reason: `Integration ${checkingIntegration.id} awaits check-result consumption (${job?.status ?? "read current Job"}); an empty integration queue does not finalize this direct attempt.`,
+            reason: `Integration ${checkingIntegration.id} awaits check-result consumption (${job?.status ?? "read current Job"}); its exact Job must be consumed to finalize the attempt.`,
             refs,
             preconditions: [{ fact: "The Integration retains its exact check Job", satisfied: true, ref: refs[0] }],
             recommendedCommand: `yui task integration continue ${task.id}/${checkingIntegration.id}`
@@ -378,7 +378,7 @@ export function projectNextAction(facts) {
     }
     if (deliveryWorkItems.length === 0
         && !taskFinalReviewRequired(facts)
-        && !facts.reviewRounds.some((round) => ((round.scope ?? "work-item") === "task"
+        && !facts.reviewRounds.some((round) => (round.scope === "task"
             && (round.status === "pending" || round.status === "running")))) {
         const reviewAlternative = facts.reviewConfig === null
             ? []
@@ -675,7 +675,6 @@ export function durableStateFingerprint(facts) {
         ...facts.workItems.map((item) => `work:${item.id}:${item.status}:${item.revision}:${item.updatedAt}`),
         ...facts.changeSets.map((changeSet) => `change-set:${changeSet.id}:${changeSet.headCommit}`),
         ...facts.integrations.map((attempt) => `integration:${attempt.id}:${attempt.status}:${attempt.updatedAt}`),
-        ...facts.integrationQueueEntries.map((entry) => `integration-queue:${entry.id}:${entry.status}:${entry.updatedAt}`),
         ...facts.reviewRounds.map((round) => `review:${round.id}:${round.status}:${round.endedAt ?? ""}`)
     ];
     return createHash("sha256").update(parts.join("\n")).digest("hex");
@@ -819,22 +818,17 @@ function taskFinalReviewRole(facts) {
 function ref(kind, id) {
     return { kind, id };
 }
-function latestFailedReviewFor(rounds, workItemId) {
-    return [...rounds]
-        .reverse()
-        .find((round) => round.workItemId === workItemId && round.status === "failed");
-}
 function latestTaskFinalReview(rounds, contract) {
     return [...rounds]
         .reverse()
-        .find((round) => ((round.scope ?? "work-item") === "task"
+        .find((round) => (round.scope === "task"
         && (contract === undefined || sameTaskFinalReviewContract(round.taskFinalReviewContract, contract))));
 }
 function hasValidFinalReview(facts) {
     const contract = taskFinalReviewContract(facts);
     const final = [...facts.reviewRounds]
         .reverse()
-        .find((round) => ((round.scope ?? "work-item") === "task"
+        .find((round) => (round.scope === "task"
         && (contract === undefined || sameTaskFinalReviewContract(round.taskFinalReviewContract, contract))));
     if (final === undefined || !isCompletedTaskReviewEvidenceFromRuns(final, facts.reviewOutcomeEvidence?.runs ?? []))
         return false;
@@ -853,7 +847,7 @@ function detectProtocolInconsistency(facts) {
                 : [ref("candidate", `${item.id}/${candidate.id}`)];
         });
         const reviewRefs = facts.reviewRounds
-            .filter((round) => ((round.scope ?? "work-item") === "task"
+            .filter((round) => (round.scope === "task"
             && round.taskFinalReviewContract !== undefined))
             .map((round) => ref("review-round", round.id));
         return {

package/dist/task/publicationAdoption.js

@@ -0,0 +1,56 @@
+import { contextContentDigest } from "../context/contextSnapshot.js";
+import { publicationExternalKey } from "./publicationReference.js";
+export const PUBLICATION_ADOPTED_EVENT = "publication.candidate-adopted";
+/**
+ * An explicit semantic decision over fixed Git endpoints, not an ancestry
+ * heuristic or a replacement completion head. Publication metadata/verification
+ * successors may retain it only while every intervening local candidate agrees.
+ */
+export function publicationAdoption(publication, completion, acceptedCommit, events, publications, integrations) {
+    const unavailable = { event: null, reason: null };
+    if (completion === undefined || acceptedCommit === null)
+        return unavailable;
+    const lineage = new Set();
+    let current = publication;
+    while (current !== undefined && !lineage.has(current.id)
+        && current.taskId === publication.taskId
+        && current.projectId === publication.projectId
+        && current.externalKind === publication.externalKind
+        && publicationExternalKey(current) === publicationExternalKey(publication)
+        && current.localCommit === publication.localCommit) {
+        lineage.add(current.id);
+        current = publications.find(p => p.id === current.supersedes);
+    }
+    const event = events.slice().reverse().find(event => {
+        const p = event.payload;
+        return event.type === PUBLICATION_ADOPTED_EVENT
+            && event.taskId === publication.taskId
+            && p.completionEventId === completion.id
+            && p.acceptedCommit === acceptedCommit
+            && p.projectId === publication.projectId
+            && p.localCommit === publication.localCommit
+            && lineage.has(p.publicationId ?? "");
+    });
+    if (event === undefined)
+        return unavailable;
+    const p = event.payload;
+    if (!p.acceptance?.trim()
+        || !["user", "operator", "leader"].includes(p.by ?? "")
+        || !/^[0-9a-f]{64}$/u.test(p.diffDigest ?? "")
+        || !/^[0-9a-f]{40}$/u.test(p.acceptedTree ?? "")
+        || !/^[0-9a-f]{40}$/u.test(p.candidateTree ?? "")) {
+        return { event: null, reason: `Adoption ${event.id} has incomplete fixed evidence.` };
+    }
+    if (p.integrationId === undefined)
+        return { event, reason: null };
+    const integration = integrations.find(i => i.id === p.integrationId);
+    const valid = integration !== undefined && integration.status === "committed"
+        && integration.taskId === publication.taskId
+        && integration.projectId === publication.projectId
+        && integration.afterCommit === publication.localCommit
+        && contextContentDigest(integration) === p.integrationDigest;
+    return valid ? { event, reason: null } : {
+        event: null,
+        reason: `Adoption ${event.id} references Integration ${p.integrationId}, whose committed candidate evidence is missing or changed (${integration?.status ?? "missing"}).`
+    };
+}

package/dist/task/publicationReference.js

@@ -35,6 +35,9 @@ export function createPublicationReference(id, taskId, input, now) {
         ...(input.localCommit === undefined ? {} : {
             localCommit: requireCommit(input.localCommit, "Publication local commit")
         }),
+        ...(input.headCommit === undefined ? {} : {
+            headCommit: requireCommit(input.headCommit, "Publication remote head")
+        }),
         ...(input.remoteCommit === undefined ? {} : {
             remoteCommit: requireCommit(input.remoteCommit, "Publication remote commit")
         }),
@@ -82,6 +85,13 @@ export function validatePublicationReference(reference) {
     if (reference.localCommit !== undefined) {
         requireCommit(reference.localCommit, "Publication local commit");
     }
+    if (reference.headCommit !== undefined) {
+        requireCommit(reference.headCommit, "Publication remote head");
+        if (reference.verification === "verified"
+            && reference.headCommit !== reference.localCommit) {
+            throw new Error("Verified publication remote head must match its local commit.");
+        }
+    }
     if (reference.remoteCommit !== undefined) {
         requireCommit(reference.remoteCommit, "Publication remote commit");
     }

package/dist/task/remoteDelivery.js

@@ -1,3 +1,4 @@
+import { publicationAdoption } from "./publicationAdoption.js";
 /**
  * One read-only delivery projection over existing Task, workspace, completion,
  * and Publication facts. It never writes a merged flag or queries a provider.
@@ -19,13 +20,19 @@ export function projectTaskRemoteDelivery(facts) {
             .filter((reference) => reference.projectId === binding.projectId);
         const matching = expectedLocalCommit === null
             ? []
-            : projectPublications.filter((reference) => reference.localCommit === expectedLocalCommit);
+            : projectPublications.filter((reference) => reference.localCommit === expectedLocalCommit
+                || publicationAdoption(reference, expected.event, expectedLocalCommit, facts.events, facts.publications, facts.integrations ?? []).event !== null);
         const publication = bestPublication(matching.length > 0 ? matching : projectPublications);
-        const coverage = projectCoverage(codeDelivery, expectedLocalCommit, publication);
+        const adoptionEvidence = publication === null ? null
+            : publicationAdoption(publication, expected.event, expectedLocalCommit, facts.events, facts.publications, facts.integrations ?? []);
+        const adoption = adoptionEvidence?.event ?? null;
+        const covers = expectedLocalCommit !== null && publication !== null
+            && (publication.localCommit === expectedLocalCommit || adoption !== null);
+        const headMatches = publication?.headCommit === undefined
+            || publication.headCommit === publication.localCommit;
+        const coverage = projectCoverage(codeDelivery, expectedLocalCommit, publication, covers, headMatches);
         const merged = codeDelivery === "none"
-            || (publication !== null
-                && expectedLocalCommit !== null
-                && publication.localCommit === expectedLocalCommit
+            || (covers && headMatches
                 && publication.state === "merged");
         const verified = codeDelivery === "none"
             || (merged && publication?.verification === "verified");
@@ -34,6 +41,8 @@ export function projectTaskRemoteDelivery(facts) {
             directory: binding.directory,
             baseCommit,
             expectedLocalCommit,
+            deliveryLocalCommit: covers ? publication.localCommit ?? null : null,
+            adoption,
             codeDelivery,
             publication,
             state: publication?.state ?? null,
@@ -42,7 +51,8 @@ export function projectTaskRemoteDelivery(facts) {
             coverage,
             merged,
             verified,
-            reason: projectCoverageReason(codeDelivery, expectedLocalCommit, publication, coverage)
+            reason: projectCoverageReason(expectedLocalCommit, publication, coverage, adoption) + (coverage === "stale" && adoptionEvidence?.reason
+                ? ` ${adoptionEvidence.reason}` : "")
         };
     });
     const codeProjects = projects.filter((project) => project.codeDelivery !== "none");
@@ -55,8 +65,9 @@ export function projectTaskRemoteDelivery(facts) {
         : codeProjects.some((project) => project.coverage === "head-unavailable")
             ? "unavailable"
             : allMerged
-                ? "merged"
-                : mergedProjectCount > 0 ? "partial" : "pending";
+                ? allVerified ? "merged" : "unverified"
+                : mergedProjectCount > 0 ? "partial"
+                    : codeProjects.some(p => p.state === "merged") ? "uncovered" : "pending";
     return {
         taskId: facts.task.id,
         source: expected.source,
@@ -111,7 +122,7 @@ function expectedDelivery(facts) {
         commits: new Map()
     };
 }
-function completionEvent(events, completedAt) {
+export function completionEvent(events, completedAt) {
     const exact = latestEvent(events, "task.completed", (event) => (event.createdAt === completedAt));
     return exact ?? latestEvent(events, "task.completed", (event) => (event.createdAt <= completedAt));
 }
@@ -154,7 +165,7 @@ function candidateCommits(candidate) {
         commit.toLowerCase()
     ]));
 }
-function commitMap(value) {
+export function commitMap(value) {
     const result = new Map();
     for (const entry of value?.split(",") ?? []) {
         const separator = entry.indexOf("@");
@@ -188,7 +199,7 @@ function publicationRank(reference) {
         return 2;
     return 1;
 }
-function projectCoverage(codeDelivery, expectedLocalCommit, publication) {
+function projectCoverage(codeDelivery, expectedLocalCommit, publication, covers, headMatches) {
     if (codeDelivery === "none")
         return "not-applicable";
     if (expectedLocalCommit === null)
@@ -197,7 +208,9 @@ function projectCoverage(codeDelivery, expectedLocalCommit, publication) {
         return "missing";
     if (publication.localCommit === undefined)
         return "missing-local-commit";
-    if (publication.localCommit !== expectedLocalCommit)
+    if (!headMatches)
+        return "head-mismatch";
+    if (!covers)
         return "stale";
     if (publication.state === "open")
         return "open";
@@ -205,7 +218,7 @@ function projectCoverage(codeDelivery, expectedLocalCommit, publication) {
         return "closed";
     return publication.verification === "verified" ? "verified" : "merged";
 }
-function projectCoverageReason(codeDelivery, expectedLocalCommit, publication, coverage) {
+function projectCoverageReason(expectedLocalCommit, publication, coverage, adoption) {
     switch (coverage) {
         case "not-applicable":
             return "Task head equals the managed workspace base; no code delivery is required.";
@@ -216,15 +229,17 @@ function projectCoverageReason(codeDelivery, expectedLocalCommit, publication, c
         case "missing-local-commit":
             return `Publication ${publication.id} does not record a local commit.`;
         case "stale":
-            return `Publication ${publication.id} covers ${publication.localCommit}, not the expected Task head ${expectedLocalCommit}.`;
+            return `Publication ${publication.id} is ${publication.state}, but its local candidate ${publication.localCommit} has no valid adoption covering accepted Task head ${expectedLocalCommit}.`;
+        case "head-mismatch":
+            return `Publication ${publication.id} is ${publication.state}, but observed remote head ${publication.headCommit} differs from local candidate ${publication.localCommit}; verification is invalid.`;
         case "open":
             return `Publication ${publication.id} covers the Task head but is still open.`;
         case "closed":
             return `Publication ${publication.id} covers the Task head but is closed without merge.`;
         case "merged":
-            return `Publication ${publication.id} reports the exact Task head as merged.`;
+            return `Publication ${publication.id} reports a covering candidate as merged, but remote verification is still required.`;
         case "verified":
-            return `Publication ${publication.id} verifies the exact Task head as merged.`;
+            return `Publication ${publication.id} verifies ${adoption === null ? "the exact Task head" : `candidate ${publication.localCommit} adopted by ${adoption.id}`} as merged.`;
     }
 }
 function compareCreated(left, right) {

package/dist/task/remoteDeliveryService.js

@@ -0,0 +1,89 @@
+import { isDeepStrictEqual } from "node:util";
+import { usageError } from "../errors/cliError.js";
+import { projectTaskRemoteDelivery } from "../task/remoteDelivery.js";
+import { PUBLICATION_ADOPTED_EVENT } from "./publicationAdoption.js";
+export function projectTaskRemoteDeliveryFromStore(store, task, currentCandidate = null) {
+    return createTaskRemoteDeliveryProof(store, task, currentCandidate).delivery;
+}
+export function createTaskRemoteDeliveryProof(store, task, currentCandidate = null) {
+    const publications = store.listPublicationReferences(task.id);
+    const delivery = projectTaskRemoteDelivery({
+        task,
+        events: store.listEventsByType(task.id, [
+            "task.completed", "task.archived", PUBLICATION_ADOPTED_EVENT
+        ]),
+        publications,
+        managedWorkspaces: store.listManagedWorkspaces(task.id),
+        runs: task.projectBindings.length === 0 ? [] : store.listTaskRunWorkspaceBases(task.id),
+        integrations: store.listIntegrationAttempts(task.id),
+        currentCandidate
+    });
+    return {
+        schemaVersion: 1,
+        task: taskRemoteDeliveryProofTask(task),
+        publications,
+        delivery
+    };
+}
+export function assertTaskRemoteDeliveryProof(store, task, proof) {
+    if (proof === undefined || proof.schemaVersion !== 1) {
+        throw usageError(`Task remote-delivery preflight proof is required: ${task.id}.`);
+    }
+    if (!isDeepStrictEqual(proof.task, taskRemoteDeliveryProofTask(task))) {
+        throw usageError(`Task changed after remote-delivery preflight: ${task.id}.`);
+    }
+    if (!isDeepStrictEqual(proof.publications, store.listPublicationReferences(task.id))) {
+        throw usageError(`Task Publication evidence changed after remote-delivery preflight: ${task.id}.`);
+    }
+    // Recheck semantic adoption/Integration facts as well as Publication versions.
+    // For provisional cancelled Tasks retain the frozen candidate used at preflight.
+    const current = projectTaskRemoteDeliveryFromStore(store, task, {
+        projects: proof.delivery.projects.flatMap(p => p.expectedLocalCommit === null
+            ? [] : [{ projectId: p.projectId, commit: p.expectedLocalCommit }])
+    });
+    if (!isDeepStrictEqual(current, proof.delivery)) {
+        throw usageError(`Task delivery evidence changed after remote-delivery preflight: ${task.id}.`);
+    }
+    assertTaskRemoteDeliveryIntegrated(proof.delivery);
+    return proof.delivery;
+}
+export function assertTaskRemoteDeliveryIntegrated(delivery) {
+    if (!delivery.allMerged) {
+        const headUnavailable = delivery.projects.filter((project) => (project.codeDelivery !== "none"
+            && project.coverage === "head-unavailable"));
+        if (headUnavailable.length > 0 && delivery.source === "task-completed") {
+            throw usageError(`Task ${delivery.taskId} has no frozen completion heads for: ${headUnavailable.map(({ projectId }) => projectId).join(", ")}. Historical acceptance cannot be inferred from a merge or archive.`);
+        }
+        const uncovered = delivery.projects
+            .filter((project) => project.codeDelivery !== "none" && !project.merged)
+            .map((project) => (`${project.projectId}/${project.coverage}`
+            + (project.publication === null ? "" : `/${project.publication.id}`)))
+            .join(", ");
+        throw usageError(`Task ${delivery.taskId} is not fully merged into remote delivery: ${uncovered || "expected Project heads are unavailable"}. Inspect each Project reason with task remote-delivery. Record confirmed Publication facts; `
+            + "for a changed post-completion candidate, review publication diff and explicitly adopt its acceptance.");
+    }
+    if (delivery.allVerified)
+        return;
+    const unverified = delivery.projects
+        .filter((project) => (project.codeDelivery !== "none"
+        && project.merged
+        && !project.verified))
+        .map((project) => (`${project.projectId}/${project.coverage}`
+        + (project.publication === null ? "" : `/${project.publication.id}`)))
+        .join(", ");
+    throw usageError(`Task ${delivery.taskId} has merged Publication evidence that is not verified: `
+        + `${unverified || "verification evidence is unavailable"}. Run task publication verify `
+        + "for each Publication only when the provider read is authorized.");
+}
+export function taskRemoteDeliveryProofTask(task) {
+    return {
+        id: task.id,
+        status: task.status,
+        projectBindings: task.projectBindings,
+        ...(task.workspaceIdentity === undefined
+            ? {}
+            : { workspaceIdentity: task.workspaceIdentity }),
+        ...(task.completedAt === undefined ? {} : { completedAt: task.completedAt }),
+        ...(task.retiredAt === undefined ? {} : { retiredAt: task.retiredAt })
+    };
+}

package/dist/task/taskActivation.js

@@ -22,7 +22,6 @@ export const TASK_ACTIVATION_EVENT = Object.freeze({
     adopted: "task.activation-adopted",
     failed: "task.activation-failed"
 });
-export const TASK_ACTIVATION_ORIGINS = Object.freeze(["explicit", "submit-develop"]);
 /**
  * The digest that decides whether a repeated requestId is the same request.
  *
@@ -64,7 +63,6 @@ export function createTaskActivationRequest(taskId, input, now) {
             partialResultRefs: []
         },
         startMode: input.startMode,
-        ...(input.origin === undefined ? {} : { origin: input.origin }),
         ...(input.afterPlanningRun === undefined
             ? {}
             : { afterPlanningRun: input.afterPlanningRun }),
@@ -196,26 +194,6 @@ export function admitTaskActivationRequest(task, request, planningRunIsActive) {
     }
     return { disposition: "ready", request };
 }
-/**
- * Whether the Controller may continue (auto-adopt) a released request without an
- * explicit activation boundary call (task-32 §2.4).
- *
- * A deferred request already holds activation authority and is released by its
- * planning Turn ending, so it is adoptable regardless of origin. An immediate
- * request is auto-continued only when it carries a recognised provable origin:
- * an explicit activation action, or a develop submission the shared transaction
- * accepted while the Task was unplanned. A request with no origin — every one
- * migrated from before the field existed — is deliberately held back so an
- * upgrade cannot turn a historical pending request into a silent activation; it
- * still adopts through the explicit `yui task activate` boundary, which does not
- * consult origin. This replaces the old actor heuristic that both dropped legal
- * Operator/user immediate requests and could not distinguish provenance.
- */
-export function activationRequestIsControllerAdoptable(request) {
-    if (request.startMode === "after-planning-turn")
-        return true;
-    return request.origin !== undefined;
-}
 /**
  * The durable terminal outcome for a requestId, read from the activation event
  * ledger.
@@ -258,9 +236,8 @@ export function validateTaskActivationRequest(request) {
     if (!["immediate", "after-planning-turn"].includes(request.startMode)) {
         throw new Error(`Activation start mode is invalid: ${String(request.startMode)}.`);
     }
-    if (request.origin !== undefined
-        && !TASK_ACTIVATION_ORIGINS.includes(request.origin)) {
-        throw new Error(`Activation origin is invalid: ${String(request.origin)}.`);
+    if (Object.hasOwn(request, "origin")) {
+        throw new Error("Activation contains retired origin metadata; use the storage upgrade boundary.");
     }
     if ((request.startMode === "after-planning-turn")
         !== (request.afterPlanningRun !== undefined)) {

package/dist/task/taskActivationService.js

@@ -108,7 +108,6 @@ export function recordTaskActivationRequestInTransaction(tx, input, now) {
         actorId: input.actorId,
         authorityRef: input.authorityRef,
         startMode,
-        ...(input.origin === undefined ? {} : { origin: input.origin }),
         ...(planningRun === undefined ? {} : { afterPlanningRun: planningRun }),
         environmentPlan: plan
     }, now);
@@ -118,7 +117,6 @@ export function recordTaskActivationRequestInTransaction(tx, input, now) {
         startMode: request.startMode,
         environmentPlan: describeEnvironmentPlan(request.environmentPlan),
         actor: request.operation.actorId,
-        ...(request.origin === undefined ? {} : { origin: request.origin }),
         ...(request.afterPlanningRun === undefined
             ? {}
             : { afterPlanningRun: request.afterPlanningRun })

package/dist/task/taskRecordReference.js

@@ -6,7 +6,6 @@ export const TASK_RECORD_ID_PREFIXES = {
     reviewRound: "review-round",
     changeSet: "change-set",
     integrationAttempt: "integration",
-    integrationQueue: "integration-queue",
     durableJob: "job",
     message: "message",
     inputRequest: "input",

package/dist/task/taskSubmission.js

@@ -131,21 +131,10 @@ export function decideSubmissionRouting(input) {
 /**
  * Normalize a possibly-absent submission intent to its effective value.
  *
- * An absent intent is `discuss` (task-32 §2.5: "默认/旧客户端都按 discuss"), so
- * every old client and every message saved before the field existed keeps its
- * historical Leader-waking behaviour. Body text is never inspected.
- *
- * A legacy `--wake-policy none` carried the "save only, do not wake" meaning that
- * `record` now names, so a caller that supplied only that older signal maps to
- * `record` rather than silently becoming a Leader-waking `discuss`. An explicit
- * intent always wins over the wake-policy shorthand.
+ * The current default is `discuss`. Body text is never inspected.
  */
-export function normalizeSubmissionIntent(intent, wakePolicy) {
-    if (intent !== undefined)
-        return intent;
-    if (wakePolicy === "none")
-        return "record";
-    return "discuss";
+export function normalizeSubmissionIntent(intent) {
+    return intent ?? "discuss";
 }
 /**
  * Whether a retry aims at the same target the key was first bound to (§2.3). An

package/dist/telemetry/sqliteTelemetryBatch.js

@@ -0,0 +1,29 @@
+/** Runs on the existing persistence worker's connection, never the ingress
+ * thread. Telemetry keeps its existing idempotent keys and aggregate triggers;
+ * it neither bumps Task revisions nor creates durable RPC outbox records.
+ */
+export function writeTelemetryBatch(db, entries, runCap) {
+    if (!Number.isSafeInteger(runCap) || runCap < 1 || entries.length > 256) {
+        throw new Error("Telemetry batch exceeds its bounded write contract.");
+    }
+    const upsert = db.prepare(`INSERT INTO telemetry (task_id, role_name, turn_id, progress_id, sequence, payload, received_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT(task_id, role_name, turn_id, progress_id) DO UPDATE SET
+       sequence = excluded.sequence, payload = excluded.payload, received_at = excluded.received_at
+     WHERE excluded.received_at >= telemetry.received_at`);
+    const cap = db.prepare(`DELETE FROM telemetry WHERE task_id = ? AND turn_id = ?
+     AND (task_id, role_name, turn_id, progress_id) NOT IN (
+       SELECT task_id, role_name, turn_id, progress_id FROM telemetry
+       WHERE task_id = ? AND turn_id = ?
+       ORDER BY received_at DESC, COALESCE(sequence, -1) DESC, progress_id ASC LIMIT ?
+     )`);
+    db.transaction(() => {
+        const runs = new Map();
+        for (const entry of entries) {
+            upsert.run(entry.taskId, entry.roleName, entry.runId, entry.progressId, entry.sequence ?? null, JSON.stringify(entry.payload), entry.receivedAt);
+            runs.set(`${entry.taskId}\0${entry.runId}`, entry);
+        }
+        for (const { taskId, runId } of runs.values())
+            cap.run(taskId, runId, taskId, runId, runCap);
+    })();
+}