@zq-silk/yui 0.16.0 → 0.16.2

package/dist/repository/gitWorkspace.js

@@ -348,6 +348,11 @@ export class NodeGitWorkspace {
         }
         await canonicalContainer(dirname(destination), true);
         const branch = input.branch === undefined ? undefined : safeRef(input.branch);
+        // Reserve exactly this operation's directory before invoking Git. A clone
+        // rejection because somebody else created the destination cannot authorize
+        // removal of that other directory.
+        await mkdir(destination, { mode: 0o700 });
+        const createdDirectory = await lstat(destination);
         try {
             await git([
                 "clone",
@@ -363,12 +368,31 @@ export class NodeGitWorkspace {
                 }
                 await git(["-C", destination, "branch", "-M", "--", localBranch]);
             }
+            return await this.inspect(destination, "HEAD");
         }
         catch (error) {
-            await rm(destination, { recursive: true, force: true });
+            try {
+                const current = await lstat(destination).catch(failure => {
+                    if (isErrno(failure, "ENOENT"))
+                        return undefined;
+                    throw failure;
+                });
+                if (current !== undefined) {
+                    if (!current.isDirectory() || current.dev !== createdDirectory.dev || current.ino !== createdDirectory.ino) {
+                        throw new Error("Clone destination ownership changed; no direct deletion attempted.");
+                    }
+                    await rm(destination, { recursive: true });
+                }
+            }
+            catch (cleanupError) {
+                throw new AggregateError([error, cleanupError], `Clone failed at ${destination}: ${error instanceof Error ? error.message : String(error)}. `
+                    + `Temporary compensation failed: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}. `
+                    + "Cleanup effects are unconfirmed; inspect this exact destination before retrying.");
+            }
+            if (error instanceof Error)
+                error.message += ` Exact temporary clone directory removed or already absent: ${destination}.`;
             throw error;
         }
-        return this.inspect(destination, "HEAD");
     }
     async ensureLocalBranch(repositoryPath, branch) {
         try {
@@ -822,31 +846,54 @@ export class NodeGitWorkspace {
      * worktree's own Git identity instead. Only call for unadopted worktrees
      * that are safe to discard (e.g. Lane preparation compensation).
      */
-    async removeStrandedWorktree(path) {
-        const kind = await pathKind(path);
-        if (kind === undefined)
-            return "missing";
-        if (kind === "symlink")
-            throw new Error("Stranded worktree path must not be a symbolic link.");
-        // Inspect dirty state through the worktree's own Git, bypassing the
-        // Project ownership check that fails after a catalog switch.
-        const porcelain = await git(["-C", path, "status", "--porcelain=v1", "--untracked-files=all"]);
-        if (porcelain.length > 0)
-            return "dirty";
+    async removeStrandedWorktree(path, identity) {
+        let worktreeRemoved = false;
         try {
-            await git(["-C", path, "worktree", "remove", "--force", "--", path]);
+            const expected = managedPath(resolve(identity.container), safeIdentity(identity.directory, "Project directory"));
+            if (path !== expected)
+                throw new Error("Unadopted worktree does not match its exact managed path.");
+            const kind = await pathKind(path);
+            if (kind === undefined)
+                return "missing";
+            if (kind === "symlink")
+                throw new Error("Stranded worktree path must not be a symbolic link.");
+            await canonicalContainer(identity.container, false);
+            if (!(await lstat(join(path, ".git"))).isFile()) {
+                throw new Error("Expected a linked worktree, not a standalone clone.");
+            }
+            const project = await this.inspect(path, "HEAD");
+            await assertOwnedWorktree(project, resolve(identity.container), path);
+            const branch = worktreeIdentity(identity.taskSegment, identity.roleName).branch;
+            await assertExpectedBranch(path, branch);
+            if (project.baseCommit !== identity.expectedCommit) {
+                throw new Error("Unadopted worktree HEAD changed since preparation; retained.");
+            }
+            if (!await this.inspectClean(path))
+                return "dirty";
+            // Use the worktree's proven common directory, never the changed catalog.
+            // Git still enforces locks/submodule restrictions. A Git error is not
+            // authority for direct filesystem deletion, even for unadopted work.
+            await git(["--git-dir", project.gitDirectory, "worktree", "remove", "--", path]);
+            worktreeRemoved = true;
+            if (identity.deleteBranch === true) {
+                await git(["--git-dir", project.gitDirectory, "update-ref", "-d", `refs/heads/${branch}`, identity.expectedCommit]);
+            }
+            return "removed";
         }
-        catch {
-            // The worktree's common-dir (old external repo) may itself be gone.
-            // Remove the directory directly; the worktree is unadopted.
-            await rm(path, { recursive: true, force: true });
+        catch (error) {
+            throw new Error(`Unadopted worktree cleanup failed at ${path}: ${error instanceof Error ? error.message : String(error)} `
+                + `Confirmed worktree removal: ${worktreeRemoved}; failed-command effects remain unconfirmed. `
+                + "No direct deletion was attempted. Inspect this exact path and its Git registration before choosing recovery.", { cause: error });
         }
-        return "removed";
     }
     async removeTaskClone(input) {
         const state = await this.inspectTaskClone(input);
         if (state !== "clean")
             return state;
+        if (input.expectedCommit !== undefined
+            && await resolveRefCommit(input.path, "HEAD") !== input.expectedCommit) {
+            throw new Error(`Unadopted Task clone HEAD changed since preparation; retained at ${input.path}.`);
+        }
         await rm(managedPath(resolve(input.container), input.directory), { recursive: true });
         return "removed";
     }

package/dist/repository/taskWorkspacePreparer.js

@@ -545,7 +545,7 @@ export class FileTaskWorkspacePreparer {
         const taskSegment = taskWorkspaceRefSegment(workspaceIdentity === undefined ? task : { ...task, workspaceIdentity });
         const root = this.#taskWorkspaceRoot(task.id);
         const prepared = [];
-        const createdClonePaths = new Set();
+        const createdClones = [];
         const baselines = new Map();
         try {
             // Resolve every remote baseline before creating any Task clone. A later
@@ -595,7 +595,14 @@ export class FileTaskWorkspacePreparer {
                     })
                     : await this.git.inspect(previous.path, "HEAD");
                 if (previous === undefined)
-                    createdClonePaths.add(physical.root);
+                    createdClones.push({
+                        project,
+                        entry: {
+                            projectId: project.id, directory: binding.directory, access: "write",
+                            path: destination, branch: identity.branch,
+                            baseRef: baseline.recordedBaseRef, baseCommit: physical.baseCommit
+                        }
+                    });
                 const physicalBranch = await this.git.headRef(physical.root);
                 if (physical.root !== (previous?.path ?? destination)
                     || physicalBranch !== (previous?.branch ?? identity.branch)) {
@@ -794,16 +801,7 @@ export class FileTaskWorkspacePreparer {
             // A failed or conflicted preparation owns no durable record: drop the
             // branches too, so a retry mints a clean identity without half-created
             // refs behind. Adopted (already catalogued) worktrees are never touched.
-            await this.#discardUnadoptedEntries(task, taskSegment, prepared, MAIN_WORKTREE, true);
-            const recorded = new Set(prepared.map(({ entry }) => entry.path));
-            for (const path of createdClonePaths) {
-                if (recorded.has(path))
-                    continue;
-                const removal = await this.git.removeStrandedWorktree(path);
-                if (removal === "dirty") {
-                    throw new Error(`Unadopted Task clone is dirty and was retained at ${path}; inspect it and retry.`);
-                }
-            }
+            await this.#discardUnadoptedEntries(task, taskSegment, createdClones, MAIN_WORKTREE, true, undefined, error);
             if (activate)
                 await removeWorkspaceView(root);
             throw error;
@@ -1125,7 +1123,7 @@ export class FileTaskWorkspacePreparer {
                 });
             }
             catch (error) {
-                await this.#discardUnadoptedEntries(lockedTask, taskSegment, prepared, item.id);
+                await this.#discardUnadoptedEntries(lockedTask, taskSegment, prepared, item.id, false, undefined, error);
                 throw error;
             }
         }
@@ -1276,7 +1274,7 @@ export class FileTaskWorkspacePreparer {
                 return workspace;
             }
             catch (error) {
-                await this.#discardUnadoptedEntries(lockedTask, taskSegment, prepared, managedWorktreeName(owner), true);
+                await this.#discardUnadoptedEntries(lockedTask, taskSegment, prepared, managedWorktreeName(owner), true, undefined, error);
                 throw error;
             }
         }
@@ -1354,48 +1352,39 @@ export class FileTaskWorkspacePreparer {
             return "missing";
         const task = requireTask(this.store, workspace.owner.taskId);
         const taskSegment = this.#taskSegment(task);
+        const root = this.#executionLaneWorkspaceRoot(task.id, workspace.owner.executionGroupId, workspace.owner.executionLaneId);
+        if (workspace.root !== root)
+            throw new Error("Unadopted Lane root does not match its managed owner.");
         const writable = workspace.entries.filter(({ access }) => access === "write");
-        let state;
+        const completed = [];
+        let target = root;
         try {
-            state = await this.#inspectEntries(task.id, taskSegment, managedWorktreeName(workspace.owner), writable);
-        }
-        catch (error) {
-            // A `project migrate` between preparation and compensation switches the
-            // catalog, so the worktree's common-dir no longer matches the Project's
-            // current repository. Fall back to removing the stranded worktree
-            // through its own Git identity.
-            if (!(error instanceof Error && error.message.includes("belongs to another project"))) {
-                throw error;
-            }
-            let removed = false;
+            // This owner was never adopted. Its captured identity is sufficient to
+            // inspect its own Git; no catalog-error matching or filesystem fallback.
             for (const entry of writable) {
-                const result = await this.git.removeStrandedWorktree(entry.path);
-                if (result === "dirty")
-                    return "dirty";
-                removed ||= result === "removed";
+                target = entry.path;
+                const result = await this.git.removeStrandedWorktree(entry.path, {
+                    container: root, directory: entry.directory, taskSegment,
+                    roleName: managedWorktreeName(workspace.owner), expectedCommit: entry.baseCommit,
+                    deleteBranch: true
+                });
+                if (result === "dirty") {
+                    if (completed.length === 0)
+                        return "dirty";
+                    throw new Error(`Unadopted Lane is dirty and retained at ${entry.path}.`);
+                }
+                completed.push({ path: entry.path, result });
             }
-            await removeWorkspaceView(workspace.root);
-            return removed ? "removed" : "missing";
+            target = root;
+            await removeWorkspaceView(root);
+            return completed.some(({ result }) => result === "removed") ? "removed" : "missing";
         }
-        if (state === "dirty")
-            return "dirty";
-        let removed = false;
-        for (const entry of writable) {
-            const project = requireProject(this.store, entry.projectId);
-            const result = await this.git.removeWorktree({
-                repositoryPath: this.#taskRepositoryPath(task.id, project.id),
-                container: dirname(entry.path),
-                directory: entry.directory,
-                taskSegment,
-                roleName: managedWorktreeName(workspace.owner),
-                deleteBranch: true
-            });
-            if (result === "dirty")
-                return "dirty";
-            removed ||= result === "removed";
+        catch (error) {
+            const result = { completed, failedPath: target,
+                remaining: writable.map(({ path }) => path).filter(path => !completed.some(done => done.path === path)) };
+            throw Object.assign(new Error(`Unadopted Lane cleanup failed: ${errorText(error)}. Effects: ${JSON.stringify(result)}. `
+                + "Failed-command effects are unknown; inspect the exact target before continuing.", { cause: error }), { result });
         }
-        await removeWorkspaceView(workspace.root);
-        return removed ? "removed" : "missing";
     }
     async cleanupExecutionLaneWorkspacesForWorkItem(taskId, workItemId) {
         let result = "missing";
@@ -1754,7 +1743,7 @@ export class FileTaskWorkspacePreparer {
                 });
             }
             catch (error) {
-                await this.#discardUnadoptedEntries(task, taskSegment, prepared, this.#reviewWorktreeName(round), existing === null, new Set([...retained.values()].map(({ entry }) => entry.path)));
+                await this.#discardUnadoptedEntries(task, taskSegment, prepared, this.#reviewWorktreeName(round), existing === null, new Set([...retained.values()].map(({ entry }) => entry.path)), error);
                 throw error;
             }
         }
@@ -2243,28 +2232,43 @@ export class FileTaskWorkspacePreparer {
         return this.store.getConfig().defaultWorkspace ?? process.cwd();
     }
     async #discardUnadoptedEntries(task, taskSegment, prepared, roleName, deleteBranch = false, adoptedPaths = new Set(this.store.listManagedWorkspaces(task.id)
-        .flatMap((workspace) => workspace.entries.map(({ path }) => path)))) {
-        for (const { project, entry } of prepared.filter(({ entry }) => entry.access === "write" && !adoptedPaths.has(entry.path))) {
-            if (roleName === MAIN_WORKTREE) {
-                const removal = await this.git.removeStrandedWorktree(entry.path);
+        .flatMap((workspace) => workspace.entries.map(({ path }) => path))), originalError) {
+        const candidates = prepared.filter(({ entry }) => entry.access === "write" && !adoptedPaths.has(entry.path));
+        const completed = [];
+        for (const { project, entry } of candidates) {
+            try {
+                const removal = roleName === MAIN_WORKTREE
+                    ? await this.git.removeTaskClone({
+                        path: entry.path, container: this.#taskWorkspaceRoot(task.id),
+                        directory: entry.directory, taskSegment, branch: entry.branch,
+                        expectedCommit: entry.baseCommit
+                    })
+                    : await this.git.removeWorktree({
+                        repositoryPath: this.#taskRepositoryPath(task.id, project.id),
+                        container: dirname(entry.path),
+                        directory: entry.directory,
+                        taskSegment,
+                        roleName,
+                        ...(deleteBranch ? { deleteBranch: true } : {})
+                    });
                 if (removal === "dirty") {
-                    throw new Error(`Unadopted Task clone is dirty and was retained at ${entry.path}; inspect it and retry.`);
+                    throw new Error(`Unadopted workspace is dirty and was retained at ${entry.path}.`);
                 }
+                completed.push({ path: entry.path, result: removal });
                 this.#resourceRegistrar().markPathsDeleted([entry.path]);
-                continue;
             }
-            const removal = await this.git.removeWorktree({
-                repositoryPath: this.#taskRepositoryPath(task.id, project.id),
-                container: dirname(entry.path),
-                directory: entry.directory,
-                taskSegment,
-                roleName,
-                ...(deleteBranch ? { deleteBranch: true } : {})
-            });
-            if (removal === "dirty") {
-                throw new Error(`Unadopted managed worktree is dirty and was retained at ${entry.path}; inspect it and retry.`);
+            catch (cleanupError) {
+                const remaining = candidates.map(({ entry }) => entry.path)
+                    .filter(path => !completed.some(done => done.path === path));
+                const result = { completed, failedPath: entry.path, remaining };
+                throw Object.assign(new AggregateError([originalError, cleanupError], `Workspace preparation failed: ${errorText(originalError)}. Compensation failed: ${errorText(cleanupError)}. `
+                    + `Effects: ${JSON.stringify(result)}. Remaining paths may be partially changed; inspect before retrying.`), { result });
             }
-            this.#resourceRegistrar().markPathsDeleted([entry.path]);
+        }
+        if (originalError instanceof Error && completed.length > 0) {
+            // Preserve the original error class (notably a safe CAS retry), while
+            // making completed compensation visible to the caller's existing report.
+            originalError.message += ` Workspace compensation: ${JSON.stringify(completed)}.`;
         }
     }
     #taskRepositoryPath(taskId, projectId) {
@@ -2653,3 +2657,6 @@ function errorCode(error) {
         ? String(error.code)
         : undefined;
 }
+function errorText(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/resources/resourceRegistry.js

@@ -43,7 +43,7 @@ export function listResourceRecords(state) {
     return Object.values(state.records);
 }
 export function parseResourceRegistryState(value) {
-    if (typeof value !== "object" || value === null) {
+    if (!isRecord(value)) {
         throw new Error("Resource registry root is not an object.");
     }
     const record = value;
@@ -51,15 +51,12 @@ export function parseResourceRegistryState(value) {
         throw new Error(`Resource registry schemaVersion is ${String(record.schemaVersion)}; `
             + `expected ${RESOURCE_REGISTRY_SCHEMA_VERSION}.`);
     }
-    if (typeof record.records !== "object" || record.records === null) {
+    if (!isRecord(record.records)) {
         throw new Error("Resource registry records is not an object.");
     }
     const records = {};
     for (const [key, entry] of Object.entries(record.records)) {
-        const parsed = parseResourceRecord(entry);
-        if (parsed === undefined) {
-            throw new Error(`Resource registry record ${key} is malformed.`);
-        }
+        const parsed = parseResourceRecord(entry, key);
         if (parsed.id !== key) {
             throw new Error(`Resource registry record key ${key} does not match id ${parsed.id}.`);
         }
@@ -70,47 +67,96 @@ export function parseResourceRegistryState(value) {
         records: Object.freeze(records)
     });
 }
-function parseResourceRecord(value) {
-    if (typeof value !== "object" || value === null)
-        return undefined;
-    const record = value;
+function parseResourceRecord(value, key) {
+    const invalid = (field) => {
+        throw new Error(`Resource registry record ${key} is malformed at ${field}; stored evidence was not repaired.`);
+    };
+    const object = (value, field) => isRecord(value) ? value : invalid(field);
+    const text = (value, field) => {
+        if (typeof value !== "string" || value.trim().length === 0)
+            invalid(field);
+    };
+    const timestamp = (value, field) => {
+        text(value, field);
+        if (!Number.isFinite(Date.parse(value)))
+            invalid(field);
+    };
+    const member = (value, choices, field) => {
+        if (typeof value !== "string" || !choices.includes(value))
+            invalid(field);
+    };
+    const optionalText = (record, fields, prefix = "") => {
+        for (const field of fields) {
+            if (record[field] !== undefined)
+                text(record[field], `${prefix}${field}`);
+        }
+    };
+    const record = object(value, "record");
     if (record.schemaVersion !== RESOURCE_REGISTRY_SCHEMA_VERSION)
-        return undefined;
-    if (typeof record.id !== "string" || typeof record.kind !== "string"
-        || typeof record.path !== "string" || typeof record.disposition !== "string"
-        || typeof record.updatedAt !== "string") {
-        return undefined;
+        invalid("schemaVersion");
+    text(record.id, "id");
+    text(record.path, "path");
+    timestamp(record.updatedAt, "updatedAt");
+    member(record.kind, ["worktree", "deployment", "runtime-artifact"], "kind");
+    member(record.disposition, ["active", "releasable", "quarantined", "deleted",
+        "retained-dirty", "retained-unowned", "retained-unproven", "cleanup-failed"], "disposition");
+    member(record.cleanliness, ["clean", "dirty", "unknown", "n/a"], "cleanliness");
+    if (!Array.isArray(record.activeRefs))
+        invalid("activeRefs");
+    record.activeRefs.forEach((ref, index) => text(ref, `activeRefs[${index}]`));
+    const owner = object(record.owner, "owner");
+    text(owner.home, "owner.home");
+    member(owner.basis, ["durable-record", "marker", "descriptor", "naming-convention", "unattributed"], "owner.basis");
+    optionalText(owner, ["projectId", "taskId", "workItemId", "reviewRoundId", "integrationAttemptId"], "owner.");
+    for (const field of ["createdAt", "lastReferencedAt"]) {
+        if (record[field] !== undefined)
+            timestamp(record[field], field);
     }
-    if (!Number.isFinite(Date.parse(record.updatedAt)))
-        return undefined;
-    if (typeof record.owner !== "object" || record.owner === null)
-        return undefined;
-    const owner = record.owner;
-    if (typeof owner.home !== "string" || typeof owner.basis !== "string") {
-        return undefined;
+    if (record.sizeBytes !== undefined
+        && (typeof record.sizeBytes !== "number" || !Number.isFinite(record.sizeBytes) || record.sizeBytes < 0)) {
+        invalid("sizeBytes");
     }
+    if (record.blocker !== undefined && typeof record.blocker !== "string")
+        invalid("blocker");
+    if (record.git !== undefined) {
+        const git = object(record.git, "git");
+        text(git.repositoryPath, "git.repositoryPath");
+        optionalText(git, ["commonDir", "branch", "head"], "git.");
+    }
+    if (record.quarantine !== undefined) {
+        const quarantine = object(record.quarantine, "quarantine");
+        text(quarantine.path, "quarantine.path");
+        text(quarantine.originalPath, "quarantine.originalPath");
+        timestamp(quarantine.movedAt, "quarantine.movedAt");
+        member(quarantine.method, ["move", "git-worktree-remove"], "quarantine.method");
+        if (quarantine.gitRestore !== undefined) {
+            const restore = object(quarantine.gitRestore, "quarantine.gitRestore");
+            text(restore.repositoryPath, "quarantine.gitRestore.repositoryPath");
+            optionalText(restore, ["branch", "head"], "quarantine.gitRestore.");
+        }
+    }
+    if (record.cleanupReceipt !== undefined) {
+        const receipt = object(record.cleanupReceipt, "cleanupReceipt");
+        timestamp(receipt.removedAt, "cleanupReceipt.removedAt");
+        member(receipt.method, ["git-worktree-remove", "quarantine-purge", "runtime-cleanup"], "cleanupReceipt.method");
+    }
+    // Validation enforces the existing persisted contract, without defaults,
+    // filtering, or a second historical reader. Constructors own new values.
+    const parsed = record;
     return Object.freeze({
-        schemaVersion: RESOURCE_REGISTRY_SCHEMA_VERSION,
-        id: record.id,
-        kind: record.kind,
-        path: record.path,
-        owner: Object.freeze({ ...owner }),
-        ...(record.git === undefined ? {} : { git: record.git }),
-        ...(typeof record.createdAt === "string" ? { createdAt: record.createdAt } : {}),
-        ...(typeof record.lastReferencedAt === "string"
-            ? { lastReferencedAt: record.lastReferencedAt }
-            : {}),
-        ...(typeof record.sizeBytes === "number" ? { sizeBytes: record.sizeBytes } : {}),
-        cleanliness: (record.cleanliness ?? "unknown"),
-        activeRefs: Array.isArray(record.activeRefs)
-            ? Object.freeze(record.activeRefs.filter((ref) => typeof ref === "string"))
-            : Object.freeze([]),
-        disposition: record.disposition,
-        ...(typeof record.blocker === "string" ? { blocker: record.blocker } : {}),
-        ...(record.quarantine === undefined ? {} : { quarantine: record.quarantine }),
-        ...(record.cleanupReceipt === undefined
-            ? {}
-            : { cleanupReceipt: record.cleanupReceipt }),
-        updatedAt: record.updatedAt
+        ...parsed,
+        owner: Object.freeze({ ...parsed.owner }),
+        activeRefs: Object.freeze([...parsed.activeRefs]),
+        ...(parsed.git === undefined ? {} : { git: Object.freeze({ ...parsed.git }) }),
+        ...(parsed.quarantine === undefined ? {} : { quarantine: Object.freeze({
+                ...parsed.quarantine,
+                ...(parsed.quarantine.gitRestore === undefined ? {} : {
+                    gitRestore: Object.freeze({ ...parsed.quarantine.gitRestore })
+                })
+            }) }),
+        ...(parsed.cleanupReceipt === undefined ? {} : { cleanupReceipt: Object.freeze({ ...parsed.cleanupReceipt }) })
     });
 }
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/resources/sqliteResourceRegistry.js

@@ -42,7 +42,7 @@ export class SqliteResourceRegistry {
         }
     }
     load() {
-        const rows = this.#db.prepare(`SELECT payload FROM ${SQLITE_RESOURCE_REGISTRY_TABLE}`).all();
+        const rows = this.#db.prepare(`SELECT id, payload FROM ${SQLITE_RESOURCE_REGISTRY_TABLE}`).all();
         if (rows.length === 0)
             return emptyResourceRegistry();
         const records = {};
@@ -52,14 +52,12 @@ export class SqliteResourceRegistry {
                 parsed = JSON.parse(row.payload);
             }
             catch (error) {
-                throw new Error(`SQLite resource registry has a corrupt payload: `
+                throw new Error(`SQLite resource registry record ${row.id} has a corrupt payload: `
                     + `${error instanceof Error ? error.message : "unknown error"}.`, { cause: error });
             }
             const state = parseResourceRegistryState({
                 schemaVersion: RESOURCE_REGISTRY_SCHEMA_VERSION,
-                records: { [typeof parsed === "object" && parsed !== null && "id" in parsed
-                        ? String(parsed.id)
-                        : ""]: parsed }
+                records: { [row.id]: parsed }
             });
             Object.assign(records, state.records);
         }

package/dist/runtime/acpSession.js

@@ -5,6 +5,7 @@ import { ACP_CONFIGURATION_ORDER, acpRunConfigurationOptions, confirmAcpConfigur
 import { handshakeObservationFrom, unknownAgentRunConfiguration } from "./agentRunConfiguration.js";
 import { JsonLineChannel, terminateProcessGroup } from "./jsonLineChannel.js";
 import { ProviderDeliveryUnknownError, ProviderTurnRejectedError } from "./providerErrors.js";
+import { providerDeliveryFailureFrom } from "./agentError.js";
 /**
  * One Agent Client Protocol Session over an Agent's stdio.
  *
@@ -86,9 +87,24 @@ export class AcpStructuredProviderSession {
         this.mirror = mirror;
     }
     static async open(input) {
-        const channel = new JsonLineChannel(input.child, input.mirror);
+        let receivingAttemptId;
+        const channel = new JsonLineChannel(input.child, input.mirror, error => {
+            // Before session/new has answered, the opening caller owns the failure.
+            if (!session.#sessionId)
+                return;
+            input.onDiagnostic?.({
+                nativeSessionId: session.#sessionId,
+                ...((receivingAttemptId ?? session.#activeAttemptId) === undefined
+                    ? {} : { attemptId: receivingAttemptId ?? session.#activeAttemptId }),
+                failure: providerDeliveryFailureFrom(error, { phase: "turn-reconcile", inputDisposition: "unknown" })
+            });
+        });
         const session = new AcpStructuredProviderSession(input.child, input.exit, input.processInstanceId, channel, input.onTerminal, input.mirror);
-        channel.onMessage((message) => session.#receive(message));
+        channel.onMessage((message) => {
+            receivingAttemptId = session.#activeAttemptId;
+            session.#receive(message);
+            receivingAttemptId = undefined;
+        });
         channel.onClose((error) => session.#fail(error));
         const negotiated = readAcpInitializeResult(await session.#request("initialize", acpInitializeRequest(input.clientVersion)));
         session.#negotiated = negotiated;
@@ -463,7 +479,7 @@ export class AcpStructuredProviderSession {
         if (message.id === undefined)
             this.#notification(method, message.params);
         else
-            void this.#serve(method, message);
+            void this.#serve(method, message).catch(error => this.#fail(error));
     }
     #response(message) {
         const id = typeof message.id === "number" ? message.id : undefined;
@@ -638,8 +654,8 @@ export class AcpStructuredProviderSession {
                 ...(error === undefined ? { result: result ?? {} } : { error })
             });
         }
-        catch {
-            // The pipe is gone; the closure path already reports that fact.
+        catch (error) {
+            this.#fail(error instanceof Error ? error : new Error(String(error)));
         }
     }
     #fail(error) {

package/dist/runtime/agentEndpoint.js

@@ -46,6 +46,7 @@ export function createAgentEndpointFactory(start = startStructuredProviderSessio
             onStarted: (value) => emit({ type: "started", value }),
             onTerminal: (value) => emit({ type: "terminal", value }),
             onInput: (value) => emit({ type: "input", value }),
+            onDiagnostic: (value) => emit({ type: "diagnostic", value }),
             onGoal: (value) => emit({ type: "goal", value })
         });
         endpoint = new BuiltinAgentEndpoint(opened.session, configuration, opened.recoveredTerminal);
@@ -193,7 +194,9 @@ class BuiltinAgentEndpoint {
         });
     }
     observe(value) {
-        if (value.type !== "goal"
+        if (value.type === "diagnostic" && value.value.nativeSessionId !== this.nativeSessionId)
+            return;
+        if (value.type !== "goal" && value.type !== "diagnostic"
             && (value.value.nativeSessionId !== this.nativeSessionId || value.value.conversationId !== this.conversationId))
             return;
         if (value.type === "goal" && value.value !== null && value.value.conversationId !== this.conversationId)