mixdog 0.9.63 → 0.9.64

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

@@ -26,6 +26,9 @@ import {
   MEASURED_TOOL_USAGE,
   READONLY_TOOL_NAMES,
 } from './tool-catalog-data.mjs';
+import { toolKind, measuredToolUsage, parseToolSelection, parseToolSearchQuerySelection, measuredToolRank, sortedCatalogByMeasuredUsage, activeToolForSurface, deferredProviderMode, nativeProviderFamily } from './tool-catalog-schema.mjs';
+export { toolKind, toolSchemaBucket, estimateToolSchemaBreakdown, measuredToolUsage, parseToolSelection, parseToolSearchQuerySelection, sortedCatalogByMeasuredUsage } from './tool-catalog-schema.mjs';
+export { resolveProviderRequestTools, snapshotProviderRequestTools } from './provider-request-snapshot.mjs';
 export {
   DEFERRED_DEFAULT_FULL_TOOLS,
   DEFERRED_DEFAULT_LEAD_TOOLS,
@@ -33,486 +36,6 @@ export {
   MEASURED_TOOL_USAGE,
 } from './tool-catalog-data.mjs';
 
-const toolSchemaBreakdownMemo = new WeakMap();
-
-function sameToolSchemaEntries(cached, tools) {
-  if (!cached || cached.entries.length !== tools.length) return false;
-  const nativePrefixCount = providerNativeToolPrefixCount(tools);
-  for (let index = 0; index < tools.length; index += 1) {
-    const entry = cached.entries[index];
-    const tool = tools[index];
-    if (entry.tool !== tool
-      || entry.name !== tool?.name
-      || entry.description !== tool?.description
-      || entry.inputSchema !== tool?.inputSchema
-      || entry.input_schema !== tool?.input_schema
-      || entry.parameters !== tool?.parameters
-      || entry.schema !== tool?.schema
-      || entry.deferLoading !== tool?.deferLoading
-      || entry.defer_loading !== tool?.defer_loading
-      || entry.annotationsMixdogKind !== tool?.annotations?.mixdogKind
-      || entry.annotationsAgentHidden !== tool?.annotations?.agentHidden
-      || entry.native !== (index < nativePrefixCount)
-      || entry.wireSignature !== toolSchemaSignature(toolMeteringList(tool, index < nativePrefixCount))) return false;
-  }
-  return true;
-}
-
-function toolMeteringList(tool, native) {
-  return native ? finalizeProviderRequestTools([tool], 1) : [tool];
-}
-
-function toolSchemaEntry(tool, native = false) {
-  return {
-    tool,
-    name: tool?.name,
-    description: tool?.description,
-    inputSchema: tool?.inputSchema,
-    input_schema: tool?.input_schema,
-    parameters: tool?.parameters,
-    schema: tool?.schema,
-    deferLoading: tool?.deferLoading,
-    defer_loading: tool?.defer_loading,
-    annotationsMixdogKind: tool?.annotations?.mixdogKind,
-    annotationsAgentHidden: tool?.annotations?.agentHidden,
-    native,
-    wireSignature: toolSchemaSignature(toolMeteringList(tool, native)),
-  };
-}
-export function toolKind(tool) {
-  const name = clean(tool?.name);
-  if (name.startsWith('mcp__')) return 'mcp';
-  if (name.startsWith('skill:') || tool?.annotations?.mixdogKind === 'skill') return 'skill';
-  if (name === 'Skill' || name.startsWith('skill_') || name === 'skills_list' || name === 'skill_view') return 'skill';
-  if (tool?.annotations?.agentHidden) return 'control';
-  if (['apply_patch', 'shell'].includes(name)) return 'mutation';
-  return 'tool';
-}
-
-export function toolSchemaBucket(tool) {
-  const name = clean(tool?.name);
-  const kind = toolKind(tool);
-  if (kind === 'mcp') return 'mcp';
-  if (kind === 'skill') return 'skills';
-  if (name === 'memory' || name === 'recall' || name.includes('memory')) return 'memory';
-  if (name === 'search' || name === 'web_fetch') return 'web';
-  if (['read', 'grep', 'find', 'glob', 'list', 'code_graph', 'explore'].includes(name)) return 'code';
-  if (['shell', 'apply_patch'].includes(name)) return 'mutation';
-  if (name === 'agent' || name === 'delegate') return 'agents';
-  if (name === 'session_manage') return 'session';
-  if (name.includes('channel') || name.includes('discord') || name.includes('webhook')) return 'channels';
-  if (name.includes('provider') || name === 'load_tool' || name === 'tool_search' || name === 'cwd') return 'setup';
-  if (kind === 'control') return 'control';
-  return 'other';
-}
-
-export function estimateToolSchemaBreakdown(tools) {
-  if (Array.isArray(tools)) {
-    const cached = toolSchemaBreakdownMemo.get(tools);
-    if (sameToolSchemaEntries(cached, tools)) return cached.value;
-  }
-  const out = {};
-  const list = Array.isArray(tools) ? tools : [];
-  const nativePrefixCount = providerNativeToolPrefixCount(list);
-  for (let index = 0; index < list.length; index += 1) {
-    const tool = list[index];
-    const bucket = toolSchemaBucket(tool);
-    const row = out[bucket] || { count: 0, tokens: 0 };
-    row.count += 1;
-    row.tokens += estimateToolSchemaTokens(toolMeteringList(tool, index < nativePrefixCount));
-    out[bucket] = row;
-  }
-  if (Array.isArray(tools)) {
-    toolSchemaBreakdownMemo.set(tools, {
-      entries: tools.map((tool, index) => toolSchemaEntry(tool, index < nativePrefixCount)),
-      value: out,
-    });
-  }
-  return out;
-}
-
-export function measuredToolUsage(name) {
-  return MEASURED_TOOL_USAGE[clean(name)] || 0;
-}
-
-export function parseToolSelection(value) {
-  if (Array.isArray(value)) return value.map(clean).filter(Boolean);
-  if (value && typeof value !== 'string' && typeof value[Symbol.iterator] === 'function') {
-    return [...value].map(clean).filter(Boolean);
-  }
-  return String(value || '').replace(/^select\s*:/i, '')
-    .split(/[,\s]+/)
-    .map(clean)
-    .filter(Boolean);
-}
-
-export function parseToolSearchQuerySelection(query) {
-  const match = clean(query).match(/^select\s*:\s*(.+)$/i);
-  return match ? parseToolSelection(match[1]) : [];
-}
-
-function measuredToolRank(name) {
-  const index = MEASURED_TOOL_ORDER.indexOf(clean(name));
-  return index === -1 ? Number.MAX_SAFE_INTEGER : index;
-}
-
-export function sortedCatalogByMeasuredUsage(catalog) {
-  return (catalog || [])
-    .map((tool, index) => ({ tool, index }))
-    .sort((a, b) => {
-      const au = measuredToolUsage(a.tool?.name);
-      const bu = measuredToolUsage(b.tool?.name);
-      if (bu !== au) return bu - au;
-      const ar = measuredToolRank(a.tool?.name);
-      const br = measuredToolRank(b.tool?.name);
-      if (ar !== br) return ar - br;
-      return a.index - b.index;
-    })
-    .map((entry) => entry.tool);
-}
-
-function activeToolForSurface(tool) {
-  if (!tool || typeof tool !== 'object') return tool;
-  return JSON.parse(JSON.stringify(tool));
-}
-
-function deferredProviderMode(provider) {
-  const p = clean(provider).toLowerCase();
-  if (p === 'gemini') return 'manifest';
-  if (p === 'anthropic' || p === 'anthropic-oauth'
-    || p === 'openai' || p === 'openai-oauth') {
-    return 'native';
-  }
-  // xAI/Grok and every other OpenAI-compatible backend have no native
-  // tool_search/tool_search_output contract. Give them one complete canonical
-  // function array instead of a load-driven array whose bytes churn.
-  return 'canonical';
-}
-
-function nativeProviderFamily(provider) {
-  const p = clean(provider).toLowerCase();
-  if (p === 'openai' || p === 'openai-oauth') return 'openai';
-  if (p === 'anthropic' || p === 'anthropic-oauth') return 'anthropic';
-  return '';
-}
-
-const ANTHROPIC_NATIVE_PROVIDERS = new Set(['anthropic', 'anthropic-oauth']);
-
-// Pure projection of the tool definitions that the next provider request will
-// serialize. Anthropic's native deferred surface sends the base active tools
-// plus only definitions that have actually been discovered through the
-// session/native tool-search history. Every other provider already receives
-// its canonical/native surface in `tools`, so preserve that array verbatim.
-export function resolveProviderRequestTools({
-  provider,
-  tools,
-  messages,
-  session,
-} = {}) {
-  const activeTools = Array.isArray(tools) ? tools : [];
-  const normalizedProvider = clean(provider || session?.provider).toLowerCase();
-  if (!ANTHROPIC_NATIVE_PROVIDERS.has(normalizedProvider)
-    || session?.deferredNativeTools !== true
-    || activeTools.length === 0) {
-    return activeTools;
-  }
-  const discovered = new Set(
-    parseToolSelection(session?.deferredDiscoveredTools),
-  );
-  for (const message of Array.isArray(messages) ? messages : []) {
-    const native = message?.nativeToolSearch;
-    const source = clean(native?.provider).toLowerCase();
-    if (source && source !== normalizedProvider
-      && !(ANTHROPIC_NATIVE_PROVIDERS.has(source)
-        && ANTHROPIC_NATIVE_PROVIDERS.has(normalizedProvider))) continue;
-    for (const name of parseToolSelection(native?.toolReferences)) discovered.add(name);
-  }
-  if (discovered.size === 0) return activeTools;
-  const activeNames = new Set(activeTools.map((tool) => clean(tool?.name)).filter(Boolean));
-  const catalog = Array.isArray(session?.deferredToolCatalog) ? session.deferredToolCatalog : [];
-  const deferredTools = catalog
-    .filter((tool) => {
-      const name = clean(tool?.name);
-      return name && discovered.has(name) && !activeNames.has(name);
-    })
-    .map((tool) => ({ ...tool, deferLoading: true }));
-  return deferredTools.length ? [...activeTools, ...deferredTools] : activeTools;
-}
-
-const OMIT_REQUEST_TOOL_VALUE = Symbol('omit-request-tool-value');
-const MAX_PROVIDER_SNAPSHOT_ARRAY_LENGTH = 1_000_000;
-
-function defineEnumerableDataProperty(target, key, value) {
-  Object.defineProperty(target, key, {
-    value,
-    enumerable: true,
-    configurable: false,
-    writable: false,
-  });
-}
-
-function boxedJsonPrimitive(value) {
-  try { return { matched: true, value: Number.prototype.valueOf.call(value) }; } catch {}
-  try { return { matched: true, value: String.prototype.valueOf.call(value) }; } catch {}
-  try { return { matched: true, value: Boolean.prototype.valueOf.call(value) }; } catch {}
-  try { return { matched: true, value: BigInt.prototype.valueOf.call(value) }; } catch {}
-  return { matched: false, value: null };
-}
-
-function providerSnapshotLengthPrimitive(value) {
-  if ((typeof value !== 'object' || value === null) && typeof value !== 'function') return value;
-  const exotic = value[Symbol.toPrimitive];
-  if (exotic !== undefined && exotic !== null) {
-    if (typeof exotic !== 'function') throw new TypeError('invalid length primitive');
-    const primitive = exotic.call(value, 'number');
-    if ((typeof primitive === 'object' && primitive !== null) || typeof primitive === 'function') {
-      throw new TypeError('invalid length primitive');
-    }
-    return primitive;
-  }
-  for (const methodName of ['valueOf', 'toString']) {
-    const method = value[methodName];
-    if (typeof method !== 'function') continue;
-    const primitive = method.call(value);
-    if ((typeof primitive !== 'object' || primitive === null) && typeof primitive !== 'function') {
-      return primitive;
-    }
-  }
-  throw new TypeError('invalid length primitive');
-}
-
-function providerSnapshotArrayLength(rawLength) {
-  let primitive;
-  let numeric;
-  try {
-    primitive = providerSnapshotLengthPrimitive(rawLength);
-    if (typeof primitive === 'bigint' || typeof primitive === 'symbol') {
-      throw new TypeError('invalid length primitive');
-    }
-    numeric = Number(primitive);
-  } catch {
-    throw new TypeError('provider tool snapshot: invalid array length');
-  }
-  if (Number.isNaN(numeric) || numeric <= 0) return 0;
-  if (!Number.isFinite(numeric)) {
-    throw new RangeError(
-      `provider tool snapshot: array length exceeds safe limit ${MAX_PROVIDER_SNAPSHOT_ARRAY_LENGTH}`,
-    );
-  }
-  const effectiveLength = Math.floor(numeric);
-  if (effectiveLength > MAX_PROVIDER_SNAPSHOT_ARRAY_LENGTH) {
-    throw new RangeError(
-      `provider tool snapshot: array length exceeds safe limit ${MAX_PROVIDER_SNAPSHOT_ARRAY_LENGTH}`,
-    );
-  }
-  return effectiveLength;
-}
-
-function normalizeRequestToolJson(value, state, {
-  arrayEntry = false,
-  key = '',
-  applyToJSON = true,
-  seededProperties = null,
-} = {}) {
-  if (value === null || typeof value === 'string' || typeof value === 'boolean') return value;
-  if (typeof value === 'number') return Number.isFinite(value) ? value : null;
-  if (typeof value === 'bigint') {
-    throw new TypeError('provider tool snapshot: BigInt is not JSON-serializable');
-  }
-  if (value === undefined || typeof value === 'function' || typeof value === 'symbol') {
-    return arrayEntry ? null : OMIT_REQUEST_TOOL_VALUE;
-  }
-  if (typeof value !== 'object') {
-    throw new TypeError(`provider tool snapshot: unsupported JSON value type ${typeof value}`);
-  }
-  if (state.active.has(value)) {
-    throw new TypeError('provider tool snapshot: cyclic value is not JSON-serializable');
-  }
-  if (state.memo.has(value)) return state.memo.get(value);
-
-  let capturedProperties = seededProperties;
-  if (applyToJSON) {
-    // JSON reads `toJSON` once before serializing an object. Preserve that
-    // single observation for an own-enumerable non-function (and for a
-    // callable that returns `this`) so property traversal cannot invoke a
-    // stateful accessor a second time.
-    const toJSONDescriptor = Object.getOwnPropertyDescriptor(value, 'toJSON');
-    const toJSON = value.toJSON;
-    if (typeof toJSON === 'function') {
-      // Keep the source guarded through both hook execution and replacement
-      // normalization. A hook returning itself, or any replacement graph that
-      // points back to its source, is a JSON cycle rather than another hook
-      // invocation.
-      state.active.add(value);
-      try {
-        const replacement = toJSON.call(value, key);
-        const normalized = normalizeRequestToolJson(replacement, state, {
-          arrayEntry,
-          key,
-          applyToJSON: false,
-          seededProperties: null,
-        });
-        state.memo.set(value, normalized);
-        return normalized;
-      } finally {
-        state.active.delete(value);
-      }
-    }
-    if (toJSONDescriptor?.enumerable) {
-      capturedProperties = { ...(seededProperties || {}), toJSON };
-    }
-  }
-  const boxed = boxedJsonPrimitive(value);
-  if (boxed.matched) {
-    return normalizeRequestToolJson(boxed.value, state, { arrayEntry, key });
-  }
-
-  const isArray = Array.isArray(value);
-  const normalized = isArray ? [] : {};
-  state.active.add(value);
-  try {
-    if (isArray) {
-      // JSON.stringify captures array length once. Accessors may mutate the
-      // source array, but they cannot extend or shorten this iteration bound.
-      const rawLength = value.length;
-      const length = providerSnapshotArrayLength(rawLength);
-      for (let index = 0; index < length; index += 1) {
-        const entry = value[index];
-        normalized.push(normalizeRequestToolJson(entry, state, {
-          arrayEntry: true,
-          key: String(index),
-        }));
-      }
-    } else {
-      // JSON-compatible request schemas are own-enumerable data. Normalize class
-      // instances/accessors to a plain record, ignore inherited mutable fields,
-      // and define keys explicitly so an own "__proto__" remains ordinary data.
-      for (const key of Reflect.ownKeys(value)) {
-        if (typeof key !== 'string') continue;
-        const descriptor = Object.getOwnPropertyDescriptor(value, key);
-        if (!descriptor?.enumerable) continue;
-        // Deferred catalog selection captures `name` once before touching the
-        // candidate schema. Seed that captured value here so a stateful/throwing
-        // getter is never observed a second time during JSON normalization.
-        const entry = capturedProperties && Object.hasOwn(capturedProperties, key)
-          ? capturedProperties[key]
-          : value[key];
-        const child = normalizeRequestToolJson(entry, state, { key });
-        if (child !== OMIT_REQUEST_TOOL_VALUE) defineEnumerableDataProperty(normalized, key, child);
-      }
-    }
-  } finally {
-    state.active.delete(value);
-  }
-  Object.freeze(normalized);
-  state.memo.set(value, normalized);
-  return normalized;
-}
-
-// Establish one immutable request-attempt snapshot. Nested schema records are
-// cloned before freezing, so a catalog refresh or in-place schema mutation
-// after this boundary cannot change either provider bytes or their signature.
-export function snapshotProviderRequestTools(options = {}) {
-  const {
-    provider,
-    tools,
-    nativeTools,
-    messages,
-    session,
-  } = options;
-  const activeTools = Array.isArray(tools) ? tools : [];
-  const state = { active: new WeakSet(), memo: new WeakMap() };
-  const snapshots = [];
-  const names = new Set();
-  const activeCandidateRefs = new WeakSet();
-  // Anthropic native definitions are already provider-wire objects. Preserve
-  // their prior prepend order and duplicate behavior, but freeze the exact
-  // bytes into the same request snapshot used for accounting and retries.
-  if (ANTHROPIC_NATIVE_PROVIDERS.has(clean(provider || session?.provider).toLowerCase())) {
-    for (const nativeTool of Array.isArray(nativeTools) ? nativeTools : []) {
-      if (!nativeTool || typeof nativeTool !== 'object') continue;
-      const normalized = normalizeRequestToolJson(nativeTool, state);
-      if (normalized && typeof normalized === 'object' && !Array.isArray(normalized)) {
-        snapshots.push(normalized);
-      }
-    }
-  }
-  const nativePrefixCount = snapshots.length;
-  const finish = () => finalizeProviderRequestTools(snapshots, nativePrefixCount);
-  const appendSnapshot = (candidate, selectedName = null, deferred = false) => {
-    const normalized = normalizeRequestToolJson(candidate, state, {
-      seededProperties: selectedName === null ? null : { name: selectedName },
-    });
-    if (deferred && (
-      !normalized
-      || typeof normalized !== 'object'
-      || Array.isArray(normalized)
-      || typeof normalized.name !== 'string'
-      || !clean(normalized.name)
-      || normalized.name !== selectedName
-    )) {
-      throw new TypeError(`provider tool snapshot: selected tool identity mismatch for ${JSON.stringify(selectedName)}`);
-    }
-    if (!normalized || typeof normalized !== 'object' || Array.isArray(normalized)) return;
-    const name = clean(normalized.name);
-    if (!name || names.has(name)) return;
-    names.add(name);
-    if (!deferred) {
-      snapshots.push(normalized);
-      return;
-    }
-    const deferredSnapshot = {};
-    for (const key of Object.keys(normalized)) {
-      if (key === 'deferLoading' || key === 'defer_loading') continue;
-      defineEnumerableDataProperty(deferredSnapshot, key, normalized[key]);
-    }
-    defineEnumerableDataProperty(deferredSnapshot, 'deferLoading', true);
-    snapshots.push(Object.freeze(deferredSnapshot));
-  };
-
-  // Active candidates are provider-visible by definition: normalize each once,
-  // then perform all validation/dedupe from the plain snapshot only.
-  for (const tool of activeTools) {
-    if (tool && typeof tool === 'object') activeCandidateRefs.add(tool);
-    appendSnapshot(tool);
-  }
-
-  const normalizedProvider = clean(provider || session?.provider).toLowerCase();
-  if (!ANTHROPIC_NATIVE_PROVIDERS.has(normalizedProvider)
-    || session?.deferredNativeTools !== true
-    // Native definitions preserve their historical prepend behavior, but they
-    // do not make an otherwise all-deferred catalog eligible for expansion.
-    || names.size === 0) {
-    return finish();
-  }
-  const discovered = new Set(parseToolSelection(session?.deferredDiscoveredTools));
-  for (const message of Array.isArray(messages) ? messages : []) {
-    const native = message?.nativeToolSearch;
-    const source = clean(native?.provider).toLowerCase();
-    if (source && source !== normalizedProvider
-      && !(ANTHROPIC_NATIVE_PROVIDERS.has(source)
-        && ANTHROPIC_NATIVE_PROVIDERS.has(normalizedProvider))) continue;
-    for (const name of parseToolSelection(native?.toolReferences)) discovered.add(name);
-  }
-  if (discovered.size === 0) return finish();
-
-  // Catalog arrays have no separate key map, so `name` is their explicit
-  // selection key contract: capture it once, skip undiscovered/duplicate
-  // entries without touching schemas, and seed selected normalization with the
-  // captured value to avoid a second getter evaluation.
-  const seenCatalogRefs = new WeakSet();
-  for (const tool of Array.isArray(session?.deferredToolCatalog) ? session.deferredToolCatalog : []) {
-    if (tool && typeof tool === 'object') {
-      if (activeCandidateRefs.has(tool) || seenCatalogRefs.has(tool)) continue;
-      seenCatalogRefs.add(tool);
-    }
-    const capturedName = tool?.name;
-    const selectionName = typeof capturedName === 'string' ? clean(capturedName) : '';
-    if (!selectionName || !discovered.has(selectionName) || names.has(selectionName)) continue;
-    appendSnapshot(tool, capturedName, true);
-  }
-  return finish();
-}
 
 export function filterDisallowedTools(tools, disallowed = []) {
   if (!Array.isArray(disallowed) || disallowed.length === 0) return tools;
@@ -663,7 +186,7 @@ function setDeferredToolState(session, names) {
   return selected;
 }
 
-export function deferredPoolToolNames(session) {
+function deferredPoolToolNames(session) {
   if (!session || session.deferredProviderMode === 'full'
     || session.deferredProviderMode === 'manifest'
     || session.deferredProviderMode === 'canonical') return [];
@@ -876,7 +399,7 @@ export function refreshInitialDeferredMcpSurface(session, liveMcpTools) {
 }
 
 /**
- * Turn-boundary reconciliation (Codex-style snapshot + CC-style delta).
+ * Turn-boundary reconciliation (full snapshot + delta).
  * Merge currently-connected MCP tools into session.deferredLateToolCatalog (a
  * SEPARATE pool from the boot-frozen session.deferredToolCatalog) so tools from
  * servers that finished their handshake AFTER this session was created become
@@ -1129,7 +652,7 @@ export function selectDeferredTools(session, names, mode, options = {}) {
 //   query "select:a,b" → legacy query-side loader
 // A free-text `query` is NOT a search anymore: it yields no names, and the
 // caller is steered back to names[].
-export function parseLoadToolNames(args = {}) {
+function parseLoadToolNames(args = {}) {
   const fromNames = parseToolSelection(args.names);
   if (fromNames.length) return fromNames;
   const fromSelect = parseToolSelection(args.select);

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

@@ -97,7 +97,7 @@ export const SESSION_MANAGE_TOOL = {
 };
 
 export const LEAD_DISALLOWED_TOOLS = Object.freeze([]);
-export const AGENT_HIDDEN_WRAPPER_TOOLS = new Set([]);
+const AGENT_HIDDEN_WRAPPER_TOOLS = new Set([]);
 
 export function applyStandaloneToolDefaults(tool) {
   if (!tool || !AGENT_HIDDEN_WRAPPER_TOOLS.has(tool.name)) return tool;

package/src/standalone/agent-task-status.mjs

@@ -44,7 +44,7 @@ export function formatAgentWatchdogSummary(policy, snapshot = null) {
   return parts.length ? `armed ${parts.join(' ')}` : null;
 }
 
-export function resolveSilentForSeconds(now, snapshot, runtime) {
+function resolveSilentForSeconds(now, snapshot, runtime) {
   const last = Math.max(
     snapshot?.lastProgressAt || 0,
     runtime?.lastProgressAt || 0,

package/src/standalone/agent-tool/helpers.mjs

@@ -75,7 +75,7 @@ export function presetKey(preset) {
   return clean(preset?.id || preset?.name);
 }
 
-export function bridgeRouteForStatusline(preset = {}) {
+function bridgeRouteForStatusline(preset = {}) {
   const provider = clean(preset.provider);
   const model = clean(preset.model);
   if (!provider || !model) return null;
@@ -191,7 +191,7 @@ export function compactIso(value) {
   return text.replace('T', ' ').replace(/\.\d+Z$/, 'Z');
 }
 
-export function formatElapsedMs(ms) {
+function formatElapsedMs(ms) {
   const n = Number(ms);
   if (!Number.isFinite(n) || n < 0) return '';
   const totalSec = Math.floor(n / 1000);

package/src/standalone/channel-admin.mjs

@@ -162,7 +162,7 @@ function listEntryDirs(dir) {
 
 // Single-channel read: resolves `cfg.channel` into the flat shape the
 // settings/TUI layer consumes.
-export function getChannel(config = {}) {
+function getChannel(config = {}) {
   const cfg = normalizeChannelsConfig(config);
   const backend = cfg.backend === 'telegram' ? 'telegram' : 'discord';
   const entry = resolveChannelEntry(cfg);
@@ -325,7 +325,7 @@ const DAY_TOKEN_TO_DOW = {
 // expression: daily -> '*', weekday -> '1-5', weekend -> '0,6', explicit day
 // lists ("mon,wed,fri" | "1,3,5") -> comma-joined numbers. Throws on an
 // unmappable token so bad combos surface instead of silently mis-scheduling.
-export function foldDaysIntoCron(cron, days) {
+function foldDaysIntoCron(cron, days) {
   const parts = String(cron).trim().split(/\s+/);
   const dowIndex = parts.length - 1;
   const raw = String(days || '').trim().toLowerCase();
@@ -446,7 +446,7 @@ export async function setScheduleEnabled(name, enabled) {
 // (webhooks-db.mjs) — the single source of truth. Legacy per-endpoint
 // WEBHOOK.md + secret folders are imported once at boot and deleted by the
 // store's migration hook.
-export async function listWebhooks() {
+async function listWebhooks() {
   const endpoints = await dbListEndpoints();
   return endpoints.map((ep) => ({
     name: ep.name,
@@ -556,7 +556,7 @@ export async function channelSetup(config = null) {
   };
 }
 
-export async function renderChannelStatus(config = null) {
+async function renderChannelStatus(config = null) {
   const setup = await channelSetup(config);
   const lines = [];
   lines.push(`discord  ${setup.discord.status}${setup.discord.problem ? ` (${setup.discord.problem})` : ''}`);

package/src/standalone/explore-tool.mjs

@@ -33,14 +33,14 @@ export const EXPLORE_TOOL = {
 // Total merged-output character cap. The original source uses a very large cap
 // (50MB) plus a smart-read summariser downstream; the standalone path returns
 // the merged text in-turn, so we keep a sane bound to protect the Lead context.
-export const EXPLORE_OUTPUT_CHAR_CAP = 24_000;
+const EXPLORE_OUTPUT_CHAR_CAP = 24_000;
 const EXPLORE_TRUNCATION_MARKER = '\n\n[explore: output truncated; narrow cwd or split queries to see more]';
 // Bound fan-out so a hostile/poisoned query array cannot spawn unbounded subs.
 export const MAX_FANOUT_QUERIES = 8;
 // Mechanical turn cap per explorer sub-session: 3 free turns (contract: tool
 // turn 1 = whole batched search, turns 2-3 = miss recovery), then the agent
 // loop forces one tool-less final-answer turn. Overridable for tuning.
-export const EXPLORE_MAX_LOOP_ITERATIONS = (() => {
+const EXPLORE_MAX_LOOP_ITERATIONS = (() => {
   const raw = Number(process.env.MIXDOG_EXPLORE_MAX_LOOP);
   return Number.isFinite(raw) && raw > 0 ? Math.floor(raw) : 3;
 })();
@@ -528,7 +528,7 @@ function anchorLineExists(line, cwd, captureRe = ANCHOR_PATH_CAPTURE_RE) {
   try { return existsSync(isAbsolute(p) ? p : resolve(cwd, p)); } catch { return true; }
 }
 
-export function cleanExplorerText(text, cwd = null) {
+function cleanExplorerText(text, cwd = null) {
   const raw = String(text || '').trim();
   if (!raw) return '';
   const anchors = [];

package/src/standalone/hook-bus/config.mjs

@@ -35,7 +35,7 @@ function readTrustedProjects(dataDir) {
   return out;
 }
 
-export function isProjectTrusted(dataDir, projectDir) {
+function isProjectTrusted(dataDir, projectDir) {
   if (!projectDir) return false;
   const abs = resolve(projectDir);
   const key = process.platform === 'win32' ? abs.toLowerCase() : abs;

package/src/standalone/hook-bus/constants.mjs

@@ -22,7 +22,7 @@ export const USER_PROMPT_TIMEOUT_S = 30;
 export const MESSAGE_DISPLAY_TIMEOUT_S = 10;
 export const DEFAULT_PROMPT_TIMEOUT_S = 30;
 export const DEFAULT_AGENT_TIMEOUT_S = 60;
-export const MAX_OUTPUT_CHARS = 10_000;
+const MAX_OUTPUT_CHARS = 10_000;
 export const MAX_BUFFER_BYTES = 10 * 1024 * 1024;
 
 export const TOOL_IF_EVENTS = new Set([

package/src/standalone/hook-bus/rules.mjs

@@ -1,7 +1,7 @@
 import { compactValue } from './payload.mjs';
 import { defaultShellKind } from './handlers.mjs';
 
-export function matchesList(pattern, value) {
+function matchesList(pattern, value) {
   if (pattern == null || pattern === '*' || pattern === 'all') return true;
   const items = Array.isArray(pattern) ? pattern : [pattern];
   return items.some((item) => {

package/src/standalone/projects.mjs

@@ -1,7 +1,7 @@
 /**
  * standalone/projects.mjs — user-registered project (cwd) store.
  *
- * Projects are working directories the user explicitly registers (Codex-style).
+ * Projects are working directories the user explicitly registers.
  * There is NO git scanning and NO recent-history auto-import; only entries the
  * user creates appear here. Persisted as JSON at <MIXDOG_HOME>/projects.json.
  *