@zq-silk/yui 0.15.7 → 0.15.8

package/dist/executor/effectiveLaunch.js

@@ -1,21 +1,32 @@
 import { isDeepStrictEqual } from "node:util";
+import { validateExecutionEnvironmentSnapshot } from "../resources/projectResource.js";
 import { validateManagedWorkspace } from "../worktree/managedWorkspace.js";
 import { resolveAgentAdapter } from "./agentAdapter.js";
 import { roleSessionKind } from "../context/roleSessionContext.js";
+import { isAgentAdapterId } from "../agent/adapterCatalog.js";
+import { adapterIdForExecutionComponent, isAgentExecutionComponentId, resolveAgentExecutionComponent } from "../agent/executionComponents.js";
 import { SESSION_BOOTSTRAP_MANIFEST_SCHEMA_VERSION, sessionManifestCompatibilityDigest } from "../context/sessionProtocolIdentity.js";
 export function resolveEffectiveLaunch(input) {
+    if (input.purpose === "planning" && input.executionAuthority === "delivery") {
+        throw new Error("Planning cannot request delivery authority.");
+    }
     validateDesiredRole(input.role);
     const binding = input.role.agentBindings[input.role.activeAgentId];
     const workspace = snapshotWorkspace(input.role.workspace, input.workspace);
     const writeProjectIds = effectiveWriteProjects(input, workspace);
     const config = resolveAgentAdapter(binding.adapterId).canonicalizeConfig(clone(binding.config));
     return snapshotFromConfig({
+        executionAuthority: input.executionAuthority ?? (input.purpose === "planning" ? "planning" : "delivery"),
         sourceDesiredRevision: input.role.launchRevision,
         agentId: binding.agentId,
+        component: resolveAgentExecutionComponent(binding.adapterId, binding.component),
         config,
         profileAccess: input.role.defaultAccess,
         writeProjectIds,
         workspace,
+        ...("taskId" in input.role && input.role.executionEnvironment !== undefined
+            ? { executionEnvironment: input.role.executionEnvironment }
+            : {}),
         context: snapshotContext(input.role),
         contextProtocolVersion: SESSION_BOOTSTRAP_MANIFEST_SCHEMA_VERSION,
         sessionManifestCompatibilityDigest: sessionManifestCompatibilityDigest(input.role.name, roleSessionKind(input.role, "taskId" in input.role
@@ -69,6 +80,24 @@ function claudeConfigFromSnapshot(snapshot) {
             : { settingsSources: [...snapshot.settingsSources] })
     };
 }
+function acpConfigFromSnapshot(snapshot) {
+    // Model and effort round-trip because they are ACP session config options
+    // that this launch pushes and confirms. Settings deliberately do not: the
+    // protocol defines no client-side settings file or settings source, so the
+    // snapshot type keeps those permanently absent.
+    return {
+        adapterId: "acp",
+        ...(snapshot.model === undefined ? {} : { model: snapshot.model }),
+        ...(snapshot.effort === undefined ? {} : { effort: snapshot.effort }),
+        permission: clone(snapshot.permission),
+        ...(snapshot.additionalDirectories === undefined
+            ? {}
+            : { additionalDirectories: [...snapshot.additionalDirectories] }),
+        ...(snapshot.advanced === undefined
+            ? {}
+            : { advanced: clone(snapshot.advanced) })
+    };
+}
 /**
  * Exactness fence for one launch: the same resolved launch must be observed by
  * every participant of that launch. Desired-revision bookkeeping is provenance
@@ -89,12 +118,12 @@ export function sameEffectiveLaunch(existing, desired) {
  * Only facts that make continuation impossible participate: the Session
  * protocol, the provider identity that owns the conversation, and the physical
  * workspace the Session runs in. Launch configuration such as model, effort,
- * permission, Role context, declared write scope, and Turn-scoped facts like
- * ReviewRound identity or candidate commits shape the next Host activation
+ * permission, Role context, declared write scope, and AgentRun-scoped facts like
+ * ReviewRound identity or candidate commits shape the next Host process
  * instead of ending the Session; that divergence is acknowledged where the
  * configuration changes and stays visible as launch provenance.
  *
- * Session kind needs no separate check: a Role's review Turns run in their own
+ * Session kind needs no separate check: a Role's review AgentRuns run in their own
  * ReviewRound workspace, so the physical workspace already separates a review
  * Session from an execution Session.
  */
@@ -108,7 +137,7 @@ export function effectiveLaunchWithTaskMainWorkspace(existing, workspace) {
     validateEffectiveLaunchSnapshot(existing);
     validateManagedWorkspace(workspace);
     if (workspace.owner.type !== "task") {
-        throw new Error("Only a Task-owned main workspace may refresh fixed Session Turn evidence.");
+        throw new Error("Only a Task-owned main workspace may refresh fixed Session AgentRun evidence.");
     }
     return validateEffectiveLaunchSnapshot({
         ...existing,
@@ -121,9 +150,15 @@ export function effectiveLaunchWithTaskMainWorkspace(existing, workspace) {
 function sessionContinuitySnapshot(snapshot) {
     return {
         schemaVersion: snapshot.schemaVersion,
+        executionAuthority: snapshot.executionAuthority,
         contextProtocolVersion: snapshot.contextProtocolVersion,
         agentId: snapshot.agentId,
+        // Two products on one connection plan are two different conversations. A
+        // Session that started against an unidentified ACP Agent must not silently
+        // continue against the Claude Agent SDK just because both speak ACP.
+        component: snapshot.component,
         adapterId: snapshot.adapterId,
+        executionEnvironment: snapshot.executionEnvironment,
         workspace: {
             root: snapshot.workspace.root,
             entries: snapshot.workspace.entries.map((entry) => ({
@@ -137,11 +172,18 @@ function sessionContinuitySnapshot(snapshot) {
     };
 }
 export function validateEffectiveLaunchSnapshot(snapshot) {
-    if (snapshot.schemaVersion !== 3) {
-        throw new Error("Effective launch snapshot must use schemaVersion 3.");
+    if (snapshot.schemaVersion !== 4) {
+        throw new Error("Effective launch snapshot must use schemaVersion 4.");
+    }
+    if (snapshot.executionAuthority !== "planning" && snapshot.executionAuthority !== "delivery") {
+        throw new Error("Effective launch requires its captured execution authority.");
     }
     positiveInteger(snapshot.sourceDesiredRevision, "Source desired revision");
     identity(snapshot.agentId, "Effective Agent id");
+    if (!isAgentExecutionComponentId(snapshot.component)
+        || adapterIdForExecutionComponent(snapshot.component) !== snapshot.adapterId) {
+        throw new Error(`Effective launch execution component is invalid: ${String(snapshot.component)}.`);
+    }
     if (snapshot.profileAccess !== "read" && snapshot.profileAccess !== "write") {
         throw new Error(`Effective launch Profile access is invalid: ${String(snapshot.profileAccess)}.`);
     }
@@ -172,6 +214,19 @@ export function validateEffectiveLaunchSnapshot(snapshot) {
         throw new Error("Effective launch Session Manifest compatibility digest is invalid.");
     }
     validateWorkspace(snapshot.workspace);
+    if (snapshot.executionEnvironment !== undefined) {
+        validateExecutionEnvironmentSnapshot(snapshot.executionEnvironment);
+        if (snapshot.executionEnvironment.access === "read") {
+            if (snapshot.adapterId !== "codex") {
+                throw new Error("Read-only execution environments require a native filesystem sandbox; Claude is unsupported.");
+            }
+            if (snapshot.permission.strategy !== "configured"
+                || snapshot.permission.sandbox !== "read-only"
+                || snapshot.permission.approval !== "never") {
+                throw new Error("Read-only execution environments require Codex configured sandbox read-only and approval never.");
+            }
+        }
+    }
     cloneContext(snapshot.context);
     const config = effectiveLaunchConfigUnchecked(snapshot);
     resolveAgentAdapter(snapshot.adapterId).canonicalizeConfig(config);
@@ -182,6 +237,7 @@ export function effectiveRoleForLaunch(role, snapshot) {
     const config = effectiveLaunchConfig(snapshot);
     const binding = {
         agentId: snapshot.agentId,
+        component: snapshot.component,
         adapterId: snapshot.adapterId,
         config
     };
@@ -194,6 +250,19 @@ export function effectiveRoleForLaunch(role, snapshot) {
         defaultAccess: snapshot.profileAccess,
         workspace: snapshot.workspace.root
     };
+    if ("taskId" in result) {
+        if (snapshot.executionEnvironment === undefined)
+            delete result.executionEnvironment;
+        else {
+            if (snapshot.executionEnvironment.taskId !== result.taskId) {
+                throw new Error("Effective execution environment belongs to another Task.");
+            }
+            result.executionEnvironment = clone(snapshot.executionEnvironment);
+        }
+    }
+    else if (snapshot.executionEnvironment !== undefined) {
+        throw new Error("Only a Task Role may use an execution environment.");
+    }
     clearMissingContext(result, snapshot.context);
     return result;
 }
@@ -209,9 +278,11 @@ function snapshotFromConfig(input) {
             reviewBaseCommit: commit(input.reviewBaseCommit ?? "", "Review base commit")
         };
     const common = {
-        schemaVersion: 3,
+        schemaVersion: 4,
+        executionAuthority: input.executionAuthority,
         sourceDesiredRevision: positiveInteger(input.sourceDesiredRevision, "Source desired revision"),
         agentId: identity(input.agentId, "Effective Agent id"),
+        component: input.component,
         profileAccess: input.profileAccess,
         ...(config.model === undefined ? {} : { model: config.model }),
         ...(config.effort === undefined ? {} : { effort: config.effort }),
@@ -222,6 +293,9 @@ function snapshotFromConfig(input) {
         ...(config.advanced === undefined ? {} : { advanced: clone(config.advanced) }),
         writeProjectIds: [...input.writeProjectIds],
         workspace: cloneWorkspace(input.workspace),
+        ...(input.executionEnvironment === undefined
+            ? {}
+            : { executionEnvironment: clone(input.executionEnvironment) }),
         context: cloneContext(input.context),
         contextProtocolVersion: input.contextProtocolVersion,
         sessionManifestCompatibilityDigest: input.sessionManifestCompatibilityDigest,
@@ -234,21 +308,25 @@ function snapshotFromConfig(input) {
             permission: clone(config.permission),
             ...(config.profile === undefined ? {} : { profile: config.profile })
         }
-        : {
-            ...common,
-            adapterId: "claude",
-            permission: clone(config.permission),
-            ...(config.settingsFile === undefined ? {} : { settingsFile: config.settingsFile }),
-            ...(config.settingsSources === undefined
-                ? {}
-                : { settingsSources: [...config.settingsSources] })
-        };
+        : config.adapterId === "acp"
+            ? { ...common, adapterId: "acp", permission: clone(config.permission) }
+            : {
+                ...common,
+                adapterId: "claude",
+                permission: clone(config.permission),
+                ...(config.settingsFile === undefined ? {} : { settingsFile: config.settingsFile }),
+                ...(config.settingsSources === undefined
+                    ? {}
+                    : { settingsSources: [...config.settingsSources] })
+            };
     return validateEffectiveLaunchSnapshot(snapshot);
 }
 function effectiveLaunchConfigUnchecked(snapshot) {
     return snapshot.adapterId === "codex"
         ? codexConfigFromSnapshot(snapshot)
-        : claudeConfigFromSnapshot(snapshot);
+        : snapshot.adapterId === "acp"
+            ? acpConfigFromSnapshot(snapshot)
+            : claudeConfigFromSnapshot(snapshot);
 }
 function effectiveWriteProjects(input, workspace) {
     if (input.purpose === "review") {
@@ -367,10 +445,19 @@ function validateDesiredRole(role) {
     if (role.defaultAccess !== "read" && role.defaultAccess !== "write") {
         throw new Error("Role default access is invalid.");
     }
+    if ("executionEnvironment" in role && role.executionEnvironment !== undefined) {
+        if (!("taskId" in role))
+            throw new Error("Only a Task Role may use an execution environment.");
+        validateExecutionEnvironmentSnapshot(role.executionEnvironment);
+        if (role.executionEnvironment.taskId !== role.taskId) {
+            throw new Error("Role execution environment belongs to another Task.");
+        }
+    }
     const binding = role.agentBindings[role.activeAgentId];
     if (binding === undefined)
         throw new Error("Role active Agent binding is missing.");
-    if (binding.adapterId !== "codex" && binding.adapterId !== "claude") {
+    // Adapter support is the catalog's fact, not a second list to keep in sync.
+    if (!isAgentAdapterId(binding.adapterId)) {
         throw new Error(`Role Agent adapter is unsupported: ${binding.adapterId}.`);
     }
 }

package/dist/executor/executorRegistry.js

@@ -1,10 +1,11 @@
 import { createHash } from "node:crypto";
 import { createPromptEnvelope, createSessionLaunchRequest } from "../runtime/index.js";
-import { formatTurnReceiptId } from "../task/taskRecordReference.js";
+import { builtinAgentDriverRegistry } from "../runtime/builtinAgentDrivers.js";
+import { formatRunReceiptId } from "../task/taskRecordReference.js";
 /**
  * rr13/test: Test-only liveness seam. Integration tests that spawn a real
  * Controller subprocess cannot inject a fake TmuxDeliveryPort, and a saved
- * active Leader Turn would be reaped by the startup liveness pass without a
+ * active Leader AgentRun would be reaped by the startup liveness pass without a
  * real tmux role. When this env var is "1", every role reads "present"
  * without probing tmux. The Controller subprocess inherits it from the
  * test's CLI env. Never set in production.
@@ -38,7 +39,7 @@ export class ExecutorRegistry {
             agentId: input.agentId,
             adapterId: input.adapterId,
             mode: input.mode,
-            ...(input.turnId === undefined ? {} : { turnId: input.turnId })
+            ...(input.runId === undefined ? {} : { runId: input.runId })
         };
         const cached = this.#prepared.get(deliveryBase.deliveryId);
         if (cached !== undefined)
@@ -49,16 +50,6 @@ export class ExecutorRegistry {
         if (this.runtimePorts === undefined) {
             planned = this.planner.plan(input);
             sessionStarted = this.tmux.ensureRoleWindow(input.taskId, planned.role, planned.launch);
-            if (sessionStarted
-                && planned.launch.env.YUI_JOB_CALLER_KEY !== undefined
-                && this.planner.commitTaskCallerKey !== undefined) {
-                this.planner.commitTaskCallerKey({
-                    taskId: input.taskId,
-                    roleName: input.roleName,
-                    agentId: input.agentId,
-                    callerKey: planned.launch.env.YUI_JOB_CALLER_KEY
-                });
-            }
             session = planned.session;
         }
         else {
@@ -71,10 +62,11 @@ export class ExecutorRegistry {
                 ...(input.managedWorkspace === undefined
                     ? {}
                     : { managedWorkspace: input.managedWorkspace }),
+                ...(input.workspaceFree === true ? { workspaceFree: true } : {}),
                 ...(input.runtimePolicy === undefined
                     ? {}
                     : { runtimePolicy: input.runtimePolicy }),
-                ...(input.turnId === undefined ? {} : { turnId: input.turnId })
+                ...(input.runId === undefined ? {} : { runId: input.runId })
             };
             if (this.runtimePorts.launchCoordinator !== undefined) {
                 binding = await this.runtimePorts.launchCoordinator.prepare(input.mode === "new"
@@ -83,21 +75,16 @@ export class ExecutorRegistry {
                         ...common,
                         mode: "resume",
                         nativeSessionId: input.nativeSessionId,
-                        ...(input.hostActivationId === undefined
-                            ? {}
-                            : { hostActivationId: input.hostActivationId })
-                    }, "deferred", undefined, input.beforeHostStart);
+                    }, undefined, input.beforeHostStart);
             }
             else {
                 const request = input.mode === "new"
                     ? createSessionLaunchRequest({
                         ...common,
-                        runtimeGenerationId: deliveryBase.deliveryId,
                         mode: "new"
                     })
                     : createSessionLaunchRequest({
                         ...common,
-                        runtimeGenerationId: deliveryBase.deliveryId,
                         mode: "resume",
                         nativeSessionId: input.nativeSessionId
                     });
@@ -118,7 +105,6 @@ export class ExecutorRegistry {
         }
         const delivery = {
             ...deliveryBase,
-            ...(binding === undefined ? {} : { runtimeGenerationId: binding.runtimeGenerationId }),
             sessionStarted,
             session,
         };
@@ -141,18 +127,20 @@ export class ExecutorRegistry {
     async sendOnce(input) {
         const prepared = this.requirePrepared(input.delivery.prepared);
         if (prepared.binding !== undefined && this.runtimePorts !== undefined) {
-            const turnId = input.delivery.prepared.turnId;
-            if (turnId === undefined) {
-                throw new Error("Runtime prompt delivery requires a Task-local Turn id.");
+            const runId = input.delivery.prepared.runId;
+            if (runId === undefined && input.notificationId === undefined) {
+                throw new Error("Runtime prompt delivery requires a Task-local AgentRun id.");
             }
             const outcome = await this.runtimePorts.promptPush.tryPush({
                 binding: prepared.binding,
                 envelope: createPromptEnvelope({
                     id: input.receiptId,
-                    source: {
-                        kind: input.receiptId === formatTurnReceiptId(input.delivery.prepared.taskId, turnId) ? "turn" : "turn-input",
+                    source: input.notificationId !== undefined ? {
+                        kind: "notification", taskId: input.delivery.prepared.taskId, localId: input.notificationId
+                    } : {
+                        kind: input.receiptId === formatRunReceiptId(input.delivery.prepared.taskId, runId) || input.receiptId.startsWith(`${formatRunReceiptId(input.delivery.prepared.taskId, runId)}/attempt/`) ? "run" : "turn-input",
                         taskId: input.delivery.prepared.taskId,
-                        localId: turnId
+                        localId: runId
                     },
                     text: input.text,
                     createdAt: new Date()
@@ -174,7 +162,6 @@ export class ExecutorRegistry {
             return { status: "unavailable" };
         const outcome = await this.runtimePorts.promptPush.trySteer({
             owner: { scope: "task", taskId: input.taskId, roleName: input.roleName },
-            runtimeGenerationId: input.runtimeGenerationId,
             agentId: input.agentId,
             adapterId: input.adapterId,
             nativeSessionId: input.nativeSessionId,
@@ -182,7 +169,7 @@ export class ExecutorRegistry {
             providerAuthority: input.authority,
             envelope: createPromptEnvelope({
                 id: input.receiptId,
-                source: { kind: "turn-input", taskId: input.taskId, localId: activeTurnId(input.receiptId) },
+                source: { kind: "turn-input", taskId: input.taskId, localId: activeRunId(input.receiptId) },
                 text: input.text,
                 createdAt: new Date()
             })
@@ -198,12 +185,7 @@ export class ExecutorRegistry {
     forgetPrepared(input) {
         for (const [deliveryId, prepared] of this.#prepared) {
             const delivery = prepared.delivery;
-            if (delivery.taskId !== input.taskId
-                || delivery.roleName !== input.roleName
-                || (input.turnId !== undefined
-                    && delivery.turnId !== input.turnId)
-                || (input.runtimeGenerationId !== undefined
-                    && delivery.runtimeGenerationId !== input.runtimeGenerationId)) {
+            if (delivery.taskId !== input.taskId || delivery.roleName !== input.roleName || (input.runId !== undefined && delivery.runId !== input.runId)) {
                 continue;
             }
             this.#prepared.delete(deliveryId);
@@ -260,13 +242,12 @@ export class ExecutorRegistry {
         const requested = resourceInputs ?? inputs.map((input) => ({
             taskId: input.taskId,
             roleName: input.roleName,
-            ...(input.turnId === undefined ? {} : { turnId: input.turnId }),
+            ...(input.runId === undefined ? {} : { runId: input.runId }),
             agentId: input.agentId,
             adapterId: input.adapterId,
             ...(input.nativeSessionId === undefined
                 ? {}
                 : { nativeSessionId: input.nativeSessionId }),
-            ...(input.runtimeGenerationId === undefined ? {} : { runtimeGenerationId: input.runtimeGenerationId }),
             ...(input.progressAt === undefined ? {} : { progressAt: input.progressAt })
         }));
         if (this.runtimePorts?.roleResourceInventory !== undefined
@@ -328,10 +309,10 @@ export class ExecutorRegistry {
         return planned;
     }
 }
-function activeTurnId(receiptId) {
+function activeRunId(receiptId) {
     const match = /^turn-input:[^/]+\/([^/]+)\/[1-9]\d*$/u.exec(receiptId);
     if (match === null)
-        throw new Error("Turn steer receipt is invalid.");
+        throw new Error("AgentRun steer receipt is invalid.");
     return decodeURIComponent(match[1]);
 }
 /**
@@ -346,10 +327,15 @@ function deliveryReport(outcome) {
     };
 }
 export function agentProcessReadinessProbe(adapterId, _surface = "role") {
-    if (adapterId !== "codex" && adapterId !== "claude") {
+    // A tmux pane probe is only meaningful for an Agent that actually has an
+    // interactive CLI surface. Asking a protocol-only Agent whether its pane
+    // looks alive would answer a question about the wrong thing, so the refusal
+    // is derived from the declared surface rather than from an adapter name.
+    const driver = builtinAgentDriverRegistry().findByAdapterId(adapterId);
+    if (driver === null || !driver.capabilities.surfaces.includes("interactive-cli")) {
         throw new Error(`No tmux readiness probe is registered for Agent adapter: ${adapterId}.`);
     }
-    // Turn state and receipt fences decide whether delivery is allowed. Provider
+    // AgentRun state and receipt fences decide whether delivery is allowed. Provider
     // terminal contents are display-only evidence and never lifecycle input.
     return livePane;
 }
@@ -364,9 +350,8 @@ function preparedDeliveryId(input) {
         input.adapterId,
         input.effective,
         input.mode,
-        input.turnId ?? null,
-        input.nativeSessionId ?? null,
-        input.hostActivationId ?? null
+        input.runId ?? null,
+        input.nativeSessionId ?? null
     ])).digest("hex");
 }
 function hasText(value) {