@zq-silk/yui 0.6.13 → 0.6.14

package/dist/controller/updateReconciliation.js

@@ -12,7 +12,7 @@ const MAX_RECONCILIATION_PASSES = 4;
  * and inode fingerprints. Agent, tmux, app, and foreign-Home resources are
  * deliberately outside this operation.
  */
-export async function reconcileControllerResourcesForUpdate(home, environment = process.env) {
+export async function reconcileControllerResourcesForUpdate(home, environment = process.env, tmuxBin) {
     const resolvedHome = resolve(home);
     const releaseLock = await acquireHomeLifecycleLock(resolvedHome, {
         removeStaleOwner: true
@@ -23,7 +23,8 @@ export async function reconcileControllerResourcesForUpdate(home, environment =
             const snapshot = await scanControllerResourceInventory({
                 currentHome: resolvedHome,
                 scope: "current",
-                environment
+                environment,
+                ...(tmuxBin === undefined ? {} : { tmuxBin })
             });
             assertCertainSnapshot(snapshot, resolvedHome);
             const resources = controllerResources(snapshot, resolvedHome);
@@ -53,7 +54,7 @@ export async function reconcileControllerResourcesForUpdate(home, environment =
             }
             for (const candidate of candidates) {
                 try {
-                    await cleanControllerResource(candidate, { environment });
+                    await cleanControllerResource(candidate, { environment, ...(tmuxBin === undefined ? {} : { tmuxBin }) });
                     cleaned.add(candidate.id);
                 }
                 catch (error) {

package/dist/doctor/doctor.js

@@ -5,6 +5,7 @@ import { configuredAgentToDefinition, resolveAgentEnvironment } from "../agent/a
 import { operationalAgentEnvironment } from "../agent/launchEnvironment.js";
 import { inspectAgentCapabilities, resolveAgentAdapter } from "../executor/agentAdapter.js";
 import { 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";
 import { usageError } from "../errors/cliError.js";
@@ -15,6 +16,7 @@ import { inspectStorageSchema } from "../storage/storageSchema.js";
 import { resolveTaskStoreBackendForHome } from "../storage/sqliteStore.js";
 import { resolveStoreWorkerEnabledForHome } from "../storage/storeRpc.js";
 import { classifyHome } from "../storage/upgrade/homeClassification.js";
+import { resolveGitBin, resolveTmuxBin } from "../config/yuiConfig.js";
 import { readMigrationReceipt } from "../storage/upgrade/migrationReceipt.js";
 import { latestStorageVersionState } from "../storage/upgrade/recordVersions.js";
 import { COMMITTED_DATABASE_FILENAME } from "../storage/upgrade/sqliteStateMigration.js";
@@ -127,9 +129,10 @@ function inspectDoctor(env, executor, storageOptions = {}) {
     const schemaCheck = checkSchema(schema, compatibility);
     const storage = inspectState(home, homeCheck, schema, compatibility);
     const domain = checkEphemeralDomain(home);
+    const durableConfig = readDurableConfigSafely(home, compatibility.storageOptions);
     const toolChecks = [
-        checkExecutable("git", env.YUI_GIT_BIN ?? "git", ["--version"], executor),
-        checkExecutable("tmux", env.YUI_TMUX_BIN ?? "tmux", ["-V"], executor)
+        checkExecutable("git", durableConfig.gitBin, ["--version"], executor),
+        checkExecutable("tmux", durableConfig.tmuxBin, ["-V"], executor)
     ];
     const agentChecks = storage.agents.flatMap((agent) => checkAgent(agent, executor, env));
     const review = inspectReview({ ...storage.review, home }, agentChecks, env);
@@ -776,9 +779,8 @@ function checkReviewerLaunch(agent, role, binding, adapter, environment, home) {
         const definition = configuredAgentToDefinition(agent);
         const launchEnvironment = resolveDoctorAgentEnvironment(definition, environment);
         const effective = resolveEffectiveLaunch({ role, purpose: "execution" });
-        const agentWorkspace = effective.workspace.entries.length === 1
-            ? effective.workspace.entries[0].path
-            : effective.workspace.root;
+        const agentWorkspace = nativeAgentWorkspace(effective.workspace);
+        const launchConfig = withNativeProjectDirectories(binding.config, nativeAdditionalDirectories(effective.workspace, agentWorkspace));
         const codexConfig = adapter.id === "codex"
             ? inspectCodexLaunchConfig({
                 environment: launchEnvironment,
@@ -801,7 +803,7 @@ function checkReviewerLaunch(agent, role, binding, adapter, environment, home) {
             : undefined;
         const compiled = adapter.compileNew({
             agent: definition,
-            config: binding.config,
+            config: launchConfig,
             workspace: agentWorkspace,
             sessionTitle: "reviewer",
             ...(reviewerContext === undefined
@@ -817,7 +819,7 @@ function checkReviewerLaunch(agent, role, binding, adapter, environment, home) {
         return {
             name: "reviewer launch",
             status: "ok",
-            detail: `adapter=${adapter.id} strategy=${compiled.sessionStrategy} command=${agent.command}`
+            detail: `adapter=${adapter.id} strategy=${compiled.sessionStrategy} command=${agent.command} addDirs=${launchConfig.additionalDirectories?.length ?? 0}`
         };
     }
     catch (error) {
@@ -973,3 +975,20 @@ function systemCode(error) {
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
+/**
+ * Read the durable config for executable paths. Falls back to defaults when
+ * the Home store cannot be opened (the doctor must still run on broken Homes).
+ */
+function readDurableConfigSafely(home, storageOptions) {
+    try {
+        const store = openCompatibleFileTaskStore(home, storageOptions ?? {});
+        const config = store.getConfig();
+        return {
+            tmuxBin: resolveTmuxBin(config.tmuxBin),
+            gitBin: resolveGitBin(config.gitBin)
+        };
+    }
+    catch {
+        return { tmuxBin: "tmux", gitBin: "git" };
+    }
+}

package/dist/executor/agentConfigurationCatalog.js

@@ -156,6 +156,24 @@ export function modelChoice(catalog, value) {
         ? defaultModel(catalog)
         : catalog.models.find((model) => model.value === value);
 }
+/**
+ * Validates the launch-time model/effort against a live or cached capability
+ * catalog. A fallback catalog intentionally carries no model list, so an
+ * unavailable Provider probe does not block a supported launch.
+ */
+export function validateAgentLaunchConfiguration(catalog, config) {
+    if (catalog.models.length === 0)
+        return;
+    const model = modelChoice(catalog, config.model);
+    if (model === undefined) {
+        throw new Error(`Unsupported ${catalog.adapterId} launch configuration: field=model actual=${JSON.stringify(config.model ?? "")} supported=${JSON.stringify(catalog.models.map(({ value }) => value))}.`);
+    }
+    if (config.effort !== undefined
+        && model.efforts.length > 0
+        && !model.efforts.some((effort) => effort.value === config.effort)) {
+        throw new Error(`Unsupported ${catalog.adapterId} launch configuration: field=effort actual=${JSON.stringify(config.effort)} model=${JSON.stringify(model.value)} supported=${JSON.stringify(model.efforts.map(({ value }) => value))}.`);
+    }
+}
 function field(key, choices, allowCustom) {
     return { key, choices, allowCustom };
 }

package/dist/executor/fileRoleLaunchPlanner.js

@@ -547,16 +547,16 @@ export class FileRoleLaunchPlanner {
         return selectEnvironment(source, names);
     }
 }
-function nativeAgentWorkspace(workspace) {
+export function nativeAgentWorkspace(workspace) {
     return workspace.entries.length === 1
         ? workspace.entries[0].path
         : workspace.root;
 }
-function nativeAdditionalDirectories(workspace, agentWorkspace) {
+export function nativeAdditionalDirectories(workspace, agentWorkspace) {
     return [workspace.root, ...workspace.entries.map(({ path }) => path)]
         .filter((path) => path !== agentWorkspace);
 }
-function withNativeProjectDirectories(config, projectDirectories) {
+export function withNativeProjectDirectories(config, projectDirectories) {
     if (projectDirectories.length === 0)
         return config;
     return {

package/dist/lifecycle/contextBudgetRollover.js

@@ -0,0 +1,81 @@
+import { enqueueWork } from "../coordination/workMailboxQueue.js";
+import { validateRoleSessionSet } from "../executor/agentExecutor.js";
+import { createTaskEvent } from "../event/taskEvent.js";
+import { RUNTIME_CLEANUP_REQUIRED_REASON, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
+/**
+ * Issue 04 (context token budget): retires one native Session generation that
+ * crossed the hard context budget so the next Leader wake starts a fresh
+ * generation. This is a controlled rollover, not a failure: the durable Task
+ * records are the checkpoint, the bounded context snapshot re-establishes
+ * working context for the new generation, and the retired Session is kept in
+ * history as `stopped` with an auditable event. The Controller separately
+ * owns verified process cleanup through the runtime cleanup lane.
+ */
+export const CONTEXT_BUDGET_ROLLOVER_REASON = "context-budget-hard-limit";
+export function rolloverTaskRoleSessionForContextBudget(store, taskId, roleName, evidence, now) {
+    const task = store.getTask(taskId);
+    if (task === null)
+        throw new Error(`Task not found: ${taskId}.`);
+    if (task.status !== "active") {
+        throw new Error(`Task is not active: ${task.id}/${task.status}.`);
+    }
+    const role = store.getRole(task.id, roleName);
+    if (role === null)
+        throw new Error(`Role not found: ${task.id}/${roleName}.`);
+    const set = store.getTaskRoleSessionSet(task.id, role.name);
+    const current = set?.sessions[set.activeAgentId];
+    if (set === null || set === undefined || current === undefined) {
+        // No live generation to retire; the caller can launch fresh directly.
+        return null;
+    }
+    const timestamp = now.toISOString();
+    const reason = `${CONTEXT_BUDGET_ROLLOVER_REASON} (peak ${evidence.peakTokens} >= hard ${evidence.hardTokens} tokens)`;
+    enqueueWork(store, runtimeLifecycleTarget({ scope: "task", taskId: task.id, roleName: role.name }), RUNTIME_CLEANUP_REQUIRED_REASON, now, [{ type: "task", id: task.id }]);
+    const retired = retireStoppedTaskRoleSession(set, timestamp);
+    store.saveTaskRoleSessionSet(retired);
+    const eventId = store.nextEventId(task.id);
+    store.saveEvent(task.id, createTaskEvent(eventId, task.id, "runtime.role-session-reset", {
+        roleName: role.name,
+        reason,
+        peakTokens: String(evidence.peakTokens),
+        hardTokens: String(evidence.hardTokens),
+        ...(current.nativeSessionId === undefined
+            ? {}
+            : { nativeSessionId: current.nativeSessionId }),
+        ...(current.launchId === undefined ? {} : { launchId: current.launchId })
+    }, now));
+    return Object.freeze({
+        taskId: task.id,
+        roleName: role.name,
+        eventId,
+        ...(current.nativeSessionId === undefined
+            ? {}
+            : { retiredNativeSessionId: current.nativeSessionId }),
+        ...(current.launchId === undefined ? {} : { retiredLaunchId: current.launchId })
+    });
+}
+/**
+ * Retires the current generation to history as `stopped` (not `broken`:
+ * a budget rollover is not a Session failure) and clears the Turn fence so
+ * the next launch is a fresh generation.
+ */
+function retireStoppedTaskRoleSession(set, timestamp) {
+    validateRoleSessionSet(set);
+    const current = set.sessions[set.activeAgentId];
+    const sessions = { ...set.sessions };
+    delete sessions[set.activeAgentId];
+    const history = current === undefined
+        ? set.history
+        : [
+            ...(set.history ?? []),
+            { ...current, status: "stopped", updatedAt: timestamp }
+        ];
+    return validateRoleSessionSet({
+        ...set,
+        sessions,
+        ...(history === undefined ? {} : { history }),
+        inFlight: null,
+        providerBinding: null,
+        updatedAt: timestamp
+    });
+}

package/dist/lifecycle/exactRunTerminalization.js

@@ -13,6 +13,7 @@ import { recordExecutionLaneResult } from "../execution/executionGroup.js";
 import { formatAgentRunReceiptId } from "../task/taskRecordReference.js";
 import { isRuntimeLaunchReservation, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
 import { clearMatchingLeaderStallAttention, latestRunDurableProgressAt, RUN_RECOVERY_APPLIED_EVENT, RUN_RECOVERY_REQUESTED_EVENT } from "../scheduler/roleRunStall.js";
+import { markTaskWakeConsumed } from "../scheduler/taskWake.js";
 import { workItemExecutionGroupById, updateWorkItemExecutionGroup, updateWorkItemStatus } from "../workItem/workItem.js";
 /**
  * Validate every immutable identity and frozen Project head needed before a
@@ -283,7 +284,9 @@ export function terminalizeExactTaskRun(store, input, now) {
                         ...(input.reviewResult.findings === undefined ? {} : { findings: input.reviewResult.findings }),
                         ...(input.reviewResult.evidence === undefined ? {} : { evidence: input.reviewResult.evidence }),
                         ...(input.reviewResult.evidenceCommit === undefined ? {} : { evidenceCommit: input.reviewResult.evidenceCommit }),
-                        ...(input.reviewResult.gitSnapshot === undefined ? {} : { gitSnapshot: input.reviewResult.gitSnapshot })
+                        ...(input.reviewResult.gitSnapshot === undefined ? {} : { gitSnapshot: input.reviewResult.gitSnapshot }),
+                        ...(input.reviewResult.deltaDisposition === undefined ? {} : { deltaDisposition: input.reviewResult.deltaDisposition }),
+                        ...(input.reviewResult.deltaReasoning === undefined ? {} : { deltaReasoning: input.reviewResult.deltaReasoning })
                     }
                 })
         }, now))
@@ -310,6 +313,13 @@ export function terminalizeExactTaskRun(store, input, now) {
         }
     }
     store.saveAgentRun(terminal);
+    if (terminal.roleName === "leader") {
+        const wake = store.listTaskWakes(input.taskId)
+            .find((candidate) => candidate.runId === terminal.id && candidate.status === "dispatched");
+        if (wake !== undefined) {
+            store.saveTaskWake(input.taskId, markTaskWakeConsumed(wake, now));
+        }
+    }
     if (terminal.executionGroupId !== undefined && terminal.executionLaneId !== undefined) {
         store.clearActiveExecutionLaneRun(input.taskId, terminal.executionGroupId, terminal.executionLaneId);
     }

package/dist/lifecycle/providerErrorClass.js

@@ -1,11 +1,15 @@
 /**
  * Issue 04 — Provider error classification.
  *
- * Provider failures arrive as opaque free text (Claude StopFailure
- * `error`/`errorDetails`, Codex turn-completion summaries). The retry-in-place
- * coordinator needs a stable, provider-neutral error class before it can decide
- * whether the original Session may be retried. This module is the single
- * classifier: it is pure, table-driven, and deliberately conservative.
+ * Provider failures arrive at the driver boundary as opaque free text (Claude
+ * StopFailure `error`/`errorDetails`, Codex turn-completion summaries). Each
+ * driver parses its own Provider's format into a structured
+ * {@link ProviderErrorCode} at the driver boundary. This module maps those
+ * codes to provider-neutral error classes by lookup, falling back to text
+ * matching only when the driver could not produce a structured code.
+ *
+ * The retry-in-place coordinator needs a stable, provider-neutral error class
+ * before it can decide whether the original Session may be retried.
  *
  * Classes (Issue 04 §2):
  * - `transient-provider`   — 500/502/504, connection reset, backend capacity;
@@ -25,6 +29,7 @@
  *                            terminalize-immediately behavior) while remaining
  *                            observable in shadow metrics.
  */
+import { PROVIDER_ERROR_CODE_CLASS } from "../runtime/providerErrorCodes.js";
 /** Classes for which the original Session may be retried in place. */
 export const RETRYABLE_PROVIDER_ERROR_CLASSES = [
     "transient-provider",
@@ -69,8 +74,11 @@ const INVALID_REQUEST_PATTERNS = [
 ];
 const TRANSIENT_PROVIDER_PATTERNS = [
     { pattern: /\b50[024]\b/u, label: "http-5xx" },
-    { pattern: /server[_-]?error/iu, label: "server-error" },
+    { pattern: /server[\s_-]?error/iu, label: "server-error" },
     { pattern: /internal server error/iu, label: "internal-server-error" },
+    // HTTP/2 RST_STREAM / gRPC status carried by Claude Code and Codex streams
+    // (Task-27: "stream error: stream ID …; INTERNAL_ERROR; received from peer").
+    { pattern: /\binternal[\s_-]?error\b/iu, label: "internal-error" },
     { pattern: /connection lost/iu, label: "connection-lost" },
     { pattern: /connection reset/iu, label: "connection-reset" },
     { pattern: /econnreset/iu, label: "econnreset" },
@@ -91,6 +99,9 @@ const TRANSPORT_UNCERTAIN_PATTERNS = [
     { pattern: /etimedout/iu, label: "etimedout" },
     { pattern: /response lost/iu, label: "response-lost" },
     { pattern: /lost response/iu, label: "lost-response" },
+    // A stream-level failure means the response may have been cut mid-turn;
+    // the retry path consults durable completion facts before any resend.
+    { pattern: /stream error/iu, label: "stream-error" },
     { pattern: /stream interrupted/iu, label: "stream-interrupted" },
     { pattern: /interrupted function/iu, label: "interrupted-function" },
     { pattern: /controller timeout/iu, label: "controller-timeout" },
@@ -106,21 +117,31 @@ const CLASS_TABLE = [
     { errorClass: "transport-uncertain", patterns: TRANSPORT_UNCERTAIN_PATTERNS }
 ];
 /**
- * Classifies one provider failure. Every available text field is concatenated
- * so a class can be recognized regardless of which field carried it. Unknown
- * text is `unclassified`, which keeps the old fail-immediately behavior.
+ * Classifies one provider failure. When the driver produced a structured
+ * {@link ProviderErrorCode}, the class is looked up directly. Otherwise the
+ * raw text fields are matched against the fallback pattern tables. Every
+ * available text field is concatenated so a class can be recognized
+ * regardless of which field carried it.
  */
 export function classifyProviderError(input) {
+    // Structured path: the driver already parsed the Provider's error format.
+    if (input.errorCode !== undefined) {
+        const errorClass = PROVIDER_ERROR_CODE_CLASS[input.errorCode];
+        if (errorClass !== undefined) {
+            return { errorClass, matched: input.errorCode, basis: "structured" };
+        }
+    }
+    // Text fallback: for drivers that cannot yet produce a structured code.
     const text = [input.error, input.errorDetails, input.summary]
         .filter((value) => typeof value === "string" && value.length > 0)
         .join("\n");
     if (text.length === 0)
-        return { errorClass: "unclassified", matched: "none" };
+        return { errorClass: "unclassified", matched: "none", basis: "text" };
     for (const { errorClass, patterns } of CLASS_TABLE) {
         for (const { pattern, label } of patterns) {
             if (pattern.test(text))
-                return { errorClass, matched: label };
+                return { errorClass, matched: label, basis: "text" };
         }
     }
-    return { errorClass: "unclassified", matched: "none" };
+    return { errorClass: "unclassified", matched: "none", basis: "text" };
 }