@zq-silk/yui 0.7.1 → 0.8.2

package/dist/controller/structuredProviderObservation.js

@@ -0,0 +1,273 @@
+import { randomUUID } from "node:crypto";
+import { callController } from "../core/controllerClient.js";
+import { builtinAgentDriverRegistry } from "../runtime/builtinAgentDrivers.js";
+import { createRuntimeObservation, runtimeObservationSemanticKey } from "../runtime/runtimeObservation.js";
+import { runtimeLifecycleSignalKey } from "../runtime/lifecycleReservation.js";
+import { FileRuntimeEventInbox } from "./runtimeEventInbox.js";
+import { resolveRuntimeHookRunFence } from "./runtimeHookRunFence.js";
+let structuredSequence = 0;
+export async function publishStructuredProviderAccepted(input) {
+    const adapterId = requireIdentity(input.environment.YUI_ADAPTER_ID, "Agent adapter id");
+    const driver = builtinAgentDriverRegistry().requireByAdapterId(adapterId);
+    const startupSession = driver.capabilities.observation.sessionBootstrap;
+    const fence = resolveRuntimeHookRunFence(input.environment, adapterId, input.receipt.nativeSessionId, {
+        startupSession,
+        nativeTurnId: input.receipt.nativeTurnId
+    });
+    const observedAt = input.receipt.acceptedAt;
+    const commonFence = {
+        taskId: fence.taskId,
+        roleName: fence.roleName,
+        runId: fence.runId,
+        agentId: fence.agentId,
+        driverId: driver.id,
+        launchId: fence.launchId,
+        sessionGenerationId: fence.launchId,
+        conversationId: input.receipt.conversationId,
+        activationId: requireIdentity(input.activationId, "Provider Activation id"),
+        nativeSessionId: input.receipt.nativeSessionId,
+        nativeTurnId: input.receipt.nativeTurnId,
+        // The structured Host owns the exact input attempt identity. Runtime
+        // descriptor receipts name the Run bootstrap and must not overwrite a
+        // continuation or human-takeover Turn.
+        receiptId: input.receipt.attemptId
+    };
+    const baseSequence = nextStructuredSequence();
+    const observations = [observation({
+            kind: startupSession === "preallocated" ? "session.ready" : "session.started",
+            observedAt,
+            sequence: baseSequence,
+            ordinal: 0,
+            fence: commonFence
+        }), observation({
+            kind: "conversation.observed",
+            observedAt,
+            sequence: baseSequence,
+            ordinal: 1,
+            fence: commonFence,
+            payload: { recoverability: "recoverable" }
+        }), observation({
+            kind: "activation.started",
+            observedAt,
+            sequence: baseSequence,
+            ordinal: 2,
+            fence: commonFence
+        }), observation({
+            kind: "turn.accepted",
+            observedAt,
+            sequence: baseSequence,
+            ordinal: 3,
+            fence: commonFence
+        })];
+    await persistAndApply(input.home, observations, fence.taskId, fence.roleName);
+}
+export async function publishStructuredProviderOpened(input) {
+    const adapterId = requireIdentity(input.environment.YUI_ADAPTER_ID, "Agent adapter id");
+    const driver = builtinAgentDriverRegistry().requireByAdapterId(adapterId);
+    const startupSession = driver.capabilities.observation.sessionBootstrap;
+    const fence = resolveRuntimeHookRunFence(input.environment, adapterId, input.nativeSessionId, { startupSession });
+    const commonFence = {
+        taskId: fence.taskId,
+        roleName: fence.roleName,
+        runId: fence.runId,
+        agentId: fence.agentId,
+        driverId: driver.id,
+        launchId: fence.launchId,
+        sessionGenerationId: fence.launchId,
+        conversationId: input.conversationId,
+        activationId: requireIdentity(input.activationId, "Provider Activation id"),
+        nativeSessionId: input.nativeSessionId,
+        ...(fence.receiptId === undefined ? {} : { receiptId: fence.receiptId })
+    };
+    const sequence = nextStructuredSequence();
+    const observations = [observation({
+            kind: startupSession === "preallocated" ? "session.ready" : "session.started",
+            observedAt: input.observedAt,
+            sequence,
+            ordinal: 0,
+            fence: commonFence
+        }), observation({
+            kind: "conversation.observed",
+            observedAt: input.observedAt,
+            sequence,
+            ordinal: 1,
+            fence: commonFence,
+            payload: { recoverability: input.recoverability }
+        }), observation({
+            kind: "activation.started",
+            observedAt: input.observedAt,
+            sequence,
+            ordinal: 2,
+            fence: commonFence
+        })];
+    await persistAndApply(input.home, observations, fence.taskId, fence.roleName);
+}
+export async function publishStructuredConversationRecoverability(input) {
+    const adapterId = requireIdentity(input.environment.YUI_ADAPTER_ID, "Agent adapter id");
+    const driver = builtinAgentDriverRegistry().requireByAdapterId(adapterId);
+    const fence = resolveRuntimeHookRunFence(input.environment, adapterId, input.conversationId);
+    const sequence = nextStructuredSequence();
+    const observationFence = {
+        taskId: fence.taskId,
+        roleName: fence.roleName,
+        runId: fence.runId,
+        agentId: fence.agentId,
+        driverId: driver.id,
+        launchId: fence.launchId,
+        sessionGenerationId: fence.launchId,
+        conversationId: input.conversationId,
+        activationId: requireIdentity(input.activationId, "Provider Activation id"),
+        nativeSessionId: input.conversationId,
+        ...(fence.receiptId === undefined ? {} : { receiptId: fence.receiptId })
+    };
+    const observations = [observation({
+            kind: "activation.started",
+            observedAt: input.observedAt,
+            sequence,
+            ordinal: 0,
+            fence: observationFence
+        }), observation({
+            kind: "conversation.observed",
+            observedAt: input.observedAt,
+            sequence,
+            ordinal: 1,
+            fence: observationFence,
+            payload: { recoverability: input.recoverability }
+        })];
+    if (input.recoverability === "unrecoverable") {
+        observations.push(observation({
+            kind: "activation.failed",
+            observedAt: input.observedAt,
+            sequence,
+            ordinal: 2,
+            fence: observationFence,
+            payload: {}
+        }));
+    }
+    await persistAndApply(input.home, observations, fence.taskId, fence.roleName);
+}
+export async function publishStructuredProviderTerminal(input) {
+    const adapterId = requireIdentity(input.environment.YUI_ADAPTER_ID, "Agent adapter id");
+    const driver = builtinAgentDriverRegistry().requireByAdapterId(adapterId);
+    const fence = resolveRuntimeHookRunFence(input.environment, adapterId, input.terminal.nativeSessionId, { terminal: true, nativeTurnId: input.terminal.nativeTurnId });
+    const kind = input.terminal.status === "completed"
+        ? "turn.completed"
+        : input.terminal.status === "cancelled" ? "turn.cancelled" : "turn.failed";
+    const payload = kind === "turn.completed"
+        ? { ...(input.terminal.summary === undefined ? {} : { summary: input.terminal.summary }) }
+        : kind === "turn.failed"
+            ? {
+                failure: {
+                    code: "provider-structured-failure",
+                    ...(input.terminal.error === undefined
+                        ? {}
+                        : { details: input.terminal.error })
+                }
+            }
+            : {};
+    const terminalObservation = observation({
+        kind,
+        observedAt: input.terminal.observedAt,
+        sequence: nextStructuredSequence(),
+        ordinal: 0,
+        fence: {
+            taskId: fence.taskId,
+            roleName: fence.roleName,
+            runId: fence.runId,
+            agentId: fence.agentId,
+            driverId: driver.id,
+            launchId: fence.launchId,
+            sessionGenerationId: fence.launchId,
+            conversationId: input.terminal.conversationId,
+            activationId: requireIdentity(input.activationId, "Provider Activation id"),
+            nativeSessionId: input.terminal.nativeSessionId,
+            nativeTurnId: input.terminal.nativeTurnId,
+            ...(fence.receiptId === undefined ? {} : { receiptId: fence.receiptId })
+        },
+        payload
+    });
+    await persistAndApply(input.home, [terminalObservation], fence.taskId, fence.roleName);
+}
+export async function publishStructuredProviderActivationTerminal(input) {
+    const adapterId = requireIdentity(input.environment.YUI_ADAPTER_ID, "Agent adapter id");
+    const driver = builtinAgentDriverRegistry().requireByAdapterId(adapterId);
+    const fence = resolveRuntimeHookRunFence(input.environment, adapterId, input.nativeSessionId);
+    const terminal = observation({
+        kind: input.status === "failed" ? "activation.failed" : "activation.ended",
+        observedAt: input.observedAt,
+        sequence: nextStructuredSequence(),
+        ordinal: 0,
+        fence: {
+            taskId: fence.taskId,
+            roleName: fence.roleName,
+            runId: fence.runId,
+            agentId: fence.agentId,
+            driverId: driver.id,
+            launchId: fence.launchId,
+            sessionGenerationId: fence.launchId,
+            conversationId: requireIdentity(input.conversationId, "Provider Conversation id"),
+            activationId: requireIdentity(input.activationId, "Provider Activation id"),
+            nativeSessionId: requireIdentity(input.nativeSessionId, "native Session id"),
+            ...(fence.receiptId === undefined ? {} : { receiptId: fence.receiptId })
+        },
+        payload: {}
+    });
+    await persistAndApply(input.home, [terminal], fence.taskId, fence.roleName);
+}
+function observation(input) {
+    const eventId = `agent-host-${randomUUID()}`;
+    const partial = {
+        eventId,
+        kind: input.kind,
+        fence: input.fence,
+        sequence: input.sequence,
+        payload: input.payload ?? {}
+    };
+    return createRuntimeObservation({
+        schemaVersion: 2,
+        eventId,
+        semanticKey: runtimeObservationSemanticKey(partial),
+        kind: input.kind,
+        authority: "provider-structured",
+        receivedAt: new Date().toISOString(),
+        observedAt: input.observedAt,
+        sequence: input.sequence,
+        ordinal: input.ordinal,
+        fence: input.fence,
+        payload: input.payload ?? {}
+    });
+}
+async function signalController(home, taskId, roleName) {
+    await callController(home, "scheduler.signal", {
+        key: runtimeLifecycleSignalKey({ scope: "task", taskId, roleName })
+    }, { timeoutMs: 100 }).catch(() => { });
+}
+function nextStructuredSequence() {
+    structuredSequence = (structuredSequence + 1) % Number.MAX_SAFE_INTEGER;
+    return structuredSequence;
+}
+function requireIdentity(value, label) {
+    if (typeof value !== "string" || value.trim().length === 0 || value.includes("\0")) {
+        throw new Error(`${label} is invalid.`);
+    }
+    return value.trim();
+}
+async function persistAndApply(home, observations, taskId, roleName) {
+    const inbox = new FileRuntimeEventInbox(home);
+    for (const entry of observations)
+        inbox.enqueueObservation(entry);
+    for (const entry of observations) {
+        const result = await callController(home, "runtime.observation-apply", entry, {
+            timeoutMs: 10_000
+        });
+        // A fast Provider can accept the initial Turn before the scheduler call
+        // that launched this Host has returned and committed `run.pushed`. The
+        // immutable inbox entry already makes that exact fenced fact durable;
+        // `deferred` therefore means "retained for replay", not delivery failure.
+        // The signal below schedules the replay after the transport transaction.
+        if (result.outcome !== "applied" && result.outcome !== "deferred") {
+            throw new Error(`Structured Provider observation was not applied: ${result.outcome ?? "unknown"}.`);
+        }
+    }
+    await signalController(home, taskId, roleName);
+}

package/dist/doctor/doctor.js

@@ -16,7 +16,7 @@ import { inspectStorageSchema } from "../storage/storageSchema.js";
 import { resolveTaskStoreBackendForHome } from "../storage/sqliteStore.js";
 import { resolveStoreWorkerEnabledForHome } from "../storage/storeRpc.js";
 import { classifyHome } from "../storage/upgrade/homeClassification.js";
-import { resolveGitBin, resolveTmuxBin } from "../config/yuiConfig.js";
+import { resolveTmuxBin } from "../config/yuiConfig.js";
 import { readMigrationReceipt } from "../storage/upgrade/migrationReceipt.js";
 import { latestStorageVersionState } from "../storage/upgrade/recordVersions.js";
 import { COMMITTED_DATABASE_FILENAME } from "../storage/upgrade/sqliteStateMigration.js";
@@ -985,7 +985,7 @@ function readDurableConfigSafely(home, storageOptions) {
         const config = store.getConfig();
         return {
             tmuxBin: resolveTmuxBin(config.tmuxBin),
-            gitBin: resolveGitBin(config.gitBin)
+            gitBin: "git"
         };
     }
     catch {

package/dist/executor/agentAdapter.js

@@ -159,6 +159,24 @@ class CodexAdapter extends BaseAdapter {
         const launch = this.compileNew(input);
         return { ...launch, argv: [...launch.argv, "resume", nativeId(input.nativeSessionId)] };
     }
+    compileManagedControl(input, _mode, _nativeSessionId) {
+        const launch = this.compileNew(input);
+        const argv = [...launch.argv];
+        if (input.config.model !== undefined) {
+            const modelFlag = argv.findIndex((value, index) => (value === "--model" && argv[index + 1] === input.config.model));
+            if (modelFlag < 0)
+                throw new Error("Managed Codex launch lost its selected model.");
+            argv.splice(modelFlag, 2);
+            // App Server thread/start reads the model from resolved configuration;
+            // the interactive --model shortcut is not inherited by new threads.
+            argv.push("--config", `model=${tomlString(input.config.model)}`);
+        }
+        return {
+            ...launch,
+            argv: [...argv, "app-server", "--stdio"],
+            transport: "codex-app-server-stdio"
+        };
+    }
 }
 class ClaudeAdapter extends BaseAdapter {
     id = "claude";
@@ -261,6 +279,28 @@ class ClaudeAdapter extends BaseAdapter {
         const launch = super.compileNew(input);
         return { ...launch, argv: [...launch.argv, "--resume", nativeId(input.nativeSessionId)] };
     }
+    compileManagedControl(input, mode, nativeSessionId) {
+        if (nativeSessionId === undefined) {
+            throw new Error("Managed Claude control requires a preallocated native Session id.");
+        }
+        const sessionId = nativeId(nativeSessionId);
+        const launch = mode === "new"
+            ? super.compileNew(input)
+            : this.compileResume({ ...input, nativeSessionId: sessionId });
+        return {
+            ...launch,
+            argv: [
+                ...launch.argv,
+                ...(mode === "new" ? ["--session-id", sessionId] : []),
+                "-p",
+                "--output-format", "stream-json",
+                "--input-format", "stream-json",
+                "--verbose",
+                "--replay-user-messages"
+            ],
+            transport: "claude-stream-json"
+        };
+    }
 }
 function driverPreInputReadiness(adapterId) {
     const capability = builtinAgentDriverRegistry().requireByAdapterId(adapterId)

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