@zq-silk/yui 2.6.0 → 2.8.0

package/dist/context/runContextPack.js

@@ -1,4 +1,4 @@
-import { providerRetryProjection } from "../runtime/providerRetry.js";
+import { providerRetrySummary } from "../runtime/providerRetry.js";
 import { operationalTaskRecords } from "../task/taskRecordRetirement.js";
 import { TASK_COMPLETION_PUBLISHED_TREE_AUTHORIZED_EVENT } from "../task/publicationReference.js";
 import { RUN_INPUT_MAX_DELTAS, requireRunContextSnapshotRef } from "./runInputContract.js";
@@ -9,6 +9,7 @@ import { formatGitArtifactRef, validateGitArtifactRef } from "../artifacts/gitAr
 import { managedWorkspaceKey } from "../worktree/managedWorkspace.js";
 import { contextContentDigest, contextSnapshotRef, createContextSnapshot, validateContextSnapshot } from "./contextSnapshot.js";
 import { MAX_SYNTHESIS_SOURCE_RUNS, sourceRunContextValue } from "./sourceRunContext.js";
+import { recordPage, summaryText } from "../output/boundedRead.js";
 export const RUN_CONTEXT_PACK_SCHEMA_VERSION = 1;
 function mergeRequiredContext(automatic, required, requiredPolicy = "current") {
     const entries = new Map(automatic.map(entry => [`${entry.ref.store}/${entry.ref.refId}`, entry]));
@@ -344,6 +345,8 @@ export function buildRunContextPack(store, taskId, runId) {
     const preliminaryBytes = Buffer.byteLength(JSON.stringify({ ...body, digest }), "utf8");
     const pack = Object.freeze({
         ...body,
+        // Current loading guidance is not part of the frozen Assignment digest.
+        skillCheckCommand: "yui session skills --json",
         inventory: Object.freeze({
             refs: pointers.length,
             frozenBytes: preliminaryBytes,
@@ -354,6 +357,41 @@ export function buildRunContextPack(store, taskId, runId) {
     });
     return pack;
 }
+/** The frozen pack remains authority. Entry is a bounded discovery projection;
+ * historical Skill packages and complete inventories are explicit reads only. */
+export function runContextPointerPage(pack, options = {}) {
+    const priority = ["task", "work-item", "review-round", "role-profile"];
+    const pointers = [...pack.pointers].sort((a, b) => {
+        const rank = (store) => priority.includes(store) ? priority.indexOf(store) : priority.length;
+        return rank(a.store) - rank(b.store);
+    }).map(pointer => ({ ...pointer, summary: summaryText(pointer.summary ?? "") }));
+    return recordPage(pointers, `run:${pack.identity.taskId}/${pack.identity.runId}/refs/${pack.snapshot.digest}`, options);
+}
+export function runContextEntry(pack) {
+    const { skillPackages: _packages, pointers: _pointers, deltaRefs, liveTaskState, input, ...identity } = pack;
+    const { directive, ...inputIdentity } = input;
+    const { items, ...pointerPage } = runContextPointerPage(pack, { limit: 16 });
+    return {
+        ...identity, input: { ...inputIdentity, ...(directive === undefined ? {} : {
+                directiveSummary: summaryText(directive), directiveOmitted: true
+            }) }, pointers: items, pointerPage,
+        deltaRefs: deltaRefs.slice(0, 16), deltaRefsTotal: deltaRefs.length,
+        inventory: { ...pack.inventory, complete: pointerPage.complete },
+        liveTaskState: {
+            providerRetries: liveTaskState.providerRetries.slice(0, 8),
+            activeRuns: liveTaskState.activeRuns.slice(0, 8),
+            activeTaskReviews: liveTaskState.activeTaskReviews.slice(0, 8),
+            totals: { providerRetries: liveTaskState.providerRetries.length,
+                activeRuns: liveTaskState.activeRuns.length, activeTaskReviews: liveTaskState.activeTaskReviews.length }
+        },
+        reads: {
+            refs: `yui task run context ${pack.identity.taskId}/${pack.identity.runId} --view refs`,
+            full: `yui task run context ${pack.identity.taskId}/${pack.identity.runId} --view full`,
+            input: `yui task run context ${pack.identity.taskId}/${pack.identity.runId} --view input`,
+            live: `yui task context ${pack.identity.taskId}`
+        }
+    };
+}
 /** Reads the Task's current in-flight execution, outside the frozen contract. */
 function readLiveTaskState(store, taskId) {
     const activeRuns = store.listActiveRuns(taskId)
@@ -374,7 +412,7 @@ function readLiveTaskState(store, taskId) {
     }));
     return Object.freeze({
         providerRetries: Object.freeze(store.listRoleSessionSets(taskId).flatMap(set => set.providerBinding?.retry === undefined
-            ? [] : [{ roleName: set.owner.roleName, retry: providerRetryProjection(set.providerBinding) }])),
+            ? [] : [{ roleName: set.owner.roleName, retry: providerRetrySummary(set.providerBinding) }])),
         activeRuns: Object.freeze(activeRuns),
         activeTaskReviews: Object.freeze(activeTaskReviews)
     });
@@ -445,9 +483,18 @@ function collectAuthorizedContext(store, run) {
     const view = contextView(run);
     const result = [materialize("L2", "task", task.id, task)];
     const brief = store.getTaskBrief(task.id);
-    if (brief !== null && view === "leader") {
+    if (brief !== null && (view === "leader" || view === "reviewer")) {
         result.push(materialize("L2", "task-brief", task.id, brief));
     }
+    // Reviewers need the current material index and effective decisions, not
+    // only the original Task description. Freeze them with the candidate so
+    // later edits cannot silently change the review contract. Artifact bodies
+    // remain on-demand, commit-pinned reads; do not crawl prose or Task history.
+    if (view === "reviewer") {
+        for (const decision of store.listDecisions(task.id).filter(({ status }) => status === "active")) {
+            result.push(materialize("L2", "task-decision", decision.id, decision));
+        }
+    }
     result.push(...collectRunContextOverlays(store, run));
     result.push(...collectSourceRunContext(store, run));
     if (run.workItemId !== undefined) {

package/dist/context/runInputContract.js

@@ -79,7 +79,7 @@ export function serializeRunInputEnvelope(value) {
         .join(",");
     const snapshot = normalized.contextSnapshotRef;
     const lines = [
-        "Yui AgentRun input. Follow the Session Manifest and injected Skills.",
+        "Yui AgentRun input. Check current Skills: yui session skills --json. Follow the Session Manifest profile and current Skills.",
         `${normalized.subject.taskId === undefined ? "" : `task=${normalized.subject.taskId} `}run=${normalized.runId} role=${normalized.roleName}`,
         `source=${normalized.source.type}/${normalized.source.channel} purpose=${normalized.purpose} subject=${subject || "global"} snapshot=${snapshot === undefined ? "none" : `${snapshot.id}@${snapshot.digest}`}`,
         normalized.deltaRefIds.length === 0

package/dist/context/sessionBootstrapManifest.js

@@ -3,6 +3,7 @@ import { chmodSync, readFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { writeTextFileAtomically } from "../storage/durableFile.js";
 import { validateSkillPackageRef } from "./skillPackage.js";
+import { checkCurrentSkills, SKILL_CHECK_COMMAND, SKILL_REUSE_RULE } from "./currentSkills.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";
 /** Portable read pointers accompany every managed input, including the first
@@ -20,9 +21,22 @@ export function withSessionContextPointer(text, environment) {
 /** No remembered/sent flag can prove instructions survived context compaction. */
 export function sessionContextInstructions(manifestPath, digest) {
     return `Yui Session Manifest: ${manifestPath}${digest === undefined ? "" : ` (digest ${digest})`}. `
-        + "Apply yui-runtime and its Role Skills/profile by exact manifest paths. "
-        + "Load on first entry, version change or missing context; reuse only same-version instructions "
-        + "fully available now, never infer availability from prior reads.";
+        + `Before work on every turn run the Manifest's contextProtocol.skillCheckCommand `
+        + `(older Manifests: ${SKILL_CHECK_COMMAND}; Global loadCommand also checks current Skills). `
+        + "Use its current stable Skill paths instead of historical frozen-package paths; preserve the Manifest's Role profile. "
+        + SKILL_REUSE_RULE;
+}
+/** The caller must already pass the ordinary managed Session/CLI/Home checks.
+ * Old manifests remain immutable audit records, while this read resolves their
+ * Skill IDs against the currently executing installation and Home. */
+export function checkSessionSkills(home, manifestPath) {
+    const manifest = readSessionBootstrapManifest(manifestPath);
+    return {
+        skills: checkCurrentSkills(home, manifest.skills.map(skill => skill.id)),
+        roleProfileRef: manifest.roleProfileRef,
+        rule: SKILL_REUSE_RULE,
+        historicalPackagesAreAuditOnly: true
+    };
 }
 /** Read back one immutable Session Manifest and verify its content digest. */
 export function readSessionBootstrapManifest(path) {
@@ -76,6 +90,10 @@ export function readSessionBootstrapManifest(path) {
         requireText(entry.id, "Session Manifest Skill id");
         requireText(entry.path, "Session Manifest Skill path");
         requireDigest(entry.digest, "Session Manifest Skill digest");
+        if (entry.version !== undefined) {
+            requireText(entry.version, "Session Manifest Skill version");
+            requireText(entry.versionPath, "Session Manifest Skill version path");
+        }
         if (entry.package !== undefined) {
             const ref = entry.package;
             validateSkillPackageRef(ref);
@@ -121,6 +139,7 @@ export function materializeSessionBootstrap(input) {
             id: skill.id,
             path: skill.path,
             digest: skill.package?.digest ?? digest(skill.content),
+            ...(skill.version === undefined ? {} : { version: skill.version, versionPath: skill.versionPath }),
             ...(skill.package === undefined ? {} : { package: skill.package })
         })),
         roleProfileRef: { digest: profileDigest, path: roleProfilePath },
@@ -129,11 +148,15 @@ export function materializeSessionBootstrap(input) {
                 // A Global Session may move between Yui's remote TUI and Desktop.
                 // Carry its read entry in the Thread-visible Manifest instead of
                 // depending on the client process that happened to create it.
-                loadCommand: renderGlobalContextCommand(input.entryPoint, home, input.role.name)
+                loadCommand: renderGlobalContextCommand(input.entryPoint, home, input.role.name),
+                // Same self-contained read remains usable from Desktop without the
+                // launching shell's managed environment or PATH.
+                skillCheckCommand: renderGlobalContextCommand(input.entryPoint, home, input.role.name)
             }
             : {
                 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`,
+                skillCheckCommand: SKILL_CHECK_COMMAND,
                 ...(input.role.name === "leader" ? {
                     currentCommand: `yui task context ${quoteShellWord(input.owner.taskId)} --json`
                 } : {})

package/dist/context/skillCatalog.js

@@ -1,9 +1,8 @@
 import { createHash } from "node:crypto";
 import { lstatSync, readFileSync, readdirSync, realpathSync } from "node:fs";
 import { dirname, join, relative, resolve, sep } from "node:path";
-import { fileURLToPath } from "node:url";
 import { verifySkillPackage } from "./skillPackage.js";
-import { BUILTIN_YUI_SKILLS } from "./roleSessionContext.js";
+import { BUILTIN_YUI_SKILLS, currentSkillPath } from "./currentSkills.js";
 const SAFE_ID = /^[A-Za-z0-9][A-Za-z0-9_-]*$/u;
 const MAX_TEXT = 256 * 1024;
 const digest = (data) => createHash("sha256").update(data).digest("hex");
@@ -13,7 +12,7 @@ export function skillSource(home, id) {
         throw new Error("Invalid Skill id.");
     const builtin = BUILTIN_YUI_SKILLS.has(id);
     return { kind: builtin ? "builtin" : "configured",
-        path: builtin ? fileURLToPath(new URL(`../../skills/${id}`, import.meta.url)) : resolve(home, "skills", id) };
+        path: currentSkillPath(home, id) };
 }
 function physical(path) {
     if (realpathSync(path) !== resolve(path))

package/dist/context/taskContext.js

@@ -4,14 +4,14 @@ import { taskNotFound, usageError } from "../errors/cliError.js";
 import { expandTaskMessageResult } from "../message/message.js";
 import { resolveManagedTaskReader } from "../runtime/managedCaller.js";
 import { hasManagedIdentity } from "../runtime/managedIdentity.js";
-import { providerRetryProjection } from "../runtime/providerRetry.js";
+import { providerRetrySummary } from "../runtime/providerRetry.js";
 import { projectTaskRemoteDeliveryFromStore } from "../task/remoteDeliveryService.js";
 import { retiredTaskRecordIds, TASK_RECORD_RETIRED_EVENT } from "../task/taskRecordRetirement.js";
 import { managedWorkspaceKey } from "../worktree/managedWorkspace.js";
 import { contextContentDigest } from "./contextSnapshot.js";
 import { buildRunContextPack } from "./runContextPack.js";
 import { sourceRunContextValue } from "./sourceRunContext.js";
-import { boundedDocument, recordPage } from "../output/boundedRead.js";
+import { boundedDocument, fitsReadBudget, summaryText, recordPage } from "../output/boundedRead.js";
 const MAX_RECORDS = 64;
 const MAX_VALUE_BYTES = 2048;
 const MAX_PAGE_BYTES = 24 * 1024;
@@ -41,13 +41,13 @@ export function readTaskContext(store, taskId, environment = {}) {
                 if (entry.ref.store === "run")
                     runtimeEvents ??= reader.listEventsByType(taskId, ["runtime.agent-error"]);
                 const valueBytes = Buffer.byteLength(JSON.stringify(entry.value));
-                const content = valueBytes > MAX_VALUE_BYTES || ["task-message", "run", "work-item", "project-knowledge"].includes(entry.ref.store)
+                const content = valueBytes > MAX_VALUE_BYTES || ["role", "task-message", "run", "work-item", "project-knowledge"].includes(entry.ref.store)
                     ? { ref: entry.ref, summary: summarize(entry.value), omitted: true }
                     : { ...entry, omitted: false };
                 const record = { ...content, ...(entry.ref.store === "run" ? {
                         execution: runExecutionObservation(entry.value, reader.getTaskRoleSessionSet(taskId, entry.value.roleName)?.providerBinding, runtimeEvents)
                     } : {}), ...(entry.ref.store === "role" ? {
-                        providerRetry: providerRetryProjection(reader.getTaskRoleSessionSet(taskId, entry.value.name)?.providerBinding)
+                        providerRetry: providerRetrySummary(reader.getTaskRoleSessionSet(taskId, entry.value.name)?.providerBinding)
                     } : {}) };
                 const size = Buffer.byteLength(JSON.stringify(record));
                 if (bytes + size > MAX_PAGE_BYTES)
@@ -55,7 +55,7 @@ export function readTaskContext(store, taskId, environment = {}) {
                 records.push(record);
                 bytes += size;
             }
-        return {
+        const result = {
             taskId, coreCursor: encode(cursor), throughCursor: encode(cursor),
             view: "current",
             collections: Object.entries(sources.reduce((counts, source) => {
@@ -67,6 +67,8 @@ export function readTaskContext(store, taskId, environment = {}) {
             discovery: `task context list ${taskId} --store <store>`,
             commandDiscovery: {
                 help: "yui help", describe: "yui --json help",
+                skillCheck: "yui session skills --json",
+                ownInbox: "yui inbox list --json",
                 note: "Help and completion share the current caller's offline command view. Follow that view for operation-specific discovery; execution always revalidates authority."
             },
             detail: `task context inspect ${taskId} --store <store> --ref <refId> --digest <digest>`,
@@ -77,6 +79,18 @@ export function readTaskContext(store, taskId, environment = {}) {
             limits: { records: MAX_RECORDS, valueBytes: MAX_VALUE_BYTES, pageBytes: 32 * 1024, recordBytes: MAX_PAGE_BYTES,
                 attentionRefsPerCategory: MAX_ATTENTION_REFS, attentionRefBytesPerCategory: MAX_VALUE_BYTES }
         };
+        // Account for nested retry facts, collection counts, commands and JSON
+        // structure together. Exact omitted records stay discoverable by family.
+        while (!fitsReadBudget(result) && records.length > 0) {
+            records.pop();
+            result.collections.forEach(collection => {
+                collection.returned = records.filter(record => record.ref.store === collection.store).length;
+            });
+            result.omitted = { records: count - records.length, values: records.filter(record => record.omitted).length };
+        }
+        if (!fitsReadBudget(result))
+            throw usageError("Context identities exceed the response budget; use scoped discovery.");
+        return result;
     });
 }
 function summarizeAttention(store, taskId, allow) {
@@ -91,7 +105,8 @@ function summarizeAttention(store, taskId, allow) {
         ["messages", "task-message", undefined]
     ]) {
         const page = store.queryContextRecords(taskId, {
-            family, statuses, descending: category === "messages", ids: allowedIds(allow, family), limit: MAX_ATTENTION_REFS
+            family, statuses, descending: category === "messages",
+            unhandledMessages: category === "messages", ids: allowedIds(allow, family), limit: MAX_ATTENTION_REFS
         });
         const summary = attention[category];
         summary.count = page.count;
@@ -260,11 +275,11 @@ export async function withContextObservations(core, providers, timeoutMs = 250)
             if (!["known", "partial", "unknown"].includes(value.coverage)
                 || Buffer.byteLength(JSON.stringify(value)) > MAX_VALUE_BYTES)
                 throw new Error("unbounded observation");
-            return { source: provider.source.slice(0, 200), observedAt: new Date().toISOString(),
+            return { source: summaryText(provider.source, 200), observedAt: new Date().toISOString(),
                 coverage: value.coverage, status: "available", value: JSON.parse(JSON.stringify(value.value)) };
         }
         catch {
-            return { source: provider.source.slice(0, 200), observedAt: new Date().toISOString(),
+            return { source: summaryText(provider.source, 200), observedAt: new Date().toISOString(),
                 coverage: "unknown", status: "unavailable" };
         }
         finally {
@@ -273,7 +288,18 @@ export async function withContextObservations(core, providers, timeoutMs = 250)
             controller.abort();
         }
     }));
-    return { ...core, observations };
+    const result = { ...core, observations: [] };
+    for (const observation of observations) {
+        result.observations.push(observation);
+        if (!fitsReadBudget(result)) {
+            result.observations.pop();
+            const { value: _value, ...identity } = observation;
+            result.observations.push({ ...identity, omitted: true });
+            if (!fitsReadBudget(result))
+                result.observations.pop();
+        }
+    }
+    return { ...result, omittedObservations: observations.length - result.observations.length };
 }
 /** Shared current/historical Session read identity; discovery may only narrow it. */
 export function resolveContextReader(store, environment) {
@@ -511,7 +537,7 @@ function authorizedSources(store, { task, allow, caller }, current = false, requ
     }
     if (!current)
         query("change-set");
-    query("task-message", { descending: true });
+    query("task-message", { descending: true, unhandledMessages: current });
     query("run", { descending: true, ...(current ? { statuses: ["active"] } : {}) });
     for (const id of allowedIds(allow, "source-turn") ?? []) {
         const run = store.getRun(taskId, id);
@@ -583,8 +609,8 @@ function freeze(value) {
 }
 function summarize(value) {
     const record = value;
-    return ["title", "scope", "expiresWhen", "version", "objective", "question", "summary", "body", "status", "type"]
+    return summaryText(["title", "name", "activeAgentId", "scope", "expiresWhen", "version", "objective", "question", "summary", "body", "status", "type"]
         .flatMap((key) => typeof record[key] === "string" || (key === "version" && typeof record[key] === "number")
         ? [`${key}: ${record[key]}`] : [])
-        .join("; ").slice(0, 400);
+        .join("; "));
 }

package/dist/controlPlaneCli.js

@@ -22,7 +22,10 @@ import { allowsInteractiveSelection, resolveInteractiveArguments } from "./cli/i
 import { routeInvocation } from "./cli/invocationRouter.js";
 import { operatorOfflineCommand, taskDiagnosticTarget } from "./cli/managedDiagnostics.js";
 import { assertConfigurationAuthority, assertTaskInvocationScope } from "./cli/invocationAuthority.js";
-import { requireManagedGlobalCaller, ManagedRuntimeDriftError } from "./runtime/managedCaller.js";
+import { requireManagedGlobalCaller, requireManagedGlobalReader, ManagedRuntimeDriftError } from "./runtime/managedCaller.js";
+import { sessionCallerEnvironment, requireManagedCaller } from "./runtime/sessionCaller.js";
+import { checkCurrentSkills, SKILL_REUSE_RULE } from "./context/currentSkills.js";
+import { roleSkillIds } from "./context/roleSessionContext.js";
 import { hasManagedIdentity } from "./runtime/managedIdentity.js";
 import { resolveOperatorWizardArguments } from "./cli/operatorWizard.js";
 import { resolveGlobalRoleAgentConfigurationArguments, resolveRoleWizardArguments } from "./cli/roleWizard.js";
@@ -38,6 +41,7 @@ import { runDurableJobCommand } from "./commands/durableJobCommands.js";
 import { parseExecutionAuditOptions, runExecutionAuditCommand } from "./commands/executionAuditCommands.js";
 import { runGlobalRoleCommand, previewGlobalRoleAgentConfigurationMutation } from "./commands/globalRoleCommands.js";
 import { runJobCommand } from "./commands/jobCommands.js";
+import { runInboxCommand } from "./commands/inboxCommands.js";
 import { applyOperatorSessionControl, runOperatorCommand } from "./commands/operatorCommands.js";
 import { previewProfileAgentConfigurationMutation, runProfileCommand } from "./commands/profileCommands.js";
 import { runProjectCommand } from "./commands/projectCommands.js";
@@ -61,7 +65,8 @@ import { runWorkflowCommandAsync } from "./commands/workflowCommands.js";
 import { FileCompletionManager } from "./completion/fileCompletionManager.js";
 import { CONFIG_DOMAINS } from "./config/configCatalog.js";
 import { resolveTmuxBin, resolveTmuxHistoryLimit } from "./config/yuiConfig.js";
-import { readSessionBootstrapManifest } from "./context/sessionBootstrapManifest.js";
+import { checkSessionSkills, readSessionBootstrapManifest } from "./context/sessionBootstrapManifest.js";
+import { boundedDocument, readOptions } from "./output/boundedRead.js";
 import { assertFileTaskControllerStorageCompatible, ensureFileTaskController, FileTaskWorkflowRuntime, refreshRunningFileTaskControllerConfiguration, refreshRunningFileTaskControllerEnvironment, restartFileTaskController, stopFileTaskController } from "./controller/clientRuntime.js";
 import { FileSchedulerStoreAdapter } from "./controller/fileSchedulerStoreAdapter.js";
 import { createControllerIntegrationJobPort } from "./controller/jobClient.js";
@@ -632,6 +637,11 @@ export async function main() {
         return;
     }
     assertTaskInvocationScope(resolved, process.env);
+    if (resolved[0] === "inbox") {
+        const result = runInboxCommand(resolved.slice(1), store, process.env);
+        emit(JSON.stringify(result, null, 2), false, result);
+        return;
+    }
     if (resolved[0] === "task" && resolved[1] === "role" && resolved[2] === "capabilities") {
         const query = parseTaskAgentCapabilityQuery(resolved.slice(3));
         const result = await callController(home, "task.role-capabilities", {
@@ -789,6 +799,26 @@ export async function main() {
             return;
         }
         if (resolved[0] === "session") {
+            if (resolved[1] === "skills") {
+                const parsed = readOptions(resolved.slice(2), ["--cursor"]);
+                if (parsed.positionals.length !== 0)
+                    throw usageError("Usage: yui session skills [--cursor <cursor>] --json");
+                const path = process.env.YUI_SESSION_MANIFEST;
+                const caller = requireManagedCaller(store, process.env);
+                const set = caller.scope === "global" ? store.getGlobalRoleSessionSet(caller.roleName)
+                    : store.getTaskRoleSessionSet(caller.taskId, caller.roleName);
+                const effective = set.sessions[caller.agentId].effective;
+                const kind = caller.scope === "global" ? caller.roleName === "operator" ? "operator" : "global"
+                    : effective.reviewRoundId !== undefined ? "reviewer" : caller.roleName === "leader" ? "leader" : "worker";
+                const checked = path === undefined ? {
+                    skills: checkCurrentSkills(home, roleSkillIds(effective.context, kind)),
+                    profile: effective.context, identity: caller, rule: SKILL_REUSE_RULE,
+                    historicalPackagesAreAuditOnly: true
+                } : checkSessionSkills(home, path);
+                const data = boundedDocument(checked, "session:current-skills", parsed.cursor);
+                emit(JSON.stringify(data, null, 2), false, data);
+                return;
+            }
             if (resolved[1] === "stop") {
                 const options = parseSessionStopOptions(resolved.slice(2));
                 const result = await runSessionStopCommand({
@@ -1969,6 +1999,19 @@ async function preflightManagedTaskControlPlane() {
     if (taskFinalReviewInvocation.error !== undefined) {
         throw new Error(taskFinalReviewInvocation.error);
     }
+    // Desktop clients may carry only their provider-native identity. Resolve
+    // command-local hints before any public/Task/Global routing. This reads this
+    // Home only, and never creates a Session or mutates its registration.
+    if ((process.env.CODEX_THREAD_ID !== undefined || process.env.YUI_NATIVE_SESSION_ID !== undefined)
+        && (process.env.YUI_SESSION_SCOPE === undefined || process.env.YUI_ROLE === undefined)) {
+        const registry = openCurrentTaskStore(resolveYuiHome(process.env));
+        try {
+            Object.assign(process.env, sessionCallerEnvironment(registry, process.env));
+        }
+        finally {
+            registry.close();
+        }
+    }
     if (process.env.YUI_SESSION_SCOPE !== "task") {
         if (process.env.YUI_SESSION_SCOPE === "global") {
             return await preflightManagedGlobalControlPlane();
@@ -2047,8 +2090,8 @@ async function preflightManagedGlobalControlPlane() {
     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) {
+    if (manifest !== undefined && (manifest.owner.scope !== "global"
+        || manifest.roleKind !== expectedRoleKind)) {
         throw new ManagedRuntimeDriftError("Managed global invocation does not match its Session Manifest.");
     }
     if (expectedRoleKind === "operator" && ["doctor", "upgrade", "update"].includes(args[0] ?? "")) {
@@ -2062,9 +2105,15 @@ async function preflightManagedGlobalControlPlane() {
     const verifiedStore = openCurrentTaskStore(home);
     const internalCallback = args[0] === "internal"
         && ["agent-host", "session-notify", "runtime-hook"].includes(args[1] ?? "");
-    if (!internalCallback && !operatorOfflineCommand(args)) {
+    if (!internalCallback) {
+        const selfRead = args[0] === "session" && args[1] === "context" && args[2] === process.env.YUI_ROLE
+            || args[0] === "role" && args[1] === "message" && ["list", "show"].includes(args[2] ?? "")
+                && args[3] === process.env.YUI_ROLE;
         try {
-            requireManagedGlobalCaller(verifiedStore, process.env);
+            if (selfRead)
+                requireManagedGlobalReader(verifiedStore, process.env);
+            else
+                requireManagedGlobalCaller(verifiedStore, process.env);
         }
         catch (error) {
             verifiedStore.close();
@@ -2076,7 +2125,9 @@ async function preflightManagedGlobalControlPlane() {
 function assertManagedSessionManifest(home, scope) {
     const manifestPath = process.env.YUI_SESSION_MANIFEST;
     if (manifestPath === undefined) {
-        throw new ManagedRuntimeDriftError("Managed control-plane invocation requires its Session Manifest.");
+        // A Manifest is a context pointer, not an authority credential. Native
+        // identity is validated against the current Home immediately below.
+        return undefined;
     }
     let manifest;
     try {

package/dist/controller/controller.js

@@ -692,6 +692,7 @@ export class FileTaskController {
     #globalInputDelivery;
     #providerRetry;
     #continuationReconciler;
+    #hostTerminalRecovery;
     #current;
     #operatorCurrent;
     #runtimeObserverCurrent;
@@ -741,6 +742,7 @@ export class FileTaskController {
         this.#leaderWakeFence = options.leaderWakeFence;
         this.#jobSupervisor = options.jobSupervisor;
         this.#continuationReconciler = options.continuationReconciler;
+        this.#hostTerminalRecovery = options.hostTerminalRecovery;
         this.#globalInputDelivery = options.globalInputDelivery;
         this.#providerRetry = options.providerRetry;
         this.#signalScheduler = new MailboxScheduler(async (keys) => { await this.#requestPass({ kind: "dirty", keys }); }, {
@@ -995,8 +997,11 @@ export class FileTaskController {
                         }
                     }
                     const firstRuntimeDrain = await this.#drainRuntimeEvents();
+                    if (scope.kind === "full" && this.#hostTerminalRecovery !== undefined) {
+                        await this.#observeMaintenance("Host terminal recovery", this.#hostTerminalRecovery);
+                    }
                     await this.#providerRetry?.reconcile();
-                    await this.#globalInputDelivery?.();
+                    await this.#globalInputDelivery?.({ reconcile: scope.kind === "full", now: this.#now() });
                     for (const taskId of runtimeTaskFailureIds(firstRuntimeDrain)) {
                         runtimeFailedTaskIds.add(taskId);
                     }
@@ -1076,7 +1081,8 @@ export class FileTaskController {
                     if (scope.kind === "full"
                         || scope.keys.some((key) => key !== "operator")
                         || runtimeAdvanced) {
-                        this.#signalOperatorMailbox(runtimeAdvanced);
+                        this.#signalOperatorMailbox(runtimeAdvanced || scope.kind === "full"
+                            || scope.kind === "dirty" && scope.keys.some(key => parseMailboxKey(key).kind === "global-role"));
                     }
                 }
                 catch (error) {

package/dist/controller/fileSchedulerStoreAdapter.js

@@ -1,5 +1,6 @@
 import { createHash, randomUUID } from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
+import { deliveredMessageWake, pinMessageRevisions, taskMessageInboxReceipt, unfinishedLeaderInbox } from "../message/taskInboxOwnership.js";
 import { contextSnapshotRef } from "../context/contextSnapshot.js";
 import { freezeRunContextSnapshot } from "../context/runContextPack.js";
 import { taskNotificationPresentation } from "../interaction/notificationPresentation.js";
@@ -28,8 +29,9 @@ import { activeRoleAgentBinding } from "../role/role.js";
 import { SYSTEM_OPERATOR_ROLE } from "../role/systemRoles.js";
 import { standardAgentError } from "../runtime/agentError.js";
 import { recordTaskAgentError } from "./taskAgentError.js";
-import { recordGlobalRuntimeAttention, recordGlobalRuntimeFailure } from "./globalRuntimeAttention.js";
+import { recordGlobalRuntimeAttention, recordGlobalRuntimeFailure, recordGlobalRuntimeRecovery } from "./globalRuntimeAttention.js";
 import { queueOperatorNotification } from "./operatorNotification.js";
+import { claimOperatorAttention } from "../scheduler/operatorEvent.js";
 import { builtinAgentDriverRegistry } from "../runtime/builtinAgentDrivers.js";
 import { RUNTIME_CLEANUP_REQUIRED_REASON, RUNTIME_HOST_DETACH_REQUIRED_REASON, RUNTIME_LIFECYCLE_OWNER, hasRuntimeCleanupObligation, hasRuntimeLifecycleWork, isRuntimeCleanupReason, runtimeCleanupDisposition, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
 import { classifyRuntimeProcessExit, validateRuntimeProcessExitObservation } from "../runtime/processExitObservation.js";
@@ -448,6 +450,10 @@ export class FileSchedulerStoreAdapter {
                 binding = settleProviderTurn(binding, { attemptId: receipt, nativeTurnId: fence.nativeTurnId,
                     status: input.kind === "turn.completed" ? "completed" : input.kind === "turn.cancelled" ? "cancelled" : "failed",
                     settledAt: at });
+                if (input.kind === "turn.completed")
+                    recordGlobalRuntimeRecovery(store, fence.roleName, input.eventId, {
+                        nativeSessionId: fence.nativeSessionId, evidence: `provider-structured:${receipt}`
+                    }, now);
                 if (fence.nativeTurnId !== undefined)
                     sessions = rememberRoleAgentCompletedTurn(sessions, fence.agentId, fence.nativeSessionId, fence.nativeTurnId, new Date(at));
             }
@@ -882,6 +888,11 @@ export class FileSchedulerStoreAdapter {
         return [...this.store.listPendingActivationRequestTaskIds()].sort((left, right) => (left.localeCompare(right, undefined, { numeric: true })));
     }
     getTask(taskId) { return this.store.getTask(taskId); }
+    getEvent(taskId, eventId) {
+        return this.store.queryContextRecords(taskId, {
+            family: "task-event", ids: [eventId], limit: 1
+        }).records[0]?.value ?? null;
+    }
     getTaskWorkspace(taskId) { return this.store.getTaskWorkspace(taskId); }
     getTaskBrief(taskId) { return this.store.getTaskBrief(taskId); }
     listDecisions(taskId) { return this.store.listDecisions(taskId); }
@@ -1146,7 +1157,8 @@ export class FileSchedulerStoreAdapter {
                     throw new AgentHostProviderSessionBusyError("The next Global input belongs to an explicit then handoff.");
                 }
                 if (message !== undefined) {
-                    if (message.delivery !== undefined || message.notDelivered !== undefined
+                    if (store.queryGlobalRoleMessages(input.roleName, { handling: true, limit: 0 }).count > 0
+                        || message.inbox !== undefined || message.delivery !== undefined || message.notDelivered !== undefined
                         || message.control !== undefined && message.control.outcome !== "rejected"
                         || message.deliveryTarget?.agentId !== input.agentId
                         || message.deliveryTarget?.nativeSessionId !== input.nativeSessionId) {
@@ -1567,7 +1579,7 @@ export class FileSchedulerStoreAdapter {
             if (mailbox.processing !== null) {
                 return { status: "processing", processing: mailbox.processing };
             }
-            let claimed = claimPending(mailbox, {
+            let claimed = (input.target.kind === "operator" ? claimOperatorAttention : claimPending)(mailbox, {
                 batchId: input.batchId,
                 owner: input.owner,
                 startedAt: input.now.toISOString()
@@ -1737,7 +1749,7 @@ export class FileSchedulerStoreAdapter {
     clearPendingWakeup(taskId) { this.store.clearPendingWakeup(taskId); }
     getLeaderFailure(taskId) { return this.store.getLeaderFailure(taskId); }
     prepareMessageContinuations(taskId, now) {
-        const roles = new Set(this.store.listMessages(taskId).flatMap((message) => message.recipient?.ownerRunId !== undefined && message.continuation?.runId === undefined ? [message.recipient.roleName] : []));
+        const roles = new Set(this.store.listMessages(taskId).flatMap((message) => message.inbox === undefined && message.recipient?.ownerRunId !== undefined && message.continuation?.runId === undefined ? [message.recipient.roleName] : []));
         for (const roleName of roles) {
             try {
                 this.store.transaction((store) => prepareMessageContinuations(store, taskId, now, roleName));
@@ -1746,7 +1758,7 @@ export class FileSchedulerStoreAdapter {
                 const reason = `preparation-failed: ${error instanceof Error ? error.message : String(error)}`.slice(0, 1000);
                 this.store.transaction((store) => {
                     for (const message of store.listMessages(taskId)) {
-                        if (message.recipient?.roleName === roleName && message.recipient.ownerRunId !== undefined && message.continuation?.runId === undefined
+                        if (message.inbox === undefined && message.recipient?.roleName === roleName && message.recipient.ownerRunId !== undefined && message.continuation?.runId === undefined
                             && message.continuation?.notDeliveredReason !== reason) {
                             store.updateMessage(taskId, { ...message, continuation: { notDeliveredReason: reason } });
                         }
@@ -1855,6 +1867,8 @@ export class FileSchedulerStoreAdapter {
                 return { wakeId, attemptId: nextAttempt, disposition: "submit",
                     presentation: taskNotificationPresentation(wake, store) };
             }
+            if (unfinishedLeaderInbox(store, taskId))
+                return null;
             if (mailbox.pending === null || (provider !== null && provider !== undefined
                 && ["submitting", "accepted", "delivery-unknown"].includes(provider.status)))
                 return null;
@@ -1864,6 +1878,12 @@ export class FileSchedulerStoreAdapter {
             const sessions = store.getTaskRoleSessionSet(taskId, "leader");
             const session = sessions?.sessions[sessions.activeAgentId];
             const obsoleteIds = new Set();
+            for (const message of store.listMessages(taskId)) {
+                if (pendingMessageIds.has(message.id) && (taskMessageInboxReceipt(store, message) !== undefined
+                    || deliveredMessageWake(store, message) !== undefined)) {
+                    obsoleteIds.add(message.id);
+                }
+            }
             for (const message of store.listMessages(taskId)) {
                 if (!pendingMessageIds.has(message.id) || message.inputControl?.expectedSessionId === undefined)
                     continue;
@@ -1910,7 +1930,7 @@ export class FileSchedulerStoreAdapter {
             const wakeId = store.nextTaskWakeId(taskId);
             const wake = createTaskWake({
                 id: wakeId, taskId, reasons: mailbox.pending.reasons,
-                refs: selectedRefs,
+                refs: pinMessageRevisions(store, taskId, selectedRefs),
                 fromCursor: latest?.toCursor ?? task.createdAt,
                 toCursor: new Date(Math.max(now.getTime(), Date.parse(mailbox.pending.lastQueuedAt))).toISOString(), now
             });