mixdog 1.3.4 → 1.4.0

package/src/vendor/statusline/bin/statusline-route.mjs

@@ -7,7 +7,6 @@ import {
   readClaudeCodeCurrentRoute,
 } from '../src/gateway/claude-current.mjs';
 import {
-  normalizeClientHostPid,
   readLatestGatewayHostRoute,
   readGatewaySessionRoute,
 } from '../src/gateway/session-routes.mjs';
@@ -16,33 +15,13 @@ import {
   defaultEffectiveContextWindowPercent,
 } from '../src/gateway/route-meta.mjs';
 import { getModelMetadataSync } from '../../../runtime/agent/orchestrator/providers/model-catalog.mjs';
-import { resolveRuntimeRoot } from '../../../runtime/shared/runtime-root.mjs';
 import { withDefaultPresets } from '../../../runtime/agent/orchestrator/config-presets.mjs';
 
-function positiveInt(value) {
-  const n = parseInt(String(value || ''), 10);
-  return Number.isFinite(n) && n > 0 ? n : 0;
-}
-
 // Keep the last known OAuth usage snapshot visible while idle. Live refreshes
 // replace it when available, but a delayed/failed refresh must not make the
 // statusline usage segment disappear. Previous-launch snapshots stay hidden
 // during boot until the current process captures usage once.
 const STATUSLINE_PROCESS_STARTED_AT_MS = Date.now() - Math.floor((Number(process.uptime?.()) || 0) * 1000);
-function isPidAlive(pid) {
-  const n = positiveInt(pid);
-  if (!n) return false;
-  try {
-    process.kill(n, 0);
-    return true;
-  } catch (e) {
-    return !!(e && e.code === 'EPERM');
-  }
-}
-
-function runtimeRoot() {
-  return resolveRuntimeRoot();
-}
 
 function claudeConfigDir() {
   return process.env.MIXDOG_CONFIG_DIR || path.join(os.homedir(), '.mixdog');
@@ -246,62 +225,11 @@ function routeContextMeta(provider, info = {}, inherited = {}) {
   };
 }
 
-// Test-only export of the route context-meta resolver for the auto-compact
-// limit migration smoke (scripts/compact-trigger-migration-smoke.mjs).
-export const _routeContextMeta = routeContextMeta;
-
-// Resolve the auto-compact limit displayed by loadGatewayStatus(). The active
-// value MUST be validated against the ACTIVE route's own boundary/window, never
-// configured?.contextWindow: the configured window can be larger than the
-// active window, so validating a stale active full-window value (== active
-// window) against the configured window would let it slip through as an
-// explicit limit. The configured route's limit (already sanitized by
-// routeContextMeta) is preferred when a configured route is present, but it
-// never validates a stale active value.
-function resolveStatusAutoCompactTokenLimit(configured, active = {}, lastCompact = null) {
-  if (configured) {
-    const c = num(configured.autoCompactTokenLimit, 0);
-    return c > 0 ? c : null;
-  }
-  const activeBoundary = num(
-    active?.gateway_context_window
-      ?? active?.gateway_raw_context_window
-      ?? lastCompact?.budgetWindow
-      ?? lastCompact?.contextWindow,
-    0,
-  );
-  const raw = num(active?.gateway_auto_compact_token_limit, 0);
-  if (!(raw > 0)) return null;
-  if (activeBoundary > 0) return raw < activeBoundary ? raw : null;
-  return raw;
-}
-
-// Test-only export of the status auto-compact-limit resolver.
-export const _resolveStatusAutoCompactTokenLimit = resolveStatusAutoCompactTokenLimit;
-
 export function compactBoundaryForStatus(routeInfo = {}, compact = null) {
   const n = compactBoundaryDenominator(routeInfo, compact);
   return n > 0 ? n : null;
 }
 
-function sessionIdFromTranscriptPath(transcriptPath) {
-  const base = path.basename(String(transcriptPath || ''));
-  return base.endsWith('.jsonl') ? base.slice(0, -6) : '';
-}
-
-function gatewaySessionStatusFileName(sessionId, clientHostPid = null) {
-  const sid = cleanString(sessionId).replace(/[^0-9A-Za-z._-]/g, '');
-  if (!sid) return null;
-  const pid = normalizeClientHostPid(clientHostPid);
-  return pid ? `${sid}--host-${pid}.json` : `${sid}.json`;
-}
-
-function gatewaySessionStatus(sessionId, clientHostPid = null) {
-  const name = gatewaySessionStatusFileName(sessionId, clientHostPid);
-  if (!name) return null;
-  return readJson(path.join(runtimeRoot(), 'gateway-session-status', name));
-}
-
 function sessionRouteFor(gateway, sessionId, clientHostPid = null) {
   const sid = cleanString(sessionId);
   if (!sid) return { route: gateway, sessionScoped: false };
@@ -538,153 +466,7 @@ export function loadGatewayStatus(options = {}) {
     balance: null,
     routeSpend: null,
   } : null;
-  const activeOverride = options.activeOverride && typeof options.activeOverride === 'object' ? options.activeOverride : null;
-  const activeGlobal = activeOverride || readJson(path.join(runtimeRoot(), 'active-instance.json'));
-  const currentClientHostPid = normalizeClientHostPid(options.clientHostPid);
-  const sessionStatus = activeOverride || gatewaySessionStatus(options.sessionId, currentClientHostPid);
-  const active = sessionStatus || activeGlobal;
-  if (!active || !active.gateway_port || !active.gateway_provider || !active.gateway_model) return configuredStatus;
-  const ownerPid = positiveInt(active.gateway_server_pid);
-  if (ownerPid && !isPidAlive(ownerPid)) return configuredStatus;
-  const updatedAt = num(active.gateway_updated_at, 0) || num(active.updatedAt, 0);
-  if (updatedAt && Date.now() - updatedAt > 5 * 60_000) return configuredStatus;
-  // Gate active-instance metrics on a positive ownership proof. The display
-  // route itself always comes from the current session config (`configured`)
-  // when present; active-instance only contributes live usage for that same
-  // session/route, never model identity.
-  const currentSessionId = cleanString(options.sessionId);
-  const gatewayCcSessionMatch = currentSessionId && cleanString(active.gateway_cc_session_id) === currentSessionId;
-  const activeClientHostPid = normalizeClientHostPid(active.gateway_client_host_pid ?? active.clientHostPid);
-  const gatewayClientHostMatch = !currentClientHostPid || activeClientHostPid === currentClientHostPid;
-  const gwTranscript = typeof active.gateway_transcript_path === 'string' && active.gateway_transcript_path || null;
-  const currentTranscript = typeof activeGlobal?.transcriptPath === 'string' && activeGlobal.transcriptPath || null;
-  const gatewayTranscriptMatch = currentSessionId
-    ? sessionIdFromTranscriptPath(gwTranscript) === currentSessionId
-    : !!(gwTranscript && currentTranscript && gwTranscript === currentTranscript);
-  const activeTranscriptMatch = currentSessionId
-    ? sessionIdFromTranscriptPath(currentTranscript) === currentSessionId
-    : false;
-  const transcriptMatch = gatewayCcSessionMatch || gatewayTranscriptMatch || (!gwTranscript && activeTranscriptMatch);
-  const routeMatchesConfigured = configured
-    ? configured.provider === active.gateway_provider && configured.model === active.gateway_model
-    : true;
-  const activeRouteBoundary = compactBoundaryForStatus({
-    autoCompactTokenLimit: active.gateway_auto_compact_token_limit,
-    contextWindow: active.gateway_context_window,
-    rawContextWindow: active.gateway_raw_context_window,
-  });
-  const configuredRouteBoundary = configured ? compactBoundaryForStatus(configured) : null;
-  const routeBoundaryMatchesConfigured = !configured
-    || !configuredRouteBoundary
-    || !activeRouteBoundary
-    || configuredRouteBoundary === activeRouteBoundary;
-  const metricsOwnCurrentSession = !!(sessionStatus || gatewayCcSessionMatch || gatewayTranscriptMatch || activeTranscriptMatch);
-  const metricsMatch = gatewayClientHostMatch && metricsOwnCurrentSession && routeMatchesConfigured && routeBoundaryMatchesConfigured;
-  // Strong ownership = this session's own status file or an explicit session/
-  // transcript id match from the gateway advert. `activeTranscriptMatch` (the
-  // global active-instance transcript merely naming the current session) is NOT
-  // strong: right after /new the global record can already point at the new
-  // session while its stored gateway metrics (context pct, last usage) still
-  // belong to the previous one.
-  const strongSessionOwnership = !!(sessionStatus || gatewayCcSessionMatch || gatewayTranscriptMatch);
-  // A model switch can keep strong session ownership while the active gateway
-  // advert still contains the previous route's lastUsage.compact. Do not let
-  // that stale compact boundary override the configured/current route window.
-  const lastUsage = gatewayClientHostMatch && strongSessionOwnership && routeMatchesConfigured && routeBoundaryMatchesConfigured && active.gateway_last_usage && typeof active.gateway_last_usage === 'object'
-    ? active.gateway_last_usage
-    : null;
-  const rawLastCompact = lastUsage?.compact && typeof lastUsage.compact === 'object'
-    ? lastUsage.compact
-    : null;
-  // A model/window switch updates the active route fields (context/raw window)
-  // but can leave the PREVIOUS route's boundary inside gateway_last_usage.compact.
-  // routeBoundaryMatchesConfigured only checks the active route fields, so that
-  // stale compact telemetry would otherwise survive and, via compactBoundaryTokens,
-  // resurrect the previous boundary in compactBoundaryForStatus below. Drop the
-  // compact telemetry when its own implied boundary contradicts the active route
-  // window.
-  const lastCompactBoundary = rawLastCompact
-    ? compactBoundaryForStatus({}, rawLastCompact)
-    : null;
-  const lastCompact = rawLastCompact
-    && (!activeRouteBoundary || !lastCompactBoundary || lastCompactBoundary === activeRouteBoundary)
-    ? rawLastCompact
-    : null;
-  const statusLastUsage = lastUsage
-    ? {
-      ...lastUsage,
-      compact: lastCompact,
-    }
-    : null;
-  const contextBoundary = compactBoundaryForStatus({
-    autoCompactTokenLimit: active.gateway_auto_compact_token_limit,
-    contextWindow: active.gateway_context_window,
-    rawContextWindow: active.gateway_raw_context_window,
-  }, lastCompact);
-  const liveContextTokens = num(options.activeContextTokens, null);
-  const compactRequestWithLiveTokens = lastUsage?.requestKind === 'compact' && liveContextTokens !== null;
-  const overflowContextTokens = !compactRequestWithLiveTokens && lastCompact?.overflow === true
-    ? Math.max(
-      num(lastUsage?.promptTokens, 0),
-      num(lastCompact?.beforeTokens, 0),
-      num(lastCompact?.afterTokens, 0),
-      num(contextBoundary, 0),
-    )
-    : null;
-  const contextNumerator = liveContextTokens !== null && Number.isFinite(liveContextTokens)
-    ? liveContextTokens
-    : (overflowContextTokens ?? null);
-  const recomputedContextUsedPct = pctOf(contextNumerator, contextBoundary);
-  const activeQuotaWindows = metricsMatch && Array.isArray(active.gateway_quota_windows)
-    ? active.gateway_quota_windows
-    : [];
-  const statusProvider = configured?.provider || active.gateway_provider;
-  const statusProviderKind = configured?.providerKind
-    || (routeMatchesConfigured ? cleanString(active.gateway_provider_kind) : '')
-    || providerKind(statusProvider);
-  // Sanitize the auto-compact limit before display: a stale boundary/window-
-  // sized active.gateway_auto_compact_token_limit must not surface as an
-  // explicit autoCompactTokenLimit (the runtime would read it as the trigger
-  // and collapse the buffer). The active value must be validated against the
-  // ACTIVE route's own boundary/window — NOT configured?.contextWindow. The
-  // configured window can be larger than the active window, so using it would
-  // let a stale active full-window value (== active window) slip through. Use
-  // the active boundary (active context/raw window, or the lastCompact budget
-  // when present) and null the active value when it is >= that boundary.
-  const statusAutoCompactTokenLimit = resolveStatusAutoCompactTokenLimit(configured, active, lastCompact);
-  const activeStatus = {
-    provider: statusProvider,
-    model: configured?.model || active.gateway_model,
-    modelDisplay: configured?.modelDisplay
-      || statuslineDisplayForModel(active.gateway_provider, active.gateway_model, {}, active.gateway_model_display)
-      || active.gateway_model,
-    effort: configured?.effort ?? active.gateway_effort ?? '',
-    fast: configured?.fast ?? active.gateway_fast === true,
-    contextWindow: configured?.contextWindow ?? num(active.gateway_context_window, null),
-    rawContextWindow: configured?.rawContextWindow ?? num(active.gateway_raw_context_window, null),
-    effectiveContextWindowPercent: configured?.effectiveContextWindowPercent ?? num(active.gateway_effective_context_window_percent, null),
-    autoCompactTokenLimit: statusAutoCompactTokenLimit,
-    // Live recompute (from the caller's own context tokens) may use the weaker
-    // metricsMatch gate, but the STORED gateway_context_used_pct fallback needs
-    // strong ownership — otherwise a fresh /new session with a not-yet-updated
-    // active-instance record would keep showing the old session's context %.
-    contextUsedPct: metricsMatch
-      ? recomputedContextUsedPct ?? (strongSessionOwnership ? num(active.gateway_context_used_pct, null) : null)
-      : null,
-    lastUsage: statusLastUsage,
-    quotaWindows: activeQuotaWindows.length ? activeQuotaWindows : (configuredStatus?.quotaWindows || []),
-    // Provenance for monotonic hysteresis: live active-instance windows are
-    // own-instance data timestamped by the advert's updatedAt; otherwise inherit
-    // the shared-cache fallback's (unowned) asOf. Older/unowned snapshots must
-    // not displace a value already rendered from newer/owned data.
-    quotaWindowsAsOf: activeQuotaWindows.length ? (updatedAt || 0) : num(configuredStatus?.quotaWindowsAsOf, 0),
-    quotaWindowsOwned: activeQuotaWindows.length ? metricsMatch : false,
-    balance: metricsMatch && active.gateway_balance && typeof active.gateway_balance === 'object' ? active.gateway_balance : (configuredStatus?.balance || null),
-    routeSpend: metricsMatch && active.gateway_route_spend && typeof active.gateway_route_spend === 'object' ? active.gateway_route_spend : (configuredStatus?.routeSpend || null),
-    providerKind: statusProviderKind,
-  };
-  if (!configured) return activeStatus;
-  return activeStatus;
+  return configuredStatus;
 }
 
 function isLocalEstimateWindow(window) {

package/src/vendor/statusline/src/gateway/route-meta.mjs

@@ -307,10 +307,17 @@ function refreshUsageView() {
 
 // Bounded compaction: keep the newest MAX_USAGE_EVENTS lines. Runs in the
 // background under the store lock (appenders take it too, so no append is lost).
-let compactRunning = false;
-async function compactUsageStore(store) {
-  if (compactRunning) return;
-  compactRunning = true;
+let compactRunning = null; // the compaction in flight
+let compactTimer = null; // a compaction scheduled to run
+let compactStore = null;
+function compactUsageStore(store) {
+  compactRunning ??= runUsageCompaction(store).finally(() => {
+    compactRunning = null;
+  });
+  return compactRunning;
+}
+
+async function runUsageCompaction(store) {
   try {
     await withFileLock(usageLockPath(store), async () => {
       const lines = (await readFile(store, 'utf8')).split('\n').filter(l => l.trim());
@@ -319,8 +326,6 @@ async function compactUsageStore(store) {
     });
   } catch {
     // Compaction is best effort; the next flush retries.
-  } finally {
-    compactRunning = false;
   }
 }
 
@@ -330,8 +335,13 @@ function maybeScheduleCompaction(store) {
   } catch {
     return;
   }
-  const t = setTimeout(() => { void compactUsageStore(store); }, 1000);
-  t.unref?.();
+  if (compactTimer) return;
+  compactStore = store;
+  compactTimer = setTimeout(() => {
+    compactTimer = null;
+    void compactUsageStore(store);
+  }, 1000);
+  compactTimer.unref?.();
 }
 
 function takePendingUsageBatch() {
@@ -357,8 +367,12 @@ function flushGatewayUsageEvents() {
   const flush = withFileLock(usageLockPath(store), async () => {
     await mkdir(dirname(store), { recursive: true });
     await appendFile(store, data);
-  }).then(() => maybeScheduleCompaction(store)).catch(() => {
-    // Local telemetry must never affect the routed model call.
+  }).then(() => maybeScheduleCompaction(store)).catch((error) => {
+    // Local telemetry must never affect the routed model call, but a lost
+    // batch is reported rather than settled as written.
+    try {
+      process.stderr.write(`[statusline] gateway usage events not saved: ${error?.message || error}\n`);
+    } catch {}
   });
   usageFlushTail = Promise.all([usageFlushTail, flush]).then(() => {});
   return usageFlushTail;
@@ -378,9 +392,17 @@ function flushGatewayUsageEventsSync() {
   }
 }
 
-/** Resolves once every recorded usage event has been handed to disk. */
-export function settleGatewayUsageWrites() {
-  return flushGatewayUsageEvents();
+/** Resolves once every recorded usage event has been handed to disk and the
+ *  compaction those writes scheduled (run now instead of on its timer) or
+ *  started has rewritten the store. */
+export async function settleGatewayUsageWrites() {
+  await flushGatewayUsageEvents();
+  if (compactTimer) {
+    clearTimeout(compactTimer);
+    compactTimer = null;
+    void compactUsageStore(compactStore);
+  }
+  await compactRunning;
 }
 
 function scheduleGatewayUsageFlush() {

package/scripts/code-graph-description-contract.mjs

@@ -1,188 +0,0 @@
-const FILE_MODES = ['overview', 'imports', 'dependents', 'related', 'impact'];
-const SYMBOL_MODES = ['find_symbol', 'symbol_search', 'search', 'references', 'callers', 'callees'];
-const EXACT_MODES = ['find_symbol', 'references', 'callers', 'callees'];
-const KEYWORD_MODES = ['symbol_search', 'search'];
-const NEGATION =
-  /\b(?:no|not|never|without|cannot|won['’]t|ain['’]t|(?:is|are|was|were|do|does|did|has|have|had|can|could|would|should|must)(?:\s+not|n['’]t)|will\s+not|fail(?:s|ed|ing)?\s+to)\b/i;
-
-const clauses = (text) =>
-  String(text || '')
-    .split(/[.;]\s*/)
-    .map((part) => part.trim())
-    .filter(Boolean);
-const escapeRegExp = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-const includesTerm = (text, term) => {
-  if (/^[a-z_][a-z0-9_]*$/i.test(term)) {
-    return new RegExp(`(?<![a-z0-9_])${escapeRegExp(term)}(?![a-z0-9_])`, 'i').test(text);
-  }
-  return text.toLowerCase().includes(term.toLowerCase());
-};
-const includesAll = (text, terms) => terms.every((term) => includesTerm(text, term));
-const hasPositiveClause = (text, terms) =>
-  clauses(text).some((clause) => !NEGATION.test(clause) && includesAll(clause, terms));
-const hasModeClause = (text, label, modes) => hasPositiveClause(text, [label, ...modes]);
-const hasContradictoryTargetAssignment = (text) =>
-  hasPositiveClause(text, [...FILE_MODES, 'symbols[]']) || hasPositiveClause(text, [...SYMBOL_MODES, 'files[]']);
-const removeIdentifier = (text, identifier) =>
-  text.replace(new RegExp(`(?<![a-z0-9_])${escapeRegExp(identifier)}(?![a-z0-9_])`, 'gi'), '');
-
-const CODE_GRAPH_EQUIVALENT_DESCRIPTION_PROBES = [
-  {
-    description: [
-      'Keywords use search/symbol_search while callers/callees/references/find_symbol use exact identifiers.',
-      'symbols[] targets callees, search, references, symbol_search, callers, and find_symbol symbol modes.',
-      'files[] targets impact, related, dependents, imports, and overview file modes.',
-    ].join(' '),
-    modeDescription: [
-      'A file outline uses files[] for symbols with files.',
-      'Impact, related, dependents, imports, and overview are file modes.',
-      'Callees, callers, references, search, symbol_search, and find_symbol are symbol modes.',
-      'Keywords from fileless symbols route to symbol_search.',
-    ].join(' '),
-    symbolsDescription: [
-      'Keywords select search/symbol_search while callers/callees/references/find_symbol select exact identifiers.',
-      'Pass multiple exact symbols in one symbols[] call.',
-    ].join(' '),
-  },
-  {
-    description: [
-      'Exact identifiers route through callees, references, callers, or find_symbol.',
-      'Keywords route through search or symbol_search.',
-      'The overview, impact, imports, related, and dependents file modes accept files[].',
-      'The search, callees, find_symbol, references, symbol_search, and callers symbol modes accept symbols[].',
-    ].join(' '),
-    modeDescription: [
-      'Related, overview, impact, dependents, and imports are file modes.',
-      'Symbols with files produce a file outline from files[].',
-      'References, callers, callees, find_symbol, search, and symbol_search are symbol modes.',
-      'Fileless symbols treat keywords as symbol_search input.',
-    ].join(' '),
-    symbolsDescription: [
-      'Exact identifiers select references, callees, callers, or find_symbol.',
-      'Keywords select symbol_search or search.',
-      'Multiple exact symbols belong in one symbols[] call.',
-    ].join(' '),
-  },
-];
-
-const CODE_GRAPH_DESCRIPTION_MUTATION_CORPUS = [
-  {
-    name: 'contracted negated file assignment',
-    mutate: (parts) => ({
-      ...parts,
-      description: parts.description.replace(
-        /file modes (?:take|use) files\[\]/i,
-        "file modes aren't assigned files[]"
-      ),
-      filesDescription: String(parts.filesDescription || '').replace(
-        /required for file modes/i,
-        'not required for file modes'
-      ),
-    }),
-  },
-  {
-    name: 'contracted outline polarity inversion',
-    allPositiveProbes: true,
-    mutate: (parts) => ({
-      ...parts,
-      modeDescription: parts.modeDescription.replace(/file outline/i, "isn't a file outline"),
-    }),
-  },
-  {
-    name: 'keyword routing polarity inversion',
-    allPositiveProbes: true,
-    mutate: (parts) => ({
-      ...parts,
-      description: parts.description.replace(
-        /keywords(?::|\s+(?:use|route through|select|via))/i,
-        "keywords won't use"
-      ),
-    }),
-  },
-  {
-    name: 'symbols-with-files outline inversion',
-    allPositiveProbes: true,
-    mutate: (parts) => ({
-      ...parts,
-      modeDescription: parts.modeDescription.replace(/symbols with files/i, 'symbols without files'),
-    }),
-  },
-  {
-    name: 'contradictory file-mode assignment retained beside correct clause',
-    allPositiveProbes: true,
-    mutate: (parts) => ({
-      ...parts,
-      description: `${parts.description} Overview, imports, dependents, related, and impact take symbols[].`,
-    }),
-  },
-  {
-    name: 'contradictory symbol-mode assignment retained beside correct clause',
-    allPositiveProbes: true,
-    mutate: (parts) => ({
-      ...parts,
-      description: `${parts.description} Find_symbol, symbol_search, search, references, callers, and callees take files[].`,
-    }),
-  },
-  {
-    name: 'swapped file-mode/symbol-mode array assignments',
-    allPositiveProbes: true,
-    mutate: (parts) => ({
-      ...parts,
-      description: `${parts.description} Overview, imports, dependents, related, and impact take symbols[]. Find_symbol, symbol_search, search, references, callers, and callees take files[].`,
-    }),
-  },
-  {
-    name: 'standalone search removed from symbol modes and keyword routing',
-    allPositiveProbes: true,
-    mutate: (parts) => ({
-      ...parts,
-      description: removeIdentifier(parts.description, 'search'),
-      modeDescription: removeIdentifier(parts.modeDescription, 'search'),
-      symbolsDescription: removeIdentifier(parts.symbolsDescription, 'search'),
-    }),
-  },
-];
-
-function hasCodeGraphDescriptionContract({ description, modeDescription, filesDescription, symbolsDescription }) {
-  return (
-    (hasPositiveClause(description, ['file modes', 'files[]']) ||
-      hasPositiveClause(filesDescription, ['required for file modes'])) &&
-    (hasPositiveClause(description, ['symbol modes', 'symbols[]']) ||
-      hasPositiveClause(symbolsDescription, ['required for symbol modes'])) &&
-    hasPositiveClause(description, ['exact identifiers', ...EXACT_MODES]) &&
-    hasPositiveClause(description, ['keywords', ...KEYWORD_MODES]) &&
-    !hasContradictoryTargetAssignment(description) &&
-    hasModeClause(modeDescription, 'file modes', FILE_MODES) &&
-    hasPositiveClause(modeDescription, ['symbols with files', 'files[]', 'file outline']) &&
-    !hasContradictoryTargetAssignment(modeDescription) &&
-    !hasContradictoryTargetAssignment(filesDescription) &&
-    hasPositiveClause(symbolsDescription, ['exact identifiers']) &&
-    hasPositiveClause(symbolsDescription, ['keywords']) &&
-    !hasContradictoryTargetAssignment(symbolsDescription)
-  );
-}
-
-export function assertCodeGraphDescriptionContract(parts) {
-  if (!hasCodeGraphDescriptionContract(parts)) {
-    throw new Error('code_graph descriptions must preserve per-mode targets and exact-vs-keyword routing');
-  }
-  for (const probe of CODE_GRAPH_EQUIVALENT_DESCRIPTION_PROBES) {
-    if (!hasCodeGraphDescriptionContract(probe)) {
-      throw new Error('code_graph description contract must accept equivalent reordered compact prose');
-    }
-    for (const mutation of CODE_GRAPH_DESCRIPTION_MUTATION_CORPUS.filter((entry) => entry.allPositiveProbes)) {
-      const mutated = mutation.mutate(probe);
-      if (JSON.stringify(mutated) === JSON.stringify(probe)) {
-        throw new Error(`code_graph description mutation did not apply to positive probe: ${mutation.name}`);
-      }
-      if (hasCodeGraphDescriptionContract(mutated)) {
-        throw new Error(`code_graph description contract accepted positive-probe mutation: ${mutation.name}`);
-      }
-    }
-  }
-  for (const mutation of CODE_GRAPH_DESCRIPTION_MUTATION_CORPUS) {
-    if (hasCodeGraphDescriptionContract(mutation.mutate(parts))) {
-      throw new Error(`code_graph description contract accepted mutation: ${mutation.name}`);
-    }
-  }
-}

package/src/runtime/channels/lib/owned-runtime/ownership-refresh.mjs

@@ -1,36 +0,0 @@
-// Daemon model: this runtime is the unconditional bridge owner, so a refresh
-// just keeps the owned runtime in sync with channelBridgeActive.
-export function createOwnershipRefresh({
-  state,
-  getBridgeRuntimeConnected,
-  getChannelBridgeActive,
-  startOwnedRuntime,
-  stopOwnedRuntime,
-}) {
-  async function syncWithBridgeActivity(options) {
-    if (!getChannelBridgeActive()) {
-      if (getBridgeRuntimeConnected()) await stopOwnedRuntime('bridge inactive');
-      return;
-    }
-    // Idempotent; early-returns when already connected.
-    await startOwnedRuntime(options);
-  }
-  // Concurrent callers coalesce onto the in-flight refresh so provider tool
-  // calls landing during a normal login wait for the same connect attempt
-  // instead of observing a spurious auto-connect failure.
-  async function refreshBridgeOwnership(options = {}) {
-    if (state.refreshInFlight) return state.refreshInFlight;
-    state.refreshInFlight = syncWithBridgeActivity(options);
-    try {
-      return await state.refreshInFlight;
-    } finally {
-      state.refreshInFlight = null;
-    }
-  }
-  function refreshBridgeOwnershipSafe(options = {}) {
-    refreshBridgeOwnership(options).catch((err) =>
-      process.stderr.write(`[channels] refreshBridgeOwnership rejected: ${err?.message || err}\n`)
-    );
-  }
-  return { refreshBridgeOwnership, refreshBridgeOwnershipSafe };
-}