mixdog 1.1.0 → 1.1.2

package/src/runtime/agent/orchestrator/providers/openai-oauth-catalog-store.mjs

@@ -0,0 +1,99 @@
+/**
+ * openai-oauth-catalog-store.mjs — where the openai-oauth model catalog is
+ * cached, and the catalog's own route successors.
+ *
+ * Kept free of the provider runtime so config load can read the last fetched
+ * catalog synchronously: a saved route on a model the catalog has superseded
+ * moves to the model the catalog names for it.
+ */
+import { makeModelCache } from './model-cache.mjs';
+import { accessProgramModelParameters, accessProgramOnly } from '../../../shared/llm/openai-daybreak.mjs';
+import { formatScheduleModelRef, parseScheduleModelRef } from '../../../shared/schedule-model-ref.mjs';
+
+export const CODEX_MODEL_CACHE_OPTIONS = Object.freeze({
+  fileName: 'openai-oauth-models.json',
+  ttlMs: 24 * 60 * 60_000,
+  version: 6,
+});
+
+export const CODEX_PROVIDER_ID = 'openai-oauth';
+
+let snapshotCache = null;
+
+/** The last saved catalog, stale or not; null when none was ever fetched. */
+function savedCatalog() {
+  snapshotCache ||= makeModelCache(CODEX_MODEL_CACHE_OPTIONS);
+  return snapshotCache.loadSync({ allowStale: true });
+}
+
+/**
+ * The route a model moves to, read off the catalog alone; null when it stays.
+ *  - A standalone access-program variant (its access programs omit the
+ *    standard one) moves to the first listed regular model, by catalog
+ *    priority, that accepts the same program, with that program's toggle on.
+ *  - A model whose `upgrade.retirement_at` has passed moves to `upgrade.model`.
+ * Returns { model, modelParameters? }.
+ */
+export function codexModelSuccessor(models, modelId, now = Date.now()) {
+  if (!Array.isArray(models) || !modelId) return null;
+  const entry = models.find((model) => model?.id === modelId);
+  if (!entry) return null;
+  const program = accessProgramOnly(entry);
+  if (program) {
+    const modelParameters = accessProgramModelParameters(program);
+    if (!modelParameters) return null;
+    const target = models
+      .filter(
+        (model) =>
+          model?.id &&
+          model.id !== modelId &&
+          model.hidden !== true &&
+          !accessProgramOnly(model) &&
+          Array.isArray(model.accessPrograms) &&
+          model.accessPrograms.includes(program)
+      )
+      .sort((a, b) => (a.priority ?? Infinity) - (b.priority ?? Infinity))[0];
+    return target ? { model: target.id, modelParameters } : null;
+  }
+  const upgrade = entry.upgrade;
+  const retiresAt = Date.parse(upgrade?.retirementAt || '');
+  if (upgrade?.model && Number.isFinite(retiresAt) && retiresAt <= now) return { model: upgrade.model };
+  return null;
+}
+
+/** A saved openai-oauth route moved to its catalog successor; any other route unchanged. */
+export function migrateCodexRoute(route, models = savedCatalog()) {
+  if (String(route?.provider || '').trim() !== CODEX_PROVIDER_ID) return route;
+  const successor = codexModelSuccessor(models, String(route.model || '').trim());
+  if (!successor) return route;
+  const current =
+    route.modelParameters && typeof route.modelParameters === 'object' && !Array.isArray(route.modelParameters)
+      ? route.modelParameters
+      : {};
+  return {
+    ...route,
+    model: successor.model,
+    ...(successor.modelParameters || Object.hasOwn(route, 'modelParameters')
+      ? { modelParameters: { ...current, ...(successor.modelParameters || {}) } }
+      : {}),
+  };
+}
+
+/** A stored schedule/webhook model ref ("provider/model@effort+fast?k=v") moved
+ *  to its catalog successor; preset names and current models unchanged. */
+export function migrateCodexModelRef(ref, models = savedCatalog()) {
+  const route = parseScheduleModelRef(ref);
+  if (!route || typeof route !== 'object') return ref;
+  const migrated = migrateCodexRoute(route, models);
+  return migrated === route ? ref : formatScheduleModelRef(migrated);
+}
+
+/** `modelSettings` keys whose model the catalog has superseded (they apply to nothing any more). */
+export function supersededCodexSettingsKey(key, models = savedCatalog()) {
+  const prefix = `${CODEX_PROVIDER_ID}/`;
+  return key.startsWith(prefix) && Boolean(codexModelSuccessor(models, key.slice(prefix.length)));
+}
+
+export function loadSavedCodexCatalog() {
+  return savedCatalog();
+}

package/src/runtime/agent/orchestrator/providers/openai-oauth-catalog.mjs

@@ -8,10 +8,10 @@
  * levels, visibility), so the catalog is normalized and enriched once here and
  * every consumer reads the same records.
  *
- * openai-oauth.mjs re-exports the lookups it used to own so existing importers
- * resolve unchanged.
+ * openai-oauth.mjs re-exports these lookups as its facade.
  */
 import { makeModelCache } from './model-cache.mjs';
+import { CODEX_MODEL_CACHE_OPTIONS } from './openai-oauth-catalog-store.mjs';
 import { enrichModels } from './model-catalog.mjs';
 import { sanitizeModelList } from './model-list-sanitize.mjs';
 import { modelSupportsServiceTier } from './model-service-tiers.mjs';
@@ -21,8 +21,6 @@ import { getLlmDispatcher } from '../../../shared/llm/http-agent.mjs';
 import { CODEX_OAUTH_ORIGINATOR, codexModelsUrl } from './openai-codex-endpoints.mjs';
 import { _normalizeCodexModel, _markLatestCodex } from './openai-codex-model.mjs';
 
-const CODEX_MODEL_CACHE_TTL_MS = 24 * 60 * 60_000;
-const CODEX_MODEL_CACHE_SCHEMA_VERSION = 6;
 const CATALOG_FETCH_TIMEOUT_MS = 10_000;
 
 // In-memory mirror of the on-disk catalog, same pattern as anthropic-oauth.
@@ -31,9 +29,7 @@ let _mirror = null;
 let _refreshInFlight = null;
 
 const _modelCache = makeModelCache({
-  fileName: 'openai-oauth-models.json',
-  ttlMs: CODEX_MODEL_CACHE_TTL_MS,
-  version: CODEX_MODEL_CACHE_SCHEMA_VERSION,
+  ...CODEX_MODEL_CACHE_OPTIONS,
   onSave: (models) => {
     _mirror = Array.isArray(models) ? models.slice() : null;
   },
@@ -96,7 +92,7 @@ export function resolveLatestCodexModel() {
   if (!Array.isArray(_mirror)) return null;
   let best = null;
   for (const m of _mirror) {
-    if (!m?.id || m.visibility === 'hide' || !Number.isFinite(m.priority)) continue;
+    if (!m?.id || m.visibility === 'hide' || m.hidden === true || !Number.isFinite(m.priority)) continue;
     if (!best || m.priority < best.priority) best = m;
   }
   return best?.id || null;

package/src/runtime/agent/orchestrator/providers/openai-oauth-login.mjs

@@ -12,6 +12,7 @@ import { createServer } from 'node:http';
 import { randomBytes } from 'node:crypto';
 import { createOAuthPkce, parseOAuthCodeInput } from './lib/oauth-pkce.mjs';
 import { OAUTH_PAGE_CONTENT_TYPE, oauthSuccessHtml } from './lib/oauth-page.mjs';
+import { openLoginUrl } from './lib/open-login-url.mjs';
 
 const TOKEN_URL = 'https://auth.openai.com/oauth/token';
 const AUTHORIZE_URL = 'https://auth.openai.com/oauth/authorize';
@@ -141,13 +142,7 @@ export function createOpenAIOAuthLogin(deps) {
         process.stderr.write(
           `\n[openai-oauth] Open this URL to log in to ChatGPT (OpenAI OAuth):\n${url.toString()}\n\n`
         );
-        if (!openBrowser) return;
-        try {
-          const { openInBrowser } = await import('../../../shared/open-url.mjs');
-          openInBrowser(url.toString());
-        } catch (err) {
-          process.stderr.write(`[openai-oauth] browser open failed: ${String(err?.message || err).slice(0, 200)}\n`);
-        }
+        if (openBrowser) await openLoginUrl('openai-oauth', url.toString());
       });
       server.on('error', (err) =>
         finish(

package/src/runtime/agent/orchestrator/providers/openai-responses-payload.mjs

@@ -7,6 +7,7 @@ import { isResponsesFreeformTool, toResponsesCustomTool } from './custom-tool-wi
 import { _envFlag } from './openai-oauth-http-sse.mjs';
 import { findCachedCodexModel } from './openai-oauth-catalog.mjs';
 import { resolveOpenAiServiceTier } from './openai-service-tier.mjs';
+import { daybreakAccessPrograms } from '../../../shared/llm/openai-daybreak.mjs';
 
 export function toOpenAIResponsesTool(t) {
   if (t?.name === 'load_tool' || t?.name === 'tool_search') {
@@ -219,6 +220,12 @@ export function buildRequestBody(messages, model, tools, sendOpts) {
     toolChoice,
   });
   const verbosity = requestedVerbosity(opts);
+  // Daybreak Blue rides on the ChatGPT route only, and only for a model that
+  // accepts it; the server still decides entitlement.
+  const accessPrograms =
+    promptCacheProvider === 'openai-oauth'
+      ? daybreakAccessPrograms(findCachedCodexModel(model) || model, opts.modelParameters)
+      : null;
   // Match the request body shape the OAuth backend expects so the
   // server-side auto-cache routes correctly: text.verbosity / include /
   // tool_choice / parallel_tool_calls are inert for most callers but their
@@ -246,6 +253,7 @@ export function buildRequestBody(messages, model, tools, sendOpts) {
     ...(serviceTier ? { service_tier: serviceTier } : {}),
     prompt_cache_key: promptCacheKey,
     text: { verbosity },
+    ...(accessPrograms ? { access_programs: accessPrograms } : {}),
     ...(maxOutputTokens ? { max_output_tokens: maxOutputTokens } : {}),
   };
 }

package/src/runtime/agent/orchestrator/providers/registry.mjs

@@ -26,6 +26,8 @@ const OAUTH_PROVIDER_NAMES = new Set([
   'anthropic-oauth',
   'openai-oauth',
   'grok-oauth',
+  'muse-code-oauth',
+  'mimo-oauth',
   'cursor-oauth',
   'antigravity-oauth',
 ]);
@@ -143,6 +145,8 @@ const PROVIDER_MODULES = {
   'openai-oauth': ['./openai-oauth.mjs', 'OpenAIOAuthProvider'],
   'anthropic-oauth': ['./anthropic-oauth.mjs', 'AnthropicOAuthProvider'],
   'grok-oauth': ['./grok-oauth.mjs', 'GrokOAuthProvider'],
+  'muse-code-oauth': ['./muse-code-oauth.mjs', 'MuseCodeOAuthProvider'],
+  'mimo-oauth': ['./mimo-oauth.mjs', 'MimoOAuthProvider'],
   'cursor-oauth': ['./cursor.mjs', 'CursorOAuthProvider'],
   'antigravity-oauth': ['./antigravity-oauth.mjs', 'AntigravityOAuthProvider'],
   'cursor-api': ['./cursor.mjs', 'CursorApiProvider'],

package/src/runtime/agent/orchestrator/runtime-core/effort.mjs

@@ -25,6 +25,8 @@ const EFFORT_OPTIONS_BY_PROVIDER = {
   // xAI Grok 4.6+: low/medium/high/xhigh. Reasoning cannot be disabled.
   xai: ['low', 'medium', 'high', 'xhigh'],
   'grok-oauth': ['low', 'medium', 'high', 'xhigh'],
+  'muse-code-oauth': ['minimal', 'low', 'medium', 'high', 'xhigh'],
+  'mimo-oauth': ['minimal', 'low', 'medium', 'high'],
   // Antigravity carries the effort tier inside the wire model id
   // (gemini-3-pro-high / -low, claude-*-thinking), so the route exposes none.
   'antigravity-oauth': [],

package/src/runtime/agent/orchestrator/runtime-core/goal-tool-defs.mjs

@@ -129,7 +129,21 @@ export function validateGoalToolCall(value) {
   if (!action) throw new Error('goal action is required');
   if (!ACTION_FIELDS[action]) throw new Error(`goal action must be one of: ${Object.keys(ACTION_FIELDS).join(', ')}`);
   const extras = Object.keys(value).filter((key) => !TOOL_FIELDS.has(key));
-  if (extras.length) throw new Error(`goal arguments contain unknown fields: ${extras.join(', ')}`);
+  if (extras.length) {
+    throw new Error(
+      `goal arguments contain unknown fields: ${extras.join(', ')}. Allowed for ${action}: ${ACTION_FIELDS[action].join(', ')}`
+    );
+  }
+  // A JSON-stringified tasks/updates array is the same list; parse it in place.
+  for (const key of ['tasks', 'updates']) {
+    if (typeof value[key] !== 'string' || !value[key].trim().startsWith('[')) continue;
+    try {
+      const parsed = JSON.parse(value[key]);
+      if (Array.isArray(parsed)) value[key] = parsed;
+    } catch {
+      /* left as-is for the handler's own rejection */
+    }
+  }
   // Restored providers can fill every optional field. Consume only the active
   // action's payload; an absent/empty revision keeps old frozen schemas usable.
   if (ACTION_FIELDS[action].includes('revision') && value.revision != null && value.revision !== '') {

package/src/runtime/agent/orchestrator/runtime-core/tool-defs.mjs

@@ -98,8 +98,7 @@ const admitted = (tools, names) => (tools || []).filter((tool) => names.includes
 
 /**
  * Assemble this runtime's tool definitions from the loaded tool-def modules.
- * Pure: callers resolve their own availability flags (skills env gate, channel
- * ownership) and pass the already-built goal/agent tool arrays.
+ * Pure: callers resolve their own availability flags (skills env gate) and pass the already-built goal/agent tool arrays.
  *
  * - `standaloneTools` is the model-facing set (also the deferred catalog base).
  * - `internalToolDefs` adds the `public: false` web-search tools: reachable
@@ -108,7 +107,6 @@ const admitted = (tools, names) => (tools || []).filter((tool) => names.includes
 export function collectStandaloneToolDefs({
   webSearchToolDefs,
   memoryToolDefs,
-  channelToolDefs,
   codeGraphToolDefs,
   browserToolDefs = [],
   computerToolDefs = [],
@@ -119,7 +117,6 @@ export function collectStandaloneToolDefs({
   setupToolDefs = [],
   goalTools = [],
   agentTools = [],
-  isChannelTool = () => false,
   skillToolEnabled = true,
 }) {
   const webSearchRuntimeTools = admitted(webSearchToolDefs?.TOOL_DEFS, WEB_SEARCH_RUNTIME_TOOLS);
@@ -129,7 +126,6 @@ export function collectStandaloneToolDefs({
     CWD_TOOL,
     ...webSearchRuntimeTools.filter((tool) => tool?.public !== false),
     ...admitted(memoryToolDefs?.TOOL_DEFS, MEMORY_RUNTIME_TOOLS),
-    ...(channelToolDefs?.TOOL_DEFS || []).filter((tool) => isChannelTool(tool?.name)),
     ...admitted(codeGraphToolDefs?.CODE_GRAPH_TOOL_DEFS, CODE_GRAPH_RUNTIME_TOOLS),
     ...admitted(browserToolDefs, BROWSER_RUNTIME_TOOLS),
     ...admitted(computerToolDefs, COMPUTER_RUNTIME_TOOLS),

package/src/runtime/agent/orchestrator/session/context-utils.mjs

@@ -1,6 +1,13 @@
 import { createHash } from 'node:crypto';
 import { estimateTokens } from './token-estimate.mjs';
-import { beginIdentity, endIdentity, putJsonElement, putJsonString, putRaw, putShapeText } from './context-identity-writer.mjs';
+import {
+  beginIdentity,
+  endIdentity,
+  putJsonElement,
+  putJsonString,
+  putRaw,
+  putShapeText,
+} from './context-identity-writer.mjs';
 import { positiveInt } from '../../../shared/numbers.mjs';
 import { hasPlainPrototype } from '../../../shared/object.mjs';
 import { createContextFingerprinter } from './context-fingerprint.mjs';
@@ -39,19 +46,10 @@ export {
   resolveSessionCompactPolicy,
 } from './context-compaction-policy.mjs';
 
-// ---------------------------------------------------------------------------
-// Token estimation lives in ./token-estimate.mjs — a conservative
-// Unicode-aware heuristic. It is accurate ENOUGH because context pressure is
-// anchored on the provider usage baseline (the exact prompt-token count the
-// provider reports for the previous request) and the heuristic only prices the
-// delta appended since then. Measured across 5,552 real deltas the worst
-// underestimate was 2,985 tokens (1.5% of a 200K window) with a +6.5%
-// aggregate bias toward overcounting.
-//
-// providerTokenCalibration() below reconciles that estimate with actual
-// billing at the provider-aware aggregation boundary (compaction pressure /
-// context gauge), never inside the provider-agnostic per-message memo.
-// ---------------------------------------------------------------------------
+// providerTokenCalibration() below reconciles the ./token-estimate.mjs
+// heuristic with actual billing at the provider-aware aggregation boundary
+// (compaction pressure / context gauge), never inside the provider-agnostic
+// per-message memo.
 
 // Billed-prompt / estimate ratio per provider family. Env overrides let a
 // deployment recalibrate without a code change; values are clamped to a

package/src/runtime/agent/orchestrator/session/loop/send-phase.mjs

@@ -15,6 +15,7 @@ import { sendWithRecovery } from '../send-with-recovery.mjs';
 import { stripInlineImages } from '../image-strip-recovery.mjs';
 import { runWithProviderRequestToolsScope } from '../../runtime-core/provider-request-tools.mjs';
 import { REPEAT_FAIL_LIMIT } from './loop-state.mjs';
+import { createToolCallIdResolver } from './tool-call-ids.mjs';
 
 /**
  * Open an iteration: refresh the live cwd, drain queued steering after a
@@ -104,13 +105,22 @@ export async function beginIteration(state) {
     getNextIteration: () => nextIteration,
     repeatFailLimit: REPEAT_FAIL_LIMIT,
   });
+  const resolveToolCallId = createToolCallIdResolver(messages);
   opts.onToolCall = (call) => {
+    resolveToolCallId(call);
     try {
       opts.onAssistantToolCallObserved?.(call, { eagerStarted: false });
     } catch {}
     return eager.onToolCall(call);
   };
-  return { iterT0, nextIteration, sendTools: boundary.sendTools, requestToolScope: boundary.requestToolScope, eager };
+  return {
+    iterT0,
+    nextIteration,
+    sendTools: boundary.sendTools,
+    requestToolScope: boundary.requestToolScope,
+    eager,
+    resolveToolCallId,
+  };
 }
 
 /** Project the transcript for the provider and send it with recovery. */

package/src/runtime/agent/orchestrator/session/loop/tool-call-ids.mjs

@@ -0,0 +1,90 @@
+/**
+ * tool-call-ids.mjs — a tool call id is unique within a transcript.
+ *
+ * Tool results are paired to their assistant turn by id, and the pairing
+ * repairs treat a second assistant turn that reuses an id as a duplicate
+ * with no result: they drop it, so its (already executed) result never
+ * reaches the model and the model asks again, forever. Local and
+ * OpenAI-compatible servers reuse ids across turns (`call_0`, `call_1`), so
+ * a call whose id the history already carries is renamed before anything —
+ * eager dispatch, the transcript, the UI — records it.
+ */
+import { collectAssistantToolCallIds } from '../context-tool-pairs.mjs';
+
+function usedToolCallIds(messages) {
+  const used = new Set();
+  for (const message of messages) {
+    if (message?.role === 'tool' && message.toolCallId) used.add(message.toolCallId);
+    for (const id of collectAssistantToolCallIds(message)) used.add(id);
+  }
+  return used;
+}
+
+/**
+ * One resolver per provider round. A call keeps its id unless the history, an
+ * id this round already handed out, or (for the final batch) another call of
+ * the batch holds it; then it gets the smallest free `<id>-<n>`.
+ *
+ * A call is seen twice per round: streamed (`resolve`, one at a time, often a
+ * clone) and in the final batch (`resolve.all`). The n-th call carrying an
+ * original id in the final batch is the n-th streamed one, so both resolve to
+ * the same new id while two distinct calls that share an id stay distinct.
+ * Mutates and returns the calls.
+ */
+export function createToolCallIdResolver(messages) {
+  const handedOut = new Set();
+  const byCall = new WeakMap();
+  const byOriginal = new Map();
+
+  const isTaken = (id, reserved) => handedOut.has(id) || reserved.has(id) || usedToolCallIds(messages).has(id);
+
+  const allocate = (call, reserved) => {
+    const original = call.id;
+    let id = original;
+    if (isTaken(id, new Set())) {
+      let n = 2;
+      while (isTaken(`${original}-${n}`, reserved)) n += 1;
+      id = `${original}-${n}`;
+    }
+    handedOut.add(id);
+    if (!byOriginal.has(original)) byOriginal.set(original, []);
+    byOriginal.get(original).push(id);
+    byCall.set(call, { original, id });
+    call.id = id;
+    return call;
+  };
+
+  const resolve = (call) => {
+    if (!call?.id) return call;
+    const known = byCall.get(call);
+    if (known) {
+      call.id = known.id;
+      return call;
+    }
+    return allocate(call, new Set());
+  };
+
+  resolve.all = (calls) => {
+    const seen = new Map();
+    const originals = calls.map((call) => byCall.get(call)?.original ?? call?.id);
+    calls.forEach((call, index) => {
+      if (!call?.id) return;
+      const original = originals[index];
+      const nth = seen.get(original) ?? 0;
+      seen.set(original, nth + 1);
+      const known = byCall.get(call) ?? null;
+      const mapped = known?.id ?? byOriginal.get(original)?.[nth];
+      if (mapped) {
+        call.id = mapped;
+        if (!known) byCall.set(call, { original, id: mapped });
+        return;
+      }
+      // Ids later in the batch that no earlier pass has placed yet stay theirs.
+      const reserved = new Set(originals.slice(index + 1).filter(Boolean));
+      allocate(call, reserved);
+    });
+    return calls;
+  };
+
+  return resolve;
+}

package/src/runtime/agent/orchestrator/session/loop/tool-exec/before-hook.mjs

@@ -4,22 +4,30 @@
  */
 import { resolvePreToolAskApproval } from '../tool-helpers.mjs';
 import { runAbortable, throwIfAborted } from '../../../../../shared/abort-race.mjs';
+import { beginSessionApprovalWait } from '../../manager/runtime-liveness.mjs';
 
 const isArgsObject = (value) => value && typeof value === 'object' && !Array.isArray(value);
 
 async function askApproval(call, { callerSessionId, executeOpts, toolApprovalHook, decision }) {
   const askReason = String(decision?.reason || 'approval requested by hook').trim();
-  const askOutcome = await runAbortable(executeOpts.signal, () =>
-    resolvePreToolAskApproval({
-      toolName: call.name,
-      args: call.args,
-      cwd: call.cwd,
-      sessionId: callerSessionId,
-      toolCallId: executeOpts.toolCallId || null,
-      askReason,
-      toolApprovalHook,
-    })
-  );
+  // While the user decides, the session is waiting on them, not working.
+  const releaseApprovalWait = beginSessionApprovalWait(callerSessionId);
+  let askOutcome;
+  try {
+    askOutcome = await runAbortable(executeOpts.signal, () =>
+      resolvePreToolAskApproval({
+        toolName: call.name,
+        args: call.args,
+        cwd: call.cwd,
+        sessionId: callerSessionId,
+        toolCallId: executeOpts.toolCallId || null,
+        askReason,
+        toolApprovalHook,
+      })
+    );
+  } finally {
+    releaseApprovalWait();
+  }
   if (askOutcome.denial) return { denial: askOutcome.denial };
   const approval = askOutcome.approval;
   if (approval && typeof approval === 'object' && isArgsObject(approval.args)) call.args = approval.args;

package/src/runtime/agent/orchestrator/session/loop/tool-phase.mjs

@@ -18,6 +18,7 @@ export async function runToolPhase(state, round, sent, onToolCall) {
   const { opts, messages, tools, sessionId, sessionRef, signal, response, suppressMidTurnText } = state;
   state.noToolTurn.noteToolCallTurn();
   const calls = response.toolCalls;
+  round.resolveToolCallId.all(calls);
   state.toolCallsTotal += calls.length;
   // Surface any mid-turn assistant text (preamble before a tool call) to the
   // UI. Providers that stream via onTextDelta already rendered it; providers

package/src/runtime/agent/orchestrator/session/manager/runtime-liveness.mjs

@@ -19,6 +19,7 @@
 //   closed?: boolean,               // flipped by closeSession()
 // }
 import { createAbortController } from '../../../../shared/abort-controller.mjs';
+import { emitSessionApprovalWaitChange } from '../../../../shared/session-approval-wait.mjs';
 import { publishHeartbeat, deleteHeartbeat } from '../store.mjs';
 import { DEFAULT_ACTIVITY_HEARTBEAT_MS } from '../../stall-policy.mjs';
 import { finishBrowserTurn } from '../../../../browser-bridge/client.mjs';
@@ -286,6 +287,32 @@ export function markSessionToolOutputTail(id, tail) {
   entry.toolOutputTail = text ? text.slice(-4000) : null;
   entry.toolOutputTailAt = Date.now();
 }
+// A turn blocked on the user: a PreToolUse `ask` waiting for the tool
+// approval only the user can give. Published as `awaitingUser: 'approval'` so
+// status surfaces stop presenting the session as working. Counted, because one
+// tool batch can hold several approvals at once; the field clears when the
+// last one settles. Never creates an entry — a real turn always has one.
+// Returns the release, which is idempotent.
+export function beginSessionApprovalWait(id) {
+  const entry = id ? _runtimeState.get(id) : null;
+  if (!entry) return () => {};
+  entry.approvalWaits = (entry.approvalWaits || 0) + 1;
+  entry.awaitingUser = 'approval';
+  // The waiting turn: the end transition carries the begin's turn even when
+  // the turn has settled (askStartedAt cleared) by the time it releases.
+  const meta = { turnAt: entry.askStartedAt || 0 };
+  // Only the begin/end transitions are announced (the worker index persists them).
+  if (entry.approvalWaits === 1) emitSessionApprovalWaitChange(id, 'approval', meta);
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    entry.approvalWaits = Math.max(0, (entry.approvalWaits || 0) - 1);
+    if (entry.approvalWaits > 0) return;
+    entry.awaitingUser = null;
+    emitSessionApprovalWaitChange(id, null, meta);
+  };
+}
 // Parent AbortSignal listeners are dropped on askSession unwind (finally /
 // terminal return) and on error/cancel/close — not in markSessionDone, which
 // also runs between queued follow-up turns within one ask.
@@ -411,6 +438,7 @@ export function getSessionProgressSnapshot(sessionId) {
     ),
     waitingForTransport,
     waitingForFirstSemantic,
+    ...(entry.awaitingUser ? { awaitingUser: entry.awaitingUser } : {}),
   };
 }
 

package/src/runtime/agent/orchestrator/session/manager/session-prompt-composition.mjs

@@ -3,6 +3,7 @@
 // the volatile environment block that closes them, and the seed messages that
 // carry all four to the provider with their cache tiers.
 import { buildSkillManifest, composeSystemPrompt } from '../../context/collect.mjs';
+import { configuredInstructionFilesMode, loadInstructionFilesContext } from '../../context/instruction-files.mjs';
 import {
   _buildBaseRules,
   _buildAgentRules,
@@ -97,6 +98,12 @@ export function composeSessionSystem(opts, { profile, providerName, modelName, s
   // as [session, bp3EnvironmentContext], so the language block must
   // already sit at the end of this string to stay last after a refresh.
   const environmentTailContext = [shellEnvironmentContext, languageContext].filter(Boolean).join('\n\n---\n\n');
+  // User instruction files (AGENTS.md / CLAUDE.md, global then the project
+  // root's); a tool-free role and a profile skipping `claudemd` get none.
+  const instructionFilesContext =
+    toolFreeRole || profile?.skip?.claudemd
+      ? ''
+      : loadInstructionFilesContext({ mode: configuredInstructionFilesMode(), cwd: opts.cwd });
   const composed = composeSystemPrompt({
     userPrompt: opts.systemPrompt,
     agentRules: injectedRules || undefined,
@@ -108,6 +115,7 @@ export function composeSessionSystem(opts, { profile, providerName, modelName, s
     agent: resolvedAgent,
     workflowContext: opts.workflowContext || null,
     coreMemoryContext: opts.coreMemoryContext || null,
+    instructionFilesContext: instructionFilesContext || null,
     skillManifest: buildSkillManifest(skills),
     environmentContext: shellEnvironmentContext,
     provider: providerName || null,

package/src/runtime/agent/orchestrator/session/manager/session-record.mjs

@@ -78,6 +78,9 @@ export function sessionOriginFields(opts, { profile, presetObj, providerCacheOpt
     // Agent Runtime metadata — optional. Applied on every ask() to merge
     // profile-driven cache settings into provider sendOpts.
     profileId: profile?.id || null,
+    // A profile skipping `claudemd` keeps instruction files out of later
+    // empty-session prompt rebuilds too (tool-policy-refresh.mjs).
+    skipInstructionFiles: profile?.skip?.claudemd === true,
     permissionMode: opts.permissionMode ?? null,
     providerCacheOpts: providerCacheOpts || null,
     parentSessionId: opts.parentSessionId || null,

package/src/runtime/agent/orchestrator/session/manager.mjs

@@ -1,9 +1,5 @@
 // src/runtime/agent/orchestrator/session/manager.mjs
-// Thin facade over the split session-manager modules in ./manager/. This file
-// re-exports the EXACT public surface the previous monolith exposed so every
-// importer (loop.mjs, loop/tool-exec.mjs, agent-dispatch.mjs, session-builder,
-// abort-lookup, statusline-agents, headless-role, session-runtime, and the
-// smoke scripts) keeps resolving its symbols through manager.mjs unchanged.
+// Thin facade over the split session-manager modules in ./manager/.
 //
 // Module map:
 //   manager/runtime-liveness.mjs       — in-memory stage/heartbeat + accessors

package/src/runtime/agent/orchestrator/session/read-dedup.mjs

@@ -1,5 +1,4 @@
 // Thin re-export facade — re-exports all cache symbols from their split modules.
-// Existing import paths keep working unchanged.
 export * from './cache/read-cache.mjs';
 export * from './cache/scoped-cache.mjs';
 export * from './cache/prefetch-cache.mjs';

package/src/runtime/agent/orchestrator/session/store-agent-worker-rows.mjs

@@ -323,6 +323,9 @@ function projectChildWorkerRow(row, { now, heartbeatMtimes }) {
     fast: row.fast === true || session?.fast === true,
     status: declaredWorking && !working ? 'unknown' : declaredStatus,
     stage: declaredWorking && !working ? 'unknown' : declaredStage,
+    // A live turn blocked on the user's approval (persisted by the agent
+    // tool's worker index); never carried by a row that is no longer working.
+    ...(working && row.awaitingUser === 'approval' ? { awaitingUser: 'approval' } : {}),
     startedAt: row.startedAt || row.createdAt || session?.createdAt || null,
     turnStartedAt: working ? row.turnStartedAt || null : null,
     createdAt: row.createdAt || session?.createdAt || null,

package/src/runtime/agent/orchestrator/session/tool-batch/finalize.mjs

@@ -15,6 +15,7 @@ import { crossTurnSignature, isEditProgressTool } from '../loop/completion-guard
 import { isEagerDispatchable, isToolCallDedupEligible, parseNativeToolSearchPayload } from '../loop/tool-helpers.mjs';
 import { restoreToolCallBodyForId } from '../loop/stored-tool-args.mjs';
 import { stageToolResult } from './state.mjs';
+import { toolMetaPatchFromMessage } from '../transcript-restore/tool-result-status.mjs';
 import {
   compactToolResultImage,
   resizeImageBuffer,
@@ -281,6 +282,7 @@ function completedToolResult(completed, result, postprocessStartedAt) {
     toolTiming: toolTiming(completed, postprocessStartedAt),
     ...(completed.nativeToolSearch ? { nativeToolSearch: completed.nativeToolSearch } : {}),
     ...(uiDiff !== null ? { uiDiff } : {}),
+    ...toolMetaPatchFromMessage(completed.result),
   };
 }
 

package/src/runtime/agent/orchestrator/session/transcript-restore/restore.mjs

@@ -23,6 +23,7 @@ import {
   aggregateLoadingTargets,
   aggregateRawResult,
   aggregateResultPatch,
+  assignToolMetaFromMessage,
   assignUiDiffFromMessage,
   mergeAggregateCategoryEntries,
   stringUiDiffPatch,
@@ -131,6 +132,7 @@ function attachRestoredToolResult(message, pendingByCallId) {
   const text = (typeof message?.content === 'string' ? message.content : toolResultText(message?.content)) || '';
   target.result = text;
   assignUiDiffFromMessage(target, message);
+  assignToolMetaFromMessage(target, message);
   // Cancel/crash control bodies are not red failures — show Cancelled tone.
   if (toolResultTerminalStatus(text) === 'cancelled') {
     target.isError = false;