@zq-silk/yui 2.2.0 → 2.4.0

package/dist/repository/project.js

@@ -63,13 +63,17 @@ export function assertProjectActive(project, action) {
         throw new Error(`Project is retired and cannot ${action}: ${project.id}.`);
     }
 }
-export function addProjectKnowledge(project, id, title, body, now, provenance) {
+export function addProjectKnowledge(project, id, title, body, now, provenance, applicability = {}) {
     const timestamp = now.toISOString();
     const knowledge = {
-        schemaVersion: 1,
+        schemaVersion: 2,
+        version: 1,
+        history: [],
         id: requireIdentity(id, "Project knowledge id"),
         title: requireText(title, "Project knowledge title"),
         body: requireText(body, "Project knowledge body"),
+        ...(applicability.scope === undefined ? {} : { scope: requireText(applicability.scope, "Knowledge scope") }),
+        ...(applicability.expiresWhen === undefined ? {} : { expiresWhen: requireText(applicability.expiresWhen, "Knowledge expiry condition") }),
         status: "active",
         ...(provenance === undefined ? {} : { provenance: validateKnowledgeProvenance(provenance) }),
         createdAt: timestamp,
@@ -114,19 +118,34 @@ export function updateProjectKnowledge(project, id, patch, now) {
         if (entry.status === "retired") {
             throw new Error(`Project knowledge is retired: ${knowledgeId}.`);
         }
-        return {
-            ...entry,
+        const { scope: _scope, expiresWhen: _expiresWhen, ...base } = entry;
+        const scope = patch.scope === undefined ? entry.scope
+            : patch.scope === null ? undefined : requireText(patch.scope, "Knowledge scope");
+        const expiresWhen = patch.expiresWhen === undefined ? entry.expiresWhen
+            : patch.expiresWhen === null ? undefined : requireText(patch.expiresWhen, "Knowledge expiry condition");
+        const next = {
+            ...base,
+            ...(scope === undefined ? {} : { scope }),
+            ...(expiresWhen === undefined ? {} : { expiresWhen }),
             title: patch.title === undefined
                 ? entry.title
                 : requireText(patch.title, "Project knowledge title"),
             body: patch.body === undefined
                 ? entry.body
                 : requireText(patch.body, "Project knowledge body"),
+            ...(patch.provenance === undefined ? {} : { provenance: validateKnowledgeProvenance(patch.provenance) }),
             updatedAt: now.toISOString()
         };
+        if (next.title === entry.title && next.body === entry.body
+            && next.scope === entry.scope && next.expiresWhen === entry.expiresWhen
+            && JSON.stringify(next.provenance) === JSON.stringify(entry.provenance))
+            return entry;
+        return { ...next, version: entry.version + 1, history: [...entry.history, knowledgeRevision(entry)] };
     });
     if (!found)
         throw new Error(`Project knowledge not found: ${knowledgeId}.`);
+    if (knowledge.every((entry, index) => entry === project.knowledge[index]))
+        return project;
     return validateProject({ ...project, knowledge, updatedAt: now.toISOString() });
 }
 export function retireProjectKnowledge(project, id, now) {
@@ -136,31 +155,42 @@ export function retireProjectKnowledge(project, id, now) {
         if (entry.id !== knowledgeId)
             return entry;
         found = true;
+        if (entry.status === "retired")
+            return entry;
         return {
             ...entry,
+            version: entry.version + 1,
+            history: [...entry.history, knowledgeRevision(entry)],
             status: "retired",
             updatedAt: now.toISOString()
         };
     });
     if (!found)
         throw new Error(`Project knowledge not found: ${knowledgeId}.`);
+    if (knowledge.every((entry, index) => entry === project.knowledge[index]))
+        return project;
     return validateProject({ ...project, knowledge, updatedAt: now.toISOString() });
 }
+function knowledgeRevision(entry) {
+    const { schemaVersion: _schema, id: _id, history: _history, createdAt: _created, ...revision } = entry;
+    return revision;
+}
 /**
  * Stable dedup fingerprint for a promotion candidate. Two proposals with the
- * same source identity, title, and body are the same conclusion regardless of
- * who proposed them or when.
+ * same source, content, applicability and replacement intent are identical.
+ * Trim outer whitespace only; preserve case, internal whitespace and Unicode.
+ * A JSON tuple avoids collisions between user-supplied identity delimiters.
  */
 export function knowledgeProposalFingerprint(input) {
-    const sourceKey = [
-        input.projectId,
-        input.source.taskId,
-        input.source.decisionId ?? "",
-        input.source.milestoneId ?? "",
-        input.source.commitSha ?? ""
-    ].join("|");
+    const optional = (value) => value === undefined ? null : requireText(value, "Knowledge fingerprint field");
     return createHash("sha256")
-        .update(`${sourceKey}\u0000${input.title}\u0000${input.body}`)
+        .update(JSON.stringify([
+        "knowledge-proposal-v2", requireText(input.projectId, "Project id"),
+        requireText(input.source.taskId, "Source Task"), optional(input.source.decisionId),
+        optional(input.source.milestoneId), optional(input.source.commitSha),
+        requireText(input.title, "Knowledge title"), requireText(input.body, "Knowledge body"),
+        optional(input.scope), optional(input.expiresWhen), optional(input.supersedesKnowledgeId)
+    ]))
         .digest("hex");
 }
 /** Digest of the cited source evidence, so a later Agent can verify it. */
@@ -334,17 +364,18 @@ export function validateProject(project) {
     requireGitRef(project.developmentBranch, "Project development branch");
     const knowledgeIds = new Set();
     for (const entry of project.knowledge) {
-        if (entry.schemaVersion !== 1)
-            throw new Error("Project knowledge must use schemaVersion 1.");
+        if (entry.schemaVersion !== 2)
+            throw new Error("Project knowledge must use schemaVersion 2.");
         requireIdentity(entry.id, "Project knowledge id");
-        requireText(entry.title, "Project knowledge title");
-        requireText(entry.body, "Project knowledge body");
-        if (!["active", "retired"].includes(entry.status)) {
-            throw new Error("Project knowledge status is invalid.");
-        }
-        if (entry.provenance !== undefined) {
-            validateKnowledgeProvenance(entry.provenance);
+        validateKnowledgeRevision(entry);
+        if (!Array.isArray(entry.history) || entry.history.length !== entry.version - 1) {
+            throw new Error("Project knowledge history must contain every prior version.");
         }
+        entry.history.forEach((revision, index) => {
+            validateKnowledgeRevision(revision);
+            if (revision.version !== index + 1)
+                throw new Error("Project knowledge history is out of order.");
+        });
         requireTimestamp(entry.createdAt, "Project knowledge createdAt");
         requireTimestamp(entry.updatedAt, "Project knowledge updatedAt");
         if (knowledgeIds.has(entry.id))
@@ -363,6 +394,21 @@ export function validateProject(project) {
     requireTimestamp(project.updatedAt, "Project updatedAt");
     return project;
 }
+function validateKnowledgeRevision(entry) {
+    if (!Number.isSafeInteger(entry.version) || entry.version < 1)
+        throw new Error("Invalid knowledge version.");
+    requireText(entry.title, "Project knowledge title");
+    requireText(entry.body, "Project knowledge body");
+    if (entry.scope !== undefined)
+        requireText(entry.scope, "Knowledge scope");
+    if (entry.expiresWhen !== undefined)
+        requireText(entry.expiresWhen, "Knowledge expiry condition");
+    if (!["active", "retired"].includes(entry.status))
+        throw new Error("Project knowledge status is invalid.");
+    if (entry.provenance !== undefined)
+        validateKnowledgeProvenance(entry.provenance);
+    requireTimestamp(entry.updatedAt, "Project knowledge updatedAt");
+}
 function validateKnowledgeProvenance(provenance) {
     requireIdentity(provenance.taskId, "Knowledge provenance task id");
     if (provenance.decisionId !== undefined) {
@@ -394,8 +440,8 @@ function validateKnowledgeProvenance(provenance) {
     return provenance;
 }
 function validateKnowledgeProposal(proposal, projectId) {
-    if (proposal.schemaVersion !== 1) {
-        throw new Error("Knowledge proposal must use schemaVersion 1.");
+    if (proposal.schemaVersion !== 2) {
+        throw new Error("Knowledge proposal must use schemaVersion 2.");
     }
     requireIdentity(proposal.id, "Knowledge proposal id");
     if (proposal.projectId !== projectId) {
@@ -403,6 +449,9 @@ function validateKnowledgeProposal(proposal, projectId) {
     }
     requireText(proposal.title, "Knowledge proposal title");
     requireText(proposal.body, "Knowledge proposal body");
+    if (proposal.fingerprint !== knowledgeProposalFingerprint(proposal)) {
+        throw new Error("Knowledge proposal fingerprint does not match its content.");
+    }
     if (!["pending", "accepted", "rejected"].includes(proposal.status)) {
         throw new Error("Knowledge proposal status is invalid.");
     }

package/dist/repository/taskWorkspaceCoordinator.js

@@ -1,10 +1,10 @@
-import { lstat } from "node:fs/promises";
 import { isDeepStrictEqual } from "node:util";
 import { isArchivePersistenceFailure, recordArchiveCleanup } from "../task/archiveDiagnostics.js";
 import { archiveExecutionChecks, archiveSettlementChecks } from "../task/archivePreflight.js";
-import { projectTaskRemoteDeliveryFromStore } from "../task/remoteDeliveryService.js";
 import { CleanupInspectionError } from "../workspace/cleanupInspection.js";
 import { WorkItemChangeSetManager } from "../workspace/workItemChangeSetManager.js";
+import { withResourceRegistry } from "../resources/resourceRegistryStore.js";
+import { jobCleanupBlocker } from "../job/jobCleanupInspection.js";
 import { hasRuntimeLifecycleWork, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
 import { managedWorkspaceKey } from "../worktree/managedWorkspace.js";
 import { acquireProjectMaintenanceLocks } from "./projectMaintenanceLock.js";
@@ -97,8 +97,9 @@ export class TaskWorkspaceCoordinator {
             if (state === "dirty")
                 return "dirty";
             this.#assertWorkItemRuntimeQuiescent(item);
-            this.#assertNoActiveWorkItemDurableJobs(item);
+            this.#assertNoActiveWorkItemDurableJobs(item, "before-role-stop");
             await this.#stopLiveRoles(item.taskId, this.#workItemRoleNames(item));
+            this.#assertNoActiveWorkItemDurableJobs(item);
             const laneCleanup = await this.preparer.cleanupExecutionLaneWorkspacesForWorkItem(item.taskId, item.id);
             if (laneCleanup === "dirty")
                 return "dirty";
@@ -162,30 +163,32 @@ export class TaskWorkspaceCoordinator {
             releaseMaintenance();
         }
     }
-    async cleanupTaskForArchive(taskId, disposition) {
-        let releaseMaintenance;
+    /** Business/runtime admission only. Physical workspaces may safely remain;
+     * their removal uses the same foreground cleanup after ordinary or force archive.
+     */
+    async prepareTaskForArchive(taskId) {
+        const task = this.store.getTask(taskId);
+        if (task === null)
+            throw new Error(`Task not found: ${taskId}.`);
+        if (task.status !== "completed" && task.status !== "cancelled") {
+            throw new Error(`Task must be completed or retired before archive: ${task.id}.`);
+        }
+        const settlement = [...archiveSettlementChecks(this.store, task),
+            ...archiveExecutionChecks(this.store, taskId, this.preparer.home, "before-role-stop")];
+        if (settlement.length > 0)
+            throw new CleanupInspectionError(settlement);
+        const managedWorkspaces = [...this.store.listManagedWorkspaces(task.id)]
+            .sort((left, right) => managedWorkspaceKey(left.owner)
+            .localeCompare(managedWorkspaceKey(right.owner)));
+        // Fence Project preparation while stopping exact Task runtimes; do not
+        // mutate Project paths until after the independent archive commit.
+        const projectIds = new Set(task.projectBindings.map(({ projectId }) => projectId));
+        for (const workspace of managedWorkspaces) {
+            for (const entry of workspace.entries)
+                projectIds.add(entry.projectId);
+        }
+        const releaseMaintenance = await acquireProjectMaintenanceLocks(this.preparer.home, projectIds);
         try {
-            const task = this.store.getTask(taskId);
-            if (task === null)
-                throw new Error(`Task not found: ${taskId}.`);
-            if (task.status !== "completed" && task.status !== "cancelled") {
-                throw new Error(`Task must be completed or retired before archive cleanup: ${task.id}.`);
-            }
-            const settlement = [...archiveSettlementChecks(this.store, task), ...archiveExecutionChecks(this.store, taskId)];
-            if (settlement.length > 0)
-                throw new CleanupInspectionError(settlement);
-            const managedWorkspaces = [...this.store.listManagedWorkspaces(task.id)]
-                .sort((left, right) => managedWorkspaceKey(left.owner)
-                .localeCompare(managedWorkspaceKey(right.owner)));
-            // Archive cleanup removes worktrees from every Project the Task uses:
-            // hold each Project's maintenance fence so the Controller defers
-            // preparation and no Project maintenance or Task archive interleaves.
-            const projectIds = new Set(task.projectBindings.map(({ projectId }) => projectId));
-            for (const workspace of managedWorkspaces) {
-                for (const entry of workspace.entries)
-                    projectIds.add(entry.projectId);
-            }
-            releaseMaintenance = await acquireProjectMaintenanceLocks(this.preparer.home, projectIds);
             this.#assertTaskArchiveLifecycle(task);
             const currentWorkspaces = [...this.store.listManagedWorkspaces(task.id)]
                 .sort((left, right) => managedWorkspaceKey(left.owner)
@@ -193,111 +196,43 @@ export class TaskWorkspaceCoordinator {
             if (!isDeepStrictEqual(currentWorkspaces, managedWorkspaces)) {
                 throw new Error(`Task workspaces changed while waiting for archive cleanup: ${taskId}.`);
             }
-            const laneWorkspaces = managedWorkspaces.filter(({ owner }) => owner.type === "execution-lane");
-            const integrationWorkspaces = managedWorkspaces.filter(({ owner }) => owner.type === "integration-attempt");
-            const workspaces = managedWorkspaces
-                .filter(({ owner }) => owner.type === "work-item");
-            const workItems = workspaces.map((workspace) => {
-                const workItemId = workspace.owner.type === "work-item"
-                    ? workspace.owner.workItemId
-                    : "";
-                const item = this.store.getWorkItem(task.id, workItemId);
-                if (item === null)
-                    throw new Error(`Work item not found: ${task.id}/${workItemId}.`);
-                if (item.status !== "accepted" && item.status !== "retired") {
-                    throw new Error(`Work item must be completed or retired before archive cleanup: ${item.id}.`);
-                }
-                return item;
-            });
             const allWorkItems = [...this.store.listWorkItems(task.id)]
                 .sort((left, right) => left.id.localeCompare(right.id));
             const allReviewRounds = [...this.store.listReviewRounds(task.id)]
                 .sort((left, right) => left.id.localeCompare(right.id));
-            const reviewRounds = allReviewRounds.filter((round) => (round.workspace !== undefined && round.workspaceDisposition?.kind !== "removed"));
             const snapshot = {
                 task,
                 managedWorkspaces,
                 workItems: allWorkItems,
                 reviewRounds: allReviewRounds
             };
-            const checks = [];
-            for (const workspace of managedWorkspaces) {
-                const workspaceDisposition = workspace.owner.type === "work-item"
-                    && this.store.getWorkItem(task.id, workspace.owner.workItemId)?.status === "retired" ? "abandoned" : disposition;
-                const inspected = await this.preparer.inspectWorkspaceCleanup(workspace, workspaceDisposition);
-                // Child worktrees are removed first below. Their Git registrations
-                // necessarily exist now; the clone's removal boundary rechecks them
-                // after every child cleanup and never removes an unresolved owner.
-                checks.push(...inspected.filter(c => !(workspace.owner.type === "task"
-                    && c.reason === "git-worktree-registrations")));
-            }
-            if (checks.length > 0)
-                throw new CleanupInspectionError(checks);
             const roleNames = this.store.listRoles(taskId).map(({ name }) => name);
             await this.#stopLiveRoles(taskId, roleNames);
             await this.runtime.releaseTaskTerminals(task.id);
-            this.#assertTaskArchiveSnapshot(snapshot);
-            for (const workspace of laneWorkspaces) {
-                this.#assertTaskArchiveLifecycle(task);
-                if (workspace.owner.type === "execution-lane") {
-                    await this.preparer.cleanupExecutionLaneWorkspace(task.id, workspace.owner.executionGroupId, workspace.owner.executionLaneId);
-                }
-            }
-            for (const workspace of integrationWorkspaces) {
-                this.#assertTaskArchiveLifecycle(task);
-                if (workspace.owner.type === "integration-attempt") {
-                    await this.preparer.cleanupIntegrationWorkspace(task.id, workspace.owner.integrationAttemptId, { preserveChanges: true });
-                }
-            }
-            for (const round of reviewRounds) {
-                this.#assertTaskArchiveLifecycle(task);
-                await this.preparer.cleanupReviewRoundWorkspace(task.id, round.id);
+            if (this.runtime.assertTaskPhysicalResourcesReleased === undefined) {
+                throw new Error("Archive requires exact physical runtime inspection.");
             }
-            for (const item of workItems) {
-                this.#assertTaskArchiveLifecycle(task);
-                await this.preparer.cleanupWorkItemWorkspace(task.id, item.id, item.status === "accepted" ? disposition : "abandoned");
-            }
-            this.#assertTaskArchiveLifecycle(task);
-            return await this.preparer.cleanupTaskForArchive(taskId, disposition);
-        }
-        catch (error) {
-            const task = this.store.getTask(taskId);
-            return {
-                taskId,
-                status: error instanceof CleanupInspectionError && error.checks.every(c => c.reason === "dirty-worktree")
-                    ? "retained-dirty" : "failed",
-                ...(task?.cwd === undefined ? {} : { path: task.cwd }),
-                error: error instanceof Error ? error.message : String(error),
-                ...(error instanceof CleanupInspectionError
-                    ? { checks: error.checks, reason: error.checks[0]?.reason ?? "cleanup-failed",
-                        resource: error.checks[0]?.resource ?? `task:${taskId}`, retryable: true }
-                    : error instanceof WorkspaceCleanupBlockedError
-                        ? {
-                            reason: error.reason,
-                            resource: error.resource,
-                            retryable: error.retryable
-                        }
-                        : {
-                            reason: "cleanup-failed",
-                            resource: `task:${taskId}`,
-                            retryable: true
-                        })
-            };
+            await this.runtime.assertTaskPhysicalResourcesReleased(task.id);
+            this.#assertTaskArchiveSnapshot(snapshot);
+            const rechecked = [...archiveSettlementChecks(this.store, task), ...archiveExecutionChecks(this.store, taskId, this.preparer.home)];
+            if (rechecked.length > 0)
+                throw new CleanupInspectionError(rechecked);
         }
         finally {
-            releaseMaintenance?.();
+            releaseMaintenance();
         }
     }
-    /** Best-effort cleanup only after explicit force admission has committed.
+    /** Best-effort cleanup only after authorized archive admission has committed.
      * This is one foreground attempt, not a retry worker. Each independent result
      * is durable before continuing, and a failed audit write really fails.
      */
     async cleanupArchivedTask(taskId, disposition) {
         const task = this.store.getTask(taskId);
-        if (task?.status !== "archived"
-            || !this.store.listEvents(taskId).some(e => e.type === "task.archived" && e.payload.force === "true")) {
-            throw new Error(`Force archive must commit before cleanup: ${taskId}.`);
+        if (task?.status !== "archived") {
+            throw new Error(`Archive must commit before cleanup: ${taskId}.`);
         }
+        recordArchiveCleanup(this.store, taskId, { resource: `cleanup-pass:${taskId}`,
+            detail: "Begin one foreground exact-owner cleanup pass." }, "started");
         const attempt = async (diagnostic, action) => {
             recordArchiveCleanup(this.store, taskId, diagnostic, "started");
             let status;
@@ -306,7 +241,7 @@ export class TaskWorkspaceCoordinator {
                 const result = await action();
                 status = result === "dirty" ? "retained" : result;
                 if (result === "dirty")
-                    detail = "Dirty workspace retained; force archive does not discard local changes.";
+                    detail = "Dirty workspace retained; archive does not discard local changes.";
             }
             catch (error) {
                 if (isArchivePersistenceFailure(error))
@@ -321,7 +256,7 @@ export class TaskWorkspaceCoordinator {
         for (const role of this.store.listRoles(taskId)) {
             const released = await attempt({ resource: `role:${taskId}/${role.name}`,
                 detail: "Exact Role runtime stop." }, async () => {
-                const checks = archiveExecutionChecks(this.store, taskId).filter(c => c.resource === `role:${taskId}/${role.name}`);
+                const checks = archiveExecutionChecks(this.store, taskId, this.preparer.home).filter(c => c.resource === `role:${taskId}/${role.name}`);
                 if (checks.length > 0)
                     throw new CleanupInspectionError(checks);
                 await this.#stopLiveRoles(taskId, [role.name]);
@@ -331,12 +266,16 @@ export class TaskWorkspaceCoordinator {
         }
         const physicalReleased = await attempt({ resource: `runtime:${taskId}`,
             detail: "Verify exact physical resource release before workspace deletion." }, async () => {
-            const checks = archiveExecutionChecks(this.store, taskId);
+            const checks = archiveExecutionChecks(this.store, taskId, this.preparer.home);
             if (checks.length > 0)
                 throw new CleanupInspectionError(checks);
             if (!runtimeReleased)
                 throw new Error("One or more Role runtimes could not be safely released.");
             await this.runtime.releaseTaskTerminals(taskId);
+            if (this.runtime.assertTaskPhysicalResourcesReleased === undefined) {
+                throw new Error("Exact physical resource release inspection is unavailable.");
+            }
+            await this.runtime.assertTaskPhysicalResourcesReleased(taskId);
             return "released";
         });
         if (physicalReleased) {
@@ -367,31 +306,10 @@ export class TaskWorkspaceCoordinator {
                             case "execution-lane":
                                 return await this.preparer.cleanupExecutionLaneWorkspace(taskId, owner.executionGroupId, owner.executionLaneId);
                             case "integration-attempt":
-                                if (await this.preparer.inspectIntegrationWorkspace(taskId, owner.integrationAttemptId) === "dirty")
-                                    return "dirty";
-                                return await this.preparer.cleanupIntegrationWorkspace(taskId, owner.integrationAttemptId, { preserveChanges: true });
+                                return await this.preparer.cleanupIntegrationWorkspace(taskId, owner.integrationAttemptId);
                             case "task": {
-                                const current = this.store.getTask(taskId);
-                                const delivery = projectTaskRemoteDeliveryFromStore(this.store, current);
-                                if (!delivery.allMerged || !delivery.allVerified) {
-                                    throw new Error("Task main retained: local commits are not covered by verified remote delivery. Force does not discard them.");
-                                }
-                                for (const entry of workspace.entries.filter(e => e.access === "write")) {
-                                    const covered = delivery.projects.find(p => p.projectId === entry.projectId);
-                                    const expected = covered?.expectedLocalCommit;
-                                    const path = await lstat(entry.path).catch(error => {
-                                        if (error.code === "ENOENT")
-                                            return null;
-                                        throw error;
-                                    });
-                                    if (expected !== null && expected !== undefined
-                                        && path !== null) {
-                                        const actual = await this.preparer.git.inspect(entry.path, "HEAD");
-                                        if (actual.baseCommit !== expected && actual.baseCommit !== covered?.deliveryLocalCommit) {
-                                            throw new Error(`Task main HEAD changed: ${entry.path}; retained.`);
-                                        }
-                                    }
-                                }
+                                // The preparer reloads the shared identity, dirt, baseline and
+                                // delivery checks; do not maintain a second post-archive gate.
                                 const result = await this.preparer.cleanupTaskForArchive(taskId, disposition);
                                 if (result.status !== "removed")
                                     throw new Error(result.error ?? "Task main or dependent workspace retained.");
@@ -405,6 +323,17 @@ export class TaskWorkspaceCoordinator {
                 });
             }
         }
+        // The registry remains the authority for scratch/resources not represented
+        // by a current workspace. Do not invent ownership or sweep those paths.
+        // Expose exact unresolved registrations instead of claiming full release.
+        const registered = withResourceRegistry(this.preparer.home, undefined, registry => Object.values(registry.load().records).filter(record => record.owner.taskId === taskId && record.disposition !== "deleted"));
+        for (const record of registered) {
+            recordArchiveCleanup(this.store, taskId, {
+                resource: `resource:${record.id}`, paths: [record.path],
+                detail: `Registered ${record.kind} retained (${record.disposition}); owner=${JSON.stringify(record.owner)}. `
+                    + "No deletion attempted by archive for this remaining registration. Inspect with yui resources gc --dry-run."
+            }, "retained");
+        }
         recordArchiveCleanup(this.store, taskId, { resource: `task:${taskId}`,
             detail: "Foreground cleanup attempt finished; inspect retained resource references and warnings." }, "finished");
     }
@@ -436,24 +365,18 @@ export class TaskWorkspaceCoordinator {
             throw new WorkspaceCleanupBlockedError("active-turn", `work-item:${item.taskId}/${item.id}`, true, `Work item still has an active AgentRun: ${item.taskId}/${item.id}.`);
         }
     }
-    /**
-     * rr5/f4: A WorkItem workspace must not be removed while a DurableJob it
-     * owns could still be using it. Queued, running, and unacknowledged
-     * unknown-needs-attention jobs are unsettled — the runner (or its corpse)
-     * may still hold the worktree. Acknowledged unknown jobs are settled: a
-     * human/Leader has taken responsibility for the outcome.
+    /** Check result/runner before stopping Roles, then physical references before
+     * cleaning any child lanes. The preparer repeats the full check at removal.
      */
-    #assertNoActiveWorkItemDurableJobs(item) {
+    #assertNoActiveWorkItemDurableJobs(item, phase = "before-removal") {
         const jobs = this.store.listDurableJobs(item.taskId);
         const blocking = jobs.filter((job) => (job.owner.kind === "work-item"
             && job.owner.workItemId === item.id
-            && (job.status === "queued"
-                || job.status === "running"
-                || (job.status === "unknown-needs-attention" && job.acknowledgedAt === undefined))));
+            && jobCleanupBlocker(job, this.preparer.home, phase) !== undefined));
         if (blocking.length > 0) {
             throw new WorkspaceCleanupBlockedError("active-durable-job", `work-item:${item.taskId}/${item.id}`, true, `Work item ${item.id} still has ${blocking.length} active DurableJob(s): `
                 + `${blocking.map((job) => `${job.id}/${job.status}`).join(", ")}. `
-                + "Cancel or acknowledge them before cleanup.");
+                + "Settle their outcomes and establish physical exit before cleanup; acknowledgement alone is not stop evidence.");
         }
     }
     #workItemRoleNames(item) {
@@ -470,6 +393,10 @@ export class TaskWorkspaceCoordinator {
     }
     async #stopLiveRoles(taskId, roleNames) {
         const targets = [...new Set(roleNames)];
+        const unresolved = archiveExecutionChecks(this.store, taskId, this.preparer.home, "before-role-stop")
+            .filter(check => targets.some(roleName => check.resource === `role:${taskId}/${roleName}`));
+        if (unresolved.length > 0)
+            throw new CleanupInspectionError(unresolved);
         for (const roleName of targets) {
             if (this.store.getActiveRun(taskId, roleName) !== null) {
                 throw new Error(`Role has an active AgentRun: ${taskId}/${roleName}.`);