@zq-silk/yui 0.2.0 → 0.4.2

package/dist/commands/roleConfiguration.js

@@ -1,5 +1,5 @@
 import { usageError } from "../errors/cliError.js";
-import { resolveAgentAdapter } from "../executor/agentAdapter.js";
+import { defaultRoleAgentConfig, resolveAgentAdapter } from "../executor/agentAdapter.js";
 const PROFILE_OPTIONS = [
     ["--description", "value"],
     ["--responsibility", "repeatable"],
@@ -19,31 +19,48 @@ const PROFILE_CLEAR_OPTIONS = [
 const AGENT_VALUE_OPTIONS = [
     ["--model", "value"],
     ["--effort", "value"],
+    ["--permission-strategy", "value"],
     ["--sandbox", "value"],
     ["--approval", "value"],
     ["--permission-mode", "value"],
     ["--search", "value"]
 ];
+const AGENT_REPEATABLE_OPTIONS = [
+    ["--allowed-tool", "repeatable"],
+    ["--disallowed-tool", "repeatable"]
+];
 const AGENT_CLEAR_OPTIONS = [
     ["--clear-model", "flag"],
     ["--clear-effort", "flag"],
-    ["--clear-sandbox", "flag"],
-    ["--clear-approval", "flag"],
-    ["--clear-permission-mode", "flag"],
+    ["--clear-allowed-tools", "flag"],
+    ["--clear-disallowed-tools", "flag"],
     ["--clear-search", "flag"],
     ["--clear-agent-config", "flag"]
 ];
 const AGENT_CONFIG_OPTIONS = new Set([
     ...AGENT_VALUE_OPTIONS.map(([option]) => option),
+    ...AGENT_REPEATABLE_OPTIONS.map(([option]) => option),
     ...AGENT_CLEAR_OPTIONS.map(([option]) => option)
 ]);
 export function roleOptionSpecs(input) {
+    const agentValueOptions = input.agentOptions === "execution"
+        ? AGENT_VALUE_OPTIONS.filter(([option]) => option === "--model" || option === "--effort")
+        : AGENT_VALUE_OPTIONS;
+    const agentClearOptions = input.agentOptions === "execution"
+        ? AGENT_CLEAR_OPTIONS.filter(([option]) => (option === "--clear-model"
+            || option === "--clear-effort"
+            || option === "--clear-agent-config"))
+        : AGENT_CLEAR_OPTIONS;
+    const agentRepeatableOptions = input.agentOptions === "execution"
+        ? []
+        : AGENT_REPEATABLE_OPTIONS;
     return new Map([
         ...(input.includeAgent === true ? [["--agent", "value"]] : []),
         ...(input.includeWorkspace === true ? [["--workspace", "value"]] : []),
         ...PROFILE_OPTIONS,
-        ...AGENT_VALUE_OPTIONS,
-        ...(input.update ? [...PROFILE_CLEAR_OPTIONS, ...AGENT_CLEAR_OPTIONS] : [])
+        ...agentValueOptions,
+        ...agentRepeatableOptions,
+        ...(input.update ? [...PROFILE_CLEAR_OPTIONS, ...agentClearOptions] : [])
     ]);
 }
 export function parseRoleOptions(args, specs, usage) {
@@ -124,21 +141,12 @@ export function patchRoleAgentBinding(binding, parsed) {
     assertAgentOptionConflicts(parsed);
     assertAdapterOptions(binding.adapterId, parsed);
     if (parsed.has("--clear-agent-config")) {
-        return { ...binding, config: { adapterId: binding.adapterId } };
+        return { ...binding, config: defaultRoleAgentConfig(binding.adapterId) };
     }
     const config = structuredClone(binding.config);
     patchText(config, parsed, "--model", "--clear-model", "model");
     patchText(config, parsed, "--effort", "--clear-effort", "effort");
-    const permission = {
-        ...(config.permission ?? {})
-    };
-    patchText(permission, parsed, "--sandbox", "--clear-sandbox", "sandbox");
-    patchText(permission, parsed, "--approval", "--clear-approval", "approval");
-    patchText(permission, parsed, "--permission-mode", "--clear-permission-mode", "mode");
-    if (Object.keys(permission).length === 0)
-        delete config.permission;
-    else
-        config.permission = permission;
+    config.permission = permissionPatch(binding, parsed);
     if (parsed.has("--search")) {
         if (parsed.one("--search") !== "true") {
             throw usageError("--search supports true only; use --clear-search to follow the CLI default.");
@@ -155,19 +163,69 @@ export function patchRoleAgentBinding(binding, parsed) {
         throw usageError(error instanceof Error ? error.message : String(error));
     }
 }
+function permissionPatch(binding, parsed) {
+    const selected = parsed.has("--permission-strategy")
+        ? permissionStrategy(parsed.one("--permission-strategy"))
+        : undefined;
+    const nativeOptions = [
+        "--sandbox", "--approval", "--permission-mode",
+        "--allowed-tool", "--clear-allowed-tools",
+        "--disallowed-tool", "--clear-disallowed-tools"
+    ].some((option) => parsed.has(option));
+    if (selected === "default" || selected === "bypass") {
+        if (nativeOptions) {
+            throw usageError(`--permission-strategy ${selected} cannot be combined with provider permission options.`);
+        }
+        return { strategy: selected };
+    }
+    const current = binding.config.permission;
+    if (selected !== "configured" && !nativeOptions) {
+        return structuredClone(current ?? { strategy: "bypass" });
+    }
+    const permission = current?.strategy === "configured"
+        ? structuredClone(current)
+        : { strategy: "configured" };
+    permission.strategy = "configured";
+    if (binding.adapterId === "codex") {
+        if (parsed.has("--sandbox"))
+            permission.sandbox = requiredText(parsed.one("--sandbox"));
+        if (parsed.has("--approval"))
+            permission.approval = requiredText(parsed.one("--approval"));
+    }
+    else {
+        if (parsed.has("--permission-mode")) {
+            permission.mode = requiredText(parsed.one("--permission-mode"));
+        }
+        patchTexts(permission, parsed, "--allowed-tool", "--clear-allowed-tools", "allowedTools");
+        patchTexts(permission, parsed, "--disallowed-tool", "--clear-disallowed-tools", "disallowedTools");
+    }
+    return permission;
+}
+function permissionStrategy(value) {
+    const strategy = requiredText(value);
+    if (strategy !== "default" && strategy !== "bypass" && strategy !== "configured") {
+        throw usageError("--permission-strategy must be default, bypass, or configured.");
+    }
+    return strategy;
+}
 function patchText(target, parsed, valueOption, clearOption, key) {
     if (parsed.has(valueOption))
         target[key] = requiredText(parsed.one(valueOption));
     if (parsed.has(clearOption))
         delete target[key];
 }
+function patchTexts(target, parsed, valueOption, clearOption, key) {
+    if (parsed.has(valueOption))
+        target[key] = parsed.many(valueOption).map(requiredText);
+    if (parsed.has(clearOption))
+        delete target[key];
+}
 function assertAgentOptionConflicts(parsed) {
     assertPairs(parsed, [
         ["--model", "--clear-model"],
         ["--effort", "--clear-effort"],
-        ["--sandbox", "--clear-sandbox"],
-        ["--approval", "--clear-approval"],
-        ["--permission-mode", "--clear-permission-mode"],
+        ["--allowed-tool", "--clear-allowed-tools"],
+        ["--disallowed-tool", "--clear-disallowed-tools"],
         ["--search", "--clear-search"]
     ]);
     if (parsed.has("--clear-agent-config")
@@ -176,14 +234,17 @@ function assertAgentOptionConflicts(parsed) {
     }
 }
 function assertAdapterOptions(adapterId, parsed) {
-    const codex = ["--sandbox", "--clear-sandbox", "--approval", "--clear-approval",
-        "--search", "--clear-search"];
-    const claude = ["--permission-mode", "--clear-permission-mode"];
+    const codex = ["--sandbox", "--approval", "--search", "--clear-search"];
+    const claude = [
+        "--permission-mode",
+        "--allowed-tool", "--clear-allowed-tools",
+        "--disallowed-tool", "--clear-disallowed-tools"
+    ];
     if (adapterId !== "codex" && codex.some((option) => parsed.has(option))) {
         throw usageError("Sandbox, approval, and search settings are only supported by Codex.");
     }
     if (adapterId !== "claude" && claude.some((option) => parsed.has(option))) {
-        throw usageError("Permission mode is only supported by Claude.");
+        throw usageError("Permission mode and tool rules are only supported by Claude.");
     }
 }
 function assertPairs(parsed, pairs) {

package/dist/commands/roleRuntimeGuard.js

@@ -0,0 +1,12 @@
+import { usageError } from "../errors/cliError.js";
+import { hasRuntimeLifecycleWork, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
+/**
+ * Runtime launch reservation and cleanup are ownership obligations for a Role
+ * identity. Mutating or recreating that identity while either obligation is
+ * queued can make the controller act on a different launch configuration.
+ */
+export function assertRoleRuntimeMutationAllowed(store, owner, action) {
+    if (!hasRuntimeLifecycleWork(store.getWorkMailbox(runtimeLifecycleTarget(owner))))
+        return;
+    throw usageError(`Role ${action} is blocked while a runtime lifecycle transition is pending or processing.`);
+}

package/dist/commands/roleSkillValidation.js

@@ -0,0 +1,47 @@
+import { accessSync, constants, statSync } from "node:fs";
+import { resolve } from "node:path";
+import { usageError } from "../errors/cliError.js";
+const ROLE_LAUNCH_CONTEXT_OPTIONS = new Set([
+    "--workspace",
+    "--description",
+    "--clear-description",
+    "--responsibility",
+    "--clear-responsibilities",
+    "--constraint",
+    "--clear-constraints",
+    "--expected-output",
+    "--clear-expected-output",
+    "--system-prompt",
+    "--clear-system-prompt",
+    "--skill",
+    "--clear-skills"
+]);
+const SAFE_SKILL_ID = /^[A-Za-z0-9][A-Za-z0-9_-]*$/;
+export function hasRoleLaunchContextOptions(parsed) {
+    return [...parsed.seen].some((option) => ROLE_LAUNCH_CONTEXT_OPTIONS.has(option));
+}
+/**
+ * Role Skills are launch-time policy. Reject invalid references before the
+ * durable Role is changed so a typo cannot make future enters or wakeups fail.
+ */
+export function validateConfiguredRoleSkills(yuiHome, skillIds) {
+    if (skillIds.length === 0)
+        return;
+    if (yuiHome === undefined || yuiHome.trim().length === 0) {
+        throw usageError("YUI_HOME is required to configure Role Skills.");
+    }
+    for (const id of new Set(skillIds)) {
+        if (!SAFE_SKILL_ID.test(id)) {
+            throw usageError(`Configured Skill id is invalid: ${id}.`);
+        }
+        const path = resolve(yuiHome, "skills", id, "SKILL.md");
+        try {
+            if (!statSync(path).isFile())
+                throw new Error("not a file");
+            accessSync(path, constants.R_OK);
+        }
+        catch {
+            throw usageError(`Configured Skill not found or unreadable: ${id}.`);
+        }
+    }
+}

package/dist/commands/taskActor.js

@@ -0,0 +1,127 @@
+import { usageError } from "../errors/cliError.js";
+import { activeRoleAgentBinding } from "../role/role.js";
+import { formatAgentRunReceiptId } from "../task/taskRecordReference.js";
+const LEADER_ROLE = "leader";
+const LEADER_ACTION_RUN_ENV = "YUI_LEADER_ACTION_RUN_ID";
+const LEADER_ACTION_RECEIPT_ENV = "YUI_LEADER_ACTION_RECEIPT_ID";
+export function taskActor(environment, taskId) {
+    const env = environment ?? {};
+    if (env.YUI_SESSION_SCOPE === "task"
+        && env.YUI_TASK_ID === taskId
+        && env.YUI_ROLE === "leader") {
+        return "leader";
+    }
+    if (env.YUI_SESSION_SCOPE === "task") {
+        throw usageError(`A managed Task Session may perform this action only as the matching Leader: ${taskId}.`);
+    }
+    if (env.YUI_SESSION_SCOPE === "global") {
+        if (env.YUI_ROLE === "operator")
+            return "operator";
+        throw usageError("A managed global Session may perform this action only as Operator.");
+    }
+    if (env.YUI_ROLE !== undefined
+        || env.YUI_AGENT_ID !== undefined
+        || env.YUI_RUN_ID !== undefined
+        || env.YUI_NATIVE_SESSION_ID !== undefined) {
+        throw usageError("Managed Agent identity is incomplete; refusing to infer user authority.");
+    }
+    return "user";
+}
+/**
+ * Resolve an exact current Task Leader Run for event attribution.
+ *
+ * Task commands may be invoked by a managed process whose environment is
+ * stale, incomplete, or copied from another Run.  A bare YUI_RUN_ID is never
+ * enough: the active durable Run, Role, in-flight receipt, native Session,
+ * launch generation, and (when supplied) Home must all agree before an
+ * allowlisted lifecycle event can buy a Leader action window.  A fixed native
+ * Session may keep an earlier Run/launch in its process environment; in that
+ * case the current Leader turn must explicitly carry the exact durable
+ * Run/receipt pair through the two command-only assertion variables below.
+ */
+export function taskLeaderActionRunId(store, taskId, environment, yuiHome) {
+    const env = environment ?? {};
+    if (env.YUI_SESSION_SCOPE !== "task" || env.YUI_ROLE !== LEADER_ROLE)
+        return undefined;
+    if (identity(env.YUI_TASK_ID) !== taskId)
+        return undefined;
+    const environmentAssertion = leaderActionAssertion(env);
+    if (environmentAssertion === "invalid")
+        return undefined;
+    const explicitAssertion = environmentAssertion === undefined ? undefined : environmentAssertion;
+    const runId = explicitAssertion?.runId ?? identity(env.YUI_RUN_ID);
+    const agentId = identity(env.YUI_AGENT_ID);
+    const adapterId = identity(env.YUI_ADAPTER_ID);
+    const launchId = identity(env.YUI_LAUNCH_ID);
+    const home = identity(env.YUI_HOME);
+    if (runId === undefined
+        || agentId === undefined
+        || adapterId === undefined
+        || launchId === undefined
+        || home === undefined) {
+        return undefined;
+    }
+    const storeHome = typeof store.rootDirectory === "function"
+        ? store.rootDirectory()
+        : undefined;
+    if (yuiHome !== undefined && home !== yuiHome)
+        return undefined;
+    if (yuiHome === undefined && storeHome !== undefined && home !== storeHome)
+        return undefined;
+    const role = store.getRole(taskId, LEADER_ROLE);
+    const run = store.getActiveAgentRun(taskId, LEADER_ROLE);
+    const sessions = store.getTaskRoleSessionSet(taskId, LEADER_ROLE);
+    if (role === null
+        || run === null
+        || run.status !== "active"
+        || run.id !== runId
+        || run.taskId !== taskId
+        || run.roleName !== LEADER_ROLE
+        || run.effective.agentId !== agentId
+        || run.effective.adapterId !== adapterId
+        || role.activeAgentId !== agentId
+        || activeRoleAgentBinding(role).adapterId !== adapterId
+        || sessions === null
+        || sessions.owner.scope !== "task"
+        || sessions.owner.taskId !== taskId
+        || sessions.owner.roleName !== LEADER_ROLE
+        || sessions.activeAgentId !== agentId
+        || sessions.inFlight === null
+        || sessions.inFlight.runId !== runId
+        || sessions.inFlight.agentId !== agentId
+        || sessions.inFlight.receiptId !== formatAgentRunReceiptId(taskId, runId))
+        return undefined;
+    if (explicitAssertion !== undefined
+        && explicitAssertion.receiptId !== formatAgentRunReceiptId(taskId, runId))
+        return undefined;
+    const session = sessions.sessions[agentId];
+    if (session === undefined
+        || identity(session.nativeSessionId) === undefined
+        || identity(session.launchId) === undefined
+        || session.status === "stopped"
+        || session.status === "broken"
+        || session.adapterId !== adapterId
+        || (explicitAssertion === undefined && session.launchId !== launchId))
+        return undefined;
+    if (env.YUI_NATIVE_SESSION_ID !== undefined
+        && env.YUI_NATIVE_SESSION_ID !== session.nativeSessionId)
+        return undefined;
+    return run.id;
+}
+function leaderActionAssertion(environment) {
+    const runId = environment[LEADER_ACTION_RUN_ENV];
+    const receiptId = environment[LEADER_ACTION_RECEIPT_ENV];
+    if (runId === undefined && receiptId === undefined)
+        return undefined;
+    const normalizedRunId = identity(runId);
+    const normalizedReceiptId = identity(receiptId);
+    return normalizedRunId === undefined || normalizedReceiptId === undefined
+        ? "invalid"
+        : { runId: normalizedRunId, receiptId: normalizedReceiptId };
+}
+function identity(value) {
+    if (typeof value !== "string" || value.includes("\0"))
+        return undefined;
+    const normalized = value.trim();
+    return normalized.length === 0 || normalized !== value ? undefined : normalized;
+}