@zq-silk/yui 2.1.0 → 2.3.0

package/dist/controller/clientRuntime.js

@@ -1,4 +1,5 @@
 import { spawn } from "node:child_process";
+import { jobCleanupBlocker } from "../job/jobCleanupInspection.js";
 import { describeCliFailure } from "../errors/cliFailure.js";
 import { fileURLToPath } from "node:url";
 import { findLiveControllerProcessForHome, inspectLiveControllerProcess } from "../core/controllerProcessIdentity.js";
@@ -525,8 +526,8 @@ export class FileTaskWorkflowRuntime {
      * live, preserving the owner records for Operator recovery.
      */
     async assertTaskPhysicalResourcesReleased(taskId) {
-        const activeJobs = this.store.listActiveDurableJobs()
-            .filter((job) => job.taskId === taskId);
+        const activeJobs = this.store.listDurableJobs(taskId)
+            .filter((job) => jobCleanupBlocker(job, this.home) !== undefined);
         if (activeJobs.length > 0) {
             throw new WorkspaceCleanupBlockedError("physical-resource-live", `task:${taskId}`, true, `Task physical resources are not released: ${activeJobs.length} DurableJob(s) are still active: `
                 + activeJobs.map(({ id }) => id).join(", "));

package/dist/controller/fileSchedulerStoreAdapter.js

@@ -267,7 +267,8 @@ export class FileSchedulerStoreAdapter {
             default:
                 outcome = "obsolete";
         }
-        if (outcome === "applied" && !isRunTerminalObservation(input)) {
+        if (outcome === "applied" && !isRunTerminalObservation(input)
+            && input.kind !== "goal.updated" && input.kind !== "goal.cleared") {
             this.persistRuntimeObservation(input, now);
         }
         return outcome;
@@ -700,7 +701,7 @@ export class FileSchedulerStoreAdapter {
             return "applied";
         });
     }
-    persistRuntimeObservation(input, now) {
+    persistRuntimeObservation(input, now, notifyGoal = true) {
         this.store.transaction((store) => {
             const taskId = input.fence.taskId;
             const events = store.listEvents(taskId);
@@ -762,8 +763,7 @@ export class FileSchedulerStoreAdapter {
                     ? "provider-continuation-report"
                     : "provider-continuation-settled", now);
             }
-            if ((input.kind === "goal.cleared"
-                || (input.kind === "goal.updated" && input.payload.goalStatus !== "active"))
+            if (notifyGoal && (input.kind === "goal.cleared" || input.kind === "goal.updated")
                 && input.fence.roleName !== "leader") {
                 routeRoleEvent(store, observationEvent, input.fence.roleName, input.kind === "goal.cleared"
                     ? "provider-goal-cleared"
@@ -2363,6 +2363,8 @@ export class FileSchedulerStoreAdapter {
     observeProviderGoal(input, now) {
         return this.store.transaction((store) => {
             const taskId = input.fence.taskId;
+            if (hasPersistedRuntimeObservation(store.listEvents(taskId), input))
+                return "applied";
             const sessions = store.getTaskRoleSessionSet(taskId, input.fence.roleName);
             const binding = sessions?.providerBinding;
             if (sessions === null || sessions === undefined || binding === null || binding === undefined
@@ -2383,7 +2385,16 @@ export class FileSchedulerStoreAdapter {
                         ? {}
                         : { tokenBudget: input.payload.goalTokenBudget })
                 });
+            // Startup/re-attachment observes current state, not necessarily a change.
+            // Compare under the same transaction that persists and routes the fact.
+            if (isDeepStrictEqual(binding.goal, updated.goal)) {
+                // Retain the existing dedup evidence: an old empty observation replayed
+                // after a later real update must not clear that newer state.
+                this.persistRuntimeObservation(input, now, false);
+                return "applied";
+            }
             store.saveTaskRoleSessionSet(updateTaskRoleProviderRuntime(sessions, updated, now));
+            this.persistRuntimeObservation(input, now);
             return "applied";
         });
     }
@@ -3127,14 +3138,16 @@ function mapRole(store, role) {
         ? resolveEffectiveLaunch({
             role,
             purpose,
-            ...(workspace === undefined ? {} : { workspace })
+            ...(workspace === undefined ? {} : { workspace }),
+            ...(item === null ? {} : { workItemWriteProjectIds: item.writeProjectIds })
         })
         : liveSession !== null && workspace?.owner.type === "task"
             ? effectiveLaunchWithTaskMainWorkspace(liveSession.effective, workspace)
             : liveSession?.effective ?? resolveEffectiveLaunch({
                 role,
                 purpose,
-                ...(workspace === undefined ? {} : { workspace })
+                ...(workspace === undefined ? {} : { workspace }),
+                ...(item === null ? {} : { workItemWriteProjectIds: item.writeProjectIds })
             });
     return {
         taskId: role.taskId,

package/dist/controller/jobControl.js

@@ -19,6 +19,7 @@ import { requireManagedTaskCaller, ManagedRuntimeDriftError } from "../runtime/m
 import { CliError } from "../errors/cliError.js";
 import { assertJobAssignmentScope, JobAssignmentScopeError } from "../job/jobAssignmentScope.js";
 import { assertContextRecordReadable } from "../context/taskContext.js";
+import { assertTaskProjectWriteAuthority } from "../task/taskAuthority.js";
 export function createDurableJobControl(store) {
     const authority = createJobCallAuthority(store);
     return {
@@ -167,8 +168,27 @@ export function authorizeJobStart(store, job) {
         throw jobDomainError("Job caller binding was revoked; no execution was started.");
     }
     requireJobAssignment(store, job, { scope, role });
+    assertLeaderJobWriteScope(store, job, { scope, role });
     validateJobTarget(store, job);
 }
+function assertLeaderJobWriteScope(store, target, caller) {
+    if (caller.scope !== "task" || caller.role !== "leader")
+        return;
+    if (target.owner.kind !== "task" && target.owner.kind !== "integration-attempt") {
+        throw jobControlError("UNAUTHORIZED", "Direct Leader delivery does not grant another Assignment or Review workspace. Use the owning executor for its Job.");
+    }
+    const { taskId, projectId } = target;
+    const session = activeLiveRoleAgentSession(store.getTaskRoleSessionSet(taskId, caller.role));
+    try {
+        assertTaskProjectWriteAuthority(store, {
+            YUI_SESSION_SCOPE: "task", YUI_TASK_ID: taskId, YUI_ROLE: caller.role,
+            YUI_NATIVE_SESSION_ID: caller.nativeSessionId ?? session?.nativeSessionId
+        }, taskId, projectId);
+    }
+    catch (error) {
+        throw jobControlError("UNAUTHORIZED", error instanceof Error ? error.message : String(error));
+    }
+}
 function requireJobAssignment(store, target, caller) {
     try {
         assertJobAssignmentScope(store, target, caller);
@@ -244,6 +264,7 @@ function assertNonSecretJobInput(params) {
 function validateStartParams(store, params) {
     validateJobTarget(store, params);
     assertCallerAuthorized(store, params.caller, params.taskId);
+    assertLeaderJobWriteScope(store, params, params.caller);
     if (params.caller.scope === "task") {
         const session = store.getTaskRoleSessionSet(params.taskId, params.caller.role);
         if (session?.sessions[session.activeAgentId]?.effective.executionAuthority !== "delivery") {

package/dist/executor/agentExecutor.js

@@ -317,7 +317,7 @@ export function roleAgentSessionResumeMode(set, agentId, desired) {
     if (roleSessionMayContinue(session.effective, desired))
         return "resume";
     throw new Error(`Role Agent session cannot continue under the next launch: ${agentId}. `
-        + "Its Agent, adapter or physical workspace changed. Explicitly select a new Session "
+        + "Its Agent, adapter, physical workspace or captured authority changed. Explicitly select a new Session "
         + "after resolving existing execution and resource ownership.");
 }
 export function bindTaskRoleProviderRuntime(set, binding, updatedAt) {

package/dist/executor/effectiveLaunch.js

@@ -117,8 +117,8 @@ export function sameEffectiveLaunch(existing, desired) {
  *
  * Only facts that make continuation impossible participate: the Session
  * protocol, the provider identity that owns the conversation, and the physical
- * workspace the Session runs in. Launch configuration such as model, effort,
- * permission, Role context, declared write scope, and AgentRun-scoped facts like
+ * workspace and captured authority the Session runs with. Launch configuration
+ * such as model, effort, provider permission, Role context, and AgentRun-scoped facts like
  * ReviewRound identity or candidate commits shape the next Host process
  * instead of ending the Session; that divergence is acknowledged where the
  * configuration changes and stays visible as launch provenance.
@@ -151,6 +151,8 @@ function sessionContinuitySnapshot(snapshot) {
     return {
         schemaVersion: snapshot.schemaVersion,
         executionAuthority: snapshot.executionAuthority,
+        profileAccess: snapshot.profileAccess,
+        writeProjectIds: snapshot.writeProjectIds,
         contextProtocolVersion: snapshot.contextProtocolVersion,
         agentId: snapshot.agentId,
         // Two products on one connection plan are two different conversations. A
@@ -329,6 +331,8 @@ function effectiveLaunchConfigUnchecked(snapshot) {
             : claudeConfigFromSnapshot(snapshot);
 }
 function effectiveWriteProjects(input, workspace) {
+    if (input.purpose === "planning" || input.executionAuthority === "planning")
+        return [];
     if (input.purpose === "review") {
         if (!("taskId" in input.role)) {
             throw new Error("Review launch requires a Task Role.");
@@ -358,9 +362,18 @@ function effectiveWriteProjects(input, workspace) {
         .map(({ projectId }) => projectId), "Workspace writable Project");
     if (!("taskId" in input.role))
         return [];
-    // A managed workspace describes what exists, not who is authorized to
-    // mutate it. Only an explicit WorkItem write scope can grant Task writes.
-    if (input.workItemWriteProjectIds === undefined)
+    // Direct delivery belongs to the Leader in this Task's adopted main
+    // workspace. Assignment scope (including explicit []) still takes priority.
+    // Never infer authority from a path, a different owner's workspace or a
+    // desired Profile change to an already-frozen Session.
+    if (input.workItemWriteProjectIds === undefined) {
+        return input.role.name === "leader"
+            && input.role.defaultAccess === "write"
+            && input.workspace?.owner.type === "task"
+            && input.workspace.owner.taskId === input.role.taskId
+            ? workspaceWrite : [];
+    }
+    if (input.role.defaultAccess !== "write")
         return [];
     const requested = uniqueIdentities(input.workItemWriteProjectIds, "WorkItem writable Project");
     if (requested.length === 0)

package/dist/executor/fileRoleLaunchPlanner.js

@@ -216,7 +216,7 @@ export class FileRoleLaunchPlanner {
             // attempt was rejected, cancelled, or completed.
             assertProviderConversationReplaceable(sessionSet.providerBinding);
         }
-        return this.#compile(role, input, { scope: "task", taskId: task.id }, resolveTaskRoleSessionTitle(input.mode === "resume" ? existing?.title : undefined, task, role.name), input.mode === "resume" && compatibleExisting ? existing.nativeSessionId : undefined, runWorkspace, effective, {
+        return this.#compile(role, input, { scope: "task", taskId: task.id }, resolveTaskRoleSessionTitle(input.mode === "resume" ? existing?.title : undefined, task, role.name), input.mode === "resume" && compatibleExisting ? existing.nativeSessionId : undefined, effective, {
             purpose
         });
     }
@@ -246,9 +246,9 @@ export class FileRoleLaunchPlanner {
         }
         return this.#compile(role, input, { scope: "global" }, input.mode === "new" && role.name === "operator"
             ? operatorSessionTitle(this.#now(), this.store.getConfig().timeZone)
-            : undefined, input.mode === "resume" && compatibleExisting ? existing.nativeSessionId : undefined, undefined, effective, { purpose: "execution" });
+            : undefined, input.mode === "resume" && compatibleExisting ? existing.nativeSessionId : undefined, effective, { purpose: "execution" });
     }
-    #compile(role, input, owner, sessionTitle, knownNativeSessionId, workspaceOverride, effective, sessionPolicy) {
+    #compile(role, input, owner, sessionTitle, knownNativeSessionId, effective, sessionPolicy) {
         const launchRole = effectiveRoleForLaunch(role, effective);
         const binding = activeRoleAgentBinding(launchRole);
         if (binding.agentId !== input.agentId || binding.adapterId !== input.adapterId) {
@@ -580,7 +580,7 @@ export class FileRoleLaunchPlanner {
             childLifecycle: driver.capabilities.lifecycle.providerProcess
         };
         const scopedLaunch = owner.scope === "task"
-            ? this.#applyWorkspaceScope(owner.taskId, role, launch, workspaceOverride)
+            ? this.#applyWorkspaceScope(launch, effective)
             : launch;
         const ordinaryConversationLaunch = withCodexThreadEnvironment(scopedLaunch);
         return {
@@ -640,20 +640,11 @@ export class FileRoleLaunchPlanner {
         }
         return { attemptId: run.attemptId, turnId: run.nativeTurnId };
     }
-    #applyWorkspaceScope(taskId, role, launch, workspaceOverride) {
-        const workspace = workspaceOverride
-            ?? (role.name === "leader"
-                ? this.store.getTaskWorkspace(taskId)
-                : this.store.listWorkItems(taskId)
-                    .find((item) => item.assignee === role.name && item.status === "open") === undefined
-                    ? this.store.getTaskWorkspace(taskId)
-                    : this.store.getWorkItemWorkspace(taskId, this.store.listWorkItems(taskId).find((item) => item.assignee === role.name && item.status === "open").id));
-        if (workspace === null || workspace === undefined)
-            return launch;
+    #applyWorkspaceScope(launch, effective) {
         return {
             ...launch,
             env: {
-                ...workspaceScopeEnvironment(launch.env, workspace)
+                ...workspaceScopeEnvironment(launch.env, effective)
             }
         };
     }
@@ -711,16 +702,21 @@ function resolveTaskRoleEffectiveLaunch(store, role, purpose = "execution") {
         ...(item === null ? {} : { workItemWriteProjectIds: item.writeProjectIds })
     });
 }
-function workspaceScopeEnvironment(environment, workspace) {
+function workspaceScopeEnvironment(environment, effective) {
+    const entries = effective.workspace.entries.map(entry => ({
+        ...entry,
+        access: entry.access === "write" && effective.writeProjectIds.includes(entry.projectId)
+            ? "write" : "read"
+    }));
     return {
         ...environment,
-        YUI_WRITABLE_PROJECT_IDS: JSON.stringify(workspace.entries
+        YUI_WRITABLE_PROJECT_IDS: JSON.stringify(entries
             .filter(({ access }) => access === "write")
             .map(({ projectId }) => projectId)),
-        YUI_CONTEXT_PROJECT_IDS: JSON.stringify(workspace.entries
+        YUI_CONTEXT_PROJECT_IDS: JSON.stringify(entries
             .filter(({ access }) => access === "read")
             .map(({ projectId }) => projectId)),
-        YUI_WORKSPACE_PROJECTS: JSON.stringify(Object.fromEntries(workspace.entries.map(({ projectId, directory, access, path }) => [
+        YUI_WORKSPACE_PROJECTS: JSON.stringify(Object.fromEntries(entries.map(({ projectId, directory, access, path }) => [
             projectId,
             { directory, access, path }
         ])))

package/dist/integration/gitIntegrationService.js

@@ -1,20 +1,19 @@
 import { execFile, spawn } from "node:child_process";
-import { lstat, mkdir, open, rm, stat } from "node:fs/promises";
+import { lstat, mkdir, open, realpath, rm, stat } from "node:fs/promises";
 import { dirname, join, relative, resolve, sep } from "node:path";
 import { promisify } from "node:util";
 import { selectEnvironment } from "../agent/launchEnvironment.js";
-import { controllerSocketPath } from "../core/controllerEndpoint.js";
 import { durableJobIdempotencyKey } from "../job/durableJob.js";
 import { readRuntimeIdentity } from "../release/runtimeRelease.js";
 import { NodeGitWorkspace } from "../repository/gitWorkspace.js";
 import { acquireProjectMaintenanceLocks } from "../repository/projectMaintenanceLock.js";
 import { taskWorkspaceRefSegment } from "../repository/taskWorkspaceIdentity.js";
-import { integrationWorkspaceRoot } from "../repository/taskWorkspacePreparer.js";
+import { FileTaskWorkspacePreparer, integrationWorkspaceRoot } from "../repository/taskWorkspacePreparer.js";
 import { ResourceRegistrar } from "../resources/resourceRegistrar.js";
-import { FileTaskRuntimeIsolation } from "../runtime/taskRuntimeIsolation.js";
-import { integrationTmuxSocketRoot, managedIntegrationRuntimeRoot } from "../storage/homeLayout.js";
+import { integrationTmuxSocketRoot } from "../storage/homeLayout.js";
+import { defaultIntegrationRuntimeIsolation } from "../runtime/integrationRuntimeIsolation.js";
 import { advanceTaskProjectCommit } from "../task/task.js";
-import { yuiTmuxServerName } from "../tmux/tmuxManager.js";
+import { taskIntegrationSettlementCheckout, taskIntegrationTargetCheckout } from "../task/taskAuthority.js";
 import { recordGateArtifactReuse } from "../verification/gateArtifact.js";
 import { touchGateArtifact } from "../verification/gateArtifactStore.js";
 import { beginGateVerification, checkResultsFromGateArtifact, checkResultsFromGateJob, gateIdentityForCandidate, lookupReusableGateArtifact, recordGateArtifactFromJob, recordGateArtifactFromStepOutcomes, resolveVerificationGate, runGateStepsInProcess } from "../verification/verificationGateService.js";
@@ -75,8 +74,12 @@ export class GitIntegrationService {
     #resourceRegistrar() {
         return this.#resourceRegistrarValue ??= new ResourceRegistrar(this.home, this.now);
     }
+    #targetCheckout(attempt) {
+        return taskIntegrationTargetCheckout(this.store, this.environment, attempt.taskId, attempt.projectId, attempt.targetRef);
+    }
     async integrate(taskId, integrationId, signal) {
         let initial = requireIntegration(this.store, taskId, integrationId);
+        this.#targetCheckout(initial);
         if (!["running", "conflicted", "blocked", "validating"].includes(initial.status)) {
             throw new Error(`Integration cannot continue from ${initial.status}.`);
         }
@@ -95,6 +98,7 @@ export class GitIntegrationService {
                 throw new Error("Integration changed before execution admission; read its current record.");
             }
             initial = currentUnderFence;
+            this.#targetCheckout(initial);
             const task = this.store.getTask(initial.taskId);
             if (task === null || !task.projectBindings.some(({ projectId }) => projectId === initial.projectId)) {
                 throw new Error(`Integration Task Project is unavailable: ${initial.taskId}.`);
@@ -116,6 +120,7 @@ export class GitIntegrationService {
                 || taskRepository === undefined) {
                 throw new Error(`Integration Task clone is unavailable: ${task.id}/${project.id}.`);
             }
+            await assertTargetCheckout(taskRepository, initial.targetRef, this.#targetCheckout(initial));
             // Issue 08: a Project with a VerificationPlan gates through its plan
             // (bootstrap + L2) and reuses exact-SHA artifacts; an unconfigured
             // Project keeps the existing explicit check path unchanged.
@@ -193,7 +198,7 @@ export class GitIntegrationService {
                 // moved or its worktree is dirty, so the check commands never run on a
                 // target that cannot be advanced.  advanceTargetRef re-verifies both
                 // after the checks, so a move during the gate is still fenced at CAS.
-                await assertTargetReadyForChecks(taskRepository, current.targetRef, current.beforeCommit);
+                await assertTargetReadyForChecks(taskRepository, current.targetRef, current.beforeCommit, this.#targetCheckout(current));
                 if (gate !== undefined) {
                     return await this.#runVerificationGate(current, workspace, prepared.path, managedWorkspace, taskRepository, gate);
                 }
@@ -221,7 +226,7 @@ export class GitIntegrationService {
                     checks: checkResults
                 }, this.now());
                 this.store.saveIntegrationAttempt(task.id, current);
-                await advanceTargetRef(taskRepository, current.targetRef, candidateCommit, current.beforeCommit);
+                await advanceTargetRef(taskRepository, current.targetRef, candidateCommit, current.beforeCommit, this.#targetCheckout(current));
                 const committed = this.#recordCommitted(current);
                 return this.#terminalResult("committed", committed, workspace);
             }
@@ -234,7 +239,7 @@ export class GitIntegrationService {
                     if (target === current.candidateCommit) {
                         try {
                             await assertIntegrationCandidate(workspace.path, current.candidateCommit, workspace.branch);
-                            await assertTargetReadyForChecks(taskRepository, current.targetRef, current.candidateCommit);
+                            await assertTargetReadyForChecks(taskRepository, current.targetRef, current.candidateCommit, this.#targetCheckout(current));
                             const committed = this.#recordCommitted(current);
                             return this.#terminalResult("committed", committed, workspace);
                         }
@@ -307,8 +312,21 @@ export class GitIntegrationService {
                 }
                 const target = await resolveRef(mainEntry.path, attempt.targetRef);
                 if (target === attempt.candidateCommit && target !== attempt.beforeCommit) {
-                    await assertTargetReadyForChecks(mainEntry.path, attempt.targetRef, target);
-                    return this.#recordCommitted(attempt, authorize);
+                    if (attempt.checks.some(check => check.outcome === "failed")
+                        || attempt.jobId !== undefined
+                            && jobs.find(job => job.id === attempt.jobId).status !== "succeeded") {
+                        throw new Error("Delivered Integration lacks successful candidate check evidence; inspect before settlement.");
+                    }
+                    await assertIntegrationCandidate(workspace.root, attempt.candidateCommit, workspaceEntry.branch);
+                    assertRecordedSourceCandidate(attempt, { path: workspace.root, branch: workspaceEntry.branch });
+                    await assertTargetReadyForChecks(mainEntry.path, attempt.targetRef, target, taskIntegrationSettlementCheckout(this.store, this.environment, taskId, attempt.projectId, attempt.targetRef));
+                    return this.#recordCommitted(attempt, (tx, id) => {
+                        authorize(tx, id);
+                        taskIntegrationSettlementCheckout(tx, this.environment, id, attempt.projectId, attempt.targetRef);
+                        if (JSON.stringify(requireIntegration(tx, id, integrationId)) !== JSON.stringify(attempt)) {
+                            throw new Error("Integration changed before delivered settlement; inspect its current record.");
+                        }
+                    });
                 }
                 if (target !== attempt.beforeCommit) {
                     throw new Error(`Target moved to ${target}; cannot prove this Integration is unadvanced. Inspect before settlement.`);
@@ -350,12 +368,9 @@ export class GitIntegrationService {
                 throw new Error("Integration changed before cleanup; read its current record.");
             }
             integration = current;
-            const activeJob = this.store.listDurableJobs(integration.taskId).find(job => job.owner.kind === "integration-attempt" && job.owner.integrationAttemptId === integration.id
-                && (job.status === "queued" || job.status === "running"
-                    || (job.status === "unknown-needs-attention" && job.acknowledgedAt === undefined)));
-            if (activeJob !== undefined) {
-                throw new Error(`Integration ${integration.id} has an active DurableJob: ${activeJob.id}/${activeJob.status}.`);
-            }
+            const managedWorkspace = this.store.getIntegrationWorkspace(integration.taskId, integration.id);
+            if (managedWorkspace === null)
+                return "missing";
             const task = this.store.getTask(integration.taskId);
             if (task === null || !task.projectBindings.some(({ projectId }) => projectId === integration.projectId)) {
                 throw new Error(`Integration Task Project is unavailable: ${integration.id}.`);
@@ -367,42 +382,8 @@ export class GitIntegrationService {
             if (taskRepository === undefined) {
                 throw new Error(`Integration Task clone is unavailable: ${task.id}/${project.id}.`);
             }
-            const managedWorkspace = this.store.getIntegrationWorkspace(integration.taskId, integration.id);
-            if (managedWorkspace !== null) {
-                const runtime = this.#runtimePreparation(integration, managedWorkspace);
-                this.runtimeIsolation.cleanup(runtime, integration.status === "committed" ? "completion" : "failure");
-            }
-            const recorded = managedWorkspace?.entries[0];
-            const directory = recorded?.directory
-                ?? task.projectBindings.find(({ projectId }) => projectId === integration.projectId)?.directory;
-            if (directory === undefined) {
-                throw new Error(`Integration Project binding is unavailable: ${task.id}/${project.id}.`);
-            }
-            const result = await this.git.removeIntegrationWorktree({
-                repositoryPath: taskRepository,
-                container: recorded !== undefined
-                    ? dirname(recorded.path)
-                    : integrationWorkspaceRoot(this.home, task.id, integration.id),
-                directory,
-                taskSegment: taskWorkspaceRefSegment(task),
-                integrationId: integration.id,
-                discardChanges: integration.status === "failed"
-            });
-            if (result !== "dirty") {
-                if (managedWorkspace !== null) {
-                    this.#resourceRegistrar().markWorkspaceDeleted(managedWorkspace);
-                }
-                await rm(integrationCheckDirectory(this.home, task.id, integration.id), {
-                    recursive: true,
-                    force: true
-                });
-                this.store.removeManagedWorkspace({
-                    type: "integration-attempt",
-                    taskId: integration.taskId,
-                    integrationAttemptId: integration.id
-                });
-            }
-            return result;
+            return await new FileTaskWorkspacePreparer(this.home, this.store, this.git, this.now)
+                .cleanupIntegrationWorkspace(task.id, integration.id, { runtimeIsolation: this.runtimeIsolation });
         }
         finally {
             release();
@@ -419,7 +400,7 @@ export class GitIntegrationService {
             throw new Error(`Integration check admission requires a running, proven candidate: ${attempt.id}.`);
         }
         await assertIntegrationCandidate(path, attempt.candidateCommit, workspace.branch);
-        await assertTargetReadyForChecks(repositoryPath, attempt.targetRef, attempt.beforeCommit);
+        await assertTargetReadyForChecks(repositoryPath, attempt.targetRef, attempt.beforeCommit, this.#targetCheckout(attempt));
         const { runtime, head, steps, environment, inputDigest } = await this.#checkSpecification(attempt, managedWorkspace, gate);
         if (attempt.checkInputDigest !== undefined && attempt.checkInputDigest !== inputDigest) {
             throw new Error("Integration check conditions changed since admission; inspect the original Job, then abort or start a new attempt.");
@@ -479,7 +460,7 @@ export class GitIntegrationService {
         const job = await this.jobPort.getJob(attempt.taskId, attempt.jobId);
         assertCheckJobIdentity(attempt, job, path);
         await assertIntegrationCandidate(path, job.head, workspace.branch);
-        await assertTargetReadyForChecks(repositoryPath, attempt.targetRef, attempt.beforeCommit);
+        await assertTargetReadyForChecks(repositoryPath, attempt.targetRef, attempt.beforeCommit, this.#targetCheckout(attempt));
         if (gate?.planDigest !== attempt.gatePlanDigest
             || gate?.toolchainDigest !== attempt.gateToolchainDigest) {
             throw new Error("Integration verification plan/toolchain changed; the original Job cannot prove the current gate.");
@@ -642,7 +623,7 @@ export class GitIntegrationService {
             checks
         }, this.now());
         this.store.saveIntegrationAttempt(attempt.taskId, validating);
-        await advanceTargetRef(repositoryPath, validating.targetRef, candidateCommit, validating.beforeCommit);
+        await advanceTargetRef(repositoryPath, validating.targetRef, candidateCommit, validating.beforeCommit, this.#targetCheckout(validating));
         const committed = this.#recordCommitted(validating);
         return this.#terminalResult("committed", committed, workspace);
     }
@@ -709,9 +690,9 @@ export class GitIntegrationService {
                 }
                 assertCheckJobIdentity(attempt, job, workspace.path);
             }
-            await advanceTargetRef(repositoryPath, attempt.targetRef, attempt.candidateCommit, attempt.beforeCommit);
+            await advanceTargetRef(repositoryPath, attempt.targetRef, attempt.candidateCommit, attempt.beforeCommit, this.#targetCheckout(attempt));
         }
-        await assertTargetReadyForChecks(repositoryPath, attempt.targetRef, attempt.candidateCommit);
+        await assertTargetReadyForChecks(repositoryPath, attempt.targetRef, attempt.candidateCommit, this.#targetCheckout(attempt));
         const committed = this.#recordCommitted(attempt);
         return this.#terminalResult("committed", committed, workspace);
     }
@@ -1004,26 +985,6 @@ function isNodeCode(error, code) {
         && "code" in error
         && error.code === code;
 }
-function defaultIntegrationRuntimeIsolation(home, homeId) {
-    const controlHome = resolve(home);
-    const runtimeRoot = managedIntegrationRuntimeRoot(controlHome);
-    return new FileTaskRuntimeIsolation({
-        // The integration check's provider data/cache/tmp live in a dedicated Home
-        // partition — the same isolation contract every Task runtime obeys — not in
-        // a system-wide `/tmp` root. Only the tmux socket ENDPOINT stays a short
-        // `/tmp` path (see `integrationCheckEnvironment`) for the `sockaddr_un`
-        // budget; ordinary runtime state is now Yui-managed under Home.
-        runtimeRoot,
-        pathLayout: "compact",
-        controlPlane: {
-            yuiHome: controlHome,
-            managedRuntimeRoot: runtimeRoot,
-            controllerSocketPath: controllerSocketPath(homeId),
-            tmuxNamespace: yuiTmuxServerName(controlHome),
-            globalInstallPaths: [process.execPath]
-        }
-    });
-}
 /**
  * Reuse is enabled only for an immutable installed release. Development
  * checkouts have no content-addressed release identity, so they return.
@@ -1138,12 +1099,12 @@ async function resolveRef(repositoryPath, ref) {
  * {@link advanceTargetRef} re-verifies both before the CAS, so a target that
  * moves during the gate is still fenced.
  */
-async function assertTargetReadyForChecks(repositoryPath, targetRef, expectedHead) {
+async function assertTargetReadyForChecks(repositoryPath, targetRef, expectedHead, expectedCheckout) {
     const current = await resolveRef(repositoryPath, targetRef);
     if (current !== expectedHead) {
         throw new Error(`Target moved to ${current}; expected ${expectedHead}.`);
     }
-    const checkedOutPaths = await checkedOutWorktreePaths(repositoryPath, fullTargetRef(targetRef));
+    const checkedOutPaths = await assertTargetCheckout(repositoryPath, targetRef, expectedCheckout);
     if (checkedOutPaths.length > 1) {
         throw new Error(`Integration target is checked out in multiple worktrees: ${targetRef}.`);
     }
@@ -1156,9 +1117,18 @@ async function assertTargetReadyForChecks(repositoryPath, targetRef, expectedHea
         }
     }
 }
-async function advanceTargetRef(repositoryPath, targetRef, candidateCommit, expectedHead) {
+async function assertTargetCheckout(repositoryPath, targetRef, expectedCheckout) {
+    const paths = await checkedOutWorktreePaths(repositoryPath, fullTargetRef(targetRef));
+    if (expectedCheckout !== undefined && (await realpath(repositoryPath) !== await realpath(expectedCheckout)
+        || paths.length !== 1 || await realpath(paths[0]) !== await realpath(expectedCheckout)
+        || (await git(["-C", expectedCheckout, "symbolic-ref", "HEAD"])).trim() !== fullTargetRef(targetRef))) {
+        throw new Error("Managed Leader Integration target must be physically checked out in its captured Task-main workspace.");
+    }
+    return paths;
+}
+async function advanceTargetRef(repositoryPath, targetRef, candidateCommit, expectedHead, expectedCheckout) {
     const ref = fullTargetRef(targetRef);
-    const checkedOutPaths = await checkedOutWorktreePaths(repositoryPath, ref);
+    const checkedOutPaths = await assertTargetCheckout(repositoryPath, targetRef, expectedCheckout);
     if (checkedOutPaths.length === 0) {
         await git([
             "-C", repositoryPath, "update-ref",
@@ -1182,6 +1152,9 @@ async function advanceTargetRef(repositoryPath, targetRef, candidateCommit, expe
     if (current !== expectedHead) {
         throw new Error(`Target moved to ${current}; expected ${expectedHead}.`);
     }
+    if (expectedCheckout !== undefined) {
+        await assertTargetCheckout(repositoryPath, targetRef, expectedCheckout);
+    }
     // The candidate may be a rebased upstream result and therefore need not be
     // a descendant of the old Task head. Advance the branch with a real
     // compare-and-swap, then update only this checkout's index and worktree.
@@ -1193,6 +1166,9 @@ async function advanceTargetRef(repositoryPath, targetRef, candidateCommit, expe
         candidateCommit,
         expectedHead
     ]);
+    if (expectedCheckout !== undefined) {
+        await assertTargetCheckout(repositoryPath, targetRef, expectedCheckout);
+    }
     await git(["-C", checkout, "read-tree", "--reset", "-u", candidateCommit]);
     const advanced = await resolveRef(repositoryPath, targetRef);
     if (advanced !== candidateCommit) {

package/dist/job/jobCleanupInspection.js

@@ -0,0 +1,67 @@
+import { isAbsolute, join, resolve } from "node:path";
+import { processGenerationIsLive } from "../core/fileLockOwner.js";
+import { scanProcessPathRefs } from "../resources/liveReferences.js";
+import { inspectTaskRuntimeCleanupClaims, parseTaskRuntimeIsolationDescriptor, YUI_TASK_RUNTIME_ISOLATION_DESCRIPTOR } from "../runtime/taskRuntimeIsolation.js";
+/** Result uncertainty and physical occupancy are different facts. Reuse the
+ * recorded process generation and resource scanner, without rewriting the Job
+ * or treating acknowledgement as stop evidence. Every cleanup reads this anew.
+ */
+export function jobCleanupBlocker(job, home, phase = "before-removal") {
+    if (job.status === "queued" || job.status === "running")
+        return `DurableJob is ${job.status}.`;
+    if (job.status === "unknown-needs-attention" && job.acknowledgedAt === undefined) {
+        return "Unknown Job result requires explicit acknowledgement.";
+    }
+    if (job.status !== "unknown-needs-attention" && job.startedAt === undefined
+        && job.process === undefined && job.operation.effect === "none")
+        return undefined;
+    if (job.process === undefined || home === undefined) {
+        return "Job has no exact process/Home evidence for physical inspection.";
+    }
+    try {
+        if (processGenerationIsLive(job.process.pid, job.process.startIdentity)) {
+            return "The exact Job runner process is still live.";
+        }
+        // A reusable idle Role can share this workspace. Its exact-owner stop is
+        // allowed only after result/runner checks; path references must then be
+        // rechecked before any child deletion or ordinary archive commit.
+        if (phase === "before-role-stop")
+            return undefined;
+        // Steps may outlive a killed runner. Their cwd, logs and isolated runtime
+        // paths remain protective references; no process is signalled here.
+        const paths = [job.workspace, join(resolve(home), "artifacts", "jobs", job.taskId, job.id),
+            ...["TMPDIR", "XDG_DATA_HOME", "XDG_CACHE_HOME"].flatMap(key => {
+                const path = job.env[key];
+                return path !== undefined && isAbsolute(path) ? [path] : [];
+            })];
+        const serialized = job.env[YUI_TASK_RUNTIME_ISOLATION_DESCRIPTOR];
+        if (serialized !== undefined) {
+            const descriptor = parseTaskRuntimeIsolationDescriptor(serialized);
+            const owner = descriptor.workspace.owner;
+            if (descriptor.taskId !== job.taskId || descriptor.workspace.root !== job.workspace
+                || owner.type !== job.owner.kind
+                || (owner.type === "integration-attempt" && job.owner.kind === "integration-attempt"
+                    && owner.integrationAttemptId !== job.owner.integrationAttemptId)
+                || (owner.type === "work-item" && job.owner.kind === "work-item"
+                    && owner.workItemId !== job.owner.workItemId)) {
+                return "Job runtime descriptor does not match its exact owner/workspace.";
+            }
+            const claims = inspectTaskRuntimeCleanupClaims(descriptor);
+            const uncertain = claims.find(claim => claim.ownership !== "owned" || claim.state !== "inactive");
+            if (uncertain !== undefined)
+                return `Job runtime cleanup claim is unverified: ${uncertain.id}.`;
+            // cwd/fd references follow rename, unlike the recorded environment.
+            // Use the same exact claim inventory as deletion, before archive commits.
+            paths.push(descriptor.roots.runtime, ...claims.map(claim => claim.id));
+        }
+        const scan = scanProcessPathRefs(paths);
+        if (scan.diagnostics.some(diagnostic => diagnostic.severity === "error")
+            || [...scan.refs.values()].some(refs => refs.length > 0)) {
+            return "Job workspace/log/runtime references are still live or unverified.";
+        }
+    }
+    catch (error) {
+        return `Job physical inspection is unavailable: ${error instanceof Error ? error.message : String(error)}`;
+    }
+    return undefined;
+}