@zq-silk/yui 1.1.2 → 2.1.0

package/dist/commands/taskContextCommand.js

@@ -1,16 +1,28 @@
 import { usageError } from "../errors/cliError.js";
-import { inspectTaskContext, readTaskContext, readTaskContextDelta } from "../context/taskContext.js";
+import { inspectTaskContext, listTaskContext, readTaskContext, readTaskContextDelta } from "../context/taskContext.js";
+import { readOptions } from "../output/boundedRead.js";
+export function taskRecordList(args, store, family, environment = {}) {
+    const parsed = readOptions(args, ["--cursor", "--limit", "--status", "--after", "--work-item"]);
+    if (parsed.positionals.length !== 1)
+        throw usageError("Record list requires one Task and optional --limit/--cursor/--status/--after/--work-item.");
+    const data = listTaskContext(store, parsed.positionals[0], family, {
+        ...parsed, status: parsed.values.get("--status"), after: parsed.values.get("--after"),
+        workItemId: parsed.values.get("--work-item")
+    }, environment);
+    return { kind: "output", output: `${JSON.stringify(data)}\n`, data };
+}
 /** CLI parsing only; typed callers and capability ingress share the read model. */
 export function runTaskContextCommand(args, store, environment = {}) {
-    const explicit = ["read", "delta", "inspect"].includes(args[0] ?? "");
+    const explicit = ["read", "delta", "inspect", "list"].includes(args[0] ?? "");
     const action = explicit ? args[0] : "read";
     const taskId = args[explicit ? 1 : 0];
     if (!taskId || taskId.startsWith("--"))
-        throw usageError("Task context usage: yui task context [read|delta|inspect] <task> [--after <cursor>] [--continuation <cursor>] [--limit <1..100>] [--store <store> --ref <id> --digest <digest>].");
+        throw usageError("Task context usage: yui task context [read|list|delta|inspect] <task> [--after <cursor|timestamp>] [--continuation <cursor>] [--cursor <cursor>] [--limit <1..100>] [--store <store> --ref <id> --digest <digest>] [--status <status>] [--work-item <id>].");
     const options = new Map();
     const rest = args.slice(explicit ? 2 : 1);
     const allowed = action === "read" ? [] : action === "delta"
-        ? ["--after", "--continuation", "--limit"] : ["--store", "--ref", "--digest"];
+        ? ["--after", "--continuation", "--limit"] : action === "list"
+        ? ["--store", "--cursor", "--limit", "--status", "--after", "--work-item"] : ["--store", "--ref", "--digest", "--cursor"];
     for (let i = 0; i < rest.length; i += 2) {
         const flag = rest[i];
         const value = rest[i + 1];
@@ -22,6 +34,16 @@ export function runTaskContextCommand(args, store, environment = {}) {
     let data;
     if (action === "read")
         data = readTaskContext(store, taskId, environment);
+    else if (action === "list") {
+        const family = options.get("--store");
+        if (family === undefined)
+            throw usageError("Context list requires --store.");
+        data = listTaskContext(store, taskId, family, {
+            cursor: options.get("--cursor"),
+            status: options.get("--status"), after: options.get("--after"), workItemId: options.get("--work-item"),
+            ...(options.has("--limit") ? { limit: Number(options.get("--limit")) } : {})
+        }, environment);
+    }
     else if (action === "delta") {
         const after = options.get("--after");
         if (after === undefined)
@@ -36,7 +58,8 @@ export function runTaskContextCommand(args, store, environment = {}) {
         const refId = options.get("--ref");
         if (family === undefined || refId === undefined)
             throw usageError("Context inspect requires --store and --ref.");
-        data = inspectTaskContext(store, taskId, { store: family, refId, digest: options.get("--digest") }, environment);
+        data = inspectTaskContext(store, taskId, { store: family, refId, digest: options.get("--digest"),
+            cursor: options.get("--cursor") }, environment);
     }
-    return { kind: "output", output: `${JSON.stringify(data, null, 2)}\n`, data };
+    return { kind: "output", output: `${JSON.stringify(data)}\n`, data };
 }

package/dist/commands/taskFactCommands.js

@@ -1,11 +1,12 @@
 import { createTaskBrief, updateTaskBrief } from "../brief/taskBrief.js";
-import { assertContextRecordReadable, contextRecordReader } from "../context/taskContext.js";
+import { assertContextRecordReadable } from "../context/taskContext.js";
+import { taskRecordList } from "./taskContextCommand.js";
+import { materialize } from "../context/taskContext.js";
 import { enqueueWork } from "../coordination/workMailboxQueue.js";
 import { createDecision, supersedeDecision } from "../decision/decision.js";
 import { dataError, usageError } from "../errors/cliError.js";
 import { createMilestone } from "../milestone/milestone.js";
-import { defaultTableWidth, renderTable } from "../output/table.js";
-import { assertTaskOpen, clock, exactPositionals, leaderActionEventPayload, leaderMailbox, notifyMailbox, optionalNonEmptyOption, output, parseMultiValueTail, parseTail, presentTime, recordTaskEvent, requiredOption, requiredText, requireTask, taskActor, taskMailbox, taskRef } from "./taskCommandSupport.js";
+import { assertTaskOpen, clock, exactPositionals, leaderActionEventPayload, leaderMailbox, notifyMailbox, output, parseMultiValueTail, parseTail, presentTime, recordTaskEvent, requiredOption, requiredText, requireTask, taskActor, taskMailbox, taskRef } from "./taskCommandSupport.js";
 import { failureCapabilitiesCommand } from "../runtime/agentFailureContext.js";
 export function taskBriefCommand(args, store, options) {
     const [command, ...rest] = args;
@@ -87,7 +88,9 @@ export function taskBriefCommand(args, store, options) {
         if (result.task.status === "active") {
             notifyMailbox(options.runtime, leaderMailbox(result.task.id));
         }
-        return output(`Updated brief for ${result.task.id}\n`, { taskId: result.task.id, brief: result.brief });
+        return output(`Updated brief for ${result.task.id}\n`, {
+            taskId: result.task.id, effect: "saved", ref: materialize("task-brief", result.task.id, result.brief).ref
+        });
     }
     throw usageError(command === undefined
         ? "Task brief command is required."
@@ -125,29 +128,7 @@ export function taskDecisionCommand(args, store, options) {
         return output(`Recorded decision ${result.decision.id} for ${result.task.id}\n`);
     }
     if (command === "list") {
-        const usage = "Task decision list usage: yui task decision list <task> [--status active|superseded].";
-        const parsed = parseTail(rest, new Set(["--status"]), usage);
-        exactPositionals(parsed.positionals, 1, usage);
-        const task = requireTask(store, parsed.positionals[0]);
-        const readable = contextRecordReader(store, task.id, options.environment);
-        let decisions = store.listDecisions(task.id).filter(record => readable("task-decision", record.id));
-        const status = parsed.options.get("--status");
-        if (status !== undefined) {
-            if (status !== "active" && status !== "superseded") {
-                throw usageError("--status must be active or superseded.", usage);
-            }
-            decisions = decisions.filter((d) => d.status === status);
-        }
-        if (decisions.length === 0) {
-            return output(`No decisions found for ${task.id}.\n`, { taskId: task.id, decisions: [] });
-        }
-        const timeZone = store.getConfig().timeZone;
-        return output(`${renderTable(`Decisions: ${task.id}`, [
-            { header: "Decision", minWidth: 8, maxWidth: 18 },
-            { header: "Status", minWidth: 6, maxWidth: 12 },
-            { header: "Title", minWidth: 8, maxWidth: 64 },
-            { header: "Created", minWidth: 10, maxWidth: 28 }
-        ], decisions.map((d) => [d.id, d.status, d.title, presentTime(d.createdAt, timeZone)]), defaultTableWidth())}\n`, { taskId: task.id, decisions });
+        return taskRecordList(rest, store, "task-decision", options.environment);
     }
     if (command === "show") {
         exactPositionals(rest, 2, "Task decision show usage: yui task decision show <task> <decision>.");
@@ -231,19 +212,7 @@ export function taskMilestoneCommand(args, store, options) {
         return output(`Added milestone ${result.milestone.id} for ${result.task.id}\n`);
     }
     if (command === "list") {
-        exactPositionals(rest, 1, "Task milestone list usage: yui task milestone list <task>.");
-        const task = requireTask(store, rest[0]);
-        const readable = contextRecordReader(store, task.id, options.environment);
-        const milestones = store.listMilestones(task.id).filter(record => readable("task-milestone", record.id));
-        if (milestones.length === 0) {
-            return output(`No milestones found for ${task.id}.\n`, { taskId: task.id, milestones: [] });
-        }
-        const timeZone = store.getConfig().timeZone;
-        return output(`${renderTable(`Milestones: ${task.id}`, [
-            { header: "Milestone", minWidth: 9, maxWidth: 18 },
-            { header: "Title", minWidth: 8, maxWidth: 64 },
-            { header: "Created", minWidth: 10, maxWidth: 28 }
-        ], milestones.map((m) => [m.id, m.title, presentTime(m.createdAt, timeZone)]), defaultTableWidth())}\n`, { taskId: task.id, milestones });
+        return taskRecordList(rest, store, "task-milestone", options.environment);
     }
     if (command === "show") {
         exactPositionals(rest, 2, "Task milestone show usage: yui task milestone show <task> <milestone>.");
@@ -269,35 +238,7 @@ export function taskMilestoneCommand(args, store, options) {
 export function taskEventCommand(args, store, options = {}) {
     const [command, ...rest] = args;
     if (command === "list") {
-        const eventListUsage = "Task event list usage: yui task event list <task> [--after <timestamp>] [--limit <n>].";
-        const parsed = parseTail(rest, new Set(["--after", "--limit"]), eventListUsage);
-        exactPositionals(parsed.positionals, 1, eventListUsage);
-        const task = requireTask(store, parsed.positionals[0]);
-        const readable = contextRecordReader(store, task.id, options.environment);
-        let events = store.listEvents(task.id).filter(record => readable("task-event", record.id));
-        const after = optionalNonEmptyOption(parsed.options, "--after");
-        if (after !== undefined) {
-            const afterMs = Date.parse(after);
-            if (!Number.isFinite(afterMs))
-                throw usageError("--after must be a valid timestamp.", eventListUsage);
-            events = events.filter((e) => Date.parse(e.createdAt) > afterMs);
-        }
-        const limit = optionalNonEmptyOption(parsed.options, "--limit");
-        if (limit !== undefined) {
-            const n = Number(limit);
-            if (!Number.isSafeInteger(n) || n <= 0)
-                throw usageError("--limit must be a positive integer.", eventListUsage);
-            events = events.slice(-n);
-        }
-        if (events.length === 0) {
-            return output(`No events found for ${task.id}.\n`, { taskId: task.id, events: [] });
-        }
-        const timeZone = store.getConfig().timeZone;
-        return output(`${renderTable(`Events: ${task.id}`, [
-            { header: "Event", minWidth: 8, maxWidth: 18 },
-            { header: "Type", minWidth: 8, maxWidth: 28 },
-            { header: "Created", minWidth: 10, maxWidth: 28 }
-        ], events.map((e) => [e.id, e.type, presentTime(e.createdAt, timeZone)]), defaultTableWidth())}\n`, { taskId: task.id, events });
+        return taskRecordList(rest, store, "task-event", options.environment);
     }
     if (command === "show") {
         exactPositionals(rest, 2, "Task event show usage: yui task event show <task> <event>.");

package/dist/commands/taskInputCommands.js

@@ -2,7 +2,9 @@ import { enqueueWork } from "../coordination/workMailboxQueue.js";
 import { dataError, roleNotFound, taskNotFound, usageError } from "../errors/cliError.js";
 import { createTaskEvent } from "../event/taskEvent.js";
 import { answerInputRequest, cancelInputRequest, createInputRequest } from "../input/inputRequest.js";
-import { defaultTableWidth, renderTable } from "../output/table.js";
+import { boundedDocument, recordPage, readOptions } from "../output/boundedRead.js";
+import { materialize, resolveContextReader } from "../context/taskContext.js";
+import { taskRecordList } from "./taskContextCommand.js";
 import { formatTimestamp } from "../output/timePresentation.js";
 import { requireManagedTaskCaller, requireManagedGlobalCaller } from "../runtime/managedCaller.js";
 import { isRoleRunStalled, RUN_RECOVERED_EVENT } from "../scheduler/roleRunStall.js";
@@ -12,7 +14,7 @@ export function runTaskInputCommand(args, store, options) {
     const [command, ...rest] = args;
     switch (command) {
         case "request": return createRequest(rest, store, options);
-        case "list": return listRequests(rest, store);
+        case "list": return listRequests(rest, store, options);
         case "show": return showRequest(rest, store, options);
         case "answer": return answerRequest(rest, store, options);
         case "cancel": return cancelRequest(rest, store, options);
@@ -86,51 +88,40 @@ function createRequest(args, store, options) {
     notifyMailbox(options, { kind: "operator" });
     return output(`Created input request ${request.id} for ${request.taskId}\n`, { request });
 }
-function listRequests(args, store) {
-    const usage = "Task input list usage: yui task input list [task] [--all].";
-    const parsed = parseTail(args, new Set(), usage, new Set(["--all"]));
+function listRequests(args, store, options) {
+    const usage = "Task input list usage: yui task input list [task] [--all] [--limit <n>] [--cursor <cursor>].";
+    const all = args.includes("--all");
+    if (args.filter(arg => arg === "--all").length > 1)
+        throw usageError(usage);
+    const parsed = readOptions(args.filter(arg => arg !== "--all"));
     if (parsed.positionals.length > 1)
         throw usageError(usage);
-    const taskId = parsed.positionals[0];
-    if (taskId !== undefined)
-        requireTask(store, taskId);
-    const all = taskId === undefined
-        ? store.listAllInputRequests()
-        : store.listInputRequests(taskId);
-    const requests = parsed.options.has("--all")
-        ? all
-        : all.filter((request) => request.status === "open");
-    let rendered = "No input requests found.\n";
-    if (requests.length > 0) {
-        const timeZone = store.getConfig().timeZone;
-        rendered = `${renderTable(taskId === undefined ? "Input inbox" : `Input requests: ${taskId}`, [
-            { header: "Input", minWidth: 6, maxWidth: 18 },
-            { header: "Task", minWidth: 6, maxWidth: 18 },
-            { header: "Status", minWidth: 6, maxWidth: 10 },
-            { header: "Policy", minWidth: 8, maxWidth: 12 },
-            { header: "Question", minWidth: 8, maxWidth: 72 },
-            { header: "Created", minWidth: 10, maxWidth: 28 }
-        ], requests.map((request) => [
-            taskId === undefined ? `${request.taskId}/${request.id}` : request.id,
-            request.taskId,
-            request.status,
-            request.policy.kind,
-            request.question,
-            formatTimestamp(request.createdAt, timeZone)
-        ]), defaultTableWidth())}\n`;
+    const caller = resolveContextReader(store, options.environment ?? {});
+    const taskId = parsed.positionals[0] ?? caller?.taskId;
+    if (taskId !== undefined) {
+        return taskRecordList([taskId, ...(all ? [] : ["--status", "open"]),
+            ...(parsed.cursor === undefined ? [] : ["--cursor", parsed.cursor]),
+            ...(parsed.limit === undefined ? [] : ["--limit", String(parsed.limit)])], store, "input-request", options.environment);
     }
-    return output(rendered, { requests });
+    const requests = store.listAllInputRequests().filter(request => all || request.status === "open");
+    const data = recordPage(requests.map(request => ({
+        taskId: request.taskId, ref: materialize("input-request", request.id, request).ref,
+        status: request.status, summary: request.question.slice(0, 400), policy: request.policy.kind
+    })), `input-inbox:${all ? "all" : "open"}`, parsed);
+    return output(`${JSON.stringify(data)}\n`, data);
 }
 function showRequest(args, store, options) {
     const usage = "Task input show usage: yui task input show (<task>/<input> | <input> --task <task>).";
-    const parsed = parseTail(args, new Set(["--task"]), usage);
+    const parsed = parseTail(args, new Set(["--task", "--cursor"]), usage);
     exactPositionals(parsed.positionals, 1, usage);
     const reference = inputRequestReference(store, parsed.positionals[0], optionalNonEmptyOption(parsed.options, "--task"), options.environment);
     const request = store.getInputRequest(reference.taskId, reference.localId);
     if (request === null) {
         throw dataError(`Input request not found: ${reference.taskId}/${reference.localId}.`);
     }
-    return output(renderInputRequest(request, store.getConfig().timeZone), { request });
+    const data = boundedDocument({ request }, `input:${reference.taskId}/${reference.localId}`, parsed.options.get("--cursor"));
+    return output("contentPage" in data ? `${JSON.stringify(data)}\n`
+        : renderInputRequest(request, store.getConfig().timeZone), data);
 }
 function answerRequest(args, store, options) {
     const usage = "Task input answer usage: yui task input answer (<task>/<input> | <input> --task <task>) (--choice <key> | --text <text>).";

package/dist/commands/taskPublicationCommands.js

@@ -1,7 +1,7 @@
 import { isDeepStrictEqual } from "node:util";
 import { dataError, taskNotFound, usageError } from "../errors/cliError.js";
 import { createTaskEvent } from "../event/taskEvent.js";
-import { defaultTableWidth, renderTable } from "../output/table.js";
+import { taskRecordList } from "./taskContextCommand.js";
 import { formatTimestamp } from "../output/timePresentation.js";
 import { resolveProject } from "../repository/project.js";
 import { createPublicationReference } from "../task/publicationReference.js";
@@ -26,7 +26,7 @@ export function runPublicationCommand(args, store, options) {
     const [command, ...rest] = args;
     switch (command) {
         case "upsert": return upsertPublication(rest, store, options);
-        case "list": return listPublications(rest, store);
+        case "list": return taskRecordList(rest, store, "publication", options.environment);
         case "show": return showPublication(rest, store);
         default:
             throw usageError(command === undefined
@@ -125,34 +125,6 @@ export function upsertTaskPublication(store, task, input, actor, now) {
     recordPublicationEvent(store, reference, now);
     return { reference, idempotent: false };
 }
-function listPublications(args, store) {
-    const usage = "Task publication list usage: yui task publication list <task>.";
-    const parsed = parseTail(args, new Set(), usage);
-    exactPositionals(parsed.positionals, 1, usage);
-    const task = requireTask(store, parsed.positionals[0]);
-    const references = store.listPublicationReferences(task.id);
-    if (references.length === 0) {
-        return output("No publication references found.\n", []);
-    }
-    const rendered = `${renderTable(`Publication references: ${task.id}`, [
-        { header: "ID", minWidth: 12, maxWidth: 22 },
-        { header: "External", minWidth: 16, maxWidth: 40 },
-        { header: "Title", minWidth: 16, maxWidth: 40 },
-        { header: "State", minWidth: 7, maxWidth: 10 },
-        { header: "Verification", minWidth: 11, maxWidth: 14 },
-        { header: "Lineage", minWidth: 18, maxWidth: 58 },
-        { header: "Supersedes", minWidth: 12, maxWidth: 22 }
-    ], references.map((reference) => [
-        reference.id,
-        `${reference.provider}/${reference.repository}/${reference.externalId}`,
-        reference.title ?? "-",
-        reference.state,
-        reference.verification,
-        lineageSummary(reference),
-        reference.supersedes ?? "-"
-    ]), defaultTableWidth())}\n`;
-    return output(rendered, references);
-}
 function showPublication(args, store) {
     const usage = "Task publication show usage: yui task publication show (<task>/<publication-id> | <task> <publication-id>).";
     const parsed = parseTail(args, new Set(), usage);
@@ -197,11 +169,6 @@ function renderPublication(reference, timeZone) {
         `Created: ${formatTimestamp(reference.createdAt, timeZone)}`
     ].join("\n").concat("\n");
 }
-function lineageSummary(reference) {
-    const local = reference.localCommit ?? "unknown";
-    const remote = reference.remoteCommit ?? "unknown";
-    return `${local.slice(0, 12)} -> ${reference.externalId} -> ${remote.slice(0, 12)}`;
-}
 function parseVerification(parsed, usage) {
     if (parsed.flags.has("--reported") && parsed.flags.has("--verified")) {
         throw usageError("--reported and --verified are mutually exclusive.", usage);

package/dist/commands/taskPublicationVerifyCommand.js

@@ -36,8 +36,7 @@ export async function runTaskPublicationVerifyCommand(args, store, options) {
         if (error instanceof CliError)
             throw error;
         throw runtimeError(`Publication verification failed for ${request.publication.provider}/`
-            + `${request.publication.repository}/${request.publication.externalId}: `
-            + `${error instanceof Error ? error.message : String(error)}`);
+            + `${request.publication.repository}/${request.publication.externalId}.`, { cause: error });
     }
     assertVerificationObservation(request, observation);
     const result = commitPublicationVerification(store, request, observation, options.now?.() ?? new Date());

package/dist/commands/taskUpstreamCommands.js

@@ -1,5 +1,6 @@
 import { parseRepeatable } from "../cli/parseRepeatable.js";
 import { usageError } from "../errors/cliError.js";
+import { describeCliFailure } from "../errors/cliFailure.js";
 import { GitIntegrationService } from "../integration/gitIntegrationService.js";
 import { createIntegrationAttempt } from "../integration/integrationAttempt.js";
 import { NodeGitWorkspace } from "../repository/gitWorkspace.js";
@@ -128,7 +129,7 @@ async function integrateUpstream(args, store, home, options) {
             failure = {
                 projectId: binding.projectId,
                 phase,
-                message: error instanceof Error ? error.message : String(error),
+                message: describeCliFailure(error, { environment: options.environment }).message,
                 ...(integrationId === undefined ? {} : { integrationId }),
                 effect: integrationId === undefined ? "not-started" : "inspect-required"
             };

package/dist/context/runContextPack.js

@@ -10,9 +10,6 @@ import { managedWorkspaceKey } from "../worktree/managedWorkspace.js";
 import { contextContentDigest, contextSnapshotRef, createContextSnapshot, validateContextSnapshot } from "./contextSnapshot.js";
 import { MAX_SYNTHESIS_SOURCE_RUNS, sourceRunContextValue } from "./sourceRunContext.js";
 export const RUN_CONTEXT_PACK_SCHEMA_VERSION = 1;
-export const RUN_CONTEXT_PACK_MAX_REFS = 256;
-export const RUN_CONTEXT_PACK_MAX_BYTES = 8 * 1024 * 1024;
-export const RUN_CONTEXT_EXPAND_MAX_BYTES = 4 * 1024 * 1024;
 export function freezeRunContextSnapshot(store, run, now, frozenBy = "controller", baselineRef, sourceRunIds) {
     if (baselineRef !== undefined) {
         const baseline = store.getContextSnapshot(run.taskId, baselineRef.id);
@@ -212,18 +209,9 @@ export function buildRunContextPack(store, taskId, runId) {
     const run = requireExactRun(store, taskId, runId);
     const snapshot = readRunContextSnapshot(store, run);
     const pointers = snapshot.refs;
-    if (pointers.length > RUN_CONTEXT_PACK_MAX_REFS) {
-        throw new Error(`AgentRun Context exceeds ${RUN_CONTEXT_PACK_MAX_REFS} authorized refs.`);
-    }
     const view = contextView(run);
     const writableProjectIds = run.effective.executionAuthority === "planning"
         ? [] : run.effective.writeProjectIds;
-    const summaries = pointers.map((ref) => Object.freeze({
-        refId: ref.refId,
-        store: ref.store,
-        summary: ref.summary ?? `${ref.store} ${ref.refId}`,
-        digest: ref.digest
-    }));
     const body = {
         schemaVersion: RUN_CONTEXT_PACK_SCHEMA_VERSION,
         identity: Object.freeze({
@@ -237,10 +225,10 @@ export function buildRunContextPack(store, taskId, runId) {
         }),
         snapshot: contextSnapshotRef(snapshot),
         input: run.inputs[0].input,
-        authority: Object.freeze({ view, readableRefs: pointers, writableProjectIds }),
+        authority: Object.freeze({ view, writableProjectIds }),
         pointers,
-        summaries,
-        deltas: pointers.filter((ref) => run.inputs[0].input.deltaRefIds.includes(ref.refId)),
+        deltaRefs: pointers.filter((ref) => run.inputs[0].input.deltaRefIds.includes(ref.refId))
+            .map(({ store, refId }) => ({ store, refId })),
         completion: Object.freeze({
             allowedActions: completionActions(view, run.effective.executionAuthority),
             exactRunRef: `${taskId}/${runId}`
@@ -248,17 +236,12 @@ export function buildRunContextPack(store, taskId, runId) {
     };
     const digest = contextContentDigest(body);
     const preliminaryBytes = Buffer.byteLength(JSON.stringify({ ...body, digest }), "utf8");
-    if (preliminaryBytes > RUN_CONTEXT_PACK_MAX_BYTES) {
-        throw new Error(`AgentRun Context Pack exceeds ${RUN_CONTEXT_PACK_MAX_BYTES} bytes.`);
-    }
     const pack = Object.freeze({
         ...body,
-        budget: Object.freeze({
-            maxRefs: RUN_CONTEXT_PACK_MAX_REFS,
-            returnedRefs: pointers.length,
-            maxBytes: RUN_CONTEXT_PACK_MAX_BYTES,
-            returnedBytes: preliminaryBytes,
-            truncated: false
+        inventory: Object.freeze({
+            refs: pointers.length,
+            frozenBytes: preliminaryBytes,
+            complete: true
         }),
         digest,
         liveTaskState: readLiveTaskState(store, taskId)
@@ -303,10 +286,6 @@ export function expandRunContextRef(store, taskId, runId, refId, refStore) {
     if (materialized === undefined || materialized.ref.digest !== authorized[0].digest) {
         throw new Error(`AgentRun Context ref is unavailable or drifted: ${selector}.`);
     }
-    const bytes = Buffer.byteLength(JSON.stringify(materialized.value), "utf8");
-    if (bytes > RUN_CONTEXT_EXPAND_MAX_BYTES) {
-        throw new Error(`AgentRun Context expansion exceeds ${RUN_CONTEXT_EXPAND_MAX_BYTES} bytes.`);
-    }
     return Object.freeze({
         ref: materialized.ref,
         value: materialized.value,
@@ -330,7 +309,7 @@ export function buildRunContextDelta(store, taskId, runId, after) {
         schemaVersion: 1,
         after,
         cursor: pack.digest,
-        refs: pack.deltas
+        refs: pack.pointers.filter(ref => pack.deltaRefs.some(delta => delta.store === ref.store && delta.refId === ref.refId))
     });
 }
 function requireExactRun(store, taskId, runId) {

package/dist/context/sessionBootstrapManifest.js

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
-import { chmodSync, existsSync, readFileSync, readdirSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
+import { chmodSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
 import { writeTextFileAtomically } from "../storage/durableFile.js";
 import { SESSION_BOOTSTRAP_MANIFEST_SCHEMA_VERSION, SESSION_CONTEXT_PROTOCOL, sessionManifestCompatibilityDigest } from "./sessionProtocolIdentity.js";
 export { SESSION_BOOTSTRAP_MANIFEST_SCHEMA_VERSION, SESSION_CONTEXT_PROTOCOL, sessionManifestCompatibilityDigest } from "./sessionProtocolIdentity.js";
@@ -13,27 +13,10 @@ export function withSessionContextPointer(text, environment) {
     return [
         `Read the Yui Session Manifest at ${manifest}.`,
         "Follow its referenced Role Skills and role profile. It gives the exact Context load command.",
-        ...(environment.YUI_SESSION_CLI === undefined ? [] : [
-            `Use this absolute CLI entry for Yui commands: ${environment.YUI_SESSION_CLI}`
-        ]),
         "",
         text
     ].join("\n");
 }
-/**
- * A managed Session wrapper answers exactly one question: which installation
- * runs this command. It therefore carries only the resolved entry point, never
- * a package or build identity. Current Sessions may survive a compatible
- * installation relocation; this is not a cross-version runtime adapter.
- */
-function renderSessionCli(entryPoint) {
-    return [
-        "#!/bin/sh",
-        `exec ${quoteShellWord(entryPoint.executable)} `
-            + `${quoteShellWord(entryPoint.cliEntry)} \"$@\"`,
-        ""
-    ].join("\n");
-}
 /** Read back one immutable Session Manifest and verify its content digest. */
 export function readSessionBootstrapManifest(path) {
     const source = resolve(path);
@@ -67,8 +50,6 @@ export function readSessionBootstrapManifest(path) {
             && record.roleKind !== "leader"
             && record.roleKind !== "worker"
             && record.roleKind !== "reviewer")
-        || record.controlPlane === null
-        || typeof record.controlPlane !== "object"
         || !Array.isArray(record.skills)
         || record.roleProfileRef === null
         || typeof record.roleProfileRef !== "object"
@@ -80,8 +61,6 @@ export function readSessionBootstrapManifest(path) {
     if (owner.scope === "task" && typeof owner.taskId !== "string") {
         throw new Error("Task Session Manifest owner is invalid.");
     }
-    const control = record.controlPlane;
-    requireText(control.sessionCliPath, "Session Manifest CLI path");
     for (const skill of record.skills) {
         if (skill === null || typeof skill !== "object") {
             throw new Error("Session Manifest Skill entry is invalid.");
@@ -103,16 +82,6 @@ export function readSessionBootstrapManifest(path) {
 }
 export function materializeSessionBootstrap(input) {
     const home = resolve(input.yuiHome);
-    // Provider command runners may rebuild PATH independently of the managed
-    // process environment, so a bare `yui` could resolve to another install or
-    // Home. The wrapper pins the resolved entry point instead. Package identity
-    // stays out of it: current Session authority and the CLI/Controller protocol
-    // boundary authorize the command.
-    const sessionCliContent = renderSessionCli(input.entryPoint);
-    const sessionCliDigest = digest(sessionCliContent);
-    const sessionCliPath = resolve(join(home, "runtime", "session-cli", `yui-${sessionCliDigest}.sh`));
-    writeImmutableText(sessionCliPath, sessionCliContent);
-    chmodSync(sessionCliPath, 0o700);
     const roleProfile = {
         roleName: input.role.name,
         roleKind: input.roleKind,
@@ -134,9 +103,6 @@ export function materializeSessionBootstrap(input) {
         effectiveRevision: input.role.launchRevision,
         roleKind: input.roleKind,
         compatibilityDigest: sessionManifestCompatibilityDigest(input.role.name, input.roleKind, input.role),
-        controlPlane: {
-            sessionCliPath
-        },
         skills: input.skills.map((skill) => Object.freeze({
             id: skill.id,
             path: skill.path,
@@ -151,10 +117,10 @@ export function materializeSessionBootstrap(input) {
                 loadCommand: renderGlobalContextCommand(input.entryPoint, home, input.role.name)
             }
             : {
-                loadCommand: "\"$YUI_SESSION_CLI\" task run context \"$YUI_TASK_ID/<run-id>\" --json",
-                expandCommand: "\"$YUI_SESSION_CLI\" task run context expand \"$YUI_TASK_ID/<run-id>\" <ref-id> --store <store> --mode full --json",
+                loadCommand: `yui task run context ${quoteShellWord(`${input.owner.taskId}/<run-id>`)} --json`,
+                expandCommand: `yui task run context expand ${quoteShellWord(`${input.owner.taskId}/<run-id>`)} <ref-id> --store <store> --mode full --json`,
                 ...(input.role.name === "leader" ? {
-                    currentCommand: "\"$YUI_SESSION_CLI\" task context \"$YUI_TASK_ID\" --json"
+                    currentCommand: `yui task context ${quoteShellWord(input.owner.taskId)} --json`
                 } : {})
             }
     };
@@ -164,7 +130,6 @@ export function materializeSessionBootstrap(input) {
     return Object.freeze({
         manifest,
         manifestPath,
-        sessionCliPath,
         roleProfilePath
     });
 }
@@ -182,67 +147,6 @@ function renderGlobalContextCommand(entryPoint, home, roleName) {
 function quoteShellWord(value) {
     return `'${value.replaceAll("'", "'\"'\"'")}'`;
 }
-/**
- * Retargets current managed wrappers to the resolved installation entry point.
- * Only a valid Session Manifest may nominate a wrapper, and only the exact
- * two-argument shell form generated here is changed.
- */
-export function refreshManagedSessionCliWrappers(homeInput, entryPoint) {
-    const home = resolve(homeInput);
-    const currentSessionCli = renderSessionCli(entryPoint);
-    const manifestDirectory = resolve(join(home, "runtime", "session-manifests"));
-    const sessionCliDirectory = resolve(join(home, "runtime", "session-cli"));
-    if (!existsSync(manifestDirectory)) {
-        return Object.freeze({ refreshed: 0, current: 0, skipped: 0 });
-    }
-    const wrapperPaths = new Set();
-    let skipped = 0;
-    for (const name of readdirSync(manifestDirectory).filter((entry) => entry.endsWith(".json"))) {
-        const manifestPath = resolve(join(manifestDirectory, name));
-        try {
-            const manifest = readSessionBootstrapManifest(manifestPath);
-            if (manifestPath !== resolve(join(manifestDirectory, `${manifest.digest}.json`))) {
-                skipped += 1;
-                continue;
-            }
-            const wrapperPath = resolve(manifest.controlPlane.sessionCliPath);
-            if (dirname(wrapperPath) !== sessionCliDirectory) {
-                skipped += 1;
-                continue;
-            }
-            wrapperPaths.add(wrapperPath);
-        }
-        catch {
-            // An invalid Manifest cannot nominate a wrapper for mutation.
-            skipped += 1;
-        }
-    }
-    let refreshed = 0;
-    let current = 0;
-    for (const wrapperPath of wrapperPaths) {
-        if (!existsSync(wrapperPath)) {
-            skipped += 1;
-            continue;
-        }
-        const content = readFileSync(wrapperPath, "utf8");
-        if (content === currentSessionCli) {
-            current += 1;
-            continue;
-        }
-        if (!isManagedSessionCli(content)) {
-            skipped += 1;
-            continue;
-        }
-        writeTextFileAtomically(wrapperPath, currentSessionCli);
-        chmodSync(wrapperPath, 0o700);
-        refreshed += 1;
-    }
-    return Object.freeze({ refreshed, current, skipped });
-}
-/** Match exactly the two shell-quoted words emitted by renderSessionCli. */
-function isManagedSessionCli(content) {
-    return /^#!\/bin\/sh\nexec '(?:[^'\n]|'"'"')*' '(?:[^'\n]|'"'"')*' "\$@"\n$/u.test(content);
-}
 function writeImmutableText(path, content) {
     writeTextFileAtomically(path, content);
     chmodSync(path, 0o600);