mixdog 0.9.174 → 1.0.0

package/src/runtime/agent/orchestrator/runtime-core/goal-tasks.mjs

@@ -0,0 +1,148 @@
+import { GOAL_TASK_SETTLED, GOAL_TASK_STATUSES, MAX_GOAL_TASKS, MAX_GOAL_TASK_TEXT_LENGTH } from './goal-tool-defs.mjs';
+import { clean } from '../../../shared/clean.mjs';
+
+// Fields a task entry or patch may carry. 'kind' is a retired field: stored
+// records and frozen provider schemas still send it, so it is accepted and
+// dropped on normalize rather than rejected.
+const TASK_ENTRY_FIELDS = ['id', 'text', 'status', 'kind'];
+
+// Dropped rows remain in the record but are no longer requested work.
+export function goalTaskProgress(tasks) {
+  return {
+    tasksCompleted: tasks.filter((task) => task?.status === 'completed').length,
+    tasksTotal: tasks.filter((task) => task?.status !== 'dropped').length,
+  };
+}
+
+// Frozen schemas can populate every optional array with an anonymous blank
+// row. Only discard that filler for optional lifecycle changes; addressed,
+// populated, or malformed rows must still reach the normal validators.
+export function optionalGoalTaskChanges({ tasks, updates } = {}) {
+  const populated = (entry) =>
+    !entry ||
+    typeof entry !== 'object' ||
+    Array.isArray(entry) ||
+    clean(entry.id) ||
+    clean(entry.text) ||
+    Object.keys(entry).some((key) => !TASK_ENTRY_FIELDS.includes(key));
+  return {
+    tasks: Array.isArray(tasks) ? tasks.filter(populated) : tasks,
+    updates: Array.isArray(updates) ? updates.filter(populated) : updates,
+  };
+}
+
+export function normalizeGoalTasks(input, previous = [], { strict = false } = {}) {
+  if (input == null) return previous.map((task) => ({ ...task }));
+  if (!Array.isArray(input)) throw new Error('goal tasks must be an array');
+  if (input.length > MAX_GOAL_TASKS) {
+    // Settled rows count toward the cap; set_tasks may omit them (only
+    // unfinished tasks must be retained), which is how a long Goal makes room.
+    const settled = previous.some((task) => GOAL_TASK_SETTLED.includes(task?.status));
+    throw new Error(
+      `goal tasks support at most ${MAX_GOAL_TASKS} entries${
+        settled
+          ? '; completed and dropped tasks count, so to add more send set_tasks with only the unfinished tasks plus the new ones'
+          : ''
+      }`
+    );
+  }
+  const previousByText = new Map(previous.map((task) => [clean(task?.text), task]));
+  const reservedIds = new Set([...previous, ...input].map((task) => clean(task?.id)).filter(Boolean));
+  let nextId = 1;
+  for (const id of reservedIds) {
+    const match = /^task_(\d+)$/.exec(id);
+    if (
+      match &&
+      Number.isSafeInteger(Number(match[1])) &&
+      Number(match[1]) < Number.MAX_SAFE_INTEGER - MAX_GOAL_TASKS
+    ) {
+      nextId = Math.max(nextId, Number(match[1]) + 1);
+    }
+  }
+  const seenText = new Set();
+  const seenIds = new Set();
+  return input.map((entry, index) => {
+    const source = typeof entry === 'string' ? { text: entry, status: 'pending' } : entry;
+    if (!source || typeof source !== 'object') throw new Error(`goal task ${index + 1} is invalid`);
+    const text = clean(source.text);
+    if (!text) throw new Error('goal task text is required');
+    if ([...text].length > MAX_GOAL_TASK_TEXT_LENGTH)
+      throw new Error(`goal task exceeds ${MAX_GOAL_TASK_TEXT_LENGTH} characters`);
+    if (seenText.has(text)) throw new Error(`duplicate goal task: ${text}`);
+    seenText.add(text);
+    const id = clean(source.id) || clean(previousByText.get(text)?.id) || `task_${nextId++}`;
+    if (seenIds.has(id)) throw new Error(`duplicate goal task id: ${id}`);
+    seenIds.add(id);
+    const rawStatus = clean(source.status).toLowerCase();
+    if (strict && !GOAL_TASK_STATUSES.includes(rawStatus))
+      throw new Error(`goal task ${index + 1} has an invalid status`);
+    let status = source.satisfied === true ? 'completed' : 'pending';
+    if (GOAL_TASK_STATUSES.includes(rawStatus)) status = rawStatus;
+    return { id, text, status };
+  });
+}
+
+function taskInputRetains(entry, task) {
+  if (typeof entry === 'string') return clean(entry) === task.text;
+  if (!entry || typeof entry !== 'object') return false;
+  return clean(entry.id) ? clean(entry.id) === task.id : clean(entry.text) === task.text;
+}
+
+export function patchGoalTasks(previous, { updates, tasks } = {}) {
+  const patches = updates ?? [];
+  const additions = tasks ?? [];
+  if (!Array.isArray(patches) || !Array.isArray(additions)) throw new Error('goal updates and tasks must be arrays');
+  if (!patches.length && !additions.length) throw new Error('goal update_tasks requires updates or new tasks');
+  if (patches.length > MAX_GOAL_TASKS) throw new Error(`goal updates support at most ${MAX_GOAL_TASKS} entries`);
+  const byId = new Map(previous.map((task) => [task.id, { ...task }]));
+  const seen = new Set();
+  for (const patch of patches) {
+    const id = clean(patch?.id);
+    if (!id || !byId.has(id)) throw new Error(`unknown Goal task id: ${id || '(missing)'}`);
+    if (seen.has(id)) throw new Error(`duplicate Goal task update: ${id}`);
+    seen.add(id);
+    if (Object.keys(patch).some((key) => !TASK_ENTRY_FIELDS.includes(key)))
+      throw new Error(`unknown Goal task update field for ${id}`);
+    byId.set(id, { ...byId.get(id), ...patch, id });
+  }
+  if (additions.some((task) => clean(task?.id)))
+    throw new Error('new Goal tasks must omit ids; use updates for existing tasks');
+  return normalizeGoalTasks([...byId.values(), ...additions], previous, { strict: true });
+}
+
+// Prepare a working copy without publishing it. Lifecycle actions can include
+// task changes in the same durable commit instead of exposing an intermediate
+// paused/active snapshot or consuming two revisions.
+export function applyGoalTaskChanges(goal, args = {}, { partial = false, at = Date.now() } = {}) {
+  if (['complete', 'stopped'].includes(goal.status))
+    throw new Error('cannot update tasks for a completed or stopped Goal');
+  if (!partial && (!Array.isArray(args.tasks) || args.tasks.length === 0)) {
+    throw new Error('goal set_tasks requires at least one task');
+  }
+  if (partial && goal.tasksObjectiveRevision !== goal.objectiveRevision) {
+    throw new Error(
+      'Goal objective changed; read status and reconcile the full task list with set_tasks before partial updates'
+    );
+  }
+  const previousTasks = normalizeGoalTasks(goal.tasks || []);
+  const input = partial ? patchGoalTasks(previousTasks, args) : args.tasks;
+  const omitted = previousTasks.filter(
+    (task) => !GOAL_TASK_SETTLED.includes(task.status) && !input.some((entry) => taskInputRetains(entry, task))
+  );
+  if (omitted.length > 0) {
+    const detail = omitted.map((task) => `${task.id} (${task.text})`).join(', ');
+    throw new Error(`cannot remove unfinished Goal tasks: ${detail}`);
+  }
+  const nextTasks = normalizeGoalTasks(input, previousTasks, { strict: true });
+  // Re-sending the same tasks is not progress. A newly dropped task must
+  // survive this turn before completion can retire the requested work.
+  if (JSON.stringify(nextTasks) !== JSON.stringify(previousTasks)) goal.tasksUpdatedAt = at;
+  const droppedNow = nextTasks.some(
+    (task) => task.status === 'dropped' && previousTasks.find((prev) => prev.id === task.id)?.status !== 'dropped'
+  );
+  if (droppedNow) goal.lastDropTurn = Math.max(0, Math.floor(Number(goal.turnCount) || 0));
+  goal.tasks = nextTasks;
+  goal.tasksObjectiveRevision = goal.objectiveRevision;
+  goal.updatedAt = at;
+  return goal;
+}

package/src/{session-runtime → runtime/agent/orchestrator/runtime-core}/goal-title.mjs

@@ -5,8 +5,8 @@
  */
 import { compactSessionTitle, SESSION_TITLE_TIMEOUT_MS } from './session-title.mjs';
 import { assertSessionId } from './goal-state.mjs';
-import { clean } from '../runtime/shared/clean.mjs';
-import { runAbortable } from '../runtime/shared/abort-race.mjs';
+import { clean } from '../../../shared/clean.mjs';
+import { runAbortable } from '../../../shared/abort-race.mjs';
 
 export function createGoalTitleScheduler(ctx) {
   const { titleJobs, now, generateTitle } = ctx;

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

@@ -0,0 +1,140 @@
+export const MAX_GOAL_TIME_LIMIT_MS = 7 * 24 * 60 * 60 * 1000;
+export const GOAL_TASK_STATUSES = Object.freeze([
+  'pending',
+  'in_progress',
+  'completed',
+  'dropped',
+  'awaiting_approval',
+]);
+export const GOAL_TASK_SETTLED = Object.freeze(['completed', 'dropped']);
+export const MAX_GOAL_TASKS = 20;
+export const MAX_GOAL_TASK_TEXT_LENGTH = 500;
+
+const taskFields = {
+  id: { type: 'string', description: 'Stable task id; omit only for new tasks.' },
+  text: {
+    type: 'string',
+    minLength: 1,
+    maxLength: MAX_GOAL_TASK_TEXT_LENGTH,
+    description: 'Required work or verification outcome.',
+  },
+  status: {
+    type: 'string',
+    enum: GOAL_TASK_STATUSES,
+    description:
+      "completed only when fully done; dropped only after user scope change; awaiting_approval only for the user's own action or out-of-scope work (e.g. unrequested commit).",
+  },
+};
+
+export const GOAL_TOOL_DEFS = Object.freeze([
+  {
+    name: 'goal',
+    title: 'Goal',
+    description: [
+      'Durable tasks with an idle reminder for unfinished work. Create for an explicit Goal request, or approved work spanning several rounds or turns: staged refactors and migrations, repeated improvement passes, open-ended objectives that must be finished, with or without a time budget. Single-turn tasks, planning or estimates alone, and unaccepted proposals do not qualify.',
+      'Obtain required approval, load the goal-management skill for lifecycle and completion policy, then create or reconcile the Goal before starting approved work. Mutations need the latest revision.',
+    ].join(' '),
+    annotations: {
+      title: 'Goal',
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: false,
+      agentHidden: true,
+    },
+    inputSchema: {
+      type: 'object',
+      properties: {
+        action: {
+          type: 'string',
+          enum: ['status', 'create', 'pause', 'resume', 'set_tasks', 'update_tasks', 'complete', 'block', 'abandon'],
+          description:
+            "create starts approved work once any previous Goal has ended; resume continues unfinished work with optional time and task changes; set_tasks replaces, update_tasks patches/adds; pause only at the user's explicit request; abandon retires superseded work.",
+        },
+        objective: { type: 'string', description: 'create: requested outcome.' },
+        time_limit_minutes: {
+          type: 'number',
+          minimum: 1,
+          maximum: MAX_GOAL_TIME_LIMIT_MS / 60_000,
+          description:
+            'create: approved total budget, omitted when none was agreed. resume: approved remaining budget from now, keeping time already used; another 5-hour round sets 300. Omit to preserve the current budget.',
+        },
+        time_mode: {
+          type: 'string',
+          enum: ['max', 'duration'],
+          description:
+            'duration commits the full period, the create default with a budget ("5-hour rounds"); max permits verified early completion, only for a stated cap ("at most", "within"). Resume keeps the mode; change it only with user approval.',
+        },
+        tasks: {
+          type: 'array',
+          minItems: 1,
+          maxItems: MAX_GOAL_TASKS,
+          items: {
+            type: 'object',
+            properties: taskFields,
+            required: ['text', 'status'],
+            additionalProperties: false,
+          },
+          description: `create/set_tasks: full list; update_tasks/resume: new tasks, no ids. Max ${MAX_GOAL_TASKS} total, including completed/dropped.`,
+        },
+        updates: {
+          type: 'array',
+          minItems: 1,
+          maxItems: MAX_GOAL_TASKS,
+          items: {
+            type: 'object',
+            properties: { ...taskFields, id: { type: 'string', description: 'Existing task id.' } },
+            required: ['id'],
+            additionalProperties: false,
+          },
+          description: 'update_tasks/resume: existing task ids with only changed fields.',
+        },
+        revision: {
+          type: 'integer',
+          minimum: 1,
+          description: 'Latest Goal revision from a result or reminder; use for mutations other than create.',
+        },
+        blocker: {
+          type: 'string',
+          minLength: 1,
+          maxLength: 1_000,
+          description:
+            'block: stable description of the same impasse only external state or the user can clear, reported once per turn; the runtime stops after 3.',
+        },
+      },
+      required: ['action'],
+      additionalProperties: false,
+    },
+  },
+]);
+
+const ACTION_FIELDS = Object.freeze({
+  status: ['action'],
+  create: ['action', 'objective', 'time_limit_minutes', 'time_mode', 'tasks'],
+  pause: ['action', 'revision'],
+  resume: ['action', 'time_limit_minutes', 'time_mode', 'tasks', 'updates', 'revision'],
+  set_tasks: ['action', 'tasks', 'revision'],
+  update_tasks: ['action', 'tasks', 'updates', 'revision'],
+  complete: ['action', 'revision'],
+  block: ['action', 'blocker', 'revision'],
+  abandon: ['action', 'revision'],
+});
+const TOOL_FIELDS = new Set(Object.values(ACTION_FIELDS).flat());
+
+export function validateGoalToolCall(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error('goal arguments must be an object');
+  const action = String(value.action ?? '')
+    .trim()
+    .toLowerCase();
+  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(', ')}`);
+  // 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 !== '') {
+    if (!Number.isSafeInteger(value.revision) || value.revision < 1)
+      throw new Error('goal revision must be a positive integer');
+  }
+  return action;
+}

package/src/{session-runtime → runtime/agent/orchestrator/runtime-core}/goal-turns.mjs

@@ -16,7 +16,7 @@ import {
 } from './goal-state.mjs';
 import { goalFinished } from './goal-mutations.mjs';
 import { observeGoal } from './goal-tool-exec.mjs';
-import { clean } from '../runtime/shared/clean.mjs';
+import { clean } from '../../../shared/clean.mjs';
 
 // Every recorded task is settled while a requested duration still has time.
 // Completed rows neither complete the objective nor shorten its duration, so

package/src/runtime/agent/orchestrator/runtime-core/model-capabilities.mjs

@@ -0,0 +1,140 @@
+// Provider/model capability probes: fast-tier + hosted web-search support, and
+// in-memory model-settings updates. saveModelSettings returns the next config;
+// callers persist via saveConfigAndAdopt so a new-task setWorkflow debounce
+// never collides with a sync mixdog-config lock (ELOCKCONTENDED).
+import { clean, hasOwn } from './session-text.mjs';
+import { modelSupportsServiceTier } from '../providers/model-service-tiers.mjs';
+import { openAiDirectSupportsFast } from '../providers/openai-direct-request.mjs';
+
+const FAST_CAPABLE_PROVIDERS = new Set([
+  'anthropic',
+  'anthropic-oauth',
+  'openai',
+  'openai-oauth',
+  'cursor-oauth',
+  'cursor-api',
+]);
+export const LAZY_SECRET_PROVIDERS = new Set(['openai-oauth', 'anthropic-oauth', 'grok-oauth']);
+
+export function routeFastKey(provider, model) {
+  const p = clean(provider);
+  const m = clean(model);
+  return p && m ? `${p}/${m}` : '';
+}
+
+function openAiModelSupportsHostedWebSearch(model) {
+  const id = clean(model?.id || model).toLowerCase();
+  if (!id) return false;
+  if (model?.supportsWebSearch === true) return true;
+  const tools = [
+    ...(Array.isArray(model?.supportedTools) ? model.supportedTools : []),
+    ...(Array.isArray(model?.tools) ? model.tools : []),
+    ...(Array.isArray(model?.capabilities?.tools) ? model.capabilities.tools : []),
+  ].map((tool) => clean(tool?.type || tool?.name || tool).toLowerCase());
+  if (tools.some((tool) => tool === 'web_search' || tool === 'web_search_preview')) return true;
+  if (/codex|image|audio|tts|stt|embedding|rerank|moderation|search-preview/.test(id)) return false;
+  return /^gpt-(5(?:\.|$|-)|4\.1(?:-|$)|4o(?:-|$)|4\.5(?:-|$))/.test(id) || /^o[34](?:-|$)/.test(id);
+}
+
+function grokModelSupportsHostedWebSearch(model) {
+  const id = clean(model?.id || model).toLowerCase();
+  if (!id || /imagine|image|video|composer/.test(id)) return false;
+  if (id === 'grok-build') return false;
+  return /^grok-/.test(id);
+}
+
+function geminiModelSupportsHostedWebSearch(model) {
+  const id = clean(model?.id || model).toLowerCase();
+  if (!id || /embedding|aqa|imagen|veo|tts|image|computer-use|customtools/.test(id)) return false;
+  return /^gemini-(3(?:\.|-|$)|2\.5-|2\.0-flash)/.test(id);
+}
+
+function anthropicModelSupportsHostedWebSearch(model) {
+  const id = clean(model?.id || model).toLowerCase();
+  if (!id) return false;
+  const match = id.match(/^claude-(opus|sonnet|haiku)-(\d+)(?:[-.](\d+))?/);
+  if (!match) return false;
+  return (Number(match[2]) || 0) >= 4;
+}
+
+function anthropicModelMetaSupportsFast(model) {
+  const id = clean(model?.id || model).toLowerCase();
+  return /^claude-(opus|sonnet)/.test(id);
+}
+
+export function fastCapableFor(provider, model, effort = null, modelParameters = {}) {
+  const p = clean(provider);
+  if (!FAST_CAPABLE_PROVIDERS.has(p)) return false;
+  if (p === 'cursor-oauth' || p === 'cursor-api') {
+    const fastEfforts = Array.isArray(model?.fastEfforts) ? model.fastEfforts.map(clean) : [];
+    if (model?.fastCapable !== true && fastEfforts.length === 0) return false;
+    const selectedEffort = clean(effort);
+    if (Array.isArray(model?.parameterVariants) && model.parameterVariants.length) {
+      const parameters = modelParameters && typeof modelParameters === 'object' ? modelParameters : {};
+      return model.parameterVariants.some(
+        (variant) =>
+          variant?.fast === 'true' &&
+          (!selectedEffort || !variant.effort || clean(variant.effort) === selectedEffort) &&
+          Object.entries(parameters).every(([key, value]) => !variant?.[key] || clean(variant[key]) === clean(value))
+      );
+    }
+    return !selectedEffort || fastEfforts.length === 0 || fastEfforts.includes(selectedEffort);
+  }
+  if (p === 'openai') return openAiDirectSupportsFast(model);
+  if (p === 'openai-oauth') return modelSupportsServiceTier(model, 'priority');
+  if (p === 'anthropic' || p === 'anthropic-oauth') return anthropicModelMetaSupportsFast(model);
+  return false;
+}
+
+// webSearchCapableFor needs the web-search-route normalizers, which live in
+// workflow.mjs and themselves are pure. Wire them in via a factory to keep
+// this module free of a circular import at load time.
+export function makeWebSearchCapableFor(normalizeWebSearchProviderId, isWebSearchCapableProvider) {
+  return function webSearchCapableFor(provider, model) {
+    const p = normalizeWebSearchProviderId(provider);
+    if (!isWebSearchCapableProvider(p)) return false;
+    if (p === 'openai' || p === 'openai-oauth') return openAiModelSupportsHostedWebSearch(model);
+    if (p === 'grok-oauth' || p === 'xai') return grokModelSupportsHostedWebSearch(model);
+    if (p === 'gemini') return geminiModelSupportsHostedWebSearch(model);
+    if (p === 'anthropic' || p === 'anthropic-oauth') return anthropicModelSupportsHostedWebSearch(model);
+    return model?.supportsWebSearch === true;
+  };
+}
+
+export function fastPreferenceFor(config, provider, model) {
+  const key = routeFastKey(provider, model);
+  if (!key) return false;
+  const saved = config?.modelSettings?.[key];
+  return Boolean(saved && typeof saved === 'object' && saved.fast === true);
+}
+
+export function saveModelSettings(cfgMod, route, { fastCapable = true, baseConfig = null } = {}) {
+  const key = routeFastKey(route?.provider, route?.model);
+  if (!key) return baseConfig || cfgMod.loadConfig();
+  const nextConfig = baseConfig || cfgMod.loadConfig();
+  const modelSettings = { ...(nextConfig.modelSettings || {}) };
+  const nextSetting = { ...(modelSettings[key] || {}) };
+  if (hasOwn(route, 'effort') && route.effort) nextSetting.effort = route.effort;
+  else delete nextSetting.effort;
+  if (fastCapable) nextSetting.fast = route.fast === true;
+  else nextSetting.fast = false;
+  if (route.modelParameters && typeof route.modelParameters === 'object') {
+    nextSetting.modelParameters = Object.fromEntries(
+      Object.entries(route.modelParameters)
+        .map(([key, value]) => [clean(key), clean(value)])
+        .filter(([key, value]) => key && value)
+    );
+  } else {
+    delete nextSetting.modelParameters;
+  }
+  const contextPercent = Number(route.contextPercent);
+  if (Number.isFinite(contextPercent) && contextPercent >= 10 && contextPercent <= 100) {
+    nextSetting.contextPercent = Math.round(contextPercent / 10) * 10;
+  } else {
+    delete nextSetting.contextPercent;
+  }
+  modelSettings[key] = nextSetting;
+
+  const savedConfig = { ...nextConfig, modelSettings };
+  return savedConfig;
+}

package/src/{session-runtime → runtime/agent/orchestrator/runtime-core}/orchestration.mjs

@@ -1,4 +1,4 @@
-import { normalizeOrchestrationMode } from '../runtime/shared/orchestration.mjs';
+import { normalizeOrchestrationMode } from '../../../shared/orchestration.mjs';
 
 const BATCHING = {
   focused: `Lead executes the main scope directly. Delegate only substantial,

package/src/{session-runtime → runtime/agent/orchestrator/runtime-core}/plugin-mcp.mjs

@@ -15,8 +15,8 @@ import {
 import { isAbsolute, join } from 'node:path';
 import { clean } from './session-text.mjs';
 import { readJsonSafe } from './fs-utils.mjs';
-import { pluginManifest, pluginSkillsRoots, resolveContainedPluginPath } from '../runtime/shared/plugin-manifest.mjs';
-import { isPlainObject } from '../runtime/shared/object.mjs';
+import { pluginManifest, pluginSkillsRoots, resolveContainedPluginPath } from '../../../shared/plugin-manifest.mjs';
+import { isPlainObject } from '../../../shared/object.mjs';
 
 const MCP_TRANSPORT_FIELDS = new Set([
   'type',

package/src/runtime/agent/orchestrator/runtime-core/session-id.mjs

@@ -0,0 +1,2 @@
+/** A session id is a filename-safe slug; anything else never addresses a session. */
+export const SESSION_ID_PATTERN = /^[A-Za-z0-9_-]+$/;

package/src/{session-runtime → runtime/agent/orchestrator/runtime-core}/session-route-policy.mjs

@@ -1,5 +1,5 @@
-import { SUMMARY_PREFIX } from '../runtime/agent/orchestrator/session/compact.mjs';
-import { hasUserConversationMessage } from '../runtime/agent/orchestrator/session/manager/prompt-utils.mjs';
+import { SUMMARY_PREFIX } from '../session/compact.mjs';
+import { hasUserConversationMessage } from '../session/manager/prompt-utils.mjs';
 
 /** A real user exchange, or the summary anchor a compaction left behind. */
 export function hasRouteHistoryMessage(messages) {

package/src/{session-runtime → runtime/agent/orchestrator/runtime-core}/session-text.mjs

@@ -1,6 +1,6 @@
 // Session message/preview text helpers. Pure, no runtime-closure deps.
-import { clean } from '../runtime/shared/clean.mjs';
-import { stripInjectedBlocks } from '../runtime/shared/injected-display-text.mjs';
+import { clean } from '../../../shared/clean.mjs';
+import { stripInjectedBlocks } from '../../../shared/injected-display-text.mjs';
 
 export function sessionMessageText(content) {
   if (content == null) return '';
@@ -102,7 +102,7 @@ export function isLateToolAnnouncement(text) {
   return value.includes(LATE_TOOL_ANNOUNCEMENT_SENTINEL) && /<available-deferred-tools>/i.test(value);
 }
 
-export { hasOwn } from '../runtime/shared/object.mjs';
+export { hasOwn } from '../../../shared/object.mjs';
 
 export { clean };
 

package/src/{session-runtime → runtime/agent/orchestrator/runtime-core}/session-title.mjs

@@ -166,8 +166,7 @@ export function createSessionTitleController(deps = {}) {
       const raw = await Promise.race([
         Promise.resolve().then(async () => {
           const complete =
-            deps.generateSessionTitle ||
-            (await import('../runtime/agent/orchestrator/agent-runtime/title-completion.mjs')).generateSessionTitle;
+            deps.generateSessionTitle || (await import('../agent-runtime/title-completion.mjs')).generateSessionTitle;
           if (disposed) return '';
           return complete(source, {
             signal: abort.signal,

package/src/{session-runtime → runtime/agent/orchestrator/runtime-core}/skill-tool-loading.mjs

@@ -1,7 +1,7 @@
 // Skill dependencies use the existing deferred registry. Native providers keep
 // definitions out of the eager prefix; selection never changes permission policy.
 import { deferredCatalogUnion, selectDeferredTools, toolSearchNativePayload } from './tool-catalog.mjs';
-import { preDispatchDenyForSession } from '../runtime/agent/orchestrator/session/loop/pre-dispatch-deny.mjs';
+import { preDispatchDenyForSession } from '../session/loop/pre-dispatch-deny.mjs';
 
 export function loadSkillToolDependencies(envelope, session, mode) {
   if (!envelope?.__toolEnvelope) return envelope;

package/src/{session-runtime → runtime/agent/orchestrator/runtime-core}/tool-catalog-schema.mjs

@@ -1,6 +1,6 @@
 // Tool schema/kind classification + measured-usage ordering.
 import { clean } from './session-text.mjs';
-import { estimateToolSchemaTokens, toolSchemaSignature } from '../runtime/agent/orchestrator/session/context-utils.mjs';
+import { estimateToolSchemaTokens, toolSchemaSignature } from '../session/context-utils.mjs';
 import {
   finalizeProviderRequestTools,
   isFinalizedProviderRequestTools,