@zq-silk/yui 2.2.0 → 2.4.0

package/dist/storage/sqliteSchema.js

@@ -2,6 +2,7 @@ import { createHash } from "node:crypto";
 import Database from "better-sqlite3";
 import { BASELINE_SCHEMA_SQL, SQLITE_SCHEMA_TABLES } from "./baselineSchema.js";
 import { migrateTaskMainWorkspaces } from "./upgrade/taskMainWorkspaceMigration.js";
+import { migrateProjectKnowledge } from "./upgrade/projectKnowledgeMigration.js";
 import { CURRENT_STORAGE_VERSION, MIN_SUPPORTED_STORAGE_VERSION, STORAGE_FORMAT, isMinorStorageUpgrade, isStorageVersion, storageVersionParts } from "./storageVersions.js";
 export { BASELINE_SCHEMA_SQL, SQLITE_SCHEMA_TABLES };
 export const TELEMETRY_KEEP_PER_RUN = 200;
@@ -34,6 +35,47 @@ const MINOR_UPGRADES = Object.freeze([{
         // New grants can carry source evidence. Valid historical Operator grants
         // remain unchanged; migration must not invent authorization provenance.
         sql: ""
+    }, {
+        fromVersion: "1.2",
+        toVersion: "1.3",
+        name: "selected-session-input",
+        introducedIn: "next",
+        sourceChecksum: CURRENT_SCHEMA_CHECKSUM,
+        targetChecksum: CURRENT_SCHEMA_CHECKSUM,
+        // Optional explicit Session fences apply only to new inputs. Preserve old
+        // Role-addressed messages; never infer a historical user's Session choice.
+        sql: ""
+    }, {
+        fromVersion: "1.3",
+        toVersion: "1.4",
+        name: "project-knowledge-applicability",
+        introducedIn: "next",
+        sourceChecksum: CURRENT_SCHEMA_CHECKSUM,
+        targetChecksum: CURRENT_SCHEMA_CHECKSUM,
+        sql: "",
+        dataMigration: "project-knowledge"
+    }, {
+        fromVersion: "1.4",
+        toVersion: "1.5",
+        name: "frozen-skill-packages",
+        introducedIn: "next",
+        sourceChecksum: CURRENT_SCHEMA_CHECKSUM,
+        targetChecksum: CURRENT_SCHEMA_CHECKSUM,
+        // Additive effective-launch/manifest package evidence. Historical envelopes
+        // and their digests remain unchanged: absence explicitly means entrypoint-only
+        // provenance, not an invitation to invent packages from today's source files.
+        // Existing Hosts retain their original inputs. Restoring such a Session fails
+        // with a bounded new-Session instruction; ordinary readers never backfill it.
+        sql: ""
+    }, {
+        fromVersion: "1.5",
+        toVersion: "1.6",
+        name: "runtime-cost-evidence",
+        introducedIn: "next",
+        sourceChecksum: CURRENT_SCHEMA_CHECKSUM,
+        targetChecksum: CURRENT_SCHEMA_CHECKSUM,
+        // Optional sourced monetary observations; historical missing costs stay unknown.
+        sql: ""
     }]);
 export function storageMinorUpgradePlan(from) {
     if (from === CURRENT_STORAGE_VERSION)
@@ -143,6 +185,8 @@ export function applySqliteMinorUpgrades(db, home, createdRoots = []) {
             if (step.dataMigration === "task-main-workspace") {
                 migrateTaskMainWorkspaces(db, home, createdRoots);
             }
+            if (step.dataMigration === "project-knowledge")
+                migrateProjectKnowledge(db);
             const { major, minor } = storageVersionParts(step.toVersion);
             db.prepare("UPDATE storage_schema SET major=?,minor=?,checksum=? WHERE id=1")
                 .run(major, minor, step.targetChecksum);

package/dist/storage/sqliteStore.js

@@ -66,6 +66,7 @@ import { initializeSqliteSchema, validateSqliteSchema, SqliteSchemaError, TELEME
 import { StorageSchemaError } from "./storageSchema.js";
 import { STORAGE_FORMAT } from "./storageVersions.js";
 import { queryTaskCatalog } from "./taskCatalog.js";
+import { queryTaskSearch } from "./taskSearch.js";
 import { CURRENT_CONFIG_SCHEMA_VERSION, CURRENT_WORK_MAILBOX_SCHEMA_VERSION, executionLaneActiveRunKey, executionLaneActiveRunKeyParts, isValidCapabilityGrantTransition, isValidReleaseWorkflowTransition, pendingWakeupProjection, StorageCancelledError, StorageConflictError, StorageRecordError, storedCapabilityGrant, storedPublicationReference, storedReleaseWorkflow, validateYuiConfig } from "./taskStore.js";
 /** Read the immutable Home identity without opening a writable Store connection. */
 export function readSqliteHomeIdentity(rootDir, databaseFilename = "yui.db") {
@@ -253,6 +254,55 @@ export class SqliteTaskStore {
     listEventsByType(taskId, types) {
         return this.#sortById(this.#listPayload("events", "task_id = ? AND type IN (SELECT value FROM json_each(?))", [taskId, JSON.stringify(types)]), event => event.id);
     }
+    readTaskUsageFacts(taskId) {
+        // Bounded source selection, not a scan/deserialization of Task history.
+        // Strip result bodies before they cross the SQLite boundary.
+        // Each event type uses idx_events_type_time (including its rowid tie
+        // breaker); only bounded prefixes are merged before JSON projection.
+        const limit = 2000;
+        const rows = this.#db.prepare(`SELECT json_set(payload, '$.payload.observation',
+      CASE WHEN type = 'runtime.observation' THEN
+        json_remove(json_extract(payload, '$.payload.observation'),
+          '$.payload.output', '$.payload.input', '$.payload.failure.lastOutput', '$.payload.summary')
+      ELSE NULL END) AS payload
+      FROM (
+        SELECT * FROM (
+          SELECT * FROM (
+            SELECT rowid AS source_order, type, occurred_at, payload FROM events
+            WHERE task_id = ? AND type = 'runtime.observation'
+            ORDER BY occurred_at DESC, rowid DESC LIMIT ?
+          )
+          UNION ALL
+          SELECT * FROM (
+            SELECT rowid AS source_order, type, occurred_at, payload FROM events
+            WHERE task_id = ? AND type = 'task.cancelled'
+            ORDER BY occurred_at DESC, rowid DESC LIMIT ?
+          )
+        ) ORDER BY occurred_at DESC, source_order DESC LIMIT ?
+      )`).all(taskId, limit + 1, taskId, limit + 1, limit + 1);
+        const events = rows.slice(0, limit).map(row => {
+            const event = JSON.parse(row.payload);
+            // json_set embeds normalized JSON as an object; the event wire contract
+            // stores the canonical observation in a string.
+            const observation = event.payload.observation;
+            return typeof observation === "object" && observation !== null
+                ? { ...event, payload: { ...event.payload, observation: JSON.stringify(observation) } } : event;
+        });
+        // The Task/Run primary key supplies a deterministic bounded ID window,
+        // not a "latest by time" claim. Beyond the cap coverage is partial.
+        const runs = this.#db.prepare(`SELECT json_object(
+      'id', turn_id, 'taskId', task_id, 'roleName', json_extract(payload, '$.roleName'),
+      'workItemId', json_extract(payload, '$.workItemId'),
+      'effective', json_object('agentId', json_extract(payload, '$.effective.agentId'),
+        'adapterId', json_extract(payload, '$.effective.adapterId'))) AS payload
+      FROM (
+        SELECT turn_id, task_id, payload FROM turns WHERE task_id = ?
+        ORDER BY turn_id DESC LIMIT ?
+      )`)
+            .all(taskId, limit + 1);
+        return { events, runs: runs.slice(0, limit).map(row => JSON.parse(row.payload)),
+            complete: rows.length <= limit && runs.length <= limit };
+    }
     /** Delivery needs original workspace bases, never complete Run reports. */
     listTaskRunWorkspaceBases(taskId) {
         return this.#db.prepare(`SELECT json_object(
@@ -978,6 +1028,9 @@ export class SqliteTaskStore {
     queryTaskCatalog(query) {
         return queryTaskCatalog(this.#db, query);
     }
+    queryTaskSearch(query) {
+        return queryTaskSearch(this.#db, query);
+    }
     listTaskChoices() {
         const rows = this.#db.prepare(`SELECT c.task_id AS id, c.status,
       json_extract(r.payload, '$.title') AS title

package/dist/storage/storageVersions.js

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

package/dist/storage/storeRpc.js

@@ -53,8 +53,10 @@ const READ_ONLY_STORE_METHODS = new Set([
     "readNextActionFacts",
     "readCompletionReadinessFacts",
     "queryContextRecords",
+    "queryTaskSearch",
     "latestEventSequence",
     "listEventsByType",
+    "readTaskUsageFacts",
     "listTaskRunWorkspaceBases",
     "contextInputReferences",
     "listActiveRuns",

package/dist/storage/taskSearch.js

@@ -0,0 +1,35 @@
+export const TASK_SEARCH_KINDS = ["brief", "message", "decision", "result", "completion"];
+/** A read-only view of authoritative JSON, not a persisted index. Apply Task
+ * scope before body matching and return only page-sized snippets/identities.
+ * No derived state needs rebuilding when a source changes or is removed. */
+export function queryTaskSearch(db, input) {
+    if (!Number.isSafeInteger(input.limit) || input.limit < 1 || input.limit > 101) {
+        throw new Error("Task search query exceeds its bounded contract.");
+    }
+    const branches = [
+        `SELECT task_id AS taskId, 'brief' AS kind, 'task-brief' AS store, task_id AS refId,
+      j.fullkey AS field, j.value AS body FROM task_records, json_tree(brief) j
+      WHERE j.type = 'text' AND (j.key IN ('objective','technicalApproach','currentFocus','leaderSummary')
+        OR j.path = '$.boundaries')`,
+        `SELECT task_id, 'message', 'task-message', message_id, '$.body', json_extract(payload, '$.body') FROM messages`,
+        `SELECT task_id, 'decision', 'task-decision', decision_id, j.fullkey, j.value
+      FROM decisions, json_each(payload) j WHERE j.key IN ('title','rationale','supersededReason') AND j.type = 'text'`,
+        `SELECT task_id, 'result', 'run', turn_id, '$.result.output', json_extract(payload, '$.result.output') FROM turns`,
+        `SELECT task_id, 'completion', 'task', task_id, '$.completionSummary',
+      json_extract(payload, '$.completionSummary') FROM task_records`
+    ];
+    const params = {
+        query: input.query, taskId: input.taskId ?? null, kind: input.kind ?? null, limit: input.limit,
+        afterTask: input.after?.taskId ?? "", afterKind: input.after?.kind ?? "",
+        afterRef: input.after?.refId ?? "", afterField: input.after?.field ?? ""
+    };
+    // SQLite lower() folds ASCII only; other Unicode is matched literally.
+    // Positions and substr use Unicode code points, not UTF-16 units or bytes.
+    return db.prepare(`WITH sources AS (${branches.join(" UNION ALL ")}),
+    matches AS (SELECT *, instr(lower(body), lower(@query)) AS hit FROM sources
+      WHERE (@taskId IS NULL OR taskId = @taskId) AND (@kind IS NULL OR kind = @kind)
+        AND (taskId, kind, refId, field) > (@afterTask, @afterKind, @afterRef, @afterField))
+    SELECT taskId, kind, store, refId, field, max(0, hit - 81) AS offset,
+      substr(body, max(1, hit - 80), 320) AS snippet
+    FROM matches WHERE hit > 0 ORDER BY taskId, kind, refId, field LIMIT @limit`).all(params);
+}

package/dist/storage/upgrade/projectKnowledgeMigration.js

@@ -0,0 +1,52 @@
+import { createHash } from "node:crypto";
+import { knowledgeProposalFingerprint, validateProject } from "../../repository/project.js";
+/**
+ * The declared 1.3 -> 1.4 payload transition. Never used by ordinary readers.
+ * Version 1 is the observed pre-migration head, not a claim that no earlier
+ * edits happened. Existing proposals and frozen Context snapshots retain their
+ * original identities, decisions and evidence; snapshots are never rewritten.
+ */
+export function migrateProjectKnowledge(db) {
+    const rows = db.prepare("SELECT id, payload FROM projects ORDER BY id").all();
+    for (const row of rows) {
+        const project = JSON.parse(row.payload);
+        if (project.id !== row.id || !Array.isArray(project.knowledge) || !Array.isArray(project.knowledgeProposals)) {
+            throw new Error(`Invalid 1.3 Project knowledge container: ${row.id}.`);
+        }
+        const knowledgeProposals = project.knowledgeProposals.map(proposal => {
+            if (proposal.schemaVersion !== 1)
+                throw new Error(`Invalid 1.3 Knowledge proposal: ${proposal.id}.`);
+            const sourceKey = [proposal.projectId, proposal.source.taskId, proposal.source.decisionId ?? "",
+                proposal.source.milestoneId ?? "", proposal.source.commitSha ?? ""].join("|");
+            const previousFingerprint = createHash("sha256")
+                .update(`${sourceKey}\u0000${proposal.title}\u0000${proposal.body}`).digest("hex");
+            if (proposal.fingerprint !== previousFingerprint) {
+                throw new Error(`Invalid 1.3 Knowledge fingerprint: ${proposal.id}.`);
+            }
+            return { ...proposal, schemaVersion: 2, fingerprint: knowledgeProposalFingerprint(proposal) };
+        });
+        const knowledge = project.knowledge.map(entry => {
+            if (entry.schemaVersion !== 1 || "version" in entry || "history" in entry
+                || "scope" in entry || "expiresWhen" in entry) {
+                throw new Error(`Invalid 1.3 Project knowledge: ${entry.id}.`);
+            }
+            const proposal = knowledgeProposals.find(candidate => candidate.id === entry.provenance?.proposalId);
+            const backed = proposal !== undefined && proposal.status === "accepted"
+                && proposal.knowledgeId === entry.id && proposal.title === entry.title && proposal.body === entry.body
+                && proposal.source.taskId === entry.provenance?.taskId
+                && proposal.source.decisionId === entry.provenance?.decisionId
+                && proposal.source.milestoneId === entry.provenance?.milestoneId
+                && proposal.source.commitSha === entry.provenance?.commitSha;
+            return {
+                ...entry, schemaVersion: 2, version: 1, history: [],
+                ...(backed ? {
+                    ...(proposal.scope === undefined ? {} : { scope: proposal.scope }),
+                    ...(proposal.expiresWhen === undefined ? {} : { expiresWhen: proposal.expiresWhen }),
+                    provenance: { ...entry.provenance, fingerprint: proposal.fingerprint }
+                } : {})
+            };
+        });
+        const migrated = validateProject({ ...project, knowledge, knowledgeProposals });
+        db.prepare("UPDATE projects SET payload=? WHERE id=?").run(JSON.stringify(migrated), row.id);
+    }
+}

package/dist/task/archiveDiagnostics.js

@@ -30,7 +30,8 @@ export function archiveRetainedResources(store, task) {
         resources.push({ resource: `run:${task.id}/${run.id}`,
             detail: `AgentRun remains active (${run.roleName}); archive is not stop evidence.` });
     }
-    for (const job of store.listDurableJobs(task.id).filter(j => ["queued", "running", "unknown-needs-attention"].includes(j.status))) {
+    for (const job of store.listDurableJobs(task.id).filter(j => ["queued", "running"].includes(j.status)
+        || (j.status === "unknown-needs-attention" && j.acknowledgedAt === undefined))) {
         resources.push({ resource: `job:${task.id}/${job.id}`, detail: `DurableJob remains ${job.status}.` });
     }
     for (const attempt of store.listIntegrationAttempts(task.id).filter(a => ["running", "blocked", "conflicted", "validating"].includes(a.status))) {
@@ -110,20 +111,37 @@ export function taskArchiveDiagnostics(store, task) {
             ...(event.payload.paths === undefined ? {} : { paths: JSON.parse(event.payload.paths) }) });
     }
     const forced = archive?.payload.force === "true";
-    const cleanupFinished = !forced || cleanup.some(e => e.payload.status === "finished");
-    if (forced && !cleanupFinished)
+    const last = cleanup.at(-1);
+    const cleanupFinished = last?.payload.status === "finished"
+        || (cleanup.length === 0 && archive !== undefined && archive.payload.cleanup !== "pending" && !forced);
+    if (task.status === "archived" && !cleanupFinished)
         warnings.push({ resource: `task:${task.id}`,
             detail: "Archive committed; cleanup has not finished. Retained references require explicit inspection; archive retry does not replay cleanup." });
+    const retainedResources = archiveRetainedResources(store, task);
+    const passStart = cleanup.map(e => e.payload.resource === `cleanup-pass:${task.id}` && e.payload.status === "started").lastIndexOf(true);
+    const lastPass = cleanup.slice(passStart >= 0 ? passStart
+        : cleanup.map(e => e.payload.status).lastIndexOf("finished", cleanup.length - 2) + 1);
+    // Derived from current references AND a completed physical cleanup attempt;
+    // neither archive nor an empty workspace list alone establishes release.
+    const allResourcesReleased = task.status === "archived" && cleanupFinished
+        && retainedResources.length === 0
+        && lastPass.some(e => e.payload.resource === `runtime:${task.id}` && e.payload.status === "released")
+        && !lastPass.some(e => e.payload.status === "retained");
     return { archived: task.status === "archived", forced,
         disposition: archive?.payload.workspaceDisposition ?? null,
-        cleanupFinished, warnings, retainedResources: archiveRetainedResources(store, task),
-        cleanupEvents: cleanup };
+        cleanupFinished, allResourcesReleased,
+        warnings: warnings.slice(-32), retainedResources: retainedResources.slice(0, 32),
+        counts: { warnings: warnings.length, retainedResources: retainedResources.length, cleanupEvents: cleanup.length },
+        cleanupEvents: cleanup.slice(-32),
+        actions: [`yui task archive-preflight ${task.id} --${archive?.payload.workspaceDisposition === "abandoned" ? "abandon" : "integrated"}`,
+            `yui task archive-cleanup ${task.id}`, `yui task event list ${task.id}`] };
 }
 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.`,
+        `Archived: ${data.archived}; forced: ${data.forced}; cleanup finished: ${data.cleanupFinished}; all resources released: ${data.allResourcesReleased}`,
+        `Retained references: ${data.counts.retainedResources}; 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(", ")})` : ""}`)
+        ...data.retainedResources.map(r => `Retained [${r.resource}]: ${r.detail}${r.paths ? ` (${r.paths.join(", ")})` : ""}`),
+        `Inspect/retry: ${data.actions.join("; ")}`
     ].join("\n") + "\n";
 }

package/dist/task/archivePreflight.js

@@ -3,6 +3,7 @@ import { WorkspaceCleanupBlockedError } from "../repository/taskWorkspacePrepare
 import { managedWorkspaceKey } from "../worktree/managedWorkspace.js";
 import { hasRuntimeLifecycleWork, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
 import { cleanupCheckFromError, renderCleanupCheck } from "../workspace/cleanupInspection.js";
+import { jobCleanupBlocker } from "../job/jobCleanupInspection.js";
 /** Semantic admission facts. Cleanup still has its own resource boundary. */
 export function archiveSettlementChecks(store, task) {
     const checks = [];
@@ -13,6 +14,9 @@ export function archiveSettlementChecks(store, task) {
     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 round of store.listReviewRounds(task.id).filter(r => ["pending", "running"].includes(r.status))) {
+        add(`review-round:${task.id}/${round.id}`, "owner-unsettled", "ReviewRound must be terminal before ordinary archive.", ["completed", "failed"], round.status, `yui task context list ${task.id} --store review-round`);
+    }
     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}`);
     }
@@ -24,15 +28,17 @@ export function archiveSettlementChecks(store, task) {
 /** 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) {
+export function archiveExecutionChecks(store, taskId, home, phase = "before-removal") {
     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 job of store.listDurableJobs(taskId)) {
+        const blocker = jobCleanupBlocker(job, home, phase);
+        if (blocker !== undefined)
+            add(`job:${taskId}/${job.id}`, "unresolved-execution", blocker, job.status, `yui job get --task ${taskId} --job ${job.id}`);
     }
     for (const role of store.listRoles(taskId)) {
         const resource = `role:${taskId}/${role.name}`;
@@ -65,7 +71,7 @@ export async function inspectTaskArchive(coordinator, request) {
         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 execution = archiveExecutionChecks(store, task.id, preparer.home);
     const runtimeResource = `runtime:${task.id}`;
     if (runtime.assertTaskPhysicalResourcesReleased === undefined) {
         execution.push(...cleanupCheckFromError(null, runtimeResource, [`task:${task.id}`], [`yui task role status ${task.id}`]));
@@ -100,25 +106,36 @@ export async function inspectTaskArchive(coordinator, request) {
             checks });
     }
     const eligible = ["completed", "cancelled", "archived"].includes(task.status);
+    const limit = 32;
+    const boundedExecution = execution.slice(0, limit);
     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,
+            settlement: settlement.slice(0, limit), delivery: deliveryChecks.slice(0, limit), forceBypassesSettlement: request.force,
+            execution: boundedExecution, physicalRetentionBlocksArchive: false,
             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." };
+        cleanup: { execution: boundedExecution, resources: resources.slice(0, limit).map(resource => ({
+                ...resource, checkCount: resource.checks.length, checks: resource.checks.slice(0, limit)
+            })) },
+        counts: { settlement: settlement.length, delivery: deliveryChecks.length,
+            execution: execution.length, resources: resources.length },
+        actions: [`yui task context list ${task.id} --store managed-workspace`,
+            `yui task remote-delivery ${task.id}`, `yui task event list ${task.id}`],
+        note: "Current observations only. Ordinary archive requires settled business, exact delivery and stopped execution; safe physical retention is separate. Cleanup reloads these checks after archive commits. 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}`,
+        `Checks/resources (showing at most 32 per list): settlement=${data.counts.settlement}; delivery=${data.counts.delivery}; execution=${data.counts.execution}; resources=${data.counts.resources}`,
         ...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}`,
+            `Workspace [${r.resource}]: ${r.status}; checks=${r.checkCount}`,
             ...r.checks.map(c => `  ${renderCleanupCheck(c)}`)
         ]),
-        data.note
+        data.note,
+        `Inspect full evidence: ${data.actions.join("; ")}`
     ].join("\n") + "\n";
 }

package/dist/task/leaderArchive.js

@@ -5,6 +5,7 @@ import { archiveExecutionChecks, archiveSettlementChecks } from "./archivePrefli
 import { admitLeaderArchive, assertLeaderArchiveAdmission } from "./leaderArchiveAuthority.js";
 import { assertTaskRemoteDeliveryIntegrated, createTaskRemoteDeliveryProof } from "./remoteDeliveryService.js";
 import { selectNewTaskRoleSession } from "../executor/agentExecutor.js";
+import { taskArchiveDiagnostics } from "./archiveDiagnostics.js";
 /** A single foreground Controller operation survives stopping its requesting
  * Session. It has no retry worker: uncertain receipts are inspected, not
  * replayed. All existing settlement, delivery and cleanup checks remain. */
@@ -28,7 +29,7 @@ export async function archiveLeaderTask(store, coordinator, taskId, environment,
     // Only the requesting no-Run Leader may be stopped as part of this action.
     // Another Run, Job, unknown input, or then handoff is not archive authority.
     const ownResources = `role:${taskId}/leader`;
-    const execution = archiveExecutionChecks(store, taskId).filter(check => !(check.resource === ownResources
+    const execution = archiveExecutionChecks(store, taskId, coordinator.preparer.home, "before-role-stop").filter(check => !(check.resource === ownResources
         && ownInput?.runId === undefined && ownInput?.status === "accepted"
         && ["unresolved-provider-input", "unresolved-mailbox"].includes(check.reason)));
     if (execution.length)
@@ -39,7 +40,7 @@ export async function archiveLeaderTask(store, coordinator, taskId, environment,
     }
     let candidate = null;
     const workspace = store.getTaskWorkspace(taskId);
-    if (task.projectBindings.length && workspace) {
+    if (task.status === "cancelled" && task.projectBindings.length && workspace) {
         const snapshot = await coordinator.preparer.snapshotDirectTaskMain(workspace, task.projectBindings.map(binding => binding.projectId));
         candidate = { schemaVersion: 1, projects: snapshot.projects.map(project => ({
                 projectId: project.projectId, commit: project.headCommit
@@ -47,14 +48,6 @@ export async function archiveLeaderTask(store, coordinator, taskId, environment,
     }
     const proof = createTaskRemoteDeliveryProof(store, task, candidate);
     assertTaskRemoteDeliveryIntegrated(proof.delivery);
-    for (const owned of store.listManagedWorkspaces(taskId)) {
-        const disposition = owned.owner.type === "work-item"
-            && store.getWorkItem(taskId, owned.owner.workItemId)?.status === "retired" ? "abandoned" : "integrated";
-        const checks = await coordinator.preparer.inspectWorkspaceCleanup(owned, disposition);
-        if (checks.some(check => !(owned.owner.type === "task" && check.reason === "git-worktree-registrations"))) {
-            throw new Error(`Archive workspace is not clean/removable: ${JSON.stringify(checks)}`);
-        }
-    }
     // Reauthenticate after asynchronous inspection, before the first effect.
     admitLeaderArchive(store, taskId, environment, request.sourceMessage, request.purpose);
     assertLeaderArchiveAdmission(store, taskId, admission);
@@ -94,14 +87,15 @@ export async function archiveLeaderTask(store, coordinator, taskId, environment,
             // the first verified stop already released its physical owner records.
             tx.saveTaskRoleSessionSet(selectNewTaskRoleSession(stopped, stopped.activeAgentId, new Date()));
         });
-        const cleanup = await coordinator.cleanupTaskForArchive(taskId, "integrated");
-        if (cleanup.status !== "removed")
-            throw new Error(cleanup.error ?? `Archive cleanup ${cleanup.status}.`);
+        await coordinator.prepareTaskForArchive(taskId);
         runTaskCommand(["archive", taskId, "--integrated"], store, {
-            environment, archiveLeaderAdmission: admission, archiveRemoteDeliveryProof: proof
+            environment, yuiHome: coordinator.preparer.home,
+            archiveLeaderAdmission: admission, archiveRemoteDeliveryProof: proof
         });
+        await coordinator.cleanupArchivedTask(taskId, "integrated");
         record("task.leader-archive-result", { status: "archived" });
-        return { taskId, requestId: request.requestId, status: "archived" };
+        return { taskId, requestId: request.requestId, status: "archived",
+            ...taskArchiveDiagnostics(store, store.getTask(taskId)) };
     }
     catch (error) {
         record("task.leader-archive-result", { status: store.getTask(taskId)?.status === "archived" ? "archived" : "failed",

package/dist/task/ordinaryArchive.js

@@ -0,0 +1,42 @@
+import { runTaskCommand, validateTaskArchiveRequest } from "../commands/taskCommands.js";
+import { taskArchiveDiagnostics } from "./archiveDiagnostics.js";
+import { assertTaskRemoteDeliveryIntegrated, createTaskRemoteDeliveryProof } from "./remoteDeliveryService.js";
+/** Read-only admission shared by CLI and Web. Cancelled Project Tasks need a
+ * workspace snapshot before delivery can be proved; that later preparation
+ * may have effects and must not be reported as a known non-submission. */
+export function validateOrdinaryTaskArchive(store, taskId, options) {
+    validateTaskArchiveRequest([taskId, "--integrated"], store, options);
+    const task = store.getTask(taskId);
+    if (task.status !== "archived" && (task.status === "completed" || !task.projectBindings.length)) {
+        assertTaskRemoteDeliveryIntegrated(createTaskRemoteDeliveryProof(store, task).delivery);
+    }
+}
+/** The local user's ordinary archive path. No force, abandonment, source
+ * impersonation, or private cleanup policy is accepted by this port. */
+export async function archiveOrdinaryTask(coordinator, taskId, options) {
+    const { store, preparer } = coordinator;
+    const args = [taskId, "--integrated"];
+    validateOrdinaryTaskArchive(store, taskId, options);
+    const task = store.getTask(taskId);
+    if (task.status !== "archived") {
+        let candidate = null;
+        if (task.status === "cancelled" && task.projectBindings.length) {
+            await preparer.prepareTaskWorkspace(taskId);
+            const workspace = store.getTaskWorkspace(taskId);
+            if (!workspace || workspace.owner.type !== "task" || workspace.owner.taskId !== taskId) {
+                throw new Error(`Task has no authoritative main workspace: ${taskId}.`);
+            }
+            const snapshot = await preparer.snapshotDirectTaskMain(workspace, task.projectBindings.map(binding => binding.projectId));
+            candidate = { schemaVersion: 1, projects: snapshot.projects.map(project => ({
+                    projectId: project.projectId, commit: project.headCommit
+                })) };
+        }
+        const proof = createTaskRemoteDeliveryProof(store, task, candidate);
+        assertTaskRemoteDeliveryIntegrated(proof.delivery);
+        await coordinator.prepareTaskForArchive(taskId);
+        runTaskCommand(["archive", ...args], store, { ...options, archiveRemoteDeliveryProof: proof });
+        await coordinator.cleanupArchivedTask(taskId, "integrated");
+    }
+    const current = store.getTask(taskId);
+    return { task: current, ...taskArchiveDiagnostics(store, current) };
+}

package/dist/tmux/tmuxManager.js

@@ -263,16 +263,16 @@ export class TmuxManager {
             // with terminal output that predates this attach.
             this.run(["set-option", "-t", clientSession, "status", "off"]);
             this.run(["set-option", "-t", clientSession, "mouse", "on"]);
+            // Arm automatic release only after a client has attached. Enabling it
+            // on the initially detached session would destroy it before attach.
+            // A client-detached hook is unsafe: after explicit session destruction,
+            // tmux can resolve that notification in a surviving session's context
+            // and execute its hook, cascading into unrelated viewer/writer leases.
             this.run([
-                "set-hook", "-t", clientSession, "client-detached",
-                `kill-session -t ${clientSession}`
+                "set-hook", "-t", clientSession, "client-attached",
+                `set-option -t ${clientSession} destroy-unattached on`
+                    + (attachedNotice === undefined ? "" : ` ; display-message -d 10000 ${tmuxWord(attachedNotice)}`)
             ]);
-            if (attachedNotice !== undefined) {
-                this.run([
-                    "set-hook", "-t", clientSession, "client-attached",
-                    `display-message -d 10000 ${tmuxWord(attachedNotice)}`
-                ]);
-            }
             return clientSession;
         }
         catch (error) {

package/dist/web/assets/assetManifest.js

@@ -1,63 +1,23 @@
+// Every asset the dashboard serves, keyed by URL path. Stylesheets come from
+// the ordered styles registry, client modules from the client registry, and
+// fonts and xterm from their packages; the shell links them in this order.
 import { readFileSync } from "node:fs";
 import { createRequire } from "node:module";
-import { API_SCRIPT } from "./client/api.js";
-import { APP_SCRIPT } from "./client/app.js";
-import { COMPONENTS_SCRIPT } from "./client/components.js";
-import { DETAIL_SCRIPT } from "./client/detail.js";
-import { DOCK_SCRIPT } from "./client/dock.js";
-import { DOM_SCRIPT } from "./client/dom.js";
-import { EVIDENCE_SCRIPT } from "./client/evidence.js";
-import { FORMAT_SCRIPT } from "./client/format.js";
-import { FORMS_SCRIPT } from "./client/forms.js";
-import { I18N_SCRIPT } from "./client/i18n.js";
-import { MARKDOWN_SCRIPT } from "./client/markdown.js";
-import { OVERVIEW_SCRIPT } from "./client/overview.js";
-import { RECORDS_SCRIPT } from "./client/records.js";
-import { SECTIONS_SCRIPT } from "./client/sections.js";
-import { SIDEBAR_SCRIPT } from "./client/sidebar.js";
-import { THEME_SCRIPT } from "./client/theme.js";
-import { DASHBOARD_HTML } from "./shell.js";
-import { FONT_FACE_STYLES } from "./fonts.js";
+import { APP_SCRIPT, CLIENT_MODULES } from "./client/index.js";
 import { FONT_WOFF2_BASE64 } from "./fontData.js";
-import { BASE_STYLES } from "./styles/base.js";
-import { COMPONENT_STYLES } from "./styles/components.js";
-import { LAYOUT_STYLES } from "./styles/layout.js";
-import { MARKDOWN_STYLES } from "./styles/markdown.js";
-import { RESPONSIVE_STYLES } from "./styles/responsive.js";
-import { TOKEN_STYLES } from "./styles/tokens.js";
-import { VIEW_STYLES } from "./styles/views.js";
+import { DASHBOARD_HTML } from "./shell/index.js";
+import { STYLESHEETS } from "./styles/index.js";
 const require = createRequire(import.meta.url);
 const CSS = "text/css; charset=utf-8";
 const JS = "text/javascript; charset=utf-8";
 export const WEB_ASSETS = Object.freeze({
-    "/assets/css/fonts.css": { contentType: CSS, body: FONT_FACE_STYLES },
-    "/assets/css/tokens.css": { contentType: CSS, body: TOKEN_STYLES },
-    "/assets/css/base.css": { contentType: CSS, body: BASE_STYLES },
-    "/assets/css/layout.css": { contentType: CSS, body: LAYOUT_STYLES },
-    "/assets/css/components.css": { contentType: CSS, body: COMPONENT_STYLES },
-    "/assets/css/views.css": { contentType: CSS, body: VIEW_STYLES },
-    "/assets/css/markdown.css": { contentType: CSS, body: MARKDOWN_STYLES },
-    "/assets/css/responsive.css": { contentType: CSS, body: RESPONSIVE_STYLES },
-    "/assets/js/dom.js": { contentType: JS, body: DOM_SCRIPT },
-    "/assets/js/format.js": { contentType: JS, body: FORMAT_SCRIPT },
-    "/assets/js/i18n.js": { contentType: JS, body: I18N_SCRIPT },
-    "/assets/js/markdown.js": { contentType: JS, body: MARKDOWN_SCRIPT },
-    "/assets/js/theme.js": { contentType: JS, body: THEME_SCRIPT },
-    "/assets/js/api.js": { contentType: JS, body: API_SCRIPT },
-    "/assets/js/components.js": { contentType: JS, body: COMPONENTS_SCRIPT },
-    "/assets/js/records.js": { contentType: JS, body: RECORDS_SCRIPT },
-    "/assets/js/forms.js": { contentType: JS, body: FORMS_SCRIPT },
-    "/assets/js/evidence.js": { contentType: JS, body: EVIDENCE_SCRIPT },
-    "/assets/js/sidebar.js": { contentType: JS, body: SIDEBAR_SCRIPT },
-    "/assets/js/overview.js": { contentType: JS, body: OVERVIEW_SCRIPT },
-    "/assets/js/sections.js": { contentType: JS, body: SECTIONS_SCRIPT },
-    "/assets/js/detail.js": { contentType: JS, body: DETAIL_SCRIPT },
-    "/assets/js/dock.js": { contentType: JS, body: DOCK_SCRIPT },
+    ...Object.fromEntries(STYLESHEETS.map(({ name, body }) => [`/assets/css/${name}.css`, { contentType: CSS, body }])),
+    ...Object.fromEntries(Object.entries(CLIENT_MODULES).map(([path, body]) => [`/assets/js/${path}.js`, { contentType: JS, body }])),
     "/assets/app.js": { contentType: JS, body: APP_SCRIPT },
     ...fontAssets(),
-    "/assets/vendor/xterm.mjs": vendorAsset("@xterm/xterm/lib/xterm.mjs", "text/javascript; charset=utf-8"),
-    "/assets/vendor/addon-fit.mjs": vendorAsset("@xterm/addon-fit/lib/addon-fit.mjs", "text/javascript; charset=utf-8"),
-    "/assets/vendor/xterm.css": vendorAsset("@xterm/xterm/css/xterm.css", "text/css; charset=utf-8")
+    "/assets/vendor/xterm.mjs": vendorAsset("@xterm/xterm/lib/xterm.mjs", JS),
+    "/assets/vendor/addon-fit.mjs": vendorAsset("@xterm/addon-fit/lib/addon-fit.mjs", JS),
+    "/assets/vendor/xterm.css": vendorAsset("@xterm/xterm/css/xterm.css", CSS)
 });
 export { DASHBOARD_HTML };
 export function findWebAsset(pathname) {