synabun 2.0.10 → 2.2.0

package/mcp-server/src/services/codex-config-heal.ts

@@ -11,12 +11,23 @@
  * emitted by its old Settings writer. All unrelated configuration is left
  * byte-for-byte intact. Repairs keep a backup; file writes are atomic,
  * preserve the original mode, and are idempotent.
+ *
+ * The managed keys: SYNABUN_TOOLS = "all" (every SynaBun tool; a Codex
+ * runtime's own list is only its focus) and SYNABUN_TOOL_CATALOG_MODE =
+ * "deferred". SYNABUN_PROFILE, the key a tool list replaced, is never written.
+ * Its old managed value "full" is left where it is: a Neural Interface from
+ * before tool lists (until it restarts, or another install sharing this file)
+ * repairs any config without it, and the MCP child reads SYNABUN_TOOLS first,
+ * so the line is inert and the two never undo each other's repair. Any other
+ * SYNABUN_PROFILE value is removed.
  */
 import {
   chmodSync,
   copyFileSync,
   existsSync,
+  lstatSync,
   readFileSync,
+  realpathSync,
   renameSync,
   statSync,
   unlinkSync,
@@ -28,15 +39,19 @@ const ENV_SECTION = `${BASE_SECTION}.env`;
 const TOOL_SECTION_PREFIX = `${BASE_SECTION}.tools.`;
 const SECTION_HEADER_RE = /^\[([^\]]+)\]\s*$/m;
 const INLINE_ENV_LINE_RE = /^env\s*=\s*\{([^}]*)\}\s*\r?\n?/m;
-const MANAGED_PROFILE_KEY = 'SYNABUN_PROFILE';
-const CODEX_PROFILE = 'full';
+const MANAGED_TOOLS_KEY = 'SYNABUN_TOOLS';
+const CODEX_TOOLS = 'all';
+const LEGACY_PROFILE_KEY = 'SYNABUN_PROFILE';
+/** The value a Neural Interface from before tool lists writes and repairs: left alone (see the header). */
+const LEGACY_CODEX_PROFILE = 'full';
 const TOOL_CATALOG_MODE_KEY = 'SYNABUN_TOOL_CATALOG_MODE';
 const CODEX_TOOL_CATALOG_MODE = 'deferred';
 
 export type CodexConfigIssue =
   | 'duplicate_env'
   | 'legacy_inline_env'
-  | 'managed_profile_override'
+  | 'managed_tools_override'
+  | 'legacy_profile_key'
   | 'missing_deferred_catalog'
   | 'missing_transport'
   | 'orphan_env'
@@ -60,8 +75,9 @@ export type HealReason =
   | 'removed_ignored_settings'
   | 'removed_duplicate_inline_env'
   | 'normalized_inline_env'
-  | 'removed_managed_profile_override'
-  | 'set_full_profile'
+  | 'migrated_profile_key'
+  | 'set_all_tools'
+  | 'removed_legacy_profile_key'
   | 'enabled_deferred_catalog'
   | 'removed_orphan_sections';
 
@@ -182,8 +198,9 @@ function upsertTomlKey(body: string, key: string, serializedValue: string): stri
   const keyRe = new RegExp(`^${escapeRegExp(key)}\\s*=.*$`, 'm');
   if (keyRe.test(body)) return body.replace(keyRe, `${key} = ${serializedValue}`);
   const newline = body.includes('\r\n') ? '\r\n' : '\n';
-  const trimmed = body.replace(/^\r?\n/, '').replace(/[ \t]*$/, '');
-  return `${newline}${key} = ${serializedValue}${trimmed ? `${newline}${trimmed}` : ''}${newline}`;
+  // The new key goes first; the rest of the body keeps its own lines, the blank one before the next table included.
+  const rest = body.replace(/^\r?\n/, '');
+  return `${newline}${key} = ${serializedValue}${newline}${rest}`;
 }
 
 function removeTomlKey(body: string, key: string): string {
@@ -196,10 +213,11 @@ function renderEnvSection(env: Record<string, string>, newline: string): string
   return `[${ENV_SECTION}]${newline}${lines.join(newline)}${newline}`;
 }
 
-function upsertEnvSection(content: string, env: Record<string, string>): string {
+function upsertEnvSection(content: string, env: Record<string, string>, { remove = [] }: { remove?: readonly string[] } = {}): string {
   const newline = content.includes('\r\n') ? '\r\n' : '\n';
   const sanitized = { ...env };
-  sanitized[MANAGED_PROFILE_KEY] = CODEX_PROFILE;
+  for (const key of remove) delete sanitized[key];
+  sanitized[MANAGED_TOOLS_KEY] = CODEX_TOOLS;
   sanitized[TOOL_CATALOG_MODE_KEY] = CODEX_TOOL_CATALOG_MODE;
 
   if (!hasSection(content, ENV_SECTION)) {
@@ -208,12 +226,17 @@ function upsertEnvSection(content: string, env: Record<string, string>): string
   }
 
   let body = sectionBody(content, ENV_SECTION);
+  for (const key of remove) body = removeTomlKey(body, key);
   for (const [key, value] of Object.entries(sanitized)) {
     body = upsertTomlKey(body, key, quote(value));
   }
   return replaceSectionBody(content, ENV_SECTION, body);
 }
 
+function hasKey(env: Record<string, string>, key: string): boolean {
+  return Object.prototype.hasOwnProperty.call(env, key);
+}
+
 function baseInlineEnv(content: string): Record<string, string> {
   const body = sectionBody(content, BASE_SECTION);
   const match = INLINE_ENV_LINE_RE.exec(body);
@@ -242,13 +265,16 @@ export function inspectCodexConfigContent(content: string): CodexConfigInspectio
 
   if (inlineEnv && hasEnv) issues.push('duplicate_env');
   else if (inlineEnv) issues.push('legacy_inline_env');
-  const configuredProfile = tableEnv[MANAGED_PROFILE_KEY] || inlineValues[MANAGED_PROFILE_KEY];
-  if (hasBase && hasTransport(content) && configuredProfile !== CODEX_PROFILE) {
-    issues.push('managed_profile_override');
-  }
-  if (hasBase && hasTransport(content)
-    && (tableEnv[TOOL_CATALOG_MODE_KEY] || inlineValues[TOOL_CATALOG_MODE_KEY]) !== CODEX_TOOL_CATALOG_MODE) {
-    issues.push('missing_deferred_catalog');
+  if (hasBase && hasTransport(content)) {
+    const tools = tableEnv[MANAGED_TOOLS_KEY] || inlineValues[MANAGED_TOOLS_KEY];
+    const hasProfile = hasKey(tableEnv, LEGACY_PROFILE_KEY) || hasKey(inlineValues, LEGACY_PROFILE_KEY);
+    const profile = tableEnv[LEGACY_PROFILE_KEY] ?? inlineValues[LEGACY_PROFILE_KEY];
+    // A config from before tool lists names only SYNABUN_PROFILE: migrating it is one issue, not two.
+    if (tools !== CODEX_TOOLS) issues.push(!tools && hasProfile ? 'legacy_profile_key' : 'managed_tools_override');
+    if (hasProfile && profile !== LEGACY_CODEX_PROFILE && !issues.includes('legacy_profile_key')) issues.push('legacy_profile_key');
+    if ((tableEnv[TOOL_CATALOG_MODE_KEY] || inlineValues[TOOL_CATALOG_MODE_KEY]) !== CODEX_TOOL_CATALOG_MODE) {
+      issues.push('missing_deferred_catalog');
+    }
   }
   if (hasBase && !hasTransport(content)) issues.push('missing_transport');
   if (!hasBase && hasEnv) issues.push('orphan_env');
@@ -286,23 +312,33 @@ export function repairCodexConfigContent(content: string): { content: string; re
   const tableEnv = parseEnvTable(next);
   const hadInline = INLINE_ENV_LINE_RE.test(sectionBody(next, BASE_SECTION));
   const hadTable = hasSection(next, ENV_SECTION);
-  const hadCanonicalProfile = (tableEnv[MANAGED_PROFILE_KEY] || inlineEnv[MANAGED_PROFILE_KEY]) === CODEX_PROFILE;
+  const configuredTools = tableEnv[MANAGED_TOOLS_KEY] || inlineEnv[MANAGED_TOOLS_KEY];
+  const hadAllTools = configuredTools === CODEX_TOOLS;
+  const hasProfile = hasKey(tableEnv, LEGACY_PROFILE_KEY) || hasKey(inlineEnv, LEGACY_PROFILE_KEY);
+  // "full" stays: an older Neural Interface writes it back into a config without it (through an account's link to
+  // this file, its write replaces the link), and next to SYNABUN_TOOLS it decides nothing.
+  const keepProfile = (tableEnv[LEGACY_PROFILE_KEY] ?? inlineEnv[LEGACY_PROFILE_KEY]) === LEGACY_CODEX_PROFILE;
   const hadDeferredCatalog = (tableEnv[TOOL_CATALOG_MODE_KEY] || inlineEnv[TOOL_CATALOG_MODE_KEY]) === CODEX_TOOL_CATALOG_MODE;
   const mergedEnv = { ...inlineEnv, ...tableEnv };
-  mergedEnv[MANAGED_PROFILE_KEY] = CODEX_PROFILE;
-  mergedEnv[TOOL_CATALOG_MODE_KEY] = CODEX_TOOL_CATALOG_MODE;
+  const remove = hasProfile && !keepProfile ? [LEGACY_PROFILE_KEY] : [];
 
   if (hadInline) next = stripInlineEnv(next);
-  next = upsertEnvSection(next, mergedEnv);
+  next = upsertEnvSection(next, mergedEnv, { remove });
 
   if (next === content) return { content, reason: null };
   if (hadInline && hadTable) return { content: next, reason: 'removed_duplicate_inline_env' };
   if (hadInline) return { content: next, reason: 'normalized_inline_env' };
-  if (!hadCanonicalProfile) return { content: next, reason: 'set_full_profile' };
+  if (!configuredTools && hasProfile) return { content: next, reason: 'migrated_profile_key' };
+  if (!hadAllTools) return { content: next, reason: 'set_all_tools' };
+  if (remove.length) return { content: next, reason: 'removed_legacy_profile_key' };
   if (!hadDeferredCatalog) return { content: next, reason: 'enabled_deferred_catalog' };
   return { content: next, reason: null };
 }
 
+/**
+ * Register SynaBun with this definition. SYNABUN_PROFILE is never written from a definition; one already there is
+ * kept only as "full", like the heal keeps it.
+ */
 export function upsertCodexMcpContent(content: string, definition: CodexMcpDefinition): string {
   let next = repairCodexConfigContent(content).content;
   const newline = next.includes('\r\n') ? '\r\n' : '\n';
@@ -319,7 +355,10 @@ export function upsertCodexMcpContent(content: string, definition: CodexMcpDefin
   }
 
   const existingEnv = parseEnvTable(next);
-  next = upsertEnvSection(next, { ...existingEnv, ...definition.env });
+  const env: Record<string, string> = { ...existingEnv, ...definition.env };
+  delete env[LEGACY_PROFILE_KEY];
+  const remove = hasKey(existingEnv, LEGACY_PROFILE_KEY) && existingEnv[LEGACY_PROFILE_KEY] !== LEGACY_CODEX_PROFILE ? [LEGACY_PROFILE_KEY] : [];
+  next = upsertEnvSection(next, env, { remove });
   return next.endsWith(newline) ? next : `${next}${newline}`;
 }
 
@@ -331,16 +370,28 @@ export function removeCodexMcpContent(content: string): string {
   ]);
 }
 
+/**
+ * The file a path writes to. A Codex account's CODEX_HOME links config.toml to the canonical one: a write goes to
+ * the file the link names, so the link (and the sharing it gives every account) stays.
+ */
+function writeTarget(configPath: string): string {
+  try {
+    if (lstatSync(configPath).isSymbolicLink()) return realpathSync(configPath);
+  } catch { /* a new file, or a link to nothing: written in place */ }
+  return configPath;
+}
+
 function atomicWrite(configPath: string, content: string): void {
-  const mode = existsSync(configPath) ? statSync(configPath).mode : null;
-  const tmpPath = `${configPath}.synabun-${process.pid}.tmp`;
+  const target = writeTarget(configPath);
+  const mode = existsSync(target) ? statSync(target).mode : null;
+  const tmpPath = `${target}.synabun-${process.pid}.tmp`;
   writeFileSync(tmpPath, content, 'utf-8');
   if (mode !== null) chmodSync(tmpPath, mode);
   try {
-    renameSync(tmpPath, configPath);
+    renameSync(tmpPath, target);
   } catch (renameErr) {
-    try { copyFileSync(tmpPath, configPath); } catch { /* preserve original when possible */ }
-    if (existsSync(configPath) && readFileSync(configPath, 'utf-8') === content) {
+    try { copyFileSync(tmpPath, target); } catch { /* preserve original when possible */ }
+    if (existsSync(target) && readFileSync(target, 'utf-8') === content) {
       try { unlinkSync(tmpPath); } catch { /* best effort */ }
       return;
     }
@@ -377,8 +428,8 @@ export function healCodexConfig(configPath: string): HealResult {
   }
 
   try {
-    // Keep the exact original, including unrelated tables and its permissions.
-    const backup = `${configPath}.synabun-backup-${Date.now()}-${process.pid}`;
+    // Keep the exact original, including unrelated tables and its permissions, next to the file it came from.
+    const backup = `${writeTarget(configPath)}.synabun-backup-${Date.now()}-${process.pid}`;
     copyFileSync(configPath, backup);
     atomicWrite(configPath, repaired.content);
   } catch (err) {

package/mcp-server/src/services/identity.ts

@@ -192,7 +192,7 @@ export function runWithBrainCredential<T>(credential: string | null, fn: () => T
 /**
  * The WhatsApp brain credential of the current caller (whatsapp_send_file sends it on its one request
  * and nowhere else): the request's own header over HTTP (X-Synabun-Brain-Token, the Claude brain),
- * SYNABUN_BRAIN_TOKEN for stdio children (the Codex and OpenCode brains). Never the host process's
+ * SYNABUN_BRAIN_TOKEN for stdio children (the Codex, OpenCode and Antigravity brains). Never the host process's
  * env for an HTTP caller.
  */
 export function callerBrainCredential(): string | null {
@@ -203,7 +203,7 @@ export function callerBrainCredential(): string | null {
 /**
  * Role of the current caller: the ALS identity's role over HTTP (derived from
  * X-Synabun-Role on every request), or SYNABUN_ROLE for stdio children —
- * Codex/OpenCode assistant brains pass the role to their MCP child via env.
+ * Codex/OpenCode/Antigravity assistant brains pass the role to their MCP child via env.
  * In HTTP mode a missing ALS store is a propagation bug, so the host
  * process's own env must never grant a role to an unidentified caller.
  */

package/mcp-server/src/services/memory-judge-backfill.ts

@@ -303,13 +303,19 @@ let timer: ReturnType<typeof setInterval> | null = null;
 /** Forget in-memory pacing state (start/resume, and tests). Persisted counters are untouched. */
 export function resetJudgeBackfillRunner(): void { consecutiveFailures = 0; nextTickAt = 0; }
 
+/**
+ * Persist the counters gathered since the last flush. `force` flushes now instead of at the next due point; with
+ * nothing gathered nothing is written, forced or not: a server that stops (stopJudgeBackfill) commits nothing to
+ * memory.db then, so a pre-update snapshot taken before its stop still stands for the database
+ * (checkUpgradeSnapshotFreshness in neural-interface/lib/backup-service.js).
+ */
 function flushProgress(force = false): void {
   const due = force || jobsSinceFlush >= FLUSH_EVERY_JOBS || Date.now() - lastFlushAt >= FLUSH_EVERY_MS;
   if (!due) return;
   const pending = delta;
   const hasChanges = pending.judged || pending.skipped || pending.failures || pending.lastError;
   delta = emptyDelta(); jobsSinceFlush = 0; lastFlushAt = Date.now();
-  if (!hasChanges && !force) return;
+  if (!hasChanges) return;
   try {
     mutateTypeSafeConfig(current => {
       const b = current.backfill;

package/mcp-server/src/services/memory-sessions.ts

@@ -2,7 +2,7 @@ import { createHash } from 'node:crypto';
 import { getDb } from './sqlite.js';
 
 export interface MemoryEvent {
-  host: 'claude-code'|'codex'|'opencode'; session_id: string; source_id: string;
+  host: 'claude-code'|'codex'|'opencode'|'antigravity'; session_id: string; source_id: string;
   project: string; timestamp: string; role: 'user'|'assistant'|'tool'; text: string;
   cwd?: string; tools?: string[]; files?: string[];
 }
@@ -18,6 +18,15 @@ function visibleText(content: any): string {
 function clean(text: string) {
   return text.replace(/<(system-reminder|environment_context|permissions|INSTRUCTIONS)>[\s\S]*?<\/\1>/g,'').trim();
 }
+// SynaBun's greeting note in an Antigravity prompt (neural-interface/public/shared/agy/agy-greeting.js, same markers).
+const AGY_GREETING_NOTE = /\[SYNABUN_GREETING_START\][\s\S]*?\[SYNABUN_GREETING_END\][ \t]*(?:\r?\n)*/g;
+const AGY_META_BLOCKS = /<(ADDITIONAL_METADATA|USER_SETTINGS_CHANGE|EPHEMERAL_MESSAGE|SYSTEM_MESSAGE)>[\s\S]*?<\/\1>/g;
+/** What a person typed, out of Antigravity's USER_INPUT step (agy wraps it in <USER_REQUEST> with blocks of its own). */
+function antigravityUserWords(content: unknown) {
+  const text = String(content ?? '');
+  const request = /<USER_REQUEST>\r?\n?([\s\S]*?)\r?\n?<\/USER_REQUEST>/.exec(text);
+  return (request ? request[1] : text.replace(AGY_META_BLOCKS, '')).replace(AGY_GREETING_NOTE, '').trim();
+}
 /** Normalize only visible provider records, never reasoning or system text. */
 export function normalizeMemoryEvents(host: MemoryEvent['host'], records: any[], context: {session_id:string;project:string;cwd?:string}): MemoryEvent[] {
   const events: MemoryEvent[] = [];
@@ -25,6 +34,7 @@ export function normalizeMemoryEvents(host: MemoryEvent['host'], records: any[],
     let role: MemoryEvent['role']|undefined;
     let text = '';
     let tools: string[] = [];
+    let sourceId: string|undefined;
     if (host === 'claude-code') {
       if (record.isMeta || record.isSidechain) continue;
       if (record.type === 'user' && !record.toolUseResult && !record.sourceToolAssistantUUID) role='user';
@@ -38,6 +48,17 @@ export function normalizeMemoryEvents(host: MemoryEvent['host'], records: any[],
       if (p?.type === 'agentMessage') { role='assistant'; text=String(p.text || ''); }
       if (p?.type === 'commandExecution') { role='tool'; text=String(p.aggregatedOutput || ''); tools=['commandExecution']; }
       if (p?.type === 'function_call_output') {role='tool';text=String(p.output || '');}
+    } else if (host === 'antigravity') {
+      // agy's transcript.jsonl (brain/<id>/.system_generated/logs): one line per step, keyed by its index (a
+      // re-read of the file, from any offset, gives every step the same source id). The person's words and the
+      // model's answers only: never its `thinking`, agy's own system messages, or tool output.
+      if (Number.isInteger(record.step_index)) sourceId = `step:${record.step_index}`;
+      if (record.type === 'USER_INPUT' && record.source === 'USER_EXPLICIT') { role='user'; text=antigravityUserWords(record.content); }
+      if (record.type === 'PLANNER_RESPONSE' && record.source === 'MODEL') {
+        role='assistant';
+        text=typeof record.content === 'string' ? record.content : '';
+        tools=(Array.isArray(record.tool_calls) ? record.tool_calls : []).map((c:any)=>String(c?.name || '')).filter(Boolean);
+      }
     } else {
       const info = record.info || record;
       if (['user','assistant'].includes(info.role)) role=info.role;
@@ -46,8 +67,8 @@ export function normalizeMemoryEvents(host: MemoryEvent['host'], records: any[],
     }
     text=clean(text);
     if (!role || !text || text.startsWith('# AGENTS.md')) continue;
-    const timestamp = record.timestamp || record.info?.time?.created || record.createdAt;
-    events.push({...context,host,source_id:String(record.uuid || record.id || record.info?.id || `${index}`),role,text,tools,
+    const timestamp = record.timestamp || record.info?.time?.created || record.createdAt || record.created_at;
+    events.push({...context,host,source_id:sourceId ?? String(record.uuid || record.id || record.info?.id || `${index}`),role,text,tools,
       timestamp: timestamp && Number.isFinite(new Date(timestamp).getTime()) ? new Date(timestamp).toISOString() : '1970-01-01T00:00:00.000Z'});
   }
   return events;

package/mcp-server/src/services/neural-interface.ts

@@ -12,6 +12,7 @@ import {
   getIdentity,
   effectivePins,
   terminalIdFor,
+  callerBrainCredential,
   callerRole,
   setReleaseHook,
   peekStdioIdentity,
@@ -163,11 +164,18 @@ async function requestOnce(
     // orchestrator apart from a worker run (workers must never dispatch).
     const role = callerRole();
     if (role) headers['X-Synabun-Role'] = role;
+    // A brain whose pin no session resolves (the Codex brain's MCP child, codex-sp-<uuid>) is known to
+    // /api/assistant/* by its launch credential: the role header alone names nobody there. Sent with the
+    // assistant role on those routes only; a worker has no role and no credential (its environment is stripped).
+    if (role === 'assistant' && path.startsWith('/api/assistant/')) {
+      const credential = callerBrainCredential();
+      if (credential) headers['X-Synabun-Brain-Token'] = credential;
+    }
     headers['X-Synabun-Request-Id'] = requestId;
     headers['X-Synabun-Deadline'] = String(deadline);
     // Lets the server refuse advisory payloads and auto-heal for a batch step on its own authority.
     if (batchContext.getStore()) headers['X-Synabun-Batch'] = '1';
-    // One request's own headers (whatsappSendFile's brain credential): never sent on any other request.
+    // One request's own headers (whatsappSendFile's brain credential, the skills requests'): sent on that request only.
     for (const [name, value] of Object.entries(extraHeaders)) if (value) headers[name] = value;
     const opts: RequestInit = {
       method,
@@ -278,37 +286,74 @@ async function request(
 }
 
 /**
- * Best-effort reconciliation for an MCP process that changed its own tool
- * profile. Only sidepanel/automation children carry an explicit terminal id;
- * standalone CLI processes stay process-local without contacting Neural
- * Interface. The server derives the owning runtime from X-Synabun-Terminal.
+ * Best-effort reconciliation for an MCP runtime that changed its own tools
+ * (tool_groups). Only runtimes SynaBun launched carry a terminal pin (the
+ * stdio child's SYNABUN_TERMINAL_SESSION, an HTTP session's X-Synabun-Terminal);
+ * any other runtime stays local without contacting the Neural Interface, which
+ * derives the owning runtime from that pin and never from the body.
  */
-export type RuntimeMcpProfileReport = {
+export type RuntimeToolsReport = {
   reported: boolean;
   hostRefresh: 'scheduled' | 'notification' | 'not-needed' | 'unavailable';
-  runtimeKind?: 'opencode' | 'codex' | 'loop';
+  runtimeKind?: 'opencode' | 'codex' | 'loop' | 'channel';
   correlationId?: string;
+  /** The route that took it: runtime-profile is a Neural Interface from before tool lists. */
+  route?: 'runtime-tools' | 'runtime-profile';
   error?: string;
 };
 
-export async function reportRuntimeMcpProfile(
-  profile: string,
-  options: { catalogMode?: 'profiled' | 'deferred' } = {}
-): Promise<RuntimeMcpProfileReport> {
-  if (!String(process.env.SYNABUN_TERMINAL_SESSION || '').trim()) {
+const RUNTIME_REPORT_TIMEOUT = 2_000;
+
+/** One report: its status and its JSON body, or null for a body that is not JSON (a route the server does not have). */
+async function postRuntimeReport(path: string, body: Record<string, unknown>): Promise<{ status: number; json: NiResponse | null; error?: string }> {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), RUNTIME_REPORT_TIMEOUT);
+  try {
+    const headers: Record<string, string> = { 'Content-Type': 'application/json', 'X-Synabun-Terminal': terminalIdFor(getIdentity()) };
+    const role = callerRole();
+    if (role) headers['X-Synabun-Role'] = role;
+    const res = await fetch(`${BASE_URL}${path}`, { method: 'POST', headers, body: JSON.stringify(body), signal: controller.signal });
+    const text = await res.text();
+    let json: NiResponse | null = null;
+    try {
+      const parsed = JSON.parse(text);
+      json = parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed as NiResponse : null;
+    } catch { /* not JSON */ }
+    return { status: res.status, json };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { status: 0, json: null, error: controller.signal.aborted ? `Runtime tools report timed out after ${RUNTIME_REPORT_TIMEOUT}ms` : `Neural Interface unreachable: ${msg}` };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+export async function reportRuntimeTools(
+  groups: readonly string[],
+  options: { mode: 'strict' | 'focus'; legacyProfile: string; refresh?: 'in-band' },
+): Promise<RuntimeToolsReport> {
+  if (!effectivePins(getIdentity()).terminalSessionId) {
     return { reported: false, hostRefresh: 'notification' };
   }
-  const result = await request('POST', '/api/mcp/runtime-profile', {
-    profile,
-    catalogMode: options.catalogMode || 'profiled',
-  }, 2_000);
-  if (result.ok) {
+  let route: 'runtime-tools' | 'runtime-profile' = 'runtime-tools';
+  let answer = await postRuntimeReport('/api/mcp/runtime-tools', { tools: [...groups], mode: options.mode, ...(options.refresh ? { refresh: options.refresh } : {}) });
+  // A Neural Interface from before tool lists has no such route (its 404 is not JSON); its own route takes the
+  // old shape. Its runtime-profile 404 for a runtime that is gone is JSON, so it is never retried.
+  if (answer.status === 404 && !answer.json) {
+    route = 'runtime-profile';
+    answer = await postRuntimeReport('/api/mcp/runtime-profile', {
+      profile: options.legacyProfile,
+      catalogMode: options.mode === 'focus' ? 'deferred' : 'profiled',
+    });
+  }
+  const result = answer.json;
+  if (result?.ok && answer.status >= 200 && answer.status < 300) {
     const hostRefresh = result.hostRefresh === 'scheduled'
       || result.hostRefresh === 'notification'
       || result.hostRefresh === 'not-needed'
       ? result.hostRefresh
       : 'unavailable';
-    const runtimeKind = result.runtimeKind === 'opencode' || result.runtimeKind === 'codex' || result.runtimeKind === 'loop'
+    const runtimeKind = result.runtimeKind === 'opencode' || result.runtimeKind === 'codex' || result.runtimeKind === 'loop' || result.runtimeKind === 'channel'
       ? result.runtimeKind
       : undefined;
     return {
@@ -316,12 +361,14 @@ export async function reportRuntimeMcpProfile(
       hostRefresh,
       runtimeKind,
       correlationId: typeof result.correlationId === 'string' ? result.correlationId : undefined,
+      route,
     };
   }
   return {
     reported: false,
     hostRefresh: 'unavailable',
-    error: typeof result.error === 'string' ? result.error : 'Runtime profile report failed',
+    route,
+    error: typeof result?.error === 'string' ? result.error : (answer.error || `Runtime tools report failed (HTTP ${answer.status})`),
   };
 }
 
@@ -1342,12 +1389,25 @@ export async function moreloginUseDefault(envId: string | null): Promise<NiRespo
   return request('POST', '/api/morelogin/use-default', envId ? { envId } : { clear: true });
 }
 
+// ── Skills (the role-gated `skills` tool group) ──
+// One thin call over /api/skills-studio/v2 (neural-interface/lib/skills/api-v2.js, creation-api.js), which owns every
+// rule: an agent reads, drafts, checks and submits for review; installing and approving are the owner's, from the
+// app's own page, and the routes refuse them to a request that carries the agent headers requestOnce sends. The
+// caller's brain credential (identity.ts callerBrainCredential: its own request's over HTTP, SYNABUN_BRAIN_TOKEN for a
+// stdio child) rides along: the server knows the Assistant by it (AI drafting needs it), never by X-Synabun-Role.
+
+export async function skillsV2(method: 'GET' | 'POST' | 'PATCH', path: string, body?: Record<string, unknown>, timeout = LONG_TIMEOUT): Promise<NiResponse> {
+  const credential = callerBrainCredential();
+  return requestOnce(method, `/api/skills-studio/v2${path}`, body, timeout, credential ? { 'X-Synabun-Brain-Token': credential } : {});
+}
+
 // ── SynaBun assistant orchestration (role-gated `agents` tool group) ──
 // Thin proxies over /api/assistant/* (neural-interface/lib/assistant-api.js),
 // which owns dispatch state, rails and authorization. requestOnce already
 // sends X-Synabun-Terminal (the assistant pin) and X-Synabun-Role.
 
-export type AssistantProvider = 'claude-code' | 'codex' | 'opencode';
+/** A worker provider (each one can be the Assistant's brain too; 'antigravity' runs both over ACP). */
+export type AssistantProvider = 'claude-code' | 'codex' | 'opencode' | 'antigravity';
 
 export type AssistantDispatchBody = {
   /** Optional when routeId names an approved route (the server applies it). */
@@ -1357,7 +1417,7 @@ export type AssistantDispatchBody = {
   assistantSessionId: string;
   model?: string;
   effort?: string;
-  mcpProfile?: string;
+  tools?: string[];
   routeId?: string;
   taskClass?: string;
   confidence?: number;