@zq-silk/yui 0.15.11 → 0.16.0

package/dist/storage/storageSchema.js

@@ -16,23 +16,11 @@ export class StorageSchemaError extends Error {
 /**
  * Inspect the one authoritative SQLite migration head without changing it.
  *
- * `schema.json` and `state.json` are recognized only to prevent setup from
- * overwriting an old Home whose SQLite authority is missing. They are not
- * version authorities for current Homes.
+ * Extra files never override the SQLite authority. A missing database in a
+ * non-empty Home is unverified, not permission to initialize over its evidence.
  */
 export function inspectStorageSchema(rootDir) {
     const databasePath = join(rootDir, CURRENT_DATABASE_FILENAME);
-    const hasPreBaselineEvidence = existsSync(join(rootDir, "schema.json")) || existsSync(join(rootDir, "state.json"));
-    if (hasPreBaselineEvidence) {
-        return {
-            status: "unsupported",
-            direction: "older",
-            currentVersion: 0,
-            latestVersion: CURRENT_STORAGE_VERSION,
-            minimumSupportedVersion: MIN_SUPPORTED_STORAGE_VERSION,
-            databasePath
-        };
-    }
     if (!existsSync(databasePath)) {
         if (existsSync(rootDir)) {
             try {

package/dist/storage/storageVersions.js

@@ -13,4 +13,4 @@
  * intermediate Yui releases.
  */
 export const MIN_SUPPORTED_STORAGE_VERSION = 1;
-export const CURRENT_STORAGE_VERSION = 25;
+export const CURRENT_STORAGE_VERSION = 37;

package/dist/storage/storeRpc.js

@@ -8,7 +8,8 @@
  *
  *   - {@link AsyncTaskStore} ........ the async counterpart to `TaskStore`
  *     (design §6): every method returns a promise; the worker owns the
- *     `SqliteTaskStore` connection, the main thread never touches the db.
+ *     worker-side connection. The Controller's separate synchronous scheduler
+ *     connection is not routed through this interface.
  *   - {@link AsyncTaskStoreClient} .. the client: serializes requests, applies
  *     the storage idempotency/dialect rules on top of the shared bounded RPC
  *     (outbox §5.4, `AbortSignal` cancellation §3.1, restart + replay §3.1).
@@ -16,8 +17,8 @@
  *     `transactionAsync` ships an ordered batch that the worker runs inside one
  *     `BEGIN IMMEDIATE … COMMIT` (§3.2).
  *
- * SQLite is the only product Store. `YUI_STORE_WORKER` controls whether its
- * connection lives in a Worker Thread; it does not select another authority.
+ * SQLite is the only product Store. `YUI_STORE_WORKER` selects the observer
+ * execution boundary; it does not select another authority.
  */
 import { BoundedRpcClient, nextRequestId } from "../core/boundedRpc.js";
 import { StorageCancelledError, StorageConflictError, StorageRecordError } from "./taskStore.js";
@@ -51,6 +52,12 @@ const READ_ONLY_STORE_METHODS = new Set([
     "getTask",
     "readNextActionFacts",
     "readCompletionReadinessFacts",
+    "queryContextRecords",
+    "latestEventSequence",
+    "listEventsByType",
+    "listTaskRunWorkspaceBases",
+    "contextInputReferences",
+    "listActiveRuns",
     "listActiveTaskIds",
     "listPlanningDraftTaskIds",
     "listPendingActivationRequestTaskIds",
@@ -72,6 +79,7 @@ const READ_ONLY_STORE_METHODS = new Set([
     "getRoleSessionSet",
     "getTaskRoleSessionSet",
     "listRoleSessionSets",
+    "listProviderRetrySessions",
     "listRuntimeSessionCandidates",
     "getRoleSession",
     "getWorkItem",
@@ -167,12 +175,8 @@ function storageProtocol(home, options) {
  * RPCs) plus {@link transactionAsync}, {@link invokeObserver}, and {@link close}.
  */
 export class AsyncTaskStoreClient {
-    #home;
-    #options;
     #rpc;
     constructor(home, options = {}) {
-        this.#home = home;
-        this.#options = options;
         this.#rpc = new BoundedRpcClient(storageProtocol(home, options), {
             maxInFlight: options.maxInFlight,
             maxQueue: options.maxQueue,
@@ -217,6 +221,11 @@ export class AsyncTaskStoreClient {
     close() {
         return this.#rpc.close();
     }
+    /** Best-effort diagnostic batch on this worker, without a Task outbox entry. */
+    async flushTelemetry(entries, runCap) {
+        const requestId = nextRequestId();
+        await this.#rpc.send(requestId, { kind: "telemetry", requestId, entries, runCap });
+    }
     /** Currently in-flight requests (metrics/tests). */
     get inFlight() {
         return this.#rpc.inFlight;

package/dist/storage/taskCatalog.js

@@ -0,0 +1,123 @@
+/** Current facts, not another persisted projection or execution status. */
+export const CATALOG_ATTENTION = [
+    "openInputs", "pendingOperations", "unknownOperations", "executionSignals"
+];
+/**
+ * All filtering/counting stays in SQLite. Only page-sized rows and fixed
+ * attention samples cross into JS; no Task/Run/Message/Event body is decoded.
+ * The existing catalog and record tables remain the only stored authorities.
+ */
+export function queryTaskCatalog(db, query) {
+    const scope = ["1=1"];
+    const params = { limit: query.limit };
+    if (query.taskId !== undefined) {
+        scope.push("c.task_id = @taskId");
+        params.taskId = query.taskId;
+    }
+    if (!query.all)
+        scope.push("c.status <> 'archived'");
+    const match = ["1=1"];
+    if (query.status !== undefined) {
+        match.push("status = @status");
+        params.status = query.status;
+    }
+    if (query.project !== undefined) {
+        match.push(`EXISTS (SELECT 1 FROM task_records r, json_each(r.payload, '$.projectBindings') p
+      WHERE r.task_id = facts.id AND json_extract(p.value, '$.projectId') = @project)`);
+        params.project = query.project;
+    }
+    if (query.search) {
+        match.push(`EXISTS (SELECT 1 FROM task_records r WHERE r.task_id = facts.id AND
+      (instr(lower(json_extract(r.payload, '$.title')), lower(@search)) > 0
+       OR instr(lower(r.task_id), lower(@search)) > 0
+       OR EXISTS (SELECT 1 FROM json_each(r.payload, '$.tags') tag
+          WHERE instr(lower(tag.value), lower(@search)) > 0)
+       OR EXISTS (SELECT 1 FROM json_each(r.payload, '$.projectBindings') b
+          JOIN projects p ON p.id = json_extract(b.value, '$.projectId')
+          WHERE instr(lower(json_extract(p.payload, '$.name')), lower(@search)) > 0)))`);
+        params.search = query.search;
+    }
+    if (query.attention !== undefined)
+        match.push(`${query.attention} > 0`);
+    const position = (name, op) => {
+        const value = query[name];
+        if (value === undefined)
+            return;
+        params[`${name}Date`] = value.createdAt;
+        params[`${name}Id`] = value.id;
+        match.push(`(createdAt, id) ${op} (@${name}Date, @${name}Id)`);
+    };
+    position("through", "<=");
+    // A fixed upper key excludes newly-created Tasks on later pages. Updates
+    // to mutable filters are current reads, not a snapshot/session protocol.
+    const after = [];
+    if (query.after !== undefined) {
+        params.afterDate = query.after.createdAt;
+        params.afterId = query.after.id;
+        after.push("(createdAt, id) > (@afterDate, @afterId)");
+    }
+    const count = (table, condition) => `(SELECT count(*) FROM ${table} x WHERE x.task_id = c.task_id AND (${condition}))`;
+    // Execution signals deliberately preserve raw inspectable conditions:
+    // live runs (including unknown admission/identity/stall), unresolved work,
+    // integrations, and pending Leader recovery. They are NOT a second
+    // classifier for working/blocked/success; precise execution stays in detail.
+    // Including all live runs is conservative: an off-page runtime attention
+    // cannot disappear just because a lightweight read did not fold its history.
+    const cte = `WITH facts AS MATERIALIZED (
+    SELECT c.task_id AS id, c.created_at AS createdAt, c.updated_at AS updatedAt, c.status,
+      ${count("work_items", "1=1")} AS workItems,
+      ${count("turns", "status = 'active'")} AS activeRuns,
+      ${count("input_requests", "status = 'open'")} AS openInputs,
+      ${count("durable_jobs", "status IN ('queued','running')")} AS pendingOperations,
+      ${count("durable_jobs", "status = 'unknown-needs-attention'")} AS unknownOperations,
+      CASE WHEN c.status IN ('active','draft') THEN
+        ${count("turns", "status = 'active'")} +
+        ${count("work_items", "status = 'open' OR (status = 'accepted' AND json_extract(payload, '$.currentExecutionGroupId') IS NOT NULL)")} +
+        ${count("integration_attempts", "status IN ('running','validating','blocked','conflicted','failed')")} +
+        ${count("review_rounds", "status IN ('pending','running','failed')")} +
+        ${count("task_projections", "kind = 'leader-failure' AND payload IS NOT NULL AND payload <> 'null'")} +
+        ${count("mailboxes", "role_name = 'leader' AND (json_type(pending) = 'object' OR json_type(processing) = 'object')")}
+      ELSE 0 END AS executionSignals
+    FROM tasks_catalog c WHERE ${scope.join(" AND ")}
+  ), matching AS MATERIALIZED (SELECT * FROM facts WHERE ${match.join(" AND ")})
+  SELECT
+    (SELECT json_group_array(json_object('status',status,'count',n))
+      FROM (SELECT status,count(*) n FROM facts GROUP BY status)) AS counts,
+    (SELECT count(*) FROM matching) AS total,
+    (SELECT json_object('id',id,'createdAt',createdAt) FROM matching
+      ORDER BY createdAt DESC,id DESC LIMIT 1) AS upper,
+    ${CATALOG_ATTENTION.map(kind => `
+      (SELECT sum(${kind}) FROM facts) AS ${kind}Count,
+      (SELECT count(*) FROM facts WHERE ${kind} > 0) AS ${kind}Tasks,
+      (SELECT json_group_array(id) FROM (SELECT id FROM facts WHERE ${kind} > 0
+        ORDER BY createdAt,id LIMIT 4)) AS ${kind}Ids`).join(",")},
+    (SELECT json_group_array(json_object(
+      'id',page.id,'createdAt',page.createdAt,'updatedAt',page.updatedAt,'status',page.status,
+      'title',substr(json_extract(r.payload,'$.title'),1,256),
+      'summary',substr(json_extract(r.brief,'$.leaderSummary'),1,512),
+      'summaryPresent',json(CASE WHEN r.brief IS NULL THEN 'false' ELSE 'true' END),
+      'workItems',page.workItems,'activeRuns',page.activeRuns,
+      'openInputs',page.openInputs,'pendingOperations',page.pendingOperations,
+      'unknownOperations',page.unknownOperations,'executionSignals',page.executionSignals)
+      ORDER BY page.createdAt,page.id)
+      FROM (SELECT * FROM matching ${after.length ? `WHERE ${after.join(" AND ")}` : ""}
+        ORDER BY createdAt,id LIMIT @limit) page
+      JOIN task_records r ON r.task_id = page.id) AS rows`;
+    const result = db.prepare(cte).get(params);
+    const counts = { draft: 0, active: 0, completed: 0, cancelled: 0, archived: 0, total: 0 };
+    for (const entry of JSON.parse(result.counts)) {
+        counts[entry.status] = entry.count;
+        counts.total += entry.count;
+    }
+    return {
+        rows: JSON.parse(result.rows),
+        total: result.total,
+        through: result.upper === null ? null : JSON.parse(result.upper),
+        counts,
+        attention: Object.fromEntries(CATALOG_ATTENTION.map(kind => [kind, {
+                count: Number(result[`${kind}Count`] ?? 0),
+                taskCount: Number(result[`${kind}Tasks`] ?? 0),
+                taskIds: JSON.parse(result[`${kind}Ids`])
+            }]))
+    };
+}

package/dist/storage/taskStore.js

@@ -2,12 +2,12 @@ import { lstatSync, mkdirSync, realpathSync } from "node:fs";
 import { homedir } from "node:os";
 import { basename, dirname, join, resolve } from "node:path";
 import { isDeepStrictEqual } from "node:util";
+import { resolveTimeZone } from "../config/timeZone.js";
+import { reconciliationIntervalMilliseconds, resolveAgentLaunchInactivityTimeoutSeconds, resolveControllerTaskConcurrency, resolveDeliveryTimeoutSeconds, resolveResourcesGcAutoQuarantine, resolveResourcesGcMode, resolveResourcesQuarantineTtlHours, resolveRuntimeHealth, resolveTelemetryEnabled, resolveTelemetryRunCap, resolveTelemetryTerminalKeep, resolveTmuxBin, resolveTmuxHistoryLimit } from "../config/yuiConfig.js";
 import { validateCapabilityGrant } from "../grant/capabilityGrant.js";
 import { validateReleaseWorkflow } from "../release/releaseWorkflow.js";
-import { validatePublicationReference } from "../task/publicationReference.js";
-import { reconciliationIntervalMilliseconds, resolveAgentLaunchInactivityTimeoutSeconds, resolveControllerTaskConcurrency, resolveDeliveryTimeoutSeconds, resolveLeaderNextActionMode, resolveLeaderSemanticBudgetRuns, resolveResourcesGcAutoQuarantine, resolveResourcesGcMode, resolveResourcesQuarantineTtlHours, resolveRuntimeHealth, resolveTelemetryEnabled, resolveTelemetryRunCap, resolveTelemetryTerminalKeep, resolveTmuxBin, resolveTmuxHistoryLimit } from "../config/yuiConfig.js";
-import { resolveTimeZone } from "../output/timePresentation.js";
 import { validateReviewConfig } from "../review/reviewConfig.js";
+import { validatePublicationReference } from "../task/publicationReference.js";
 import { validateTaskRecordReference } from "../task/taskRecordReference.js";
 export const CURRENT_CONFIG_SCHEMA_VERSION = 6;
 /** Current SQLite payload-family versions owned by this storage boundary. */
@@ -151,12 +151,10 @@ export function validateYuiConfig(config) {
             "resourcesGcMode",
             "resourcesGcAutoQuarantine",
             "review",
-            "leaderNextActionMode",
             "runtimeHealth",
             "controllerTaskConcurrency",
             "agentLaunchInactivityTimeoutSeconds",
             "deliveryTimeoutSeconds",
-            "leaderSemanticBudgetRuns",
             "resourcesQuarantineTtlHours",
             "tmuxBin",
             "tmuxHistoryLimit",
@@ -176,7 +174,6 @@ export function validateYuiConfig(config) {
         resolveTimeZone(config.timeZone);
         if (config.review !== undefined)
             validateReviewConfig(config.review);
-        resolveLeaderNextActionMode(config.leaderNextActionMode);
         resolveResourcesGcMode(config.resourcesGcMode);
         resolveResourcesGcAutoQuarantine(config.resourcesGcAutoQuarantine);
         resolveResourcesQuarantineTtlHours(config.resourcesQuarantineTtlHours);
@@ -184,7 +181,6 @@ export function validateYuiConfig(config) {
         resolveControllerTaskConcurrency(config.controllerTaskConcurrency);
         resolveAgentLaunchInactivityTimeoutSeconds(config.agentLaunchInactivityTimeoutSeconds);
         resolveDeliveryTimeoutSeconds(config.deliveryTimeoutSeconds);
-        resolveLeaderSemanticBudgetRuns(config.leaderSemanticBudgetRuns);
         resolveTmuxBin(config.tmuxBin);
         resolveTmuxHistoryLimit(config.tmuxHistoryLimit);
         resolveTelemetryEnabled(config.telemetryEnabled);
@@ -448,6 +444,8 @@ export function storedPublicationReference(value) {
         fields.push("targetBranch");
     if (reference.localCommit !== undefined)
         fields.push("localCommit");
+    if (reference.headCommit !== undefined)
+        fields.push("headCommit");
     if (reference.remoteCommit !== undefined)
         fields.push("remoteCommit");
     if (reference.evidence !== undefined)

package/dist/storage/upgrade/upgradeOrchestrator.js

@@ -4,16 +4,14 @@ import Database from "better-sqlite3";
 import { inspectAgentHostCompatibility, describeAgentHostUpgradeBlockers } from "../../runtime/agentHostCompatibility.js";
 import { RUNTIME_OBSERVATION_TASK_EVENT, createRuntimeObservation } from "../../runtime/runtimeObservation.js";
 import { RUNTIME_PROCESS_EXIT_TASK_EVENT, validateRuntimeProcessExitObservation } from "../../runtime/processExitObservation.js";
-import { validateAgentProfile } from "../../profile/agentProfile.js";
-import { validateRoleSessionSet } from "../../executor/agentExecutor.js";
-import { validateReviewRound } from "../../review/reviewRound.js";
-import { validateRun } from "../../agentRun/agentRun.js";
-import { validateDurableJob } from "../../job/durableJob.js";
-import { validateWorkItem } from "../../workItem/workItem.js";
 import { SqliteTaskStore } from "../sqliteStore.js";
 import { storageBackupRoot } from "../homeLayout.js";
 import { preflightUnifyHomeLayout } from "../migrations/unifyHomeLayout.js";
 import { preflightCollapseWorktreeLayout } from "../migrations/collapseWorktreeLayout.js";
+import { preflightNotificationOnlyWakes } from "../migrations/notificationOnlyWakes.js";
+import { preflightVerificationPolicy } from "../migrations/verificationPolicy.js";
+import { preflightCurrentInputContract } from "../migrations/currentInputContract.js";
+import { preflightCurrentRuntimeContract } from "../migrations/currentRuntimeContract.js";
 import { migrateSqliteSchema, storageMigrationPlan } from "../sqliteSchema.js";
 import { CURRENT_DATABASE_FILENAME, inspectStorageSchema } from "../storageSchema.js";
 import { CURRENT_STORAGE_VERSION, MIN_SUPPORTED_STORAGE_VERSION } from "../storageVersions.js";
@@ -153,7 +151,6 @@ export async function runStorageUpgrade(options) {
             database.close();
         }
         validateCurrentStore(options.home);
-        rmSync(join(options.home, "schema.json"), { force: true });
     }
     catch (error) {
         const restoration = migrationCommitted
@@ -206,29 +203,8 @@ export async function runStorageUpgrade(options) {
 function validateCurrentStore(home) {
     const store = new SqliteTaskStore(home);
     try {
-        store.getConfig();
-        for (const profile of store.listAgentProfiles())
-            validateAgentProfile(profile);
-        for (const sessions of store.listGlobalRoleSessionSets()) {
-            validateRoleSessionSet(sessions);
-        }
-        for (const owner of store.listSessionOwners()) {
-            if (owner.schemaVersion !== 2 || Object.hasOwn(owner, "launchId")) {
-                throw new Error("Session owner runtime identity is invalid.");
-            }
-        }
+        store.validateCurrentRecords();
         for (const taskId of store.listTasks().map(({ id }) => id)) {
-            for (const job of store.listDurableJobs(taskId))
-                validateDurableJob(job);
-            for (const item of store.listWorkItems(taskId))
-                validateWorkItem(item);
-            for (const round of store.listReviewRounds(taskId))
-                validateReviewRound(round);
-            for (const run of store.listRuns(taskId))
-                validateRun(run);
-            for (const sessions of store.listRoleSessionSets(taskId)) {
-                validateRoleSessionSet(sessions);
-            }
             for (const event of store.listEvents(taskId)) {
                 if (event.type === RUNTIME_OBSERVATION_TASK_EVENT) {
                     createRuntimeObservation(JSON.parse(event.payload.observation ?? ""));
@@ -345,16 +321,17 @@ function blocked(classification, stage, message, action) {
     };
 }
 /**
- * Run each path-relocating data migration's READ-ONLY preflight against the
+ * Run each data migration's registered READ-ONLY preflight against the
  * current (pre-upgrade) database and, when any finds a blocker, return a
  * `blocked` result the caller surfaces before touching the Controller or the
- * Home. Returns `null` when the plan carries no path-relocating data migration,
+ * Home. Returns `null` when the plan carries no registered readiness check,
  * or when every preflight is clear.
  *
- * Both the 18->19 unify and the 19->20 collapse migrations physically relocate
+ * Both the 23->24 unify and the 24->25 collapse migrations physically relocate
  * managed worktrees and share the same blocker shape (in-flight Job, conflicting
  * relocation target). When a Home is upgraded across both in one run, their
- * blockers are aggregated so the operator sees every readiness problem at once.
+ * blockers are aggregated so the operator sees their readiness problems together.
+ * Notification retirement separately rejects unsettled execution references.
  *
  * The database is opened read-only so the checks cannot mutate the authoritative
  * store, and the handle is always closed. An unexpected failure to evaluate a
@@ -364,8 +341,11 @@ function blocked(classification, stage, message, action) {
 function preflightMigrationBlockers(home, plan, classification) {
     const relocatesUnify = plan.some((step) => step.name === "unify-home-layout");
     const relocatesCollapse = plan.some((step) => step.name === "collapse-worktree-layout");
-    // Only meaningful when the plan actually includes a path-relocating migration.
-    if (!relocatesUnify && !relocatesCollapse)
+    const retiresRunWakes = plan.some((step) => step.name === "notification-only-wakes");
+    const changesVerification = plan.some(step => step.name === "advisory-and-verification-policy");
+    const changesInput = plan.some(step => step.name === "current-input-contract");
+    const retiresRuntime = plan.some(step => step.name === "current-verification-and-owner-contract");
+    if (!relocatesUnify && !relocatesCollapse && !retiresRunWakes && !changesVerification && !changesInput && !retiresRuntime)
         return null;
     let blockers;
     try {
@@ -379,6 +359,14 @@ function preflightMigrationBlockers(home, plan, classification) {
                 blockers.push(...preflightUnifyHomeLayout(database).blockers);
             if (relocatesCollapse)
                 blockers.push(...preflightCollapseWorktreeLayout(database).blockers);
+            if (retiresRunWakes)
+                preflightNotificationOnlyWakes(database);
+            if (changesVerification)
+                preflightVerificationPolicy(database);
+            if (changesInput)
+                preflightCurrentInputContract(database);
+            if (retiresRuntime)
+                preflightCurrentRuntimeContract(database);
         }
         finally {
             database.close();
@@ -386,8 +374,8 @@ function preflightMigrationBlockers(home, plan, classification) {
     }
     catch (error) {
         return {
-            ...blocked(classification, "in-flight", `The storage migration readiness check could not be completed: ${messageOf(error)}`, "Resolve the reported problem, confirm no Job is queued or running against a managed "
-                + "workspace, then rerun the upgrade.")
+            ...blocked(classification, "in-flight", `The storage migration readiness check could not be completed: ${messageOf(error)}`, "Resolve the named execution or resource boundary, preserving original input and results. "
+                + "Confirm the relevant Runs and Jobs are settled, then rerun the upgrade.")
         };
     }
     if (blockers.length === 0)

package/dist/task/archiveDiagnostics.js

@@ -122,6 +122,7 @@ export function taskArchiveDiagnostics(store, task) {
 export function renderArchiveDiagnostics(data) {
     return [
         `Archived: ${data.archived}; forced: ${data.forced}; cleanup finished: ${data.cleanupFinished}`,
+        `Retained references: ${data.retainedResources.length}; a finished cleanup attempt is not physical resource release evidence.`,
         ...data.warnings.map(w => `Warning [${w.resource}]: ${w.detail}`),
         ...data.retainedResources.map(r => `Retained [${r.resource}]: ${r.detail}${r.paths ? ` (${r.paths.join(", ")})` : ""}`)
     ].join("\n") + "\n";

package/dist/task/archivePreflight.js

@@ -0,0 +1,124 @@
+import { readArchiveDelivery } from "../repository/workspaceCleanupInspection.js";
+import { WorkspaceCleanupBlockedError } from "../repository/taskWorkspacePreparer.js";
+import { managedWorkspaceKey } from "../worktree/managedWorkspace.js";
+import { hasRuntimeLifecycleWork, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
+import { cleanupCheckFromError, renderCleanupCheck } from "../workspace/cleanupInspection.js";
+/** Semantic admission facts. Cleanup still has its own resource boundary. */
+export function archiveSettlementChecks(store, task) {
+    const checks = [];
+    const add = (resource, reason, detail, expected, observed, action) => checks.push({ resource, reason, status: "blocked", detail, expected, observed, sources: [resource], actions: [action] });
+    for (const input of store.listInputRequests(task.id).filter(i => i.status === "open")) {
+        add(`input:${task.id}/${input.id}`, "unresolved-input", "Open user input is not answered by archive.", "resolved input", input.status, `yui task input show ${task.id}/${input.id}`);
+    }
+    for (const item of store.listWorkItems(task.id).filter(i => i.status === "open")) {
+        add(`work-item:${task.id}/${item.id}`, "owner-unsettled", "WorkItem must be accepted or explicitly retired before archive.", ["accepted", "retired"], item.status, `yui task work show ${task.id}/${item.id}`);
+    }
+    for (const attempt of store.listIntegrationAttempts(task.id).filter(a => ["running", "blocked", "conflicted", "validating"].includes(a.status))) {
+        add(`integration-attempt:${task.id}/${attempt.id}`, "unresolved-integration", "Task has an unresolved Integration Attempt.", "terminal attempt", attempt.status, `yui task integration show ${task.id}/${attempt.id}`);
+    }
+    for (const job of store.listDurableJobs(task.id).filter(j => ["queued", "running"].includes(j.status) || (j.status === "unknown-needs-attention" && j.acknowledgedAt === undefined))) {
+        add(`job:${task.id}/${job.id}`, "active-durable-job", "Task has an active or unacknowledged DurableJob.", "settled job", job.status, `yui job get --task ${task.id} --job ${job.id}`);
+    }
+    return checks;
+}
+/** Unknown execution is never permission to remove workspaces, even after
+ * force admission. These facts are reloaded in the actual force cleanup path.
+ */
+export function archiveExecutionChecks(store, taskId) {
+    const checks = [];
+    const add = (resource, reason, detail, observed, action) => checks.push({ resource, reason, status: "unknown", detail, expected: "settled execution",
+        observed, sources: [resource], actions: [action] });
+    for (const run of store.listRuns(taskId).filter(r => r.status === "active")) {
+        add(`run:${taskId}/${run.id}`, "active-turn", "AgentRun remains active; archive is not stop evidence.", run.status, `yui task run show ${taskId}/${run.id}`);
+    }
+    for (const job of store.listDurableJobs(taskId).filter(j => ["queued", "running", "unknown-needs-attention"].includes(j.status))) {
+        add(`job:${taskId}/${job.id}`, "unresolved-execution", "DurableJob may still hold resources; acknowledgement is not physical exit evidence.", job.status, `yui job get --task ${taskId} --job ${job.id}`);
+    }
+    for (const role of store.listRoles(taskId)) {
+        const resource = `role:${taskId}/${role.name}`;
+        const action = `yui task role session inspect ${taskId} ${role.name}`;
+        const provider = store.getTaskRoleSessionSet(taskId, role.name)?.providerBinding;
+        const mailbox = store.getWorkMailbox({ kind: "role", taskId, roleName: role.name });
+        if (provider?.run != null && !["completed", "failed", "cancelled"].includes(provider.run.status)) {
+            add(resource, "unresolved-provider-input", "Original provider input outcome is unresolved; do not replay it.", { attemptId: provider.run.attemptId, status: provider.run.status }, action);
+        }
+        if (mailbox?.processing != null && (provider?.run == null
+            || !["completed", "failed", "cancelled"].includes(provider.run.status))) {
+            add(resource, "unresolved-mailbox", "Original mailbox claim has no proven terminal; archive does not acknowledge it.", { batchId: mailbox.processing.batchId }, action);
+        }
+        if (hasRuntimeLifecycleWork(store.getWorkMailbox(runtimeLifecycleTarget({ scope: "task", taskId, roleName: role.name })))) {
+            add(resource, "unresolved-runtime-lifecycle", "Role has unsettled runtime lifecycle work.", "pending", action);
+        }
+    }
+    return checks;
+}
+export async function inspectTaskArchive(coordinator, request) {
+    const { store, preparer, runtime } = coordinator;
+    const task = store.getTask(request.taskId);
+    if (task === null)
+        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))
+        .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 },
+        sources: [`task:${task.id}`, ...(p.publication === null ? [] : [`publication:${task.id}/${p.publication.id}`])],
+        actions: [`yui task remote-delivery ${task.id}`] }));
+    const execution = archiveExecutionChecks(store, task.id);
+    const runtimeResource = `runtime:${task.id}`;
+    if (runtime.assertTaskPhysicalResourcesReleased === undefined) {
+        execution.push(...cleanupCheckFromError(null, runtimeResource, [`task:${task.id}`], [`yui task role status ${task.id}`]));
+    }
+    else {
+        try {
+            await runtime.assertTaskPhysicalResourcesReleased(task.id);
+        }
+        catch (error) {
+            execution.push({ resource: runtimeResource, reason: "physical-resources-unreleased", status: "unknown",
+                detail: error instanceof WorkspaceCleanupBlockedError ? error.message
+                    : "Exact physical resource release is not established by the runtime inspection.",
+                expected: "proven physical absence",
+                observed: error instanceof WorkspaceCleanupBlockedError ? { reason: error.reason, resource: error.resource } : "unavailable",
+                sources: [`task:${task.id}`],
+                actions: [`yui task role status ${task.id}`, `yui session reconcile --report`] });
+        }
+    }
+    const resources = [];
+    for (const workspace of store.listManagedWorkspaces(task.id)) {
+        const disposition = workspace.owner.type === "work-item"
+            && store.getWorkItem(task.id, workspace.owner.workItemId)?.status === "retired" ? "abandoned" : request.disposition;
+        let checks;
+        try {
+            checks = await preparer.inspectWorkspaceCleanup(workspace, disposition, request.force);
+        }
+        catch (error) {
+            checks = cleanupCheckFromError(error, managedWorkspaceKey(workspace.owner), [managedWorkspaceKey(workspace.owner)], [`yui task show ${task.id}`]);
+        }
+        resources.push({ resource: managedWorkspaceKey(workspace.owner), owner: workspace.owner,
+            status: checks.some(c => c.status === "unknown") ? "unknown" : checks.length > 0 ? "blocked" : "checked",
+            checks });
+    }
+    const eligible = ["completed", "cancelled", "archived"].includes(task.status);
+    return { taskId: task.id, observedAt: new Date().toISOString(), disposition: request.disposition, force: request.force,
+        readOnly: true, authorizesCleanup: false,
+        archive: { status: task.status, eligible, alreadyArchived: task.status === "archived",
+            settlement, delivery: deliveryChecks, forceBypassesSettlement: request.force,
+            requiresIndependentAuthorization: true },
+        cleanup: { execution, resources },
+        note: "Current observations only. Execution reloads the checks. Force commits archive first and retains unsafe resources; a finished attempt does not prove resource release." };
+}
+export function renderTaskArchivePreflight(data) {
+    return [
+        `Archive preflight: ${data.taskId} (${data.disposition}${data.force ? ", force" : ""}); read-only, not authorization`,
+        `Task: ${data.archive.status}; terminal eligibility: ${data.archive.eligible}`,
+        ...data.archive.settlement.map(c => `Admission${data.force ? " (force preserves)" : ""}: ${renderCleanupCheck(c)}`),
+        ...data.archive.delivery.map(c => `Delivery${data.force || data.disposition === "abandoned" ? " (advisory for admission)" : ""}: ${renderCleanupCheck(c)}`),
+        ...data.cleanup.execution.map(c => `Cleanup: ${renderCleanupCheck(c)}`),
+        ...data.cleanup.resources.flatMap(r => [
+            `Workspace [${r.resource}]: ${r.status}`,
+            ...r.checks.map(c => `  ${renderCleanupCheck(c)}`)
+        ]),
+        data.note
+    ].join("\n") + "\n";
+}

package/dist/task/completionReadiness.js

@@ -17,18 +17,13 @@ export function pendingCompletionMessages(store, taskId) {
     const ids = new Set(refs.filter(ref => ref.type === "message" && ref.taskId === taskId).map(ref => ref.id));
     return operationalTaskRecords(store.listMessages(taskId), store.listEvents(taskId), "message")
         .filter(message => ids.has(message.id)
-        && (message.kind === "user" || message.kind === "operator") && message.wakePolicy !== "none");
+        && (message.kind === "user" || message.kind === "operator"));
 }
 const ACTIVE_JOB_STATUSES = new Set([
     "queued",
     "running",
     "unknown-needs-attention"
 ]);
-const UNRESOLVED_INTEGRATION_STATUSES = new Set([
-    "running",
-    "blocked",
-    "validating"
-]);
 const TERMINAL_REVIEW_STATUSES = new Set(["completed", "failed"]);
 const TERMINAL_LANE_STATUSES = new Set(["completed", "failed", "skipped"]);
 export function projectCompletionReadiness(facts) {
@@ -45,7 +40,7 @@ export function projectCompletionReadiness(facts) {
     }
     // A pending/running Task-final Review must be resumed or blocked first.
     for (const round of facts.reviewRounds) {
-        if ((round.scope ?? "work-item") !== "task")
+        if (round.scope !== "task")
             continue;
         if (round.status !== "pending" && round.status !== "running")
             continue;
@@ -103,11 +98,9 @@ export function projectCompletionReadiness(facts) {
             fix: `yui task integration start ${task.id} --work-item ${delivery.workItemId} --project ${delivery.projectId} --strategy <ff|cherry-pick|merge|manual>`
         });
     }
-    // Current delivery Attempts and any Attempt that may still be writing must
-    // settle. Historical blocked Attempts remain audit evidence only.
+    // Unsettled attempts must be explicitly resolved; terminal history remains
+    // evidence and is not a second delivery workflow.
     for (const integration of facts.integrations) {
-        if (!UNRESOLVED_INTEGRATION_STATUSES.has(integration.status))
-            continue;
         if (!integrationAttemptRequiresSettlement(integration))
             continue;
         blockers.push({
@@ -117,18 +110,6 @@ export function projectCompletionReadiness(facts) {
             fix: `yui task integration continue ${task.id}/${integration.id}`
         });
     }
-    // Legacy queue entries may still launch an Integration and therefore must
-    // settle even though ChangeSets are no longer delivery authority.
-    for (const entry of facts.integrationQueueEntries) {
-        if (entry.status === "committed" || entry.status === "superseded")
-            continue;
-        blockers.push({
-            code: "unsettled-integration-queue-entry",
-            ref: ref("integration-queue-entry", entry.id),
-            reason: `Integration queue entry ${entry.id} is ${entry.status}.`,
-            fix: `settle integration queue entry ${entry.id} (continue or supersede)`
-        });
-    }
     // Terminal child workspaces are cleanup advisories: Task completion is the
     // semantic delivery boundary, while archive remains the fail-closed resource
     // reclamation boundary. Missing/non-terminal ownership stays conservative.
@@ -198,7 +179,7 @@ function workspaceCompletionDisposition(facts, taskId, workspace) {
         }
         case "integration-attempt": {
             const integration = facts.integrations.find((entry) => entry.id === owner.integrationAttemptId);
-            if (integration !== undefined && UNRESOLVED_INTEGRATION_STATUSES.has(integration.status)) {
+            if (integration !== undefined && integrationAttemptRequiresSettlement(integration)) {
                 return null;
             }
             const value = {