@zq-silk/yui 2.6.0 → 2.8.0

package/README.md

@@ -67,6 +67,29 @@ Native first-run confirmations may still require your input.
 npm install -g @zq-silk/yui
 ```
 
+SQLite is selected lazily before opening your Home: Yui probes a disposable
+in-memory connection with `sqlite-modern` (`better-sqlite3@13.0.3`, N-API) first,
+then tries `sqlite-compat` (`better-sqlite3@10.1.0`) only for identified missing
+native bindings, Node ABI or system-library incompatibility. Each process keeps
+its successful selection. Home permissions, corruption, locks, SQL and migration
+errors never trigger a driver switch. `yui doctor` reports the driver version,
+actual SQLite engine and fallback reason separately from Home health.
+
+The N-API driver avoids the native `ObjectWrap` garbage-collection abort seen
+with the earlier driver on Node 24.19/24.20. It requires Node-API 10;
+runtimes with an older API (including Node 20 and Node 22.9) skip it before
+native loading and use the compatibility candidate. No global Node change
+or Home migration is needed for this dependency correction.
+
+npm attempts **both** fixed optional aliases during installation; it does not
+install the older one only after the newer one fails. This increases download
+size and installation/build time. Optional installation failures may leave npm
+successful, but Yui cannot run without a usable candidate; do not use
+`--omit=optional`. The compatibility driver uses older SQLite (3.46.0), without
+later fixes, and is not guaranteed on every old glibc/toolchain or newer Node
+ABI. The supported Node range above is unchanged; an OS/toolchain upgrade may
+still be necessary. Selection does not downgrade or migrate Home data.
+
 ### 2. Set up, yourself or with an Agent
 
 Run the interactive setup:

package/dist/cli/commandCatalog.js

@@ -190,6 +190,12 @@ const roleChildren = [
     { name: "unbind", discovery: { surface: "public", audiences: ["public", "operator"] }, summary: "Unbind a dormant Agent from a global Role.", usage: "yui config role unbind <role> <agent-id>" }
 ];
 const globalSessionChildren = [
+    {
+        name: "skills", discovery: { surface: "managed", audiences: ["operator", "leader", "assignment", "global", "unbound"] },
+        summary: "Check current Skill paths, versions and availability for this managed Session without reading bodies.",
+        usage: "yui session skills [--cursor <cursor>]",
+        options: ["--cursor"]
+    },
     { name: "enter", discovery: { surface: "public", audiences: ["public", "operator"] }, summary: "Enter a global Role's native session.", usage: "yui session enter <role>" },
     {
         name: "context", discovery: { surface: "managed", audiences: ["operator", "global", "unbound"] },
@@ -366,7 +372,7 @@ const taskChildren = [
             }
         ]
     },
-    { name: "reopen", discovery: { surface: "public", audiences: ["public", "operator"] }, summary: "Explicitly reopen completed or cancelled intent without replaying historical inputs.", usage: "yui task reopen <id>" },
+    { name: "reopen", discovery: { surface: "public", audiences: ["public", "operator", "leader"] }, summary: "Reopen a completed Task without replaying historical inputs; a current Leader is limited to its own Task. Restoring cancelled intent requires user or Operator authority; an independent execution stop is preserved.", usage: "yui task reopen <id>" },
     {
         name: "cancel", discovery: { surface: "public", audiences: ["public", "operator", "leader"] },
         summary: "Stop pursuing a Task without claiming its processes stopped.",
@@ -906,9 +912,9 @@ const taskChildren = [
             },
             {
                 name: "context", discovery: { surface: "managed", audiences: ["operator", "leader", "assignment"] },
-                summary: "Load the exact authorized AgentRun context.",
-                usage: "yui task run context <task>/<run> [--cursor <cursor>] [--json]",
-                options: ["--cursor", "--json"],
+                summary: "Load bounded AgentRun entry facts; discover refs or read the full authorized pack explicitly.",
+                usage: "yui task run context <task>/<run> [--view current|refs|input|full] [--cursor <cursor>] [--json]",
+                options: ["--view", "--cursor", "--json"],
                 executable: true,
                 hidden: true,
                 sections: [{ id: "load", title: "Commands", entries: ["expand", "delta"] }],
@@ -1128,7 +1134,7 @@ export const ROOT_COMMAND = buildNode({
         { id: "general", title: "General", entries: [
                 "help", "version", "update", "upgrade", "setup", "start", "doctor"
             ] },
-        { id: "workflow", title: "Workflow", entries: ["agent", "operator", "role", "project", "task"] },
+        { id: "workflow", title: "Workflow", entries: ["agent", "operator", "role", "inbox", "project", "task"] },
         { id: "configuration", title: "Configuration", entries: ["config"] },
         { id: "operations", title: "Operations", entries: ["web", "controller", "session", "execution", "capability", "job", "jobs", "telemetry", "release"] },
         { id: "resources", title: "Resources", entries: ["resources"] },
@@ -1154,6 +1160,26 @@ export const ROOT_COMMAND = buildNode({
                     options: catalogCommandOptions(name) }))
             ]
         },
+        {
+            name: "inbox",
+            summary: "Read and explicitly handle the current managed Agent's own inbox.",
+            sections: [{ id: "commands", title: "Commands", entries: ["list", "show", "claim", "ack"] }],
+            children: [
+                { name: "list", discovery: { surface: "managed", audiences: ["operator", "global", "leader", "assignment"] },
+                    summary: "Discover unhandled own-address entries, including accepted delivery, with current identity and separate handling receipts.",
+                    usage: "yui inbox list [--limit <1..100>] [--cursor <cursor>]", options: ["--limit", "--cursor"] },
+                { name: "show", discovery: { surface: "managed", audiences: ["operator", "global", "leader", "assignment"] },
+                    summary: "Read an exact original or fixed notification window without acknowledgement.",
+                    usage: "yui inbox show <entry> [--cursor <cursor>]", options: ["--cursor"] },
+                { name: "claim", discovery: { surface: "managed", audiences: ["operator", "global", "leader", "assignment"] },
+                    summary: "Reserve 1..16 exact entries for handling in this turn; never starts a model turn.",
+                    usage: "yui inbox claim <entry> [<entry> ...] --request-id <id>", options: ["--request-id"] },
+                { name: "ack", discovery: { surface: "managed", audiences: ["operator", "global", "leader", "assignment"] },
+                    summary: "Confirm handling of claimed entries with an auditable disposition, not Provider acceptance.",
+                    usage: "yui inbox ack <entry> [<entry> ...] --request-id <id> --reason <disposition>",
+                    options: ["--request-id", "--reason"] }
+            ]
+        },
         {
             name: "role", discovery: { surface: "public", audiences: ["public", "operator"] },
             summary: "Queue input or control an exact current Global Role Turn.",
@@ -1165,8 +1191,8 @@ export const ROOT_COMMAND = buildNode({
                     children: [
                         {
                             name: "list", discovery: { surface: "public", audiences: ["public", "operator"] }, summary: "Discover Global Messages without consuming input.",
-                            usage: "yui role message list <role> [--pending] [--limit <1..100>] [--cursor <cursor>]",
-                            options: ["--pending", "--limit", "--cursor"]
+                            usage: "yui role message list <role> [--pending|--diagnostics|--diagnostic <key>] [--limit <1..100>] [--cursor <cursor>]",
+                            options: ["--pending", "--diagnostics", "--diagnostic", "--limit", "--cursor"]
                         },
                         {
                             name: "show", discovery: { surface: "public", audiences: ["public", "operator"] }, summary: "Read one exact Global Message; follow contentPage.nextCursor for long content.",
@@ -1584,6 +1610,7 @@ export const ROOT_COMMAND = buildNode({
                 "yui session reconcile --report"
             ],
             sections: [
+                { id: "instructions", title: "Managed instructions", entries: ["skills"] },
                 { id: "global", title: "Global Role sessions", entries: ["context", "enter", "record", "replace"] },
                 { id: "maintenance", title: "Maintenance", entries: ["stop"] },
                 { id: "recovery", title: "Recovery", entries: ["reconcile", "retry"] }

package/dist/cli/updateCommand.js

@@ -65,6 +65,9 @@ export function renderUpdateResult(result) {
     })();
     return [
         rendered,
+        ...(result.outcome === "updated" ? [
+            "Runtime: existing Hosts are retained, not upgraded in place. Host control capabilities and event delivery are checked separately; accepted input is never replayed."
+        ] : []),
         ...(result.controllerReconciliation === undefined ? [] : [
             `Controller reconciliation: ${JSON.stringify(result.controllerReconciliation)}`
         ]),

package/dist/commands/configCommands.js

@@ -56,6 +56,7 @@ export function effectiveConfigData(config, domain) {
     const health = resolveRuntimeHealth(config.runtimeHealth);
     const all = {
         schemaVersion: config.schemaVersion,
+        modelManagement: config.modelManagement ?? null,
         defaultAgent: config.defaultAgent ?? null,
         defaultWorkspace: config.defaultWorkspace ?? null,
         timeZone: resolveTimeZone(config.timeZone),

package/dist/commands/globalRoleCommands.js

@@ -1,8 +1,14 @@
 import { roleNotFound, usageError } from "../errors/cliError.js";
 import { hasManagedIdentity } from "../runtime/managedIdentity.js";
-import { boundedDocument, recordPage, readOptions, readDigest, messageReceipt } from "../output/boundedRead.js";
-import { controlProviderRetry, providerRetryProjection, renderProviderRetry } from "../runtime/providerRetry.js";
+import { requireManagedGlobalCaller } from "../runtime/managedCaller.js";
+import { boundedDocument, recordPage, readOptions, readDigest, messageReceipt, summaryText, summaryMetadata } from "../output/boundedRead.js";
+import { controlProviderRetry, providerRetryProjection, providerRetrySummary, renderProviderRetry } from "../runtime/providerRetry.js";
+import { pendingGlobalInboxMessages, inboxHandlingState, globalInboxDeliveryState } from "../message/inboxReceipt.js";
 import { settleGlobalRetryInput } from "../message/globalProviderRetry.js";
+import { globalInputBacklog } from "../message/globalInputBacklog.js";
+import { checkCurrentSkills, SKILL_REUSE_RULE } from "../context/currentSkills.js";
+import { runtimeDiagnosticGroups, runtimeDiagnosticEvidence } from "../controller/globalRuntimeAttention.js";
+import { roleSkillIds } from "../context/roleSessionContext.js";
 import { createRoleSessionSet, recordRoleAgentSession } from "../executor/agentExecutor.js";
 import { resolveEffectiveLaunch } from "../executor/effectiveLaunch.js";
 import { managedGlobalRoleWorkspace } from "../storage/homeLayout.js";
@@ -73,13 +79,7 @@ function assertGlobalInputAuthority(store, options, target) {
         throw usageError("Global input mutation is outside the exact Session authority.");
     }
     if (env.YUI_SESSION_SCOPE === "global") {
-        const caller = store.getGlobalRoleSessionSet(env.YUI_ROLE ?? "");
-        const session = caller?.sessions[caller.activeAgentId];
-        if (session === undefined || session.status !== "active" || env.YUI_AGENT_ID !== session.agentId
-            || env.YUI_ADAPTER_ID !== session.adapterId
-            || (env.CODEX_THREAD_ID ?? env.YUI_NATIVE_SESSION_ID) !== session.nativeSessionId) {
-            throw usageError("Global input mutation requires the current native caller Session.");
-        }
+        requireManagedGlobalCaller(store, env);
     }
     else if (hasManagedIdentity(env)) {
         throw usageError("Incomplete managed identity cannot acquire user authority.");
@@ -120,22 +120,26 @@ 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) {
-            throw usageError("Managed GlobalRole context requires its Session Manifest.");
-        }
     }
     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];
-    // Only the controlled Endpoint's accepted receipt consumes a queued Message.
+    const currentSkills = checkCurrentSkills(options.yuiHome ?? environment.YUI_HOME, roleSkillIds(session?.effective.context ?? role, role.name === "operator" ? "operator" : "global"));
+    // Native delivery and explicit Agent handling settle the same queued input
+    // through distinct receipts; a context read does neither.
     const messages = store.listGlobalRoleMessages(name);
     const queued = messages.filter((message) => message.delivery === undefined
+        && message.inbox?.ack === undefined
         && message.notDelivered === undefined
         && (message.interruptThen !== undefined || message.inputControl?.action === "queue"));
-    const pending = recordPage(queued.map(globalMessageSummary), `global:${name}/messages/pending`, { limit: 8 });
-    const recent = recordPage([...messages].reverse().map(globalMessageSummary), `global:${name}/messages/all`, { limit: 8 });
+    const pending = recordPage(pendingGlobalInboxMessages(messages).map(globalMessageSummary), `global:${name}/messages/pending`, { limit: 8 });
+    const observedAt = new Date();
+    const { oldestAgeMs, messages: _backlogMessages, ...backlog } = globalInputBacklog(queued, sessions, observedAt, {
+        attention: name === "operator" ? store.getWorkMailbox({ kind: "operator" }) : null,
+        lifecycle: store.getWorkMailbox({ kind: "global-role-runtime", roleName: name })
+    });
     const context = Object.freeze({
         schemaVersion: 1,
         protocol: "yui-managed-context/v1",
@@ -152,10 +156,7 @@ function roleContext(args, store, options) {
                 : { nativeSessionId: session.nativeSessionId })
         },
         profile: {
-            description: role.description,
-            responsibilities: role.responsibilities ?? [],
-            constraints: role.constraints ?? [],
-            expectedOutput: role.expectedOutput,
+            read: "Read roleProfileRef from the current Session Manifest; it is not repeated at each entry.",
             skillIds: [
                 "yui-runtime",
                 ...(role.name === "operator" ? ["yui-operator"] : []),
@@ -172,21 +173,33 @@ function roleContext(args, store, options) {
         },
         // Reading pending input is neither delivery nor implementation.
         pending,
-        recent,
+        backlog,
         reads: {
+            ownInbox: "yui inbox list --json",
             messages: `role message list ${name}`,
             pending: `role message list ${name} --pending`,
-            detail: `role message show ${name} <message-id>`
+            detail: `role message show ${name} <message-id>`,
+            diagnostics: `role message list ${name} --diagnostics`,
+            retry: `session retry ${name} show`
         },
-        nativeTurn: sessions?.providerBinding?.run ?? null,
-        retry: providerRetryProjection(sessions?.providerBinding),
+        nativeTurn: sessions?.providerBinding?.run == null ? null : {
+            attemptId: sessions.providerBinding.run.attemptId,
+            nativeTurnId: sessions.providerBinding.run.nativeTurnId,
+            status: sessions.providerBinding.run.status
+        },
+        retry: providerRetrySummary(sessions?.providerBinding),
         // Historical interrupt receipts are available through Session inspection;
         // only this Turn's exact identity is required at entry.
         sessionManifestPath: environment.YUI_SESSION_MANIFEST,
-        skillPackages: session?.effective.skillPackages ?? null,
+        skillCheckCommand: "yui session skills --json",
+        currentSkills,
+        skillLoadingRule: SKILL_REUSE_RULE,
         cliCommand: "yui"
     });
-    const data = boundedDocument(context, `global:${name}/context`, parsed.cursor);
+    // Elapsed wall-clock time is live display metadata, not a changing source
+    // fact: keep it outside the digest so a long Context remains pageable.
+    const data = { ...boundedDocument(context, `global:${name}/context`, parsed.cursor),
+        backlogObservation: { observedAt: observedAt.toISOString(), oldestAgeMs } };
     return { kind: "output", data, output: [
             `Role Context: ${role.name}`,
             `Scope: global (${context.identity.roleKind})`,
@@ -195,7 +208,7 @@ function roleContext(args, store, options) {
             `Effective revision: ${role.launchRevision}`,
             `Skills: ${context.profile.skillIds.join(", ") || "none"}`,
             `Authority: ${context.authority.view}; Task implementation: no`,
-            `Pending messages: ${pending.total}; recent messages: ${recent.total}`,
+            `Pending messages: ${pending.total}; history is available on demand`,
             JSON.stringify(data),
             ""
         ].join("\n") };
@@ -203,12 +216,15 @@ function roleContext(args, store, options) {
 function globalMessageSummary(message) {
     return {
         id: message.id, createdAt: message.createdAt, kind: message.kind,
-        digest: readDigest(message), summary: message.body.slice(0, 240),
+        digest: readDigest(message), summary: summaryText(message.body),
+        read: `role message show ${message.roleName} ${message.id}`,
         delivery: message.delivery === undefined ? undefined : { deliveredAt: message.delivery.deliveredAt },
-        notDelivered: message.notDelivered === undefined ? undefined : { summary: message.notDelivered.reason.slice(0, 240) },
+        notDelivered: message.notDelivered === undefined ? undefined : { summary: summaryText(message.notDelivered.reason) },
         control: message.control === undefined ? undefined : { outcome: message.control.outcome, observedAt: message.control.observedAt },
         inputAction: message.inputControl?.action,
-        deliveryTarget: message.deliveryTarget,
+        handling: inboxHandlingState(message.inbox),
+        deliveryState: globalInboxDeliveryState(message),
+        deliveryTarget: message.deliveryTarget === undefined ? undefined : summaryMetadata(message.deliveryTarget),
         interruptThen: message.interruptThen === undefined ? undefined : true
     };
 }
@@ -610,8 +626,13 @@ function globalRoleMessage(args, store, options) {
         }
         requireRole(name, store);
         const pending = tail.includes("--pending");
-        const parsed = readOptions(tail.filter(arg => arg !== "--pending"), action === "list"
-            ? ["--cursor", "--limit"] : ["--cursor"]);
+        const diagnostics = tail.includes("--diagnostics");
+        const parsed = readOptions(tail.filter(arg => arg !== "--pending" && arg !== "--diagnostics"), action === "list"
+            ? ["--cursor", "--limit", "--diagnostic"] : ["--cursor"]);
+        const diagnostic = parsed.values.get("--diagnostic");
+        if (Number(pending) + Number(diagnostics) + Number(diagnostic !== undefined) > 1
+            || action === "show" && diagnostics)
+            throw usageError("Choose one Message discovery view.");
         const messages = store.listGlobalRoleMessages(name);
         let data;
         if (action === "show") {
@@ -625,10 +646,16 @@ function globalRoleMessage(args, store, options) {
         else {
             if (parsed.positionals.length !== 0)
                 throw usageError("Role message list <role> [--pending] [--limit <n>] [--cursor <cursor>].");
-            const selected = pending ? messages.filter(message => message.delivery === undefined
-                && message.notDelivered === undefined
-                && (message.interruptThen !== undefined || message.inputControl?.action === "queue")) : [...messages].reverse();
-            data = recordPage(selected.map(globalMessageSummary), `global:${name}/messages/${pending ? "pending" : "all"}`, parsed);
+            if (diagnostics) {
+                data = recordPage(runtimeDiagnosticGroups(messages).reverse().map(group => ({
+                    ...group, source: summaryMetadata(group.source),
+                    read: `role message show ${name} ${group.latestEvidence}`
+                })), `global:${name}/diagnostics`, parsed);
+                return { kind: "output", output: `${JSON.stringify(data)}\n`, data };
+            }
+            const selected = diagnostic !== undefined ? runtimeDiagnosticEvidence(messages, diagnostic)
+                : pending ? pendingGlobalInboxMessages(messages) : [...messages].reverse();
+            data = recordPage(selected.map(globalMessageSummary), `global:${name}/messages/${diagnostic === undefined ? pending ? "pending" : "all" : `diagnostic/${diagnostic}`}`, parsed);
         }
         return { kind: "output", output: `${JSON.stringify(data, null, 2)}\n`, data };
     }