@zq-silk/yui 0.8.9 → 0.10.0

package/dist/commands/taskCompletionGate.js

@@ -2,14 +2,13 @@ import { usageError } from "../errors/cliError.js";
 import { GitIntegrationService } from "../integration/gitIntegrationService.js";
 import { createIntegrationAttempt } from "../integration/integrationAttempt.js";
 import { NodeGitWorkspace } from "../repository/gitWorkspace.js";
-import { taskDeliveryPath } from "../task/task.js";
 import { publicationExternalKey } from "../task/publicationReference.js";
 import { isSemanticReviewRound } from "../review/reviewOutcomeClassifier.js";
 import { workspaceProjectEntry } from "../worktree/managedWorkspace.js";
 /**
  * Verify the one supported ancestry waiver before `task complete` mutates any
  * durable state. The explicit Publication must be the current verified merged
- * record, bind the exact physical Task head (and, for integrated delivery, its
+ * record, bind the exact physical Task head (and, when WorkItems exist, its
  * completed final Review), and name an ancestry-divergent commit with the
  * exact same Git tree.
  */
@@ -30,12 +29,14 @@ export async function verifyTaskCompletionPublishedTree(taskId, publicationId, s
         throw usageError(`Publication ${publication.id} must record exact local and remote commits.`);
     }
     const workspace = requireTaskWorkspace(store, task);
-    const integrated = taskDeliveryPath(task) === "integrated";
-    const latestReview = integrated ? latestTaskFinalReview(store, task.id) : undefined;
-    if (integrated && (latestReview === undefined
-        || !isSemanticReviewRound(latestReview, store)
-        || latestReview.taskCandidate === undefined)) {
-        throw usageError(`Task ${task.id} requires a latest completed Task-final Review before accepting a published tree.`);
+    const latestRecordedReview = latestTaskFinalReview(store, task.id);
+    const latestReview = latestRecordedReview !== undefined
+        && isSemanticReviewRound(latestRecordedReview, store)
+        && latestRecordedReview.taskCandidate !== undefined
+        ? latestRecordedReview
+        : undefined;
+    if (latestRecordedReview !== undefined && latestReview === undefined) {
+        throw usageError(`Task ${task.id} has an unsettled Task-final Review obligation before accepting a published tree.`);
     }
     const git = options.git ?? new NodeGitWorkspace();
     const actualHeads = new Map();
@@ -122,7 +123,7 @@ export function assertTaskCompletionPublishedTreeProof(store, task, publicationI
         || publication.remoteCommit !== proof.remoteCommit) {
         throw usageError(`Publication evidence changed before Task completion: ${publication.id}.`);
     }
-    if (taskDeliveryPath(task) === "integrated") {
+    if (proof.reviewRoundId !== undefined) {
         const latestReview = latestTaskFinalReview(store, task.id);
         if (latestReview === undefined
             || latestReview.id !== proof.reviewRoundId
@@ -132,8 +133,8 @@ export function assertTaskCompletionPublishedTreeProof(store, task, publicationI
             throw usageError(`Task-final Review evidence changed before published-tree completion: ${task.id}.`);
         }
     }
-    else if (proof.reviewRoundId !== undefined) {
-        throw usageError(`Direct published-tree proof unexpectedly binds a final Review: ${task.id}.`);
+    else if (latestTaskFinalReview(store, task.id) !== undefined) {
+        throw usageError(`Published-tree proof omitted the Task-final Review: ${task.id}.`);
     }
     const actualCommit = actualCandidate.projects.find(({ projectId }) => (projectId === proof.projectId))?.commit;
     if (actualCommit !== proof.localCommit) {
@@ -183,8 +184,10 @@ export async function reconcileTaskRemoteBaselines(taskId, store, home, options
     // The delivery contract opts Project-backed Tasks into committed
     // Integration evidence.  Metadata-only Tasks retain their existing local
     // completion semantics and have no remote baseline to reconcile here.
-    if (task.projectBindings.length === 0 || task.requireIntegration !== true)
+    if (task.projectBindings.length === 0
+        || !store.listIntegrationAttempts(task.id).some(({ status }) => status === "committed")) {
         return [];
+    }
     const workspace = requireTaskWorkspace(store, task);
     const git = options.git ?? new NodeGitWorkspace();
     if (git.fetchRemoteHeadIntoWorktree === undefined

package/dist/commands/taskContextCommand.js

@@ -4,7 +4,6 @@ import { formatTimestamp } from "../output/timePresentation.js";
 import { isRoleRunStalled, latestStallProgressAt } from "../scheduler/roleRunStall.js";
 import { buildTaskExecutionProjection } from "../scheduler/taskExecutionProjection.js";
 import { projectNextAction } from "../task/nextAction.js";
-import { taskDeliveryPath } from "../task/task.js";
 import { inspectTaskRoleSessionRecovery } from "./taskRoleRuntimeStatus.js";
 import { summarizeExecutionGroup } from "../execution/executionGroup.js";
 import { currentWorkItemExecutionGroup } from "../workItem/workItem.js";
@@ -54,7 +53,6 @@ export function runTaskContextCommand(args, store) {
         }
         return {
             task,
-            deliveryPath: taskDeliveryPath(task),
             execution,
             reviewConfig: reader.getReviewConfig(),
             brief: reader.getTaskBrief(task.id),
@@ -141,12 +139,15 @@ export function runTaskContextCommand(args, store) {
         ...(managedWorkspaces.length === 0
             ? ["  None."]
             : managedWorkspaces.map((workspace) => (`  ${managedWorkspaceLabel(workspace)}: ${workspace.root} (${workspace.entries.filter(({ access }) => access === "write").length} writable / ${workspace.entries.length} Projects)`))),
-        `Delivery: ${taskDeliveryPath(task)}`,
-        `Completion evidence: ${task.requireIntegration
-            ? "WorkItem, ChangeSet, and committed Integration required"
-            : task.projectBindings.length > 0
+        `Type: ${task.type ?? "unspecified"}`,
+        `Execution topology: ${workItems.length === 0
+            ? "Leader-owned Task main"
+            : `${workItems.length} independently owned WorkItem(s), integrated on Task main`}`,
+        `Completion evidence: ${task.projectBindings.length === 0
+            ? "no Project evidence required"
+            : workItems.length === 0
                 ? "clean committed Task main required"
-                : "no Project evidence required"}`,
+                : "each delivered WorkItem requires a ChangeSet and committed Integration"}`,
         `Global review: ${reviewConfig === null
             ? "disabled"
             : `${reviewConfig.roleName} (${reviewConfig.trigger})`}`,
@@ -259,10 +260,13 @@ export function runTaskContextCommand(args, store) {
                                 ? []
                                 : [`      Summary: ${compactText(latestRun.summary)}`])
                         ]),
-                    ...renderWorkItemReviews(reviewRounds.filter((round) => round.workItemId === item.id))
+                    ...renderReviewRounds(reviewRounds.filter((round) => round.workItemId === item.id))
                 ];
             })),
         "",
+        "Task-final reviews:",
+        ...renderReviewRounds(reviewRounds.filter((round) => (round.scope ?? "work-item") === "task")),
+        "",
         ...recentSection("AgentRuns", agentRuns, (run) => [
             `  ${run.id} [${run.status}/${run.purpose}] ${run.roleName} via ${run.effective.agentId}/${run.effective.adapterId}`,
             `    Effective: r${run.effective.sourceDesiredRevision}; Profile intent: ${run.effective.profileAccess}; permission: ${run.effective.permission.strategy}; model: ${run.effective.model ?? "default"}; effort: ${run.effective.effort ?? "default"}`,
@@ -358,16 +362,19 @@ function latestStallKind(events, runId) {
         .sort((left, right) => Date.parse(right.createdAt) - Date.parse(left.createdAt))[0];
     return event?.payload.kind ?? "workflow-not-progressing";
 }
-function renderWorkItemReviews(rounds) {
+function renderReviewRounds(rounds) {
     const latest = rounds.at(-1);
     if (latest === undefined)
         return ["    ReviewRounds: none."];
+    const target = (latest.scope ?? "work-item") === "task"
+        ? "frozen Task candidate"
+        : `Candidate ${latest.candidateId ?? "unavailable"}`;
     return [
-        `    ReviewRounds: ${rounds.length}; latest ${latest.id} [${latest.status}] ${latest.scope === "task" ? "Task-final" : "WorkItem"} for ${latest.candidateId} via ${latest.reviewerRoleName} (${latest.requestedBy})`,
+        `    ReviewRounds: ${rounds.length}; latest ${latest.id} [${latest.status}] ${latest.scope === "task" ? "Task-final" : "WorkItem"} for ${target} via ${latest.reviewerRoleName} (${latest.requestedBy})`,
         `      Review base: ${latest.reviewBaseCommit}`,
         ...(latest.scope === "task"
             ? [
-                `      Frozen integrated Task heads: ${latest.taskCandidate?.projects
+                `      Frozen Task heads: ${latest.taskCandidate?.projects
                     .map(({ projectId, commit }) => `${projectId}@${commit}`).join(", ") ?? "unavailable"}`,
                 `      Task-final contract: ${latest.taskFinalReviewContract?.digest ?? "global policy"}`,
                 ...(latest.deltaRecheck === undefined

package/dist/commands/taskNextActionCommand.js

@@ -2,7 +2,6 @@ import { taskNotFound, usageError } from "../errors/cliError.js";
 import { projectNextAction } from "../task/nextAction.js";
 import { projectCompletionReadiness } from "../task/completionReadiness.js";
 import { extractReviewFindings, planRepairWave } from "../task/repairWave.js";
-import { taskDeliveryPath } from "../task/task.js";
 import { projectTaskOrchestration } from "../observability/orchestrationMetrics.js";
 import { operationalTaskRecords } from "../task/taskRecordRetirement.js";
 /**
@@ -75,7 +74,7 @@ export function runTaskNextActionCommand(args, store) {
             managedWorkspaces: reader.listManagedWorkspaces(taskId)
         });
         return {
-            deliveryPath: taskDeliveryPath(facts.task),
+            taskType: facts.task.type ?? null,
             action,
             repairWave,
             completionReadiness,
@@ -92,7 +91,7 @@ export function runTaskNextActionCommand(args, store) {
     }
     return {
         kind: "output",
-        output: renderNextAction(data.action, data.deliveryPath, data.repairWave, data.completionReadiness, data.knowledgeProposals, data.orchestration.advisories),
+        output: renderNextAction(data.action, data.taskType, data.repairWave, data.completionReadiness, data.knowledgeProposals, data.orchestration.advisories),
         data
     };
 }
@@ -110,10 +109,10 @@ function repairWaveFor(action, facts) {
         return null;
     return planRepairWave(round.id, findings);
 }
-function renderNextAction(action, deliveryPath, repairWave, completionReadiness, knowledgeProposals, orchestrationAdvisories) {
+function renderNextAction(action, taskType, repairWave, completionReadiness, knowledgeProposals, orchestrationAdvisories) {
     const lines = [
         `Task: ${action.taskId}`,
-        `Delivery: ${deliveryPath}`,
+        `Type: ${taskType ?? "unspecified"}`,
         `Next action: ${action.kind}`,
         `Reason: ${action.reason}`,
         ...(action.refs.length === 0

package/dist/commands/taskWorkspaceCommands.js

@@ -119,8 +119,8 @@ function replaceTaskCommand(args, store, options) {
         createArgs.push("--project", binding.projectId);
         createArgs.push("--base", `${binding.projectId}=${binding.baseRef}`);
     }
-    if (old.requireIntegration)
-        createArgs.push("--require-integration");
+    if (old.type !== undefined)
+        createArgs.push("--type", old.type);
     const created = runTaskCommand(createArgs, store);
     if (created.kind !== "output") {
         throw new Error(`Task replacement could not be created for ${old.id}.`);

package/dist/controller/clientRuntime.js

@@ -1,9 +1,11 @@
 import { spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { callController, readControllerDiscovery, stopOrphanedFileTaskController, stopPreviousFileTaskController } from "../core/controllerClient.js";
+import { controllerSocketPath } from "../core/controllerEndpoint.js";
 import { FILE_TASK_CONTROLLER_PROTOCOL_VERSION } from "../core/protocol.js";
 import { AGENT_OPERATIONAL_ENVIRONMENT_NAMES, nativeAgentEnvironmentNames, operationalAgentEnvironment, selectEnvironment, YUI_MANAGED_RUNTIME_ENVIRONMENT_NAMES } from "../agent/launchEnvironment.js";
 import { openCompatibleFileTaskStore } from "../storage/compatibleTaskStore.js";
+import { yuiTmuxServerName } from "../tmux/tmuxManager.js";
 import { hasRuntimeLifecycleWork } from "../runtime/lifecycleReservation.js";
 import { assertControllerStatusIdentity } from "../runtime/exactControlPlane.js";
 import { EPHEMERAL_DOMAIN_ENVIRONMENT_NAMES } from "./domainIdentity.js";
@@ -11,6 +13,7 @@ import { yuiVersionIdentity } from "../version.js";
 import { SessionOwnerReconciliation } from "./sessionOwnerReconciliation.js";
 import { WorkspaceCleanupBlockedError } from "../repository/taskWorkspacePreparer.js";
 import { CONTROLLER_SHUTDOWN_TIMEOUT_MS, LIFECYCLE_REQUEST_TIMEOUT_MS } from "../runtime/runtimeDeadlines.js";
+import { FileTaskRuntimeIsolation } from "../runtime/taskRuntimeIsolation.js";
 const STARTUP_TIMEOUT_MS = 5_000;
 const POLL_INTERVAL_MS = 50;
 const ENVIRONMENT_REFRESH_TIMEOUT_MS = 500;
@@ -502,6 +505,63 @@ export class FileTaskWorkflowRuntime {
             throw new Error(`Global Role runtime session is still active: ${roleName}.`);
         }
     }
+    /** Drain pending runtime facts while an external maintenance fence is held. */
+    async drainController() {
+        await ensureFileTaskController(this.home, {
+            environment: this.clientOptions.environment
+        });
+        await callFileTaskController(this.home, "scheduler.scan", {}, {
+            ...this.clientOptions,
+            requestTimeoutMs: LIFECYCLE_REQUEST_TIMEOUT_MS
+        });
+    }
+    /**
+     * Maintenance-only exact stop used after the Controller has fully exited.
+     * The dormant candidate fences the durable cleanup request; physical owner
+     * records and Task runtime isolation are cleared through the same primitives
+     * as the Controller lifecycle path before the Session becomes stopped.
+     */
+    async stopDormantSession(candidate) {
+        const queuedAt = new Date();
+        const target = this.schedulerStore.enqueueRuntimeCleanup(candidate.owner, queuedAt, candidate);
+        if (target === null) {
+            throw new Error(`Dormant Session changed before maintenance cleanup: ${runtimeOwnerLabel(candidate.owner)}.`);
+        }
+        const reconciliation = new SessionOwnerReconciliation({
+            home: this.home,
+            store: this.store,
+            environment: this.clientOptions.environment,
+            tmux: this.tmux
+        });
+        const termination = await reconciliation.terminateOwner(candidate.owner);
+        if (termination.outcome !== "stop-confirmed") {
+            throw new Error(`Role runtime cleanup could not prove physical exit: ${runtimeOwnerLabel(candidate.owner)}; `
+                + termination.remaining
+                    .map(({ record, detail }) => `${record.launchId}: ${detail}`)
+                    .join("; "));
+        }
+        if (candidate.owner.scope === "task" && candidate.launchId !== undefined) {
+            const isolation = new FileTaskRuntimeIsolation({
+                runtimeRoot: `${this.home}.task-runtimes`,
+                controlPlane: {
+                    yuiHome: this.home,
+                    controllerSocketPath: controllerSocketPath(this.store.getHomeIdentity().homeId),
+                    tmuxNamespace: yuiTmuxServerName(this.home),
+                    globalInstallPaths: [process.execPath]
+                }
+            });
+            isolation.cleanupTaskLaunch({
+                taskId: candidate.owner.taskId,
+                launchId: candidate.launchId,
+                reason: this.store.getTask(candidate.owner.taskId)?.status === "completed"
+                    ? "completion"
+                    : "interruption"
+            });
+        }
+        if (!this.schedulerStore.completeRuntimeCleanup(target, new Date())) {
+            throw new Error(`Role runtime cleanup state changed before completion: ${runtimeOwnerLabel(candidate.owner)}.`);
+        }
+    }
     inspectTaskRolePanes(taskId) {
         return this.tmux.inspectTaskRolePanes(taskId);
     }
@@ -532,6 +592,11 @@ export class FileTaskWorkflowRuntime {
         });
     }
 }
+function runtimeOwnerLabel(owner) {
+    return owner.scope === "task"
+        ? `${owner.taskId}/${owner.roleName}`
+        : `global/${owner.roleName}`;
+}
 const MANAGED_RUNTIME_ENVIRONMENT = new Set(YUI_MANAGED_RUNTIME_ENVIRONMENT_NAMES);
 function foregroundGlobalRoleEnvironment(store, roleName, source) {
     const role = store.getGlobalRole?.(roleName);

package/dist/controller/fileSchedulerStoreAdapter.js

@@ -3,7 +3,6 @@ import { isDeepStrictEqual } from "node:util";
 import { activeLiveRoleAgentSession, bindTaskRoleProviderRuntime, bindTaskRoleRun, clearTaskRoleProviderRuntimeForCleanup, clearTaskRoleRun, createRoleSessionSet, markTaskRoleRunDelivered, markTaskRoleRunPushed, prepareTaskRoleRunRedispatch, recordRoleAgentSession, recordTaskRoleTurnBoundary, rememberRoleAgentCompletedTurn, updateRoleAgentSessionStatus, updateTaskRoleProviderRuntime } from "../executor/agentExecutor.js";
 import { acceptProviderTurn, beginProviderTurn, createProviderRuntimeBinding, endProviderActivation, currentProviderActivation, currentProviderConversation, markProviderTurnDeliveryUnknown, rejectProviderTurn, settleProviderTurn, startProviderActivation, supersedeProviderConversation, updateProviderConversationRecoverability } from "../runtime/providerRuntimeIdentity.js";
 import { decideProviderRecovery } from "../runtime/providerRecoveryDecision.js";
-import { boundProviderRetryBeforeFirstProgress, projectFirstProgressStopLoss } from "../runtime/firstProgressStopLoss.js";
 import { hasRecentTurnId } from "../executor/turnCompletion.js";
 import { createTaskEvent } from "../event/taskEvent.js";
 import { operationalTaskRecords } from "../task/taskRecordRetirement.js";
@@ -1300,40 +1299,6 @@ export class FileSchedulerStoreAdapter {
     clearPendingWakeup(taskId) { this.store.clearPendingWakeup(taskId); }
     getLeaderFailure(taskId) { return this.store.getLeaderFailure(taskId); }
     getOperatorNotification(taskId) { return this.store.getOperatorNotification(taskId); }
-    saveLeaderFirstProgressStopLoss(input) {
-        return this.store.transaction((store) => {
-            const task = store.getTask(input.taskId);
-            const role = store.getRole(input.taskId, input.roleName);
-            if (task === null || task.status !== "active" || role === null
-                || store.getLeaderFailure(input.taskId) !== null) {
-                return "state-changed";
-            }
-            const stopLoss = projectFirstProgressStopLoss({
-                sessions: store.getTaskRoleSessionSet(input.taskId, input.roleName),
-                events: store.listEvents(input.taskId),
-                workItems: store.listWorkItems(input.taskId),
-                reviewRounds: store.listReviewRounds(input.taskId),
-                integrations: store.listIntegrationAttempts(input.taskId)
-            });
-            if (!stopLoss.exhausted || stopLoss.fingerprint !== input.expectedFingerprint) {
-                return "state-changed";
-            }
-            const sessions = store.getTaskRoleSessionSet(input.taskId, input.roleName);
-            const lastSession = sessions === null
-                ? undefined
-                : [...(sessions.history ?? []), ...Object.values(sessions.sessions)]
-                    .sort((left, right) => left.createdAt.localeCompare(right.createdAt))
-                    .at(-1);
-            const message = `Leader first-progress stop-loss: ${stopLoss.reason}`;
-            store.saveRole(input.taskId, updateRoleStatus(role, "failed", input.now));
-            store.saveLeaderFailure(recordLeaderFailure(input.taskId, lastSession?.nativeSessionId ?? "(unregistered)", message, input.now, null));
-            store.saveOperatorNotification(createLeaderRecoveryNotification(input.taskId, message, input.now, store.getOperatorNotification(input.taskId)));
-            enqueueWork(store, { kind: "operator" }, "leader-first-progress-stop-loss", input.now, [
-                { type: "task", id: input.taskId }
-            ]);
-            return "recorded";
-        });
-    }
     saveLeaderDispatch(input) {
         return this.store.transaction((store) => {
             const task = store.getTask(input.task.id);
@@ -2287,7 +2252,7 @@ export class FileSchedulerStoreAdapter {
             failedNativeTurnId: input.nativeTurnId,
             lastErrorSummary: summary,
             ...(input.retryAfterMs === undefined ? {} : { retryAfterMs: input.retryAfterMs })
-        }, now, configuredProviderRetryPolicy(store, input.taskId, input.roleName));
+        }, now, configuredProviderRetryPolicy(store));
         if (retryDecision.outcome === "exhausted") {
             this.recordProviderRetryClassified(store, input, classification.errorClass, {
                 wouldRetry: "false",
@@ -4069,19 +4034,7 @@ function compareCanonicalObservationOrder(left, right) {
         || (left.ordinal ?? -1) - (right.ordinal ?? -1)
         || left.eventId.localeCompare(right.eventId);
 }
-function configuredProviderRetryPolicy(store, taskId, roleName) {
+function configuredProviderRetryPolicy(store) {
     const config = providerRetryConfig(store.getConfig());
-    if (taskId !== undefined && roleName === "leader") {
-        const progress = projectFirstProgressStopLoss({
-            sessions: store.getTaskRoleSessionSet(taskId, roleName),
-            events: store.listEvents(taskId),
-            workItems: store.listWorkItems(taskId),
-            reviewRounds: store.listReviewRounds(taskId),
-            integrations: store.listIntegrationAttempts(taskId)
-        });
-        if (progress.firstProgressAt === undefined) {
-            return boundProviderRetryBeforeFirstProgress(config, progress);
-        }
-    }
     return { delaysMs: config.delaysMs, maxWindowMs: config.maxWindowMs };
 }

package/dist/doctor/doctor.js

@@ -4,7 +4,7 @@ import Database from "better-sqlite3";
 import { configuredAgentToDefinition, resolveAgentEnvironment } from "../agent/agent.js";
 import { operationalAgentEnvironment } from "../agent/launchEnvironment.js";
 import { inspectAgentCapabilities, resolveAgentAdapter } from "../executor/agentAdapter.js";
-import { inspectCodexLaunchConfig } from "../executor/codexConfigConflict.js";
+import { assertCodexLaunchOverridesAvailable, inspectCodexLaunchConfig } from "../executor/codexConfigConflict.js";
 import { nativeAdditionalDirectories, nativeAgentWorkspace, withNativeProjectDirectories } from "../executor/fileRoleLaunchPlanner.js";
 import { resolveEffectiveLaunch } from "../executor/effectiveLaunch.js";
 import { compileRoleSessionContext } from "../context/roleSessionContext.js";
@@ -789,14 +789,8 @@ function checkReviewerLaunch(agent, role, binding, adapter, environment, home) {
                 trustWorkspace: true
             })
             : undefined;
-        if (codexConfig?.notify.status === "configured") {
-            return {
-                name: "reviewer launch",
-                status: "invalid",
-                detail: "Codex notify is already configured by "
-                    + `${codexConfig.notify.source}; Yui requires exclusive ownership of the structured `
-                    + "notify callback and refuses to replace or be replaced by native configuration."
-            };
+        if (codexConfig !== undefined) {
+            assertCodexLaunchOverridesAvailable(codexConfig, ["developerInstructions", "notify"]);
         }
         const reviewerContext = adapter.id === "codex"
             ? compileRoleSessionContext(home, role, { scope: "global" }, { purpose: "review" })
@@ -810,8 +804,7 @@ function checkReviewerLaunch(agent, role, binding, adapter, environment, home) {
                 ? {}
                 : {
                     developerInstructions: reviewerContext.developerInstructions,
-                    skills: reviewerContext.skills,
-                    codexDeveloperInstructions: codexConfig?.developerInstructions
+                    skills: reviewerContext.skills
                 })
         });
         if (compiled.argv.length === 0)
@@ -819,7 +812,18 @@ function checkReviewerLaunch(agent, role, binding, adapter, environment, home) {
         return {
             name: "reviewer launch",
             status: "ok",
-            detail: `adapter=${adapter.id} strategy=${compiled.sessionStrategy} command=${agent.command} addDirs=${launchConfig.additionalDirectories?.length ?? 0}`
+            detail: [
+                `adapter=${adapter.id}`,
+                `strategy=${compiled.sessionStrategy}`,
+                `command=${agent.command}`,
+                `addDirs=${launchConfig.additionalDirectories?.length ?? 0}`,
+                ...(codexConfig?.developerInstructions.status === "configured"
+                    ? [`override=developer_instructions@${codexConfig.developerInstructions.source}`]
+                    : []),
+                ...(codexConfig?.notify.status === "configured"
+                    ? [`override=notify@${codexConfig.notify.source}`]
+                    : [])
+            ].join(" ")
         };
     }
     catch (error) {

package/dist/execution/executionGroup.js

@@ -435,9 +435,6 @@ export function validateExecutionTarget(target, taskId) {
     if (target.kind === "work-item" && target.workItemId === undefined) {
         throw new Error("WorkItem ExecutionTarget requires a Work Item id.");
     }
-    if (target.kind === "task-final-review" && target.candidateId === undefined) {
-        throw new Error("Task-final ExecutionTarget requires a Candidate id.");
-    }
     if (target.workItemId !== undefined)
         requireIdentity(target.workItemId, "Work Item id");
     if (target.candidateId !== undefined)

package/dist/executor/agentAdapter.js

@@ -4,7 +4,6 @@ import { isAbsolute, resolve } from "node:path";
 import { supportedAgentAdapterIds } from "../agent/adapterCatalog.js";
 import { ownedArgumentsForAdapter, validateAgentAdvancedArguments, validateAgentBaseArguments } from "../agent/argumentPolicy.js";
 import { writeTextFileAtomically } from "../storage/durableFile.js";
-import { inspectCodexDeveloperInstructions } from "./codexConfigConflict.js";
 import { discoverClaudeConfiguration, discoverCodexConfiguration } from "./agentConfigurationProbe.js";
 import { builtinAgentDriverRegistry } from "../runtime/builtinAgentDrivers.js";
 const SANDBOXES = ["read-only", "workspace-write", "danger-full-access"];
@@ -139,16 +138,6 @@ class CodexAdapter extends BaseAdapter {
         ];
         if (instructions.length === 0)
             return workspaceTrust;
-        const nativeInstructions = input.codexDeveloperInstructions
-            ?? inspectCodexDeveloperInstructions({
-                workspace: input.workspace,
-                profile: input.config.profile,
-                trustWorkspace: true
-            });
-        if (nativeInstructions.status === "configured") {
-            throw new Error("Codex developer_instructions is already configured by "
-                + `${nativeInstructions.source}; Yui refuses to replace native developer instructions.`);
-        }
         return [
             ...workspaceTrust,
             "--config",
@@ -375,37 +364,33 @@ export function inspectAgentCapabilities(agent, optionsOrNow = {}) {
     if (!supported) {
         return snapshot(agent, adapter, {
             status: "unsupported-version", command: agent.command, version,
-            reason: adapter.id === "codex"
-                ? `Minimum supported version is ${adapter.supportedVersion}.`
-                : `Supported version line starts at ${adapter.supportedVersion}.`,
+            reason: `Minimum supported version is ${adapter.supportedVersion}.`,
             probedAt: at
         }, fields, at, [`Installed version ${version} is not supported by adapter ${adapter.id}.`]);
     }
     const help = run(agent.command, ["--help"]);
     const helpFailure = failed(help);
-    if (adapter.id === "codex" && helpFailure !== undefined) {
+    if (helpFailure !== undefined) {
         return snapshot(agent, adapter, {
             status: "probe-failed", command: agent.command, version,
-            reason: `Required Codex capability probe failed: ${helpFailure}`, probedAt: at
+            reason: `Required ${adapter.label} capability probe failed: ${helpFailure}`,
+            probedAt: at
         }, fields, at);
     }
-    if (helpFailure === undefined) {
-        const helpOutput = output(help.stdout, help.stderr);
-        fields = fromHelp(agent.adapterId, helpOutput);
-        if (adapter.id === "codex") {
-            const missing = missingCodexCapabilities(helpOutput);
-            if (missing.length > 0) {
-                return snapshot(agent, adapter, {
-                    status: "unsupported-version", command: agent.command, version,
-                    reason: `Codex CLI is missing required capabilities: ${missing.join(", ")}.`,
-                    probedAt: at
-                }, fields, at);
-            }
-            if (compareVersions(version, CODEX_TESTED_THROUGH_VERSION) > 0) {
-                warnings.push(`Installed Codex version ${version} is newer than the latest tested version `
-                    + `${CODEX_TESTED_THROUGH_VERSION}; required capabilities were detected.`);
-            }
-        }
+    const helpOutput = output(help.stdout, help.stderr);
+    fields = fromHelp(agent.adapterId, helpOutput);
+    const missing = missingRequiredCapabilities(adapter.id, helpOutput);
+    if (missing.length > 0) {
+        return snapshot(agent, adapter, {
+            status: "unsupported-version", command: agent.command, version,
+            reason: `${adapter.label} CLI is missing required capabilities: ${missing.join(", ")}.`,
+            probedAt: at
+        }, fields, at);
+    }
+    if (adapter.id === "codex"
+        && compareVersions(version, CODEX_TESTED_THROUGH_VERSION) > 0) {
+        warnings.push(`Installed Codex version ${version} is newer than the latest tested version `
+            + `${CODEX_TESTED_THROUGH_VERSION}; required capabilities were detected.`);
     }
     return snapshot(agent, adapter, {
         status: "installed", command: agent.command, version, probedAt: at
@@ -498,10 +483,7 @@ function output(stdout, stderr) {
     return value;
 }
 function supports(version, adapter) {
-    if (adapter.id === "codex")
-        return compareVersions(version, adapter.supportedVersion) >= 0;
-    const left = version.split(".").map(Number), right = adapter.supportedVersion.split(".").map(Number);
-    return left[0] === right[0] && left[1] === right[1] && left[2] >= right[2];
+    return compareVersions(version, adapter.supportedVersion) >= 0;
 }
 function compareVersions(leftVersion, rightVersion) {
     const left = leftVersion.split(".").map(Number);
@@ -513,11 +495,26 @@ function compareVersions(leftVersion, rightVersion) {
     }
     return 0;
 }
-function missingCodexCapabilities(help) {
-    const required = [
-        [/(?:^|\s)--config(?:\s|[=<,]|$)/m, "--config"],
-        [/^\s*resume(?:\s|$)/m, "resume"]
-    ];
+function missingRequiredCapabilities(id, help) {
+    const required = id === "codex"
+        ? [
+            [/(?:^|\s)--config(?:\s|[=<,]|$)/m, "--config"],
+            [/^\s*resume(?:\s|$)/m, "resume"]
+        ]
+        : [
+            [/(?:^|\s)--append-system-prompt(?:-file|\[-file\])(?:\s|[=<,]|$)/m,
+                "--append-system-prompt-file"],
+            [/(?:^|\s)--resume(?:\s|[=<,]|$)/m, "--resume"],
+            [/(?:^|\s)--session-id(?:\s|[=<,]|$)/m, "--session-id"],
+            [/(?:^|\s)-p(?:\s|[=<,]|$)/m, "-p"],
+            [/(?:^|\s)--output-format(?:\s|[=<,]|$)/m, "--output-format"],
+            [/(?:^|\s)--input-format(?:\s|[=<,]|$)/m, "--input-format"],
+            [/(?:^|\s)--verbose(?:\s|[=<,]|$)/m, "--verbose"],
+            [/(?:^|\s)--replay-user-messages(?:\s|[=<,]|$)/m,
+                "--replay-user-messages"],
+            [/(?:^|\s)--plugin-dir(?:\s|[=<,]|$)/m, "--plugin-dir"],
+            [/(?:^|\s)--name(?:\s|[=<,]|$)/m, "--name"]
+        ];
     return required.flatMap(([pattern, label]) => pattern.test(help) ? [] : [label]);
 }
 function cloneConfig(config, paths) {

package/dist/executor/agentExecutor.js

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import { hasRecentTurnId, rememberRecentTurnId, validatePendingTurnCompletion, validateRecentTurnIds } from "./turnCompletion.js";
-import { effectiveLaunchSnapshotsCompatible, effectiveLaunchSnapshotsCompatibleForTaskMain, validateEffectiveLaunchSnapshot } from "./effectiveLaunch.js";
+import { effectiveLaunchSnapshotsCompatible, effectiveLaunchSnapshotsCompatibleForTaskMain, effectiveLaunchSnapshotsCompatibleForTaskReview, validateEffectiveLaunchSnapshot } from "./effectiveLaunch.js";
 import { rebindProviderRuntimeRun, validateProviderRuntimeBinding } from "../runtime/providerRuntimeIdentity.js";
 import { builtinDriverIdForAdapter } from "../runtime/builtinAgentDrivers.js";
 export function createRoleSessionSet(owner, activeAgentId, now) {
@@ -67,7 +67,9 @@ export function recordRoleAgentSession(set, input, now) {
         throw new Error(`Role Agent session effective identity is inconsistent: ${agentId}.`);
     }
     if (existing !== undefined && existing.nativeSessionId === nativeSessionId
-        && !effectiveLaunchSnapshotsCompatible(existing.effective, effective)) {
+        && !effectiveLaunchSnapshotsCompatible(existing.effective, effective)
+        && !(set.owner.scope === "task"
+            && effectiveLaunchSnapshotsCompatibleForTaskReview(existing.effective, effective))) {
         throw new Error(`Role Agent session effective launch cannot change: ${agentId}.`);
     }
     if (existing !== undefined && existing.nativeSessionId !== nativeSessionId