@zq-silk/yui 2.2.0 → 2.4.0

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

@@ -1,8 +1,9 @@
 import { createHash, randomBytes } from "node:crypto";
-import { lstatSync, mkdirSync, readFileSync, renameSync, rmdirSync, rmSync, writeFileSync } from "node:fs";
-import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { lstatSync, mkdirSync, readFileSync, readdirSync, renameSync, rmdirSync, rmSync, writeFileSync } from "node:fs";
+import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { validateManagedWorkspace } from "../worktree/managedWorkspace.js";
 import { ResourceRegistrar } from "../resources/resourceRegistrar.js";
+import { scanProcessPathRefs } from "../resources/liveReferences.js";
 export const YUI_TASK_RUNTIME_ISOLATION_DESCRIPTOR = "YUI_TASK_RUNTIME_ISOLATION_DESCRIPTOR";
 export const YUI_TASK_RUNTIME_SERVICE_NAMESPACE = "YUI_TASK_RUNTIME_SERVICE_NAMESPACE";
 const MARKER_FILE = ".yui-task-runtime-owner.json";
@@ -55,6 +56,10 @@ export class FileTaskRuntimeIsolation {
         const { descriptor, fingerprint } = validatePreparation(preparation);
         const root = descriptor.roots.runtime;
         const existing = inspectRuntimeRoot(descriptor, fingerprint);
+        const claim = existing.find(resource => resource.id !== root);
+        if (claim !== undefined) {
+            throw new Error(`Task runtime has an unresolved cleanup claim: ${claim.id}.`);
+        }
         if (existing.length > 0) {
             const [resource] = existing;
             if (resource?.ownership !== "owned"
@@ -97,16 +102,24 @@ export class FileTaskRuntimeIsolation {
     cleanup(preparation, reason) {
         requireCleanupReason(reason);
         const { descriptor, fingerprint } = validatePreparation(preparation);
-        const resources = [
-            ...inspectRuntimeRoot(descriptor, fingerprint),
-            ...(this.#inspectResources?.(descriptor) ?? [])
-        ];
-        if (resources.length === 0)
+        const resources = inspectTaskRuntimeCleanup(preparation, reason, this.#inspectResources?.(descriptor) ?? []);
+        if (resources.length === 0) {
+            this.#resourceRegistrar().markTaskRuntimeDeleted(descriptor);
             return;
-        planTaskRuntimeCleanup(descriptor, reason, resources);
+        }
+        // Claims keep the original descriptor and owner marker. An interrupted
+        // rename is not absence: resume only exact, inactive claims and leave any
+        // partial/unmarked deletion discoverable through the original owner.
+        for (const claimed of runtimeCleanupClaims(descriptor.roots.runtime)) {
+            removeRuntimeClaim(descriptor, fingerprint, claimed);
+        }
         // Re-read the sole durable marker immediately before deletion. A missing,
         // replaced, symlinked, or mismatched runtime is never cleanup authority.
         const current = inspectRuntimeRoot(descriptor, fingerprint);
+        if (current.length === 0) {
+            this.#resourceRegistrar().markTaskRuntimeDeleted(descriptor);
+            return;
+        }
         if (current.length !== 1
             || current[0]?.ownership !== "owned"
             || current[0].descriptorFingerprint !== fingerprint) {
@@ -116,18 +129,7 @@ export class FileTaskRuntimeIsolation {
         const claimed = `${root}.cleanup-${randomBytes(16).toString("hex")}`;
         renameSync(root, claimed);
         try {
-            const marker = parseMarker(readFileSync(join(claimed, MARKER_FILE), "utf8"));
-            if (marker.fingerprint !== fingerprint
-                || JSON.stringify(marker.descriptor) !== JSON.stringify(descriptor)) {
-                throw new Error("Task runtime resources changed during cleanup claim.");
-            }
-            rmSync(claimed, { recursive: true });
-            this.#resourceRegistrar().markPathsDeleted([
-                descriptor.roots.runtime,
-                descriptor.roots.data,
-                descriptor.roots.cache,
-                descriptor.roots.temporary
-            ]);
+            removeRuntimeClaim(descriptor, fingerprint, claimed);
         }
         catch (error) {
             // Preserve a claimed-but-unverified resource. Restore its exact path only
@@ -140,6 +142,13 @@ export class FileTaskRuntimeIsolation {
             }
             throw error;
         }
+        if (inspectRuntimeRoot(descriptor, fingerprint).length !== 0) {
+            throw new Error("Task runtime resources changed during cleanup.");
+        }
+        // Receipt persistence is separate from the filesystem claim. If it fails,
+        // retain the caller's owner and retry using the same validated descriptor;
+        // do not try to restore an already removed directory.
+        this.#resourceRegistrar().markTaskRuntimeDeleted(descriptor);
     }
 }
 export function createTaskRuntimeIsolationDescriptor(input) {
@@ -329,8 +338,69 @@ export function planTaskRuntimeCleanup(descriptor, reason, resources) {
     }
     return Object.freeze([...ids].sort());
 }
+/** Read-only cleanup admission, shared by resource preflight and deletion.
+ * Deletion still repeats ownership/live checks after claiming each directory.
+ */
+export function inspectTaskRuntimeCleanup(preparation, reason, additionalResources = []) {
+    const { descriptor, fingerprint } = validatePreparation(preparation);
+    const resources = [...inspectRuntimeRoot(descriptor, fingerprint), ...additionalResources];
+    planTaskRuntimeCleanup(descriptor, reason, resources);
+    const paths = resources.filter(resource => resource.kind === "directory").map(resource => resource.id);
+    if (paths.length === 0)
+        return resources;
+    const scan = scanProcessPathRefs(paths);
+    if (scan.diagnostics.some(diagnostic => diagnostic.severity === "error")
+        || [...scan.refs.values()].some(refs => refs.length > 0)) {
+        throw new Error("Task runtime cleanup resources are live or unverified.");
+    }
+    return resources;
+}
 function inspectRuntimeRoot(descriptor, expectedFingerprint) {
-    const root = descriptor.roots.runtime;
+    return [
+        ...inspectRuntimeDirectory(descriptor, expectedFingerprint, descriptor.roots.runtime),
+        ...inspectTaskRuntimeCleanupClaims(descriptor)
+    ];
+}
+/** Read-only inventory shared by execution admission and physical cleanup.
+ * The descriptor remains the original identity after a cleanup rename.
+ */
+export function inspectTaskRuntimeCleanupClaims(descriptor) {
+    const fingerprint = taskRuntimeIsolationFingerprint(descriptor);
+    return runtimeCleanupClaims(descriptor.roots.runtime)
+        .flatMap(root => inspectRuntimeDirectory(descriptor, fingerprint, root));
+}
+function runtimeCleanupClaims(root) {
+    const parent = dirname(root);
+    try {
+        // Names select candidates, never deletion authority. Include malformed or
+        // partially removed claims too so absence cannot produce a false receipt.
+        return readdirSync(parent).filter(name => name.startsWith(`${basename(root)}.cleanup-`))
+            .sort().map(name => join(parent, name));
+    }
+    catch (error) {
+        if (isNodeCode(error, "ENOENT"))
+            return [];
+        throw error;
+    }
+}
+function removeRuntimeClaim(descriptor, fingerprint, claimed) {
+    const current = inspectRuntimeDirectory(descriptor, fingerprint, claimed);
+    if (current.length !== 1 || current[0]?.ownership !== "owned") {
+        throw new Error(`Task runtime cleanup claim is not exactly owned: ${claimed}.`);
+    }
+    // A process cwd/fd follows rename. Inspect the physical claim, not only the
+    // descriptor's original (now missing) runtime path.
+    const scan = scanProcessPathRefs([claimed]);
+    if (scan.diagnostics.some(diagnostic => diagnostic.severity === "error")
+        || [...scan.refs.values()].some(refs => refs.length > 0)) {
+        throw new Error(`Task runtime cleanup claim is live or unverified: ${claimed}.`);
+    }
+    if (inspectRuntimeDirectory(descriptor, fingerprint, claimed)[0]?.ownership !== "owned") {
+        throw new Error(`Task runtime cleanup claim changed during inspection: ${claimed}.`);
+    }
+    rmSync(claimed, { recursive: true });
+}
+function inspectRuntimeDirectory(descriptor, expectedFingerprint, root) {
     let metadata;
     try {
         metadata = lstatSync(root);

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