@bastani/atomic 0.9.19-alpha.1 → 0.9.19-alpha.10

package/dist/builtin/workflows/builtin/{chunk-b0v2xab1.js → chunk-ngkqkzej.js}

@@ -1,18 +1,18 @@
 import {
-  build_scoring_prompt,
-  scoring_prompt_reads
-} from "./chunk-7430zyas.js";
+  VERIFICATION_SCALE
+} from "./chunk-n1910xc4.js";
 import {
-  DEFAULT_FALL_DELTA,
   DEFAULT_RISE_DELTA,
+  DEFAULT_FALL_DELTA,
   classify_trend
-} from "./chunk-6fqs7c01.js";
+} from "./chunk-z0d03ktm.js";
 import {
-  VERIFICATION_SCALE
-} from "./chunk-cg9tmks0.js";
+  scoring_prompt_reads,
+  build_scoring_prompt
+} from "./chunk-2377r57g.js";
 
 // dist/builtin/workflows/src/shared/workflow-artifacts.ts
-import { randomUUID } from "node:crypto";
+import { randomUUID as randomUUID2 } from "node:crypto";
 import { mkdir, readdir, rm, stat } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { getAgentDir, getEnvValue } from "@bastani/atomic";
@@ -212,9 +212,9 @@ function isMemoizedBackendUsable(backend) {
   return !backend.persistent || dbosLifecycleState() === "ready";
 }
 function getDurableBackend() {
-  const owner2 = getDurableBackendProcessOwner();
-  const memoized = owner2.initializedBackend !== undefined && isMemoizedBackendUsable(owner2.initializedBackend) ? owner2.initializedBackend : undefined;
-  const backend = owner2.injectedBackend ?? memoized ?? getReadyDbosBackendSync();
+  const owner = getDurableBackendProcessOwner();
+  const memoized = owner.initializedBackend !== undefined && isMemoizedBackendUsable(owner.initializedBackend) ? owner.initializedBackend : undefined;
+  const backend = owner.injectedBackend ?? memoized ?? getReadyDbosBackendSync();
   if (backend === undefined)
     throw new DbosNotReadyError;
   return backend;
@@ -229,7 +229,7 @@ function queueStageMessage(messages, input, senderGroup, runGroup, stageIdentity
   }
   const messageId = input.message.id;
   const queued = pendingStageMessagesFor(messages, input.runId, input.stageKey, stageIdentity);
-  const existing = messages.find((entry2) => entry2.runId === input.runId && entry2.id === messageId);
+  const existing = messages.find((entry) => entry.runId === input.runId && entry.id === messageId);
   if (existing !== undefined) {
     if (pendingStageMessageSignature(existing, stageIdentity) !== pendingStageMessageSignature(input, stageIdentity)) {
       return {
@@ -279,7 +279,7 @@ function queueStickyStageMessage(messages, input, senderGroup, runGroup) {
     return { ok: false, reason: "group_mismatch", runId: input.runId, stageKey: input.targetPath };
   }
   const messageId = input.message.id;
-  const existing = messages.find((entry2) => entry2.runId === input.runId && entry2.id === messageId);
+  const existing = messages.find((entry) => entry.runId === input.runId && entry.id === messageId);
   if (existing !== undefined) {
     if (pendingStageMessageSignature(existing) !== pendingStageMessageSignature(input)) {
       return {
@@ -330,7 +330,7 @@ function queuedStickyCount(messages, runId, targetPath) {
   return messages.filter((entry) => entry.runId === runId && entry.sticky === true && entry.targetPath === targetPath && entry.status === "queued").length;
 }
 function recordPendingStageMessageDeliveries(messages, runId, messageId, records, deliveredAt) {
-  const index = messages.findIndex((entry2) => entry2.runId === runId && entry2.id === messageId && entry2.sticky === true && entry2.status === "queued");
+  const index = messages.findIndex((entry) => entry.runId === runId && entry.id === messageId && entry.sticky === true && entry.status === "queued");
   if (index < 0)
     return messages;
   const entry = messages[index];
@@ -490,7 +490,7 @@ function createSessionScopedSingleton(key, createLocal) {
   const live = () => shared.instance ?? instance;
   const current = () => live();
   const adoptWithResult = (scope, options) => {
-    const current2 = live();
+    const current = live();
     let targetCreated = false;
     const target = sessionScopedExtensionState(scope, key, () => {
       targetCreated = true;
@@ -499,8 +499,8 @@ function createSessionScopedSingleton(key, createLocal) {
       shared.localClaimed = true;
       return shared.local;
     });
-    const preservedCurrent = !targetCreated && target !== current2 && options?.preserveCurrentWhenTargetExists?.(current2, target) === true;
-    shared.instance = preservedCurrent ? current2 : target;
+    const preservedCurrent = !targetCreated && target !== current && options?.preserveCurrentWhenTargetExists?.(current, target) === true;
+    shared.instance = preservedCurrent ? current : target;
     instance = shared.instance;
     return { instance: shared.instance, preservedCurrent };
   };
@@ -830,6 +830,7 @@ function compactStage(stage) {
     attemptedModels: _attemptedModels,
     modelAttempts: _modelAttempts,
     result: _result,
+    structured: _structured,
     ...metadata
   } = stage;
   return {
@@ -888,6 +889,173 @@ function deepFreezeGraphValue(value) {
   }
 }
 
+// dist/builtin/workflows/src/shared/workflow-observation-runtime.ts
+import { randomUUID } from "node:crypto";
+
+// dist/builtin/workflows/src/shared/workflow-activity.ts
+function workflowActivityNodeKey(runId, nodeId) {
+  return `${runId}:${nodeId}`;
+}
+
+// dist/builtin/workflows/src/shared/workflow-observation-runtime.ts
+class WorkflowObservationRuntime {
+  runs;
+  invalidate;
+  liveRunIds = new Set;
+  executingStageIds = new Set;
+  executingToolNodeIds = new Set;
+  stoppingRunIds = new Set;
+  retryingStageIds = new Set;
+  acknowledgedFailureRunIds = new Set;
+  listeners = new Set;
+  replayStageIds = new Set;
+  previous = new Map;
+  recoveryDepth = 0;
+  constructor(runs, invalidate) {
+    this.runs = runs;
+    this.invalidate = invalidate;
+  }
+  get recovering() {
+    return this.recoveryDepth > 0;
+  }
+  startRun(runId) {
+    this.liveRunIds.add(runId);
+    this.stoppingRunIds.delete(runId);
+  }
+  finishRun(runId) {
+    this.liveRunIds.delete(runId);
+    this.stoppingRunIds.delete(runId);
+    for (const ids of [
+      this.executingStageIds,
+      this.executingToolNodeIds,
+      this.retryingStageIds,
+      this.replayStageIds
+    ]) {
+      for (const id of ids)
+        if (id.startsWith(`${runId}:`))
+          ids.delete(id);
+    }
+    this.invalidate();
+  }
+  emit(event) {
+    for (const listener of this.listeners) {
+      try {
+        listener(event);
+      } catch {}
+    }
+  }
+  rootRunId(run) {
+    if (run.rootRunId !== undefined)
+      return run.rootRunId;
+    if (run.parentRunId === undefined)
+      return run.id;
+    const parent = this.runs().find((candidate) => candidate.id === run.parentRunId);
+    return parent ? this.rootRunId(parent) : run.parentRunId;
+  }
+  lifecycle(target, attribution = "unknown") {
+    if (this.recovering && !this.liveRunIds.has(target.runId))
+      return;
+    const run = this.runs().find((candidate) => candidate.id === target.runId);
+    if (!run)
+      return;
+    const rootRunId = this.rootRunId(run);
+    const now = Date.now();
+    this.emit({
+      kind: "lifecycle",
+      event: {
+        type: "workflow_lifecycle",
+        eventId: randomUUID(),
+        runId: run.id,
+        rootRunId,
+        occurredAt: now,
+        observedAt: now,
+        target: canonicalTarget(target, rootRunId),
+        attribution,
+        delivery: target.kind === "stage" && this.replayStageIds.has(workflowActivityNodeKey(run.id, target.stageId)) ? "replay" : "live"
+      }
+    });
+  }
+  control(runId, action, attribution = "unknown") {
+    const run = this.runs().find((candidate) => candidate.id === runId);
+    if (!run)
+      return;
+    if ((action === "quit" || action === "kill" || action === "pause") && this.liveRunIds.has(runId))
+      this.stoppingRunIds.add(runId);
+    if (action === "resume")
+      this.stoppingRunIds.delete(runId);
+    this.lifecycle({ kind: "run", runId, status: run.status, action }, attribution);
+    this.invalidate();
+  }
+  heartbeat(runId, scheduledAt, intervalMinutes) {
+    const run = this.runs().find((candidate) => candidate.id === runId);
+    if (run)
+      this.emit({
+        kind: "heartbeat",
+        event: { type: "workflow_heartbeat", runId, rootRunId: this.rootRunId(run), scheduledAt, intervalMinutes }
+      });
+  }
+  beginRecovery() {
+    this.recoveryDepth++;
+    if (this.recoveryDepth === 1)
+      this.emit({ kind: "availability" });
+    let ended = false;
+    return () => {
+      if (ended)
+        return;
+      ended = true;
+      this.capture();
+      this.recoveryDepth--;
+      if (!this.recovering)
+        this.emit({ kind: "availability" });
+    };
+  }
+  capture() {
+    const next = new Map;
+    const visit = (key, target, historical = false) => {
+      next.set(key, target);
+      const previous = this.previous.get(key);
+      if (!historical && this.liveRunIds.has(target.runId) && previous?.status !== target.status) {
+        this.lifecycle(previous && previous.kind !== "prompt" && target.kind !== "prompt" ? { ...target, previousStatus: previous.status } : target, this.runs().find((run) => run.id === target.runId)?.origin);
+      }
+    };
+    for (const run of this.runs()) {
+      const existing = this.previous.has(`run:${run.id}`);
+      visit(`run:${run.id}`, { kind: "run", runId: run.id, status: run.status });
+      for (const stage of run.stages) {
+        visit(`stage:${workflowActivityNodeKey(run.id, stage.id)}`, { kind: "stage", runId: run.id, stageId: stage.id, stageName: stage.name, status: stage.status }, !existing);
+        if (stage.pendingPrompt)
+          visit(`prompt:${stage.pendingPrompt.id}`, {
+            kind: "prompt",
+            runId: run.id,
+            stageId: stage.id,
+            promptId: stage.pendingPrompt.id,
+            status: "opened"
+          }, !existing);
+      }
+      for (const tool of run.toolNodes ?? [])
+        visit(`tool:${workflowActivityNodeKey(run.id, tool.id)}`, { kind: "tool", runId: run.id, toolNodeId: tool.id, toolName: tool.name, status: tool.status }, !existing);
+      if (run.pendingPrompt)
+        visit(`prompt:${run.pendingPrompt.id}`, { kind: "prompt", runId: run.id, promptId: run.pendingPrompt.id, status: "opened" }, !existing);
+    }
+    this.previous = next;
+  }
+}
+var workflowObservationRuntimeKey = Symbol.for("atomic-workflows/store-observation-runtime@1");
+function canonicalTarget(target, rootRunId) {
+  if (target.runId === rootRunId)
+    return target;
+  switch (target.kind) {
+    case "stage":
+      return { ...target, stageId: workflowActivityNodeKey(target.runId, target.stageId) };
+    case "tool":
+      return { ...target, toolNodeId: workflowActivityNodeKey(target.runId, target.toolNodeId) };
+    case "prompt":
+      return target.stageId === undefined ? target : { ...target, stageId: workflowActivityNodeKey(target.runId, target.stageId) };
+    case "run":
+      return target;
+  }
+}
+
 // dist/builtin/workflows/src/shared/store-internal.ts
 var TERMINAL_STATUSES = new Set([
   "completed",
@@ -987,6 +1155,7 @@ function createStoreState() {
 function createStoreContext(state = createStoreState()) {
   let cachedGraphVersion = -1;
   let cachedGraphSnapshot;
+  const observation = new WorkflowObservationRuntime(() => state.runs, bumpAndNotify);
   function snapshot() {
     return JSON.parse(JSON.stringify({ runs: state.runs, notices: state.notices, version: state.version }));
   }
@@ -998,6 +1167,7 @@ function createStoreContext(state = createStoreState()) {
     return cachedGraphSnapshot;
   }
   function notify() {
+    observation.capture();
     for (const fn of state.invalidationListeners) {
       try {
         fn();
@@ -1053,6 +1223,7 @@ function createStoreContext(state = createStoreState()) {
     const prompt = stage.pendingPrompt;
     if (!prompt)
       return;
+    observation.lifecycle({ kind: "prompt", runId, stageId: stage.id, promptId: prompt.id, status: "cancelled" });
     stage.pendingPrompt = undefined;
     state.stagePromptDrafts.delete(stagePromptDraftKey(runId, stage.id, prompt.id));
     rejectPrompt(prompt.id, reason);
@@ -1064,6 +1235,7 @@ function createStoreContext(state = createStoreState()) {
   }
   return {
     state,
+    observation,
     snapshot,
     graphSnapshot,
     notify,
@@ -1233,8 +1405,8 @@ function createPendingStageDeliveryStoreMethods(context) {
   };
 }
 function resolvePendingStageIdentity(run, stageKey) {
-  const exactIds = run.stages.filter((stage2) => stage2.id === stageKey);
-  const candidates = exactIds.length > 0 ? exactIds : run.stages.filter((stage2) => stage2.name === stageKey);
+  const exactIds = run.stages.filter((stage) => stage.id === stageKey);
+  const candidates = exactIds.length > 0 ? exactIds : run.stages.filter((stage) => stage.name === stageKey);
   if (candidates.length !== 1)
     return;
   const stage = candidates[0];
@@ -1273,6 +1445,7 @@ function createPromptStoreMethods(context) {
       const pending = run.pendingPrompt;
       if (!pending || pending.id !== promptId)
         return false;
+      context.observation.lifecycle({ kind: "prompt", runId, promptId, status: "answered" });
       run.pendingPrompt = undefined;
       context.bumpAndNotify();
       const entry = state.resolvers.get(promptId);
@@ -1343,6 +1516,13 @@ function createPromptStoreMethods(context) {
         state.stagePromptAnswers.delete(context.stagePromptAnswerKey(runId, stageId));
         delete stage.promptAnswerState;
       }
+      context.observation.lifecycle({
+        kind: "prompt",
+        runId,
+        stageId,
+        promptId,
+        status: options.recordAnswer === false ? "cancelled" : "answered"
+      });
       stage.pendingPrompt = undefined;
       if (stage.status === "awaiting_input") {
         stage.status = "running";
@@ -1548,6 +1728,7 @@ function createRunStoreMethods(context) {
       }
       const pending = run.pendingPrompt;
       if (pending) {
+        context.observation.lifecycle({ kind: "prompt", runId, promptId: pending.id, status: "cancelled" });
         run.pendingPrompt = undefined;
         context.rejectPrompt(pending.id, `atomic-workflows: run ${runId} ended before prompt resolved`);
       }
@@ -1629,6 +1810,7 @@ function createRunStoreMethods(context) {
       const run = state.runs[index];
       const pending = run.pendingPrompt;
       if (pending) {
+        context.observation.lifecycle({ kind: "prompt", runId, promptId: pending.id, status: "cancelled" });
         context.rejectPrompt(pending.id, `atomic-workflows: run ${runId} was removed before prompt resolved`);
       }
       context.rejectAllStagePrompts(runId, run, `atomic-workflows: run ${runId} was removed before prompt resolved`);
@@ -1789,6 +1971,8 @@ function createToolNodeStoreMethods(context) {
         return false;
       node.status = "running";
       node.startedAt = startedAt;
+      if (context.observation.liveRunIds.has(runId))
+        context.observation.executingToolNodeIds.add(workflowActivityNodeKey(runId, nodeId));
       context.bumpAndNotify();
       return true;
     },
@@ -1796,6 +1980,7 @@ function createToolNodeStoreMethods(context) {
       const node = context.findRun(runId)?.toolNodes?.find((candidate) => candidate.id === nodeId);
       if (node === undefined || node.status === "completed" || node.status === "failed" || node.status === "cached" || node.status === "cancelled")
         return false;
+      context.observation.executingToolNodeIds.delete(workflowActivityNodeKey(runId, nodeId));
       node.status = update.status;
       if (update.endedAt !== undefined)
         node.endedAt = update.endedAt;
@@ -1825,6 +2010,9 @@ function createStageStoreMethods(context) {
       if (!run.stages.some((s) => s.id === stage.id)) {
         run.stages.push(stage);
       }
+      if (stage.status === "running" && context.observation.liveRunIds.has(runId)) {
+        context.observation.executingStageIds.add(workflowActivityNodeKey(runId, stage.id));
+      }
       context.bumpAndNotify();
     },
     recordStageWorkflowChildRun(runId, stageId, ref) {
@@ -1834,8 +2022,12 @@ function createStageStoreMethods(context) {
       const stage = context.findStage(run, stageId);
       if (!stage)
         return false;
-      if (stage.workflowChildRun?.runId === ref.runId && stage.workflowChildRun.alias === ref.alias && stage.workflowChildRun.workflow === ref.workflow)
+      const released = context.observation.executingStageIds.delete(workflowActivityNodeKey(runId, stageId));
+      if (stage.workflowChildRun?.runId === ref.runId && stage.workflowChildRun.alias === ref.alias && stage.workflowChildRun.workflow === ref.workflow) {
+        if (released)
+          context.bumpAndNotify();
         return false;
+      }
       stage.workflowChildRun = { ...ref };
       context.bumpAndNotify();
       return true;
@@ -1874,6 +2066,7 @@ function createStageStoreMethods(context) {
       const existing = context.findStage(run, stage.id);
       if (!existing)
         return;
+      context.observation.executingStageIds.delete(workflowActivityNodeKey(runId, stage.id));
       existing.status = stage.status;
       existing.endedAt = stage.endedAt;
       if (existing.endedAt !== undefined && existing.pausedAt !== undefined) {
@@ -2097,6 +2290,7 @@ function createStageStoreMethods(context) {
         context.bumpAndNotify();
         return false;
       }
+      context.observation.executingStageIds.delete(workflowActivityNodeKey(runId, stageId));
       stage.status = "paused";
       stage.pausedAt = nextControlTimestamp(pausedAt, stage.resumedAt);
       stage.resumedAt = undefined;
@@ -2129,6 +2323,8 @@ function createStageStoreMethods(context) {
         return false;
       }
       const resumedTs = nextControlTimestamp(resumedAt, stage.pausedAt);
+      if (context.observation.liveRunIds.has(runId))
+        context.observation.executingStageIds.add(workflowActivityNodeKey(runId, stageId));
       stage.status = "running";
       if (stage.startedAt !== undefined) {
         stage.pausedDurationMs = accumulatePausedDurationMs(stage.pausedDurationMs, stage.pausedAt, resumedTs);
@@ -2151,13 +2347,15 @@ function createStageStoreMethods(context) {
 // dist/builtin/workflows/src/shared/store-factory.ts
 function createStore() {
   const context = createStoreContext();
-  return {
+  const created = {
+    [workflowObservationRuntimeKey]: context.observation,
     ...createRunStoreMethods(context),
     ...createPendingStageDeliveryStoreMethods(context),
     ...createStageStoreMethods(context),
     ...createToolNodeStoreMethods(context),
     ...createPromptStoreMethods(context)
   };
+  return created;
 }
 var SESSION_KEY = "workflows:store:v1";
 var singleton = createSessionScopedSingleton(SESSION_KEY, createStore);
@@ -2319,8 +2517,8 @@ async function pruneArtifactRootIfDue(root, now) {
   }
 }
 function workflowArtifactDirectoryPath(runId) {
-  const effectiveRunId = runId ?? randomUUID();
-  return join(workflowArtifactRunPath(effectiveRunId), `artifact-${randomUUID()}`);
+  const effectiveRunId = runId ?? randomUUID2();
+  return join(workflowArtifactRunPath(effectiveRunId), `artifact-${randomUUID2()}`);
 }
 async function ensureWorkflowArtifactDirectory(directory) {
   await pruneArtifactRootIfDue(workflowArtifactRunsRoot(), Date.now());

package/dist/builtin/workflows/builtin/{chunk-ed4jfn5t.js → chunk-nkrafh9s.js}

@@ -1,48 +1,48 @@
-import {
-  consolidateFindingsBatch,
-  convergence_escalation_evidence,
-  ensureWorkflowArtifactDirectory,
-  finalActionRemaining,
-  parseFailureDiagnostics,
-  record_convergence,
-  reverify_consolidated_batch,
-  reviewerFailureText,
-  summarizeReviewConvergence,
-  workflowArtifactDirectoryPath
-} from "./chunk-b0v2xab1.js";
-import {
-  fold_usage
-} from "./chunk-7at6dnkr.js";
-import {
-  VERIFICATION_SCALE
-} from "./chunk-cg9tmks0.js";
 import {
   workflow
-} from "./chunk-bfkmzv9h.js";
+} from "./chunk-xtxcq5tj.js";
 import {
-  ACCEPTANCE_MATRIX_CONTRACT,
-  CODE_QUALITY_VERIFICATION_GUIDANCE,
-  CONTRACT_FIDELITY_AUDIT,
+  keepContext,
+  REVIEWER_CALIBRATION_RULES,
+  WORKER_PREFLIGHT_CONTRACT,
   E2E_VERIFICATION_GUIDANCE,
-  EVIDENCE_CLOSURE_POLICY,
-  FINDINGS_CONSOLIDATION_CONTRACT,
-  LITERAL_OBJECTIVE_CONTRACT,
+  CODE_QUALITY_VERIFICATION_GUIDANCE,
   MEDIA_PUBLICATION_GUIDANCE,
-  REGRESSION_EVIDENCE_CONTRACT,
   REPO_INTENT_MINING_GUIDANCE,
-  REVIEWER_CALIBRATION_RULES,
-  REVIEWER_INDEPENDENT_VERIFICATION_CONTRACT,
-  REVIEWER_INTERCOM_COORDINATION_PROTOCOL,
-  REVIEWER_OVERIMPLEMENTATION_GUARD,
+  renderE2eQaVideoReviewGuidance,
+  LITERAL_OBJECTIVE_CONTRACT,
   REVIEWER_SPEC_VS_OBJECTIVE_GUARD,
-  REVIEW_CODE_DELTA_CONTRACT,
+  REVIEWER_OVERIMPLEMENTATION_GUARD,
+  ACCEPTANCE_MATRIX_CONTRACT,
+  CONTRACT_FIDELITY_AUDIT,
+  REVIEWER_INTERCOM_COORDINATION_PROTOCOL,
+  REVIEWER_INDEPENDENT_VERIFICATION_CONTRACT,
+  REGRESSION_EVIDENCE_CONTRACT,
+  FINDINGS_CONSOLIDATION_CONTRACT,
   SCOPE_DISCIPLINE_CONTRACT,
-  WORKER_PREFLIGHT_CONTRACT,
+  EVIDENCE_CLOSURE_POLICY,
   WORKTREE_DISCIPLINE_CONTRACT,
-  keepContext,
-  renderE2eQaVideoReviewGuidance,
-  withSteeringPropagationContext
-} from "./chunk-zbekjqew.js";
+  REVIEW_CODE_DELTA_CONTRACT,
+  withSteeringPropagationContext2
+} from "./chunk-a2kdsqn8.js";
+import {
+  workflowArtifactDirectoryPath,
+  ensureWorkflowArtifactDirectory,
+  record_convergence,
+  convergence_escalation_evidence,
+  finalActionRemaining,
+  consolidateFindingsBatch,
+  parseFailureDiagnostics,
+  reviewerFailureText,
+  summarizeReviewConvergence,
+  reverify_consolidated_batch
+} from "./chunk-ngkqkzej.js";
+import {
+  VERIFICATION_SCALE
+} from "./chunk-n1910xc4.js";
+import {
+  fold_usage
+} from "./chunk-tgt0s5e5.js";
 
 // dist/builtin/workflows/builtin/goal.ts
 import { Type as Type2 } from "typebox";
@@ -113,19 +113,19 @@ var reviewDecisionSchema = Type.Object({
 
 // dist/builtin/workflows/builtin/goal-models.ts
 var orchestratorModelConfig = {
-  model: "openai-codex/gpt-6-astra:high",
+  model: "openai-codex/gpt-6-astra:medium",
   fallbackModels: [
-    "github-copilot/gpt-6-astra:high",
-    "openai/gpt-6-astra:high",
-    "anthropic/claude-fable-5-1:high",
-    "github-copilot/claude-fable-5-1:high",
+    "github-copilot/gpt-6-astra:medium",
+    "openai/gpt-6-astra:medium",
+    "anthropic/claude-fable-5-1:medium",
+    "github-copilot/claude-fable-5-1:medium",
     "anthropic/claude-opus-5:high",
     "github-copilot/claude-opus-5:high",
-    "openai-codex/gpt-5.6-sol:xhigh",
-    "github-copilot/gpt-5.6-sol:xhigh",
-    "openai/gpt-5.6-sol:xhigh",
-    "anthropic/claude-fable-5:high",
-    "github-copilot/claude-fable-5:high",
+    "openai-codex/gpt-5.6-sol:high",
+    "github-copilot/gpt-5.6-sol:high",
+    "openai/gpt-5.6-sol:high",
+    "anthropic/claude-fable-5:medium",
+    "github-copilot/claude-fable-5:medium",
     "kimi-coding/k3:max",
     "moonshotai/kimi-k3:max",
     "moonshotai-cn/kimi-k3:max",
@@ -142,35 +142,35 @@ var orchestratorModelConfig = {
     "zai-coding-cn/glm-5.3-flash:high",
     "baseten/zai-org/GLM-5.3:high",
     "baseten/zai-org/GLM-5.3-Flash:high",
-    "openrouter/openai/gpt-6-astra:high",
-    "openrouter/anthropic/claude-fable-5-1:high",
+    "openrouter/openai/gpt-6-astra:medium",
+    "openrouter/anthropic/claude-fable-5-1:medium",
     "openrouter/anthropic/claude-opus-5:high",
-    "openrouter/openai/gpt-5.6-sol:xhigh",
-    "openrouter/anthropic/claude-fable-5:high",
+    "openrouter/openai/gpt-5.6-sol:high",
+    "openrouter/anthropic/claude-fable-5:medium",
     "openrouter/moonshotai/kimi-k3:max",
     "openrouter/sakana/fugu-ultra:high",
     "openrouter/openai/gpt-5.5:xhigh",
     "openrouter/anthropic/claude-opus-4-8:high",
-    "openrouter/x-ai/grok-4.6",
+    "openrouter/x-ai/grok-4.6:xhigh",
     "openrouter/z-ai/glm-5.3:high",
     "openrouter/z-ai/glm-5.3-flash:high"
   ],
   excludedTools: ["ask_user_question"]
 };
 var reviewerModelConfig = {
-  model: "openai-codex/gpt-6-astra:xhigh",
+  model: "openai-codex/gpt-6-astra:high",
   fallbackModels: [
-    "github-copilot/gpt-6-astra:xhigh",
-    "openai/gpt-6-astra:xhigh",
+    "github-copilot/gpt-6-astra:high",
+    "openai/gpt-6-astra:high",
     "anthropic/claude-fable-5-1:high",
     "github-copilot/claude-fable-5-1:high",
     "anthropic/claude-opus-5:high",
     "github-copilot/claude-opus-5:high",
     "anthropic/claude-fable-5:high",
     "github-copilot/claude-fable-5:high",
-    "openai-codex/gpt-5.6-sol:xhigh",
-    "github-copilot/gpt-5.6-sol:xhigh",
-    "openai/gpt-5.6-sol:xhigh",
+    "openai-codex/gpt-5.6-sol:high",
+    "github-copilot/gpt-5.6-sol:high",
+    "openai/gpt-5.6-sol:high",
     "kimi-coding/k3:max",
     "moonshotai/kimi-k3:max",
     "moonshotai-cn/kimi-k3:max",
@@ -187,16 +187,16 @@ var reviewerModelConfig = {
     "zai-coding-cn/glm-5.3-flash:high",
     "baseten/zai-org/GLM-5.3:high",
     "baseten/zai-org/GLM-5.3-Flash:high",
-    "openrouter/openai/gpt-6-astra:xhigh",
+    "openrouter/openai/gpt-6-astra:high",
     "openrouter/anthropic/claude-fable-5-1:high",
     "openrouter/anthropic/claude-opus-5:high",
     "openrouter/anthropic/claude-fable-5:high",
-    "openrouter/openai/gpt-5.6-sol:xhigh",
+    "openrouter/openai/gpt-5.6-sol:high",
     "openrouter/moonshotai/kimi-k3:max",
     "openrouter/sakana/fugu-ultra:high",
     "openrouter/openai/gpt-5.5:xhigh",
     "openrouter/anthropic/claude-opus-4-8:high",
-    "openrouter/x-ai/grok-4.6",
+    "openrouter/x-ai/grok-4.6:xhigh",
     "openrouter/z-ai/glm-5.3:high",
     "openrouter/z-ai/glm-5.3-flash:high"
   ],
@@ -1227,7 +1227,7 @@ var goal_default = workflow({
     baseBranch: "base_branch"
   },
   run: async (ctx) => {
-    const workflowCtx = withSteeringPropagationContext(ctx);
+    const workflowCtx = withSteeringPropagationContext2(ctx);
     const workflowStartCwd = workflowCtx.cwd ?? process.cwd();
     const createPr = workflowCtx.inputs.create_pr === true;
     return await runGoalWorkflow(workflowCtx, { createPr, workflowStartCwd });