@zq-silk/yui 0.2.0 → 0.4.2

package/dist/agent/agent.js

@@ -59,7 +59,8 @@ function validateEnvironmentBinding(binding) {
         throw new Error("Agent environment binding must be an object.");
     }
     if (binding.source !== "process" || typeof binding.required !== "boolean"
-        || !isEnvironmentName(binding.target) || !isEnvironmentName(binding.sourceName)) {
+        || !isEnvironmentName(binding.target) || !isEnvironmentName(binding.sourceName)
+        || binding.target.startsWith("YUI_")) {
         throw new Error("Agent environment binding is invalid.");
     }
     return {

package/dist/agent/argumentPolicy.js

@@ -14,7 +14,9 @@ const OWNED_ARGUMENTS_BY_ADAPTER = {
         "--setting-sources", "--worktree", "-w", "--tmux", "--print", "-p",
         "--agents", "--bg", "--background", "--dangerously-skip-permissions",
         "--allow-dangerously-skip-permissions", "--no-session-persistence", "--from-pr",
-        "--fallback-model", "--tools"
+        "--fallback-model", "--tools", "--system-prompt", "--system-prompt-file",
+        "--append-system-prompt", "--append-system-prompt-file", "--plugin-dir",
+        "--name", "-n"
     ]
 };
 export function ownedArgumentsForAdapter(adapterId) {

package/dist/agent/launchEnvironment.js

@@ -0,0 +1,106 @@
+import { resolveAgentEnvironment } from "./agent.js";
+import { homedir, tmpdir } from "node:os";
+import { dirname } from "node:path";
+import { usableInteractiveTerminal } from "../output/terminal.js";
+export { YUI_MANAGED_RUNTIME_ENVIRONMENT_NAMES } from "./managedRuntimeEnvironment.js";
+/**
+ * Non-secret process context needed by native Agent CLIs after tmux starts
+ * them with an empty environment. Keep this list explicit: arbitrary parent
+ * variables can contain credentials belonging to a different Agent.
+ */
+export const AGENT_OPERATIONAL_ENVIRONMENT_NAMES = [
+    "PATH",
+    "HOME",
+    "USER",
+    "LOGNAME",
+    "SHELL",
+    "TMPDIR",
+    "TMP",
+    "TEMP",
+    "TMUX_TMPDIR",
+    "TERM",
+    "COLORTERM",
+    "LANG",
+    "LANGUAGE",
+    "LC_ALL",
+    "LC_ADDRESS",
+    "LC_COLLATE",
+    "LC_CTYPE",
+    "LC_IDENTIFICATION",
+    "LC_MEASUREMENT",
+    "LC_MESSAGES",
+    "LC_MONETARY",
+    "LC_NAME",
+    "LC_NUMERIC",
+    "LC_PAPER",
+    "LC_TELEPHONE",
+    "LC_TIME",
+    "TZ",
+    "XDG_CONFIG_HOME",
+    "XDG_CACHE_HOME",
+    "XDG_DATA_HOME",
+    "XDG_STATE_HOME",
+    "XDG_RUNTIME_DIR",
+    "HTTP_PROXY",
+    "HTTPS_PROXY",
+    "ALL_PROXY",
+    "NO_PROXY",
+    "http_proxy",
+    "https_proxy",
+    "all_proxy",
+    "no_proxy",
+    "SSL_CERT_FILE",
+    "SSL_CERT_DIR",
+    "NODE_EXTRA_CA_CERTS",
+    "CURL_CA_BUNDLE",
+    "REQUESTS_CA_BUNDLE",
+    "SSH_AUTH_SOCK"
+];
+export const NATIVE_AGENT_ENVIRONMENT_NAMES = [
+    "CODEX_HOME",
+    "CLAUDE_CONFIG_DIR"
+];
+export function nativeAgentEnvironmentNames(adapterId) {
+    switch (adapterId) {
+        case "codex": return ["CODEX_HOME"];
+        case "claude": return ["CLAUDE_CONFIG_DIR"];
+    }
+}
+export function selectEnvironment(source, names) {
+    const selected = {};
+    for (const name of names) {
+        const value = source[name];
+        if (value !== undefined)
+            selected[name] = value;
+    }
+    return selected;
+}
+function selectNonEmptyEnvironment(source, names) {
+    const selected = {};
+    for (const name of names) {
+        const value = source[name];
+        if (value !== undefined && value.length > 0)
+            selected[name] = value;
+    }
+    return selected;
+}
+export function operationalAgentEnvironment(adapterId, source) {
+    return {
+        ...selectNonEmptyEnvironment(source, [
+            ...AGENT_OPERATIONAL_ENVIRONMENT_NAMES,
+            ...nativeAgentEnvironmentNames(adapterId)
+        ]),
+        PATH: source.PATH
+            || `${dirname(process.execPath)}:/usr/local/bin:/usr/bin:/bin`,
+        HOME: source.HOME || homedir(),
+        TERM: usableInteractiveTerminal(source.TERM),
+        TMPDIR: source.TMPDIR || tmpdir()
+    };
+}
+export function configuredAgentLaunchEnvironment(agent, source) {
+    const { SSH_AUTH_SOCK: _sshAgent, ...operational } = operationalAgentEnvironment(agent.adapterId, source);
+    return {
+        ...operational,
+        ...resolveAgentEnvironment(agent, source)
+    };
+}

package/dist/agent/managedRuntimeEnvironment.js

@@ -0,0 +1,34 @@
+/**
+ * Environment values owned by Yui's managed runtime.
+ *
+ * These values carry control-plane, Task, workspace, launch, or exact-action
+ * identity. They are never user Agent environment bindings, and an ordinary
+ * repository test must not inherit them from the managed Session that launched
+ * the test command.
+ */
+export const YUI_MANAGED_RUNTIME_ENVIRONMENT_NAMES = Object.freeze([
+    "YUI_CLI_NAME",
+    "YUI_HOME",
+    "YUI_SESSION_SCOPE",
+    "YUI_TASK_ID",
+    "YUI_ROLE",
+    "YUI_AGENT_ID",
+    "YUI_ADAPTER_ID",
+    "YUI_WORKSPACE",
+    "YUI_RUN_ID",
+    "YUI_LAUNCH_ID",
+    "YUI_NATIVE_SESSION_ROOT",
+    "YUI_NATIVE_SESSION_ID",
+    "YUI_CONTROL_PLANE_DESCRIPTOR",
+    "YUI_TASK_RUNTIME_DESCRIPTOR",
+    "YUI_TASK_RUNTIME_ISOLATION_DESCRIPTOR",
+    "YUI_TASK_RUNTIME_SERVICE_NAMESPACE",
+    "YUI_SESSION_TITLE",
+    "YUI_AGENT_COMMAND",
+    "YUI_AGENT_BASE_ARGS",
+    "YUI_WRITABLE_PROJECT_IDS",
+    "YUI_CONTEXT_PROJECT_IDS",
+    "YUI_WORKSPACE_PROJECTS",
+    "YUI_LEADER_ACTION_RUN_ID",
+    "YUI_LEADER_ACTION_RECEIPT_ID"
+]);

package/dist/brief/taskBrief.js

@@ -1,8 +1,9 @@
 export function createTaskBrief(input, now) {
     return {
-        schemaVersion: 1,
+        schemaVersion: 2,
         objective: requireText(input.objective, "Task objective"),
         boundaries: normalizeBoundaries(input.boundaries),
+        technicalApproach: optionalText(input.technicalApproach, "Task technical approach"),
         currentFocus: requireText(input.currentFocus, "Current focus"),
         leaderSummary: requireText(input.leaderSummary, "Leader summary"),
         updatedAt: now.toISOString(),
@@ -13,6 +14,7 @@ export function updateTaskBrief(brief, patch, updatedBy, now) {
     return createTaskBrief({
         objective: patch.objective ?? brief.objective,
         boundaries: patch.boundaries ?? brief.boundaries,
+        technicalApproach: patch.technicalApproach ?? brief.technicalApproach,
         currentFocus: patch.currentFocus ?? brief.currentFocus,
         leaderSummary: patch.leaderSummary ?? brief.leaderSummary,
         updatedBy
@@ -35,3 +37,11 @@ function requireText(value, label) {
         throw new Error(`${label} is required.`);
     return normalized;
 }
+function optionalText(value, label) {
+    if (value === undefined)
+        return "";
+    if (typeof value !== "string" || value.includes("\0")) {
+        throw new Error(`${label} is invalid.`);
+    }
+    return value.trim();
+}

package/dist/cli/agentConfigurationPicker.js

@@ -0,0 +1,287 @@
+import { configurationField, defaultModel, modelChoice } from "../executor/agentConfigurationCatalog.js";
+import { renderTable } from "../output/table.js";
+const DEFAULT = "\0yui:cli-default";
+const CUSTOM = "\0yui:custom";
+const OMIT = "\0yui:omit";
+const COLUMNS = [
+    { header: "Value", minWidth: 12, maxWidth: 34 },
+    { header: "Details", minWidth: 16, maxWidth: 52 }
+];
+export async function selectAgentModelAndEffort(resolved, io, current) {
+    renderResolutionNotice(resolved, io);
+    const model = await selectModel(resolved, io, current.currentModel);
+    if (model === null)
+        return { kind: "cancelled" };
+    const record = modelChoice(resolved.catalog, model);
+    const currentEffort = model === current.currentModel
+        ? current.currentEffort
+        : undefined;
+    const effort = await selectEffortValue(resolved, io, model, record, currentEffort);
+    return effort.cancelled
+        ? { kind: "cancelled" }
+        : { kind: "selected", model, effort: effort.value };
+}
+export async function selectAgentEffort(resolved, io, input) {
+    renderResolutionNotice(resolved, io);
+    const effort = await selectEffortValue(resolved, io, input.model, modelChoice(resolved.catalog, input.model), input.currentEffort);
+    return effort.cancelled
+        ? { kind: "cancelled" }
+        : { kind: "selected", effort: effort.value };
+}
+/** Select provider-native permission settings in the adapter's canonical shape. */
+export async function selectAgentPermission(resolved, io, current) {
+    const strategyField = configurationField(resolved.catalog, "permission.strategy");
+    const strategyChoices = uniqueChoices(strategyField?.choices ?? [
+        { value: "default", label: "default" },
+        { value: "bypass", label: "bypass" },
+        { value: "configured", label: "configured" }
+    ], current.strategy);
+    const strategy = await choose("Select permission strategy", strategyChoices.map(({ value, label, description }) => ({
+        value,
+        label,
+        detail: description ?? value
+    })), io, current.strategy, "permission strategy");
+    if (strategy === undefined)
+        return { kind: "cancelled" };
+    if (strategy === "default" || strategy === "bypass") {
+        return { kind: "selected", permission: { strategy } };
+    }
+    if (resolved.catalog.adapterId === "codex") {
+        const codex = current.strategy === "configured"
+            ? current
+            : undefined;
+        const sandbox = await selectPermissionField(resolved, io, "permission.sandbox", codex?.sandbox, codex === undefined ? "workspace-write" : OMIT);
+        if (sandbox.kind === "cancelled")
+            return sandbox;
+        const approval = await selectPermissionField(resolved, io, "permission.approval", codex?.approval, codex === undefined ? "on-request" : OMIT);
+        if (approval.kind === "cancelled")
+            return approval;
+        const permission = {
+            ...(codex ?? { strategy: "configured" })
+        };
+        if (sandbox.value === undefined)
+            delete permission.sandbox;
+        else
+            permission.sandbox = sandbox.value;
+        if (approval.value === undefined)
+            delete permission.approval;
+        else
+            permission.approval = approval.value;
+        return {
+            kind: "selected",
+            permission: permission
+        };
+    }
+    const claude = current.strategy === "configured"
+        ? current
+        : undefined;
+    const mode = await selectPermissionField(resolved, io, "permission.mode", claude?.mode, claude === undefined ? undefined : OMIT);
+    if (mode.kind === "cancelled")
+        return mode;
+    const permission = {
+        ...(claude ?? { strategy: "configured" })
+    };
+    if (mode.value === undefined)
+        delete permission.mode;
+    else
+        permission.mode = mode.value;
+    return {
+        kind: "selected",
+        permission: permission
+    };
+}
+export function renderAgentConfigurationResolutionNotice(resolved) {
+    const lines = [];
+    if (resolved.source === "cache") {
+        lines.push(`! Runtime capability request failed (${resolved.failure?.message ?? "unknown failure"}). `
+            + `Showing cached options from ${resolved.fetchedAt ?? "an earlier request"}; they may be stale.`);
+    }
+    else if (resolved.source === "fallback") {
+        lines.push(`! Runtime capability request failed (${resolved.failure?.message ?? "unknown failure"}). `
+            + "No matching cache is available; only fallback and custom values can be offered.");
+    }
+    lines.push(...resolved.catalog.warnings.map((warning) => `! Agent catalog warning: ${warning}`));
+    return lines.length === 0 ? "" : `${lines.join("\n")}\n`;
+}
+async function selectModel(resolved, io, current) {
+    const catalogDefault = defaultModel(resolved.catalog);
+    const choices = [
+        {
+            value: DEFAULT,
+            label: "CLI default",
+            detail: catalogDefault === undefined
+                ? "Follow the Agent CLI default"
+                : `${catalogDefault.label}${catalogDefault.resolvedModel === undefined
+                    ? "" : ` (${catalogDefault.resolvedModel})`}`,
+            aliases: ["default"]
+        },
+        ...resolved.catalog.models.map((model) => ({
+            value: model.value,
+            label: model.label,
+            detail: [
+                model.description ?? model.value,
+                model.isDefault ? "Reported CLI default model" : undefined
+            ].filter((part) => part !== undefined).join("; ")
+        })),
+        ...(current === undefined || resolved.catalog.models.some((model) => model.value === current)
+            ? []
+            : [{ value: current, label: current, detail: "Current value; not reported by this catalog" }]),
+        {
+            value: CUSTOM,
+            label: "Custom…",
+            detail: "Enter another model value",
+            aliases: ["custom"]
+        }
+    ];
+    const selected = await choose("Select model", choices, io, current === undefined ? DEFAULT : current, "model");
+    if (selected === undefined)
+        return null;
+    if (selected === DEFAULT)
+        return undefined;
+    if (selected !== CUSTOM)
+        return selected;
+    const custom = (await io.question("Custom model: "))?.trim();
+    return custom === undefined || custom.length === 0 ? null : custom;
+}
+async function selectEffortValue(resolved, io, model, record, current) {
+    const customModel = record === undefined && model !== undefined;
+    const efforts = customModel
+        ? observedEfforts(resolved.catalog.models)
+        : record?.efforts ?? [];
+    if (!customModel && record !== undefined && efforts.length === 0) {
+        io.write(`○ ${record.label} does not report configurable reasoning effort; using CLI default.\n`);
+        return { cancelled: false };
+    }
+    const choices = [
+        {
+            value: DEFAULT,
+            label: "CLI default",
+            detail: record?.defaultEffort === undefined
+                ? "Follow the selected model default"
+                : record.defaultEffort,
+            aliases: ["default"]
+        },
+        ...efforts.map((effort) => ({
+            value: effort.value,
+            label: effort.label,
+            detail: customModel
+                ? "Observed for another model; compatibility is unverified"
+                : effort.description ?? "Supported by selected model"
+        })),
+        ...(current === undefined || efforts.some((effort) => effort.value === current)
+            ? []
+            : [{ value: current, label: current, detail: "Current value; not reported for selected model" }]),
+        ...(!customModel && record !== undefined && record.efforts.length === 0
+            ? []
+            : [{
+                    value: CUSTOM,
+                    label: "Custom…",
+                    detail: "Enter another effort value",
+                    aliases: ["custom"]
+                }])
+    ];
+    const selected = await choose("Select reasoning effort", choices, io, current === undefined ? DEFAULT : current, "effort");
+    if (selected === undefined)
+        return { cancelled: true };
+    if (selected === DEFAULT)
+        return { cancelled: false };
+    if (selected !== CUSTOM)
+        return { cancelled: false, value: selected };
+    const custom = (await io.question("Custom reasoning effort: "))?.trim();
+    return custom === undefined || custom.length === 0
+        ? { cancelled: true }
+        : { cancelled: false, value: custom };
+}
+function observedEfforts(models) {
+    const observed = new Map();
+    for (const effort of models.flatMap((model) => model.efforts)) {
+        if (!observed.has(effort.value))
+            observed.set(effort.value, effort);
+    }
+    return [...observed.values()];
+}
+async function selectPermissionField(resolved, io, key, current, defaultValue) {
+    const field = configurationField(resolved.catalog, key);
+    const fallback = key === "permission.sandbox"
+        ? ["read-only", "workspace-write", "danger-full-access"]
+        : key === "permission.approval"
+            ? ["untrusted", "on-request", "never"]
+            : ["acceptEdits", "auto", "bypassPermissions", "manual", "dontAsk", "plan"];
+    const choices = uniqueChoices(field === undefined
+        ? fallback.map((value) => ({ value, label: value }))
+        : field.choices, current);
+    const includeOmit = defaultValue === OMIT || current !== undefined;
+    const pickerChoices = [
+        ...(includeOmit
+            ? [{ value: OMIT, label: "Omit", detail: "Do not pass this provider option" }]
+            : []),
+        ...choices.map(({ value, label, description }) => ({
+            value,
+            label,
+            detail: description ?? value
+        })),
+        ...(field?.allowCustom === true
+            ? [{ value: CUSTOM, label: "Custom…", detail: "Enter another provider value" }]
+            : [])
+    ];
+    const selected = await choose(`Select ${key}`, pickerChoices, io, current ?? defaultValue ?? pickerChoices[0]?.value ?? OMIT, key);
+    if (selected === undefined)
+        return { kind: "cancelled" };
+    if (selected === OMIT)
+        return { kind: "selected", value: undefined };
+    if (selected === CUSTOM) {
+        const custom = (await io.question(`Custom ${key}: `))?.trim();
+        return custom === undefined || custom.length === 0
+            ? { kind: "cancelled" }
+            : { kind: "selected", value: custom };
+    }
+    return { kind: "selected", value: selected };
+}
+function uniqueChoices(choices, current) {
+    const seen = new Set();
+    const result = [];
+    for (const choice of choices) {
+        if (seen.has(choice.value))
+            continue;
+        seen.add(choice.value);
+        result.push(choice);
+    }
+    if (current !== undefined && !seen.has(current)) {
+        result.push({
+            value: current,
+            label: current,
+            description: "Current value; not reported by this catalog"
+        });
+    }
+    return result;
+}
+function renderResolutionNotice(resolved, io) {
+    const notice = renderAgentConfigurationResolutionNotice(resolved);
+    if (notice.length > 0)
+        io.write(notice);
+}
+async function choose(title, choices, io, defaultValue, label) {
+    io.write(`${renderTable(title, [{ header: "#", minWidth: 1, maxWidth: 4 }, ...COLUMNS], choices.map((choice, index) => [
+        String(index + 1),
+        choice.label,
+        choice.detail
+    ]), io.width)}\n\n`);
+    const defaultLabel = choices.find((choice) => choice.value === defaultValue)?.label
+        ?? defaultValue;
+    const answer = (await io.question(`Choose ${label} [1-${choices.length}/value, q; default ${defaultLabel}]: `))?.trim();
+    if (answer === undefined || answer.toLowerCase() === "q" || answer.toLowerCase() === "quit") {
+        return undefined;
+    }
+    if (answer.length === 0) {
+        return choices.some((choice) => choice.value === defaultValue)
+            ? defaultValue
+            : choices[0]?.value;
+    }
+    const numeric = Number(answer);
+    if (Number.isSafeInteger(numeric) && numeric >= 1 && numeric <= choices.length) {
+        return choices[numeric - 1]?.value;
+    }
+    return choices.find((choice) => choice.value === answer)?.value
+        ?? choices.find((choice) => choice.aliases?.includes(answer) === true)?.value
+        ?? (choices.some((choice) => choice.value === CUSTOM) ? answer : undefined);
+}