@zq-silk/yui 0.15.11 → 0.16.0

package/dist/cli/completion.js

@@ -1,11 +1,11 @@
 import { ROOT_COMMAND, listPublicCommandPaths, orderedImmediateTokens, visibleChildren } from "./commandCatalog.js";
 import { findInteractionPolicy } from "./interactionPolicy.js";
-export function renderCompletion(shell, identity = "yui") {
+export function renderCompletion(shell) {
     const entries = collectEntries(ROOT_COMMAND);
     switch (shell) {
-        case "bash": return renderBash(entries, identity);
-        case "zsh": return renderZsh(entries, identity);
-        case "fish": return renderFish(entries, identity);
+        case "bash": return renderBash(entries);
+        case "zsh": return renderZsh(entries);
+        case "fish": return renderFish(entries);
         default: throw new Error("Completion shell must be one of bash, zsh, fish.");
     }
 }
@@ -30,8 +30,8 @@ function collectEntries(root) {
 function manifest(prefix) {
     return listPublicCommandPaths().map((path) => `${prefix} ${path}`).join("\n");
 }
-function renderBash(entries, identity) {
-    const functionName = identity === "yui" ? "_yui" : "_yui_dev";
+function renderBash(entries) {
+    const functionName = "_yui";
     return `${manifest("# yui command:")}
 ${functionName}() {
   local current path previous dynamic_candidate dynamic=false
@@ -55,7 +55,7 @@ ${bashDynamicOptionCases(entries)}
   if [[ "$dynamic" == true ]]; then
     while IFS= read -r dynamic_candidate; do
       [[ -n "$dynamic_candidate" ]] && dynamic_candidates+=("$dynamic_candidate")
-    done < <(command ${identity} config completion candidates "$current" -- "\${COMP_WORDS[@]:1:COMP_CWORD-1}" 2>/dev/null)
+    done < <(command yui config completion candidates "$current" -- "\${COMP_WORDS[@]:1:COMP_CWORD-1}" 2>/dev/null)
     candidates=("\${dynamic_candidates[@]}")
   elif [[ "$current" == -* ]]; then
     case "$path" in
@@ -70,11 +70,11 @@ ${entries.map((entry) => `      ${bashPattern(entry.path)}) candidates=(${[...en
   fi
   COMPREPLY=( $(compgen -W "\${candidates[*]}" -- "$current") )
 }
-complete -F ${functionName} ${identity}
+complete -F ${functionName} yui
 `;
 }
-function renderZsh(entries, identity) {
-    return `#compdef ${identity}
+function renderZsh(entries) {
+    return `#compdef yui
 ${manifest("# yui command:")}
 local current command_path previous dynamic_output dynamic=false
 local -a candidates
@@ -95,7 +95,7 @@ ${zshDynamicOptionCases(entries)}
   esac
 fi
 if [[ "$dynamic" == true ]]; then
-  dynamic_output="$(command ${identity} config completion candidates "$current" -- "\${(@)words[2,CURRENT-1]}" 2>/dev/null)"
+  dynamic_output="$(command yui config completion candidates "$current" -- "\${(@)words[2,CURRENT-1]}" 2>/dev/null)"
   candidates=("\${(@f)dynamic_output}")
 elif [[ "$current" == -* ]]; then
   case "$command_path" in
@@ -111,8 +111,8 @@ fi
 (( \${#candidates[@]} > 0 )) && compadd -- "$candidates[@]"
 `;
 }
-function renderFish(entries, identity) {
-    const prefix = `__${identity.replaceAll("-", "_")}`;
+function renderFish(entries) {
+    const prefix = "__yui";
     const lines = [
         manifest("# yui command:"),
         `function ${prefix}_at_path`,
@@ -151,17 +151,17 @@ function renderFish(entries, identity) {
         "end",
         `function ${prefix}_dynamic`,
         "  set -l words (commandline -opc)",
-        `  ${identity} config completion candidates (commandline -ct) -- $words[2..-1] 2>/dev/null`,
+        "  yui config completion candidates (commandline -ct) -- $words[2..-1] 2>/dev/null",
         "end"
     ];
     for (const entry of entries) {
         for (const argument of entry.dynamicArguments) {
             const condition = `${prefix}_needs_dynamic argument ${argument} ${fishPath(entry.path)}`;
-            lines.push(`complete -c ${identity} -f -n ${fishQuote(condition)} -a '(${prefix}_dynamic)'`);
+            lines.push(`complete -c yui -f -n ${fishQuote(condition)} -a '(${prefix}_dynamic)'`);
         }
         for (const option of entry.dynamicOptions) {
             const condition = `${prefix}_needs_dynamic option ${option} ${fishPath(entry.path)}`;
-            lines.push(`complete -c ${identity} -f -n ${fishQuote(condition)} -a '(${prefix}_dynamic)'`);
+            lines.push(`complete -c yui -f -n ${fishQuote(condition)} -a '(${prefix}_dynamic)'`);
         }
     }
     for (const entry of entries) {
@@ -169,13 +169,13 @@ function renderFish(entries, identity) {
             const condition = entry.path.length === 0
                 ? "__fish_use_subcommand"
                 : `${prefix}_at_path ${fishPath(entry.path)}${fishInitialDynamicExclusion(entry, prefix)}`;
-            lines.push(`complete -c ${identity} -f -n ${fishQuote(condition)} -a '${escapeSingle(entry.immediate.join(" "))}'`);
+            lines.push(`complete -c yui -f -n ${fishQuote(condition)} -a '${escapeSingle(entry.immediate.join(" "))}'`);
         }
         if (entry.options.length > 0) {
             const path = fishPath(entry.path);
             const exact = `${prefix}_at_path ${path}${fishInitialDynamicExclusion(entry, prefix)}`;
             const condition = `begin; ${exact}; end; or ${prefix}_at_command_options ${path}`;
-            lines.push(`complete -c ${identity} -f -n ${fishQuote(condition)} -a '${escapeSingle(entry.options.join(" "))}'`);
+            lines.push(`complete -c yui -f -n ${fishQuote(condition)} -a '${escapeSingle(entry.options.join(" "))}'`);
         }
     }
     return `${lines.join("\n")}\n`;

package/dist/cli/completionWizard.js

@@ -41,7 +41,7 @@ export async function runCompletionWizard(port, io, options = {}) {
     let activate = false;
     let activationReady = automatic;
     if (!automatic) {
-        const activationAnswer = normalize(await io.question(`${activationBlock(state.shell, installation, overview.identity)}\n`
+        const activationAnswer = normalize(await io.question(`${activationBlock(state.shell, installation)}\n`
             + `Update ${installation.activationPath} with this managed Yui block? [Y/n]: `));
         if (activationAnswer !== ""
             && activationAnswer !== "y"

package/dist/cli/dynamicCompletion.js

@@ -2,7 +2,7 @@ import { findChild, ROOT_COMMAND, visibleChildren } from "./commandCatalog.js";
 import { getSelectionCandidates } from "./interactionCandidates.js";
 import { findInteractionPolicy } from "./interactionPolicy.js";
 export async function resolveCompletionCandidates(input) {
-    const words = input.words[0] === "yui" || input.words[0] === "yui-dev"
+    const words = input.words[0] === "yui"
         ? input.words.slice(1)
         : [...input.words];
     const { node, consumed } = resolveCommand(words);

package/dist/cli/interactionPolicy.js

@@ -223,12 +223,19 @@ export const INTERACTION_POLICIES = Object.freeze([
     {
         commandPath: ["task", "list"],
         selectors: [],
-        trailingOptions: { "--all": "flag", "--verbose": "flag" }
+        trailingOptions: {
+            "--all": "flag", "--status": "value", "--project": "value",
+            "--search": "value", "--attention": "value", "--limit": "value", "--cursor": "value"
+        }
     },
     {
         ...taskTarget("remote-delivery"),
         trailingOptions: { "--json": "flag" }
     },
+    {
+        ...taskTarget("archive-preflight"),
+        trailingOptions: { "--integrated": "flag", "--abandon": "flag", "--force": "flag", "--json": "flag" }
+    },
     {
         ...taskTarget("archive", 2, ["completed", "cancelled"]),
         trailingOptions: { "--integrated": "flag", "--abandon": "flag", "--force": "flag" },
@@ -272,7 +279,7 @@ export const INTERACTION_POLICIES = Object.freeze([
                 provider: "messages",
                 actionTarget: true
             }],
-        trailingOptions: { "--body-file": "value", "--wake-policy": "value" }
+        trailingOptions: { "--body-file": "value" }
     },
     {
         commandPath: ["task", "message", "retire"],
@@ -550,7 +557,8 @@ export const INTERACTION_POLICIES = Object.freeze([
             "--strategy": "value",
             "--project": "value",
             "--target": "value",
-            "--check": "value"
+            "--check": "value",
+            "--rerun-checks": "flag"
         }
     },
     {

package/dist/cli/invocationAuthority.js

@@ -0,0 +1,64 @@
+import { usageError } from "../errors/cliError.js";
+import { requireManagedGlobalCaller } from "../runtime/managedCaller.js";
+import { routeInvocation } from "./invocationRouter.js";
+import { findInteractionPolicy } from "./interactionPolicy.js";
+import { TASK_RECORD_ID_PREFIXES } from "../task/taskRecordReference.js";
+import { taskDiagnosticTarget } from "./managedDiagnostics.js";
+/** Configuration reads remain available; every Home configuration mutation
+ * has one owner, irrespective of which config subcommand parses its flags. */
+export function assertConfigurationAuthority(args, store, env) {
+    const configurationWrite = args[0] === "config"
+        && !["show", "describe"].includes(args[1] ?? "")
+        && !["show", "list", "capabilities", "status", "candidates"].includes(args[2] ?? "");
+    const resourceWrite = args[0] === "resources" && args.some(arg => ["--apply", "--purge", "--restore"].includes(arg));
+    if (!configurationWrite && !resourceWrite)
+        return;
+    if (env.YUI_SESSION_SCOPE === "global" && env.YUI_ROLE === "operator") {
+        requireManagedGlobalCaller(store, env);
+        return;
+    }
+    if (env.YUI_SESSION_SCOPE !== undefined || env.YUI_ROLE !== undefined
+        || env.YUI_AGENT_ID !== undefined || env.YUI_NATIVE_SESSION_ID !== undefined) {
+        throw usageError("Home configuration and resource mutations require the user or current Operator, not a Task Assignment.");
+    }
+}
+/** The parsed command path identifies the first target argument, never a
+ * string found in a body/flag value. Record-local references retain their
+ * normal command-specific parser; an explicit foreign Task cannot pass it. */
+export function assertTaskInvocationScope(args, env) {
+    if (env.YUI_SESSION_SCOPE !== "task")
+        return;
+    if (args[0] === "jobs" || (args[0] === "task" && ["create", "overlap"].includes(args[1] ?? ""))) {
+        throw usageError("This global operation is outside the caller's Task; use its scoped Context.");
+    }
+    if (args[0] !== "task" || args[1] === "list")
+        return;
+    const diagnostic = taskDiagnosticTarget(args);
+    if (diagnostic !== undefined) {
+        if (diagnostic !== env.YUI_TASK_ID)
+            throw usageError("Command target is outside the caller's Task.");
+        return;
+    }
+    const invocation = routeInvocation([...args]);
+    if (invocation.kind !== "execute")
+        return;
+    let targetIndex = invocation.node.path.length - 1;
+    const optionSyntax = findInteractionPolicy(invocation.node)?.trailingOptions;
+    while (args[targetIndex]?.startsWith("--")) {
+        // Reuse known option arity, not any picker/confirmation authority. An
+        // unclassified prefix cannot turn a missing target into permission.
+        const kind = optionSyntax?.[args[targetIndex]];
+        if (kind === undefined)
+            throw usageError("Place this command's Task target before its options so its scope is explicit.");
+        targetIndex += kind === "flag" ? 1 : 2;
+    }
+    const target = args[targetIndex];
+    if (target === undefined)
+        return; // The domain parser still requires its target.
+    const taskId = target.split("/")[0];
+    const local = !target.includes("/") && Object.values(TASK_RECORD_ID_PREFIXES)
+        .some(prefix => target.startsWith(`${prefix}-`));
+    if (!local && taskId !== env.YUI_TASK_ID) {
+        throw usageError("Command target is outside the caller's Task.");
+    }
+}

package/dist/cli/managedDiagnostics.js

@@ -3,8 +3,8 @@
 export function taskDiagnosticTarget(args) {
     if (args[0] !== "task")
         return undefined;
-    if (["show", "context", "next-action"].includes(args[1] ?? "")) {
-        return args[1] === "context" && ["inspect", "delta"].includes(args[2] ?? "")
+    if (["show", "context", "next-action", "archive-preflight"].includes(args[1] ?? "")) {
+        return args[1] === "context" && ["read", "inspect", "delta"].includes(args[2] ?? "")
             ? args[3] : args[2];
     }
     if (args[1] === "role" && ["list", "status", "show"].includes(args[2] ?? ""))

package/dist/cli/parseRepeatable.js

@@ -0,0 +1,35 @@
+import { usageError } from "../errors/cliError.js";
+export function parseRepeatable(args, repeatable, singular, usage, flags = new Set()) {
+    const positionals = [];
+    const many = new Map();
+    const one = new Map();
+    for (let index = 0; index < args.length; index += 1) {
+        const value = args[index];
+        if (!value.startsWith("--")) {
+            positionals.push(value);
+            continue;
+        }
+        if (flags.has(value)) {
+            if (one.has(value))
+                throw usageError(`Option may only be specified once: ${value}.`, usage);
+            one.set(value, "true");
+            continue;
+        }
+        if (!repeatable.has(value) && !singular.has(value)) {
+            throw usageError(`Unsupported option: ${value}.`, usage);
+        }
+        if (singular.has(value) && one.has(value)) {
+            throw usageError(`Option may only be specified once: ${value}.`, usage);
+        }
+        const optionValue = args[index + 1];
+        if (optionValue === undefined || optionValue.startsWith("--")) {
+            throw usageError(`${value} is required.`, usage);
+        }
+        if (repeatable.has(value))
+            many.set(value, [...(many.get(value) ?? []), optionValue]);
+        else
+            one.set(value, optionValue);
+        index += 1;
+    }
+    return { positionals, many, one };
+}

package/dist/cli/updatePorts.js

@@ -238,6 +238,7 @@ export function createUpdatePorts(environment, spawn = spawnSync, stagingRoot =
 }
 const UPDATE_CLI_PATH = fileURLToPath(new URL("../cli.js", import.meta.url));
 const UPDATE_CLIENT_RUNTIME_PATH = fileURLToPath(new URL("../controller/clientRuntime.js", import.meta.url));
+const UPDATE_INVENTORY_PATH = fileURLToPath(new URL("../controller/resourceInventoryLinux.js", import.meta.url));
 const UPDATE_CONTROLLER_RECONCILIATION_PATH = fileURLToPath(new URL("../controller/updateReconciliation.js", import.meta.url));
 /**
  * Capture running state plus an authenticated exact process identity before
@@ -522,18 +523,38 @@ function restoreControllerIdentity(home, identity, environment, spawn) {
     assertSpawnOk(result, "restore the previously running Controller identity");
 }
 function runControllerCommand(home, environment, spawn, method, cliBinary) {
-    const command = cliBinary ?? process.execPath;
-    const args = cliBinary === undefined
+    let command = cliBinary ?? process.execPath;
+    let args = cliBinary === undefined
         ? [UPDATE_CLI_PATH, "--json", "controller", method]
         : ["--json", "controller", method];
+    if (method === "status") {
+        // Lifecycle capture consumes the resource collector, not public status's
+        // current-schema health verdict. This is the same schema-independent seam
+        // used for update-owned stop/reconciliation, with no environment bypass.
+        const inventoryModule = cliBinary === undefined
+            ? UPDATE_INVENTORY_PATH
+            : join(dirname(activatedControllerEntrypoint(cliBinary)), "resourceInventoryLinux.js");
+        const helper = [
+            "(async () => {",
+            "  const { pathToFileURL } = await import('node:url');",
+            "  const { scanControllerResourceInventory } = await import(pathToFileURL(process.argv[1]).href);",
+            "  const data = await scanControllerResourceInventory({",
+            "    currentHome: process.argv[2], scope: 'current', environment: process.env",
+            "  });",
+            "  process.stdout.write(JSON.stringify({ ok: true, data }));",
+            "})().catch(error => {",
+            "  process.stderr.write(JSON.stringify({ ok: false, code: error.code ?? 'RUNTIME_ERROR', message: error.message }));",
+            "  process.exitCode = 5;",
+            "});"
+        ].join(" ");
+        command = process.execPath;
+        args = ["-e", helper, inventoryModule, home];
+    }
     const result = spawn(command, args, {
         cwd: process.cwd(),
         env: {
             ...environment,
             YUI_HOME: home,
-            // Lifecycle capture needs the schema-independent resource inventory,
-            // not the optional current-schema identity health verdict.
-            YUI_STATUS_IDENTITY: "0",
             // This exact lifecycle child is part of the update process that owns
             // the handover lock. Managed Sessions never receive this bypass.
             YUI_UPDATE_HANDOVER_OWNER_PID: String(process.pid)