@zq-silk/yui 0.9.0 → 0.10.1

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/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/codexConfigConflict.js

@@ -4,15 +4,14 @@ import { homedir } from "node:os";
 import { basename, dirname, isAbsolute, join, resolve, sep } from "node:path";
 import { parse } from "smol-toml";
 /**
- * Inspects the local, file-backed Codex configuration layers supported by Yui
- * that can conflict with launch-owned settings. Remote and platform-managed
- * layers are outside this compatibility boundary. Project files are considered
- * only when the directory, project root, or project root is trusted.
+ * Reports the local, file-backed Codex configuration layers supported by Yui.
+ * Yui's invocation-local launch settings take precedence over ordinary local
+ * layers without mutating those files. Higher-precedence managed policy is
+ * reported separately because an invocation cannot override it. Remote
+ * managed layers remain outside this reporting boundary. Project files are
+ * considered only when the directory, project root, or repository root is
+ * trusted.
  */
-export function inspectCodexDeveloperInstructions(input) {
-    return inspectCodexConfigKeys(input, ["developer_instructions"])
-        .developerInstructions;
-}
 export function inspectCodexLaunchConfig(input) {
     return inspectCodexConfigKeys(input, ["developer_instructions", "notify"]);
 }
@@ -49,12 +48,17 @@ function inspectCodexConfigKeys(input, keys) {
         ? withExactWorkspaceTrust(discovery, input.workspace)
         : discovery);
     const candidates = [
-        ...discoveryPaths.map((path) => ({ path, keys })),
+        ...discoveryPaths.map((path) => ({
+            path,
+            keys,
+            precedence: "session-overridable"
+        })),
         ...projectPaths.map((path) => ({
             path,
-            keys: keys.filter((key) => key === "developer_instructions")
+            keys: keys.filter((key) => key === "developer_instructions"),
+            precedence: "session-overridable"
         })),
-        { path: managedPath, keys }
+        { path: managedPath, keys, precedence: "managed" }
     ];
     let developerInstructions = { status: "absent" };
     let notify = { status: "absent" };
@@ -71,16 +75,36 @@ function inspectCodexConfigKeys(input, keys) {
         catch (error) {
             throw unreliableInspection(candidate.path, error);
         }
-        if (developerInstructions.status === "absent"
-            && configured.has("developer_instructions")) {
-            developerInstructions = { status: "configured", source: candidate.path };
+        if (configured.has("developer_instructions")) {
+            developerInstructions = {
+                status: "configured",
+                source: candidate.path,
+                precedence: candidate.precedence
+            };
         }
-        if (notify.status === "absent" && configured.has("notify")) {
-            notify = { status: "configured", source: candidate.path };
+        if (configured.has("notify")) {
+            notify = {
+                status: "configured",
+                source: candidate.path,
+                precedence: candidate.precedence
+            };
         }
     }
     return { developerInstructions, notify };
 }
+export function assertCodexLaunchOverridesAvailable(inspection, keys) {
+    for (const key of keys) {
+        const configured = inspection[key];
+        if (configured.status !== "configured" || configured.precedence !== "managed") {
+            continue;
+        }
+        const nativeKey = key === "developerInstructions"
+            ? "developer_instructions"
+            : "notify";
+        throw new Error(`Codex ${nativeKey} is controlled by higher-precedence managed configuration at `
+            + `${configured.source}; Yui cannot apply its invocation-local ${nativeKey} value.`);
+    }
+}
 function withExactWorkspaceTrust(discovery, workspace) {
     return {
         ...discovery,

package/dist/executor/fileRoleLaunchPlanner.js

@@ -13,7 +13,6 @@ import { serializeRunBootstrapEnvelope, serializeRunHostRecoveryEnvelope } from
 import { serializeProviderRetryEnvelope } from "../run/providerRetry.js";
 import { prefixYuiTitleInput } from "../run/runIdentity.js";
 import { resolveAgentAdapter } from "./agentAdapter.js";
-import { inspectCodexLaunchConfig } from "./codexConfigConflict.js";
 import { resolveTaskRoleSessionTitle } from "../runtime/sessionTitle.js";
 import { nativeSessionIdForLaunch } from "../runtime/preallocatedNativeSession.js";
 import { isTaskOwnedWorkspace } from "../worktree/managedWorkspace.js";
@@ -26,6 +25,7 @@ import { ResourceRegistrar } from "../resources/resourceRegistrar.js";
 import { builtinAgentDriverRegistry, builtinDriverIdForAdapter } from "../runtime/builtinAgentDrivers.js";
 import { managedRuntimeAdmission } from "../runtime/agentDriver.js";
 import { formatAgentRunReceiptId } from "../task/taskRecordReference.js";
+import { assertCodexLaunchOverridesAvailable, inspectCodexLaunchConfig } from "./codexConfigConflict.js";
 /** Builds managed native Agent launches from the authoritative Task records. */
 export class FileRoleLaunchPlanner {
     home;
@@ -274,6 +274,19 @@ export class FileRoleLaunchPlanner {
         const adapter = resolveAgentAdapter(binding.adapterId);
         const effectiveWorkspace = effective.workspace.root;
         const agentWorkspace = nativeAgentWorkspace(effective.workspace);
+        if (adapter.id === "codex") {
+            const codexConfig = inspectCodexLaunchConfig({
+                environment: launchEnvironment,
+                workspace: agentWorkspace,
+                profile: binding.config.adapterId === "codex"
+                    ? binding.config.profile
+                    : undefined,
+                trustWorkspace: true
+            });
+            assertCodexLaunchOverridesAvailable(codexConfig, owner.scope !== "task" || input.runId === undefined
+                ? ["developerInstructions", "notify"]
+                : ["developerInstructions"]);
+        }
         const runtimeIsolation = input.runtimeIsolation === undefined
             ? undefined
             : parseTaskRuntimeIsolationDescriptor(JSON.stringify(input.runtimeIsolation));
@@ -309,25 +322,6 @@ export class FileRoleLaunchPlanner {
             sessionManifestDigest: bootstrap.manifest.digest,
             sessionCliPath: bootstrap.sessionCliPath
         };
-        const codexConfig = binding.config.adapterId === "codex"
-            ? inspectCodexLaunchConfig({
-                environment: {
-                    ...operationalSourceEnvironment,
-                    ...agentSourceEnvironment,
-                    ...launchEnvironment
-                },
-                workspace: agentWorkspace,
-                profile: binding.config.profile,
-                trustWorkspace: true
-            })
-            : undefined;
-        if (codexConfig?.notify.status === "configured"
-            && (owner.scope !== "task" || input.runId === undefined)) {
-            throw new Error("Codex notify is already configured by "
-                + `${codexConfig.notify.source}; this interactive Yui Session requires exclusive `
-                + "ownership of the structured notify callback and refuses to replace or be replaced "
-                + "by native configuration.");
-        }
         const managedRun = owner.scope === "task" && input.runId !== undefined
             ? this.store.getAgentRun(owner.taskId, input.runId)
             : null;
@@ -353,10 +347,7 @@ export class FileRoleLaunchPlanner {
             config: effectiveConfig,
             workspace: agentWorkspace,
             ...(sessionTitle === undefined ? {} : { sessionTitle }),
-            ...sessionContext,
-            ...(codexConfig === undefined
-                ? {}
-                : { codexDeveloperInstructions: codexConfig.developerInstructions })
+            ...sessionContext
         };
         if (input.mode === "resume"
             && knownNativeSessionId !== undefined

package/dist/integration/deliveryObligation.js

@@ -0,0 +1,72 @@
+import { governingWorkItemCandidate } from "../workItem/workItem.js";
+/**
+ * Delivery obligations follow the Candidate that currently governs each
+ * WorkItem. Older Candidates and their ChangeSets remain audit evidence, but
+ * they do not keep a Task open after a replacement Candidate is accepted.
+ */
+export function governingChangeSets(workItems, changeSets) {
+    const selected = new Map();
+    for (const item of workItems) {
+        const candidate = governingWorkItemCandidate(item);
+        if (candidate === undefined)
+            continue;
+        for (const changeSet of changeSets) {
+            if (changeSet.workItemId !== item.id)
+                continue;
+            const expectedHead = candidateProjectHead(candidate, changeSet.projectId);
+            if (expectedHead !== undefined && changeSet.headCommit !== expectedHead)
+                continue;
+            const key = `${item.id}\0${changeSet.projectId}`;
+            const current = selected.get(key);
+            if (current === undefined || compareChangeSets(current, changeSet) < 0) {
+                selected.set(key, changeSet);
+            }
+        }
+    }
+    return [...selected.values()].sort(compareChangeSets);
+}
+export function changeSetDeliverySettled(changeSet, integrations, queueEntries = []) {
+    if (integrations.some((attempt) => (attempt.status === "committed" && attempt.changeSetIds.includes(changeSet.id))))
+        return true;
+    const latestQueueEntry = queueEntries
+        .filter((entry) => entry.changeSetId === changeSet.id)
+        .sort(compareQueueEntries)
+        .at(-1);
+    return latestQueueEntry?.status === "superseded";
+}
+export function latestGoverningQueueEntries(changeSets, queueEntries) {
+    const governingIds = new Set(changeSets.map(({ id }) => id));
+    const latest = new Map();
+    for (const entry of queueEntries) {
+        if (!governingIds.has(entry.changeSetId))
+            continue;
+        const current = latest.get(entry.changeSetId);
+        if (current === undefined || compareQueueEntries(current, entry) < 0) {
+            latest.set(entry.changeSetId, entry);
+        }
+    }
+    return [...latest.values()].sort(compareQueueEntries);
+}
+/**
+ * Historical blocked attempts are audit evidence once every ChangeSet they
+ * reference has been replaced by a newer governing Candidate. Attempts that
+ * may still be writing remain blockers regardless of Candidate history.
+ */
+export function integrationAttemptRequiresSettlement(attempt, changeSets) {
+    if (attempt.status === "running" || attempt.status === "validating")
+        return true;
+    const governingIds = new Set(changeSets.map(({ id }) => id));
+    return attempt.changeSetIds.some((id) => governingIds.has(id));
+}
+function candidateProjectHead(candidate, projectId) {
+    return candidate.gitSnapshot?.projects.find((project) => project.projectId === projectId)?.commit
+        ?? candidate.taskMainSnapshot?.projects.find((project) => project.projectId === projectId)?.headCommit;
+}
+function compareChangeSets(left, right) {
+    return left.createdAt.localeCompare(right.createdAt)
+        || left.id.localeCompare(right.id, undefined, { numeric: true });
+}
+function compareQueueEntries(left, right) {
+    return left.updatedAt.localeCompare(right.updatedAt)
+        || left.id.localeCompare(right.id, undefined, { numeric: true });
+}

package/dist/observability/orchestrationMetrics.js

@@ -1,5 +1,5 @@
 import { classifyReviewRoundOutcome } from "../review/reviewOutcomeClassifier.js";
-import { projectFirstProgressStopLoss } from "../runtime/firstProgressStopLoss.js";
+import { projectFirstProgressAdvisory } from "../runtime/firstProgressAdvisory.js";
 /** One Task's orchestration cost and advisory projection, with no writes. */
 export function projectTaskOrchestration(facts) {
     const evidence = {
@@ -35,14 +35,14 @@ export function projectTaskOrchestration(facts) {
     const repeatedIdentities = [...integrationIdentities.values()]
         .reduce((total, count) => total + Math.max(0, count - 1), 0);
     const leaderSessions = facts.roleSessionSets.find(({ owner }) => owner.roleName === "leader") ?? null;
-    const firstProgress = projectFirstProgressStopLoss({
+    const firstProgress = projectFirstProgressAdvisory({
         sessions: leaderSessions,
         events: facts.events,
         workItems: facts.workItems,
         reviewRounds: facts.reviewRounds,
         integrations: facts.integrations
     });
-    const advisories = projectAdvisories(facts, classifications, fullRounds, repeatedIdentities, firstProgress.exhausted);
+    const advisories = projectAdvisories(facts, classifications, fullRounds, repeatedIdentities, firstProgress.attentionRecommended);
     const publicationAt = facts.task.completedAt === undefined
         ? undefined
         : facts.publications
@@ -86,7 +86,7 @@ export function projectTaskOrchestration(facts) {
         advisories
     });
 }
-function projectAdvisories(facts, classifications, fullRounds, repeatedIdentities, stopLoss) {
+function projectAdvisories(facts, classifications, fullRounds, repeatedIdentities, firstProgressAttention) {
     const result = [];
     if (facts.task.type === "bugfix" && facts.workItems.length > 0) {
         result.push({
@@ -136,10 +136,10 @@ function projectAdvisories(facts, classifications, fullRounds, repeatedIdentitie
             refs: recent.map(({ id }) => `review-round:${id}`)
         });
     }
-    if (stopLoss) {
+    if (firstProgressAttention) {
         result.push({
-            code: "provider-first-progress-stop-loss",
-            reason: "Two fresh Leader generations produced no first durable progress; hand off to the unique Operator before another generation.",
+            code: "provider-first-progress-advisory",
+            reason: "Two fresh Leader generations produced no first durable progress; consider Operator attention before another generation.",
             refs: [facts.task.id]
         });
     }

package/dist/repository/taskBaseFreshness.js

@@ -113,23 +113,17 @@ export function assertTaskBaseFreshnessForCompletion(report, options = {}) {
         const acceptedPublishedTree = options.acceptedPublishedTreeProjectId === entry.projectId;
         if ((entry.status === "behind" || entry.status === "diverged")
             && !acceptedPublishedTree) {
-            throw usageError(`Task ${report.taskId} Project ${entry.projectId} base is ${entry.status}; `
-                + `run 'yui task base status ${report.taskId} --refresh' and choose an explicit delivery base. `
-                + "Safe resolutions are to rebase or merge the Task workspace onto the refreshed remote base, "
-                + "create a clean delivery branch from that base and cherry-pick the Task changes, "
-                + "or ask the Leader to resolve it. Continuing without rebasing is allowed only after explicitly "
-                + "recording the unrelated-diff risk.");
+            warnings.push(`Project ${entry.projectId} base is ${entry.status}; the Leader must choose the delivery base `
+                + "and account for any remote-only changes.");
         }
         if (entry.workspaceClean === false) {
             throw usageError(`Task ${report.taskId} Project ${entry.projectId} workspace is dirty; `
                 + "commit, integrate, or clean it before completion.");
         }
         if (entry.status === "unknown") {
-            if (report.refreshed) {
-                throw usageError(`Task ${report.taskId} Project ${entry.projectId} remote base could not be refreshed: `
-                    + `${entry.error ?? "unknown error"}`);
-            }
-            warnings.push(`Project ${entry.projectId} remote base is unknown; local completion continues without a remote claim.`);
+            warnings.push(report.refreshed
+                ? `Project ${entry.projectId} remote base could not be refreshed: ${entry.error ?? "unknown error"}; local completion continues without a remote claim.`
+                : `Project ${entry.projectId} remote base is unknown; local completion continues without a remote claim.`);
         }
     }
     return warnings;

package/dist/role/role.js

@@ -217,20 +217,11 @@ function validateRoleOwner(role) {
     const entries = Object.entries(role.agentBindings);
     if (entries.length === 0)
         throw new Error("Role requires at least one Agent binding.");
-    const operatorAdapters = new Map();
     for (const [agentId, binding] of entries) {
         validateRoleAgentBinding(binding);
         if (agentId !== binding.agentId) {
             throw new Error(`Role Agent binding identity is inconsistent: ${agentId}.`);
         }
-        if (!("taskId" in role) && role.name === "operator") {
-            const existingAgentId = operatorAdapters.get(binding.adapterId);
-            if (existingAgentId !== undefined) {
-                throw new Error("Operator supports one Agent per adapter; "
-                    + `${binding.adapterId} is bound to both ${existingAgentId} and ${agentId}.`);
-            }
-            operatorAdapters.set(binding.adapterId, agentId);
-        }
     }
     if (!Object.hasOwn(role.agentBindings, role.activeAgentId)) {
         throw new Error(`Role active Agent is not bound: ${role.activeAgentId}.`);

package/dist/runtime/{firstProgressStopLoss.js → firstProgressAdvisory.js}

@@ -1,11 +1,4 @@
-import { createHash } from "node:crypto";
-/** One automatic same-Session continuation is allowed before first progress. */
-export function boundProviderRetryBeforeFirstProgress(policy, projection) {
-    return projection.firstProgressAt === undefined
-        ? Object.freeze({ delaysMs: policy.delaysMs.slice(0, 1), maxWindowMs: policy.maxWindowMs })
-        : policy;
-}
-export function projectFirstProgressStopLoss(input) {
+export function projectFirstProgressAdvisory(input) {
     const sessions = input.sessions === null
         ? []
         : [...(input.sessions.history ?? []), ...Object.values(input.sessions.sessions)]
@@ -31,24 +24,17 @@ export function projectFirstProgressStopLoss(input) {
             .sort((left, right) => left.at.localeCompare(right.at) || left.ref.localeCompare(right.ref));
     const firstProgressAt = progress[0]?.at;
     const generationsBeforeFirstProgress = unique.filter((session) => (firstProgressAt === undefined || session.createdAt <= firstProgressAt)).length;
-    const generationRefs = unique.map((session) => (`${session.nativeSessionId}@${session.launchId ?? session.createdAt}`));
-    const progressRefs = progress.map(({ ref }) => ref);
-    const exhausted = firstProgressAt === undefined && generationsBeforeFirstProgress >= 2;
-    const fingerprint = createHash("sha256")
-        .update(JSON.stringify({ generationRefs, progressRefs }))
-        .digest("hex");
+    const attentionRecommended = firstProgressAt === undefined
+        && generationsBeforeFirstProgress >= 2;
     return Object.freeze({
-        exhausted,
+        attentionRecommended,
         generationsBeforeFirstProgress,
         ...(firstGenerationAt === undefined ? {} : { firstGenerationAt }),
         ...(firstProgressAt === undefined ? {} : { firstProgressAt }),
-        generationRefs,
-        progressRefs,
-        fingerprint,
-        reason: exhausted
-            ? `${generationsBeforeFirstProgress} fresh Leader generations produced no first durable progress; stop before creating another generation and hand off to the Operator.`
+        reason: attentionRecommended
+            ? `${generationsBeforeFirstProgress} fresh Leader generations produced no first durable progress; Operator attention may be useful before another generation.`
             : firstProgressAt !== undefined
                 ? `First durable progress was recorded at ${firstProgressAt}.`
-                : `Fewer than two Leader generations exist before first durable progress.`
+                : "Fewer than two Leader generations exist before first durable progress."
     });
 }