@zq-silk/yui 2.2.0 → 2.4.0

package/dist/repository/taskWorkspacePreparer.js

@@ -1,4 +1,4 @@
-import { lstat, mkdir, readdir, readlink, rm, rmdir, symlink, unlink } from "node:fs/promises";
+import { lstat, mkdir, readdir, readlink, rmdir, symlink, unlink } from "node:fs/promises";
 import { dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { isDeepStrictEqual } from "node:util";
 import { recordArchiveCleanup } from "../task/archiveDiagnostics.js";
@@ -25,7 +25,8 @@ import { NodeGitWorkspace, worktreeIdentity } from "./gitWorkspace.js";
 import { acquireProjectMaintenanceLocks, ProjectMaintenanceLockCancelledError, ProjectMaintenanceLockedError } from "./projectMaintenanceLock.js";
 import { captureTaskBaseProvenance, recordTaskBaseProvenanceEvents } from "./taskBaseFreshness.js";
 import { generateTaskWorkspaceIdentity, taskWorkspaceRefSegment, validateTaskWorkspaceIdentity } from "./taskWorkspaceIdentity.js";
-import { inspectWorkspaceCleanup } from "./workspaceCleanupInspection.js";
+import { inspectWorkspaceCleanup, inspectWorkspaceContainer } from "./workspaceCleanupInspection.js";
+import { defaultIntegrationRuntimeIsolation } from "../runtime/integrationRuntimeIsolation.js";
 const MAIN_WORKTREE = "main";
 const LEADER_ROLE = "leader";
 /**
@@ -73,7 +74,7 @@ export class FileTaskWorkspacePreparer {
         this.maintenanceLockOptions = maintenanceLockOptions;
     }
     inspectWorkspaceCleanup(workspace, disposition, forceArchive = false) {
-        return inspectWorkspaceCleanup(this.store, this.git, workspace, disposition, forceArchive);
+        return inspectWorkspaceCleanup(this.store, this.git, workspace, disposition, forceArchive, this.home);
     }
     async #assertWorkspaceCleanup(workspace, disposition) {
         const checks = await this.inspectWorkspaceCleanup(workspace, disposition);
@@ -1296,7 +1297,7 @@ export class FileTaskWorkspacePreparer {
             this.#recordArchivePathRemoval(task, entry.path, result);
             removed ||= result === "removed";
         }
-        await removeWorkspaceView(workspace.root);
+        await removeWorkspaceView(workspace.root, workspace);
         this.#resourceRegistrar().markWorkspaceDeleted(workspace);
         this.store.removeManagedWorkspace(workspace.owner);
         return removed ? "removed" : "missing";
@@ -1907,7 +1908,7 @@ export class FileTaskWorkspacePreparer {
             this.#recordArchivePathRemoval(task, entry.path, result);
             removed ||= result === "removed";
         }
-        await removeWorkspaceView(workspace.root);
+        await removeWorkspaceView(workspace.root, workspace);
         this.#resourceRegistrar().markWorkspaceDeleted(workspace);
         this.store.transaction((tx) => {
             const currentRound = tx.getReviewRound(task.id, round.id);
@@ -1976,7 +1977,7 @@ export class FileTaskWorkspacePreparer {
             this.#recordArchivePathRemoval(task, entry.path, result);
             removed ||= result === "removed";
         }
-        await removeWorkspaceView(workspace.root);
+        await removeWorkspaceView(workspace.root, workspace);
         this.#resourceRegistrar().markWorkspaceDeleted(workspace);
         try {
             this.#recordWorkspaceRemoval(task, workspace, this.#fallbackWorkspace(), {
@@ -2027,39 +2028,36 @@ export class FileTaskWorkspacePreparer {
             throw new Error(`IntegrationAttempt must be terminal before cleanup: ${attempt.id}.`);
         }
         const workspace = this.store.getIntegrationWorkspace(task.id, attempt.id);
-        // A failed Integration's explicitly disposable conflict tree retains its
-        // existing cleanup contract outside archive. Archive never discards dirt.
-        if (workspace !== null && (options.preserveChanges || task.status === "archived" || attempt.status !== "failed")) {
-            await this.#assertWorkspaceCleanup(workspace, "abandoned");
-        }
+        if (workspace === null)
+            return "missing"; // no current resource ownership to delete
+        // Terminal history does not authorize discarding conflict resolutions or
+        // diagnostics. All entry points use the same exact-owner inspection.
+        const runtime = options.runtimeIsolation ?? defaultIntegrationRuntimeIsolation(this.home, this.store.getHomeIdentity().homeId);
+        const checks = await inspectWorkspaceCleanup(this.store, this.git, workspace, "abandoned", false, this.home, runtime);
+        if (checks.length > 0)
+            throw new CleanupInspectionError(checks);
+        runtime.cleanup(runtime.preflight({ workspace, allowExactActive: true }), attempt.status === "committed" ? "completion" : "failure");
         const project = requireProject(this.store, attempt.projectId);
-        // The recorded entry pins the exact on-disk worktree path; reconstruct the
-        // owner root from it so removal targets the real Git worktree regardless of
-        // how the layout helper derives it. Absent a recorded workspace, fall back
-        // to the deterministic integration owner root + bound directory.
-        const recorded = workspace?.entries[0];
-        const directory = recorded?.directory
-            ?? task.projectBindings.find(({ projectId }) => projectId === attempt.projectId)?.directory;
-        if (directory === undefined) {
-            throw new Error(`Integration Project binding is unavailable: ${task.id}/${project.id}.`);
+        // Only the recorded entry grants resource ownership; no history-derived
+        // path reconstruction after the current resource record has been removed.
+        const recorded = workspace.entries[0];
+        if (recorded === undefined || recorded.projectId !== project.id || workspace.entries.length !== 1) {
+            throw new Error(`Integration workspace Project identity is unavailable: ${task.id}/${project.id}.`);
         }
         const result = await this.git.removeIntegrationWorktree({
             repositoryPath: this.#taskRepositoryPath(task.id, project.id),
-            container: recorded !== undefined
-                ? dirname(recorded.path)
-                : this.#integrationWorkspaceRoot(task.id, attempt.id),
-            directory,
+            container: dirname(recorded.path),
+            directory: recorded.directory,
             taskSegment: this.#taskSegment(task),
             integrationId: attempt.id,
-            discardChanges: options.preserveChanges !== true && task.status !== "archived" && attempt.status === "failed"
+            discardChanges: false
         });
         if (result !== "dirty") {
-            for (const entry of workspace?.entries ?? []) {
+            for (const entry of workspace.entries) {
                 this.#recordArchivePathRemoval(task, entry.path, result);
             }
-            if (workspace !== null)
-                this.#resourceRegistrar().markWorkspaceDeleted(workspace);
-            await rm(join(this.home, "artifacts", "integration-checks", task.id, attempt.id), { recursive: true, force: true });
+            this.#resourceRegistrar().markWorkspaceDeleted(workspace);
+            // Check logs are stable historical evidence, not worktree scratch.
             this.store.removeManagedWorkspace({
                 type: "integration-attempt",
                 taskId: task.id,
@@ -2097,15 +2095,9 @@ export class FileTaskWorkspacePreparer {
         if (main !== null) {
             await this.#assertWorkspaceCleanup(main, disposition);
             assertTaskArchiveState(requireTask(this.store, task.id), task);
-            // Scratch-only workspaces have no Git entries or Git workspace identity.
-            if (main.entries.length > 0 && await this.#inspectEntries(task.id, this.#taskSegment(task), MAIN_WORKTREE, main.entries) === "dirty") {
-                return {
-                    taskId,
-                    status: "retained-dirty",
-                    ...(task.cwd === undefined ? {} : { path: task.cwd })
-                };
-            }
-            for (const entry of main.entries) {
+            // The shared preflight and removeTaskClone both inspect clone identity.
+            // Do not re-enter linked-worktree inspection against a missing clone.
+            for (const entry of main.entries.filter(e => e.access === "write")) {
                 assertTaskArchiveState(requireTask(this.store, task.id), task);
                 const result = await this.git.removeTaskClone({
                     path: entry.path, container: main.root, directory: entry.directory,
@@ -2117,7 +2109,7 @@ export class FileTaskWorkspacePreparer {
                 this.#recordArchivePathRemoval(task, entry.path, result);
             }
             assertTaskArchiveState(requireTask(this.store, task.id), task);
-            await removeWorkspaceView(main.root);
+            await removeWorkspaceView(main.root, main);
             this.#resourceRegistrar().markWorkspaceDeleted(main);
             assertTaskArchiveState(requireTask(this.store, task.id), task);
             this.#recordWorkspaceRemoval(task, main, this.#fallbackWorkspace());
@@ -2175,9 +2167,6 @@ export class FileTaskWorkspacePreparer {
     #reviewRoundWorkspaceRoot(taskId, round) {
         return join(resolveTaskRoot(this.home), safePathSegment(taskId), "reviews", safePathSegment(this.#reviewWorktreeName(round)));
     }
-    #integrationWorkspaceRoot(taskId, integrationId) {
-        return integrationWorkspaceRoot(this.home, taskId, integrationId);
-    }
     #reviewWorktreeName(round) {
         return round.scope === "task"
             ? `reviewer-${round.reviewerRoleName}`
@@ -2570,7 +2559,12 @@ async function ensureWorkspaceView(root, entries) {
         await symlink(target, join(root, directory), "dir");
     }
 }
-async function removeWorkspaceView(root) {
+async function removeWorkspaceView(root, workspace) {
+    if (workspace !== undefined) {
+        const checks = await inspectWorkspaceContainer(workspace);
+        if (checks.length > 0)
+            throw new CleanupInspectionError(checks);
+    }
     let entries;
     try {
         entries = await readdir(root, { withFileTypes: true });
@@ -2584,6 +2578,8 @@ async function removeWorkspaceView(root) {
         if (!entry.isSymbolicLink()) {
             throw new Error(`Managed workspace contains an unexpected entry: ${join(root, entry.name)}.`);
         }
+    }
+    for (const entry of entries) {
         await unlink(join(root, entry.name));
     }
     await rmdir(root);

package/dist/repository/workspaceCleanupInspection.js

@@ -1,15 +1,19 @@
-import { dirname, isAbsolute, join, relative } from "node:path";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { isDeepStrictEqual } from "node:util";
+import { lstat, readdir, readlink } from "node:fs/promises";
 import { projectTaskRemoteDeliveryFromStore } from "../task/remoteDeliveryService.js";
 import { cleanupCheckFromError } from "../workspace/cleanupInspection.js";
 import { WorkItemChangeSetManager } from "../workspace/workItemChangeSetManager.js";
 import { managedWorkspaceKey, managedWorktreeName } from "../worktree/managedWorkspace.js";
 import { integrationWorktreeIdentity, worktreeIdentity } from "./gitWorkspace.js";
 import { taskWorkspaceRefSegment } from "./taskWorkspaceIdentity.js";
+import { jobCleanupBlocker } from "../job/jobCleanupInspection.js";
+import { defaultIntegrationRuntimeIsolation } from "../runtime/integrationRuntimeIsolation.js";
+import { inspectTaskRuntimeCleanup } from "../runtime/taskRuntimeIsolation.js";
 /** Current owner facts + the same Git inspection used immediately before removal.
  * No preparation, locks, Git refresh, runtime stop, DB writes or repair.
  */
-export async function inspectWorkspaceCleanup(store, git, workspace, disposition, forceArchive = false) {
+export async function inspectWorkspaceCleanup(store, git, workspace, disposition, forceArchive = false, home, integrationRuntime) {
     const owner = workspace.owner;
     const task = store.getTask(owner.taskId);
     if (task === null)
@@ -23,6 +27,18 @@ export async function inspectWorkspaceCleanup(store, git, workspace, disposition
         add("workspace-identity-mismatch", "Current workspace ownership differs from the inspected record.", "same managed workspace", "changed or missing");
         return checks;
     }
+    // Job admission supports these three exact managed owners. Apply the same
+    // physical check before every supported owner's cleanup, not only Integration.
+    for (const job of store.listDurableJobs(task.id).filter(job => (owner.type === "task" && job.owner.kind === "task")
+        || (owner.type === "work-item" && job.owner.kind === "work-item"
+            && job.owner.workItemId === owner.workItemId)
+        || (owner.type === "integration-attempt" && job.owner.kind === "integration-attempt"
+            && job.owner.integrationAttemptId === owner.integrationAttemptId))) {
+        const blocker = jobCleanupBlocker(job, home);
+        if (blocker !== undefined)
+            add("unresolved-execution", blocker, "settled execution", { jobId: job.id, status: job.status });
+    }
+    checks.push(...await inspectWorkspaceContainer(workspace));
     if (task.workspaceIdentity === undefined && workspace.entries.some(e => e.access === "write")) {
         add("workspace-metadata-missing", "Task has no durable workspace identity; do not infer one from paths.", "recorded Task workspace identity", null);
         return checks;
@@ -68,9 +84,24 @@ export async function inspectWorkspaceCleanup(store, git, workspace, disposition
         }
         case "integration-attempt": {
             const attempt = store.getIntegrationAttempt(task.id, owner.integrationAttemptId);
+            const entry = workspace.entries[0];
+            if (workspace.entries.length !== 1 || entry?.access !== "write"
+                || entry.projectId !== attempt?.projectId || entry.path !== workspace.root) {
+                add("workspace-identity-mismatch", "Integration resource does not match its single recorded Project worktree.", "one writable Project at the Integration root", "different or missing entry");
+                return checks;
+            }
             if (attempt === null || ["running", "blocked", "conflicted", "validating"].includes(attempt.status)) {
                 add("owner-unsettled", "IntegrationAttempt must be terminal before cleanup.", "terminal attempt", attempt?.status ?? null);
             }
+            try {
+                if (home === undefined)
+                    throw new Error("Runtime Home unavailable.");
+                const runtime = integrationRuntime ?? defaultIntegrationRuntimeIsolation(home, store.getHomeIdentity().homeId);
+                inspectTaskRuntimeCleanup(runtime.preflight({ workspace, allowExactActive: true }), attempt?.status === "committed" ? "completion" : "failure");
+            }
+            catch {
+                add("runtime-resource-unverified", "Integration runtime ownership or physical quiescence cannot be verified.", "exactly owned inactive runtime and cleanup claims", "unverified");
+            }
             break;
         }
         case "task":
@@ -79,9 +110,9 @@ export async function inspectWorkspaceCleanup(store, git, workspace, disposition
             }
             break;
     }
-    const delivery = owner.type === "task" && (disposition === "integrated" || task.status === "archived" || forceArchive)
+    const delivery = owner.type === "task"
         ? await readArchiveDelivery(store, git, task, forceArchive) : undefined;
-    if (delivery !== undefined && (!delivery.allMerged || !delivery.allVerified)) {
+    if (disposition === "integrated" && delivery !== undefined && (!delivery.allMerged || !delivery.allVerified)) {
         add("delivery-coverage", "Task main has commits without verified remote coverage; cleanup does not establish delivery.", { allMerged: true, allVerified: true }, { allMerged: delivery.allMerged, allVerified: delivery.allVerified });
     }
     for (const entry of workspace.entries.filter(e => e.access === "write")) {
@@ -116,14 +147,20 @@ export async function inspectWorkspaceCleanup(store, git, workspace, disposition
                     ? await git.inspectTaskClone({ path: entry.path, container: workspace.root, directory: entry.directory,
                         taskSegment, branch: entry.branch })
                     : await git.inspectWorktree({ repositoryPath: main.path, container, directory: entry.directory,
-                        taskSegment, roleName, expectedBranch });
+                        taskSegment, roleName,
+                        ...(owner.type === "integration-attempt" ? { expectedBranch } : {}) });
                 if (state === "dirty")
                     check("dirty-worktree", "Uncommitted or untracked changes must be preserved.", "clean", "dirty");
                 if (owner.type === "task" && state !== "missing" && delivery !== undefined) {
                     const covered = delivery.projects.find(p => p.projectId === entry.projectId);
                     const expected = covered?.expectedLocalCommit;
                     const observed = (await git.inspect(entry.path, "HEAD")).baseCommit;
-                    if (expected != null && expected !== observed && covered?.deliveryLocalCommit !== observed) {
+                    const baseline = task.projectBindings.find(binding => binding.projectId === entry.projectId)?.baseCommit;
+                    const unchangedAbandonment = disposition === "abandoned" && baseline !== undefined && observed === baseline;
+                    if (!unchangedAbandonment && disposition === "abandoned" && (!covered?.merged || !covered.verified)) {
+                        check("delivery-coverage", "Abandonment does not discard unverified local commits; only the exact unchanged baseline is disposable.", { baseline: baseline ?? null, verifiedDelivery: true }, observed);
+                    }
+                    else if (!unchangedAbandonment && expected != null && expected !== observed && covered?.deliveryLocalCommit !== observed) {
                         check("head-mismatch", "Task main HEAD differs from the accepted head and its covered publication candidate.", { acceptedCommit: expected, deliveryLocalCommit: covered?.deliveryLocalCommit ?? null }, observed);
                     }
                 }
@@ -136,6 +173,49 @@ export async function inspectWorkspaceCleanup(store, git, workspace, disposition
     }
     return checks;
 }
+/** Inspect the complete logical container before removing any Project. Files
+ * and unrecognized links are evidence, not disposable workspace scaffolding.
+ */
+export async function inspectWorkspaceContainer(workspace) {
+    if (workspace.owner.type === "integration-attempt")
+        return []; // root is the Git worktree itself
+    const resource = managedWorkspaceKey(workspace.owner);
+    const sources = [resource];
+    const actions = workspaceCleanupActions(workspace);
+    try {
+        const root = await lstat(workspace.root).catch(error => {
+            if (error.code === "ENOENT")
+                return null;
+            throw error;
+        });
+        if (root === null)
+            return [];
+        if (!root.isDirectory() || root.isSymbolicLink())
+            return [{
+                    resource, reason: "workspace-identity-mismatch", status: "blocked",
+                    detail: "Logical workspace container is not an owned directory.",
+                    expected: "directory", observed: "different filesystem type", sources, actions
+                }];
+        const unexpected = [];
+        for (const entry of await readdir(workspace.root, { withFileTypes: true })) {
+            const owned = workspace.entries.find(e => e.directory === entry.name);
+            const allowed = owned !== undefined && (owned.access === "write"
+                ? entry.isDirectory() && !entry.isSymbolicLink()
+                : entry.isSymbolicLink() && resolve(workspace.root, await readlink(join(workspace.root, entry.name))) === resolve(owned.path));
+            if (!allowed)
+                unexpected.push(entry.name);
+        }
+        return unexpected.length === 0 ? [] : [{
+                resource, reason: "workspace-material-retained", status: "blocked",
+                detail: "Logical container contains material outside its registered Project entries; no Project removal was started.",
+                expected: "only registered Project directories/links", observed: unexpected,
+                sources, actions
+            }];
+    }
+    catch (error) {
+        return cleanupCheckFromError(error, resource, sources, actions);
+    }
+}
 /** Reuse Publication's projection, supplying live heads only where its existing
  * contract asks for them (active/cancelled). Completed/archived heads stay frozen.
  * Never prepare a workspace or substitute an old binding's commit for a failed read.
@@ -166,7 +246,8 @@ export async function readArchiveDelivery(store, git, task, forceArchive = false
 export function workspaceCleanupActions(workspace) {
     const owner = workspace.owner;
     switch (owner.type) {
-        case "task": return [`yui task remote-delivery ${owner.taskId}`, `yui task show ${owner.taskId}`];
+        case "task": return [`yui task remote-delivery ${owner.taskId}`, `yui task show ${owner.taskId}`,
+            `yui task archive-cleanup ${owner.taskId}`];
         case "work-item": return [`yui task work show ${owner.taskId}/${owner.workItemId}`,
             `yui task work cleanup ${owner.taskId}/${owner.workItemId} --integrated|--abandon`];
         case "review-round": return [`yui task work review show ${owner.taskId}/${owner.reviewRoundId}`,

package/dist/resources/resourceDiscovery.js

@@ -10,6 +10,7 @@ import { execFile } from "node:child_process";
 import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 import { basename, join, resolve } from "node:path";
 import { promisify } from "node:util";
+import { readGitWorktrees } from "../repository/gitWorktreeInventory.js";
 import { managedProjectPath } from "../repository/project.js";
 import { managedRuntimeRoot } from "../storage/homeLayout.js";
 import { isResourceQuarantinePath } from "./resourceRegistry.js";
@@ -54,8 +55,7 @@ export function parseGitWorktreePorcelain(output) {
 }
 async function listGitWorktrees(repositoryPath) {
     try {
-        const { stdout } = await executeFile("git", ["-C", repositoryPath, "worktree", "list", "--porcelain"], { timeout: 10_000 });
-        return parseGitWorktreePorcelain(stdout);
+        return await readGitWorktrees(repositoryPath);
     }
     catch (error) {
         throw new Error(`Failed to list Git worktrees for ${repositoryPath}: `

package/dist/resources/resourceGc.js

@@ -16,6 +16,7 @@
  * - `restoreAllResourceGc` is the explicit rollback entry point.
  */
 import { execFileSync } from "node:child_process";
+import { supportedGit } from "../repository/gitCompatibility.js";
 import { existsSync, mkdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, join, resolve, relative, isAbsolute } from "node:path";
 import { isDeepStrictEqual } from "node:util";
@@ -384,13 +385,14 @@ function quarantineResource(home, record, now) {
     const receiptPath = `${quarantinePath}.receipt.json`;
     try {
         if (isGitWorktreePath(record.path)) {
+            const program = supportedGit();
             // Move the linked worktree, including its exact checkout and Git
             // metadata, into the Home-local quarantine. Restore is the inverse
             // move, so the recorded HEAD cannot drift with a branch.
             mkdirSync(quarantineRoot, { recursive: true, mode: 0o700 });
             // Keep the existing SQLite writer fence through this bounded move, so a
             // Task reopen or new durable owner cannot commit between check and move.
-            execFileSync("git", ["-C", record.path, "worktree", "move", "--", record.path, quarantinePath], { timeout: 30_000 });
+            execFileSync(program.path, ["-C", record.path, "worktree", "move", "--", record.path, quarantinePath], { timeout: 30_000 });
             writeQuarantineReceipt(home, record, now, "move", receiptPath);
             return {
                 ok: true,
@@ -496,9 +498,10 @@ function restoreQuarantinedRecord(record, liveRefs, now) {
                 updatedAt: now.toISOString()
             };
         }
+        const program = isGitWorktreePath(quarantine.path) ? supportedGit() : undefined;
         mkdirSync(dirname(quarantine.originalPath), { recursive: true });
-        if (isGitWorktreePath(quarantine.path)) {
-            execFileSync("git", ["-C", quarantine.path, "worktree", "move", "--", quarantine.path, quarantine.originalPath], { timeout: 30_000 });
+        if (program !== undefined) {
+            execFileSync(program.path, ["-C", quarantine.path, "worktree", "move", "--", quarantine.path, quarantine.originalPath], { timeout: 30_000 });
         }
         else {
             renameSync(quarantine.path, quarantine.originalPath);
@@ -604,7 +607,7 @@ export async function purgeResourceQuarantine(home, options, store) {
             try {
                 if (existsSync(quarantine.path)) {
                     if (isGitWorktreePath(quarantine.path)) {
-                        execFileSync("git", ["-C", quarantine.path, "worktree", "remove", "--force", "--", quarantine.path], { timeout: 30_000 });
+                        execFileSync(supportedGit().path, ["-C", quarantine.path, "worktree", "remove", "--force", "--", quarantine.path], { timeout: 30_000 });
                     }
                     rmSync(quarantine.path, { recursive: true, force: true });
                 }

package/dist/resources/resourceRegistrar.js

@@ -9,6 +9,7 @@
 import { execFileSync } from "node:child_process";
 import { existsSync } from "node:fs";
 import { basename, dirname, resolve } from "node:path";
+import { gitOutputLine, supportedGit } from "../repository/gitCompatibility.js";
 import { upsertResourceRecord } from "./resourceRegistry.js";
 import { createResourceRegistryStore } from "./resourceRegistryStore.js";
 import { createResourceRecord, isReleaseNamespacePath, resourceId } from "./resourceTypes.js";
@@ -100,15 +101,17 @@ export class ResourceRegistrar {
             })]);
     }
     markWorkspaceDeleted(workspace) {
-        try {
-            this.markPathsDeleted([
-                workspace.root,
-                ...workspace.entries.map((entry) => entry.path)
-            ]);
-        }
-        catch {
-            // Best-effort receipt; workspace deletion must proceed regardless.
-        }
+        // Callers remove the managed owner only after this succeeds. Losing the
+        // receipt must retain that exact owner so a missing-path retry can finish.
+        this.#markPathsDeleted([
+            workspace.root,
+            ...workspace.entries.filter(entry => entry.access === "write").map(entry => entry.path)
+        ], ownerFromManagedWorkspace(this.#home, workspace.owner));
+    }
+    markTaskRuntimeDeleted(descriptor) {
+        // The validated descriptor and matching registry owner survive deletion.
+        // A missing-root retry may settle this receipt, never a different owner.
+        this.#markPathsDeleted(Object.values(descriptor.roots), ownerFromManagedWorkspace(this.#home, descriptor.workspace.owner));
     }
     markPathsDeleted(paths) {
         try {
@@ -118,7 +121,7 @@ export class ResourceRegistrar {
             // Best-effort receipt; path deletion must proceed regardless.
         }
     }
-    #markPathsDeleted(paths) {
+    #markPathsDeleted(paths, owner) {
         const targets = new Set(paths.map((path) => resolve(path)));
         const store = createResourceRegistryStore(this.#home);
         try {
@@ -128,6 +131,10 @@ export class ResourceRegistrar {
             for (const record of Object.values(state.records)) {
                 if (!targets.has(record.path) || record.disposition === "deleted")
                     continue;
+                if (owner !== undefined && ["home", "taskId", "workItemId", "reviewRoundId", "integrationAttemptId"]
+                    .some(key => record.owner[key] !== owner[key])) {
+                    throw new Error("Resource registration owner changed; deletion receipt retained for inspection.");
+                }
                 next = upsertResourceRecord(next, {
                     ...record,
                     activeRefs: Object.freeze([]),
@@ -206,7 +213,7 @@ function ownerFromManagedWorkspace(home, owner, projectId) {
     };
 }
 function readGitWorktreeMetadata(path) {
-    const commonDir = execFileSync("git", ["-C", path, "rev-parse", "--path-format=absolute", "--git-common-dir"], { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    const commonDir = resolve(path, gitOutputLine(execFileSync(supportedGit().path, ["-C", path, "rev-parse", "--git-common-dir"], { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] })));
     const repositoryPath = basename(commonDir) === ".git" ? dirname(commonDir) : commonDir;
     let branch;
     try {

package/dist/runtime/agentEndpoint.js

@@ -41,6 +41,12 @@ export function createAgentEndpointFactory(start = startStructuredProviderSessio
                 endpoint.observe(event);
         };
         const opened = await start(payload, {
+            // The native TUI owns rendering while attached. Raw JSON mirroring into
+            // its inherited PTY would corrupt its screen on every Provider event.
+            mirrorOutput: (stream, text) => {
+                if (!endpoint?.nativeAccess?.attached)
+                    (stream === "stdout" ? process.stdout : process.stderr).write(text);
+            },
             onAccepted: (value) => emit({ type: "accepted", value }),
             onActivity: (value) => emit({ type: "activity", value }),
             onStarted: (value) => emit({ type: "started", value }),
@@ -74,6 +80,7 @@ function freezeConfiguration(value) {
 class BuiltinAgentEndpoint {
     driver;
     configuration;
+    get nativeAccess() { return this.driver.nativeAccess; }
     get ownedProcessId() { return this.driver.ownedProcessId; }
     get nativeAccountHome() { return this.driver.nativeAccountHome; }
     capabilities;
@@ -118,6 +125,7 @@ class BuiltinAgentEndpoint {
     get nativeSessionId() { return this.driver.nativeSessionId; }
     get conversationId() { return this.driver.conversationId; }
     get processInstanceId() { return this.driver.processInstanceId; }
+    get publicReply() { return this.driver.publicReply; }
     /**
      * Delegated rather than copied at construction: the Session reads its own
      * current state, and a value captured here would freeze the configuration as