@zq-silk/yui 0.16.1 → 1.0.0-alpha

package/dist/executor/agentConfigurationFields.js

@@ -0,0 +1,120 @@
+// These are Yui's accepted configuration values, not a native capability probe.
+// Keep existing explicit configuration legal; current native choices come from
+// help and requirements, and may be a smaller set.
+export const CODEX_SANDBOXES = ["read-only", "workspace-write", "danger-full-access"];
+export const CODEX_APPROVALS = ["untrusted", "on-request", "never"];
+export const STATIC_CONFIGURATION_NOTICE = "Static adapter configuration contracts are not native enumeration or proof of Provider acceptance; see field reasons.";
+export function staticAgentConfigurationFields(id) {
+    const fields = [
+        staticField("model", [], true, "Model values require native metadata; custom IDs remain explicit input."),
+        staticField("effort", [], true, "Effort values depend on the selected native model."),
+        staticField("permission.strategy", ["default", "bypass", "configured"], false, "These are Yui strategies, not Provider modes.")
+    ];
+    if (id === "codex")
+        return [
+            ...fields,
+            staticField("permission.sandbox", CODEX_SANDBOXES, false),
+            staticField("permission.approval", CODEX_APPROVALS, false, "Native versions may retire values accepted by the adapter."),
+            staticField("search", ["true"], false),
+            staticField("profile", [], true),
+            staticField("additionalDirectories", [], true)
+        ];
+    if (id === "acp")
+        return [
+            ...fields,
+            staticField("permission.mode", [], true, "Mode IDs are enumerated per Session and checked at launch."),
+            staticField("additionalDirectories", [], true, "Delivery requires the Agent's initialize capability; it is unverified offline.")
+        ];
+    return [
+        ...fields,
+        staticField("permission.mode", [], true, "No native modes were enumerated."),
+        staticField("permission.allowedTools", [], true),
+        staticField("permission.disallowedTools", [], true),
+        staticField("settingsSources", ["user", "project", "local"], false),
+        staticField("settingsFile", [], true),
+        staticField("additionalDirectories", [], true)
+    ];
+}
+function staticField(key, values, allowCustom, detail = "") {
+    return {
+        key, choices: values.map(value => ({ value, label: value })), allowCustom,
+        reason: `Static adapter configuration contract; native support is unverified.${detail ? ` ${detail}` : ""}`
+    };
+}
+/** One help interpretation shared by installation inspection and live probes. */
+export function configurationFieldsFromHelp(id, help) {
+    const fields = staticAgentConfigurationFields(id);
+    if (id === "acp")
+        return fields;
+    const bypassFlag = id === "codex"
+        ? "--dangerously-bypass-approvals-and-sandbox" : "--dangerously-skip-permissions";
+    const replacements = [
+        {
+            ...staticField("permission.strategy", [
+                "default", ...(configurationFlagAvailable(help, bypassFlag) ? ["bypass"] : []), "configured"
+            ], false),
+            reason: `Static Yui strategies; ${bypassFlag} ${configurationFlagAvailable(help, bypassFlag) ? "reported" : "not reported"} by native --help. This does not confirm account policy.`
+        },
+        ...(id === "codex"
+            ? [
+                helpChoiceField("permission.sandbox", help, "--sandbox", false, CODEX_SANDBOXES),
+                helpChoiceField("permission.approval", help, "--ask-for-approval", false, CODEX_APPROVALS)
+            ]
+            : [
+                helpChoiceField("permission.mode", help, "--permission-mode", true),
+                helpChoiceField("effort", help, "--effort", true),
+                // The CLI's description often names settings sources without an enum.
+                // Retain the explicit static contract, never relabel it as discovery.
+                ...(configurationHelpChoices(help, "--setting-sources").length === 0 ? []
+                    : [helpChoiceField("settingsSources", help, "--setting-sources", false)])
+            ])
+    ];
+    const byKey = new Map(replacements.map(value => [value.key, value]));
+    return fields.map(value => byKey.get(value.key) ?? value);
+}
+function helpChoiceField(key, help, flag, allowCustom, supported) {
+    const reported = configurationHelpChoices(help, flag);
+    const values = supported === undefined ? reported : reported.filter(value => supported.includes(value));
+    return {
+        key, choices: values.map(value => ({ value, label: value })), allowCustom,
+        available: values.length > 0,
+        reason: values.length > 0
+            ? `Native --help ${flag} enumeration${supported === undefined ? "" : ", limited to adapter-supported values"}.`
+            : `Native enumeration unavailable: ${flag} values were not reported or are not supported by this adapter.`
+    };
+}
+export function configurationFieldWarnings(fields) {
+    return [
+        STATIC_CONFIGURATION_NOTICE,
+        ...fields.filter(field => field.available === false)
+            .map(field => `${field.key}: ${field.reason ?? "Native capability unavailable."}`)
+    ];
+}
+/** Read only an explicit native enum. Prose examples and missing fields are not choices. */
+export function configurationHelpChoices(help, flag) {
+    const section = helpSection(help, flag);
+    if (section === undefined)
+        return [];
+    const inline = /(?:\[possible values:\s*([^\]]+)\]|\(choices:\s*([^)]*)\))/i.exec(section);
+    const declared = inline?.[1] ?? inline?.[2];
+    const bullets = declared === undefined && /Possible values:/i.test(section)
+        ? [...section.matchAll(/^\s*-\s*([\w.+-]+)\s*:/gm)].map(match => match[1] ?? "")
+        : [];
+    return [...new Set((declared ?? bullets.join(",")).replace(/["']/g, "").split(",")
+            .map(value => value.trim().replace(/\.$/, "")).filter(value => /^[\w.+-]+$/.test(value)))];
+}
+export function configurationFlagAvailable(help, flag) {
+    return helpSection(help, flag) !== undefined;
+}
+function helpSection(help, flag) {
+    const lines = help.replace(/\r\n/g, "\n").split("\n");
+    const escaped = flag.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const declaration = new RegExp(`^\\s*(?:-[A-Za-z],?\\s+)?${escaped}(?=[\\s=,<\\[]|$)`);
+    const start = lines.findIndex(line => declaration.test(line));
+    if (start < 0)
+        return undefined;
+    let end = start + 1;
+    while (end < lines.length && !/^\s*(?:-[A-Za-z],?\s+|--)[\w-]/.test(lines[end]))
+        end++;
+    return lines.slice(start, end).join("\n");
+}

package/dist/executor/agentConfigurationProbe.js

@@ -9,6 +9,7 @@ import { codexClientInitialization } from "../runtime/codexAppServerRuntime.js";
 import { acpInitializeRequest, readAcpInitializeResult } from "../runtime/acpProtocol.js";
 import { handshakeObservationFrom } from "../runtime/agentRunConfiguration.js";
 import { YUI_VERSION } from "../version.js";
+import { configurationFieldsFromHelp, configurationFieldWarnings, STATIC_CONFIGURATION_NOTICE } from "./agentConfigurationFields.js";
 /**
  * Codex and Claude Code are configured by flags and their own files; neither
  * plan exchanges capabilities on connect. Saying so explicitly keeps a caller
@@ -20,8 +21,6 @@ const NO_HANDSHAKE = Object.freeze({
 });
 const MAX_OUTPUT_BYTES = 1024 * 1024;
 const PROCESS_TERMINATION_GRACE_MS = 100;
-const CODEX_SANDBOXES = ["read-only", "workspace-write", "danger-full-access"];
-const CODEX_APPROVALS = ["untrusted", "on-request", "never"];
 const ACP_PROBE_REQUEST_ID = 1;
 export async function discoverCodexConfiguration(input) {
     const environment = configuredAgentLaunchEnvironment(input.agent, input.environment);
@@ -43,17 +42,35 @@ export async function discoverCodexConfiguration(input) {
             client.request("configRequirements/read", {}),
             client.request("modelProvider/capabilities/read", {})
         ]);
-        const requirements = object(requirementsResult)?.requirements;
-        const requirementRecord = object(requirements);
+        const requirements = requiredObject(requirementsResult, "Codex configuration requirements response").requirements;
+        const requirementRecord = requirements === null ? undefined
+            : requiredObject(requirements, "Codex configuration requirements");
         const allowedSandboxes = optionalStrings(requirementRecord?.allowedSandboxModes);
-        const allowedApprovals = optionalStrings(requirementRecord?.allowedApprovalPolicies);
+        const allowedApprovals = optionalApprovalChoices(requirementRecord?.allowedApprovalPolicies);
         const allowedWebSearchModes = optionalStrings(requirementRecord?.allowedWebSearchModes);
-        const capabilityRecord = object(providerCapabilities);
-        const webSearch = capabilityRecord?.webSearch === true
+        const capabilityRecord = requiredObject(providerCapabilities, "Codex Provider capabilities");
+        if (typeof capabilityRecord.webSearch !== "boolean") {
+            throw new Error("Codex Provider capabilities did not report webSearch.");
+        }
+        const webSearch = capabilityRecord.webSearch
             && (allowedWebSearchModes === undefined || allowedWebSearchModes.includes("live"));
-        const bypass = configurationFlagAvailable(help, "--dangerously-bypass-approvals-and-sandbox");
-        const sandboxChoices = intersectChoices(configurationHelpChoices(help, "--sandbox", CODEX_SANDBOXES), allowedSandboxes);
-        const approvalChoices = intersectChoices(configurationHelpChoices(help, "--ask-for-approval", CODEX_APPROVALS), allowedApprovals);
+        const fields = configurationFieldsFromHelp("codex", help).map(candidate => {
+            const allowed = candidate.key === "permission.sandbox" ? allowedSandboxes
+                : candidate.key === "permission.approval" ? allowedApprovals : undefined;
+            if (allowed !== undefined) {
+                const choices = candidate.choices.filter(choice => allowed.includes(choice.value));
+                return {
+                    ...candidate, choices, available: choices.length > 0,
+                    reason: `${candidate.reason} Native configuration requirements applied.${choices.length === 0 ? " No usable values were confirmed." : ""}`
+                };
+            }
+            if (candidate.key === "search")
+                return field("search", webSearch ? [choice("true")] : [], false, webSearch, webSearch ? "Native Provider capability and configuration requirements permit live web search."
+                    : "Live web search is unavailable or disallowed.");
+            if (candidate.key === "profile")
+                return codexProfileField(environment);
+            return candidate;
+        });
         return {
             schemaVersion: 1,
             agentId: input.agent.id,
@@ -61,21 +78,8 @@ export async function discoverCodexConfiguration(input) {
             ...(semanticVersion(version) === undefined ? {} : { cliVersion: semanticVersion(version) }),
             handshake: NO_HANDSHAKE,
             models,
-            fields: [
-                field("model", [], true),
-                field("effort", [], true),
-                field("permission.strategy", [
-                    choice("default"),
-                    ...(bypass ? [choice("bypass")] : []),
-                    choice("configured")
-                ], false, true, bypass ? undefined : "Codex bypass strategy is unavailable."),
-                field("permission.sandbox", sandboxChoices.map(choice), false),
-                field("permission.approval", approvalChoices.map(choice), false),
-                field("search", webSearch ? [choice("true")] : [], false, webSearch, webSearch ? undefined : "Live web search is unavailable or disallowed."),
-                field("profile", codexProfileChoices(environment).map(choice), true),
-                field("additionalDirectories", [], true)
-            ],
-            warnings: client.warnings()
+            fields,
+            warnings: [...client.warnings(), ...configurationFieldWarnings(fields)]
         };
     }
     finally {
@@ -105,9 +109,7 @@ export async function discoverClaudeConfiguration(input) {
     ]);
     const initialized = object(initialization);
     const models = array(initialized?.models, "Claude model catalog").map(claudeModel);
-    const permissionModes = configurationHelpChoices(help, "--permission-mode", []);
-    const bypass = configurationFlagAvailable(help, "--dangerously-skip-permissions");
-    const settingsSources = configurationHelpChoices(help, "--setting-sources", ["user", "project", "local"]);
+    const fields = configurationFieldsFromHelp("claude", help);
     return {
         schemaVersion: 1,
         agentId: input.agent.id,
@@ -115,22 +117,8 @@ export async function discoverClaudeConfiguration(input) {
         ...(semanticVersion(version) === undefined ? {} : { cliVersion: semanticVersion(version) }),
         handshake: NO_HANDSHAKE,
         models,
-        fields: [
-            field("model", [], true),
-            field("effort", [], true),
-            field("permission.strategy", [
-                choice("default"),
-                ...(bypass ? [choice("bypass")] : []),
-                choice("configured")
-            ], false, true, bypass ? undefined : "Claude bypass strategy is unavailable."),
-            field("permission.mode", permissionModes.map(choice), true),
-            field("permission.allowedTools", [], true),
-            field("permission.disallowedTools", [], true),
-            field("settingsSources", settingsSources.map(choice), false),
-            field("settingsFile", [], true),
-            field("additionalDirectories", [], true)
-        ],
-        warnings: []
+        fields,
+        warnings: configurationFieldWarnings(fields)
     };
 }
 async function listCodexModels(client) {
@@ -283,7 +271,7 @@ async function requestClaudeInitialization(command, args, cwd, environment, sign
 export async function discoverAcpConfiguration(input) {
     const environment = configuredAgentLaunchEnvironment(input.agent, input.environment);
     const negotiated = await requestAcpInitialization(input.agent.command, [...input.agent.baseArgs], input.cwd, environment, input.signal);
-    const warnings = [];
+    const warnings = [STATIC_CONFIGURATION_NOTICE];
     if (!negotiated.capabilities.loadSession) {
         warnings.push("This ACP Agent does not support `session/load`, so a managed Yui Turn "
             + "cannot survive a Provider restart.");
@@ -331,7 +319,7 @@ export async function discoverAcpConfiguration(input) {
             field("effort", [], true, true, "ACP selects reasoning effort with session/set_config_option, under the "
                 + "`thought_level` category. As with the model, the accepted values are "
                 + "negotiated per Session and verified at launch rather than listed here."),
-            field("permission.strategy", [choice("default"), choice("bypass"), choice("configured")], false, true, "`default` sends no mode, so the Agent's own default stands. `configured` "
+            field("permission.strategy", [choice("default"), choice("bypass"), choice("configured")], false, true, "Static Yui strategies: `default` sends no mode, so the Agent's own default stands. `configured` "
                 + "selects one exact mode the Agent offers. `bypass` applies the mode that "
                 + "grants unattended action, and only for an execution component Yui can "
                 + "identify — it is never guessed from a mode's name. None of these change "
@@ -573,47 +561,34 @@ function terminateProcess(child) {
     child.once("exit", () => { clearTimeout(force); });
     child.kill("SIGTERM");
 }
-export function codexProfileChoices(environment) {
+function codexProfileField(environment) {
     const root = environment.CODEX_HOME
         ?? join(environment.HOME ?? homedir(), ".codex");
     try {
         const profiles = object(parse(readFileSync(join(root, "config.toml"), "utf8")).profiles);
-        return Object.keys(profiles ?? {}).filter((name) => name.trim().length > 0 && !name.includes("\0")).sort();
-    }
-    catch {
-        return [];
+        const names = Object.keys(profiles ?? {}).filter((name) => name.trim().length > 0 && !name.includes("\0")).sort();
+        return field("profile", names.map(choice), true, undefined, "Local config.toml profile names, not a Provider enumeration; custom names remain explicit input.");
     }
-}
-export function configurationHelpChoices(help, flag, fallback) {
-    const lines = help.replace(/\r\n/g, "\n").split("\n");
-    const start = lines.findIndex((line) => line.includes(flag));
-    if (start < 0)
-        return [...fallback];
-    let end = start + 1;
-    while (end < lines.length && !/^\s{2,}(?:-[A-Za-z](?:,\s*)?|--)[\w-]/.test(lines[end] ?? "")) {
-        end += 1;
+    catch (error) {
+        const absent = error instanceof Error && "code" in error && error.code === "ENOENT";
+        return field("profile", [], true, absent ? undefined : false, absent
+            ? "No local config.toml; no profile names observed. Custom names remain explicit input."
+            : "Local config.toml could not be read or parsed; profile enumeration unavailable.");
     }
-    const section = lines.slice(start, end).join("\n");
-    const inline = /(?:\[possible values:\s*([^\]]+)\]|\(choices:\s*([^)]*)\))/i
-        .exec(section);
-    const declared = inline?.[1] ?? inline?.[2];
-    const bulletValues = declared === undefined && /Possible values:/i.test(section)
-        ? [...section.matchAll(/^\s*-\s*([\w.+-]+)\s*:/gm)].map((match) => match[1] ?? "")
-        : [];
-    const parsed = [...new Set((declared ?? bulletValues.join(","))
-            .replace(/["']/g, "")
-            .split(",")
-            .map((value) => value.trim().replace(/\.$/, ""))
-            .filter((value) => /^[\w.+-]+$/.test(value)))];
-    return parsed.length === 0 ? [...fallback] : parsed;
-}
-function configurationFlagAvailable(help, flag) {
-    return help.replace(/\r\n/g, "\n").split("\n").some((line) => line.includes(flag));
 }
-function intersectChoices(choices, allowed) {
-    return allowed === undefined
-        ? [...choices]
-        : choices.filter((candidate) => allowed.includes(candidate));
+function optionalApprovalChoices(value) {
+    if (value === null || value === undefined)
+        return undefined;
+    // Current Codex also reports structured granular policies. They constrain
+    // configuration but cannot be selected by Yui's scalar approval input; do not
+    // reject the whole legitimate response or expand them into guessed aliases.
+    return array(value, "configuration approval requirements").flatMap(entry => {
+        if (typeof entry === "string")
+            return [requiredString(entry, "approval requirement")];
+        if (object(object(entry)?.granular) !== undefined)
+            return [];
+        throw new Error("Codex configuration approval requirement is invalid.");
+    });
 }
 function optionalStrings(value) {
     if (value === null || value === undefined)

package/dist/executor/agentExecutor.js

@@ -7,7 +7,7 @@ import { builtinAgentEndpointImplementation, validateAgentEndpointImplementation
 /** Recovery addresses retained execution identity, not a live Session grant.
  * A released Session cache can be absent while its native binding still needs
  * to be stopped. No active Session record is fabricated by this projection. */
-export function taskRoleControlTarget(set) {
+export function roleSessionControlTarget(set) {
     if (set == null)
         return undefined;
     const current = set.sessions[set.activeAgentId];
@@ -19,7 +19,10 @@ export function taskRoleControlTarget(set) {
     const agentId = fromBinding ? binding.accountScope : current?.agentId;
     if (nativeSessionId === undefined || agentId === undefined)
         return undefined;
-    const session = [...Object.values(set.sessions), ...(set.history ?? [])]
+    const history = set.owner.scope === "global"
+        ? Object.values(set.history ?? {})
+        : set.history ?? [];
+    const session = [...Object.values(set.sessions), ...history]
         .find(entry => entry.nativeSessionId === nativeSessionId && entry.agentId === agentId);
     const adapterId = session?.adapterId ?? (binding === null ? undefined : builtinAgentDriverRegistry().find(binding.providerNamespace)?.adapterId);
     return { nativeSessionId, agentId, adapterId, status: session?.status,
@@ -33,10 +36,10 @@ export function createRoleSessionSet(owner, activeAgentId, now) {
         updatedAt: now.toISOString()
     };
     return owner.scope === "global"
-        ? { ...base, schemaVersion: 5, providerBinding: null }
+        ? { ...base, schemaVersion: 1, providerBinding: null }
         : {
             ...base,
-            schemaVersion: 12,
+            schemaVersion: 1,
             providerBinding: null
         };
 }
@@ -103,7 +106,7 @@ export function recordRoleAgentSession(set, input, now) {
         throw new Error("A native Session cannot change its Endpoint implementation in place.");
     }
     const session = {
-        schemaVersion: 6,
+        schemaVersion: 1,
         agentId,
         adapterId,
         nativeSessionId,
@@ -461,7 +464,7 @@ export function validateRoleSessionSet(set) {
         validateRoleAgentSession(session, agentId);
     }
     if (set.owner.scope === "global") {
-        if (set.schemaVersion !== 5) {
+        if (set.schemaVersion !== 1) {
             throw new Error("Global Role session set schema version is invalid.");
         }
         const globalSet = set;
@@ -500,7 +503,7 @@ export function validateRoleSessionSet(set) {
         }
     }
     else {
-        if (set.schemaVersion !== 12) {
+        if (set.schemaVersion !== 1) {
             throw new Error("Task Role session set schema version is invalid.");
         }
         if (!Object.hasOwn(set, "providerBinding")) {
@@ -547,7 +550,7 @@ export function validateRoleSessionSet(set) {
     return set;
 }
 export function validateRoleAgentSession(session, expectedAgentId = session.agentId) {
-    if (session.schemaVersion !== 6) {
+    if (session.schemaVersion !== 1) {
         throw new Error(`Role Agent session schema version is invalid: ${expectedAgentId}.`);
     }
     const agentId = requireSafeIdentity(session.agentId, "Agent id");

package/dist/executor/effectiveLaunch.js

@@ -172,8 +172,8 @@ function sessionContinuitySnapshot(snapshot) {
     };
 }
 export function validateEffectiveLaunchSnapshot(snapshot) {
-    if (snapshot.schemaVersion !== 4) {
-        throw new Error("Effective launch snapshot must use schemaVersion 4.");
+    if (snapshot.schemaVersion !== 1) {
+        throw new Error("Effective launch snapshot must use schemaVersion 1.");
     }
     if (snapshot.executionAuthority !== "planning" && snapshot.executionAuthority !== "delivery") {
         throw new Error("Effective launch requires its captured execution authority.");
@@ -278,7 +278,7 @@ function snapshotFromConfig(input) {
             reviewBaseCommit: commit(input.reviewBaseCommit ?? "", "Review base commit")
         };
     const common = {
-        schemaVersion: 4,
+        schemaVersion: 1,
         executionAuthority: input.executionAuthority,
         sourceDesiredRevision: positiveInteger(input.sourceDesiredRevision, "Source desired revision"),
         agentId: identity(input.agentId, "Effective Agent id"),

package/dist/executor/executorRegistry.js

@@ -176,15 +176,6 @@ export class ExecutorRegistry {
         });
         return deliveryReport(outcome);
     }
-    async notifyOperatorInputOnce(input) {
-        if (this.runtimePorts?.notifyOperatorInputOnce !== undefined) {
-            return this.runtimePorts.notifyOperatorInputOnce(input);
-        }
-        const probe = this.readiness(input.adapterId, "operator");
-        return this.tmux.sendRoleInputOnceIfReadyAsync === undefined
-            ? this.tmux.sendRoleInputOnceIfReady("operator", input.roleName, input.receiptId, input.text, probe)
-            : this.tmux.sendRoleInputOnceIfReadyAsync("operator", input.roleName, input.receiptId, input.text, probe);
-    }
     forgetPrepared(input) {
         for (const [deliveryId, prepared] of this.#prepared) {
             const delivery = prepared.delivery;

package/dist/executor/fileRoleLaunchPlanner.js

@@ -21,7 +21,7 @@ import { resolveTaskRoleSessionTitle } from "../runtime/sessionTitle.js";
 import { parseTaskRuntimeIsolationDescriptor, taskRuntimeIsolationEnvironment } from "../runtime/taskRuntimeIsolation.js";
 import { planningRuntimeCwd } from "../storage/homeLayout.js";
 import { resolveAgentAdapter } from "./agentAdapter.js";
-import { activeLiveRoleAgentSession, taskRoleControlTarget } from "./agentExecutor.js";
+import { activeLiveRoleAgentSession, roleSessionControlTarget } from "./agentExecutor.js";
 import { assertCodexLaunchOverridesAvailable, inspectCodexLaunchConfig } from "./codexConfigConflict.js";
 import { effectiveRoleForLaunch, resolveEffectiveLaunch, roleSessionMayContinue } from "./effectiveLaunch.js";
 import { classifyWorkspacePreflight, formatWorkspacePreflightError } from "./workspacePreflightClassification.js";
@@ -69,9 +69,11 @@ export class FileRoleLaunchPlanner {
     }
     /** Recovery addresses the recorded Agent/Session, independent of delivery
      * admission, a missing worktree, or the old Endpoint code generation. */
-    planNativeControl(taskId, roleName) {
-        const set = this.store.getTaskRoleSessionSet(taskId, roleName);
-        const session = taskRoleControlTarget(set);
+    planNativeControl(owner) {
+        const set = owner.scope === "task"
+            ? this.store.getTaskRoleSessionSet(owner.taskId, owner.roleName)
+            : this.store.getGlobalRoleSessionSet(owner.roleName);
+        const session = roleSessionControlTarget(set);
         if (session?.adapterId !== "codex")
             throw new Error("Native metadata control requires a recorded Codex Session.");
         const configured = this.store.getConfiguredAgent(session.agentId);
@@ -79,9 +81,11 @@ export class FileRoleLaunchPlanner {
             throw new Error("The recorded native Agent connection is unavailable.");
         }
         const agent = configuredAgentToDefinition(configured);
-        const connection = this.store.listEvents(taskId).find(event => event.type === "runtime.native-connection-bound"
-            && event.payload.roleName === roleName && event.payload.agentId === session.agentId
-            && event.payload.nativeSessionId === session.nativeSessionId)?.payload;
+        const connection = owner.scope === "task"
+            ? this.store.listEvents(owner.taskId).find(event => event.type === "runtime.native-connection-bound"
+                && event.payload.roleName === owner.roleName && event.payload.agentId === session.agentId
+                && event.payload.nativeSessionId === session.nativeSessionId)?.payload
+            : undefined;
         return {
             command: configured.command, args: [...agent.baseArgs, "app-server", "proxy"], cwd: this.home,
             expectedAccountHome: connection?.nativeAccountHome,
@@ -758,10 +762,7 @@ function managedClaudeControlPlaneConfig(config, taskId, workItemId, runId) {
 }
 function isManagedYuiBashRule(rule) {
     const normalized = rule.trim();
-    return /^Bash\(yui(?:\s|:\*|\*|\))/u.test(normalized)
-        // Yui no longer writes a control-plane digest into a managed rule; this
-        // shape only clears one an earlier release left in a Provider config.
-        || /^Bash\(.*\s--yui-control\s/u.test(normalized);
+    return /^Bash\(yui(?:\s|:\*|\*|\))/u.test(normalized);
 }
 function canonicalPath(path) {
     const absolute = resolve(path);

package/dist/grant/capabilityGrant.js

@@ -1,6 +1,6 @@
 import { requireIdentity, requireText, requireTimestamp, requirePositiveInteger } from "../domain/validation.js";
 import { validateTaskRecordReference } from "../task/taskRecordReference.js";
-export const CAPABILITY_GRANT_SCHEMA_VERSION = 2;
+export const CAPABILITY_GRANT_SCHEMA_VERSION = 1;
 const IRREVERSIBILITY_RANK = {
     none: 0,
     reversible: 1,
@@ -105,7 +105,7 @@ export function revokeGrant(grant, revokedBy, now) {
 }
 export function validateCapabilityGrant(grant) {
     if (grant.schemaVersion !== CAPABILITY_GRANT_SCHEMA_VERSION) {
-        throw new Error("Capability grant must use schemaVersion 2.");
+        throw new Error("Capability grant must use schemaVersion 1.");
     }
     validateTaskRecordReference({ taskId: grant.taskId, localId: grant.id }, "capabilityGrant");
     requireIdentity(grant.taskId, "Task id");

package/dist/input/inputRequest.js

@@ -14,7 +14,7 @@ export function createInputRequest(id, taskId, requester, input, now) {
     const timestamp = requireDate(now, "Input request creation time");
     const choices = normalizeChoices(input.choices);
     return validateInputRequest({
-        schemaVersion: 3,
+        schemaVersion: 1,
         id: requireIdentity(id, "Input request id"),
         taskId: requireIdentity(taskId, "Input request Task id"),
         requester: normalizeRequester(requester),
@@ -72,12 +72,12 @@ export function validateInputRequest(value) {
         "schemaVersion", "id", "taskId", "requester", "question", "choices",
         "blockedRefs", "policy", "status", "createdAt", "updatedAt", ...terminalField
     ], "Input request");
-    if (request.schemaVersion !== 3)
-        throw new Error("Input request must use schemaVersion 3.");
+    if (request.schemaVersion !== 1)
+        throw new Error("Input request must use schemaVersion 1.");
     const choices = validateChoices(request.choices);
     const createdAt = requireTimestamp(request.createdAt, "Input request createdAt");
     const base = {
-        schemaVersion: 3,
+        schemaVersion: 1,
         id: requireIdentity(request.id, "Input request id"),
         taskId: requireIdentity(request.taskId, "Input request Task id"),
         requester: normalizeRequester(request.requester),

package/dist/integration/changeSet.js

@@ -3,7 +3,7 @@ import { validateTaskRecordReference } from "../task/taskRecordReference.js";
 import { validateChangeSetManifest } from "./changeSetManifest.js";
 export function createWorkItemChangeSet(input, now) {
     return validateChangeSet({
-        schemaVersion: 4,
+        schemaVersion: 1,
         ...input,
         changedPaths: [...input.changedPaths],
         manifest: validateChangeSetManifest(input.manifest),
@@ -11,8 +11,8 @@ export function createWorkItemChangeSet(input, now) {
     });
 }
 export function validateChangeSet(changeSet) {
-    if (changeSet.schemaVersion !== 4)
-        throw new Error("ChangeSet must use schemaVersion 4.");
+    if (changeSet.schemaVersion !== 1)
+        throw new Error("ChangeSet must use schemaVersion 1.");
     validateTaskRecordReference({ taskId: changeSet.taskId, localId: changeSet.id }, "changeSet");
     validateTaskRecordReference({
         taskId: changeSet.taskId,

package/dist/integration/integrationAttempt.js

@@ -4,7 +4,7 @@ import { normalizeCheckResult } from "./checkResult.js";
 export function createIntegrationAttempt(input, now) {
     const timestamp = now.toISOString();
     return validateIntegrationAttempt({
-        schemaVersion: 6,
+        schemaVersion: 1,
         id: input.id,
         taskId: input.taskId,
         projectId: input.projectId,
@@ -132,8 +132,8 @@ export function supersedeIntegration(attempt, reason, now) {
     });
 }
 export function validateIntegrationAttempt(attempt) {
-    if (attempt.schemaVersion !== 6) {
-        throw new Error("IntegrationAttempt must use schemaVersion 6.");
+    if (attempt.schemaVersion !== 1) {
+        throw new Error("IntegrationAttempt must use schemaVersion 1.");
     }
     validateTaskRecordReference({
         taskId: attempt.taskId,

package/dist/integration/integrationSourceApplication.js

@@ -233,7 +233,7 @@ async function assertOperation(path, kind, commit, before, branch, source) {
         throw new Error(`Integration expected ${kind}, found ${active ?? "no active Git operation"}.`);
     if (kind === "rebase") {
         const directory = await gitPath(path, "rebase-merge");
-        // Yui invokes the merge backend explicitly. A legacy apply-backend
+        // Yui invokes the merge backend explicitly. An apply-backend
         // operation cannot be silently treated as the same execution.
         const [onto, original, headName] = await Promise.all(["onto", "orig-head", "head-name"].map(name => readFile(resolve(directory, name), "utf8")));
         if (source.kind !== "upstream" || onto.trim() !== commit

package/dist/interaction/operatorPresentation.js

@@ -1,5 +1,5 @@
 /**
- * One mailbox batch becomes one short synthetic user message. The durable
+ * One mailbox batch becomes one short system notification. The durable
  * records remain the context authority; this wake text carries only stable
  * identities and exact CLI reads, never copied Task or Provider narrative.
  */
@@ -11,6 +11,7 @@ export function createOperatorBatchPresentation(batchId, items) {
         text: [
             "[Yui updates]",
             "Yui recorded the following durable updates. Inspect the referenced records and present only information that changes the user's understanding, authorization, or next action.",
+            "This notification is not a new execution assignment or authorization to replay prior operations.",
             ...items.flatMap(renderItem)
         ].join("\n")
     };

package/dist/job/durableJob.js

@@ -2,7 +2,7 @@ import { createHash } from "node:crypto";
 import { requireIdentity, requirePositiveInteger, requireText, requireTimestamp } from "../domain/validation.js";
 import { validateTaskRecordReference } from "../task/taskRecordReference.js";
 import { recordOperationEvidence, validateOperationFacts } from "../kernel/operationFacts.js";
-export const CURRENT_DURABLE_JOB_SCHEMA_VERSION = 2;
+export const CURRENT_DURABLE_JOB_SCHEMA_VERSION = 1;
 export const JOB_RUNNER_IMPLEMENTATION = Object.freeze({ id: "yui:job-runner", generation: "1" });
 export const DURABLE_JOB_TERMINAL_STATUSES = [
     "succeeded",

package/dist/job/jobRunner.js

@@ -128,8 +128,8 @@ export async function runDurableJobRunner(specPath) {
             let child;
             try {
                 // Issue 08: a structured argv step executes without a shell so its
-                // tokens can never be reinterpreted; a legacy command step keeps the
-                // shell form. A per-step cwd/env override applies to either form.
+                // tokens can never be reinterpreted; an explicit command step uses
+                // the shell. A per-step cwd/env override applies to either form.
                 const stepCwd = jobStepDirectory(spec.workspace, step.cwd);
                 const stepEnv = step.env === undefined
                     ? spec.env