@zq-silk/yui 0.8.1 → 0.8.3

package/dist/executor/agentExecutor.js

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
 import { hasRecentTurnId, rememberRecentTurnId, validatePendingTurnCompletion, validateRecentTurnIds } from "./turnCompletion.js";
 import { effectiveLaunchSnapshotsCompatible, effectiveLaunchSnapshotsCompatibleForTaskMain, validateEffectiveLaunchSnapshot } from "./effectiveLaunch.js";
-import { validateProviderRuntimeBinding } from "../runtime/providerRuntimeIdentity.js";
+import { rebindProviderRuntimeRun, validateProviderRuntimeBinding } from "../runtime/providerRuntimeIdentity.js";
 import { builtinDriverIdForAdapter } from "../runtime/builtinAgentDrivers.js";
 export function createRoleSessionSet(owner, activeAgentId, now) {
     const base = {
@@ -14,7 +14,7 @@ export function createRoleSessionSet(owner, activeAgentId, now) {
         ? { ...base, schemaVersion: 3 }
         : {
             ...base,
-            schemaVersion: 5,
+            schemaVersion: 6,
             inFlight: null,
             providerBinding: null
         };
@@ -285,13 +285,39 @@ export function bindTaskRoleRun(set, fence, preparedAt) {
         throw new Error("Task Role session set already has an in-flight Run.");
     }
     const timestamp = requireDate(preparedAt, "Task Role Run preparedAt");
+    const providerBinding = set.providerBinding === null
+        ? null
+        : rebindProviderRuntimeRun(set.providerBinding, normalized.runId);
     const updated = {
         ...set,
         inFlight: { ...normalized, preparedAt: timestamp },
+        providerBinding,
         updatedAt: timestamp
     };
     return validateRoleSessionSet(updated);
 }
+/** Re-fences the same active Run for an exact Provider retry without losing its Conversation. */
+export function prepareTaskRoleRunRedispatch(set, fence, preparedAt) {
+    validateRoleSessionSet(set);
+    const normalized = normalizeTaskRoleRunFence(fence);
+    if (set.inFlight === null
+        || set.inFlight.agentId !== normalized.agentId
+        || set.inFlight.runId !== normalized.runId) {
+        throw new Error("Provider retry does not match the in-flight Task Run.");
+    }
+    if (set.providerBinding !== null
+        && set.providerBinding.turn !== null
+        && ["submitting", "accepted", "running", "delivery-unknown"]
+            .includes(set.providerBinding.turn.status)) {
+        throw new Error("Provider retry cannot redispatch an unsettled Turn.");
+    }
+    const timestamp = requireDate(preparedAt, "Task Role retry preparedAt");
+    return validateRoleSessionSet({
+        ...set,
+        inFlight: { ...normalized, preparedAt: timestamp },
+        updatedAt: timestamp
+    });
+}
 export function bindTaskRoleProviderRuntime(set, binding, updatedAt) {
     validateRoleSessionSet(set);
     const normalized = validateProviderRuntimeBinding(binding);
@@ -446,7 +472,6 @@ export function clearTaskRoleRun(set, fence, clearedAt) {
     const updated = {
         ...set,
         inFlight: null,
-        providerBinding: null,
         updatedAt: timestamp
     };
     return validateRoleSessionSet(updated);
@@ -519,7 +544,6 @@ export function settleTaskRoleCompletion(set, expected, settledAt) {
             }
         },
         inFlight: null,
-        providerBinding: null,
         updatedAt: timestamp
     };
     return validateRoleSessionSet(updated);
@@ -550,7 +574,7 @@ export function validateRoleSessionSet(set) {
         }
     }
     else {
-        if (set.schemaVersion !== 5) {
+        if (set.schemaVersion !== 6) {
             throw new Error("Task Role session set schema version is invalid.");
         }
         if (!Object.hasOwn(set, "inFlight")
@@ -590,10 +614,10 @@ export function validateRoleSessionSet(set) {
             throw new Error("Task Role in-flight Run Agent must be active.");
         }
         if (providerBinding !== null) {
-            if (inFlight === null || providerBinding.runId !== inFlight.runId) {
+            if (inFlight !== null && providerBinding.runId !== inFlight.runId) {
                 throw new Error("Provider Runtime Binding must match the in-flight Run.");
             }
-            const session = taskSet.sessions[inFlight.agentId];
+            const session = taskSet.sessions[inFlight?.agentId ?? set.activeAgentId];
             if (session === undefined) {
                 throw new Error("Provider Runtime Binding has no active Role Agent session.");
             }

package/dist/executor/executorRegistry.js

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import { createPromptEnvelope, createRuntimeBinding, createSessionLaunchRequest } from "../runtime/index.js";
+import { createPromptEnvelope, createSessionLaunchRequest } from "../runtime/index.js";
 import { formatAgentRunReceiptId } from "../task/taskRecordReference.js";
 /**
  * rr13/test: Test-only liveness seam. Integration tests that spawn a real
@@ -26,9 +26,6 @@ export class ExecutorRegistry {
         this.readiness = readiness;
         this.runtimePorts = runtimePorts;
     }
-    canRouteProviderInput(adapterId) {
-        return adapterId === "codex" && this.runtimePorts?.providerInputRouting !== undefined;
-    }
     async prepareRoleSession(input) {
         if (input.mode === "resume" && !hasText(input.nativeSessionId)) {
             throw new Error("Role session resume requires a native session id.");
@@ -122,10 +119,16 @@ export class ExecutorRegistry {
             sessionStarted,
             session,
             ...(input.runId !== undefined
-                && ((sessionStarted
-                    && (planned?.initialPromptRunId ?? binding?.initialPromptRunId) === input.runId)
-                    || binding?.launchPromptUncertainRunId === input.runId)
-                ? { inputSubmittedAtLaunch: true }
+                && ((binding?.initialTurnRunId === input.runId))
+                ? { turnAcceptedDuringLaunch: true }
+                : {}),
+            ...(input.runId !== undefined
+                && binding?.initialTurnDeliveryUnknownRunId === input.runId
+                ? { turnDeliveryUnknownDuringLaunch: true }
+                : {}),
+            ...(input.runId !== undefined
+                && binding?.initialTurnRejectedRunId === input.runId
+                ? { turnRejectedDuringLaunch: true }
                 : {})
         };
         this.#prepared.set(delivery.deliveryId, {
@@ -196,47 +199,6 @@ export class ExecutorRegistry {
         }
         return outcome;
     }
-    async routeProviderInput(input) {
-        const prepared = this.requirePrepared(input.delivery.prepared);
-        if (prepared.binding === undefined || this.runtimePorts?.providerInputRouting === undefined) {
-            return "unavailable";
-        }
-        try {
-            return await this.runtimePorts.providerInputRouting.route({
-                binding: prepared.binding,
-                attemptId: input.attemptId,
-                mode: input.mode,
-                text: input.text,
-                fence: input.fence
-            });
-        }
-        finally {
-            // A routed mutation is fenced by its durable inputDelivery, not by this
-            // process-local preparation. Never let a later Turn reuse a cached
-            // Activation binding after this attempt (including an unknown result).
-            this.#prepared.delete(input.delivery.prepared.deliveryId);
-        }
-    }
-    async reconcileProviderInput(input) {
-        if (this.runtimePorts?.providerInputRouting === undefined) {
-            return "unavailable";
-        }
-        return this.runtimePorts.providerInputRouting.reconcile({
-            binding: createRuntimeBinding({
-                id: `metadata:${input.taskId}:${input.roleName}:${input.launchId}`,
-                launchId: input.launchId,
-                owner: { scope: "task", taskId: input.taskId, roleName: input.roleName },
-                agentId: input.agentId,
-                adapterId: input.adapterId,
-                hostRef: "metadata-only",
-                hostCreated: false,
-                nativeSessionId: input.nativeSessionId
-            }),
-            attemptId: input.attemptId,
-            mode: input.mode,
-            fence: input.fence
-        });
-    }
     async notifyOperatorInputOnce(input) {
         const probe = this.readiness(input.adapterId, "operator");
         return this.tmux.sendRoleInputOnceIfReadyAsync === undefined

package/dist/executor/fileRoleLaunchPlanner.js

@@ -24,6 +24,7 @@ import { parseTaskRuntimeIsolationDescriptor, taskRuntimeIsolationEnvironment }
 import { ResourceRegistrar } from "../resources/resourceRegistrar.js";
 import { builtinAgentDriverRegistry, builtinDriverIdForAdapter } from "../runtime/builtinAgentDrivers.js";
 import { managedRuntimeAdmission } from "../runtime/agentDriver.js";
+import { formatAgentRunReceiptId } from "../task/taskRecordReference.js";
 /** Builds managed native Agent launches from the authoritative Task records. */
 export class FileRoleLaunchPlanner {
     home;
@@ -223,7 +224,7 @@ export class FileRoleLaunchPlanner {
         if (input.mode === "resume" && !compatibleExisting) {
             throw new Error(`Task Role resume effective snapshot drifted: ${task.id}/${role.name}.`);
         }
-        return this.#compile(role, input, { scope: "task", taskId: task.id }, taskRoleSessionTitle(task, role.name), compatibleExisting ? existing.nativeSessionId : undefined, runWorkspace, effective, {
+        return this.#compile(role, input, { scope: "task", taskId: task.id }, taskRoleSessionTitle(task, role.name), input.mode === "resume" && compatibleExisting ? existing.nativeSessionId : undefined, runWorkspace, effective, {
             purpose: activeRun?.purpose ?? "execution"
         });
     }
@@ -331,6 +332,9 @@ export class FileRoleLaunchPlanner {
         const managedRun = owner.scope === "task" && input.runId !== undefined
             ? this.store.getAgentRun(owner.taskId, input.runId)
             : null;
+        const managedSessionSet = owner.scope === "task" && input.runId !== undefined
+            ? this.store.getTaskRoleSessionSet(owner.taskId, role.name)
+            : null;
         const driver = builtinAgentDriverRegistry().require(builtinDriverIdForAdapter(configured.adapterId));
         if (owner.scope === "task" && input.runId !== undefined) {
             const admission = managedRuntimeAdmission(driver.capabilities);
@@ -369,12 +373,33 @@ export class FileRoleLaunchPlanner {
         const launchMode = resumeNativeSessionId === undefined
             ? "new"
             : "resume";
-        const compiled = launchMode === "resume"
-            ? adapter.compileResume({
-                ...compileInput,
-                nativeSessionId: resumeNativeSessionId
-            })
-            : adapter.compileNew(compileInput);
+        const managedControl = owner.scope === "task" && input.runId !== undefined;
+        const managedProviderEnvironment = managedControl
+            && configured.adapterId === "codex"
+            ? {
+                // Managed Codex Runs are non-interactive. Use the Codex execution
+                // identity for provider requests while clientInfo still identifies Yui.
+                CODEX_INTERNAL_ORIGINATOR_OVERRIDE: "codex_exec"
+            }
+            : {};
+        const preallocatedManagedNativeSessionId = managedControl
+            && binding.adapterId === "claude"
+            && resumeNativeSessionId === undefined
+            ? requireText(input.launchId === undefined
+                ? this.#createNativeSessionId()
+                : nativeSessionIdForLaunch(this.home, input.launchId, input.agentId, input.adapterId), "Native session id")
+            : resumeNativeSessionId;
+        const managedCompiled = managedControl
+            ? adapter.compileManagedControl(compileInput, launchMode, preallocatedManagedNativeSessionId)
+            : undefined;
+        const compiled = managedCompiled !== undefined
+            ? managedCompiled
+            : launchMode === "resume"
+                ? adapter.compileResume({
+                    ...compileInput,
+                    nativeSessionId: resumeNativeSessionId
+                })
+                : adapter.compileNew(compileInput);
         for (const path of [
             bootstrap.manifestPath,
             bootstrap.sessionCliPath,
@@ -397,39 +422,32 @@ export class FileRoleLaunchPlanner {
             if (owner.scope !== "task" || input.runId === undefined) {
                 args = addCodexSessionNotify(args, launchMode, this.#cliPath);
             }
-            // A fresh Codex TUI has no provider event before its first prompt. Carry
-            // the exact Run input as the provider's positional launch prompt so it is
-            // submitted only after Codex completes startup; never race terminal bytes
-            // and Enter against TUI initialization.
+            // Managed Codex runs use App Server lifecycle hooks and structured Turn
+            // submission. No Run prompt is placed in argv or written as terminal input.
             if (owner.scope === "task" && input.runId !== undefined) {
                 if (managedRun === null || managedRun.status !== "active") {
                     throw new Error(`Managed Codex Run is no longer active: ${input.runId}.`);
                 }
-                args = addCodexLifecycleHooks(args, launchMode, this.#cliPath);
-                // End option parsing before the opaque prompt so a wakeup beginning
-                // with '-' can never be reinterpreted as a Codex CLI flag.
-                if (managedRun.pushedAt === undefined) {
-                    args.push("--", managedRunLaunchEnvelope(managedRun, input.mode));
-                }
+                args = managedControl
+                    ? addCodexManagedLifecycleHooks(args, this.#cliPath)
+                    : addCodexLifecycleHooks(args, launchMode, this.#cliPath);
             }
             session = launchMode === "resume"
                 ? readySession(input.agentId, binding.adapterId, resumeNativeSessionId, effective)
                 : null;
         }
         else if (launchMode === "new") {
-            if (owner.scope === "task" && input.runId !== undefined) {
-                args.push("-p", "--output-format", "stream-json", "--input-format", "stream-json", "--verbose");
+            if (managedControl)
                 args.push("--plugin-dir", ensureManagedClaudeLifecyclePlugin(this.home, this.#cliPath));
-            }
-            const nativeSessionId = requireText(input.launchId === undefined
-                ? this.#createNativeSessionId()
-                : nativeSessionIdForLaunch(this.home, input.launchId, input.agentId, input.adapterId), "Native session id");
-            args.push("--session-id", nativeSessionId);
+            const nativeSessionId = requireText(preallocatedManagedNativeSessionId, "Native session id");
+            if (!managedControl)
+                args.push("--session-id", nativeSessionId);
+            else if (!args.includes("--session-id"))
+                args.push("--session-id", nativeSessionId);
             session = readySession(input.agentId, binding.adapterId, nativeSessionId, effective);
         }
         else {
-            if (owner.scope === "task" && input.runId !== undefined) {
-                args.push("-p", "--output-format", "stream-json", "--input-format", "stream-json", "--verbose");
+            if (managedControl) {
                 args.push("--plugin-dir", ensureManagedClaudeLifecyclePlugin(this.home, this.#cliPath));
             }
             session = readySession(input.agentId, binding.adapterId, resumeNativeSessionId, effective);
@@ -469,6 +487,36 @@ export class FileRoleLaunchPlanner {
         if (owner.scope === "task" && (input.mode === "new" || input.mode === "resume")) {
             jobCallerKey = randomBytes(32).toString("hex");
         }
+        const carriesInitialTurn = managedControl
+            && managedRun?.pushedAt === undefined
+            && (managedSessionSet?.providerBinding === null
+                || managedSessionSet?.providerBinding === undefined);
+        const providerAuthority = managedControl
+            ? this.#providerAuthorityForLaunch(owner.taskId, role.name, input.launchId)
+            : undefined;
+        const providerNativeSessionId = binding.adapterId === "claude"
+            ? preallocatedManagedNativeSessionId
+            : resumeNativeSessionId;
+        const providerControl = managedControl
+            ? {
+                schemaVersion: 1,
+                adapterId: binding.adapterId,
+                transport: managedCompiled.transport,
+                mode: resumeNativeSessionId === undefined ? "new" : "resume",
+                ...(providerNativeSessionId === undefined
+                    ? {}
+                    : { nativeSessionId: providerNativeSessionId }),
+                authority: providerAuthority,
+                ...(carriesInitialTurn
+                    ? {
+                        initialTurn: {
+                            attemptId: formatAgentRunReceiptId(owner.taskId, input.runId),
+                            boundedText: managedRunLaunchEnvelope(managedRun, input.mode)
+                        }
+                    }
+                    : {})
+            }
+            : undefined;
         const launch = {
             command,
             args,
@@ -476,16 +524,10 @@ export class FileRoleLaunchPlanner {
                 && managedRun.providerRetry.state !== "dispatching"
                 ? { deferProviderStart: true }
                 : {}),
-            ...(managedClaudeRun
-                ? {
-                    providerInput: {
-                        kind: "stdin-json-user-message",
-                        boundedText: managedRunLaunchEnvelope(managedRun, input.mode)
-                    }
-                }
-                : {}),
+            ...(providerControl === undefined ? {} : { providerControl }),
             env: {
                 ...launchEnvironment,
+                ...managedProviderEnvironment,
                 YUI_HOME: resolve(this.home),
                 YUI_SESSION_SCOPE: owner.scope,
                 ...(owner.scope === "task" ? { YUI_TASK_ID: owner.taskId } : {}),
@@ -536,12 +578,36 @@ export class FileRoleLaunchPlanner {
             },
             launch: scopedLaunch,
             session,
-            ...((binding.adapterId === "codex" && managedRun?.pushedAt === undefined
-                || managedClaudeRun) && input.runId !== undefined
-                ? { initialPromptRunId: input.runId }
+            ...(carriesInitialTurn && input.runId !== undefined
+                ? { initialTurnRunId: input.runId }
                 : {})
         };
     }
+    #providerAuthorityForLaunch(taskId, roleName, launchId) {
+        const activationId = requireText(launchId, "Managed Provider Activation id");
+        const binding = this.store.getTaskRoleSessionSet(taskId, roleName)?.providerBinding;
+        if (binding === null || binding === undefined) {
+            return { epoch: 1, owner: "controller", holderId: activationId };
+        }
+        if (binding.authority.owner === "controller") {
+            return {
+                epoch: binding.authority.epoch,
+                owner: "controller",
+                holderId: binding.authority.holderId
+            };
+        }
+        if (binding.authority.owner === "human") {
+            throw new Error(`Provider writer is held by a human: ${taskId}/${roleName}.`);
+        }
+        if (binding.authority.owner === "none") {
+            return {
+                epoch: binding.authority.epoch + 1,
+                owner: "controller",
+                holderId: activationId
+            };
+        }
+        throw new Error(`Provider writer authority is unknown: ${taskId}/${roleName}.`);
+    }
     #applyWorkspaceScope(taskId, role, launch, workspaceOverride) {
         const workspace = workspaceOverride
             ?? (role.name === "leader"
@@ -786,6 +852,18 @@ function addCodexLifecycleHooks(args, mode, cliPath) {
     }
     return [...args.slice(0, -2), ...managed, ...args.slice(-2)];
 }
+function addCodexManagedLifecycleHooks(args, cliPath) {
+    if (args.length < 2 || args.at(-2) !== "app-server" || args.at(-1) !== "--stdio") {
+        throw new Error("Managed Codex App Server launch shape is invalid.");
+    }
+    return [
+        ...args.slice(0, -2),
+        "--enable", "hooks",
+        "--config", codexLifecycleHooksConfig(cliPath),
+        "--dangerously-bypass-hook-trust",
+        ...args.slice(-2)
+    ];
+}
 function readySession(agentId, adapterId, nativeSessionId, effective) {
     return {
         agentId,

package/dist/lifecycle/canonicalLifecycleEvent.js

@@ -185,9 +185,12 @@ export function foldCanonicalLifecycleEvent(event, expectation) {
             // Only an identity-matched durable native event can move accepted/delivered,
             // and only after the independently committed transport receipt. Provider
             // acceptance and transport acknowledgement are deliberately separate
-            // evidence layers: neither may repair or infer the other.
+            // evidence layers: neither may repair or infer the other. A fresh managed
+            // Host can publish native acceptance immediately before its launch call
+            // returns and lets the scheduler persist the transport receipt. Retain
+            // that exact fenced fact for replay instead of misclassifying it as stale.
             if (!expectation.pushed)
-                return { outcome: "fail-closed", reason: "accept-without-push" };
+                return { outcome: "deferred", reason: "accept-before-push" };
             if (expectation.terminal)
                 return { outcome: "obsolete", reason: "accept-after-terminal" };
             if (expectation.accepted)

package/dist/repository/gitWorkspace.js

@@ -15,15 +15,18 @@ export class RemoteBaselineConflictError extends Error {
 }
 /** The small Git boundary used by project registration and Task workspaces. */
 export class NodeGitWorkspace {
+    async resolveTree(repositoryPath, commit) {
+        return gitLine([
+            "-C", repositoryPath,
+            "rev-parse", "--verify", "--end-of-options", `${commit}^{tree}`
+        ]);
+    }
     async findCommitWithSameTreeInHistory(input) {
         const source = (await this.inspect(input.repositoryPath, input.sourceCommit)).baseCommit;
         const history = (await this.inspect(input.repositoryPath, input.historyHead)).baseCommit;
         if (await this.isAncestor(input.repositoryPath, source, history))
             return source;
-        const sourceTree = await gitLine([
-            "-C", input.repositoryPath,
-            "rev-parse", "--verify", "--end-of-options", `${source}^{tree}`
-        ]);
+        const sourceTree = await this.resolveTree(input.repositoryPath, source);
         const pageSize = 1000;
         for (let skip = 0;; skip += pageSize) {
             const output = await git([

package/dist/repository/taskBaseFreshness.js

@@ -107,10 +107,12 @@ export async function inspectTaskBaseFreshness(taskId, store, options = {}) {
     }));
     return { taskId, refreshed: options.refresh === true, entries };
 }
-export function assertTaskBaseFreshnessForCompletion(report) {
+export function assertTaskBaseFreshnessForCompletion(report, options = {}) {
     const warnings = [];
     for (const entry of report.entries) {
-        if (entry.status === "behind" || entry.status === "diverged") {
+        const acceptedPublishedTree = options.acceptedPublishedTreeProjectId === entry.projectId;
+        if ((entry.status === "behind" || entry.status === "diverged")
+            && !acceptedPublishedTree) {
             throw usageError(`Task ${report.taskId} Project ${entry.projectId} base is ${entry.status}; `
                 + `run 'yui task base status ${report.taskId} --refresh' and choose an explicit delivery base. `
                 + "Safe resolutions are to rebase or merge the Task workspace onto the refreshed remote base, "

package/dist/run/agentRun.js

@@ -67,11 +67,11 @@ export function withAgentRunContextSnapshot(run, snapshot, deltaRefIds = []) {
     if (run.status !== "active" || run.pushedAt !== undefined || run.deliveredAt !== undefined) {
         throw new Error(`Cannot bind Context Snapshot after Run delivery: ${run.id}.`);
     }
-    const assignment = validateRunAssignment(Object.freeze({
+    const assignment = createRunAssignment({
         ...run.assignment,
         contextSnapshotRef: snapshot,
         deltaRefIds
-    }));
+    });
     return validateAgentRun(Object.freeze({
         ...run,
         assignment,
@@ -329,7 +329,7 @@ export function withProviderRetry(run, retry) {
  * remain historical facts; the new delivery receipt and `dispatching` retry
  * state make the delivery path send only the short continuation envelope.
  */
-export function reopenRunForProviderRetry(run, receiptId, now) {
+export function reopenRunForProviderRetry(run, receiptId, now, mode = "resume") {
     if (run.status !== "active" || run.providerRetry === undefined) {
         throw new Error(`Agent run is not waiting for a provider retry: ${run.id}.`);
     }
@@ -337,7 +337,7 @@ export function reopenRunForProviderRetry(run, receiptId, now) {
     const { providerRetry, ...rest } = run;
     return validateAgentRun({
         ...rest,
-        mode: "resume",
+        mode,
         deliveryReceiptId: receiptId,
         updatedAt: timestamp,
         providerRetry: prepareProviderRetryDispatch(providerRetry, receiptId, now)