amalgm 0.0.1 → 0.0.33

package/runtime/scripts/amalgm-mcp/toolbox/tools.js

@@ -0,0 +1,269 @@
+'use strict';
+
+const { textResult } = require('../lib/tool-result');
+const {
+  deleteTool,
+  deleteToolAction,
+  getTool,
+  getToolAction,
+  readToolbox,
+  updateTool,
+  updateToolAction,
+  upsertTool,
+  upsertToolAction,
+} = require('./store');
+
+function compactTool(tool, actionCount) {
+  return {
+    id: tool.id,
+    name: tool.name,
+    type: tool.type,
+    owner: tool.owner,
+    origin: tool.origin,
+    status: tool.status,
+    discovery: tool.discovery,
+    actionCount,
+    source: tool.source,
+    guide: tool.guide,
+    display: tool.display,
+    policy: tool.policy,
+  };
+}
+
+function listPayload(args = {}) {
+  const toolbox = readToolbox();
+  const actionsByTool = new Map();
+  for (const action of Object.values(toolbox.toolActions || {})) {
+    const existing = actionsByTool.get(action.toolId) || [];
+    existing.push(action);
+    actionsByTool.set(action.toolId, existing);
+  }
+
+  const tools = Object.values(toolbox.tools || {})
+    .filter((tool) => !args.type || tool.type === args.type)
+    .filter((tool) => !args.owner || tool.owner === args.owner)
+    .filter((tool) => !args.origin || tool.origin === args.origin)
+    .map((tool) => compactTool(tool, actionsByTool.get(tool.id)?.length || 0));
+
+  const payload = {
+    version: toolbox.version,
+    tools,
+    ...(args.include_actions
+      ? { toolActions: toolbox.toolActions }
+      : {}),
+  };
+  return payload;
+}
+
+module.exports = [
+  {
+    name: 'toolbox_tools_list',
+    description: 'List registered Amalgm Toolbox connectors/tools. Use this to see persistent user tools available across sessions.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        type: { type: 'string', enum: ['mcp', 'api', 'cli'], description: 'Optional tool type filter.' },
+        owner: { type: 'string', description: 'Optional owner filter, e.g. amalgm, claude, cursor, codex, or an agent harness id.' },
+        origin: { type: 'string', enum: ['system', 'user', 'catalog'], description: 'Optional origin filter.' },
+        include_actions: { type: 'boolean', description: 'Include full tool action records. Defaults false.' },
+      },
+    },
+    async handler(args) {
+      return textResult(JSON.stringify(listPayload(args || {}), null, 2));
+    },
+  },
+  {
+    name: 'toolbox_tool_get',
+    description: 'Read one registered Toolbox connector/tool by id, optionally including its actions.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'string', description: 'Tool id to read.' },
+        include_actions: { type: 'boolean', description: 'Include actions for this tool. Defaults true.' },
+      },
+      required: ['id'],
+    },
+    async handler(args) {
+      const payload = getTool(args?.id, { includeActions: args?.include_actions !== false });
+      return textResult(JSON.stringify(payload, null, 2));
+    },
+  },
+  {
+    name: 'toolbox_tool_register',
+    description: [
+      'Register or update a persistent Toolbox connector/tool. This is how agents save custom tools for future sessions.',
+      'For CLI tools, provide type="cli" and source.command. A default <tool>.run action is created automatically unless actions are provided.',
+      'Optional skillPath/guidePath attaches usage instructions to the tool without becoming a separate callable action.',
+    ].join('\n'),
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'string', description: 'Stable tool id, e.g. acme.executor.' },
+        name: { type: 'string', description: 'Human-readable connector/tool name.' },
+        type: { type: 'string', enum: ['mcp', 'api', 'cli'] },
+        owner: { type: 'string', description: 'Tool owner. Defaults to amalgm. Use a harness or agent id for externally owned tools.' },
+        origin: { type: 'string', enum: ['user', 'catalog'], description: 'Defaults to user.' },
+        status: { type: 'string', enum: ['enabled', 'disabled', 'error'] },
+        source: {
+          type: 'object',
+          description: 'Type-specific source config. CLI: {command,args,cwd,inputMode,outputMode}. MCP: {transport,url|command}. API: {baseUrl,specUrl,specPath,endpoints}.',
+          additionalProperties: true,
+        },
+        command: { type: 'string', description: 'CLI shortcut for source.command.' },
+        args: { type: 'array', items: { type: 'string' }, description: 'CLI/MCP stdio args shortcut.' },
+        cwd: { type: 'string', description: 'Working directory shortcut.' },
+        inputMode: { type: 'string', enum: ['json-stdin', 'argv', 'terminal', 'none'] },
+        outputMode: { type: 'string', enum: ['json', 'text'] },
+        skillPath: { type: 'string', description: 'Optional local SKILL.md path with usage guidance.' },
+        guidePath: { type: 'string', description: 'Optional local guide path with usage guidance.' },
+        display: { type: 'object', additionalProperties: true },
+        policy: { type: 'object', additionalProperties: true },
+        actions: {
+          type: 'array',
+          description: 'Optional static action records to create/update with the tool.',
+          items: { type: 'object', additionalProperties: true },
+        },
+      },
+      required: ['id', 'name', 'type'],
+    },
+    async handler(args) {
+      const saved = upsertTool(args || {});
+      return textResult(JSON.stringify({ ok: true, ...saved }, null, 2));
+    },
+  },
+  {
+    name: 'toolbox_tool_update',
+    description: [
+      'Partially update an existing Toolbox connector/tool without replacing unspecified fields.',
+      'Use this for modifications like status, display metadata, policy, guide/skill path, owner, or source patches.',
+      'System tools cannot be modified.',
+    ].join('\n'),
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'string', description: 'Tool id to update.' },
+        name: { type: 'string', description: 'Optional new human-readable name.' },
+        type: { type: 'string', enum: ['mcp', 'api', 'cli'], description: 'Optional type update.' },
+        owner: { type: 'string', description: 'Optional owner update.' },
+        origin: { type: 'string', enum: ['user', 'catalog'], description: 'Optional origin update.' },
+        status: { type: 'string', enum: ['enabled', 'disabled', 'error'] },
+        source: {
+          type: 'object',
+          description: 'Partial source patch. CLI: {command,args,cwd,inputMode,outputMode}. MCP: {transport,url|command}. API: {baseUrl,specUrl,specPath,endpoints}.',
+          additionalProperties: true,
+        },
+        command: { type: 'string', description: 'CLI shortcut for source.command.' },
+        args: { type: 'array', items: { type: 'string' }, description: 'CLI/MCP stdio args shortcut.' },
+        cwd: { type: 'string', description: 'Working directory shortcut.' },
+        inputMode: { type: 'string', enum: ['json-stdin', 'argv', 'terminal', 'none'] },
+        outputMode: { type: 'string', enum: ['json', 'text'] },
+        discovery: { type: 'object', additionalProperties: true },
+        skillPath: { type: 'string', description: 'Optional local SKILL.md path with usage guidance.' },
+        guidePath: { type: 'string', description: 'Optional local guide path with usage guidance.' },
+        guide: { type: 'object', additionalProperties: true },
+        display: { type: 'object', additionalProperties: true },
+        policy: { type: 'object', additionalProperties: true },
+      },
+      required: ['id'],
+    },
+    async handler(args) {
+      const saved = updateTool(args || {});
+      return textResult(JSON.stringify({ ok: true, ...saved }, null, 2));
+    },
+  },
+  {
+    name: 'toolbox_action_get',
+    description: 'Read one registered Toolbox action by id.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'string', description: 'Tool action id to read.' },
+      },
+      required: ['id'],
+    },
+    async handler(args) {
+      const payload = getToolAction(args?.id);
+      return textResult(JSON.stringify(payload, null, 2));
+    },
+  },
+  {
+    name: 'toolbox_action_register',
+    description: 'Register or update a persistent action under an existing Toolbox tool. Use this for richer CLI/API schemas beyond the default run action.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'string', description: 'Stable action id, e.g. acme.executor.run_job.' },
+        toolId: { type: 'string', description: 'Parent tool id.' },
+        name: { type: 'string', description: 'Action name, e.g. run_job.' },
+        displayName: { type: 'string' },
+        description: { type: 'string' },
+        inputSchema: { type: 'object', additionalProperties: true },
+        outputSchema: { type: 'object', additionalProperties: true },
+        status: { type: 'string', enum: ['enabled', 'disabled', 'error'] },
+        sourceAction: { type: 'object', additionalProperties: true },
+        skillPath: { type: 'string', description: 'Optional local SKILL.md path with usage guidance.' },
+        guidePath: { type: 'string', description: 'Optional local guide path with usage guidance.' },
+        policy: { type: 'object', additionalProperties: true },
+      },
+      required: ['toolId', 'name'],
+    },
+    async handler(args) {
+      const action = upsertToolAction(args || {});
+      return textResult(JSON.stringify({ ok: true, action }, null, 2));
+    },
+  },
+  {
+    name: 'toolbox_action_update',
+    description: 'Partially update an existing Toolbox action without replacing unspecified fields. System tool actions cannot be modified.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'string', description: 'Tool action id to update.' },
+        name: { type: 'string', description: 'Optional action name update.' },
+        displayName: { type: 'string' },
+        description: { type: 'string' },
+        inputSchema: { type: 'object', additionalProperties: true },
+        outputSchema: { type: 'object', additionalProperties: true },
+        status: { type: 'string', enum: ['enabled', 'disabled', 'error'] },
+        sourceAction: { type: 'object', additionalProperties: true },
+        skillPath: { type: 'string', description: 'Optional local SKILL.md path with usage guidance.' },
+        guidePath: { type: 'string', description: 'Optional local guide path with usage guidance.' },
+        guide: { type: 'object', additionalProperties: true },
+        policy: { type: 'object', additionalProperties: true },
+      },
+      required: ['id'],
+    },
+    async handler(args) {
+      const action = updateToolAction(args || {});
+      return textResult(JSON.stringify({ ok: true, action }, null, 2));
+    },
+  },
+  {
+    name: 'toolbox_tool_delete',
+    description: 'Delete a user/catalog Toolbox tool and its actions. System tools cannot be deleted.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'string', description: 'Tool id to delete.' },
+      },
+      required: ['id'],
+    },
+    async handler(args) {
+      return textResult(JSON.stringify(deleteTool(args?.id), null, 2));
+    },
+  },
+  {
+    name: 'toolbox_action_delete',
+    description: 'Delete a user/catalog Toolbox action. System tool actions cannot be deleted.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'string', description: 'Tool action id to delete.' },
+      },
+      required: ['id'],
+    },
+    async handler(args) {
+      return textResult(JSON.stringify(deleteToolAction(args?.id), null, 2));
+    },
+  },
+];

package/runtime/scripts/amalgm-mcp/workspace/rest.js

@@ -7,12 +7,55 @@ const fs = require('fs');
 const path = require('path');
 const { execFile } = require('child_process');
 const { promisify } = require('util');
-const { DEFAULT_CWD } = require('../config');
+const { AMALGM_DIR, DEFAULT_CWD } = require('../config');
 
 const execFileAsync = promisify(execFile);
 const MAX_BUFFER = 10 * 1024 * 1024;
 const WORKTREE_SUFFIX_RE = /-amalgm-wt-[a-z0-9]+$/;
 
+function isWithin(root, target) {
+  const relative = path.relative(root, target);
+  return relative === '' || (!!relative && !relative.startsWith('..') && !path.isAbsolute(relative));
+}
+
+function sanitizeProjectName(value) {
+  const fallback = 'project';
+  return String(value || fallback)
+    .trim()
+    .replace(/[\/\\:\0]/g, '-')
+    .replace(/^\.+$/, fallback)
+    .replace(/^\.+/, '')
+    .slice(0, 120) || fallback;
+}
+
+function getWorkspaceRoot() {
+  if (process.env.AMALGM_WORKSPACES_DIR) return path.resolve(process.env.AMALGM_WORKSPACES_DIR);
+  if (process.env.AMALGM_PROJECTS_DIR) return path.resolve(process.env.AMALGM_PROJECTS_DIR);
+  if (process.env.AMALGM_LOCAL_MODE === 'true') return path.join(AMALGM_DIR, 'workspaces');
+  return path.join(DEFAULT_CWD, 'workspaces');
+}
+
+async function ensureWorkspaceRoot() {
+  const workspaceRoot = getWorkspaceRoot();
+  await fs.promises.mkdir(workspaceRoot, { recursive: true });
+  return workspaceRoot;
+}
+
+async function uniqueProjectPath(workspaceRoot, requestedName) {
+  const name = sanitizeProjectName(requestedName);
+  let candidate = path.join(workspaceRoot, name);
+  let suffix = 2;
+  while (true) {
+    try {
+      await fs.promises.access(candidate);
+      candidate = path.join(workspaceRoot, `${name}-${suffix}`);
+      suffix += 1;
+    } catch {
+      return candidate;
+    }
+  }
+}
+
 function isValidWorkspacePath(workspacePath) {
   return typeof workspacePath === 'string' && workspacePath.length > 0 && path.isAbsolute(workspacePath);
 }
@@ -94,7 +137,7 @@ function getLocalWorktreePath(workspacePath, shortId) {
 
 async function handleProjects(sendJson) {
   try {
-    const rootDir = DEFAULT_CWD;
+    const rootDir = await ensureWorkspaceRoot();
     const dirents = await fs.promises.readdir(rootDir, { withFileTypes: true }).catch(() => []);
     const projects = [];
 
@@ -112,10 +155,73 @@ async function handleProjects(sendJson) {
     }
 
     projects.sort((a, b) => a.name.localeCompare(b.name));
-    sendJson(200, { projects });
+    sendJson(200, { projects, workspaceRoot: rootDir });
+  } catch (error) {
+    sendJson(500, {
+      error: error instanceof Error ? error.message : 'Failed to list workspaces',
+    });
+  }
+}
+
+async function handleImport(body, sendJson) {
+  const sourcePath = body?.source_path;
+  const projectName = body?.project_name;
+
+  if (!sourcePath || typeof sourcePath !== 'string') {
+    sendJson(400, { error: 'source_path is required' });
+    return;
+  }
+
+  if (!path.isAbsolute(sourcePath)) {
+    sendJson(400, { error: 'source_path must be absolute' });
+    return;
+  }
+
+  try {
+    const sourceStats = await fs.promises.stat(sourcePath);
+    if (!sourceStats.isDirectory()) {
+      sendJson(400, { error: 'source_path must be a folder' });
+      return;
+    }
+
+    const workspaceRoot = await ensureWorkspaceRoot();
+    const [realSource, realWorkspaceRoot] = await Promise.all([
+      fs.promises.realpath(sourcePath),
+      fs.promises.realpath(workspaceRoot),
+    ]);
+
+    if (isWithin(realWorkspaceRoot, realSource)) {
+      sendJson(200, {
+        success: true,
+        path: realSource,
+        name: path.basename(realSource),
+        workspaceRoot,
+        alreadyInWorkspace: true,
+      });
+      return;
+    }
+
+    const targetPath = await uniqueProjectPath(
+      workspaceRoot,
+      projectName || path.basename(realSource),
+    );
+    await fs.promises.cp(realSource, targetPath, {
+      recursive: true,
+      force: false,
+      errorOnExist: true,
+      dereference: false,
+    });
+
+    sendJson(200, {
+      success: true,
+      path: targetPath,
+      name: path.basename(targetPath),
+      workspaceRoot,
+      alreadyInWorkspace: false,
+    });
   } catch (error) {
     sendJson(500, {
-      error: error instanceof Error ? error.message : 'Failed to list projects',
+      error: error instanceof Error ? error.message : 'Failed to import project',
     });
   }
 }
@@ -135,12 +241,13 @@ async function handleClone(body, sendJson) {
     return;
   }
 
-  const targetPath = path.join(DEFAULT_CWD, repoName);
+  const workspaceRoot = await ensureWorkspaceRoot();
+  const targetPath = path.join(workspaceRoot, sanitizeProjectName(repoName));
 
   try {
     await fs.promises.access(targetPath);
     if (await isGitRepo(targetPath)) {
-      sendJson(200, { success: true, path: targetPath, alreadyExists: true });
+      sendJson(200, { success: true, path: targetPath, workspaceRoot, alreadyExists: true });
       return;
     }
     sendJson(409, {
@@ -158,7 +265,7 @@ async function handleClone(body, sendJson) {
   }
   cloneArgs.push('clone', cloneUrl, targetPath);
 
-  const cloneResult = await runGit(cloneArgs, DEFAULT_CWD);
+  const cloneResult = await runGit(cloneArgs, workspaceRoot);
   if (cloneResult.exitCode !== 0) {
     sendJson(500, {
       error: cloneResult.stderr.trim() || cloneResult.stdout.trim() || 'Clone failed',
@@ -166,7 +273,7 @@ async function handleClone(body, sendJson) {
     return;
   }
 
-  sendJson(200, { success: true, path: targetPath, alreadyExists: false });
+  sendJson(200, { success: true, path: targetPath, workspaceRoot, alreadyExists: false });
 }
 
 async function handleBranches(query, sendJson) {
@@ -379,6 +486,7 @@ async function handleWorktreeDelete(body, sendJson) {
 
 module.exports = {
   handleProjects,
+  handleImport,
   handleClone,
   handleBranches,
   handleCheckout,

package/runtime/scripts/chat-core/adapters/claude.js

@@ -36,6 +36,8 @@ class ClaudeAdapter {
       cwd: contract.cwd,
       env: runtimeEnv(contract),
       model: contract.cliModel,
+      ...(contract.reasoningEffort ? { effort: contract.reasoningEffort } : {}),
+      ...(contract.fastMode ? { settings: { fastMode: true, fastModePerSessionOptIn: true } } : {}),
       ...(pathToClaudeCodeExecutable ? { pathToClaudeCodeExecutable } : {}),
       ...(systemPrompt ? { systemPrompt: { type: 'preset', preset: 'claude_code', append: systemPrompt } } : {}),
       mcpServers: toClaudeMcpServers(contract),

package/runtime/scripts/chat-core/contract.js

@@ -266,6 +266,7 @@ function createContract(payload, options = {}) {
   const authMethod = coerceAuth(harness, payload.authMethod || 'amalgm');
   const modelId = canonicalModel(payload.modelId || payload.cliModel, harness);
   const reasoningEffort = payload.reasoningEffort || null;
+  const fastMode = payload.fastMode === true;
   const cliModel = cliModelFor({ harness, modelId, cliModel: payload.cliModel, reasoningEffort });
   const cwd = resolveCwd(payload.cwd, options);
   const localBaseUrl = options.localBaseUrl || `http://127.0.0.1:${options.port || process.env.CHAT_SERVER_PORT || 8084}`;
@@ -294,6 +295,7 @@ function createContract(payload, options = {}) {
     providerSessionId: nullableString(payload.providerSessionId || payload.provider_session_id),
     cliModel,
     reasoningEffort,
+    fastMode,
     contextWindow: positiveOrNull(payload.contextWindow),
     maxTokens: positiveOrNull(payload.maxTokens),
     cwd,

package/runtime/scripts/chat-core/engine.js

@@ -7,9 +7,39 @@ const { normalizeInput } = require('./input');
 const { frameFor, titleFrame } = require('./sse');
 const { beginProxyTurn, logTurnUsage } = require('./usage');
 
-function assertDbSaved(result, label) {
+function warnIfDbNotSaved(result, label) {
   if (result === false || result === null) {
-    throw new Error(`${label} was not saved; keeping temp/raw stream for reconnect`);
+    console.warn(`[ChatCore] ${label} was not saved; continuing turn with temp/raw stream for reconnect`);
+    return false;
+  }
+  return true;
+}
+
+async function bestEffortDbSave(label, fn) {
+  try {
+    return warnIfDbNotSaved(await fn(), label);
+  } catch (err) {
+    console.warn(`[ChatCore] ${label} save failed: ${err.message}; continuing turn with temp/raw stream for reconnect`);
+    return false;
+  }
+}
+
+async function withDeadline(label, promise, ms) {
+  if (!ms || ms <= 0) return promise;
+  let timeout = null;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise((resolve) => {
+        timeout = setTimeout(() => {
+          console.warn(`[ChatCore] ${label} timed out after ${ms}ms; continuing without it`);
+          resolve(null);
+        }, ms);
+        timeout.unref?.();
+      }),
+    ]);
+  } finally {
+    if (timeout) clearTimeout(timeout);
   }
 }
 
@@ -20,6 +50,7 @@ class ChatCore {
     this.turns = turns;
     this.options = options;
     this.beginTurn = options.beginTurn || beginProxyTurn;
+    this.historyLoadTimeoutMs = Number(options.historyLoadTimeoutMs ?? process.env.AMALGM_HISTORY_LOAD_TIMEOUT_MS ?? 750);
     this.contracts = new Map();
   }
 
@@ -70,10 +101,14 @@ class ChatCore {
       assistantMessageId: contract.assistantMessageId,
       modelId: contract.usageModelId || contract.modelId,
     };
-    assertDbSaved(await this.db.saveUserMessage(msgConfig), 'User message');
+    const userMessageSave = bestEffortDbSave('User message', () => this.db.saveUserMessage(msgConfig));
     if (isReturningToSession && !runtimeWasWarm && !contract.providerSessionId && typeof this.db.loadConversationHistory === 'function') {
       try {
-        const history = await this.db.loadConversationHistory(contract.sessionId, contract.userMessageId);
+        const history = await withDeadline(
+          'Cold-resume history load',
+          this.db.loadConversationHistory(contract.sessionId, contract.userMessageId),
+          this.historyLoadTimeoutMs,
+        );
         if (history) {
           const text = `${history}${input.text || ''}`.trim();
           runtimeInput = {
@@ -86,8 +121,11 @@ class ChatCore {
         console.warn('[ChatCore] Failed to load cold-resume conversation history:', err.message);
       }
     }
-    assertDbSaved(await this.db.ensureAssistantMessage(msgConfig), 'Assistant placeholder');
-    await this.db.mergeSessionMetadata(contract.sessionId, {
+    const assistantPlaceholderSave = bestEffortDbSave(
+      'Assistant placeholder',
+      () => this.db.ensureAssistantMessage(msgConfig),
+    );
+    this.db.mergeSessionMetadata(contract.sessionId, {
       contract: {
         userId: contract.userId,
         computerId: contract.computerId,
@@ -121,6 +159,11 @@ class ChatCore {
       assistantMessageId: contract.assistantMessageId,
       userMessageId: contract.userMessageId,
     });
+    entry.persistence = {
+      userMessageSaved: null,
+      assistantPlaceholderSaved: null,
+      assistantMessageSaved: null,
+    };
 
     if (typeof this.db.generateAndSaveTitle === 'function' && input.text) {
       this.db.generateAndSaveTitle(contract.sessionId, input.text, (title) => {
@@ -173,20 +216,35 @@ class ChatCore {
 
     const savedParts = parts.finalize();
     this.turns.setParts(turnId, savedParts);
-    try {
-      assertDbSaved(await this.db.saveAssistantMessage(msgConfig, savedParts, providerSessionId, usage), 'Assistant message');
-    } catch (saveErr) {
+    this.turns.mark(turnId, 'persisting');
+    const finalizePersistence = async () => {
+      const [userMessageSaved, assistantPlaceholderSaved, assistantMessageSaved] = await Promise.all([
+        userMessageSave,
+        assistantPlaceholderSave,
+        bestEffortDbSave('Assistant message', () => this.db.saveAssistantMessage(msgConfig, savedParts, providerSessionId, usage)),
+      ]);
+      if (entry.persistence) {
+        entry.persistence.userMessageSaved = userMessageSaved;
+        entry.persistence.assistantPlaceholderSaved = assistantPlaceholderSaved;
+        entry.persistence.assistantMessageSaved = assistantMessageSaved;
+      }
+      await logTurnUsage({
+        db: this.db,
+        contract,
+        messageId: contract.assistantMessageId,
+        usage,
+        usageRecords,
+      });
+      if (!assistantMessageSaved || !userMessageSaved || !assistantPlaceholderSaved) {
+        this.turns.mark(turnId, 'save_failed');
+      } else {
+        this.turns.mark(turnId, stopReason === 'error' ? 'error' : stopReason === 'cancelled' ? 'cancelled' : 'complete');
+        this.turns.clear(turnId);
+      }
+    };
+    finalizePersistence().catch((err) => {
+      console.warn('[ChatCore] Persistence finalization failed:', err.message);
       this.turns.mark(turnId, 'save_failed');
-      throw saveErr;
-    }
-    this.turns.mark(turnId, stopReason === 'error' ? 'error' : stopReason === 'cancelled' ? 'cancelled' : 'complete');
-    this.turns.clear(turnId);
-    await logTurnUsage({
-      db: this.db,
-      contract,
-      messageId: contract.assistantMessageId,
-      usage,
-      usageRecords,
     });
     return { providerSessionId, usage, parts: savedParts, stopReason };
   }

package/runtime/scripts/credential-adapter.js

@@ -13,12 +13,13 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 
-const VALID_HARNESS_IDS = ['claude_code', 'codex', 'opencode'];
+const VALID_HARNESS_IDS = ['claude_code', 'codex', 'opencode', 'pi'];
 const VALID_AUTH_MODES = ['amalgm', 'provider_auth', 'byok'];
 const SUPPORTED_AUTH_BY_HARNESS = {
   claude_code: ['amalgm', 'byok', 'provider_auth'],
   codex: ['amalgm', 'byok', 'provider_auth'],
-  opencode: ['amalgm'],
+  opencode: ['amalgm', 'byok'],
+  pi: ['amalgm', 'byok', 'provider_auth'],
 };
 
 const AMALGM_DIR = process.env.AMALGM_DIR || path.join(os.homedir(), '.amalgm');
@@ -30,6 +31,7 @@ function defaultAuthModes() {
     claude_code: 'amalgm',
     codex: 'amalgm',
     opencode: 'amalgm',
+    pi: 'amalgm',
   };
 }
 

package/runtime/scripts/local-gateway.js

@@ -106,6 +106,8 @@ const MCP_PREFIXES = [
   '/github',
   '/fs',
   '/mcp-connections',
+  '/toolbox',
+  '/state',
   '/local',
   '/credentials',
   '/email',