@zq-silk/yui 0.6.16 → 0.7.0

package/dist/cli/commandCatalog.js

@@ -121,6 +121,7 @@ const roleChildren = [
     },
     { name: "list", summary: "List global Roles." },
     { name: "show", summary: "Show one global Role.", usage: "yui role show <name>" },
+    { name: "context", summary: "Load the exact authorized global Role context.", usage: "yui role context <name>" },
     {
         name: "update",
         summary: "Update a global Role.",
@@ -1227,7 +1228,7 @@ export const ROOT_COMMAND = buildNode({
             name: "role",
             summary: "Manage reusable global Roles and their native sessions.",
             sections: [
-                { id: "inspect", title: "Inspect", entries: ["list", "show"] },
+                { id: "inspect", title: "Inspect", entries: ["list", "show", "context"] },
                 { id: "manage", title: "Manage", entries: ["add", "update", "remove", "bind", "unbind"] },
                 { id: "sessions", title: "Sessions", entries: ["enter", "session"] }
             ],
@@ -1278,7 +1279,7 @@ export const ROOT_COMMAND = buildNode({
             name: "internal",
             summary: "Internal Yui callbacks.",
             hidden: true,
-            sections: [{ id: "callbacks", title: "Callbacks", entries: ["session-notify", "runtime-hook", "managed-claude-run"] }],
+            sections: [{ id: "callbacks", title: "Callbacks", entries: ["session-notify", "runtime-hook"] }],
             children: [
                 {
                     name: "session-notify",
@@ -1289,11 +1290,6 @@ export const ROOT_COMMAND = buildNode({
                     name: "runtime-hook",
                     summary: "Record a managed Agent Driver observation from stdin.",
                     usage: "yui internal runtime-hook"
-                },
-                {
-                    name: "managed-claude-run",
-                    summary: "Run one managed Claude turn over the stream-json protocol.",
-                    usage: "yui internal managed-claude-run -- <command> [args...]"
                 }
             ]
         }

package/dist/cli.js

@@ -60,7 +60,7 @@ import { runRuntimeObservationHookCommand } from "./controller/runtimeObservatio
 import { buildDoctorReport, renderDoctor, runDoctorCommand } from "./doctor/doctor.js";
 import { agentNotFound, CliError, usageError } from "./errors/cliError.js";
 import { FileRoleLaunchPlanner } from "./executor/fileRoleLaunchPlanner.js";
-import { runManagedClaudeProcess } from "./executor/managedClaudeRunner.js";
+import { runAgentHost } from "./runtime/agentHost.js";
 import { TaskWorkspaceCoordinator, WorkspaceCleanupBlockedError } from "./repository/taskWorkspaceCoordinator.js";
 import { FileTaskWorkspacePreparer, ReviewRoundWorkspaceEvidenceError } from "./repository/taskWorkspacePreparer.js";
 import { inspectStorageSchema } from "./storage/storageSchema.js";
@@ -243,6 +243,14 @@ export async function main() {
         return;
     }
     if (args[0] === "internal") {
+        if (args[1] === "agent-host" && args.length === 4) {
+            process.exitCode = await runAgentHost({
+                home,
+                launchId: args[2],
+                ticket: args[3]
+            });
+            return;
+        }
         if (args[1] === "session-notify" && args.length === 3) {
             await runSessionNotifyCommand(args[2], process.env);
             return;
@@ -251,36 +259,6 @@ export async function main() {
             await runRuntimeObservationHookCommand(readFileSync(0, "utf8"), process.env);
             return;
         }
-        if (args[1] === "managed-claude-run"
-            && args[2] === "--"
-            && args.length >= 4
-            && verifiedStore !== undefined) {
-            const taskId = process.env.YUI_TASK_ID;
-            const runId = process.env.YUI_RUN_ID;
-            const agentId = process.env.YUI_AGENT_ID;
-            if (taskId === undefined || runId === undefined || agentId === undefined) {
-                throw new Error("Managed Claude run identity is incomplete.");
-            }
-            const run = verifiedStore.getActiveAgentRun(taskId, process.env.YUI_ROLE ?? "");
-            if (run === null || run.id !== runId || run.effective.agentId !== agentId
-                || run.effective.adapterId !== "claude") {
-                throw new Error("Managed Claude run is not the exact active generation.");
-            }
-            const configured = verifiedStore.getConfiguredAgent(agentId);
-            if (configured === null || configured.adapterId !== "claude" || args[3] !== configured.command) {
-                throw new Error("Managed Claude command does not match the active Agent.");
-            }
-            if (!configured.baseArgs.every((value, index) => args[index + 4] === value)) {
-                throw new Error("Managed Claude arguments do not start with the configured base arguments.");
-            }
-            process.exitCode = await runManagedClaudeProcess({
-                command: configured.command,
-                args: args.slice(4),
-                prompt: run.input,
-                environment: process.env
-            });
-            return;
-        }
         throw usageError("Internal lifecycle callback usage is invalid.");
     }
     if (args[0] === "session") {
@@ -620,7 +598,8 @@ export async function main() {
     if (resolved[0] === "role") {
         const roleOptions = {
             yuiHome: home,
-            env: process.env
+            env: process.env,
+            jsonOutput
         };
         const result = runGlobalRoleCommand(resolved.slice(1), store, roleOptions);
         if (typeof result === "string") {
@@ -1240,7 +1219,7 @@ async function preflightManagedTaskControlPlane() {
     });
     const runtime = assertExactTaskRuntimeEnvironment(serializedRuntime, process.env, digest, control.yuiHome);
     const runtimeDriverCallback = args[0] === "internal"
-        && (args[1] === "runtime-hook" || args[1] === "managed-claude-run")
+        && args[1] === "runtime-hook"
         && process.env.YUI_DRIVER_ID !== undefined
         ? builtinAgentDriverRegistry().require(process.env.YUI_DRIVER_ID)
         : undefined;

package/dist/commands/executionAuditCommands.js

@@ -221,6 +221,25 @@ export function renderExecutionAudit(report, width = defaultTableWidth()) {
     else {
         lines.push("", ...sectionError("storage", report));
     }
+    if (report.runtimeProtocol.status === "ok" && report.runtimeProtocol.data !== undefined) {
+        const runtime = report.runtimeProtocol.data;
+        const versions = Object.entries(runtime.contextProtocolVersions)
+            .map(([version, count]) => `${version}:${count}`)
+            .join(", ") || "none";
+        const retryStates = Object.entries(runtime.activeRetryStates)
+            .map(([state, count]) => `${state}:${count}`)
+            .join(", ") || "none";
+        const exits = Object.entries(runtime.processExitClassifications)
+            .map(([classification, count]) => `${classification}:${count}`)
+            .join(", ") || "none";
+        const usage = Object.entries(runtime.usageSemantics)
+            .map(([semantics, count]) => `${semantics}:${count}`)
+            .join(", ") || "none";
+        lines.push("", `Runtime protocol: context versions ${versions} · manifest compatibility identities ${runtime.manifestCompatibilityDigests}`, `Active retry: ${runtime.activeRetryEpisodes} episode(s) [${retryStates}] · failures ${runtime.activeConsecutiveFailures} · dispatched ${runtime.activeDispatchedRetries}`, `Retry audit: ${runtime.retryClassifiedEvents} classified · ${runtime.retryDispatchedEvents} dispatched · ${runtime.retryRecoveredEvents} recovered · ${runtime.retryExhaustedEvents} exhausted`, `Process exits: ${runtime.processExitObservations} [${exits}] · capacity failures ${runtime.contextCapacityFailures}`, `Context telemetry: usage [${usage}] · native compaction events ${runtime.compactionEvents}`);
+    }
+    else {
+        lines.push("", ...sectionError("runtimeProtocol", report));
+    }
     if (report.topLongRunning.status === "ok" && report.topLongRunning.data !== undefined) {
         const entries = report.topLongRunning.data;
         if (entries.length > 0) {

package/dist/commands/globalRoleCommands.js

@@ -14,6 +14,7 @@ export function runGlobalRoleCommand(args, store, options = {}) {
         case "add": return addRole(rest, store, options);
         case "list": return listRoles(rest, store);
         case "show": return showRole(rest, store);
+        case "context": return roleContext(rest, store, options);
         case "update": return updateRole(rest, store, options);
         case "remove": return removeRole(rest, store);
         case "bind": return bindRole(rest, store);
@@ -26,6 +27,75 @@ export function runGlobalRoleCommand(args, store, options = {}) {
                 : `Unknown command: role ${command}`);
     }
 }
+function roleContext(args, store, options) {
+    const [rawName, ...rest] = args;
+    const name = roleName(rawName);
+    assertNoArguments(rest, "Role context usage: yui role context <role>");
+    const environment = options.env ?? process.env;
+    if (environment.YUI_SESSION_SCOPE !== undefined) {
+        if (environment.YUI_SESSION_SCOPE !== "global" || environment.YUI_ROLE !== name) {
+            throw usageError("Managed GlobalRole context is outside the exact Session authority.");
+        }
+        if (environment.YUI_SESSION_MANIFEST === undefined
+            || environment.YUI_SESSION_CLI === undefined) {
+            throw usageError("Managed GlobalRole context requires the exact Session Manifest and CLI.");
+        }
+    }
+    const role = requireRole(name, store);
+    const binding = activeRoleAgentBinding(role);
+    const effective = resolveEffectiveLaunch({ role, purpose: "execution" });
+    const sessions = store.getGlobalRoleSessionSet(name);
+    const session = sessions?.sessions[role.activeAgentId];
+    const context = Object.freeze({
+        schemaVersion: 1,
+        protocol: "yui-managed-context/v1",
+        identity: {
+            scope: "global",
+            roleName: role.name,
+            roleKind: role.name === "operator" ? "operator" : "global",
+            agentId: binding.agentId,
+            adapterId: binding.adapterId,
+            workspace: role.workspace,
+            effectiveRevision: role.launchRevision,
+            ...(session?.nativeSessionId === undefined
+                ? {}
+                : { nativeSessionId: session.nativeSessionId })
+        },
+        profile: {
+            description: role.description,
+            responsibilities: role.responsibilities ?? [],
+            constraints: role.constraints ?? [],
+            expectedOutput: role.expectedOutput,
+            skillIds: [
+                "yui-runtime",
+                ...(role.name === "operator" ? ["yui-operator"] : []),
+                ...(role.skills ?? [])
+            ]
+        },
+        authority: {
+            view: role.name === "operator" ? "operator" : "global",
+            taskImplementation: false,
+            writableProjectIds: effective.writeProjectIds,
+            allowedActions: role.name === "operator"
+                ? ["route-request", "inspect-catalog", "answer-user-boundary"]
+                : ["perform-global-role-request"]
+        },
+        sessionManifestPath: environment.YUI_SESSION_MANIFEST,
+        sessionCliPath: environment.YUI_SESSION_CLI
+    });
+    if (options.jsonOutput === true)
+        return `${JSON.stringify(context)}\n`;
+    return [
+        `Role Context: ${role.name}`,
+        `Scope: global (${context.identity.roleKind})`,
+        `Agent: ${binding.agentId}/${binding.adapterId}`,
+        `Workspace: ${role.workspace}`,
+        `Effective revision: ${role.launchRevision}`,
+        `Skills: ${context.profile.skillIds.join(", ") || "none"}`,
+        `Authority: ${context.authority.view}; Task implementation: no`,
+        ""
+    ].join("\n");
+}
 function addRole(args, store, options) {
     const [rawName, ...tail] = args;
     const name = roleName(rawName);

package/dist/commands/taskActor.js

@@ -1,6 +1,7 @@
 import { usageError } from "../errors/cliError.js";
 import { activeRoleAgentBinding } from "../role/role.js";
 import { formatAgentRunReceiptId } from "../task/taskRecordReference.js";
+import { agentRunDeliveryReceiptId } from "../run/agentRun.js";
 const LEADER_ROLE = "leader";
 const LEADER_ACTION_RUN_ENV = "YUI_LEADER_ACTION_RUN_ID";
 const LEADER_ACTION_RECEIPT_ENV = "YUI_LEADER_ACTION_RECEIPT_ID";
@@ -152,7 +153,7 @@ function activeLeaderRunId(store, taskId) {
         return undefined;
     }
     const sessions = store.getTaskRoleSessionSet(taskId, LEADER_ROLE);
-    const expectedReceipt = formatAgentRunReceiptId(taskId, run.id);
+    const expectedReceipt = agentRunDeliveryReceiptId(run);
     if (sessions === null
         || sessions.inFlight === null
         || sessions.inFlight.runId !== run.id
@@ -223,7 +224,7 @@ export function taskLeaderActionRunId(store, taskId, environment, yuiHome) {
         || sessions.inFlight === null
         || sessions.inFlight.runId !== runId
         || sessions.inFlight.agentId !== agentId
-        || sessions.inFlight.receiptId !== formatAgentRunReceiptId(taskId, runId))
+        || sessions.inFlight.receiptId !== agentRunDeliveryReceiptId(run))
         return undefined;
     if (explicitAssertion !== undefined
         && explicitAssertion.receiptId !== formatAgentRunReceiptId(taskId, runId))

package/dist/commands/taskCommands.js

@@ -1,5 +1,8 @@
+import { createHash } from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
-import { compileDispatchInput, ensureWorkerRunCompletionRequirement } from "../context/dispatchContext.js";
+import { createRunAssignment } from "../context/runContextContract.js";
+import { buildRunContextPack, buildRunContextDelta, contextSnapshotDeltaRefIds, expandRunContextRef, freezeRunContextSnapshot } from "../context/runContextPack.js";
+import { contextSnapshotRef } from "../context/contextSnapshot.js";
 import { CliError, dataError, roleNotFound, runtimeError, taskNotFound, usageError } from "../errors/cliError.js";
 import { createTaskEvent } from "../event/taskEvent.js";
 import { clearMatchingLeaderStallAttention, isRoleRunStalled, RUN_PROGRESS_EVENT, RUN_RECOVERED_EVENT } from "../scheduler/roleRunStall.js";
@@ -14,7 +17,7 @@ import { cancelInputRequest } from "../input/inputRequest.js";
 import { recoverExactAgentRun, terminalizeExactTaskRun, validateExactRunReviewRound } from "../lifecycle/exactRunTerminalization.js";
 import { resetTaskRoleSessionGeneration } from "../lifecycle/taskRoleSessionReset.js";
 import { activeRoleAgentBinding, copyGlobalRoleToTaskRole, createRole, createRoleAgentBinding, switchActiveRoleAgent, unbindRoleAgent, updateRole, updateRoleStatus } from "../role/role.js";
-import { createAgentRun } from "../run/agentRun.js";
+import { agentRunDeliveryReceiptId, createAgentRun, withAgentRunContextSnapshot } from "../run/agentRun.js";
 import { projectRunRecovery, readRunRecoveryFacts } from "../run/recoveryProjection.js";
 import { matchYieldReceipt } from "../run/yieldReceipt.js";
 import { providerRetryConfig } from "../run/providerRetryConfig.js";
@@ -22,8 +25,6 @@ import { createReviewRound, createTaskReviewRound, createTaskDeltaReviewRound, a
 import { buildDeltaRecheckDispatchContext, verifyDeltaRecheckDiff } from "../review/deltaRecheck.js";
 import { buildTaskFinalReviewFindingContext, dispositionReviewFinding, planRepairGroups, reconcileReviewFindings, reconcileReviewFindingsAfterReview } from "../review/reviewFindingLedger.js";
 import { LEADER_FINDING_DISPOSITIONS } from "../review/reviewFinding.js";
-import { markYuiRunInput, retagYuiRunInput } from "../run/runIdentity.js";
-import { taskRoleSessionTitle } from "../runtime/sessionTitle.js";
 import { createTaskBrief, updateTaskBrief } from "../brief/taskBrief.js";
 import { createDecision, supersedeDecision } from "../decision/decision.js";
 import { createMilestone } from "../milestone/milestone.js";
@@ -34,7 +35,7 @@ import { RUNTIME_CLEANUP_REQUIRED_REASON, runtimeLifecycleTarget } from "../runt
 import { blockingProviderContinuations, projectProviderContinuations } from "../runtime/runtimeContinuationProjection.js";
 import { runtimeObservationFromTaskEvent } from "../runtime/runtimeObservation.js";
 import { activateTask, addTaskProjectBinding, archiveTask, completeTask, createTask, retireTask, reopenTask, updateTaskMetadata } from "../task/task.js";
-import { formatAgentRunReceiptId, resolveTaskRecordReference } from "../task/taskRecordReference.js";
+import { resolveTaskRecordReference } from "../task/taskRecordReference.js";
 import { projectCompletionReadiness } from "../task/completionReadiness.js";
 import { resolveProject } from "../repository/project.js";
 import { acquireProjectMaintenanceLocks } from "../repository/projectMaintenanceLock.js";
@@ -683,7 +684,7 @@ function completeTaskCommand(args, store, options) {
                 roleName: LEADER_ROLE,
                 agentId: leaderEntry.run.effective.agentId,
                 runId: leaderEntry.run.id,
-                receiptId: formatAgentRunReceiptId(task.id, leaderEntry.run.id),
+                receiptId: agentRunDeliveryReceiptId(leaderEntry.run),
                 outcome: { status: "yielded", summary }
             }, now);
             if (terminal.disposition !== "applied") {
@@ -923,7 +924,7 @@ function retireTaskCommand(args, store, options) {
                 roleName: run.roleName,
                 agentId: run.effective.agentId,
                 runId: run.id,
-                receiptId: formatAgentRunReceiptId(task.id, run.id),
+                receiptId: agentRunDeliveryReceiptId(run),
                 mailboxDisposition: "discard",
                 outcome: {
                     status: "failed",
@@ -1964,15 +1965,21 @@ function dispatchWork(args, store, options) {
                     workspace: laneWorkspace
                 }, now);
             runningGroup = runningLane;
-            const input = markYuiRunInput(compileDispatchInput({}, task.id, plan.role, `${rawInput}\nExecution Group ${group.id}; Lane ${lane.id}; frozen target ${group.target.fingerprint}.`, {
-                workItem: item,
-                projectPolicy: task.projectBindings.map(({ projectId, directory }) => ({
-                    projectId,
-                    directory
-                })),
-                ...(laneManagedWorkspace === undefined ? {} : { workspace: laneManagedWorkspace })
-            }), plan.runId, taskRoleSessionTitle(task, plan.role.name));
-            createdRuns.push(createAgentRun(plan.runId, task.id, plan.role.name, dispatchMode, input, now, {
+            const assignment = createRunAssignment({
+                runId: plan.runId,
+                roleName: plan.role.name,
+                purpose: "execution",
+                action: item.status === "failed" ? "repair-work-item" : "execute-work-item",
+                subject: {
+                    taskId: task.id,
+                    workItemId: item.id,
+                    executionGroupId: runningGroup.id,
+                    executionLaneId: lane.id
+                },
+                directive: `${rawInput}\nFrozen target: ${group.target.fingerprint}.`,
+                deltaRefIds: []
+            });
+            createdRuns.push(createAgentRun(plan.runId, task.id, plan.role.name, dispatchMode, assignment, now, {
                 workItemId: item.id,
                 executionGroupId: runningGroup.id,
                 executionLaneId: lane.id,
@@ -2028,7 +2035,15 @@ function dispatchWork(args, store, options) {
             }
         }
         for (let index = 0; index < createdRuns.length; index += 1) {
-            const runWithLineage = createdRuns[index];
+            const unboundRun = createdRuns[index];
+            const snapshot = freezeRunContextSnapshot(tx, {
+                taskId: task.id,
+                roleName: unboundRun.roleName,
+                purpose: "execution",
+                workItemId: item.id
+            }, now);
+            const runWithLineage = withAgentRunContextSnapshot(unboundRun, contextSnapshotRef(snapshot), contextSnapshotDeltaRefIds(tx, snapshot));
+            createdRuns[index] = runWithLineage;
             const role = plans[index].role;
             tx.saveAgentRun(runWithLineage);
             tx.saveActiveAgentRun(runWithLineage);
@@ -2404,7 +2419,7 @@ function retireWork(args, store, options) {
                 roleName: run.roleName,
                 agentId: run.effective.agentId,
                 runId: run.id,
-                receiptId: formatAgentRunReceiptId(task.id, run.id),
+                receiptId: agentRunDeliveryReceiptId(run),
                 outcome: {
                     status: "failed",
                     summary: `Work Item retired: ${summary}`
@@ -3217,6 +3232,8 @@ function taskRunCommand(args, store, options) {
         return output(listRuns(rest, store, options));
     if (command === "show")
         return showRun(rest, store, options);
+    if (command === "context")
+        return runContextCommand(rest, store, options);
     if (command === "retry")
         return retryRun(rest, store, options);
     if (command === "settle")
@@ -3233,6 +3250,70 @@ function taskRunCommand(args, store, options) {
         ? "Task run command is required."
         : `Unknown command: task run ${command}`);
 }
+function runContextCommand(args, store, options) {
+    const [first, ...rest] = args;
+    if (first === "expand") {
+        if (rest.length < 2 || rest.length > 4 || (rest.length > 2
+            && !(rest.length === 4 && rest[2] === "--mode" && rest[3] === "full"))) {
+            throw usageError("Task run context expand usage: yui task run context expand <task>/<run> <ref-id> [--mode full].");
+        }
+        const { taskId, runId } = parseRunContextReference(rest[0]);
+        authorizeRunContext(store, taskId, runId, options.environment);
+        const expanded = store.transaction((tx) => expandRunContextRef(tx, taskId, runId, rest[1]));
+        return output(`${JSON.stringify(expanded, null, 2)}\n`, { context: expanded });
+    }
+    if (first === "delta") {
+        if (rest.length !== 3 || rest[1] !== "--after") {
+            throw usageError("Task run context delta usage: yui task run context delta <task>/<run> --after <cursor>.");
+        }
+        const { taskId, runId } = parseRunContextReference(rest[0]);
+        authorizeRunContext(store, taskId, runId, options.environment);
+        const delta = store.transaction((tx) => (buildRunContextDelta(tx, taskId, runId, rest[2])));
+        return output(`${JSON.stringify(delta, null, 2)}\n`, { contextDelta: delta });
+    }
+    if (first === undefined || rest.length !== 0) {
+        throw usageError("Task run context usage: yui task run context <task>/<run>.");
+    }
+    const { taskId, runId } = parseRunContextReference(first);
+    authorizeRunContext(store, taskId, runId, options.environment);
+    const pack = store.transaction((tx) => buildRunContextPack(tx, taskId, runId));
+    return output(`${JSON.stringify(pack, null, 2)}\n`, { context: pack });
+}
+function parseRunContextReference(value) {
+    const [taskId, runId, extra] = value.split("/");
+    if (taskId === undefined || taskId.length === 0 || runId === undefined || runId.length === 0
+        || extra !== undefined) {
+        throw usageError(`Run context reference is invalid: ${value}.`);
+    }
+    return { taskId, runId };
+}
+function authorizeRunContext(store, taskId, runId, environment) {
+    const managed = environment?.YUI_SESSION_SCOPE !== undefined
+        || environment?.YUI_TASK_ID !== undefined
+        || environment?.YUI_ROLE !== undefined
+        || environment?.YUI_RUN_ID !== undefined;
+    if (!managed)
+        return;
+    const run = store.getAgentRun(taskId, runId);
+    const active = run === null ? null : store.getActiveAgentRun(taskId, run.roleName);
+    if (environment?.YUI_SESSION_SCOPE !== "task"
+        || environment.YUI_TASK_ID !== taskId
+        || run === null
+        || environment.YUI_ROLE !== run.roleName
+        || environment.YUI_AGENT_ID !== run.effective.agentId
+        || environment.YUI_ADAPTER_ID !== run.effective.adapterId
+        || run.status !== "active"
+        || active?.id !== runId) {
+        throw usageError(`Run Context access is not authorized: ${taskId}/${runId}.`);
+    }
+    const callerKey = environment.YUI_JOB_CALLER_KEY;
+    const expectedCallerKeyHash = store.getJobCallerKeyHash(taskId, run.roleName, run.effective.agentId);
+    if (callerKey === undefined
+        || expectedCallerKeyHash === null
+        || createHash("sha256").update(callerKey).digest("hex") !== expectedCallerKeyHash) {
+        throw usageError(`Run Context caller key is not authorized: ${taskId}/${runId}.`);
+    }
+}
 function listRuns(args, store, options) {
     exactPositionals(args, 1, "Task run list usage: yui task run list <task>/<work>.");
     const item = requireWorkItem(store, args[0], options);
@@ -3505,18 +3586,6 @@ function retryRun(args, store, options) {
             : laneRestartedItem.status === "failed"
                 ? retryFailedWorkItem(laneRestartedItem, now)
                 : laneRestartedItem;
-        const retaggedInput = retagYuiRunInput(previous.input, runId, taskRoleSessionTitle(task, role.name));
-        const created = createAgentRun(runId, task.id, role.name, roleAgentSessionResumeMode(sessions, effective.agentId, effective), previous.workItemId === undefined
-            ? retaggedInput
-            : ensureWorkerRunCompletionRequirement(retaggedInput), now, {
-            ...(previous.workItemId === undefined ? {} : { workItemId: previous.workItemId }),
-            ...(runningGroup === undefined ? {} : {
-                executionGroupId: runningGroup.id,
-                executionLaneId: retryLane.id
-            }),
-            ...(retryManagedWorkspace === undefined ? {} : { workspace: retryManagedWorkspace }),
-            effective
-        });
         if (retriedItemWithGroup !== null) {
             if (laneRestartedItem !== null && laneRestartedItem !== retryItem) {
                 tx.saveWorkItem(task.id, laneRestartedItem);
@@ -3525,6 +3594,40 @@ function retryRun(args, store, options) {
                 tx.saveWorkItem(task.id, retriedItemWithGroup);
             }
         }
+        const retrySnapshot = freezeRunContextSnapshot(tx, {
+            taskId: task.id,
+            roleName: role.name,
+            purpose: "execution",
+            ...(previous.workItemId === undefined ? {} : { workItemId: previous.workItemId })
+        }, now);
+        const assignment = createRunAssignment({
+            runId,
+            roleName: role.name,
+            purpose: previous.assignment.purpose,
+            action: previous.workItemId === undefined ? previous.assignment.action : "repair-work-item",
+            subject: {
+                taskId: task.id,
+                ...(previous.workItemId === undefined ? {} : { workItemId: previous.workItemId }),
+                ...(runningGroup === undefined ? {} : {
+                    executionGroupId: runningGroup.id,
+                    executionLaneId: retryLane.id
+                })
+            },
+            ...(previous.assignment.directive === undefined
+                ? {}
+                : { directive: previous.assignment.directive }),
+            contextSnapshotRef: contextSnapshotRef(retrySnapshot),
+            deltaRefIds: contextSnapshotDeltaRefIds(tx, retrySnapshot)
+        });
+        const created = createAgentRun(runId, task.id, role.name, roleAgentSessionResumeMode(sessions, effective.agentId, effective), assignment, now, {
+            ...(previous.workItemId === undefined ? {} : { workItemId: previous.workItemId }),
+            ...(runningGroup === undefined ? {} : {
+                executionGroupId: runningGroup.id,
+                executionLaneId: retryLane.id
+            }),
+            ...(retryManagedWorkspace === undefined ? {} : { workspace: retryManagedWorkspace }),
+            effective
+        });
         tx.saveAgentRun(created);
         tx.saveActiveAgentRun(created);
         tx.saveRole(task.id, updateRoleStatus(role, "running", now));
@@ -4448,7 +4551,7 @@ function yieldRun(args, store, options) {
             roleName: role.name,
             agentId: active.effective.agentId,
             runId: active.id,
-            receiptId: formatAgentRunReceiptId(task.id, active.id),
+            receiptId: agentRunDeliveryReceiptId(active),
             ...(active.purpose !== "review" || options.environment?.YUI_NATIVE_SESSION_ID === undefined
                 ? {}
                 : { nativeSessionId: options.environment.YUI_NATIVE_SESSION_ID }),
@@ -5035,14 +5138,21 @@ export function dispatchPreparedReviewRound(taskId, reviewRoundId, store, option
                         .filter(({ access }) => access === "write")
                         .map(({ projectId }) => projectId)
                 };
-            const input = markYuiRunInput(compileDispatchInput({}, taskId, laneReviewer, `${rawInput}\nReviewer Lane ${lane.id}; frozen target ${runningGroup.target.fingerprint}.`, {
-                workItem: item,
-                projectPolicy: task.projectBindings.map(({ projectId, directory }) => ({
-                    projectId,
-                    directory
-                })),
-                workspace: laneManagedWorkspace ?? round.workspace
-            }), runId, taskRoleSessionTitle(task, laneReviewer.name));
+            const assignment = createRunAssignment({
+                runId,
+                roleName: laneReviewer.name,
+                purpose: "review",
+                action: "review-round",
+                subject: {
+                    taskId,
+                    workItemId: item.id,
+                    reviewRoundId: round.id,
+                    executionGroupId: runningGroup.id,
+                    executionLaneId: lane.id
+                },
+                directive: `${rawInput}\nFrozen target: ${runningGroup.target.fingerprint}.`,
+                deltaRefIds: []
+            });
             runningGroup = updateExecutionLane(runningGroup, lane.id, {
                 status: "running",
                 runId,
@@ -5050,7 +5160,7 @@ export function dispatchPreparedReviewRound(taskId, reviewRoundId, store, option
                 effective,
                 workspace: laneWorkspace
             }, now);
-            createdRuns.push(createAgentRun(runId, taskId, laneReviewer.name, roleAgentSessionResumeMode(sessions, effective.agentId, effective), input, now, {
+            createdRuns.push(createAgentRun(runId, taskId, laneReviewer.name, roleAgentSessionResumeMode(sessions, effective.agentId, effective), assignment, now, {
                 workItemId: item.id,
                 purpose: "review",
                 reviewRoundId: round.id,
@@ -5083,7 +5193,16 @@ export function dispatchPreparedReviewRound(taskId, reviewRoundId, store, option
             }
         }
         for (let index = 0; index < createdRuns.length; index += 1) {
-            const created = createdRuns[index];
+            const unboundRun = createdRuns[index];
+            const snapshot = freezeRunContextSnapshot(tx, {
+                taskId,
+                roleName: unboundRun.roleName,
+                purpose: "review",
+                workItemId: item.id,
+                reviewRoundId: round.id
+            }, now);
+            const created = withAgentRunContextSnapshot(unboundRun, contextSnapshotRef(snapshot), contextSnapshotDeltaRefIds(tx, snapshot));
+            createdRuns[index] = created;
             const laneReviewer = reviewers[index];
             tx.saveAgentRun(created);
             tx.saveActiveAgentRun(created);

package/dist/commands/taskContextCommand.js

@@ -247,7 +247,7 @@ export function runTaskContextCommand(args, store) {
                         ? ["    AgentRuns: none."]
                         : [
                             `    AgentRuns: ${itemRuns.length}; latest ${latestRun.id} [${latestRun.status}] ${latestRun.effective.agentId}/${latestRun.effective.adapterId} · effective r${latestRun.effective.sourceDesiredRevision}/${latestRun.effective.profileAccess}/${latestRun.effective.permission.strategy}`,
-                            `      Input: ${compactText(latestRun.input)}`,
+                            `      Assignment: ${latestRun.assignment.action}${latestRun.assignment.directive === undefined ? "" : ` · ${compactText(latestRun.assignment.directive)}`}`,
                             ...(latestRun.summary === undefined
                                 ? []
                                 : [`      Summary: ${compactText(latestRun.summary)}`])

package/dist/commands/taskInputCommands.js

@@ -4,10 +4,11 @@ import { activeLiveRoleAgentSession } from "../executor/agentExecutor.js";
 import { answerInputRequest, cancelInputRequest, createInputRequest } from "../input/inputRequest.js";
 import { defaultTableWidth, renderTable } from "../output/table.js";
 import { formatTimestamp } from "../output/timePresentation.js";
+import { agentRunDeliveryReceiptId } from "../run/agentRun.js";
 import { enqueueWork } from "../coordination/workMailboxQueue.js";
 import { clearMatchingLeaderStallAttention, isRoleRunStalled, RUN_RECOVERED_EVENT } from "../scheduler/roleRunStall.js";
 import { terminalizeExactTaskRun } from "../lifecycle/exactRunTerminalization.js";
-import { formatAgentRunReceiptId, resolveTaskRecordReference } from "../task/taskRecordReference.js";
+import { resolveTaskRecordReference } from "../task/taskRecordReference.js";
 const LEADER_ROLE = "leader";
 export function runTaskInputCommand(args, store, options) {
     const [command, ...rest] = args;
@@ -71,7 +72,7 @@ function createRequest(args, store, options) {
             roleName: LEADER_ROLE,
             agentId: origin.run.effective.agentId,
             runId: origin.run.id,
-            receiptId: formatAgentRunReceiptId(task.id, origin.run.id),
+            receiptId: agentRunDeliveryReceiptId(origin.run),
             ...(origin.requester.nativeSessionId === undefined
                 ? {}
                 : { nativeSessionId: origin.requester.nativeSessionId }),

package/dist/commands/taskRoleRuntimeStatus.js

@@ -1,11 +1,11 @@
 import { isDeepStrictEqual } from "node:util";
+import { agentRunDeliveryReceiptId } from "../run/agentRun.js";
 import { hasRuntimeCleanupObligation, hasRuntimeLifecycleWork, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
 import { isRoleRunStalled, latestStallProgressAt } from "../scheduler/roleRunStall.js";
 import { createRuntimeObservation, runtimeObservationFromTaskEvent } from "../runtime/runtimeObservation.js";
 import { classifyRuntimeHealth, projectRuntimeMailbox, projectRuntimeObservation, projectRuntimeTaskEvents, runtimeDisplayStatus } from "../runtime/runtimeProjection.js";
 import { latestRunDurableProgressAt } from "../scheduler/roleRunStall.js";
 import { builtinDriverIdForAdapter } from "../runtime/builtinAgentDrivers.js";
-import { formatAgentRunReceiptId } from "../task/taskRecordReference.js";
 export function inspectTaskRoleRuntimeStatuses(taskId, roles, store, panes, now = new Date()) {
     const taskOpenInputRequestCount = store.listInputRequests(taskId)
         .filter((request) => request.status === "open").length;
@@ -372,9 +372,9 @@ function projectTaskRoleRuntime(run, session, tmux, events, mailbox, store, task
             driverId,
             launchId: session.launchId,
             nativeSessionId: session.nativeSessionId,
-            receiptId: formatAgentRunReceiptId(run.taskId, run.id)
+            receiptId: agentRunDeliveryReceiptId(run)
         }) ?? run.id,
-        receiptId: formatAgentRunReceiptId(run.taskId, run.id)
+        receiptId: agentRunDeliveryReceiptId(run)
     };
     let projection = projectRuntimeTaskEvents(fence, run.createdAt, events);
     projection = projectRuntimeMailbox(projection, mailbox);