@zq-silk/yui 0.15.7 → 0.15.8

package/dist/runtime/acpSessionConfiguration.js

@@ -0,0 +1,260 @@
+/**
+ * Turning a Yui Role's requested run configuration into ACP config option
+ * calls, and judging what the Agent answered.
+ *
+ * Two rules shape this module.
+ *
+ * The first is that the protocol does the work. ACP describes a Session's
+ * configurable surface as a list of `select` options, each with an id, an
+ * optional category naming the axis it belongs to, a current value and the
+ * complete enumeration of values it accepts. Model, reasoning effort and
+ * permission mode are all just options on that list, so resolving them is one
+ * generic lookup by category rather than three product branches. An Agent Yui
+ * has never seen is configured by the same code as one it ships knowledge of.
+ *
+ * The second is that a product-specific fact must be named, never inferred. One
+ * such fact is needed here: which mode value means "act without asking". No ACP
+ * field marks it, and its name is the Agent's own choice, so a value called
+ * `bypassPermissions` proves nothing on its own — a different Agent could use
+ * the same word for something narrower, or a narrower word for the same power.
+ * Guessing from the string would convert an unverified reading into granted
+ * authority. So this module does not decide it: it asks the execution component
+ * catalog, where every product is described, and a component that names no
+ * bypass value has its request reported as unsupported instead. That is a worse
+ * user experience and the only honest one. Nothing here enumerates which
+ * components exist, so a new ACP product is added by describing it there rather
+ * than by editing this file.
+ *
+ * Nothing here performs I/O: the caller owns the transport, this module owns
+ * the decision. That keeps the mapping testable against recorded option lists
+ * without a live Agent, and keeps the Session free of product knowledge.
+ */
+import { agentExecutionComponent } from "../agent/executionComponents.js";
+import { ACP_MODE_CONFIG_ID } from "./acpProtocol.js";
+/** ACP categories that name each configurable axis. */
+const MODEL_CATEGORY = "model";
+const EFFORT_CATEGORY = "thought_level";
+const MODE_CATEGORY = "mode";
+/** Only expose the axes Yui configures, never arbitrary peer credential/settings fields. */
+export function acpRunConfigurationOptions(options) {
+    const selected = [
+        findOption(options, MODEL_CATEGORY, "model"),
+        findOption(options, EFFORT_CATEGORY, "effort"),
+        findOption(options, MODE_CATEGORY, ACP_MODE_CONFIG_ID)
+    ];
+    return options.filter((option) => selected.includes(option));
+}
+/**
+ * Find the option describing one axis.
+ *
+ * Category is the primary key because it is the field ACP defines for exactly
+ * this purpose and it does not depend on an Agent's choice of id. The id is
+ * consulted only as a fallback, for an Agent that omits the optional category
+ * but uses the conventional id anyway. An Agent doing neither leaves the axis
+ * unconfigurable, which is reported rather than worked around.
+ */
+function findOption(options, category, fallbackId) {
+    return options.find((option) => option.category === category)
+        ?? options.find((option) => option.id === fallbackId);
+}
+/**
+ * Resolve one requested value against one axis.
+ *
+ * A value is sendable only when the Agent enumerated it. ACP requires a `select`
+ * option to carry its complete set of accepted values, so that list is
+ * authoritative: sending anything outside it would be sending a value the Agent
+ * has already said it does not take. Reporting the mismatch with the real
+ * enumeration is both more accurate and more useful than relaying whatever
+ * generic error the Agent would answer with.
+ */
+function resolveValue(field, requested, option, missingAxisReason) {
+    if (option === undefined) {
+        return Object.freeze({ field, requested, reason: missingAxisReason, offered: Object.freeze([]) });
+    }
+    const offered = Object.freeze(option.options.map(({ value }) => value));
+    const match = option.options.find(({ value }) => value === requested);
+    if (match === undefined) {
+        return Object.freeze({
+            field,
+            requested,
+            reason: `ACP Agent option \`${option.id}\` does not offer the value \`${requested}\`.`,
+            offered
+        });
+    }
+    return Object.freeze({
+        field,
+        configId: option.id,
+        value: match.value,
+        previousValue: option.currentValue
+    });
+}
+function isRejection(value) {
+    return "reason" in value;
+}
+/**
+ * The order fields are applied in, and it is load-bearing.
+ *
+ * A model change is what redefines the other axes: selecting a model can reset
+ * the reasoning effort to that model's own default, and can change which effort
+ * values exist at all. So the model is settled first and everything that depends
+ * on it is resolved afterwards, against the list the Agent reports by then. The
+ * permission mode is last because it is the one axis whose wrong value grants
+ * authority rather than merely degrading quality — it is decided when the
+ * Session's shape has stopped moving.
+ */
+export const ACP_CONFIGURATION_ORDER = Object.freeze(["model", "effort", "permission"]);
+/**
+ * Resolve exactly one requested field against the options the Agent reports
+ * right now.
+ *
+ * Per-field and stateless by design. The Session applies one field at a time and
+ * re-reads the Agent's complete list in between, so every resolution must be
+ * computed from the newest list rather than from anything remembered: a value
+ * that was correct before a model change may have been reset by it, and a value
+ * that was unavailable may have become offered. A batch plan computed once
+ * cannot express either, which is why this replaced one.
+ */
+export function resolveAcpConfigurationField(field, desired, options, component) {
+    const outcome = resolveRequest(field, desired, options, component);
+    if (outcome === undefined)
+        return UNREQUESTED;
+    if (isRejection(outcome))
+        return Object.freeze({ kind: "rejection", rejection: outcome });
+    // A value the Agent already holds needs no call. Keeping this distinct from a
+    // value Yui set means a launch never claims to have sent something it did not.
+    return outcome.previousValue === outcome.value
+        ? Object.freeze({ kind: "satisfied", step: outcome })
+        : Object.freeze({ kind: "step", step: outcome });
+}
+const UNREQUESTED = Object.freeze({ kind: "unrequested" });
+function resolveRequest(field, desired, options, component) {
+    if (field === "model") {
+        if (desired.model === undefined)
+            return undefined;
+        return resolveValue("model", desired.model, findOption(options, MODEL_CATEGORY, "model"), "ACP Agent offers no model config option for this Session, so the requested model "
+            + "cannot be selected over the protocol; configure it in the Agent itself.");
+    }
+    if (field === "effort") {
+        if (desired.effort === undefined)
+            return undefined;
+        return resolveValue("effort", desired.effort, findOption(options, EFFORT_CATEGORY, "effort"), "ACP Agent offers no reasoning-effort config option for this Session, so the "
+            + "requested effort cannot be selected over the protocol.");
+    }
+    const permission = desired.permission;
+    // `default` deliberately produces nothing. Yui states no mode, so whatever the
+    // Agent chose for itself stands: an old Role's conservative default is never
+    // widened, and a permissive Agent is not narrowed behind the user's back.
+    if (permission.kind === "default")
+        return undefined;
+    const modeOption = findOption(options, MODE_CATEGORY, ACP_MODE_CONFIG_ID);
+    if (permission.kind === "mode") {
+        return resolveValue("permission", permission.modeId, modeOption, "ACP Agent offers no permission-mode config option for this Session, so the "
+            + "requested mode cannot be applied.");
+    }
+    const bypassValue = agentExecutionComponent(component).bypassPermissionMode;
+    if (bypassValue === undefined) {
+        // The user asked for real elevation and Yui cannot name the value that
+        // grants it for this product. Selecting a mode by how its name reads would
+        // be a guess with authority attached, so the request stops here.
+        return Object.freeze({
+            field: "permission",
+            requested: "bypass",
+            reason: `Yui cannot map the bypass permission strategy onto execution component `
+                + `${component}: no mode value is known to grant it, and Yui does not infer one `
+                + `from a mode's name. Select an exact mode this Agent offers instead.`,
+            offered: Object.freeze(modeOption?.options.map(({ value }) => value) ?? [])
+        });
+    }
+    return resolveValue("permission", bypassValue, modeOption, "ACP Agent offers no permission-mode config option for this Session, so the "
+        + "requested bypass strategy cannot be applied.");
+}
+/**
+ * Re-check every explicitly requested value against the Agent's final option
+ * list, after all calls have been made.
+ *
+ * This exists because confirming each step as it lands is not enough: a later
+ * call can reset an earlier axis. Selecting a model resets the reasoning effort
+ * on real Agents, so a Session can confirm `effort=high`, then confirm
+ * `model=b`, and end up running at that model's default effort with both
+ * per-step checks having passed. Only a check against the last complete list the
+ * Agent reported can see that, and it is the list the prompt would run under.
+ *
+ * Only stated values are checked. An unrequested axis has no expectation to
+ * violate, and `default` permission means Yui asked for nothing.
+ *
+ * Legacy `session/set_mode` peers answer with no option list, so their mode
+ * cannot be re-read; `acknowledged` outcomes carry that and are excluded here
+ * rather than being verified against a value Yui wrote into its own cache.
+ */
+export function verifyAcpConfiguration(desired, options, component, outcomes) {
+    const failures = [];
+    for (const field of ACP_CONFIGURATION_ORDER) {
+        const outcome = outcomes.find((candidate) => candidate.field === field);
+        if (outcome !== undefined && outcome.confirmation === "acknowledged")
+            continue;
+        const resolution = resolveAcpConfigurationField(field, desired, options, component);
+        if (resolution.kind === "unrequested" || resolution.kind === "satisfied")
+            continue;
+        if (resolution.kind === "rejection") {
+            // The axis or the value disappeared from the Agent's final list, so the
+            // request cannot be shown to hold even though a call for it succeeded.
+            failures.push(`Requested ${field} could not be confirmed against the ACP Agent's `
+                + `final configuration. ${resolution.rejection.reason}`);
+            continue;
+        }
+        // The Agent reports a different current value than the one requested, which
+        // means something applied later moved this axis.
+        failures.push(`ACP Agent reports ${field} \`${resolution.step.previousValue}\` after `
+            + `Yui applied this Session's configuration, but the launch requested `
+            + `\`${resolution.step.value}\`.`);
+    }
+    return Object.freeze(failures);
+}
+/**
+ * Confirm that one applied step actually took effect.
+ *
+ * `session/set_config_option` answers with the Session's complete option list,
+ * so the proof is in that answer rather than in the call having not thrown. An
+ * Agent that accepts the call and reports a different current value has
+ * substituted something for what was asked, and that substitution must surface
+ * as a failure instead of passing as success.
+ */
+export function confirmAcpConfigurationStep(step, options) {
+    const option = options.find(({ id }) => id === step.configId);
+    if (option === undefined) {
+        return `ACP Agent stopped reporting config option \`${step.configId}\` after Yui set it, `
+            + `so the requested ${step.field} cannot be confirmed.`;
+    }
+    if (option.currentValue !== step.value) {
+        return `ACP Agent accepted \`${step.configId}\` = \`${step.value}\` but reports `
+            + `\`${option.currentValue}\`, so the requested ${step.field} was not applied.`;
+    }
+    return undefined;
+}
+/** A single readable diagnostic for every request the Agent cannot honour. */
+export function describeAcpConfigurationRejections(rejections) {
+    return rejections
+        .map((rejection) => rejection.offered.length === 0
+        ? rejection.reason
+        : `${rejection.reason} Offered values: ${rejection.offered.join(", ")}.`)
+        .join(" ");
+}
+/**
+ * Read a launch payload's requested configuration into the form this module
+ * plans from.
+ *
+ * The payload keeps the two permission requests as separate fields because they
+ * travel as JSON; this collapses them into the one decision they represent.
+ * Neither present means `default`, which sends no mode at all.
+ */
+export function acpDesiredSessionConfiguration(options) {
+    return Object.freeze({
+        ...(options.model === undefined ? {} : { model: options.model }),
+        ...(options.effort === undefined ? {} : { effort: options.effort }),
+        permission: options.permissionMode !== undefined
+            ? Object.freeze({ kind: "mode", modeId: options.permissionMode })
+            : options.permissionBypass === true
+                ? Object.freeze({ kind: "bypass" })
+                : Object.freeze({ kind: "default" })
+    });
+}

package/dist/runtime/agentDriver.js

@@ -41,6 +41,9 @@ export function validateAgentDriverCapabilities(input) {
             throw new Error(`Agent Driver control capability ${name} must be boolean.`);
         }
     }
+    if (!["native", "owned-process"].includes(String(control.interruptDelivery))) {
+        throw new Error("Agent Driver interrupt delivery capability is invalid.");
+    }
     const lifecycle = input.lifecycle;
     if (lifecycle === null || typeof lifecycle !== "object" || Array.isArray(lifecycle)) {
         throw new Error("Agent Driver lifecycle capabilities must be an object.");
@@ -140,6 +143,7 @@ export function validateAgentDriverCapabilities(input) {
             resume: control.resume,
             sendTurn: control.sendTurn,
             interrupt: control.interrupt,
+            interruptDelivery: control.interruptDelivery,
             stop: control.stop
         }),
         conversation: Object.freeze({
@@ -190,9 +194,8 @@ export function managedRuntimeAdmission(capabilities) {
     if (actual.observation.sessionIdentity !== "exact"
         || actual.conversation.persistentIdentity !== "exact")
         missing.push("exact-session-identity");
-    if (actual.observation.promptAcceptance !== "exact"
-        || actual.input.acceptance !== "exact")
-        missing.push("exact-prompt-acceptance");
+    if (!provesPromptAcceptance(actual))
+        missing.push("provable-prompt-acceptance");
     if (actual.lifecycle.host !== "persistent")
         missing.push("persistent-agent-host");
     if (actual.lifecycle.nativeConversationResume !== "exact") {
@@ -206,6 +209,30 @@ export function managedRuntimeAdmission(capabilities) {
         ? Object.freeze({ admitted: true })
         : Object.freeze({ admitted: false, missing: Object.freeze(missing) });
 }
+/**
+ * Whether a Turn's input can be proven either accepted or not accepted.
+ *
+ * Two different protocol shapes satisfy this, and neither is weaker than the
+ * other:
+ *
+ *  - the provider announces acceptance separately from the result, so a Turn
+ *    is known to be running before it finishes (`acceptance: "exact"`);
+ *  - the provider answers the request itself with an exact structured
+ *    terminal, so the reply that settles the Turn is also the proof its input
+ *    was accepted (`bounded.structuredTerminal` with an exact turn lifecycle).
+ *
+ * In the second shape a long wait is genuinely pending rather than unproven:
+ * the correlated response is still owed, and it will say which way the Turn
+ * went. What must never be admitted is a provider that can leave input in a
+ * state with no reply and no acceptance, because nothing there can ever settle
+ * the Turn.
+ */
+function provesPromptAcceptance(actual) {
+    if (actual.observation.promptAcceptance === "exact" && actual.input.acceptance === "exact") {
+        return true;
+    }
+    return actual.bounded.structuredTerminal && actual.observation.turnLifecycle === "exact";
+}
 export function boundedRuntimeAdmission(capabilities) {
     const actual = validateAgentDriverCapabilities(capabilities);
     const missing = [];
@@ -314,19 +341,11 @@ export function normalizeAgentDriverHookClassification(input) {
     }
     if (input.continuationId !== undefined) {
         requireText(input.continuationId, "Agent Driver Hook continuation id");
-        if (!Number.isSafeInteger(input.continuationGeneration)
-            || input.continuationGeneration < 1) {
-            throw new Error("Agent Driver Hook continuation generation is invalid.");
-        }
-    }
-    else if (input.continuationGeneration !== undefined) {
-        throw new Error("Agent Driver Hook continuation generation requires an id.");
     }
     return Object.freeze({
         ...(input.startupSession === undefined ? {} : { startupSession: input.startupSession }),
         ...(input.continuationId === undefined ? {} : {
             continuationId: input.continuationId,
-            continuationGeneration: input.continuationGeneration
         }),
         terminal: input.terminal ?? false
     });

package/dist/runtime/agentEndpoint.js

@@ -0,0 +1,278 @@
+import { builtinAgentDriverRegistry } from "./builtinAgentDrivers.js";
+import { builtinAgentEndpointImplementation, requireBuiltinAgentEndpointImplementation } from "./agentEndpointIdentity.js";
+import { CodexPreSubmissionError } from "./codexAppServerRuntime.js";
+export { builtinAgentEndpointImplementation } from "./agentEndpointIdentity.js";
+import { ProviderDeliveryUnknownError, ProviderTurnBusyError, ProviderTurnRejectedError, startStructuredProviderSession } from "./structuredProviderHost.js";
+/**
+ * The only built-in managed execution factory. Product/protocol codecs remain
+ * private to runtime; the Host consumes the same boundary for both providers.
+ * An injected opener is useful for isolated protocol evidence, not a fallback.
+ */
+export function createAgentEndpointFactory(start = startStructuredProviderSession) {
+    const connect = async (payload, mode) => {
+        const control = payload.providerControl;
+        if (control === undefined || control.mode !== mode) {
+            throw new Error(`AgentEndpoint ${mode === "new" ? "open" : "resume"} requires matching Session intent.`);
+        }
+        const pinned = control.endpointImplementation;
+        const implementation = pinned === undefined ? builtinAgentEndpointImplementation(control.adapterId)
+            : Object.freeze({ ...requireBuiltinAgentEndpointImplementation(control.adapterId, pinned) });
+        // Clone before asynchronous startup; callers must not mutate the Session's
+        // effective invocation when configuration changes for a subsequent AgentRun.
+        const configuration = Object.freeze({
+            implementation,
+            command: payload.command,
+            args: Object.freeze([...payload.args]),
+            cwd: payload.cwd,
+            ...(payload.executionEnvironment === undefined ? {} : {
+                executionEnvironment: freezeConfiguration(structuredClone(payload.executionEnvironment))
+            }),
+            ...(control.codexThread === undefined ? {} : {
+                threadOptions: freezeConfiguration(structuredClone(control.codexThread))
+            })
+        });
+        let endpoint;
+        const openingEvents = [];
+        const emit = (event) => {
+            if (endpoint === undefined)
+                openingEvents.push(event);
+            else
+                endpoint.observe(event);
+        };
+        const opened = await start(payload, {
+            onAccepted: (value) => emit({ type: "accepted", value }),
+            onActivity: (value) => emit({ type: "activity", value }),
+            onStarted: (value) => emit({ type: "started", value }),
+            onTerminal: (value) => emit({ type: "terminal", value }),
+            onInput: (value) => emit({ type: "input", value }),
+            onGoal: (value) => emit({ type: "goal", value })
+        });
+        endpoint = new BuiltinAgentEndpoint(opened.session, configuration, opened.recoveredTerminal);
+        for (const event of openingEvents)
+            endpoint.observe(event);
+        return Object.freeze({
+            session: endpoint,
+            ...(opened.recoveredTerminal === undefined ? {} : { recoveredTerminal: opened.recoveredTerminal }),
+            ...(opened.goal === undefined ? {} : { goal: opened.goal })
+        });
+    };
+    return Object.freeze({
+        open: (payload) => connect(payload, "new"),
+        resume: (payload) => connect(payload, "resume")
+    });
+}
+function freezeConfiguration(value) {
+    if (value !== null && typeof value === "object") {
+        for (const member of Object.values(value))
+            freezeConfiguration(member);
+        Object.freeze(value);
+    }
+    return value;
+}
+class BuiltinAgentEndpoint {
+    driver;
+    configuration;
+    get ownedProcessId() { return this.driver.ownedProcessId; }
+    get nativeAccountHome() { return this.driver.nativeAccountHome; }
+    capabilities;
+    conversationRecoverability;
+    #listeners = new Set();
+    #openingEvents = [];
+    #attempts = new Map();
+    #terminals = new Map();
+    #attachment = "attached";
+    #cancellation = "not-requested";
+    constructor(driver, configuration, recoveredTerminal) {
+        this.driver = driver;
+        this.configuration = configuration;
+        if (recoveredTerminal?.clientOwned && recoveredTerminal.attemptId !== undefined) {
+            this.#terminals.set(recoveredTerminal.attemptId, cancellationProof(recoveredTerminal));
+        }
+        // The registered Driver, not the adapter name, states which control
+        // affordances this Session really has: a Session that sends a native
+        // cancel message must not be reported as one that can only kill its
+        // process, and vice versa.
+        const capabilities = builtinAgentDriverRegistry()
+            .requireByAdapterId(driver.adapterId)
+            .capabilities;
+        this.capabilities = Object.freeze({
+            steer: capabilities.input.steer === "fenced" ? "native" : "unsupported",
+            cancel: capabilities.control.interruptDelivery === "native"
+                ? "native-interrupt"
+                : "owned-process"
+        });
+        // What the protocol permits is not always what this Agent agreed to. When
+        // the Session settled the question during its own handshake, that answer
+        // wins over the adapter-wide capability, which cannot see the difference
+        // between two Agents on the same adapter.
+        this.conversationRecoverability = driver.conversationRecoverability
+            ?? (capabilities.lifecycle.nativeConversationResume === "exact"
+                && capabilities.conversation.crossProcessResume
+                ? "recoverable"
+                : "unknown");
+        void driver.waitForExit().then(() => { this.#attachment = "exited"; });
+    }
+    get adapterId() { return this.driver.adapterId; }
+    get nativeSessionId() { return this.driver.nativeSessionId; }
+    get conversationId() { return this.driver.conversationId; }
+    get processInstanceId() { return this.driver.processInstanceId; }
+    /**
+     * Delegated rather than copied at construction: the Session reads its own
+     * current state, and a value captured here would freeze the configuration as
+     * it stood when the connection opened.
+     */
+    get runConfiguration() {
+        return this.driver.runConfiguration;
+    }
+    submit(input) {
+        return this.deliver(input, "submit");
+    }
+    steer(input) {
+        return this.deliver(input, "steer");
+    }
+    async deliver(input, operation) {
+        if (!input.attemptId || !input.inputRef)
+            throw new Error("Endpoint input requires attemptId and inputRef.");
+        const previous = this.#attempts.get(input.attemptId);
+        if (previous !== undefined) {
+            if (previous.input.inputRef !== input.inputRef || previous.input.boundedText !== input.boundedText
+                || previous.operation !== operation) {
+                throw new Error("Endpoint attempt identity cannot be reused for different input or operation.");
+            }
+            // Busy is a proven non-write: the same durable request may be tried
+            // explicitly later. Unknown, accepted and in-flight input are never resent.
+            if (previous.disposition.status !== "pending" || previous.disposition.reason !== "native-busy") {
+                return previous.disposition;
+            }
+        }
+        if (this.#attachment !== "attached") {
+            return { status: "not-submitted", error: new ProviderTurnRejectedError("Endpoint is detached.", input.attemptId) };
+        }
+        const attempt = {
+            input: Object.freeze({ ...input }),
+            operation,
+            disposition: { status: "pending", reason: "submitting" }
+        };
+        this.#attempts.set(input.attemptId, attempt);
+        try {
+            const receipt = await (operation === "submit"
+                ? this.driver.submitTurn(input) : this.driver.steerTurn(input));
+            if (receipt.attemptId !== input.attemptId || receipt.nativeSessionId !== this.nativeSessionId
+                || receipt.conversationId !== this.conversationId) {
+                throw new ProviderDeliveryUnknownError("Provider receipt does not match Endpoint input.", input.attemptId);
+            }
+            if (attempt.disposition.status !== "accepted") {
+                attempt.disposition = { status: "accepted", receipt };
+            }
+        }
+        catch (error) {
+            if (attempt.disposition.status === "accepted")
+                return attempt.disposition;
+            attempt.disposition = error instanceof ProviderTurnBusyError
+                ? { status: "pending", reason: "native-busy", error }
+                : error instanceof ProviderTurnRejectedError || error instanceof CodexPreSubmissionError
+                    ? { status: "not-submitted", error }
+                    : {
+                        status: "unknown",
+                        error: error instanceof ProviderDeliveryUnknownError ? error
+                            : new ProviderDeliveryUnknownError("Provider submission outcome is unknown.", input.attemptId, { cause: error })
+                    };
+        }
+        return attempt.disposition;
+    }
+    inspect() {
+        return Object.freeze({
+            ...(this.driver.activeTurnId === undefined ? {} : { activeNativeTurnId: this.driver.activeTurnId }),
+            submissions: Object.freeze([...this.#attempts].map(([attemptId, attempt]) => Object.freeze({
+                attemptId, inputRef: attempt.input.inputRef, disposition: attempt.disposition
+            }))),
+            attachment: this.#attachment,
+            cancellation: this.#cancellation,
+            resources: "unknown"
+        });
+    }
+    observe(value) {
+        if (value.type !== "goal"
+            && (value.value.nativeSessionId !== this.nativeSessionId || value.value.conversationId !== this.conversationId))
+            return;
+        if (value.type === "goal" && value.value !== null && value.value.conversationId !== this.conversationId)
+            return;
+        if (value.type === "accepted") {
+            const attempt = this.#attempts.get(value.value.attemptId);
+            if (attempt === undefined || value.value.acceptance !== "provider")
+                return;
+            attempt.disposition = { status: "accepted", receipt: value.value };
+        }
+        if (value.type === "terminal" && value.value.clientOwned && value.value.attemptId !== undefined) {
+            const attempt = this.#attempts.get(value.value.attemptId);
+            if (attempt !== undefined) {
+                const prior = attempt.disposition;
+                if (prior.status === "accepted" && prior.receipt.nativeTurnId !== undefined
+                    && prior.receipt.nativeTurnId !== value.value.nativeTurnId)
+                    return;
+                // An exactly correlated terminal is stronger evidence than pipe write
+                // or a lost acknowledgement. It never adopts the current attempt.
+                attempt.disposition = {
+                    status: "accepted",
+                    receipt: {
+                        attemptId: value.value.attemptId,
+                        nativeSessionId: this.nativeSessionId,
+                        conversationId: this.conversationId,
+                        ...(value.value.nativeTurnId === undefined ? {} : { nativeTurnId: value.value.nativeTurnId }),
+                        acceptedAt: value.value.observedAt,
+                        acceptance: "provider"
+                    }
+                };
+            }
+            this.#terminals.set(value.value.attemptId, cancellationProof(value.value));
+        }
+        const event = Object.freeze({
+            ...value, implementation: this.configuration.implementation, processInstanceId: this.processInstanceId
+        });
+        if (this.#listeners.size === 0)
+            this.#openingEvents.push(event);
+        else
+            for (const listener of this.#listeners)
+                listener(event);
+    }
+    events(listener) {
+        this.#listeners.add(listener);
+        for (const event of this.#openingEvents.splice(0))
+            listener(event);
+        return () => { this.#listeners.delete(listener); };
+    }
+    async cancel(attemptId) {
+        this.#cancellation = "requested";
+        const status = await this.driver.cancelTurn(attemptId);
+        let terminal = this.#terminals.get(attemptId);
+        if (terminal === undefined && status !== "unknown") {
+            terminal = await new Promise(resolve => {
+                const timer = setTimeout(() => { this.#listeners.delete(listener); resolve(undefined); }, 8_000);
+                const listener = (event) => {
+                    if (event.type !== "terminal" || !event.value.clientOwned || event.value.attemptId !== attemptId)
+                        return;
+                    clearTimeout(timer);
+                    this.#listeners.delete(listener);
+                    resolve(cancellationProof(event.value));
+                };
+                this.#listeners.add(listener);
+            });
+        }
+        if (terminal === undefined || this.driver.activeTurnId !== undefined) {
+            return { status: "unknown", resources: "unknown" };
+        }
+        return Object.freeze({ status, resources: "unknown", terminal });
+    }
+    detach(signal = "SIGTERM") {
+        if (this.#attachment === "exited")
+            return;
+        this.#attachment = "detach-requested";
+        // The driver terminates only its owned proxy/stream process group.
+        this.driver.terminate(signal);
+    }
+    waitForExit() { return this.driver.waitForExit(); }
+}
+function cancellationProof(terminal) {
+    const { input: _input, output: _output, error: _error, rawError: _rawError, ...proof } = terminal;
+    return Object.freeze(proof);
+}