@zq-silk/yui 0.8.3 → 0.8.7

package/dist/cli.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { readFileSync } from "node:fs";
-import { resolve } from "node:path";
+import { join, resolve } from "node:path";
 import { createInterface } from "node:readline/promises";
 import { fileURLToPath } from "node:url";
 import { isDeepStrictEqual } from "node:util";
@@ -36,8 +36,9 @@ import { runResourcesCommand } from "./commands/resourcesCommands.js";
 import { applyOperatorSessionControl, runOperatorCommand } from "./commands/operatorCommands.js";
 import { runProjectCommand } from "./commands/projectCommands.js";
 import { runProfileCommand } from "./commands/profileCommands.js";
-import { dispatchPreparedReviewRound, failPendingReviewRound, RESUMED_PENDING_FINAL_REVIEW, TERMINALIZED_LEADER_BEFORE_FINAL_REVIEW, TaskFinalReviewDispatchDriftError, preserveReviewRoundWorkspace, parseTaskCompletionRequest, preflightTaskCompletion, runTaskCommand, normalizedExecutionLanePlan, validateTaskArchiveRequest } from "./commands/taskCommands.js";
+import { dispatchPreparedReviewRound, failPendingReviewRound, RESUMED_PENDING_FINAL_REVIEW, TERMINALIZED_LEADER_BEFORE_FINAL_REVIEW, TaskFinalReviewDispatchDriftError, preserveReviewRoundWorkspace, parseTaskCompletionRequest, parseTaskFinalReviewContractRebindRequest, preflightTaskCompletion, runTaskCommand, normalizedExecutionLanePlan, validateTaskArchiveRequest } from "./commands/taskCommands.js";
 import { taskActor } from "./commands/taskActor.js";
+import { isCurrentGlobalOperator } from "./commands/taskInputCommands.js";
 import { runTaskIntegrationCommand } from "./commands/taskIntegrationCommands.js";
 import { runTaskChangeSetCommand } from "./commands/taskChangeSetCommands.js";
 import { runTaskOverlapCommand } from "./commands/taskOverlapCommands.js";
@@ -46,7 +47,7 @@ import { runTaskWorkspaceCommand } from "./commands/taskWorkspaceCommands.js";
 import { runWorkflowCommandAsync } from "./commands/workflowCommands.js";
 import { createUpdatePorts } from "./cli/updatePorts.js";
 import { createReleaseWorkflowPorts } from "./release/releaseWorkflowPorts.js";
-import { readRuntimeIdentity } from "./release/runtimeRelease.js";
+import { acquireHandoverLock, readRuntimeIdentity } from "./release/runtimeRelease.js";
 import { renderReleaseActivateResult, renderReleaseInstallResult, renderReleaseList, runReleaseActivate, runReleaseInstall, runReleaseList } from "./commands/releaseCommands.js";
 import { reconcileTaskRemoteBaselines, verifyTaskCompletionPublishedTree } from "./commands/taskCompletionGate.js";
 import { runTaskBaseStatusCommand } from "./commands/taskBaseCommands.js";
@@ -80,9 +81,11 @@ import { AgentConfigurationCatalogService } from "./executor/agentConfigurationC
 import { TmuxWebTerminalService } from "./web/tmuxWebTerminal.js";
 import { listOperatorSessions, operatorSessionRef } from "./operator/operatorSessionHistory.js";
 import { YUI_VERSION, yuiVersionIdentity } from "./version.js";
-import { YUI_CONTROL_PLANE_DESCRIPTOR, YUI_TASK_RUNTIME_DESCRIPTOR, assertExactControlPlanePreflight, assertExactTaskRuntimeEnvironment, assertExactTaskRuntimeState, exactControlPlaneDigest, extractExactControlArgument, parseExactControlPlaneDescriptor } from "./runtime/exactControlPlane.js";
+import { YUI_CONTROL_PLANE_DESCRIPTOR, YUI_TASK_RUNTIME_DESCRIPTOR, assertCompatibleControlPlanePreflight, assertExactControlPlanePreflight, assertExactTaskRuntimeEnvironment, assertExactTaskRuntimeState, exactControlPlaneDigest, extractExactControlArgument, createExactControlPlaneDescriptor, parseExactControlPlaneDescriptor } from "./runtime/exactControlPlane.js";
+import { readSessionBootstrapManifest, refreshManagedSessionCliWrappers } from "./context/sessionBootstrapManifest.js";
 import { builtinAgentDriverRegistry } from "./runtime/builtinAgentDrivers.js";
 import { createTaskFinalReviewContract, extractTaskFinalReviewRequest } from "./review/taskFinalReviewContract.js";
+import { prepareTaskFinalReviewContractRebindProof, resolveRecordedTaskFinalReviewContract } from "./review/taskFinalReviewContractRebind.js";
 import { assessDeltaRecheck } from "./review/deltaRecheck.js";
 import { deltaRecheckEnabled } from "./review/reviewConfig.js";
 import { NodeGitWorkspace } from "./repository/gitWorkspace.js";
@@ -109,7 +112,7 @@ void main().catch((error) => {
     process.exitCode = 5;
 });
 export async function main() {
-    const { contract: taskFinalReviewContract, verifiedStore } = await preflightManagedTaskControlPlane();
+    const { contract: taskFinalReviewContract, verifiedStore, controlPlane: exactCurrentControlPlane } = await preflightManagedTaskControlPlane();
     if (args.length === 0) {
         emit(renderCommandHelp((await import("./cli/commandCatalog.js")).ROOT_COMMAND, VERSION));
         return;
@@ -261,6 +264,16 @@ export async function main() {
         return;
     }
     if (args[0] === "internal") {
+        if (args[1] === "session-cli-refresh" && args.length === 2) {
+            if (process.env.YUI_SESSION_SCOPE === "task"
+                || (process.env.YUI_SESSION_SCOPE === "global" && process.env.YUI_ROLE !== "operator")) {
+                throw usageError("Managed Session CLI refresh may be run only by the user or global Operator.");
+            }
+            const result = refreshManagedSessionCliWrappers(home);
+            emit(`Refreshed ${result.refreshed} legacy Session CLI wrapper(s); `
+                + `${result.current} already current, ${result.skipped} skipped.`, false, result);
+            return;
+        }
         if (args[1] === "agent-host" && args.length === 4) {
             process.exitCode = await runAgentHost({
                 home,
@@ -988,6 +1001,59 @@ export async function main() {
                 }
             }
         }
+        let taskFinalReviewRebindProof;
+        let taskFinalReviewRebindRequest;
+        let releaseTaskFinalReviewHandoverLock;
+        if (resolved[1] === "review" && resolved[2] === "rebind") {
+            if (!isCurrentGlobalOperator(store, process.env)) {
+                throw usageError("Task-final Review contract rebind requires the authenticated global Operator session.");
+            }
+            if (exactCurrentControlPlane === undefined) {
+                throw usageError("Task-final Review contract rebind requires the exact current global Session CLI.");
+            }
+            taskFinalReviewRebindRequest = parseTaskFinalReviewContractRebindRequest(resolved.slice(3));
+        }
+        if ((resolved[1] === "review"
+            && ["request", "force-fresh", "retry", "rebind"].includes(resolved[2] ?? ""))
+            || resolved[1] === "complete") {
+            const handoverLock = acquireHandoverLock(home);
+            releaseTaskFinalReviewHandoverLock = handoverLock.release;
+        }
+        if (taskFinalReviewRebindRequest !== undefined) {
+            const request = taskFinalReviewRebindRequest;
+            try {
+                taskFinalReviewRebindProof = prepareTaskFinalReviewContractRebindProof({
+                    home,
+                    taskId: request.taskId,
+                    fromControlPlaneDigest: request.fromControlPlaneDigest,
+                    toControlPlaneDigest: request.toControlPlaneDigest,
+                    fromReleaseId: request.fromReleaseId,
+                    toReleaseId: request.toReleaseId,
+                    currentControlPlane: exactCurrentControlPlane.descriptor
+                });
+                const workItems = store.listWorkItems(request.taskId);
+                const reviewRounds = store.listReviewRounds(request.taskId);
+                const resolution = resolveRecordedTaskFinalReviewContract(request.taskId, workItems, reviewRounds, store.listEvents(request.taskId));
+                const activeRound = reviewRounds.find((round) => ((round.scope ?? "work-item") === "task"
+                    && (round.status === "pending" || round.status === "running")));
+                // An exact replay is a true no-op, even when the target Leader is live.
+                // Invalid/stale source tuples also reach the command unchanged so its
+                // transactional diagnosis cannot stop a healthy target runtime.
+                if (resolution?.effective.controlPlaneDigest === request.fromControlPlaneDigest
+                    && activeRound === undefined) {
+                    // The contract event and wake must never target a Provider
+                    // Conversation launched by the source release. Active Runs fail
+                    // closed; otherwise stop and retire that runtime under the handover
+                    // lock before the transactional event+wake commit.
+                    await workspaceCoordinator.cleanupTaskRoleRuntime(request.taskId, "leader");
+                }
+            }
+            catch (error) {
+                releaseTaskFinalReviewHandoverLock();
+                releaseTaskFinalReviewHandoverLock = undefined;
+                throw error;
+            }
+        }
         let candidateMaterialization;
         let candidateMaterializationCommitted = false;
         try {
@@ -1002,7 +1068,7 @@ export async function main() {
                 ? await candidateSnapshotForTaskCommand(resolved, store, workspacePreparer, process.env, taskFinalReviewContract)
                 : candidateMaterialization.snapshot;
             const directTaskMainSnapshot = await directTaskMainSnapshotForTaskCommand(resolved, store, workspacePreparer, process.env, taskFinalReviewContract);
-            const actualTaskReviewCandidate = await actualTaskReviewCandidateForTaskCommand(resolved, store, workspacePreparer, process.env, taskFinalReviewContract);
+            const actualTaskReviewCandidate = await actualTaskReviewCandidateForTaskCommand(resolved, store, workspacePreparer, process.env);
             const deltaRecheckPreflight = await deltaRecheckPreflightForTaskCommand(resolved.slice(1), store, actualTaskReviewCandidate);
             const reviewWorkspaceResult = await reviewWorkspaceResultForTaskCommand(resolved, store, workspacePreparer, process.env);
             const executionLaneGitSnapshot = await executionLaneGitSnapshotForTaskCommand(resolved, store, workspacePreparer, process.env);
@@ -1016,6 +1082,9 @@ export async function main() {
                 ...(taskFinalReviewContract === undefined
                     ? {}
                     : { taskFinalReviewContract }),
+                ...(taskFinalReviewRebindProof === undefined
+                    ? {}
+                    : { taskFinalReviewRebindProof }),
                 ...(completionSummary === undefined ? {} : { completionSummary }),
                 ...(completionPublishedTreeProof === undefined
                     ? {}
@@ -1260,6 +1329,12 @@ export async function main() {
             }
             throw error;
         }
+        finally {
+            if (releaseTaskFinalReviewHandoverLock !== undefined) {
+                releaseTaskFinalReviewHandoverLock();
+                releaseTaskFinalReviewHandoverLock = undefined;
+            }
+        }
     }
     if (resolved[0] === "jobs") {
         emit(runJobCommand(resolved.slice(1), store, { runtime }));
@@ -1299,13 +1374,14 @@ async function preflightManagedTaskControlPlane() {
         throw new Error("Exact control-plane invocation requires both frozen descriptors in a managed Task runtime.");
     }
     if (!exactRuntime) {
-        if (exactControlInvocation.digest !== undefined) {
-            throw new Error("Exact Task control-plane invocation requires its frozen runtime descriptors.");
+        if (exactControlInvocation.digest !== undefined
+            || process.env.YUI_SESSION_SCOPE === "global") {
+            return await preflightManagedGlobalControlPlane(exactControlInvocation.digest);
         }
         if (taskFinalReviewInvocation.request !== undefined) {
             throw new Error("Task final-review contract requires a verified exact Task control-plane invocation.");
         }
-        return { contract: undefined, verifiedStore: undefined };
+        return { contract: undefined, controlPlane: undefined, verifiedStore: undefined };
     }
     if (process.env.YUI_SESSION_SCOPE !== "task") {
         throw new Error("Exact Task control-plane invocation requires a managed Task runtime.");
@@ -1314,24 +1390,42 @@ async function preflightManagedTaskControlPlane() {
         throw new Error("Exact control-plane invocation is required for this managed Task runtime.");
     }
     const control = parseExactControlPlaneDescriptor(serializedControl);
-    const internalCallback = args[0] === "internal";
-    if (!internalCallback && exactControlInvocation.digest === undefined) {
-        throw new Error("Exact control-plane invocation is required; bare `yui` and PATH launchers are not valid in a managed Task runtime.");
-    }
-    const digest = exactControlInvocation.digest ?? exactControlPlaneDigest(control);
-    await assertExactControlPlanePreflight({
-        serializedDescriptor: serializedControl,
-        digest,
-        actualExecutable: process.execPath,
-        actualCliEntry: fileURLToPath(import.meta.url),
-        actualHome: resolveYuiHome(process.env)
-    }, {
-        // Provider callbacks must remain able to append their immutable inbox fact
-        // while the Controller is offline. They still validate executable, CLI,
-        // Home, build, schema, and the exact Task runtime envelope first.
-        checkController: !internalCallback
-    });
-    const runtime = assertExactTaskRuntimeEnvironment(serializedRuntime, process.env, digest, control.yuiHome);
+    const internalCallback = args[0] === "internal"
+        && ["agent-host", "session-notify", "runtime-hook"].includes(args[1] ?? "");
+    const home = resolveYuiHome(process.env);
+    assertManagedSessionManifest(home, "task");
+    if (resolve(control.yuiHome) !== resolve(home)) {
+        throw new Error("Managed Task control-plane descriptor belongs to another YUI_HOME.");
+    }
+    const frozenDigest = exactControlPlaneDigest(control);
+    const exactCommand = internalCallback || exactControlInvocation.digest !== undefined;
+    let commandControl;
+    let digest;
+    if (exactCommand) {
+        digest = exactControlInvocation.digest ?? frozenDigest;
+        await assertExactControlPlanePreflight({
+            serializedDescriptor: serializedControl,
+            digest,
+            actualExecutable: process.execPath,
+            actualCliEntry: fileURLToPath(import.meta.url),
+            actualHome: home
+        }, {
+            // Provider callbacks must remain able to append their immutable inbox fact
+            // while the Controller is offline. They still validate executable, CLI,
+            // Home, schema, and the exact Task runtime envelope first.
+            checkController: !internalCallback
+        });
+        commandControl = control;
+    }
+    else {
+        await assertCompatibleControlPlanePreflight({ actualHome: home });
+        // Package/build identity is deliberately not part of ordinary Session
+        // continuity. Keep contracts on the Session's frozen digest while the
+        // current CLI is proven protocol/storage compatible.
+        commandControl = control;
+        digest = frozenDigest;
+    }
+    const runtime = assertExactTaskRuntimeEnvironment(serializedRuntime, process.env, frozenDigest, control.yuiHome);
     const runtimeDriverCallback = args[0] === "internal"
         && args[1] === "runtime-hook"
         && process.env.YUI_DRIVER_ID !== undefined
@@ -1349,23 +1443,117 @@ async function preflightManagedTaskControlPlane() {
         }
         : {});
     const request = taskFinalReviewInvocation.request;
-    if (request === undefined)
-        return { contract: undefined, verifiedStore };
+    if (request === undefined) {
+        return {
+            contract: undefined,
+            controlPlane: { digest, descriptor: commandControl },
+            verifiedStore
+        };
+    }
     if (runtime.roleName !== "leader") {
         throw new Error("Only the exact Task Leader invocation may establish a final-review contract.");
     }
     if (request.taskId !== runtime.taskId) {
         throw new Error(`Task final-review contract Task id mismatch: expected ${runtime.taskId}, found ${request.taskId}.`);
     }
+    const recordedContract = resolveRecordedTaskFinalReviewContract(runtime.taskId, verifiedStore.listWorkItems(runtime.taskId), verifiedStore.listReviewRounds(runtime.taskId), verifiedStore.listEvents(runtime.taskId))?.effective;
+    if (recordedContract !== undefined
+        && recordedContract.reviewerRoleName !== request.reviewerRoleName) {
+        throw new Error(`Task final-review Reviewer mismatch: expected ${recordedContract.reviewerRoleName}, `
+            + `found ${request.reviewerRoleName}.`);
+    }
     return {
         contract: createTaskFinalReviewContract({
             taskId: runtime.taskId,
             reviewerRoleName: request.reviewerRoleName,
-            controlPlaneDigest: digest
+            // Once Task evidence establishes a contract, a compatible Session or
+            // CLI replacement presents that same capability. Package/build identity
+            // must not force a release rebind or invalidate delivery evidence.
+            controlPlaneDigest: recordedContract?.controlPlaneDigest ?? digest
         }),
+        controlPlane: { digest, descriptor: commandControl },
         verifiedStore
     };
 }
+async function preflightManagedGlobalControlPlane(digest) {
+    if (process.env.YUI_SESSION_SCOPE !== "global") {
+        throw new Error("Exact Task control-plane invocation requires its frozen runtime descriptors.");
+    }
+    if (taskFinalReviewInvocation.request !== undefined) {
+        throw new Error("Task final-review contract establishment requires a verified exact Task control-plane invocation.");
+    }
+    const manifestPath = process.env.YUI_SESSION_MANIFEST;
+    if (manifestPath === undefined) {
+        throw new Error("Managed global control-plane invocation requires its Session Manifest.");
+    }
+    const home = resolveYuiHome(process.env);
+    const manifest = assertManagedSessionManifest(home, "global");
+    const expectedRoleKind = process.env.YUI_ROLE === "operator" ? "operator" : "global";
+    if (manifest.owner.scope !== "global"
+        || manifest.roleKind !== expectedRoleKind) {
+        throw new Error("Managed global invocation does not match its Session Manifest.");
+    }
+    const serializedDescriptor = readFileSync(manifest.controlPlane.descriptorPath, "utf8");
+    const descriptor = parseExactControlPlaneDescriptor(serializedDescriptor);
+    if (resolve(descriptor.yuiHome) !== resolve(home)) {
+        throw new Error("Managed global control-plane descriptor belongs to another YUI_HOME.");
+    }
+    const frozenDigest = exactControlPlaneDigest(descriptor);
+    if (frozenDigest !== manifest.controlPlane.digest
+        || resolve(manifest.controlPlane.descriptorPath) !== resolve(join(descriptor.yuiHome, "runtime", "control-plane", `${frozenDigest}.json`))
+        || resolve(manifestPath) !== resolve(join(descriptor.yuiHome, "runtime", "session-manifests", `${manifest.digest}.json`))) {
+        throw new Error("Exact global Session Manifest does not match its control-plane descriptor.");
+    }
+    let commandControl;
+    let commandDigest;
+    if (digest !== undefined) {
+        await assertExactControlPlanePreflight({
+            serializedDescriptor,
+            digest,
+            actualExecutable: process.execPath,
+            actualCliEntry: fileURLToPath(import.meta.url),
+            actualHome: home
+        });
+        commandControl = descriptor;
+        commandDigest = digest;
+    }
+    else {
+        await assertCompatibleControlPlanePreflight({ actualHome: home });
+        commandControl = currentInvocationControlPlane(home);
+        commandDigest = exactControlPlaneDigest(commandControl);
+    }
+    return {
+        contract: undefined,
+        controlPlane: { digest: commandDigest, descriptor: commandControl },
+        verifiedStore: openCompatibleFileTaskStore(home)
+    };
+}
+function currentInvocationControlPlane(home) {
+    return createExactControlPlaneDescriptor({
+        executable: process.execPath,
+        cliEntry: fileURLToPath(import.meta.url),
+        yuiHome: home
+    });
+}
+function assertManagedSessionManifest(home, scope) {
+    const manifestPath = process.env.YUI_SESSION_MANIFEST;
+    if (manifestPath === undefined) {
+        throw new Error("Managed control-plane invocation requires its Session Manifest.");
+    }
+    const manifest = readSessionBootstrapManifest(manifestPath);
+    if (manifest.owner.scope !== scope) {
+        throw new Error("Managed invocation scope does not match its Session Manifest.");
+    }
+    if (scope === "task" && (manifest.owner.scope !== "task"
+        || manifest.owner.taskId !== process.env.YUI_TASK_ID)) {
+        throw new Error("Managed Task invocation does not match its Session Manifest owner.");
+    }
+    const expectedPath = resolve(home, "runtime", "session-manifests", `${manifest.digest}.json`);
+    if (resolve(manifestPath) !== expectedPath) {
+        throw new Error("Managed Session Manifest path is outside this YUI_HOME.");
+    }
+    return manifest;
+}
 function cleanupCliError(error, fallbackResource) {
     if (error instanceof WorkspaceCleanupBlockedError) {
         return usageError(error.message, undefined, cleanupBlockedDetails(error.reason, error.resource, error.retryable));
@@ -1630,6 +1818,36 @@ async function prepareReviewLaneWorkspaces(taskId, reviewRoundId, store, prepare
     return map;
 }
 async function directTaskMainSnapshotForTaskCommand(args, store, preparer, environment, taskFinalReviewContract) {
+    const deliveryOption = args.indexOf("--delivery", 3);
+    const deliveryPromotion = args[0] === "task"
+        && args[1] === "update"
+        && args[2] !== undefined
+        && (args.includes("--require-integration", 3)
+            || (deliveryOption >= 0 && args[deliveryOption + 1] === "integrated"));
+    if (deliveryPromotion) {
+        const task = store.getTask(args[2]);
+        if (task === null
+            || (task.status !== "active" && task.status !== "draft")
+            || task.requireIntegration === true
+            || task.projectBindings.length === 0) {
+            return undefined;
+        }
+        const workspace = store.getTaskWorkspace(task.id);
+        if (task.status === "draft" && workspace === null)
+            return undefined;
+        if (workspace === null
+            || workspace.owner.type !== "task"
+            || workspace.owner.taskId !== task.id) {
+            throw usageError(`Task has no authoritative main workspace: ${task.id}.`);
+        }
+        try {
+            return await preparer.snapshotDirectTaskMain(workspace, task.projectBindings.map(({ projectId }) => projectId));
+        }
+        catch (error) {
+            throw usageError(`Delivery promotion Task-main verification failed for ${task.id}: `
+                + `${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
     if (taskFinalReviewContract === undefined
         || args[0] !== "task"
         || args[1] !== "work"
@@ -1660,7 +1878,7 @@ async function directTaskMainSnapshotForTaskCommand(args, store, preparer, envir
         throw usageError(error instanceof Error ? error.message : String(error));
     }
 }
-async function actualTaskReviewCandidateForTaskCommand(args, store, preparer, environment, taskFinalReviewContract) {
+async function actualTaskReviewCandidateForTaskCommand(args, store, preparer, environment) {
     if (args[0] !== "task")
         return undefined;
     let taskId;
@@ -1669,12 +1887,9 @@ async function actualTaskReviewCandidateForTaskCommand(args, store, preparer, en
         if (task === null || task.status !== "active" || task.projectBindings.length === 0) {
             return undefined;
         }
-        const establishedFinalRound = store.listReviewRounds(task.id).some((round) => ((round.scope ?? "work-item") === "task"));
-        if (taskFinalReviewContract === undefined
-            && store.getReviewConfig()?.trigger !== "final"
-            && !establishedFinalRound) {
-            return undefined;
-        }
+        // Every Project-backed completion, including direct delivery, must freeze
+        // a clean committed Task-main snapshot. Review policy only decides whether
+        // that head also needs an independent ReviewRound.
         taskId = task.id;
     }
     else if (args[1] === "review"

package/dist/commands/executionAuditCommands.js

@@ -213,6 +213,36 @@ export function renderExecutionAudit(report, width = defaultTableWidth()) {
     else {
         lines.push("", ...sectionError("workItems", report));
     }
+    if (report.orchestration.status === "ok" && report.orchestration.data !== undefined) {
+        const orchestration = report.orchestration.data;
+        lines.push("", `Orchestration: ${orchestration.tasks.length} Task(s) · ${orchestration.advisoryCount} advisory finding(s)`);
+        if (orchestration.tasks.length > 0) {
+            lines.push(renderTable("Task orchestration metrics", [
+                { header: "Task", minWidth: 7, maxWidth: 14 },
+                { header: "Delivery", minWidth: 8, maxWidth: 10 },
+                { header: "Runs", minWidth: 4, maxWidth: 6 },
+                { header: "WIs", minWidth: 3, maxWidth: 5 },
+                { header: "Review F/D/N", minWidth: 12, maxWidth: 16 },
+                { header: "Integration A/F/R", minWidth: 17, maxWidth: 20 },
+                { header: "Pre-progress gen", minWidth: 12, maxWidth: 16 },
+                { header: "Terminal ws", minWidth: 10, maxWidth: 12 },
+                { header: "Advice", minWidth: 6, maxWidth: 8 }
+            ], orchestration.tasks.map((task) => [
+                task.taskId,
+                task.deliveryPath,
+                String(task.runs.total),
+                String(task.workItems),
+                `${task.reviews.full}/${task.reviews.delta}/${task.reviews.nonSemantic}`,
+                `${task.integrations.attempts}/${task.integrations.failed}/${task.integrations.repeatedIdentities}`,
+                String(task.providerGenerationsBeforeFirstProgress),
+                String(task.terminalWorkspaceCount),
+                String(task.advisories.length)
+            ]), width));
+        }
+    }
+    else {
+        lines.push("", ...sectionError("orchestration", report));
+    }
     if (report.storage.status === "ok" && report.storage.data !== undefined) {
         const storage = report.storage.data;
         lines.push("", `Storage: backend ${storage.backend} · state.json ${formatBytes(storage.stateJsonBytes)} · yui.db ${formatBytes(storage.databaseBytes)}`

package/dist/commands/globalRoleCommands.js

@@ -36,9 +36,8 @@ function roleContext(args, store, options) {
         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.");
+        if (environment.YUI_SESSION_MANIFEST === undefined) {
+            throw usageError("Managed GlobalRole context requires its Session Manifest.");
         }
     }
     const role = requireRole(name, store);
@@ -81,7 +80,12 @@ function roleContext(args, store, options) {
                 : ["perform-global-role-request"]
         },
         sessionManifestPath: environment.YUI_SESSION_MANIFEST,
-        sessionCliPath: environment.YUI_SESSION_CLI
+        cliCommand: "yui",
+        // Compatibility hint for already-running Sessions. New instructions use
+        // the stable command name and do not bind behavior to this wrapper path.
+        ...(environment.YUI_SESSION_CLI === undefined
+            ? {}
+            : { legacySessionCliPath: environment.YUI_SESSION_CLI })
     });
     if (options.jsonOutput === true)
         return `${JSON.stringify(context)}\n`;

package/dist/commands/operatorCommands.js

@@ -1,6 +1,6 @@
 import { usageError } from "../errors/cliError.js";
 import { createRoleSessionSet } from "../executor/agentExecutor.js";
-import { listOperatorSessions, prepareOperatorNewSession, prepareOperatorResumeSession } from "../operator/operatorSessionHistory.js";
+import { listOperatorSessions, projectOperatorStatus, prepareOperatorNewSession, prepareOperatorResumeSession } from "../operator/operatorSessionHistory.js";
 import { defaultTableWidth, renderTable } from "../output/table.js";
 import { formatRelativeTimestamp } from "../output/timePresentation.js";
 import { updateGlobalRole } from "../role/role.js";
@@ -11,6 +11,7 @@ export function runOperatorCommand(args, store, options = {}) {
     const [command, ...rest] = args;
     switch (command) {
         case "list": return listSessions(rest, store, options);
+        case "status": return status(rest, store, options);
         case "new": return newSession(rest, store);
         case "resume": return resumeSession(rest, store);
         case "submit": return submit(rest, store, options);
@@ -20,6 +21,46 @@ export function runOperatorCommand(args, store, options = {}) {
                 : `Unknown command: operator ${command}`);
     }
 }
+function status(args, store, options) {
+    if (args.length !== 0)
+        throw usageError("Operator status usage: yui operator status.");
+    const role = requireOperator(store);
+    const activeBinding = role.agentBindings[role.activeAgentId];
+    if (activeBinding === undefined) {
+        throw usageError(`Operator active Agent is not bound: ${role.activeAgentId}.`);
+    }
+    const projection = projectOperatorStatus(store.getGlobalRoleSessionSet(role.name), role.activeAgentId, activeBinding.adapterId);
+    const writer = projection.writer;
+    const writerLines = [
+        "Operator status",
+        "Active writer:",
+        `  State: ${writer.state}`,
+        `  Agent: ${writer.agentId}`,
+        `  Adapter: ${adapterLabel(writer.adapterId)}`,
+        `  Conversation: ${writer.sessionRef ?? "-"}`,
+        `  Native session: ${writer.nativeSessionId ?? "-"}`,
+        `  Session state: ${writer.sessionStatus ?? "-"}`
+    ];
+    const history = projection.historicalConversations;
+    const historyOutput = history.length === 0
+        ? "Historical conversations: none"
+        : renderTable("Historical conversations", [
+            { header: "Updated", minWidth: 7, maxWidth: 12 },
+            { header: "Agent", minWidth: 6, maxWidth: 16 },
+            { header: "Conversation", minWidth: 20, maxWidth: 72 },
+            { header: "State", minWidth: 7, maxWidth: 10 }
+        ], history.map((session) => [
+            formatRelativeTimestamp(session.updatedAt, options.now?.() ?? new Date()),
+            adapterLabel(session.adapterId),
+            session.displayTitle,
+            session.state
+        ]), options.width ?? defaultTableWidth());
+    return {
+        kind: "output",
+        output: `${writerLines.join("\n")}\n\n${historyOutput}\n`,
+        data: projection
+    };
+}
 function submit(rest, store, options) {
     const usage = "Operator submit usage: yui operator submit (<body>|--body-file <path|->) [--task <id>].";
     const positionals = [];