@zq-silk/yui 2.3.0 → 2.5.0

package/dist/runtime/publicReply.js

@@ -0,0 +1,23 @@
+export function foldPublicReply(previous, nativeSessionId, method, params) {
+    if (params.threadId !== nativeSessionId)
+        return previous;
+    if (method === "turn/started")
+        return undefined;
+    if (typeof params.turnId !== "string")
+        return previous;
+    if (method === "item/agentMessage/delta" && typeof params.itemId === "string" && typeof params.delta === "string") {
+        const same = previous?.id === params.itemId && previous.turnId === params.turnId;
+        const text = (same ? previous.text : "") + params.delta;
+        return { nativeSessionId, turnId: params.turnId, id: params.itemId,
+            text: text.slice(0, 6000), truncated: text.length > 6000 || !!(same && previous.truncated) };
+    }
+    if ((method === "item/started" || method === "item/completed")
+        && params.item !== null && typeof params.item === "object") {
+        const item = params.item;
+        if (item.type === "agentMessage" && typeof item.id === "string" && typeof item.text === "string") {
+            return { nativeSessionId, turnId: params.turnId, id: item.id,
+                text: item.text.slice(0, 6000), truncated: item.text.length > 6000 };
+        }
+    }
+    return previous;
+}

package/dist/runtime/runtimeObservation.js

@@ -15,6 +15,11 @@ export function isRuntimeTokenEvidence(observation) {
                 && (observation.payload.observationQuality === "partial"
                     || observation.payload.observationQuality === "unavailable")));
 }
+/** Both money and tokens survive activity compaction; only tokens feed token metrics. */
+export function isRuntimeUsageEvidence(observation) {
+    return isRuntimeTokenEvidence(observation)
+        || (observation.kind === "activity.observed" && observation.payload.cost !== undefined);
+}
 const KINDS = [
     "host.observed",
     "session.started",
@@ -296,6 +301,11 @@ function normalizePayload(kind, input) {
     const observerSource = input.observerSource === undefined
         ? undefined
         : normalizeObserverSource(input.observerSource);
+    const cost = input.cost === undefined ? undefined : normalizeCost(input.cost);
+    if (cost !== undefined && (kind !== "activity.observed"
+        || (cost.semantics === "request" && input.activityId === undefined))) {
+        throw new Error("Cost requires activity.observed and a stable request activityId.");
+    }
     if (kind === "turn.failed" && input.failure === undefined) {
         throw new Error("run.failed requires normalized failure evidence.");
     }
@@ -376,6 +386,7 @@ function normalizePayload(kind, input) {
                     ...input.usage,
                     semantics: input.usage.semantics ?? "cumulative-session"
                 }) }),
+        ...(cost === undefined ? {} : { cost }),
         ...(observerSource === undefined ? {} : { observerSource }),
         ...(input.sourceId === undefined
             ? {}
@@ -434,6 +445,43 @@ function normalizePayload(kind, input) {
         ...(input.goalTokenBudget === undefined ? {} : { goalTokenBudget: input.goalTokenBudget })
     });
 }
+function normalizeCost(input) {
+    if (input === null || typeof input !== "object"
+        || !["actual", "estimated"].includes(input.kind)
+        || !["request", "cumulative-session"].includes(input.semantics)) {
+        throw new Error("Runtime cost kind or semantics is invalid.");
+    }
+    if (!Number.isFinite(input.amount) || input.amount < 0 || input.amount > Number.MAX_SAFE_INTEGER) {
+        throw new Error("Runtime cost amount must be finite and non-negative.");
+    }
+    if (typeof input.currency !== "string" || !/^[A-Z]{3}$/u.test(input.currency)) {
+        throw new Error("Runtime cost currency requires a three-letter currency code.");
+    }
+    if (input.kind === "estimated" && input.basis === undefined) {
+        throw new Error("Estimated cost requires a price basis.");
+    }
+    const basis = input.basis;
+    if (basis !== undefined && (!Array.isArray(basis.excluded) || basis.excluded.length > 16)) {
+        throw new Error("Runtime cost basis excluded items must be a bounded list.");
+    }
+    return Object.freeze({
+        kind: input.kind, semantics: input.semantics, amount: input.amount,
+        currency: input.currency, source: costText(input.source, "Cost source"),
+        ...(basis === undefined ? {} : { basis: Object.freeze({
+                model: costText(basis.model, "Cost model"),
+                source: costText(basis.source, "Price source"),
+                version: costText(basis.version, "Price version or date"),
+                scope: costText(basis.scope, "Estimate scope"),
+                excluded: Object.freeze(basis.excluded.map(value => costText(value, "Excluded cost", 128)))
+            }) })
+    });
+}
+function costText(value, label, limit = 512) {
+    const text = requireText(value, label);
+    if (text.length > limit)
+        throw new Error(`${label} exceeds ${limit} characters.`);
+    return text;
+}
 export function runtimeObservationSemanticKey(input) {
     const fence = input.fence;
     const continuationIdentity = [

package/dist/runtime/structuredProviderHost.js

@@ -13,6 +13,8 @@ import { unsupportedAgentRunConfiguration } from "./agentRunConfiguration.js";
 import { codexAppServerErrorIsMissing, CodexAppServerRequestError, CodexAppServerRuntime, codexClientInitialization, codexGoalNotification, codexTurnInput, codexTurnOutput } from "./codexAppServerRuntime.js";
 import { JsonLineChannel, PROVIDER_MESSAGE_MAX_BYTES, terminateProcessGroup } from "./jsonLineChannel.js";
 import { PROVIDER_ACCEPT_TIMEOUT_MS } from "./runtimeDeadlines.js";
+import { foldPublicReply } from "./publicReply.js";
+import { createCodexNativeAccess } from "./codexNativeAccess.js";
 const CODEX_PROXY_HANDSHAKE_TIMEOUT_MS = 10_000;
 /**
  * These Session implementations do not expose run-configuration observations.
@@ -297,7 +299,7 @@ class CodexProxyWebSocketChannel {
             return;
         }
         const id = requestId(message.id);
-        const pending = id === undefined ? undefined : this.#pending.get(id);
+        const pending = id === undefined || message.method !== undefined ? undefined : this.#pending.get(id);
         if (pending !== undefined) {
             clearTimeout(pending.timer);
             this.#pending.delete(id);
@@ -382,6 +384,7 @@ class CodexStructuredProviderSession {
     onActivity;
     mirror;
     nativeAccountHome;
+    nativeAccess;
     #turnAttempts = new Map();
     adapterId = "codex";
     #activeTurnId;
@@ -391,6 +394,7 @@ class CodexStructuredProviderSession {
     #bufferedStarts = [];
     #bufferedTerminals = [];
     #bufferedActivities = [];
+    publicReply;
     constructor(child, exit, processInstanceId, conversationId, runtime, onStarted, onTerminal, onGoal, onInput, onActivity, mirror, nativeAccountHome) {
         this.child = child;
         this.exit = exit;
@@ -412,13 +416,16 @@ class CodexStructuredProviderSession {
         await channel.notify("initialized");
         const runtime = new CodexAppServerRuntime(channel);
         let conversationId;
+        let nativeConfiguration;
         let resumedActiveTurnId;
         let resumedTurns = [];
         if (control.mode === "new") {
-            conversationId = (await runtime.openConversation({
+            const opened = await runtime.openConversation({
                 cwd: payload.cwd,
                 ...control.codexThread
-            })).conversationId;
+            });
+            conversationId = opened.conversationId;
+            nativeConfiguration = opened.raw;
         }
         else {
             try {
@@ -427,6 +434,7 @@ class CodexStructuredProviderSession {
                     ...control.codexThread
                 });
                 conversationId = resumed.threadId;
+                nativeConfiguration = resumed.raw;
                 resumedActiveTurnId = resumed.activeTurnId;
                 resumedTurns = resumed.turns;
             }
@@ -456,6 +464,7 @@ class CodexStructuredProviderSession {
             }
         }
         const session = new CodexStructuredProviderSession(child, exit, processInstanceId, conversationId, runtime, onStarted, onTerminal, onGoal, onInput, onActivity, mirror, optionalId(initialized.codexHome));
+        session.nativeAccess = createCodexNativeAccess(conversationId, initialized, channel, openingMessages, nativeConfiguration);
         session.#activeTurnId = resumedActiveTurnId;
         const ownedTurn = control.kind === "restore" ? control.ownedTurn : undefined;
         session.#clientOwnedTurnId = ownedTurn?.turnId;
@@ -514,6 +523,8 @@ class CodexStructuredProviderSession {
         const method = typeof message.method === "string" ? message.method : "";
         const params = object(message.params) ?? {};
         const threadId = optionalId(params.threadId);
+        if (emit)
+            this.publicReply = foldPublicReply(this.publicReply, this.conversationId, method, params);
         if (threadId !== this.conversationId) {
             if (threadId === undefined && (method === "turn/started" || method === "turn/completed")) {
                 this.mirror("stderr", `Codex protocol: ${method} has no thread identity; ignored.\n`);
@@ -630,11 +641,9 @@ class CodexStructuredProviderSession {
     get activeTurnId() {
         return this.#activeTurnId;
     }
-    /**
-     * This implementation has no run-configuration observation reader.
-     */
+    /** Last model confirmation from native start/resume, with its observation time. */
     get runConfiguration() {
-        return CODEX_RUN_CONFIGURATION;
+        return this.nativeAccess?.runConfiguration ?? CODEX_RUN_CONFIGURATION;
     }
     async submitTurn(turn) {
         if (this.#activeTurnId !== undefined) {

package/dist/runtime/taskCostMetrics.js

@@ -0,0 +1,133 @@
+/** No price catalog, currency conversion, token-to-money guess, or billing claim. */
+export function projectTaskCosts(observations, inScope, workItem, missingEvidence = []) {
+    const main = observations.filter(o => o.fence.nativeSessionId !== undefined
+        && o.fence.continuationId === undefined && o.fence.parentContinuationId === undefined
+        && (o.authority === "provider-structured" || o.authority === "driver-inferred"));
+    const resource = (o) => JSON.stringify([
+        o.fence.driverId, o.fence.nativeSessionId
+    ]);
+    const sessions = new Map();
+    for (const o of main)
+        sessions.set(resource(o), [...(sessions.get(resource(o)) ?? []), o]);
+    const project = (kind) => {
+        const evidence = [];
+        const reasons = [...missingEvidence];
+        if (observations.some(o => inScope(o) && o.payload.cost?.kind === kind
+            && (o.fence.continuationId !== undefined || o.fence.parentContinuationId !== undefined))) {
+            reasons.push("child-usage-overlap-unproven");
+        }
+        for (const all of sessions.values()) {
+            if (!all.some(inScope))
+                continue;
+            const costs = all.filter(o => o.payload.cost?.kind === kind);
+            if (costs.length === 0) {
+                reasons.push("cost-unobserved");
+                continue;
+            }
+            // Different native Roles and sources cannot safely claim independent charges.
+            const overlap = new Set(all.map(o => JSON.stringify([o.fence.roleName, o.fence.agentId]))).size > 1;
+            const latest = costs.at(-1);
+            const cost = latest.payload.cost;
+            // Missing receipts can carry only a coverage boundary, with no cost.
+            const local = qualityReasons(all.filter(o => inScope(o)
+                && (o.payload.cost === undefined || o.payload.cost.kind === kind)));
+            const semantics = new Set(costs.map(o => o.payload.cost.semantics));
+            if (overlap || semantics.size > 1) {
+                evidence.push(detail(latest, null, [...local,
+                    overlap ? "native-session-role-overlap" : "cost-source-overlap"]));
+                continue;
+            }
+            if (cost.semantics === "cumulative-session") {
+                let value = null;
+                if (new Set(costs.map(o => JSON.stringify([o.payload.cost.source, o.payload.cost.currency]))).size > 1) {
+                    local.push("cost-source-overlap");
+                }
+                else if (workItem)
+                    local.push("cumulative-not-allocatable-to-work-item");
+                else if (costs.some((o, i) => i > 0
+                    && o.payload.cost.amount < costs[i - 1].payload.cost.amount)) {
+                    local.push("cost-counter-rollback");
+                }
+                else if (new Set(costs.map(o => JSON.stringify(o.payload.cost.basis))).size > 1) {
+                    local.push("cost-basis-changed");
+                }
+                else {
+                    const baseline = costs[0].payload.cost.amount;
+                    if (baseline !== 0)
+                        local.push("nonzero-session-baseline");
+                    if (baseline === 0 || costs.length > 1)
+                        value = cost.amount - baseline;
+                }
+                evidence.push(detail(latest, value, [...local, ...qualityReasons(costs)]));
+                continue;
+            }
+            // Currency and price basis can change in a request revision. Resolve
+            // identity and attribution over every version before monetary grouping.
+            const requests = new Map();
+            for (const o of costs) {
+                const id = o.payload.activityId;
+                requests.set(id, [...(requests.get(id) ?? []), o]);
+            }
+            const bases = new Map();
+            for (const request of requests.values()) {
+                if (!request.some(inScope))
+                    continue;
+                const selected = request.at(-1);
+                const conflict = new Set(request.map(o => o.payload.cost.source)).size > 1
+                    ? "cost-source-overlap"
+                    : workItem && (!request.every(inScope) || new Set(request.map(o => o.fence.runId)).size !== 1)
+                        ? "request-run-attribution-conflict" : undefined;
+                if (conflict !== undefined) {
+                    evidence.push(detail(selected, null, [...local, conflict]));
+                    continue;
+                }
+                const selectedCost = selected.payload.cost;
+                const key = JSON.stringify([selectedCost.currency, selectedCost.source, selectedCost.basis]);
+                bases.set(key, [...(bases.get(key) ?? []), selected]);
+            }
+            for (const group of bases.values()) {
+                const subtotal = group.reduce((sum, o) => sum + o.payload.cost.amount, 0);
+                evidence.push(detail(group.at(-1), safeAmount(subtotal), [...local, ...qualityReasons(group)]));
+            }
+        }
+        if (evidence.length === 0)
+            reasons.push(kind === "estimated" ? "price-unavailable" : "cost-unobserved");
+        reasons.push(...evidence.flatMap(e => e.amount.reasons));
+        const amounts = [...new Set(evidence.map(e => e.currency))].sort().flatMap(currency => {
+            const known = evidence.filter(e => e.currency === currency && e.amount.value !== null);
+            return known.length === 0 ? [] : [{
+                    ...metric(safeAmount(known.reduce((sum, e) => sum + e.amount.value, 0)), reasons), currency
+                }];
+        });
+        return {
+            status: amounts.length === 0 ? "unknown" : reasons.length ? "partial" : "known",
+            amounts, reasons: [...new Set(reasons)].sort(), evidence
+        };
+    };
+    return { scope: "observed-sources-only", actual: project("actual"), estimated: project("estimated") };
+}
+function qualityReasons(observations) {
+    return [
+        ...(observations.some(o => o.payload.observationQuality === "partial"
+            || o.payload.observationQuality === "unavailable") ? ["source-coverage-partial"] : []),
+        ...(observations.some(o => (o.payload.cost?.basis?.excluded.length ?? 0) > 0)
+            ? ["estimate-exclusions"] : [])
+    ];
+}
+function detail(o, value, reasons) {
+    const cost = o.payload.cost;
+    return {
+        nativeSessionId: o.fence.nativeSessionId, roleName: o.fence.roleName,
+        agentId: o.fence.agentId, driverId: o.fence.driverId,
+        source: cost.source, currency: cost.currency, semantics: cost.semantics,
+        ...(cost.basis === undefined ? {} : { basis: cost.basis }),
+        amount: metric(value, reasons)
+    };
+}
+function safeAmount(value) {
+    return Number.isFinite(value) && value >= 0 && value <= Number.MAX_SAFE_INTEGER ? value : null;
+}
+function metric(value, reasons) {
+    return { value, status: value === null ? "unknown" : reasons.length ? "partial" : "known",
+        reasons: [...new Set(reasons)].sort() };
+}

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/leaderWakeupProcessor.js

@@ -86,15 +86,7 @@ export async function processLeaderWakeups(store, delivery, now, selection) {
             attempted = true;
             const outcome = await delivery.sendOnce({
                 delivery: ready, receiptId: notification.attemptId, notificationId: notification.wakeId,
-                text: [
-                    `Yui Task notification: task=${task.id} wake=${notification.wakeId}.`,
-                    `Read current context: yui task context ${task.id} --json.`,
-                    `Read the fixed notification window: yui task wake show ${task.id} ${notification.wakeId}.`,
-                    "Read referenced result Messages in full before deciding their disposition.",
-                    "Follow the Leader Skill to advance outstanding Task work from these durable facts, or record the exact decision/authority needed.",
-                    "This is a notification, not an execution assignment. No separate final report is required.",
-                    "Reading context is not an acknowledgement that its requirements have been implemented."
-                ].join("\n")
+                text: notification.presentation
             });
             const accepted = outcome.status === "sent" || outcome.status === "already-sent";
             const disposition = accepted ? "accepted"

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",