@zq-silk/yui 2.3.0 → 2.4.0

package/dist/runtime/taskUsageMetrics.js

@@ -1,3 +1,4 @@
+import { projectTaskCosts } from "./taskCostMetrics.js";
 import { builtinDriverIdForAdapter } from "./builtinAgentDrivers.js";
 import { isRuntimeTokenEvidence, runtimeObservationFromTaskEvent } from "./runtimeObservation.js";
 import { projectSessionTokenObservations, unobservedSessionTokenMetrics } from "./sessionTokenMetrics.js";
@@ -39,7 +40,7 @@ export function projectTaskUsageMetrics(input) {
             continue;
         const resource = resourceKey(identity);
         const owners = resourceOwners.get(resource) ?? new Set();
-        owners.add(identity.roleName);
+        owners.add(JSON.stringify([identity.roleName, identity.agentId]));
         resourceOwners.set(resource, owners);
     }
     const sessions = [...buckets.values()]
@@ -107,14 +108,21 @@ export function projectTaskUsageMetrics(input) {
             }];
     });
     const reasons = [];
+    const costReasons = [];
     if (scoped.some((observation) => sessionIdentity(observation) === null))
         reasons.push("session-identity-missing");
+    if (reasons.length > 0)
+        costReasons.push("session-identity-missing");
     for (const run of runs.values()) {
         if (input.workItemId !== undefined && run.workItemId !== input.workItemId)
             continue;
         if (!observations.some((observation) => exactRun(observation, runs)?.id === run.id
             && usageAuthority(observation) && isRuntimeTokenEvidence(observation)))
             reasons.push("run-usage-unobserved");
+        if (!observations.some((observation) => exactRun(observation, runs)?.id === run.id
+            && usageAuthority(observation) && !child(observation) && observation.payload.cost !== undefined)) {
+            costReasons.push("run-cost-unobserved");
+        }
     }
     const tokenValues = sessions.flatMap(({ tokens }) => tokens.value === null ? [] : [tokens.value]);
     const sum = safeSum(tokenValues);
@@ -149,6 +157,7 @@ export function projectTaskUsageMetrics(input) {
         elapsedSeconds: input.workItemId === undefined
             ? taskElapsed(input.task, events, now) : metric(null, ["work-item-lifecycle-not-task-elapsed"]),
         executionSeconds: executionDuration(scoped, now),
+        costs: projectTaskCosts(observations, inScope, input.workItemId !== undefined, costReasons),
         coverage: {
             basis: "task-fenced-observations",
             observedSessions: sessions.length,
@@ -199,7 +208,7 @@ function identityKey(identity) {
     return JSON.stringify([identity.taskId, identity.roleName, identity.agentId, identity.driverId, identity.nativeSessionId]);
 }
 function resourceKey(identity) {
-    return JSON.stringify([identity.agentId, identity.driverId, identity.nativeSessionId]);
+    return JSON.stringify([identity.driverId, identity.nativeSessionId]);
 }
 function child({ fence }) {
     return fence.continuationId !== undefined || fence.parentContinuationId !== undefined;

package/dist/runtime/taskUsageQuery.js

@@ -0,0 +1,38 @@
+import { projectTaskUsageMetrics } from "./taskUsageMetrics.js";
+export const TASK_USAGE_FACT_LIMIT = 2000;
+/** Same bounded, read-only fact query for the Task CLI and Web. */
+export function readTaskUsage(store, taskId, options = {}) {
+    const task = store.getTask(taskId);
+    if (task === null)
+        return null;
+    const facts = store.readTaskUsageFacts(taskId);
+    return pageTaskUsage(projectTaskUsageMetrics({ task, ...facts, now: options.now }), facts.complete, options);
+}
+export function pageTaskUsage(input, complete = true, options = {}) {
+    const offset = options.offset ?? 0, limit = options.limit ?? 0;
+    if (!Number.isSafeInteger(offset) || offset < 0 || !Number.isSafeInteger(limit) || limit < 0 || limit > 50) {
+        throw new Error("Usage detail offset must be non-negative; limit must be 0..50.");
+    }
+    const bounded = (metric) => complete ? metric : {
+        ...metric, status: metric.value === null ? "unknown" : "partial",
+        reasons: [...new Set([...metric.reasons, "usage-history-limited"])]
+    };
+    const cost = (value) => ({
+        ...value,
+        status: complete || value.status === "unknown" ? value.status : "partial",
+        reasons: complete ? value.reasons : [...new Set([...value.reasons, "usage-history-limited"])],
+        amounts: value.amounts.map(amount => ({ ...bounded(amount), currency: amount.currency })),
+        evidence: value.evidence.slice(offset, offset + limit)
+    });
+    const total = Math.max(input.sessions.length, input.costs.actual.evidence.length, input.costs.estimated.evidence.length);
+    return {
+        ...input, tokens: bounded(input.tokens), toolCalls: bounded(input.toolCalls),
+        executionSeconds: bounded(input.executionSeconds),
+        costs: { scope: input.costs.scope, actual: cost(input.costs.actual), estimated: cost(input.costs.estimated) },
+        sessions: input.sessions.slice(offset, offset + limit),
+        details: { offset, limit, sessionTotal: input.sessions.length,
+            actualTotal: input.costs.actual.evidence.length, estimatedTotal: input.costs.estimated.evidence.length,
+            nextOffset: offset + limit < total ? offset + limit : null },
+        history: { complete, limit: TASK_USAGE_FACT_LIMIT }
+    };
+}

package/dist/scheduler/taskExecutionProjection.js

@@ -36,6 +36,7 @@ export function buildTaskExecutionProjection(store, taskId, now = new Date()) {
     });
     return projectTaskExecution({
         task,
+        usageFacts: store.readTaskUsageFacts(taskId),
         roles,
         runs,
         usageRuns,
@@ -110,6 +111,7 @@ export function projectTaskExecution(facts) {
         workItems,
         executionGroups: observabilityGroups,
         runs: facts.usageRuns ?? runs,
+        usageFacts: facts.usageFacts,
         events,
         contextSnapshots: facts.contextSnapshots,
         sessionTokens,

package/dist/scheduler/taskObservabilityProjection.js

@@ -1,4 +1,5 @@
 import { projectTaskUsageMetrics } from "../runtime/taskUsageMetrics.js";
+import { pageTaskUsage } from "../runtime/taskUsageQuery.js";
 /**
  * Build the read-only DAG, execution, cost, and context view consumed by CLI
  * and Web. It deliberately derives every value from existing Task records and
@@ -145,8 +146,15 @@ function projectCost(input, groups, workItemId) {
     const groupIds = new Set(uniqueGroups.map(({ id }) => id));
     const attempts = input.runs.filter(({ executionGroupId }) => (executionGroupId !== undefined && groupIds.has(executionGroupId)));
     const laneCount = uniqueGroups.reduce((total, group) => total + group.lanes.length, 0);
+    const usage = projectTaskUsageMetrics({
+        ...input,
+        ...(input.usageFacts === undefined ? {} : {
+            events: input.usageFacts.events, runs: input.usageFacts.runs
+        }),
+        workItemId
+    });
     return Object.freeze({
-        ...projectTaskUsageMetrics({ ...input, workItemId }),
+        ...(input.usageFacts === undefined ? usage : pageTaskUsage(usage, input.usageFacts.complete)),
         laneCount,
         groupCount: uniqueGroups.length,
         retryCount: Math.max(0, attempts.length - laneCount),

package/dist/storage/homeLayout.js

@@ -1,5 +1,6 @@
 import { isAbsolute, join, relative, resolve } from "node:path";
 import { createHash } from "node:crypto";
+import { statSync } from "node:fs";
 /**
  * The single authority for every Yui self-managed path derived from a Home.
  *
@@ -64,6 +65,18 @@ export function integrationTmuxSocketRoot(home) {
     const homeDigest = createHash("sha256").update(homeRoot(home)).digest("hex").slice(0, 16);
     return join("/tmp", `yi-${uid.toString(36)}-${homeDigest}`);
 }
+/** Short IPC endpoint for one foreground HTTP Job. Its durable owner and
+ * receipts stay in the Job artifact directory; only the socket lives here. */
+export function jobPreviewSocketRoot(artifactDir) {
+    const uid = typeof process.getuid === "function" ? process.getuid() : 0;
+    const identity = statSync(artifactDir);
+    if (!identity.isDirectory())
+        throw new Error("Preview Job artifacts must be a directory.");
+    const owner = createHash("sha256").update(JSON.stringify([
+        resolve(artifactDir), identity.dev, identity.ino
+    ])).digest("hex").slice(0, 24);
+    return join("/tmp", `yp-${uid.toString(36)}-${owner}`);
+}
 /**
  * Disposable staging prefix for `yui update`'s side-by-side package install
  * (an upgrade artifact): `<home>/runtime/update-staging`. Kept under Home so a

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/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) {