mixdog 0.9.174 → 1.0.0

package/src/session-runtime/goal-tasks.mjs

@@ -1,137 +1 @@
-import { GOAL_TASK_SETTLED, GOAL_TASK_STATUSES, MAX_GOAL_TASKS, MAX_GOAL_TASK_TEXT_LENGTH } from './goal-tool-defs.mjs';
-import { clean } from '../runtime/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) throw new Error(`goal tasks support at most ${MAX_GOAL_TASKS} entries`);
-  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;
-}
+export * from '../runtime/agent/orchestrator/runtime-core/goal-tasks.mjs';

package/src/session-runtime/goal-tool-defs.mjs

@@ -1,140 +1 @@
-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;
-}
+export * from '../runtime/agent/orchestrator/runtime-core/goal-tool-defs.mjs';

package/src/session-runtime/hook-payload.mjs

@@ -3,16 +3,15 @@
  * dispatch (session id, transcript path, cwd, permission mode, effort).
  */
 import { join } from 'node:path';
-import { clean } from './session-text.mjs';
-import { STANDALONE_DATA_DIR } from './runtime-paths.mjs';
-import { SESSION_ID_PATTERN } from './lifecycle/shared.mjs';
+import { clean } from '../runtime/agent/orchestrator/runtime-core/session-text.mjs';
+import { pluginDataDir } from './runtime-paths.mjs';
+import { SESSION_ID_PATTERN } from '../runtime/agent/orchestrator/runtime-core/session-id.mjs';
 
 export function createHookPayload({ rt, cfgMod }) {
   function hookTranscriptPath(sessionId) {
     const id = clean(sessionId);
     if (!id || !SESSION_ID_PATTERN.test(id)) return null;
-    const dataDir = cfgMod.getPluginData?.() || STANDALONE_DATA_DIR;
-    return join(dataDir, 'sessions', `${id}.json`);
+    return join(pluginDataDir(cfgMod), 'sessions', `${id}.json`);
   }
   function hookEffortPayload() {
     const level = clean(rt.route.effectiveEffort || rt.route.effort);

package/src/session-runtime/internal-tool-executor/bridge-tools.mjs

@@ -3,12 +3,12 @@
 import { executeBrowserTool } from '../../runtime/browser-bridge/client.mjs';
 import { executeComputerTool } from '../../runtime/computer-bridge/client.mjs';
 import { createBridgeFirstUseGate } from '../bridge-first-use-gate.mjs';
-import { featureEnvOverride } from '../config-helpers.mjs';
+import { featureEnvOverride } from '../../runtime/agent/orchestrator/runtime-core/config-helpers.mjs';
+import { createCallerContextResolvers } from './caller-context.mjs';
 
 export function createBridgeToolHandlers({ rt }) {
   const bridgeFirstUseGate = createBridgeFirstUseGate({ getConfig: () => rt.config });
-  const sessionIdFor = (callerCtx) => callerCtx?.sessionId || callerCtx?.callerSessionId || rt.session?.id;
-  const signalFor = (callerCtx) => callerCtx?.signal || rt.session?.controller?.signal || null;
+  const { sessionIdFor, signalFor } = createCallerContextResolvers(rt);
 
   // Browser Use and Computer Use ask the user once per session before their
   // first live call; the answer is the tool result when it is no.

package/src/session-runtime/internal-tool-executor/caller-context.mjs

@@ -0,0 +1,8 @@
+// Resolvers shared by the internal tool handlers: which session and abort
+// signal a call runs under, preferring the caller's context over the runtime's.
+export function createCallerContextResolvers(rt) {
+  return {
+    sessionIdFor: (callerCtx) => callerCtx?.sessionId || callerCtx?.callerSessionId || rt.session?.id,
+    signalFor: (callerCtx) => callerCtx?.signal || rt.session?.controller?.signal || null,
+  };
+}

package/src/session-runtime/internal-tool-executor/feature-tools.mjs

@@ -1,9 +1,10 @@
 // Optional feature tools gated by settings for model-initiated calls: office,
 // media and tidy (each loaded on first use), and the setup tool.
 import { STANDALONE_DATA_DIR } from '../runtime-paths.mjs';
+import { createCallerContextResolvers } from './caller-context.mjs';
 
 export function createFeatureToolHandlers({ rt, setupTool, officeToolsEnabled, mediaToolEnabled, tidyToolEnabled }) {
-  const signalFor = (callerCtx) => callerCtx?.signal || rt.session?.controller?.signal || null;
+  const { sessionIdFor, signalFor } = createCallerContextResolvers(rt);
   const requireEnabled = (callerCtx, enabled, label) => {
     if (callerCtx?.invocationSource === 'model-tool' && !enabled()) {
       throw new Error(`${label} is disabled in settings; start a new session to refresh the tool list`);
@@ -33,7 +34,7 @@ export function createFeatureToolHandlers({ rt, setupTool, officeToolsEnabled, m
       const { executeTidyTool } = await import('../../runtime/tidy/tool.mjs');
       return await executeTidyTool(args, {
         cwd: callerCwd,
-        sessionId: callerCtx?.sessionId || callerCtx?.callerSessionId || rt.session?.id,
+        sessionId: sessionIdFor(callerCtx),
         signal: signalFor(callerCtx),
       });
     },

package/src/session-runtime/internal-tool-executor/knowledge-tools.mjs

@@ -1,7 +1,8 @@
 // Tools that read rather than act: web search/fetch, memory, the code graph,
 // the deferred tool catalog, and skill bodies.
-import { refreshDeferredMcpToolCatalog, renderToolSearch } from '../tool-catalog.mjs';
+import { refreshDeferredMcpToolCatalog, renderToolSearch } from '../../runtime/agent/orchestrator/runtime-core/tool-catalog.mjs';
 import { dispatchWebSearchRuntimeTool, memoryToolArgsForCaller } from '../runtime-tool-routing.mjs';
+import { createCallerContextResolvers } from './caller-context.mjs';
 
 export function createKnowledgeToolHandlers({
   rt,
@@ -14,6 +15,7 @@ export function createKnowledgeToolHandlers({
   mcpStatus,
   skillToolContent,
 }) {
+  const { signalFor } = createCallerContextResolvers(rt);
   const webSearch = (args, { name, callerCtx }) =>
     dispatchWebSearchRuntimeTool(name, args, callerCtx, {
       getWebSearchModule,
@@ -26,11 +28,7 @@ export function createKnowledgeToolHandlers({
   const memory = async (args, { name, callerCtx, callerCwd }) => {
     const memoryMod = await getMemoryModule();
     if (!memoryMod?.handleToolCall) throw new Error('memory runtime is not available');
-    return await memoryMod.handleToolCall(
-      name,
-      memoryToolArgsForCaller(args, callerCwd),
-      callerCtx?.signal || rt.session?.controller?.signal || null
-    );
+    return await memoryMod.handleToolCall(name, memoryToolArgsForCaller(args, callerCwd), signalFor(callerCtx));
   };
 
   const toolSearch = (args) => {

package/src/session-runtime/internal-tool-executor/workspace-tools.mjs

@@ -2,8 +2,8 @@
 // agent dispatch.
 import { statSync } from 'node:fs';
 import { resolve } from 'node:path';
-import { listProjects } from '../../standalone/projects.mjs';
-import { clean } from '../session-text.mjs';
+import { listProjects } from '../../runtime/shared/projects.mjs';
+import { clean } from '../../runtime/agent/orchestrator/runtime-core/session-text.mjs';
 
 export function createWorkspaceToolHandlers({ rt, goalRuntime, agentTool, notifyFnForSession, applyResolvedCwd }) {
   const cwd = async (args, { callerCtx, callerCwd }) => {

package/src/session-runtime/internal-tool-executor.mjs

@@ -5,7 +5,7 @@
  * applies the model-call feature guards, dispatches by name, and falls through
  * to channel tools.
  */
-import { clean } from './session-text.mjs';
+import { clean } from '../runtime/agent/orchestrator/runtime-core/session-text.mjs';
 import { createBridgeToolHandlers } from './internal-tool-executor/bridge-tools.mjs';
 import { createFeatureToolHandlers } from './internal-tool-executor/feature-tools.mjs';
 import { createKnowledgeToolHandlers } from './internal-tool-executor/knowledge-tools.mjs';

package/src/session-runtime/lifecycle/inheritance.mjs

@@ -13,7 +13,7 @@ import {
   inheritanceFitMessage,
   inheritanceRouteTarget,
 } from '../inheritance-fit.mjs';
-import { clean } from '../session-text.mjs';
+import { clean } from '../../runtime/agent/orchestrator/runtime-core/session-text.mjs';
 
 export function createInheritance(deps, { compactConversation, saveSession }) {
   const { getSession, getRoute, mgr, createCurrentSession, invalidateContextStatusCache, getReservedSessionId } = deps;

package/src/session-runtime/lifecycle/session-catalog.mjs

@@ -8,7 +8,7 @@ import {
   isRootLeadSession,
 } from '../../runtime/agent/orchestrator/session/store-summary-visibility.mjs';
 import { listSessionHeartbeatMtimes } from '../../runtime/agent/orchestrator/session/store/paths-heartbeat.mjs';
-import { sessionMessageText, isSessionPreviewNoise, cleanSessionPreview, clean } from '../session-text.mjs';
+import { sessionMessageText, isSessionPreviewNoise, cleanSessionPreview, clean } from '../../runtime/agent/orchestrator/runtime-core/session-text.mjs';
 
 const VISIBLE_OWNERS = ['cli', 'user', 'mixdog'];
 
@@ -35,7 +35,7 @@ function previewOf(s) {
   let preview = isSessionPreviewNoise(rawPreview) ? '' : cleanSessionPreview(rawPreview);
   let messageCount = Math.max(0, Number(s.messageCount) || 0);
   if (!preview && Array.isArray(s.messages)) {
-    const msgs = s.messages || [];
+    const msgs = s.messages;
     const userPreviews = msgs
       .filter((m) => m && m.role === 'user')
       .map((m) => sessionMessageText(m.content))
@@ -48,7 +48,7 @@ function previewOf(s) {
   return { preview, messageCount };
 }
 
-export function leadSessionRow(s, heartbeatMtimes) {
+function leadSessionRow(s, heartbeatMtimes) {
   // Durable visibility is the catalog boundary. Apply it before the legacy
   // lead-shape heuristics so an explicitly agent-only child cannot leak just
   // because its owner field looks ordinary.

package/src/session-runtime/lifecycle/session-switch/resume.mjs

@@ -4,8 +4,8 @@
  * deferred tool surface, and finish route preparation in the background.
  */
 import { writeStatuslineRoute } from '../../statusline-route.mjs';
-import { clean, hasOwn } from '../../session-text.mjs';
-import { toolSpecForMode, deferredSurfaceModeForLead } from '../../effort.mjs';
+import { clean, hasOwn } from '../../../runtime/agent/orchestrator/runtime-core/session-text.mjs';
+import { toolSpecForMode, deferredSurfaceModeForLead } from '../../../runtime/agent/orchestrator/runtime-core/effort.mjs';
 import { isScratchConversation } from '../shared.mjs';
 
 export function resolveResumeCwd(session, currentCwd) {

package/src/session-runtime/lifecycle/session-switch/session-delete.mjs

@@ -3,7 +3,7 @@
  * with its linked agent children, and releasing the work a closing session
  * owns (shared with the context switch).
  */
-import { clean } from '../../session-text.mjs';
+import { clean } from '../../../runtime/agent/orchestrator/runtime-core/session-text.mjs';
 import { listLeadSessions } from '../session-catalog.mjs';
 import { SESSION_ID_PATTERN } from '../shared.mjs';
 

package/src/session-runtime/lifecycle/session-switch.mjs

@@ -5,7 +5,7 @@
  * (switch + new), resume.
  */
 import { getStoreDir } from '../../runtime/agent/orchestrator/session/store/paths-heartbeat.mjs';
-import { toolSpecForMode } from '../effort.mjs';
+import { toolSpecForMode } from '../../runtime/agent/orchestrator/runtime-core/effort.mjs';
 import { listLeadSessions } from './session-catalog.mjs';
 import { createSessionDelete } from './session-switch/session-delete.mjs';
 import { createContextSwitch } from './session-switch/context-switch.mjs';

package/src/session-runtime/lifecycle/shared.mjs

@@ -4,7 +4,7 @@
  */
 import { hasUserConversationMessage } from '../../runtime/agent/orchestrator/session/manager/prompt-utils.mjs';
 
-export const SESSION_ID_PATTERN = /^[A-Za-z0-9_-]+$/;
+export { SESSION_ID_PATTERN } from '../../runtime/agent/orchestrator/runtime-core/session-id.mjs';
 
 // Only truly-empty scratch sessions are tombstoned on close; non-empty
 // sessions must survive exit resumable. liveTurnMessages holds the in-flight

package/src/session-runtime/mcp-glue/connect.mjs

@@ -1,7 +1,7 @@
 // MCP connection orchestration: the serialized full connect/reset, the
 // non-superseding single-server toggle, and the turn gate on the initial
 // connect. All mutable progress lives on the caller-owned `state`.
-import { clean } from '../session-text.mjs';
+import { clean } from '../../runtime/agent/orchestrator/runtime-core/session-text.mjs';
 import { envFlag } from '../../runtime/shared/env.mjs';
 
 export function createMcpConnect({ mcpClient, getMcpScopeId, state, resolveEffectiveMcpServers, mcpStatus }) {

package/src/session-runtime/mcp-glue/server-catalog.mjs

@@ -1,6 +1,6 @@
 // Effective MCP server set and its status projection: config entries folded
 // with plugin ownership, per-server config reads, and the live/failed rollup.
-import { clean } from '../session-text.mjs';
+import { clean } from '../../runtime/agent/orchestrator/runtime-core/session-text.mjs';
 import { envFlag } from '../../runtime/shared/env.mjs';
 
 function mcpServerStatus(cfg, live, fail) {

package/src/session-runtime/mcp-glue/server-input.mjs

@@ -2,7 +2,7 @@
 // URL servers, and command/args/cwd/env coercion for stdio servers.
 import { homedir } from 'node:os';
 import { resolve } from 'node:path';
-import { clean } from '../session-text.mjs';
+import { clean } from '../../runtime/agent/orchestrator/runtime-core/session-text.mjs';
 
 function coerceStringRecord(value) {
   if (!value || typeof value !== 'object' || Array.isArray(value)) return null;