@zq-silk/yui 0.15.12 → 0.16.0

package/dist/resources/resourceRegistry.js

@@ -1,19 +1,13 @@
 /**
  * Persistent Resource registry (Issue 10).
  *
- * The registry is GC's own state.  When the Home is SQLite-backed it lives in
- * the `resource_registry` table inside `yui.db`; otherwise it falls back to a
- * JSON file at `$YUI_HOME/runtime/resource-registry/registry.json`.
+ * The registry lives only in `resource_registry` inside the current `yui.db`.
+ * This module owns its value validation and quarantine paths, not persistence.
  */
-import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
+import { join, resolve } from "node:path";
 import { RESOURCE_REGISTRY_SCHEMA_VERSION } from "./resourceTypes.js";
 export const RESOURCE_REGISTRY_DIRECTORY = "resource-registry";
-export const RESOURCE_REGISTRY_FILE = "registry.json";
 export const RESOURCE_QUARANTINE_DIRECTORY = "quarantine";
-export function resourceRegistryPath(home) {
-    return join(resolve(home), "runtime", RESOURCE_REGISTRY_DIRECTORY, RESOURCE_REGISTRY_FILE);
-}
 export function resourceQuarantineRoot(home) {
     return join(resolve(home), "runtime", RESOURCE_REGISTRY_DIRECTORY, RESOURCE_QUARANTINE_DIRECTORY);
 }
@@ -29,34 +23,6 @@ export function emptyResourceRegistry() {
         records: Object.freeze({})
     });
 }
-/**
- * Load the registry. A missing registry is an empty Home. A corrupt or
- * unreadable registry fails closed: GC must never invent ownership from a
- * corrupt registry, and silently dropping quarantine receipts could let a
- * resource be released twice.
- */
-export function loadResourceRegistry(home) {
-    const path = resourceRegistryPath(home);
-    if (!existsSync(path))
-        return emptyResourceRegistry();
-    let parsed;
-    try {
-        parsed = JSON.parse(readFileSync(path, "utf8"));
-    }
-    catch (error) {
-        throw new Error(`Resource registry is corrupt or unreadable at ${path}: `
-            + `${error instanceof Error ? error.message : "unknown error"}. `
-            + "Fix or remove the registry file before running GC.", { cause: error });
-    }
-    return parseResourceRegistryState(parsed);
-}
-export function saveResourceRegistry(home, state) {
-    const path = resourceRegistryPath(home);
-    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
-    const temporary = `${path}.tmp-${process.pid}`;
-    writeFileSync(temporary, `${JSON.stringify(state, null, 2)}\n`, { mode: 0o600 });
-    renameSync(temporary, path);
-}
 export function upsertResourceRecord(state, record) {
     return Object.freeze({
         schemaVersion: RESOURCE_REGISTRY_SCHEMA_VERSION,

package/dist/resources/resourceRegistryStore.js

@@ -1,41 +1,18 @@
-/**
- * Resource registry store abstraction (Issue 10, DB-only optimal).
- *
- * The GC engine depends on this interface, not on a specific storage backend.
- * When the Home is SQLite-backed the registry lives in the `resource_registry`
- * table inside `yui.db`; otherwise it falls back to a JSON file.
- */
-import { join } from "node:path";
-import { existsSync } from "node:fs";
-import { loadResourceRegistry, saveResourceRegistry } from "./resourceRegistry.js";
 import { SqliteResourceRegistry } from "./sqliteResourceRegistry.js";
-/**
- * JSON-file-backed registry store (File-store Homes).
- */
-export class FileResourceRegistryStore {
-    #home;
-    constructor(home) {
-        this.#home = home;
-    }
-    load() {
-        return loadResourceRegistry(this.#home);
-    }
-    save(state) {
-        saveResourceRegistry(this.#home, state);
-    }
-    close() {
-        // No persistent connection to close.
-    }
+export function createResourceRegistryStore(home) {
+    return new SqliteResourceRegistry(home);
 }
-/**
- * Create the appropriate registry store for a Home.
- *
- * SQLite-backed Homes use the `resource_registry` table in `yui.db`;
- * File-store Homes fall back to the JSON file.
+/** Connections created here never survive a synchronous read/write operation.
+ * A borrowed Store remains the caller's responsibility. No DB handle is held
+ * across filesystem scans, Git subprocesses or other asynchronous GC work.
  */
-export function createResourceRegistryStore(home) {
-    if (existsSync(join(home, "yui.db"))) {
-        return new SqliteResourceRegistry(home);
+export function withResourceRegistry(home, borrowed, operation) {
+    const store = borrowed ?? createResourceRegistryStore(home);
+    try {
+        return operation(store);
+    }
+    finally {
+        if (borrowed === undefined)
+            store.close();
     }
-    return new FileResourceRegistryStore(home);
 }

package/dist/resources/sqliteResourceRegistry.js

@@ -12,16 +12,15 @@
  */
 import { existsSync } from "node:fs";
 import { join } from "node:path";
+import { isDeepStrictEqual } from "node:util";
 import Database from "better-sqlite3";
-import { RESOURCE_REGISTRY_SCHEMA_VERSION } from "./resourceTypes.js";
-import { emptyResourceRegistry, parseResourceRegistryState } from "./resourceRegistry.js";
 import { migrateSqliteSchema } from "../storage/sqliteSchema.js";
+import { emptyResourceRegistry, parseResourceRegistryState } from "./resourceRegistry.js";
+import { RESOURCE_REGISTRY_SCHEMA_VERSION } from "./resourceTypes.js";
 export const SQLITE_RESOURCE_REGISTRY_TABLE = "resource_registry";
 /**
- * A SQLite-backed resource registry store.  Each `save` is a single
- * transaction that upserts every record and removes rows that disappeared
- * from the in-memory state, so the on-disk table always matches the state
- * the GC engine computed.
+ * Each save applies only the caller's delta. Unrelated registrations survive;
+ * a changed same-record snapshot fails closed instead of overwriting ownership.
  */
 export class SqliteResourceRegistry {
     #db;
@@ -31,10 +30,16 @@ export class SqliteResourceRegistry {
             throw new Error(`SQLite database not found at ${dbPath}`);
         }
         this.#db = new Database(dbPath);
-        this.#db.pragma("journal_mode = WAL");
-        this.#db.pragma("foreign_keys = ON");
-        this.#db.pragma("busy_timeout = 5000");
-        migrateSqliteSchema(this.#db, { mode: "validate" });
+        try {
+            this.#db.pragma("journal_mode = WAL");
+            this.#db.pragma("foreign_keys = ON");
+            this.#db.pragma("busy_timeout = 5000");
+            migrateSqliteSchema(this.#db, { mode: "validate" });
+        }
+        catch (error) {
+            this.#db.close();
+            throw error;
+        }
     }
     load() {
         const rows = this.#db.prepare(`SELECT payload FROM ${SQLITE_RESOURCE_REGISTRY_TABLE}`).all();
@@ -63,7 +68,13 @@ export class SqliteResourceRegistry {
             records: Object.freeze(records)
         });
     }
-    save(state) {
+    save(state, previous) {
+        const next = parseResourceRegistryState(state);
+        const before = parseResourceRegistryState(previous);
+        const ids = [...new Set([...Object.keys(before.records), ...Object.keys(next.records)])]
+            .filter(id => !isDeepStrictEqual(before.records[id], next.records[id]));
+        if (ids.length === 0)
+            return;
         const upsert = this.#db.prepare(`INSERT INTO ${SQLITE_RESOURCE_REGISTRY_TABLE}
          (id, kind, path, disposition, task_id, payload, created_at, updated_at)
        VALUES
@@ -76,11 +87,24 @@ export class SqliteResourceRegistry {
          payload = excluded.payload,
          updated_at = excluded.updated_at`);
         const remove = this.#db.prepare(`DELETE FROM ${SQLITE_RESOURCE_REGISTRY_TABLE} WHERE id = ?`);
-        const existingRows = this.#db.prepare(`SELECT id FROM ${SQLITE_RESOURCE_REGISTRY_TABLE}`).all();
-        const existingIds = new Set(existingRows.map((row) => row.id));
-        const currentIds = new Set(Object.keys(state.records));
         const tx = this.#db.transaction(() => {
-            for (const record of Object.values(state.records)) {
+            const read = this.#db.prepare(`SELECT payload FROM ${SQLITE_RESOURCE_REGISTRY_TABLE} WHERE id = ?`);
+            for (const id of ids) {
+                const row = read.get(id);
+                const current = row === undefined ? undefined : parseResourceRegistryState({
+                    schemaVersion: RESOURCE_REGISTRY_SCHEMA_VERSION,
+                    records: { [id]: JSON.parse(row.payload) }
+                }).records[id];
+                if (!isDeepStrictEqual(current, before.records[id])) {
+                    throw new Error(`Resource registry record changed since inspection: ${id}. Inspect and retry.`);
+                }
+            }
+            for (const id of ids) {
+                const record = next.records[id];
+                if (record === undefined) {
+                    remove.run(id);
+                    continue;
+                }
                 upsert.run({
                     id: record.id,
                     kind: record.kind,
@@ -92,20 +116,13 @@ export class SqliteResourceRegistry {
                     updated_at: record.updatedAt
                 });
             }
-            for (const id of existingIds) {
-                if (!currentIds.has(id))
-                    remove.run(id);
-            }
         });
-        tx();
+        tx.immediate();
     }
     close() {
         this.#db.close();
     }
-}
-/**
- * Detect whether a Home uses SQLite storage (yui.db exists).
- */
-export function isSqliteHome(home) {
-    return existsSync(join(home, "yui.db"));
+    transaction(operation) {
+        return this.#db.transaction(operation).immediate();
+    }
 }

package/dist/review/deltaRecheck.js

@@ -8,7 +8,7 @@ export async function assessDeltaRecheck(input) {
     const { repositoryPaths, previousRound, candidate, git } = input;
     if (previousRound.status !== "completed"
         || previousRound.reviewerRunId === undefined
-        || (previousRound.scope ?? "work-item") !== "task") {
+        || previousRound.scope !== "task") {
         return {
             kind: "ineligible",
             reason: "Delta recheck requires a semantic completed Task-final ReviewRound."

package/dist/review/reviewAcceptance.js

@@ -20,7 +20,7 @@ export function isCompletedTaskReviewEvidence(store, round) {
     return isCompletedTaskReviewEvidenceFromRuns(round, store.listRuns(round.taskId));
 }
 export function isCompletedTaskReviewEvidenceFromRuns(round, runs) {
-    if ((round.scope ?? "work-item") !== "task"
+    if (round.scope !== "task"
         || round.taskCandidate === undefined
         || round.taskCandidate.projects.length === 0) {
         return false;

package/dist/review/reviewDecision.js

@@ -4,7 +4,7 @@ import { projectReviewerAvailability } from "./reviewerAvailability.js";
 /** Read-only facts for Leader judgment; this projection never blocks an action. */
 export function projectReviewDecision(input) {
     const { store, task, roles, runs, rounds, reviewConfig, currentCandidate } = input;
-    const taskRounds = rounds.filter((round) => (round.scope ?? "work-item") === "task");
+    const taskRounds = rounds.filter((round) => round.scope === "task");
     const accepted = [...taskRounds]
         .filter((round) => isCompletedTaskReviewEvidence(store, round))
         .sort(compareRoundIdentity)

package/dist/review/reviewRound.js

@@ -10,6 +10,7 @@ export function createReviewRound(id, taskId, workItemId, candidateId, reviewerR
         taskId: requireIdentity(taskId, "Task id"),
         workItemId: requireIdentity(workItemId, "Work Item id"),
         candidateId: requireIdentity(candidateId, "Candidate id"),
+        scope: "work-item",
         reviewerRoleName: requireIdentity(reviewerRoleName, "Reviewer Role"),
         reviewBaseCommit: requireCommit(reviewBaseCommit, "Review base commit"),
         requestedBy: validateReviewRequestSource(requestedBy),
@@ -134,12 +135,12 @@ export function retryReviewRound(round, requestedBy, now) {
     if (round.status !== "failed") {
         throw new Error(`ReviewRound ${round.id} is not retryable from ${round.status}.`);
     }
-    const taskScope = (round.scope ?? "work-item") === "task";
+    const taskScope = round.scope === "task";
     return validateReviewRound({
         schemaVersion: round.schemaVersion,
         id: round.id,
         taskId: round.taskId,
-        ...(round.scope === undefined ? {} : { scope: round.scope }),
+        scope: round.scope,
         ...(taskScope
             ? {}
             : {
@@ -185,9 +186,9 @@ export function retryReviewRound(round, requestedBy, now) {
         createdAt: round.createdAt
     });
 }
-/** Task-final compatibility wrapper for callers that require that scope. */
+/** Scope guard for the Task-final retry operation. */
 export function retryTaskReviewRound(round, requestedBy, now) {
-    if ((round.scope ?? "work-item") !== "task") {
+    if (round.scope !== "task") {
         throw new Error(`Only a Task-final ReviewRound can be retried in place: ${round.id}.`);
     }
     return retryReviewRound(round, requestedBy, now);
@@ -289,7 +290,7 @@ export function validateReviewRound(round) {
     validateTaskRecordReference({ taskId: round.taskId, localId: round.id }, "reviewRound");
     requireIdentity(round.reviewerRoleName, "Reviewer Role");
     requireCommit(round.reviewBaseCommit, "Review base commit");
-    const scope = round.scope ?? "work-item";
+    const scope = round.scope;
     if (scope !== "work-item" && scope !== "task") {
         throw new Error(`ReviewRound scope is invalid: ${String(round.scope)}.`);
     }
@@ -441,10 +442,10 @@ function validateReviewExecutionGroup(group, round) {
         || assignment.taskId !== round.taskId
         || assignment.reviewRoundId !== round.id
         || assignment.reviewBaseCommit !== round.reviewBaseCommit
-        || assignment.scope !== (round.scope ?? "work-item")) {
+        || assignment.scope !== round.scope) {
         throw new Error(`ReviewRound ExecutionGroup provenance is invalid: ${round.id}.`);
     }
-    if ((round.scope ?? "work-item") === "work-item"
+    if (round.scope === "work-item"
         && (assignment.workItemId !== round.workItemId
             || assignment.candidateId !== round.candidateId)) {
         throw new Error(`ReviewRound ExecutionGroup WorkItem target is invalid: ${round.id}.`);

package/dist/review/taskFinalReviewContractResolution.js

@@ -14,7 +14,7 @@ export function resolveRecordedTaskFinalReviewContract(taskId, workItems, review
                     contract: candidate.taskFinalReviewContract,
                     source: `Candidate ${item.id}/${candidate.id}`
                 }]))),
-        ...reviewRounds.flatMap((round) => ((round.scope ?? "work-item") !== "task"
+        ...reviewRounds.flatMap((round) => (round.scope !== "task"
             || round.taskFinalReviewContract === undefined
             ? []
             : [{

package/dist/runtime/acpProtocol.js

@@ -183,58 +183,15 @@ export function readAcpConfigOptions(value) {
 export const ACP_MODE_CONFIG_ID = "mode";
 export function readAcpSessionConfiguration(value) {
     const result = asObject(value);
-    const modern = readAcpConfigOptions(result?.configOptions);
-    if (modern !== undefined) {
-        return Object.freeze({ options: modern, legacyModes: false });
+    const options = readAcpConfigOptions(result?.configOptions);
+    if (options === undefined) {
+        throw new Error("ACP Session must report configOptions; mode-only peers are unsupported.");
     }
-    const legacy = readAcpSessionModes(result?.modes);
-    return Object.freeze({
-        options: legacy === undefined ? Object.freeze([]) : Object.freeze([legacy]),
-        legacyModes: legacy !== undefined
-    });
-}
-/**
- * Convert the legacy `modes` field into the one config option it describes.
- *
- * The shape is fixed by ACP: `currentModeId` plus `availableModes`. Presenting
- * it as a config option keeps mode selection in one vocabulary without
- * pretending the Agent supports the newer method.
- */
-function readAcpSessionModes(value) {
-    const modes = asObject(value);
-    const currentValue = modes === null ? undefined : optionalText(modes.currentModeId);
-    if (modes === null || currentValue === undefined)
-        return undefined;
-    const values = [];
-    if (Array.isArray(modes.availableModes)) {
-        for (const entry of modes.availableModes) {
-            const mode = asObject(entry);
-            const id = mode === null ? undefined : optionalText(mode.id);
-            if (mode === null || id === undefined)
-                continue;
-            values.push(Object.freeze({
-                value: id,
-                name: optionalText(mode.name) ?? id,
-                ...(optionalText(mode.description) === undefined
-                    ? {}
-                    : { description: optionalText(mode.description) })
-            }));
-        }
-    }
-    return Object.freeze({
-        id: ACP_MODE_CONFIG_ID,
-        name: "Mode",
-        category: "mode",
-        currentValue,
-        options: Object.freeze(values)
-    });
+    return Object.freeze({ options });
 }
 export function acpSetConfigOptionRequest(sessionId, configId, value) {
     return { sessionId, configId, value };
 }
-export function acpSetModeRequest(sessionId, modeId) {
-    return { sessionId, modeId };
-}
 export function acpCancelNotification(sessionId) {
     return { sessionId };
 }
@@ -330,10 +287,6 @@ export function readAcpSessionUpdate(params, sessionId) {
                 ? undefined
                 : Object.freeze({ kind: "config-options", options });
         }
-        case "current_mode_update": {
-            const modeId = optionalText(update.currentModeId);
-            return modeId === undefined ? undefined : Object.freeze({ kind: "mode", modeId });
-        }
         case "usage_update":
             return Object.freeze({
                 kind: "usage",

package/dist/runtime/acpSession.js

@@ -1,10 +1,10 @@
 import { isAbsolute } from "node:path";
 import { MAX_RUN_RESULT_OUTPUT_BYTES } from "../domain/agentResultTransport.js";
-import { ACP_METHOD_NOT_FOUND_CODE, acpCancelNotification, acpDeclinePermission, acpInitializeRequest, acpNewSessionRequest, acpPermissionResult, acpPermissionSummary, acpPromptRequest, acpSetConfigOptionRequest, acpSetModeRequest, acpStopReasonDetail, acpTerminalStatus, asObject, optionalText, readAcpConfigOptions, readAcpInitializeResult, readAcpPermissionRequest, readAcpSessionConfiguration, readAcpSessionUpdate, readAcpStopReason } from "./acpProtocol.js";
+import { ACP_METHOD_NOT_FOUND_CODE, acpCancelNotification, acpDeclinePermission, acpInitializeRequest, acpNewSessionRequest, acpPermissionResult, acpPermissionSummary, acpPromptRequest, acpSetConfigOptionRequest, acpStopReasonDetail, acpTerminalStatus, asObject, optionalText, readAcpConfigOptions, readAcpInitializeResult, readAcpPermissionRequest, readAcpSessionConfiguration, readAcpSessionUpdate, readAcpStopReason } from "./acpProtocol.js";
 import { ACP_CONFIGURATION_ORDER, acpRunConfigurationOptions, confirmAcpConfigurationStep, describeAcpConfigurationRejections, resolveAcpConfigurationField, verifyAcpConfiguration } from "./acpSessionConfiguration.js";
 import { handshakeObservationFrom, unknownAgentRunConfiguration } from "./agentRunConfiguration.js";
 import { JsonLineChannel, terminateProcessGroup } from "./jsonLineChannel.js";
-import { ProviderDeliveryUnknownError, ProviderTurnRejectedError } from "./structuredProviderHost.js";
+import { ProviderDeliveryUnknownError, ProviderTurnRejectedError } from "./providerErrors.js";
 /**
  * One Agent Client Protocol Session over an Agent's stdio.
  *
@@ -71,20 +71,10 @@ export class AcpStructuredProviderSession {
      * the complete list, so this is replaced wholesale and never merged.
      */
     #configOptions = [];
-    /** Legacy writes invalidate current evidence until the peer reports it again. */
-    #unobservedConfigIds = new Set();
-    /**
-     * True when this Agent described its options through the legacy `modes` field
-     * only. Mode changes then go to `session/set_mode`, because an Agent that
-     * never advertised config options must not receive
-     * `session/set_config_option`.
-     */
-    #legacyModes = false;
     /**
      * What Yui asked this Session for and what the Agent did with it, recorded so
      * a launch reports the configuration it actually runs under rather than the
-     * one it requested. Each entry carries how strongly it was confirmed, because
-     * a legacy mode-only peer cannot prove more than that it accepted the call.
+     * one it requested. Requested changes require a reported current value.
      */
     #appliedConfiguration = [];
     constructor(child, exit, processInstanceId, channel, onTerminal, mirror) {
@@ -293,7 +283,6 @@ export class AcpStructuredProviderSession {
     #readConfiguration(result) {
         const configuration = readAcpSessionConfiguration(result);
         this.#configOptions = configuration.options;
-        this.#legacyModes = configuration.legacyModes;
     }
     /**
      * Push this launch's requested run configuration and verify the Agent applied
@@ -342,33 +331,11 @@ export class AcpStructuredProviderSession {
                 continue;
             }
             const step = resolution.step;
-            if (this.#legacyModes)
-                this.#unobservedConfigIds.add(step.configId);
-            // An Agent that only ever advertised legacy `modes` has no
-            // `session/set_config_option` handler, so mode changes must use the method
-            // it does implement. Sending the modern method to it would fail with
-            // method-not-found and read as the Agent refusing the value.
-            const result = this.#legacyModes
-                ? await this.#request("session/set_mode", acpSetModeRequest(this.#sessionId, step.value))
-                : await this.#request("session/set_config_option", acpSetConfigOptionRequest(this.#sessionId, step.configId, step.value), (response) => {
-                    const options = readAcpConfigOptions(asObject(response)?.configOptions);
-                    if (options !== undefined)
-                        this.#configOptions = options;
-                });
-            if (this.#legacyModes) {
-                // `session/set_mode` answers with no options, so the only fact available
-                // is that the Agent accepted the call. Yui's own view is left untouched:
-                // writing the requested value into the cached list would manufacture the
-                // very confirmation the protocol withheld, and the final verification
-                // would then read Yui's own assumption back as the Agent's report.
-                outcomes.push(Object.freeze({
-                    field,
-                    configId: step.configId,
-                    value: step.value,
-                    confirmation: "acknowledged"
-                }));
-                continue;
-            }
+            const result = await this.#request("session/set_config_option", acpSetConfigOptionRequest(this.#sessionId, step.configId, step.value), (response) => {
+                const options = readAcpConfigOptions(asObject(response)?.configOptions);
+                if (options !== undefined)
+                    this.#configOptions = options;
+            });
             // The answer is the whole option list, so it both confirms this step and
             // carries any change the Agent made alongside it.
             const options = readAcpConfigOptions(asObject(result)?.configOptions);
@@ -385,7 +352,7 @@ export class AcpStructuredProviderSession {
         // Every call has landed, so this is the configuration the prompt would run
         // under. Re-checking all requested values here is what catches an axis that a
         // later call reset after its own step had already been confirmed.
-        const failures = verifyAcpConfiguration(desired, this.#configOptions, component, outcomes);
+        const failures = verifyAcpConfiguration(desired, this.#configOptions, component);
         if (failures.length > 0) {
             throw new Error(`ACP Session run configuration did not hold. ${failures.join(" ")}`);
         }
@@ -409,11 +376,6 @@ export class AcpStructuredProviderSession {
      * rather than as the launch's confirmed one. Reading the private field on every
      * call rather than caching a projection is what makes that true: a snapshot
      * taken at launch would keep reporting a configuration this Session has left.
-     *
-     * A legacy mode-only peer has no reported value to pair with its
-     * `acknowledged` step, because Yui deliberately never wrote the requested value
-     * into its own view. That absence is stated as `unobserved` instead of being
-     * filled in from the request.
      */
     get runConfiguration() {
         if (this.#closed !== undefined) {
@@ -438,24 +400,8 @@ export class AcpStructuredProviderSession {
             })))
         });
     }
-    /**
-     * What the Agent reports for one listed axis.
-     *
-     * Almost always an observation: the option list ACP sends is the Agent's own
-     * report. The exception is an axis Yui changed on a legacy peer, whose value
-     * here still dates from the setup reply because `session/set_mode` returned
-     * nothing to refresh it with. That entry is listed — the axis is real and its
-     * enumeration is accurate — but its value is stale by construction, so it is
-     * reported as unobserved rather than as the Agent's current answer.
-     */
+    /** The current complete option list is the Agent's own report. */
     #axisValue(option) {
-        if (this.#unobservedConfigIds.has(option.id)) {
-            return Object.freeze({
-                status: "unobserved",
-                reason: "Yui set this axis with `session/set_mode`, which reports no "
-                    + `configuration, so the Agent last reported \`${option.currentValue}\` before that call.`
-            });
-        }
         return Object.freeze({ status: "observed", value: option.currentValue });
     }
     /** Read current evidence independently of the request's historical confirmation. */
@@ -631,17 +577,6 @@ export class AcpStructuredProviderSession {
         // already confirmed before any prompt was sent.
         if (update?.kind === "config-options") {
             this.#configOptions = update.options;
-            this.#unobservedConfigIds.clear();
-            return;
-        }
-        if (update?.kind === "mode") {
-            for (const option of this.#configOptions) {
-                if (option.category === "mode")
-                    this.#unobservedConfigIds.delete(option.id);
-            }
-            this.#configOptions = this.#configOptions.map((option) => option.category === "mode"
-                ? Object.freeze({ ...option, currentValue: update.modeId })
-                : option);
             return;
         }
         // Streamed content is Provider-visible progress, mirrored for the Turn

package/dist/runtime/acpSessionConfiguration.js

@@ -181,17 +181,10 @@ function resolveRequest(field, desired, options, component) {
  *
  * 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) {
+export function verifyAcpConfiguration(desired, options, component) {
     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;

package/dist/runtime/agentEndpoint.js

@@ -1,8 +1,9 @@
-import { builtinAgentDriverRegistry } from "./builtinAgentDrivers.js";
 import { builtinAgentEndpointImplementation, requireBuiltinAgentEndpointImplementation } from "./agentEndpointIdentity.js";
+import { builtinAgentDriverRegistry } from "./builtinAgentDrivers.js";
 import { CodexPreSubmissionError } from "./codexAppServerRuntime.js";
+import { ProviderDeliveryUnknownError, ProviderTurnBusyError, ProviderTurnRejectedError } from "./providerErrors.js";
+import { startStructuredProviderSession } from "./structuredProviderHost.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.

package/dist/runtime/agentFailureContext.js

@@ -0,0 +1,43 @@
+import { createHash } from "node:crypto";
+import { isAbsolute } from "node:path";
+import { requireIdentity } from "../domain/validation.js";
+import { projectAgentCapabilityConfig, validateAgentCapabilityConfig } from "../executor/agentCapabilityConfig.js";
+export function configuredAgentFingerprint(agent) {
+    // Environment entries name bindings, never their resolved secret values.
+    return createHash("sha256").update(JSON.stringify({
+        id: agent.id, component: agent.component, adapterId: agent.adapterId,
+        command: agent.command, baseArgs: agent.baseArgs, environment: agent.environment
+    })).digest("hex");
+}
+export function captureAgentFailureContext(effective, agent) {
+    const value = effective === undefined || agent === null
+        ? { status: "unavailable", reason: "The failing execution did not report a complete launch configuration." }
+        : agent.id !== effective.agentId || agent.adapterId !== effective.adapterId || agent.component !== effective.component
+            ? { status: "unavailable", reason: "The configured Agent no longer matches the failing execution's implementation." }
+            : { status: "recorded", agentId: effective.agentId, cwd: effective.workspace.root,
+                config: projectAgentCapabilityConfig(effective),
+                agentFingerprint: configuredAgentFingerprint(agent) };
+    return JSON.stringify(value);
+}
+export function readAgentFailureContext(value) {
+    if (value === undefined)
+        throw new Error("Agent failure is missing its configuration context.");
+    const parsed = JSON.parse(value);
+    if (parsed?.status === "unavailable" && typeof parsed.reason === "string" && parsed.reason.length > 0)
+        return parsed;
+    if (parsed?.status !== "recorded" || !/^[a-f0-9]{64}$/.test(parsed.agentFingerprint)) {
+        throw new Error("Agent failure configuration context is invalid.");
+    }
+    if (Object.keys(parsed).some(key => !["status", "agentId", "cwd", "config", "agentFingerprint"].includes(key))) {
+        throw new Error("Agent failure context contains unsupported fields.");
+    }
+    requireIdentity(parsed.agentId, "Failure Agent id");
+    if (typeof parsed.cwd !== "string" || !isAbsolute(parsed.cwd) || parsed.cwd.includes("\0")) {
+        throw new Error("Agent failure working directory is invalid.");
+    }
+    validateAgentCapabilityConfig(parsed.config);
+    return parsed;
+}
+export function failureCapabilitiesCommand(taskId, roleName, eventId) {
+    return `yui task role capabilities ${taskId} ${roleName} --error ${eventId} --refresh`;
+}