@geraldmaron/construct 1.0.24 → 1.1.1

package/lib/engine/contradiction.mjs

@@ -0,0 +1,74 @@
+/**
+ * lib/engine/contradiction.mjs — deterministic "do these two observations disagree?"
+ *
+ * Restatement supersede (construct-xh6c) collapses near-duplicates that say the
+ * same thing. The open case is contradiction: two observations about the same
+ * subject that make opposing claims ("auth is supported" vs "auth is not
+ * supported"). A contradiction inherently shares most of its tokens but flips
+ * one — so its cosine sits *below* the duplicate threshold, which is why the
+ * consolidation scan looks in a suspicious band rather than inside a cluster.
+ *
+ * The signal this detects without an LLM is negation polarity: same claim
+ * words, opposite assertion. A value swap with no negation cue ("RS256" vs
+ * "HS256") is not caught here — that needs semantic judgment and is left to an
+ * optional `contradictionJudge` plugin wired into the consolidation pass.
+ */
+
+// Cues that flip an assertion. Apostrophes are stripped during tokenization, so
+// contracted forms appear here without them (don't -> dont, isn't -> isnt).
+const NEGATION_CUES = new Set([
+  'not', 'no', 'never', 'none', 'neither', 'nor', 'without', 'cannot',
+  'dont', 'doesnt', 'didnt', 'isnt', 'arent', 'wasnt', 'werent', 'wont',
+  'cant', 'couldnt', 'shouldnt', 'wouldnt', 'fails', 'failing', 'failed',
+  'unsupported', 'disabled', 'broken', 'missing', 'absent',
+]);
+
+function tokenize(text) {
+  return String(text || '')
+    .toLowerCase()
+    .replace(/['’]/g, '')
+    .split(/[^a-z0-9]+/)
+    .filter(Boolean);
+}
+
+function jaccard(a, b) {
+  if (a.size === 0 && b.size === 0) return 0;
+  let inter = 0;
+  for (const t of a) if (b.has(t)) inter += 1;
+  return inter / (a.size + b.size - inter);
+}
+
+/**
+ * Decide whether two observation texts contradict on negation polarity.
+ *
+ * Contradiction = the claim words (tokens minus negation cues) overlap heavily
+ * AND the two carry a different number of negation cues — one asserts, the other
+ * denies the same thing.
+ *
+ * @param {string} textA
+ * @param {string} textB
+ * @param {{coreSimilarity?: number}} [opts] coreSimilarity: Jaccard floor on the
+ *   cue-stripped token sets (default 0.6); below it the two are about different
+ *   subjects, not a flipped claim.
+ * @returns {{contradicts: boolean, coreSimilarity: number, negDelta: number, reason: string}}
+ */
+export function detectContradiction(textA, textB, opts = {}) {
+  const floor = opts.coreSimilarity ?? 0.6;
+  const tokA = tokenize(textA);
+  const tokB = tokenize(textB);
+  const negA = tokA.filter((t) => NEGATION_CUES.has(t)).length;
+  const negB = tokB.filter((t) => NEGATION_CUES.has(t)).length;
+  const coreA = new Set(tokA.filter((t) => !NEGATION_CUES.has(t)));
+  const coreB = new Set(tokB.filter((t) => !NEGATION_CUES.has(t)));
+
+  const coreSimilarity = jaccard(coreA, coreB);
+  const negDelta = negA - negB;
+  const contradicts =
+    coreA.size > 0 && coreB.size > 0 &&
+    coreSimilarity >= floor &&
+    negDelta !== 0;
+
+  return { contradicts, coreSimilarity, negDelta, reason: 'negation-polarity' };
+}
+
+export const __testing = { tokenize, jaccard, NEGATION_CUES };

package/lib/handoffs/cleanup.mjs

@@ -10,7 +10,7 @@
  *      surfaced as a warning but never deleted — open work is sacred.
  *
  * The function is idempotent and runs from:
- *   - `construct down` (best effort, time-boxed)
+ *   - `construct stop` (best effort, time-boxed)
  *   - doctor daemon tick (lib/doctor/watchers/handoffs.mjs)
  *   - `construct handoffs prune` (manual)
  *

package/lib/hooks/audit-trail.mjs

@@ -33,11 +33,11 @@
  * @matcher  Edit|Write|MultiEdit|NotebookEdit|Bash
  * @exits 0 = pass
  */
-import { readFileSync, existsSync, mkdirSync } from 'node:fs';
+import { readFileSync, existsSync } from 'node:fs';
 import { createHash } from 'node:crypto';
-import { join, resolve, dirname } from 'node:path';
+import { join, resolve } from 'node:path';
 import { homedir } from 'node:os';
-import { appendBounded, readLastLineAcrossSegments } from '../logging/rotate.mjs';
+import { appendAuditRecord } from '../audit-trail.mjs';
 import { resolveProjectScopedPath } from '../project-root.mjs';
 import { logHookFailure } from './_lib/log.mjs';
 
@@ -77,16 +77,6 @@ function readLastAgent() {
   }
 }
 
-function readPrevLineHash() {
-  try {
-    const lastLine = readLastLineAcrossSegments(AUDIT_FILE);
-    if (lastLine === null) return null;
-    return sha256(lastLine);
-  } catch {
-    return null;
-  }
-}
-
 function truncateSnippet(s, limit = 280) {
   if (!s) return '';
   const str = String(s);
@@ -140,22 +130,18 @@ if (toolName !== 'Bash' && target) {
   }
 }
 
-const record = {
-  ts: new Date().toISOString(),
-  session_id: input?.session_id || null,
-  tool: toolName,
-  agent: readLastAgent(),
-  task: null,
-  cwd,
-  target,
-  detail,
-  content_hash: contentHash,
-  prev_line_hash: readPrevLineHash(),
-};
-
 try {
-  mkdirSync(dirname(AUDIT_FILE), { recursive: true });
-  appendBounded('audit-trail', AUDIT_FILE, JSON.stringify(record) + '\n');
+  appendAuditRecord({
+    ts: new Date().toISOString(),
+    session_id: input?.session_id || null,
+    tool: toolName,
+    agent: readLastAgent(),
+    task: null,
+    cwd,
+    target,
+    detail,
+    content_hash: contentHash,
+  }, { file: AUDIT_FILE });
 } catch (err) {
   logHookFailure({ hook: 'audit-trail', err, phase: 'append' });
 }

package/lib/host-capabilities.mjs

@@ -118,6 +118,36 @@ function detectCopilotAvailability(homeDir = os.homedir()) {
   return { hasFiles };
 }
 
+/**
+ * Detects active host-native sessions (GitHub, Anthropic, etc.).
+ * Returns a list of authenticated provider families.
+ */
+export function detectActiveSessions() {
+  const active = [];
+  
+  // GitHub Copilot check
+  try {
+    const ghStatus = execSync("gh auth status", { stdio: ["ignore", "pipe", "ignore"], encoding: "utf8" });
+    if (ghStatus.includes("Logged in to github.com")) {
+      active.push("github-copilot");
+    }
+  } catch { /* not logged in or gh cli missing */ }
+  
+  // Anthropic / Claude Code check
+  const home = os.homedir();
+  const claudeSettings = path.join(home, ".claude", "settings.json");
+  try {
+    if (fs.existsSync(claudeSettings)) {
+      const settings = JSON.parse(fs.readFileSync(claudeSettings, "utf8"));
+      if (settings?.primaryModel || settings?.mcpServers) {
+        active.push("anthropic");
+      }
+    }
+  } catch { /* invalid or missing config */ }
+  
+  return active;
+}
+
 // `capability` is the honest, normalized functional classification per host:
 //   full-native      — the host runs a multi-specialist chain itself (native
 //                       dispatch or config-driven agents): Claude Code, OpenCode.

package/lib/ingest/docling-remote.mjs

@@ -0,0 +1,90 @@
+/**
+ * lib/ingest/docling-remote.mjs — opt-in remote document conversion via Docling Serve.
+ *
+ * The `docling-remote` ingest strategy (ADR-0036) sends the document to a
+ * user-configured Docling Serve API instead of the offline Python sidecar —
+ * for zero-local-footprint installs that accept remote conversion. The endpoint
+ * contract is Docling Serve's `POST /v1/convert/file` (multipart field `files`,
+ * markdown at `document.md_content`, per docling-serve docs/usage.md).
+ *
+ * The serve URL must be configured (DOCLING_SERVE_URL); a missing URL fails loud —
+ * the user explicitly chose remote, so silently degrading to the sidecar would
+ * hide the misconfiguration. The call is bounded by the same timeout knob as the
+ * sidecar (CONSTRUCT_DOCLING_TIMEOUT_MS, default 600s).
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+
+const DEFAULT_TIMEOUT_MS = 600_000;
+
+export function resolveDoclingServeUrl(env = process.env) {
+  const raw = (env.DOCLING_SERVE_URL || '').trim();
+  return raw ? raw.replace(/\/+$/, '') : null;
+}
+
+/**
+ * Convert one local file through Docling Serve. Returns the shared extractor
+ * contract ({ text, extractionMethod, characters, truncated, droppedInfo }).
+ * Throws (fail-loud) on missing URL, HTTP error, non-success status, or timeout.
+ */
+export async function extractViaDoclingRemote({ filePath, maxChars = null, env = process.env, timeoutMs = null } = {}) {
+  const baseUrl = resolveDoclingServeUrl(env);
+  if (!baseUrl) {
+    const err = new Error(
+      "ingest.strategy is 'docling-remote' but DOCLING_SERVE_URL is not set. " +
+      "Point it at a Docling Serve instance, or switch ingest.strategy back to 'adapter' (offline sidecar).",
+    );
+    err.code = 'DOCLING_REMOTE_UNCONFIGURED';
+    throw err;
+  }
+
+  const budget = timeoutMs ?? (Number(env.CONSTRUCT_DOCLING_TIMEOUT_MS) || DEFAULT_TIMEOUT_MS);
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), budget);
+  try {
+    const form = new FormData();
+    const bytes = fs.readFileSync(filePath);
+    form.append('files', new Blob([bytes]), path.basename(filePath));
+
+    const res = await fetch(`${baseUrl}/v1/convert/file`, {
+      method: 'POST',
+      body: form,
+      signal: controller.signal,
+    });
+    if (!res.ok) {
+      const err = new Error(`Docling Serve returned HTTP ${res.status} for ${path.basename(filePath)}`);
+      err.code = 'DOCLING_REMOTE_HTTP';
+      throw err;
+    }
+    const data = await res.json();
+    const status = data?.status;
+    const markdown = data?.document?.md_content;
+    if ((status && status !== 'success' && status !== 'partial_success') || typeof markdown !== 'string') {
+      const detail = Array.isArray(data?.errors) && data.errors.length ? `: ${JSON.stringify(data.errors).slice(0, 200)}` : '';
+      const err = new Error(`Docling Serve conversion ${status || 'returned no markdown'}${detail}`);
+      err.code = 'DOCLING_REMOTE_FAILED';
+      throw err;
+    }
+
+    const truncated = maxChars != null && markdown.length > maxChars;
+    const text = truncated ? markdown.slice(0, maxChars) : markdown;
+    return {
+      text,
+      extractionMethod: 'docling-remote',
+      characters: text.length,
+      truncated,
+      droppedInfo: status === 'partial_success'
+        ? [{ type: 'partial-conversion', count: 1, reason: 'Docling Serve reported partial_success', recoverable: true }]
+        : [],
+    };
+  } catch (err) {
+    if (err.name === 'AbortError') {
+      const e = new Error(`Docling Serve conversion timed out after ${budget}ms`);
+      e.code = 'DOCLING_REMOTE_TIMEOUT';
+      throw e;
+    }
+    throw err;
+  } finally {
+    clearTimeout(timer);
+  }
+}

package/lib/ingest/strategy.mjs

@@ -17,7 +17,7 @@ import { resolveSetting } from '../config/project-config.mjs';
 import { resolveEmbeddedModel } from '../embedded-contract/model-resolve.mjs';
 import { resolveExecution } from '../embedded-contract/execution.mjs';
 
-export const INGEST_STRATEGIES = ['adapter', 'provider'];
+export const INGEST_STRATEGIES = ['adapter', 'provider', 'docling-remote'];
 export const INGEST_FALLBACKS = ['none', 'provider', 'adapter'];
 
 // Orchestration is a second, independent axis from extraction (adapter|provider):

package/lib/init-unified.mjs

@@ -23,6 +23,7 @@ import { multiSelect } from './tty-prompts.mjs';
 import { execSync, spawnSync } from 'node:child_process';
 import { stageProjectAdapters } from './install/stage-project.mjs';
 import { missingIgnorePatterns, isConstructPackageRepo } from './host-disposition.mjs';
+import { HOST_KEYS, displayNameToKey } from './platforms/capabilities.mjs';
 
 const __dirname = fileURLToPath(new URL(".", import.meta.url));
 const ROOT_DIR = path.join(__dirname, "..");
@@ -63,8 +64,7 @@ const commitBootstrap = args.includes("--commit-bootstrap");
 // one, --all-hosts writes every adapter set. Copilot (`.github/`) is opt-in only
 // — never written by detection — so init never touches a repo's CI directory
 // without --with-copilot.
-const HOST_FLAG_KEYS = ["claude", "codex", "opencode", "vscode", "cursor", "copilot"];
-const withHostFlags = new Set(HOST_FLAG_KEYS.filter((k) => args.includes(`--with-${k}`)));
+const withHostFlags = new Set(HOST_KEYS.filter((k) => args.includes(`--with-${k}`)));
 const allHosts = args.includes("--all-hosts");
 
 // Active profile selector. `--profile=<id>` writes the field into the
@@ -809,23 +809,19 @@ async function resolveAdapterHosts() {
   const detected = new Set();
   try {
     const { detectHostCapabilities } = await import('./host-capabilities.mjs');
-    const nameToKey = {
-      'Claude Code': 'claude',
-      'OpenCode': 'opencode',
-      'Codex': 'codex',
-      'VS Code': 'vscode',
-      'Cursor': 'cursor',
-      'Copilot': 'copilot',
-    };
+    const nameToKey = displayNameToKey();
     for (const cap of detectHostCapabilities()) {
       if (cap.availability === 'installed' && nameToKey[cap.host]) detected.add(nameToKey[cap.host]);
     }
   } catch { /* detection is advisory; fall back to flags + baseline */ }
   detected.delete('copilot');
   const selected = new Set([...detected, ...withHostFlags]);
-  if (selected.has('vscode')) selected.add('claude');
-  if (selected.size === 0) selected.add('claude');
-  return HOST_FLAG_KEYS.filter((k) => selected.has(k));
+
+  // An empty selection writes no adapters: nothing detected and no --with-<host>
+  // flag means the user is guided by docs to run sync with an explicit host,
+  // rather than scaffolding a sidecar they did not ask for.
+
+  return HOST_KEYS.filter((k) => selected.has(k));
 }
 
 async function main() {

package/lib/logging/rotate.mjs

@@ -222,6 +222,24 @@ export const LIMITS = {
     envOverride: 'CONSTRUCT_SKILL_CALLS_MAX_MB',
   },
 
+  // Per-hook fire/block/error telemetry. ~/.cx/hook-calls.jsonl.
+
+  'hook-calls': {
+    maxBytes: 25 * 1024 * 1024,
+    maxSegments: 4,
+    gzip: true,
+    envOverride: 'CONSTRUCT_HOOK_CALLS_MAX_MB',
+  },
+
+  // Legacy-lock fallback firings on the beads write path. ~/.cx/beads-fallback.jsonl.
+
+  'beads-fallback': {
+    maxBytes: 5 * 1024 * 1024,
+    maxSegments: 2,
+    gzip: true,
+    envOverride: 'CONSTRUCT_BEADS_FALLBACK_MAX_MB',
+  },
+
   // Agent-dispatch log written by `lib/hooks/agent-tracker.mjs`. Path: ~/.cx/agent-log.jsonl.
 
   'agent-log': {

package/lib/mcp/server.mjs

@@ -118,8 +118,12 @@ server.setRequestHandler(ReadResourceRequestSchema, async (req) => {
   };
 });
 
-server.setRequestHandler(ListToolsRequestSchema, async () => ({
-  tools: [
+// The full construct-mcp tool catalog. Only a curated core is exposed flat in
+// ListTools; the long tail is reachable through the construct_call meta-tool, so
+// the serialized tool surface stays small on every host and model. The 71-tool
+// flat surface alone (~10.6k tokens) overran a 32k local-model window.
+
+const ALL_TOOL_DEFS = [
     {
       name: 'agent_health',
       description: 'Returns agent health summaries from the most recent performance review.',
@@ -1209,17 +1213,60 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
         },
       },
     },
-  ],
-}));
+];
 
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-  const { name, arguments: args = {} } = request.params;
+// Curated flat core: high-frequency, low-arg tools the orchestrator and the
+// built-in Build/Plan agents actually reach for. Everything else collapses
+// behind construct_call so the schema stays small. Universal — applies on every
+// host/model; the long tail is reachable, just not front-loaded.
+
+const CORE_TOOL_NAMES = new Set([
+  'orchestration_policy', 'get_skill', 'search_skills', 'knowledge_search',
+  'memory_search', 'project_context', 'summarize_diff',
+]);
+
+function firstSentence(text) {
+  const s = String(text || '').replace(/\s+/g, ' ').trim();
+  const end = s.search(/\.(\s|$)/);
+  return (end > 0 ? s.slice(0, end) : s).slice(0, 140);
+}
+
+const LONG_TAIL_DEFS = ALL_TOOL_DEFS.filter((t) => !CORE_TOOL_NAMES.has(t.name));
+
+// One dispatcher for the long tail. `tool` is constrained to an enum of valid
+// names (≈1 token each — kills hallucinated names, the key small-model lever),
+// and the description carries a compact one-line catalog instead of ~10k of full
+// schemas. Dispatch reuses the same handlers via dispatchToolByName.
+
+const CONSTRUCT_CALL_TOOL = {
+  name: 'construct_call',
+  description:
+    'Invoke any non-core Construct tool by name. Put the tool name in `tool` and its arguments in `args`. '
+    + 'Available tools:\n'
+    + LONG_TAIL_DEFS.map((t) => `- ${t.name} — ${firstSentence(t.description)}`).join('\n'),
+  inputSchema: {
+    type: 'object',
+    properties: {
+      tool: { type: 'string', enum: LONG_TAIL_DEFS.map((t) => t.name), description: 'The Construct tool to invoke.' },
+      args: { type: 'object', additionalProperties: true, description: 'Arguments object for the tool.' },
+    },
+    required: ['tool'],
+  },
+};
+
+export function exposedTools() {
+  return [...ALL_TOOL_DEFS.filter((t) => CORE_TOOL_NAMES.has(t.name)), CONSTRUCT_CALL_TOOL];
+}
 
-  // Extract W3C traceparent from params._meta (SEP-414 propagation).
-  const parentCtx = await extractTraceContext(request.params?._meta || {});
+server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: exposedTools() }));
 
+// Single dispatch table shared by the direct CallTool path and the construct_call
+// meta-tool, so collapsing the surface costs no capability — every tool stays
+// reachable by name. construct_call re-enters here once (guarded against
+// recursing into itself).
+
+export async function dispatchToolByName(name, args = {}) {
   let result;
-  try {
     if (name === 'agent_health') result = agentHealth(args);
     else if (name === 'summarize_diff') result = summarizeDiff(args);
     else if (name === 'scan_file') result = scanFile(args);
@@ -1301,13 +1348,65 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     else if (name === 'construct_execution_resolve') result = executionResolve(args);
     else if (name === 'orchestration_run') { const m = await import('./tools/orchestration-run.mjs'); result = await m.orchestrationRun(args); }
     else if (name === 'orchestration_status') { const m = await import('./tools/orchestration-run.mjs'); result = await m.orchestrationStatus(args); }
+    else if (name === 'construct_call') {
+      const inner = String(args?.tool || '');
+      if (!inner || inner === 'construct_call') result = { error: "construct_call requires a 'tool' name (not 'construct_call')" };
+      else result = await dispatchToolByName(inner, args?.args || {});
+    }
     else result = { error: `Unknown tool: ${name}` };
-  } catch (err) {
-    result = { error: err.message ?? String(err) };
+  return result;
+}
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args = {} } = request.params;
+
+  // Extract W3C traceparent from params._meta (SEP-414 propagation). Tracing
+  // must never break dispatch — a malformed _meta should not fail the call.
+  let parentCtx = {};
+  try { parentCtx = await extractTraceContext(request.params?._meta || {}); } catch { /* tracing optional */ }
+  void parentCtx;
+
+  // Bound every tool call. A tool that stalls (a stuck external extractor, a slow
+  // model load, a wedged subprocess) must surface a clean timeout error to the
+  // client rather than block the request until the client gives up and reports an
+  // opaque failure. Override with CONSTRUCT_MCP_TOOL_TIMEOUT_MS (0 disables).
+  const TOOL_TIMEOUT_MS = (() => {
+    const raw = Number(process.env.CONSTRUCT_MCP_TOOL_TIMEOUT_MS);
+    return Number.isFinite(raw) && raw >= 0 ? raw : 120_000;
+  })();
+
+  const dispatch = (async () => {
+    let result;
+    try {
+      result = await dispatchToolByName(name, args);
+    } catch (err) {
+      result = { error: err.message ?? String(err) };
+    }
+    return result;
+  })();
+
+  let toolResult;
+  if (!TOOL_TIMEOUT_MS) {
+    toolResult = await dispatch;
+  } else {
+    let timer;
+    const timeout = new Promise((_, reject) => {
+      timer = setTimeout(
+        () => reject(new Error(`tool ${name} timed out after ${Math.round(TOOL_TIMEOUT_MS / 1000)}s`)),
+        TOOL_TIMEOUT_MS,
+      );
+    });
+    try {
+      toolResult = await Promise.race([dispatch, timeout]);
+    } catch (err) {
+      toolResult = { error: err.message ?? String(err) };
+    } finally {
+      clearTimeout(timer);
+    }
   }
 
   return {
-    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+    content: [{ type: 'text', text: JSON.stringify(toolResult, null, 2) }],
   };
 });
 
@@ -1333,6 +1432,19 @@ export {
 const argv1Real = (() => { try { return realpathSync(process.argv[1]); } catch { return process.argv[1]; } })();
 if (fileURLToPath(import.meta.url) === argv1Real) {
   console.error('[construct-mcp] server started');
+
+  // A long-running stdio server must survive a single malformed request: a
+  // background rejection from one ingest (e.g. a broken docling sidecar that
+  // settles late) must not terminate the process and close the client
+  // connection. Log loudly and keep serving instead of crashing. Scoped to the
+  // server entry so importing this module never installs global handlers.
+  process.on('unhandledRejection', (reason) => {
+    console.error('[construct-mcp] unhandledRejection (kept alive):', reason instanceof Error ? reason.stack : reason);
+  });
+  process.on('uncaughtException', (err) => {
+    console.error('[construct-mcp] uncaughtException (kept alive):', err?.stack || err);
+  });
+
   const transport = new StdioServerTransport();
   await server.connect(transport);
 }

package/lib/mcp/tool-budget.mjs

@@ -0,0 +1,53 @@
+/**
+ * lib/mcp/tool-budget.mjs — tool-surface sizing for the OpenCode integration.
+ *
+ * OpenCode 1.15.4 exposes no per-session tool filter (chat.params carries only
+ * sampler params, and tool.definition cannot remove a tool or see the model), so
+ * the serialized tool surface is fixed by two config/server-time levers:
+ *   1. construct-mcp's ListTools — a lean core + the construct_call gateway.
+ *   2. which external MCP servers are `enabled` in opencode.json — sync disables
+ *      the heavy ones for local-capable setups (they cannot be trimmed at runtime).
+ * Holds the shared token-sizing helper and the external-server id list both
+ * levers reason about.
+ */
+
+const TOKENS_PER_CHAR = 0.25;
+
+// Heavy external MCP servers Construct registers globally. On a local-capable
+// setup these alone serialize ~12k tokens into every agent's window (including
+// the built-in Build/Plan agents) and cannot be filtered per request, so sync
+// disables them in opencode.json. construct-mcp's own knowledge_search /
+// memory_search cover the search/memory cases.
+
+export const HEAVY_EXTERNAL_MCP_IDS = ['context7', 'github', 'memory', 'sequential-thinking', 'playwright'];
+
+export const LOCAL_SURFACE_MODES = ['auto', 'on', 'off'];
+
+// A model benefits from trimming only when it is a small-context local runtime
+// reached over Ollama/localhost. github-copilot is a hosted, full-context proxy,
+// so it is deliberately not "local" here even though it is provider-local.
+
+export function isLocalModel(model) {
+  const m = (model || "").toLowerCase();
+  return m.includes("ollama") || m.includes("localhost") || m.includes("127.0.0.1");
+}
+
+// Decide whether to disable the heavy external MCP servers for one opencode.json.
+// Trimming is driven by INTENT — the default model this config actually selects —
+// not by whether the machine happens to have Ollama installed. Machine-wide
+// presence stripped context7/github from cloud sessions that merely shared a box
+// with Ollama; keying off the config's own default model preserves cloud surfaces
+// and still shrinks the window when the user has chosen a local model.
+//   surface: 'on' (always trim) | 'off' (never) | 'auto' (trim iff default is local)
+
+export function decideTrim({ surface = 'auto', defaultModel = null } = {}) {
+  if (surface === 'off') return false;
+  if (surface === 'on') return true;
+  return isLocalModel(defaultModel);
+}
+
+export function estimateToolTokens(tools) {
+  if (!tools) return 0;
+  const arr = Array.isArray(tools) ? tools : Object.values(tools);
+  return Math.round(JSON.stringify(arr).length * TOKENS_PER_CHAR);
+}

package/lib/mcp-catalog.json

@@ -29,7 +29,7 @@
     {
       "id": "sequential-thinking",
       "name": "Sequential Thinking",
-      "category": "core",
+      "category": "optional",
       "description": "Structured multi-step reasoning chains. Helps with complex planning and analysis.",
       "package": "@modelcontextprotocol/server-sequential-thinking",
       "command": "npx",