@zq-silk/yui 2.8.1 → 2.10.0

package/dist/storage/sqliteStore.js

@@ -40,6 +40,7 @@ import { runPurposeAdmitsTaskState } from "../agentRun/agentRun.js";
 import { validateTaskBrief } from "../brief/taskBrief.js";
 import { validateContextSnapshot } from "../context/contextSnapshot.js";
 import { consumePendingBatch, mailboxTargetKey, validateWorkMailbox } from "../coordination/workMailbox.js";
+import { createTaskEvent } from "../event/taskEvent.js";
 import { enqueueDurableOperatorFact } from "../scheduler/operatorEvent.js";
 import { validateDurableJob, validDurableJobTransition } from "../job/durableJob.js";
 import { validateGlobalRoleMessage } from "../message/message.js";
@@ -60,6 +61,8 @@ import { TASK_RECORD_ID_PREFIXES } from "../task/taskRecordReference.js";
 import { operationalTaskRecords, TASK_RECORD_RETIRED_EVENT } from "../task/taskRecordRetirement.js";
 import { writeTelemetryBatch } from "../telemetry/sqliteTelemetryBatch.js";
 import { STORED_RECORD_TABLES, validateStoredRecord } from "./recordValidation.js";
+import { jobScopeKey, validateJobDefinition } from "../job/jobDefinition.js";
+import { validateSchedule } from "../schedule/schedule.js";
 import { gateArtifactKey, validateGateArtifact } from "../verification/gateArtifact.js";
 import { validateWorkItem } from "../workItem/workItem.js";
 import { managedWorkspaceKey } from "../worktree/managedWorkspace.js";
@@ -986,10 +989,22 @@ export class SqliteTaskStore {
         const params = { name: roleName };
         if (query.handling)
             where.push(`json_extract(payload, '$.inbox.claim') IS NOT NULL
-      AND json_extract(payload, '$.inbox.ack') IS NULL`);
+      AND json_extract(payload, '$.inbox.ack') IS NULL
+      AND json_extract(payload, '$.inbox.retirement') IS NULL`);
+        if (query.unclaimed)
+            where.push("json_extract(payload, '$.inbox') IS NULL");
+        if (query.handlingExceptSession !== undefined) {
+            if (!query.handling)
+                throw new Error("A handling Session filter requires a handling query.");
+            where.push(`(json_extract(payload, '$.inbox.claim.actor.agentId') != @handlingAgent
+        OR json_extract(payload, '$.inbox.claim.actor.nativeSessionId') != @handlingSession)`);
+            params.handlingAgent = query.handlingExceptSession.agentId;
+            params.handlingSession = query.handlingExceptSession.nativeSessionId;
+        }
         if (query.pending)
             where.push(`json_extract(payload, '$.delivery') IS NULL
       AND json_extract(payload, '$.inbox.ack') IS NULL
+      AND json_extract(payload, '$.inbox.retirement') IS NULL
       AND json_extract(payload, '$.notDelivered') IS NULL
       AND (json_extract(payload, '$.inputControl.action') = 'queue'
         OR json_extract(payload, '$.interruptThen') IS NOT NULL)`);
@@ -1056,6 +1071,25 @@ export class SqliteTaskStore {
             throw new StorageRecordError("Task id is required.");
         }
         this.#mutate(() => {
+            const schedules = this.listSchedules({ kind: "task", taskId: task.id });
+            if (task.status === "completed" && schedules.some(s => s.rule.kind === "once"
+                && (s.state === "enabled" || s.state === "needs-attention"))) {
+                throw new StorageRecordError("Task has unfulfilled once Schedules; inspect and explicitly disable them before completion.");
+            }
+            if (["completed", "cancelled", "archived"].includes(task.status)) {
+                for (const schedule of schedules.filter(s => s.state === "enabled" || s.state === "needs-attention")) {
+                    this.saveSchedule({ ...schedule, state: "retired", revision: schedule.revision + 1,
+                        reason: `Task ${task.status}; no future admission. Pending intent and Run history retained.`,
+                        updatedAt: task.updatedAt });
+                }
+            }
+            else if (task.executionGate.state === "stopped") {
+                for (const schedule of schedules.filter(s => s.state === "enabled")) {
+                    this.saveSchedule({ ...schedule, state: "needs-attention", revision: schedule.revision + 1,
+                        reason: "Task execution stopped; inspect and explicitly enable after execution resumes.",
+                        updatedAt: task.updatedAt });
+                }
+            }
             for (const binding of task.projectBindings) {
                 const found = this.#db.prepare("SELECT 1 FROM projects WHERE id = ?").get(binding.projectId);
                 if (found === undefined)
@@ -1234,6 +1268,71 @@ export class SqliteTaskStore {
         return this.#getPayload("integration_attempts", "task_id = ? AND integration_id = ?", [taskId, integrationId]);
     }
     // -- durable jobs -----------------------------------------------------------
+    saveSchedule(schedule) {
+        validateSchedule(schedule);
+        this.#mutate(() => {
+            this.#db.prepare(`INSERT INTO schedules VALUES(?,?,?,?,?)
+        ON CONFLICT(scope_key,schedule_id) DO UPDATE SET payload=excluded.payload,state=excluded.state,next_due=excluded.next_due`)
+                .run(jobScopeKey(schedule.scope), schedule.id, this.#recordJson("schedules", schedule), schedule.state, schedule.nextDue);
+        });
+    }
+    getSchedule(scope, id) {
+        return this.#getPayload("schedules", "scope_key=? AND schedule_id=?", [jobScopeKey(scope), id]);
+    }
+    listSchedules(scope) {
+        return this.#listPayload("schedules", "scope_key=?", [jobScopeKey(scope)]);
+    }
+    listDueSchedules(now, limit) {
+        const rows = this.#db.prepare(`SELECT payload FROM schedules
+      WHERE state='enabled' AND next_due<=?
+      ORDER BY COALESCE(json_extract(payload,'$.lastAttempt.at'),''),next_due,scope_key,schedule_id LIMIT ?`).all(now, limit);
+        return rows.map(row => validateSchedule(JSON.parse(row.payload)));
+    }
+    saveJobDefinition(job) {
+        validateJobDefinition(job);
+        if (job.scope.kind === "task")
+            this.#requireTask(job.scope.taskId);
+        const previous = this.getJobDefinition(job.scope, job.id);
+        if (previous !== null && (job.revision !== previous.revision + 1
+            || job.createdAt !== previous.createdAt || Date.parse(job.updatedAt) < Date.parse(previous.updatedAt))) {
+            throw new StorageRecordError("Job definition revision changed; reload before editing.");
+        }
+        this.#mutate(() => {
+            this.#db.prepare(`INSERT INTO job_definitions VALUES(?,?,?)
+        ON CONFLICT(scope_key,definition_id) DO UPDATE SET payload=excluded.payload`)
+                .run(jobScopeKey(job.scope), job.id, this.#recordJson("job_definitions", job));
+        });
+    }
+    getJobDefinition(scope, id) {
+        return this.#getPayload("job_definitions", "scope_key=? AND definition_id=?", [jobScopeKey(scope), id]);
+    }
+    listJobDefinitions(scope) {
+        return this.#listPayload("job_definitions", "scope_key=?", [jobScopeKey(scope)]);
+    }
+    saveGlobalJobRun(run) {
+        validateDurableJob(run);
+        if ("taskId" in run || run.scope !== "global")
+            throw new StorageRecordError("Global Run cannot have a Task.");
+        const previous = this.getGlobalJobRun(run.id);
+        if (previous !== null && (!validDurableJobTransition(previous, run)
+            || Date.parse(run.updatedAt) < Date.parse(previous.updatedAt))) {
+            throw new StorageRecordError("Invalid global JobRun transition.");
+        }
+        this.#mutate(() => {
+            this.#db.prepare(`INSERT INTO global_job_runs VALUES(?,?,?)
+        ON CONFLICT(run_id) DO UPDATE SET payload=excluded.payload,status=excluded.status`)
+                .run(run.id, this.#recordJson("global_job_runs", run), run.status);
+        });
+    }
+    getGlobalJobRun(id) {
+        return this.#getPayload("global_job_runs", "run_id=?", [id]);
+    }
+    listGlobalJobRuns() {
+        return this.#listPayload("global_job_runs", "1=1", []);
+    }
+    listActiveGlobalJobRuns() {
+        return this.#listPayload("global_job_runs", "status IN ('queued','running')", []);
+    }
     nextDurableJobId(taskId) {
         return this.#nextTaskRecordId(taskId, "durableJob");
     }
@@ -1243,21 +1342,35 @@ export class SqliteTaskStore {
         }
         validateDurableJob(job);
         this.#requireTask(taskId);
-        const existing = this.getDurableJob(taskId, job.id);
-        if (existing !== null) {
-            if (Date.parse(job.updatedAt) < Date.parse(existing.updatedAt)) {
-                throw new StorageRecordError(`DurableJob updatedAt cannot move backwards: ${job.id}`);
-            }
-            if (!validDurableJobTransition(existing, job)) {
-                throw new StorageRecordError(`DurableJob transition is invalid: ${job.id}`);
-            }
-        }
         this.#mutate(() => {
+            const existing = this.getDurableJob(taskId, job.id);
+            if (existing !== null) {
+                if (Date.parse(job.updatedAt) < Date.parse(existing.updatedAt)) {
+                    throw new StorageRecordError(`DurableJob updatedAt cannot move backwards: ${job.id}`);
+                }
+                if (!validDurableJobTransition(existing, job)) {
+                    throw new StorageRecordError(`DurableJob transition is invalid: ${job.id}`);
+                }
+            }
             this.#db.prepare(`INSERT INTO durable_jobs (job_id, task_id, idempotency_key, status, payload, created_at, updated_at)
          VALUES (?, ?, ?, ?, ?, ?, ?)
          ON CONFLICT(task_id, job_id) DO UPDATE SET idempotency_key = excluded.idempotency_key,
            status = excluded.status,
            payload = excluded.payload, updated_at = excluded.updated_at`).run(job.id, taskId, job.idempotencyKey ?? null, job.status, this.#recordJson("durable_jobs", job), job.createdAt, job.updatedAt);
+            // All Task Job writers share this boundary (including cancellation and
+            // unknown-result acknowledgement). Publish semantic changes atomically;
+            // heartbeat/checkpoint/notification bookkeeping is deliberately excluded.
+            if (existing === null || existing.status !== job.status
+                || !isDeepStrictEqual(existing.result, job.result)
+                || existing.cancelRequestedAt !== job.cancelRequestedAt
+                || existing.acknowledgedAt !== job.acknowledgedAt) {
+                this.saveEvent(taskId, createTaskEvent(this.nextEventId(taskId), taskId, "job.state-changed", {
+                    jobId: job.id, status: job.status,
+                    ...(existing === null ? {} : { previousStatus: existing.status }),
+                    ...(job.cancelRequestedAt === undefined ? {} : { cancelRequestedAt: job.cancelRequestedAt }),
+                    ...(job.acknowledgedAt === undefined ? {} : { acknowledgedAt: job.acknowledgedAt })
+                }, new Date(job.updatedAt)));
+            }
         });
     }
     listDurableJobs(taskId) {

package/dist/storage/storageVersions.js

@@ -1,4 +1,4 @@
-export const CURRENT_STORAGE_VERSION = "1.8";
+export const CURRENT_STORAGE_VERSION = "1.13";
 export const MIN_SUPPORTED_STORAGE_VERSION = "1.0";
 export const STORAGE_FORMAT = "yui-home";
 export function isStorageVersion(value) {

package/dist/storage/storeRpc.js

@@ -70,6 +70,11 @@ const READ_ONLY_STORE_METHODS = new Set([
     "listIntegrationAttempts",
     "getIntegrationAttempt",
     "listActiveDurableJobs",
+    "getJobDefinition",
+    "listJobDefinitions",
+    "getGlobalJobRun",
+    "listGlobalJobRuns",
+    "listActiveGlobalJobRuns",
     "listRoles",
     "getRole",
     "listManagedWorkspaces",

package/dist/storage/upgrade/jobDefinitionMigration.js

@@ -0,0 +1,22 @@
+import { validateDurableJob } from "../../job/durableJob.js";
+import { definitionFromTaskRun } from "../../job/jobDefinition.js";
+export function migrateJobDefinitions(db) {
+    const rows = db.prepare("SELECT task_id, job_id, payload FROM durable_jobs").all();
+    for (const row of rows) {
+        const original = JSON.parse(row.payload);
+        if (original.taskId !== row.task_id || original.id !== row.job_id
+            || original.definitionId !== undefined || original.definitionRevision !== undefined || original.trigger !== undefined) {
+            throw new Error(`Invalid 1.8 Job identity: ${row.task_id}/${row.job_id}.`);
+        }
+        const run = validateDurableJob({
+            ...original, definitionId: original.id, definitionRevision: 1,
+            trigger: { source: "migration", key: original.operation.requestId }
+        });
+        db.prepare("INSERT INTO storage_migration_archive(migration_version,family,record_key,payload) VALUES(?,?,?,?)")
+            .run(9, "durable_jobs", `${row.task_id}/${row.job_id}`, row.payload);
+        db.prepare("INSERT INTO job_definitions VALUES(?,?,?)")
+            .run(row.task_id, run.definitionId, JSON.stringify(definitionFromTaskRun(run)));
+        db.prepare("UPDATE durable_jobs SET payload=? WHERE task_id=? AND job_id=?")
+            .run(JSON.stringify(run), row.task_id, row.job_id);
+    }
+}

package/dist/task/archiveDiagnostics.js

@@ -76,7 +76,7 @@ export function archiveRetainedResources(store, task) {
     return resources;
 }
 export function archiveDeliveryWarnings(delivery) {
-    return delivery.projects.filter(p => p.codeDelivery !== "none" && (!p.merged || !p.verified))
+    return delivery.projects.filter(p => p.deliveryRequired && (!p.merged || !p.verified))
         .map(p => ({ resource: `delivery:${delivery.taskId}/${p.projectId}`,
         detail: `${p.coverage}: ${p.reason} Merged=${p.merged}; verified=${p.verified}.` }));
 }

package/dist/task/archivePreflight.js

@@ -65,7 +65,7 @@ export async function inspectTaskArchive(coordinator, request) {
         throw new Error(`Task not found: ${request.taskId}.`);
     const settlement = archiveSettlementChecks(store, task);
     const delivery = await readArchiveDelivery(store, preparer.git, task, request.force);
-    const deliveryChecks = delivery.projects.filter(p => p.codeDelivery !== "none" && (!p.merged || !p.verified))
+    const deliveryChecks = delivery.projects.filter(p => p.deliveryRequired && (!p.merged || !p.verified))
         .map(p => ({ resource: `delivery:${task.id}/${p.projectId}`, reason: "delivery-coverage", status: "blocked",
         detail: p.reason, expected: { merged: true, verified: true, localCommit: p.expectedLocalCommit },
         observed: { coverage: p.coverage, merged: p.merged, verified: p.verified, localCommit: p.publication?.localCommit ?? null },

package/dist/task/projectDeliveryScope.js

@@ -0,0 +1,20 @@
+/** An append-only Task decision, not a Project permission or a merge fact. */
+export const PROJECT_DELIVERY_DECIDED_EVENT = "task.project-delivery-decided";
+export function projectDeliveryDecision(events, taskId, projectId) {
+    return events.filter(event => event.taskId === taskId
+        && event.type === PROJECT_DELIVERY_DECIDED_EVENT && event.payload.projectId === projectId)
+        // Task event IDs are monotonic durable sequence numbers; wall clocks can move backwards.
+        .sort((a, b) => a.id.localeCompare(b.id, undefined, { numeric: true })).at(-1) ?? null;
+}
+export function projectDeliveryRequirement(decision) {
+    if (decision === null)
+        return "required";
+    const p = decision.payload;
+    if (!["required", "excluded"].includes(p.requirement ?? "")
+        || !p.reason?.trim() || !p.sourceMessageId?.trim()
+        || !/^[a-f0-9]{64}$/u.test(p.sourceDigest ?? "") || !p.purpose?.trim()
+        || !["user", "operator", "leader"].includes(p.by ?? "")) {
+        throw new Error(`Project delivery decision ${decision.id} has incomplete evidence; preserve it for diagnosis.`);
+    }
+    return p.requirement;
+}

package/dist/task/publicationToolObservation.js

@@ -0,0 +1,126 @@
+import { usageError } from "../errors/cliError.js";
+const REQUIRED = [
+    "taskId", "publicationId", "projectId", "localCommit", "provider", "repository",
+    "externalKind", "externalId", "externalUrl", "targetBranch", "state",
+    "headCommit", "observedAt", "tool", "command", "output"
+];
+const OPTIONAL = ["remoteCommit", "mergedAt"];
+const SHA = /^[0-9a-f]{40}$/u;
+const MAX_AGE_MS = 24 * 60 * 60 * 1_000;
+export function parsePublicationToolObservation(text) {
+    if (Buffer.byteLength(text, "utf8") > 64 * 1024) {
+        throw usageError("Tool observation must not exceed 64 KiB; supply a sanitized relevant output excerpt.");
+    }
+    let value;
+    try {
+        value = JSON.parse(text);
+    }
+    catch {
+        throw usageError("--observation requires a JSON object.");
+    }
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        throw usageError("--observation requires a JSON object.");
+    }
+    const record = value;
+    const allowed = new Set([...REQUIRED, ...OPTIONAL]);
+    for (const key of Object.keys(record)) {
+        if (!allowed.has(key))
+            throw usageError(`Unknown tool observation field: ${key}.`);
+    }
+    for (const key of [...REQUIRED, ...OPTIONAL]) {
+        if (OPTIONAL.includes(key) && record[key] === undefined)
+            continue;
+        if (typeof record[key] !== "string" || record[key].trim().length === 0) {
+            throw usageError(`Tool observation requires nonempty ${key}.`);
+        }
+    }
+    for (const key of ["localCommit", "headCommit", "remoteCommit"]) {
+        if (record[key] !== undefined && !SHA.test(record[key])) {
+            throw usageError(`Tool observation ${key} requires an exact lowercase Git SHA.`);
+        }
+    }
+    if (!((record.provider === "github" && record.externalKind === "pull-request")
+        || (record.provider === "gitlab" && record.externalKind === "merge-request"))) {
+        throw usageError("Tool observation requires a matching GitHub PR or GitLab MR kind.");
+    }
+    if (!["open", "merged", "closed"].includes(record.state)
+        || (record.state === "merged" && record.remoteCommit === undefined)) {
+        throw usageError("Tool observation requires a known state and an integrated commit for a merge.");
+    }
+    for (const key of ["observedAt", "mergedAt"]) {
+        if (record[key] !== undefined
+            && (!/^\d{4}-\d\d-\d\dT/u.test(record[key])
+                || !Number.isFinite(Date.parse(record[key])))) {
+            throw usageError(`Tool observation ${key} requires an ISO timestamp.`);
+        }
+    }
+    // Canonical key ordering makes retries independent of JSON whitespace/order.
+    const evidence = JSON.stringify(Object.fromEntries(Object.keys(record).sort().map(key => [key, record[key]])));
+    return { ...record, evidence };
+}
+export function assertPublicationToolObservation(publication, observation, now, observationNotBefore) {
+    for (const field of ["taskId", "projectId", "provider", "repository",
+        "externalKind", "externalId", "localCommit", "targetBranch"]) {
+        if (observation[field] !== publication[field]) {
+            throw usageError(`Tool observation ${field} does not match the Publication candidate.`);
+        }
+    }
+    if (observation.publicationId !== publication.id) {
+        throw usageError("Tool observation publicationId does not match the selected Publication.");
+    }
+    if (publication.externalUrl === undefined
+        || canonicalPublicationUrl(observation.externalUrl, publication.provider)
+            !== canonicalPublicationUrl(publication.externalUrl, publication.provider)) {
+        throw usageError("Tool observation externalUrl must match the recorded Publication service and object.");
+    }
+    const url = new URL(canonicalPublicationUrl(observation.externalUrl, publication.provider));
+    // GitLab UI routes are deployment-specific. Structured identity above and
+    // the complete registered URL bind the object without inventing a web route.
+    if (publication.provider === "github"
+        && url.pathname !== `/${publication.repository.toLowerCase()}/pull/${publication.externalId}`) {
+        throw usageError("Tool observation URL does not match the repository and PR/MR identity.");
+    }
+    const observed = Date.parse(observation.observedAt);
+    if ((observationNotBefore !== undefined && observed < observationNotBefore)
+        || observed > now.getTime() || now.getTime() - observed > MAX_AGE_MS) {
+        throw usageError("Tool observation is stale or future-dated; observe the current Publication within 24 hours of recording.");
+    }
+    if (observation.mergedAt !== undefined && Date.parse(observation.mergedAt) > observed) {
+        throw usageError("Tool observation merge time cannot follow its observation time.");
+    }
+}
+/** Derive the latest material change from immutable history, not title edits or
+ * initial bookkeeping. A tool read may legitimately precede its first upsert.
+ * Changed-then-restored candidates still have a change boundary. */
+export function publicationObservationNotBefore(publication, previous) {
+    const fields = [
+        "projectId", "provider", "repository", "externalKind", "externalId",
+        "externalUrl", "localCommit", "targetBranch", "state", "headCommit", "remoteCommit", "mergedAt"
+    ];
+    let current = publication;
+    while (current.supersedes !== undefined) {
+        const prior = previous(current.supersedes);
+        if (prior === null)
+            throw usageError("Publication history is incomplete; cannot validate observation freshness.");
+        if (fields.some(field => current[field] !== prior[field])) {
+            return Date.parse(current.createdAt);
+        }
+        current = prior;
+    }
+    return undefined;
+}
+export function canonicalPublicationUrl(value, provider) {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        throw usageError("Publication URL must be an absolute HTTP(S) URL.");
+    }
+    if (!["https:", "http:"].includes(url.protocol) || url.username || url.password
+        || url.search || url.hash) {
+        throw usageError("Publication URL must be HTTP(S), without credentials, query or fragment.");
+    }
+    const path = url.pathname.replace(/\/$/u, "");
+    return `${url.origin}${provider === "github" ? path.toLowerCase() : path}`;
+}

package/dist/task/remoteDelivery.js

@@ -1,4 +1,5 @@
 import { publicationAdoption } from "./publicationAdoption.js";
+import { projectDeliveryDecision, projectDeliveryRequirement } from "./projectDeliveryScope.js";
 /**
  * One read-only delivery projection over existing Task, workspace, completion,
  * and Publication facts. It never writes a merged flag or queries a provider.
@@ -10,6 +11,8 @@ export function projectTaskRemoteDelivery(facts) {
     const currentPublications = currentPublicationReferences(facts.publications);
     const projects = facts.task.projectBindings.map((binding) => {
         const expectedLocalCommit = expected.commits.get(binding.projectId) ?? null;
+        const scopeDecision = projectDeliveryDecision(facts.events, facts.task.id, binding.projectId);
+        const deliveryRequirement = projectDeliveryRequirement(scopeDecision);
         const baseCommit = baseCommits.get(binding.projectId) ?? null;
         const codeDelivery = expectedLocalCommit === null
             ? "unknown"
@@ -44,6 +47,9 @@ export function projectTaskRemoteDelivery(facts) {
             deliveryLocalCommit: covers ? publication.localCommit ?? null : null,
             adoption,
             codeDelivery,
+            deliveryRequirement,
+            scopeDecision,
+            deliveryRequired: deliveryRequirement === "required" && codeDelivery !== "none",
             publication,
             state: publication?.state ?? null,
             verification: publication?.verification ?? null,
@@ -51,23 +57,26 @@ export function projectTaskRemoteDelivery(facts) {
             coverage,
             merged,
             verified,
-            reason: projectCoverageReason(expectedLocalCommit, publication, coverage, adoption) + (coverage === "stale" && adoptionEvidence?.reason
+            reason: (deliveryRequirement === "excluded"
+                ? `No delivery obligation: ${scopeDecision.payload.reason} (${scopeDecision.id}). Merge and cleanup facts remain separate. `
+                : "") + projectCoverageReason(expectedLocalCommit, publication, coverage, adoption) + (coverage === "stale" && adoptionEvidence?.reason
                 ? ` ${adoptionEvidence.reason}` : "")
         };
     });
     const codeProjects = projects.filter((project) => project.codeDelivery !== "none");
-    const mergedProjectCount = codeProjects.filter((project) => project.merged).length;
-    const verifiedProjectCount = codeProjects.filter((project) => project.verified).length;
-    const allMerged = codeProjects.every((project) => project.merged);
-    const allVerified = codeProjects.every((project) => project.verified);
-    const status = codeProjects.length === 0
+    const requiredProjects = projects.filter(project => project.deliveryRequired);
+    const mergedProjectCount = requiredProjects.filter((project) => project.merged).length;
+    const verifiedProjectCount = requiredProjects.filter((project) => project.verified).length;
+    const allMerged = requiredProjects.every((project) => project.merged);
+    const allVerified = requiredProjects.every((project) => project.verified);
+    const status = requiredProjects.length === 0
         ? "none"
-        : codeProjects.some((project) => project.coverage === "head-unavailable")
+        : requiredProjects.some((project) => project.coverage === "head-unavailable")
             ? "unavailable"
             : allMerged
                 ? allVerified ? "merged" : "unverified"
                 : mergedProjectCount > 0 ? "partial"
-                    : codeProjects.some(p => p.state === "merged") ? "uncovered" : "pending";
+                    : requiredProjects.some(p => p.state === "merged") ? "uncovered" : "pending";
     return {
         taskId: facts.task.id,
         source: expected.source,
@@ -81,6 +90,8 @@ export function projectTaskRemoteDelivery(facts) {
         allVerified,
         totalProjectCount: projects.length,
         codeProjectCount: codeProjects.length,
+        requiredCodeProjectCount: requiredProjects.length,
+        excludedProjectCount: projects.filter(project => project.deliveryRequirement === "excluded").length,
         mergedProjectCount,
         verifiedProjectCount,
         integratedCoverageSatisfied: allMerged && allVerified,

package/dist/task/remoteDeliveryService.js

@@ -2,6 +2,7 @@ import { isDeepStrictEqual } from "node:util";
 import { usageError } from "../errors/cliError.js";
 import { projectTaskRemoteDelivery } from "../task/remoteDelivery.js";
 import { PUBLICATION_ADOPTED_EVENT } from "./publicationAdoption.js";
+import { PROJECT_DELIVERY_DECIDED_EVENT } from "./projectDeliveryScope.js";
 export function projectTaskRemoteDeliveryFromStore(store, task, currentCandidate = null) {
     return createTaskRemoteDeliveryProof(store, task, currentCandidate).delivery;
 }
@@ -10,7 +11,7 @@ export function createTaskRemoteDeliveryProof(store, task, currentCandidate = nu
     const delivery = projectTaskRemoteDelivery({
         task,
         events: store.listEventsByType(task.id, [
-            "task.completed", "task.archived", PUBLICATION_ADOPTED_EVENT
+            "task.completed", "task.archived", PUBLICATION_ADOPTED_EVENT, PROJECT_DELIVERY_DECIDED_EVENT
         ]),
         publications,
         managedWorkspaces: store.listManagedWorkspaces(task.id),
@@ -49,13 +50,13 @@ export function assertTaskRemoteDeliveryProof(store, task, proof) {
 }
 export function assertTaskRemoteDeliveryIntegrated(delivery) {
     if (!delivery.allMerged) {
-        const headUnavailable = delivery.projects.filter((project) => (project.codeDelivery !== "none"
+        const headUnavailable = delivery.projects.filter((project) => (project.deliveryRequired
             && 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)
+            .filter((project) => project.deliveryRequired && !project.merged)
             .map((project) => (`${project.projectId}/${project.coverage}`
             + (project.publication === null ? "" : `/${project.publication.id}`)))
             .join(", ");
@@ -65,7 +66,7 @@ export function assertTaskRemoteDeliveryIntegrated(delivery) {
     if (delivery.allVerified)
         return;
     const unverified = delivery.projects
-        .filter((project) => (project.codeDelivery !== "none"
+        .filter((project) => (project.deliveryRequired
         && project.merged
         && !project.verified))
         .map((project) => (`${project.projectId}/${project.coverage}`

package/dist/task/taskActivationService.js

@@ -3,6 +3,8 @@ import { enqueueWork } from "../coordination/workMailboxQueue.js";
 import { createProjectResources } from "../resources/projectResourceService.js";
 import { admitTaskActivationRequest, adoptTaskActivationRequest, cancelTaskActivationRequest, canonicalEnvironmentPlan, createTaskActivationRequest, describeEnvironmentPlan, failTaskActivationRequest, settledActivationFromEvents, taskActivationInputDigest, TASK_ACTIVATION_EVENT } from "./taskActivation.js";
 import { setTaskActivationRequest, recordTaskActivationRequestEvidence } from "./task.js";
+import { contextContentDigest } from "../context/contextSnapshot.js";
+import { activationSourceEvent } from "../context/taskPhase.js";
 /**
  * The terminal outcome already recorded for a requestId, or `undefined` if it
  * was never cancelled or adopted.
@@ -63,6 +65,20 @@ export function recordTaskActivationRequestInTransaction(tx, input, now) {
         ? "immediate"
         : "after-planning-turn";
     const existing = task.activationRequest;
+    if (input.sourceMessageId !== undefined && input.sourceText !== undefined) {
+        throw new Error("Activation source requires either a Message or exact text, not both.");
+    }
+    if (input.sourceText !== undefined && (!input.sourceText.trim() || input.sourceText.includes("\0"))) {
+        throw new Error("Activation source text must be nonempty exact input.");
+    }
+    const sourceMessage = input.sourceMessageId === undefined ? undefined : tx.queryContextRecords(task.id, {
+        family: "task-message", ids: [input.sourceMessageId], limit: 1
+    }).records[0]?.value;
+    if (input.sourceMessageId !== undefined && (!sourceMessage
+        || !["user", "operator"].includes(sourceMessage.kind) || sourceMessage.recipient !== undefined
+        || sourceMessage.workItemId !== undefined)) {
+        throw new Error("Activation source must reference an existing shared user/Operator Message in this Task.");
+    }
     // A requestId whose outcome was already decided is never re-opened, whether
     // it still holds the slot or a later request displaced it. Cancelling A,
     // requesting B and then retrying A must not resurrect A: the withdrawal is
@@ -81,6 +97,11 @@ export function recordTaskActivationRequestInTransaction(tx, input, now) {
             + "Use a new requestId.");
     }
     if (existing?.operation.requestId === input.requestId) {
+        const source = activationSourceEvent(tx, task)?.payload;
+        if (source?.sourceMessageId !== input.sourceMessageId || source?.sourceText !== input.sourceText
+            || (sourceMessage !== undefined && source?.sourceBodyDigest !== contextContentDigest(sourceMessage.body))) {
+            throw new Error(`Activation requestId ${input.requestId} was already used with a different source.`);
+        }
         const digest = taskActivationInputDigest(task.id, {
             startMode,
             ...(planningRun === undefined ? {} : { afterPlanningRun: planningRun }),
@@ -112,11 +133,25 @@ export function recordTaskActivationRequestInTransaction(tx, input, now) {
         environmentPlan: plan
     }, now);
     tx.saveTask(setTaskActivationRequest(task, request, now));
+    const priorMessageId = tx.queryContextRecords(task.id, {
+        family: "task-message", descending: true, limit: 1
+    }).records[0]?.id;
     tx.saveEvent(task.id, createTaskEvent(tx.nextEventId(task.id), task.id, TASK_ACTIVATION_EVENT.requested, {
         requestId: request.operation.requestId,
         startMode: request.startMode,
         environmentPlan: describeEnvironmentPlan(request.environmentPlan),
         actor: request.operation.actorId,
+        ...(priorMessageId === undefined ? {} : { priorMessageId }),
+        ...(input.sourceMessageId === undefined ? {} : {
+            sourceMessageId: input.sourceMessageId,
+            sourceBodyDigest: contextContentDigest(sourceMessage.body),
+            sourceKind: "task-message"
+        }),
+        ...(input.sourceText === undefined ? {} : {
+            sourceText: input.sourceText,
+            sourceKind: input.actorId.startsWith("task:") ? "leader-attested-native-input" : "caller-provided-input",
+            ...(input.sourceNativeSessionId === undefined ? {} : { sourceNativeSessionId: input.sourceNativeSessionId })
+        }),
         ...(request.afterPlanningRun === undefined
             ? {}
             : { afterPlanningRun: request.afterPlanningRun })

package/dist/web/assets/client/app/settings.js

@@ -8,6 +8,7 @@ import { createThemeController } from "/assets/js/lib/theme.js";
 import { clearPreference, readSessionAccessMode, writeSessionAccessMode } from "/assets/js/lib/prefs.js";
 import { i18n, createManageShell, pageSections, registerManagePage, navigateManage } from "/assets/js/layout/manageShell.js";
 import { mountSkills } from "/assets/js/views/skills.js";
+import { mountJobs } from "/assets/js/views/jobs.js";
 
 const $ = selector => document.querySelector(selector);
 const t = i18n.t;
@@ -18,11 +19,13 @@ function readSection() {
   return SECTIONS.includes(section) ? section : SECTIONS[0];
 }
 let section = readSection();
+let jobs;
 const shell = createManageShell({ page: "settings", t, onNavigate: navigate });
 function showSection(next) {
   section = next;
   document.querySelectorAll("#settings-root > .manage-section[data-section]").forEach(panel => { panel.hidden = panel.dataset.section !== next; });
   shell.set(next);
+  if (next === "jobs" && !jobs) jobs = mountJobs($("#global-jobs"), t);
 }
 function navigate(next) {
   navigateManage({ page: "settings", section: next });
@@ -34,6 +37,9 @@ function markDirty(name, value) {
 }
 registerManagePage("settings", { show: next => showSection(next.section) });
 i18n.subscribe(() => shell.render());
+i18n.subscribe(() => {
+  if (jobs && !jobs.isDirty() && !jobs.isBusy()) jobs = mountJobs($("#global-jobs"), t);
+});
 showSection(section);
 const skills = mountSkills($("#skill-browser"), t, { heading: false, onDirty: value => markDirty("skills", value) });
 i18n.subscribe(() => skills?.translate());
@@ -59,7 +65,7 @@ let searchTimer;
 const more = h("button.btn", { type: "button", hidden: true }, t("settings.more"));
 container.after(more);
 window.addEventListener("beforeunload", event => {
-  if (!groups.some(g => g.dirty)) return;
+  if (!groups.some(g => g.dirty) && !jobs?.isDirty()) return;
   event.preventDefault(); event.returnValue = "";
 });