@amalgm/tools 0.1.4 → 0.1.5

package/PURPOSE.md

@@ -23,14 +23,9 @@ registry or execution implementation.
 - An **action** is one model-callable capability owned by exactly one tool.
 - A **Toolbox** is the sole catalog and mutation authority for one local state
   directory.
-- A **tool deployment** is one immutable definition of a stable tool identity,
-  including its complete authoritative action set; activation appends the
-  deployment and moves that tool's current pointer atomically.
 - A **loadout** is a set of tool or action ids used to derive a read-only view
   of the Toolbox.
 - A **driver** executes actions for one tool type.
-- An **MCP server** is a separately identified runtime endpoint that may expose
-  one or more tools; selecting a tool never changes that server's identity.
 - A **system tool** is an embedder-owned definition projected into the catalog;
   it is not user state.
 - A **notification** is one request to inform the current user; a channel
@@ -38,18 +33,20 @@ registry or execution implementation.
 
 ## Axioms
 
+Managed releases bind to one exact published Core version and build from the
+locked dependency graph on the supported Node toolchain.
+
 1. Every action belongs to exactly one tool and has the canonical id
    `<tool-id>.<action-name>`.
 2. Tool ids are stable, globally unique within one Toolbox, and never change
    as a side effect of renaming display text.
-3. A tool's portable source of truth is its immutable deployment history and
-   current deployment pointer. SQLite tables, WAL files, catalog indexes, and
-   compatibility artifacts are local projections; SDK, CLI, MCP, HTTP, and UI
-   adapters never keep parallel registries.
-4. Applying a semantically changed tool definition mints one deployment and
-   atomically activates its complete action set. Applying equal semantics is a
-   no-op; rollback and deletion mint new deployments rather than rewriting or
-   removing history.
+3. A tool's portable definition is its artifact file: one file per tool,
+   the tool and all of its actions together, never a second tool in the
+   same file. The Toolbox database is a derived index maintained for
+   runtime and realtime sync; SDK, CLI, and MCP adapters never keep
+   parallel registries.
+4. Applying a tool definition is atomic and authoritative for that tool: its
+   supplied action set replaces the previous set completely.
 5. Deleting a tool deletes all of its actions in the same transaction; an
    orphan action can never be observed.
 6. Disabled tools expose and execute no actions. Disabled actions are likewise
@@ -87,34 +84,11 @@ registry or execution implementation.
 20. Notification channels are host capabilities. Tools owns validation and
     result semantics; an injected channel adapter owns formatting, recipient
     lookup, credentials, and delivery.
-21. Reopening a Toolbox preserves the temporal fields of every semantically
-    unchanged system projection already present in its portable index; boot
-    never rewrites tracked bytes merely to stamp the current machine's time.
-22. The Toolbox exposes the versioned `deployment.activate` operation and its
-    exact definition through one Live surface; SQLite pages are never part of
-    that contract. A received activation materializes locally without echo,
-    retries are idempotent, and an existing deployment id can never acquire
-    different bytes.
-23. A host may separate the synced deployment directory from its machine-local
-    database. Amalgm Shell stores immutable deployment documents beneath
-    `users/<email>/toolbox/<tool-id>/deployments/` while keeping SQLite
-    coordination state below the machine boundary.
-24. A Chat preparation selects one catalog `revisionId` derived from exact
-    current deployment ids and system projections. Preparation either resolves
-    that exact revision or fails; it never silently substitutes newer tools.
-25. A host MCP source names both its server and its route. Tool identity,
-    action identity, server identity, and transport location are distinct even
-    when a first-party release currently maps them one-to-one.
-26. A scoped Toolbox MCP server advertises and calls only the selected loadout;
-    management actions are included only when the composing host asks for them.
 
 ## Predictable behavior
 
-Applying the same definition twice produces the same catalog and no second
-deployment. Reopening the
-same system projection produces the same portable index bytes on every
-machine. Applying a changed action set replaces the old set atomically.
-Selecting a whole tool
+Applying the same definition twice produces the same catalog. Applying a
+changed action set replaces the old set atomically. Selecting a whole tool
 grants all of its enabled actions; selecting one action grants only that
 action. Disabling or deleting a tool immediately removes all of its actions
 from list and call surfaces. CLI arguments are passed directly to a process,

package/README.md

@@ -36,28 +36,6 @@ verbatim when set, then `AMALGM_DIR/toolbox`, then the scoped layout
 `~/.amalgm/users/<scope>/toolbox`. Passing `stateDir` or `databaseFile`
 bypasses resolution entirely.
 
-Platform hosts should separate portable deployment documents from local
-coordination state:
-
-```js
-const toolbox = new Toolbox({
-  deploymentDir: '/amalgm/users/person@example.com/toolbox',
-  databaseFile: '/machine-state/services/tools/tools.db',
-});
-```
-
-An intentional semantic change appends
-`<deploymentDir>/<tool-id>/deployments/<deployment-id>.json` and atomically
-advances the local head. The database, WAL, `toolbox.index.json`, and legacy
-flat artifacts are projections and must not be synchronized. `catalog()`
-exposes both a local numeric `revision` for presentation freshness and the
-immutable `revisionId` that Chat must use for preparation.
-
-`deploymentSurface()` implements the `amalgm.tools.deployments@1` Live
-surface. Its operation is the shared `deployment.activate` envelope. Remote
-application is idempotent and does not echo; `deploymentSnapshot()` and
-`applyDeploymentSnapshot()` are the hydration/recovery boundary.
-
 ## CLI
 
 ```sh

package/dist/artifact-files.d.ts

@@ -1,4 +1,3 @@
-import type { ToolboxIndexDocument } from './artifacts.js';
 import type { ActionRecord, Catalog, ToolRecord } from './types.js';
 declare class ArtifactFiles {
     private readonly directory;
@@ -10,10 +9,9 @@ declare class ArtifactFiles {
     }): string;
     removeTool(toolId: string): void;
     writeIndex(catalog: Catalog): void;
-    readIndex(): ToolboxIndexDocument | null;
     /** Give every persisted user tool its portable artifact and refresh the
      * index. Additive only: a file for a tool this catalog does not know is
-     * never deleted here — removal or snapshot hydration is explicit. */
+     * never deleted here — removal is an explicit mutation. */
     materialize(catalog: Catalog): void;
     /** Execute the legacy `toolbox.json` migration plan: per-tool artifacts
      * first, then the index, and only then the rename that retires the

package/dist/artifact-files.js

@@ -2,9 +2,8 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { LEGACY_TOOLBOX_FILE_NAME, TOOLBOX_INDEX_FILE_NAME, artifactDocument, catalogIndexDocument, isToolArtifactDocument, legacyMigrationPlan, safeToolId, userArtifactFileName, } from './artifacts.js';
 /**
- * The host adapter for current compatibility projections: it executes the
- * pure documents and plans from `artifacts.ts` against one local state
- * directory. Writes are atomic
+ * The host adapter for tool artifacts: it executes the pure documents and
+ * plans from `artifacts.ts` against one state directory. Writes are atomic
  * (tmp file + rename) and skipped when the bytes are unchanged, matching
  * Engine `lib/storage.js`.
  *
@@ -52,16 +51,9 @@ class ArtifactFiles {
     writeIndex(catalog) {
         writeJsonIfChanged(this.file(TOOLBOX_INDEX_FILE_NAME), catalogIndexDocument(catalog));
     }
-    readIndex() {
-        const value = readJson(this.file(TOOLBOX_INDEX_FILE_NAME));
-        if (!value || value.version !== 1 || !value.tools || typeof value.tools !== 'object'
-            || !value.toolActions || typeof value.toolActions !== 'object')
-            return null;
-        return value;
-    }
     /** Give every persisted user tool its portable artifact and refresh the
      * index. Additive only: a file for a tool this catalog does not know is
-     * never deleted here — removal or snapshot hydration is explicit. */
+     * never deleted here — removal is an explicit mutation. */
     materialize(catalog) {
         for (const tool of catalog.tools) {
             if (tool.origin === 'system')

package/dist/artifacts.d.ts

@@ -2,11 +2,11 @@ import type { ActionRecord, Catalog, ToolRecord } from './types.js';
 /**
  * Tool artifact format laws — the portable representation of a tool.
  *
- * One compatibility artifact projects one current tool and every action it
- * owns together; a file never carries a second tool. Immutable deployment
- * documents are the portable source of truth. These artifacts, the Toolbox
- * database, and `toolbox.index.json` are derived views retained for current
- * Engine/UI readers.
+ * One tool is one artifact file: the tool definition and every action it
+ * owns travel together, and a file never carries a second tool. Artifact
+ * files are the portable definition; the Toolbox database and
+ * `toolbox.index.json` are derived caches. The format is ported byte-exact
+ * from Engine `runtime/scripts/amalgm-mcp/toolbox/artifacts.js`.
  *
  * Pure laws only: nothing here touches the filesystem. `artifact-files.ts`
  * is the host adapter that executes these documents and plans.
@@ -57,12 +57,10 @@ declare function artifactDocument(input: {
 declare function isToolArtifactDocument(value: unknown): value is ToolArtifactDocument;
 declare function toolboxIndexDocument(tools: Record<string, unknown>, toolActions: Record<string, unknown>): ToolboxIndexDocument;
 declare function catalogIndexDocument(catalog: Pick<Catalog, 'tools' | 'actions'>): ToolboxIndexDocument;
-declare function portableRecordSemantic(value: ToolRecord | ActionRecord): string;
-declare function preserveProjectionTime<T extends ToolRecord | ActionRecord>(candidate: T, previous: unknown): T;
 /** The migration of one legacy aggregate `toolbox.json` catalog, as a pure
  * plan: every user tool becomes a per-tool artifact write, the whole legacy
  * catalog becomes the index, and the aggregate file is renamed out of the
  * way only after each record has a per-tool replacement. */
 declare function legacyMigrationPlan(legacy: unknown): LegacyMigrationPlan;
-export { LEGACY_TOOLBOX_BACKUP_FILE_NAME, LEGACY_TOOLBOX_FILE_NAME, TOOL_ARTIFACT_KIND, TOOL_ARTIFACT_SCHEMA_VERSION, TOOLBOX_INDEX_FILE_NAME, artifactDocument, catalogIndexDocument, isToolArtifactDocument, legacyMigrationPlan, safeToolId, portableRecordSemantic, preserveProjectionTime, toolboxIndexDocument, userArtifactFileName, };
+export { LEGACY_TOOLBOX_BACKUP_FILE_NAME, LEGACY_TOOLBOX_FILE_NAME, TOOL_ARTIFACT_KIND, TOOL_ARTIFACT_SCHEMA_VERSION, TOOLBOX_INDEX_FILE_NAME, artifactDocument, catalogIndexDocument, isToolArtifactDocument, legacyMigrationPlan, safeToolId, toolboxIndexDocument, userArtifactFileName, };
 export type { ArtifactFileWrite, LegacyMigrationPlan, ToolArtifactDocument, ToolboxIndexDocument };

package/dist/artifacts.js

@@ -1,11 +1,11 @@
 /**
  * Tool artifact format laws — the portable representation of a tool.
  *
- * One compatibility artifact projects one current tool and every action it
- * owns together; a file never carries a second tool. Immutable deployment
- * documents are the portable source of truth. These artifacts, the Toolbox
- * database, and `toolbox.index.json` are derived views retained for current
- * Engine/UI readers.
+ * One tool is one artifact file: the tool definition and every action it
+ * owns travel together, and a file never carries a second tool. Artifact
+ * files are the portable definition; the Toolbox database and
+ * `toolbox.index.json` are derived caches. The format is ported byte-exact
+ * from Engine `runtime/scripts/amalgm-mcp/toolbox/artifacts.js`.
  *
  * Pure laws only: nothing here touches the filesystem. `artifact-files.ts`
  * is the host adapter that executes these documents and plans.
@@ -81,19 +81,6 @@ function toolboxIndexDocument(tools, toolActions) {
 function catalogIndexDocument(catalog) {
     return toolboxIndexDocument(Object.fromEntries(catalog.tools.map((tool) => [tool.id, tool])), Object.fromEntries(catalog.actions.map((action) => [action.id, action])));
 }
-function portableRecordSemantic(value) {
-    const { createdAt, updatedAt, ...portable } = value;
-    return JSON.stringify(portable);
-}
-function preserveProjectionTime(candidate, previous) {
-    if (!previous || typeof previous !== 'object')
-        return candidate;
-    const record = previous;
-    if (typeof record.createdAt !== 'string' || typeof record.updatedAt !== 'string'
-        || portableRecordSemantic(record) !== portableRecordSemantic(candidate))
-        return candidate;
-    return { ...candidate, createdAt: record.createdAt, updatedAt: record.updatedAt };
-}
 /** The migration of one legacy aggregate `toolbox.json` catalog, as a pure
  * plan: every user tool becomes a per-tool artifact write, the whole legacy
  * catalog becomes the index, and the aggregate file is renamed out of the
@@ -122,4 +109,4 @@ function legacyMigrationPlan(legacy) {
         rename: { from: LEGACY_TOOLBOX_FILE_NAME, to: LEGACY_TOOLBOX_BACKUP_FILE_NAME },
     };
 }
-export { LEGACY_TOOLBOX_BACKUP_FILE_NAME, LEGACY_TOOLBOX_FILE_NAME, TOOL_ARTIFACT_KIND, TOOL_ARTIFACT_SCHEMA_VERSION, TOOLBOX_INDEX_FILE_NAME, artifactDocument, catalogIndexDocument, isToolArtifactDocument, legacyMigrationPlan, safeToolId, portableRecordSemantic, preserveProjectionTime, toolboxIndexDocument, userArtifactFileName, };
+export { LEGACY_TOOLBOX_BACKUP_FILE_NAME, LEGACY_TOOLBOX_FILE_NAME, TOOL_ARTIFACT_KIND, TOOL_ARTIFACT_SCHEMA_VERSION, TOOLBOX_INDEX_FILE_NAME, artifactDocument, catalogIndexDocument, isToolArtifactDocument, legacyMigrationPlan, safeToolId, toolboxIndexDocument, userArtifactFileName, };

package/dist/definition.js

@@ -32,15 +32,6 @@ function refs(value, label) {
         result[string(key, label)] = string(reference, `${label}.${key}`);
     return result;
 }
-function hostRoute(value) {
-    if (value === undefined)
-        return undefined;
-    const route = string(value, 'source.route');
-    if (!route.startsWith('/') || route.startsWith('//') || route.includes('?') || route.includes('#')) {
-        throw new Error('source.route must be an absolute path without query or fragment');
-    }
-    return route.replace(/\/+$/, '') || '/';
-}
 function base(source) {
     return {
         timeoutMs: positive(source.timeoutMs, DEFAULT_TIMEOUT, 'source.timeoutMs'),
@@ -100,7 +91,6 @@ function normalizeSource(source) {
             ...(strings(source.args, 'source.args') ? { args: strings(source.args, 'source.args') } : {}),
             ...(source.cwd ? { cwd: string(source.cwd, 'source.cwd') } : {}),
             ...(source.serverName ? { serverName: string(source.serverName, 'source.serverName') } : {}),
-            ...(hostRoute(source.route) ? { route: hostRoute(source.route) } : {}),
             ...(refs(source.secretHeaders, 'source.secretHeaders') ? { secretHeaders: refs(source.secretHeaders, 'source.secretHeaders') } : {}),
             ...(refs(source.secretEnv, 'source.secretEnv') ? { secretEnv: refs(source.secretEnv, 'source.secretEnv') } : {}),
         };

package/dist/http.js

@@ -16,12 +16,7 @@ function actionDocument(action) {
     return { ...action };
 }
 function catalogDocument(catalog) {
-    return {
-        ...toolboxIndexDocument(Object.fromEntries(catalog.tools.map((tool) => [tool.id, toolDocument(tool)])), Object.fromEntries(catalog.actions.map((action) => [action.id, actionDocument(action)]))),
-        revision: catalog.revision,
-        revisionId: catalog.revisionId,
-        deployments: catalog.deployments,
-    };
+    return toolboxIndexDocument(Object.fromEntries(catalog.tools.map((tool) => [tool.id, toolDocument(tool)])), Object.fromEntries(catalog.actions.map((action) => [action.id, actionDocument(action)])));
 }
 async function readBody(req) {
     const chunks = [];

package/dist/index.d.ts

@@ -2,12 +2,10 @@ export { ArtifactFiles } from './artifact-files.js';
 export { LEGACY_TOOLBOX_BACKUP_FILE_NAME, LEGACY_TOOLBOX_FILE_NAME, TOOL_ARTIFACT_KIND, TOOL_ARTIFACT_SCHEMA_VERSION, TOOLBOX_INDEX_FILE_NAME, artifactDocument, catalogIndexDocument, isToolArtifactDocument, legacyMigrationPlan, safeToolId, toolboxIndexDocument, userArtifactFileName, } from './artifacts.js';
 export type { ArtifactFileWrite, LegacyMigrationPlan, ToolArtifactDocument, ToolboxIndexDocument, } from './artifacts.js';
 export { defineTool, normalizeDefinition } from './definition.js';
-export { defineHostMcpTool } from './host-mcp-tool.js';
-export { TOOL_DEPLOYMENT_CONTRACT, TOOL_DEPLOYMENT_KIND, TOOL_DEPLOYMENT_SCHEMA_VERSION, assertToolDeploymentActivation, createToolDeployment, deploymentRevisionId, emptyToolDeploymentSnapshot, } from './deployments.js';
 export { catalogDocument, createToolboxHttpServer } from './http.js';
 export type { ToolboxHttpServer } from './http.js';
 export { actionId, actionName, id, mcpName } from './ids.js';
-export { actionTools, callMcpTool, createMcpTools, findMcpTool, managementToolDescriptors, managementTools, } from './mcp.js';
+export { actionTools, callMcpTool, createMcpTools, findMcpTool, managementTools, } from './mcp.js';
 export { createMcpServer } from './mcp-server.js';
 export { Notifications, createNotificationsDriver, notificationToolDefinition, } from './notifications.js';
 export type { EmailDelivery, EmailDeliveryReceipt, EmailNotificationRequest, NotificationLevel, NotificationsOptions, } from './notifications.js';

package/dist/index.js

@@ -1,11 +1,9 @@
 export { ArtifactFiles } from './artifact-files.js';
 export { LEGACY_TOOLBOX_BACKUP_FILE_NAME, LEGACY_TOOLBOX_FILE_NAME, TOOL_ARTIFACT_KIND, TOOL_ARTIFACT_SCHEMA_VERSION, TOOLBOX_INDEX_FILE_NAME, artifactDocument, catalogIndexDocument, isToolArtifactDocument, legacyMigrationPlan, safeToolId, toolboxIndexDocument, userArtifactFileName, } from './artifacts.js';
 export { defineTool, normalizeDefinition } from './definition.js';
-export { defineHostMcpTool } from './host-mcp-tool.js';
-export { TOOL_DEPLOYMENT_CONTRACT, TOOL_DEPLOYMENT_KIND, TOOL_DEPLOYMENT_SCHEMA_VERSION, assertToolDeploymentActivation, createToolDeployment, deploymentRevisionId, emptyToolDeploymentSnapshot, } from './deployments.js';
 export { catalogDocument, createToolboxHttpServer } from './http.js';
 export { actionId, actionName, id, mcpName } from './ids.js';
-export { actionTools, callMcpTool, createMcpTools, findMcpTool, managementToolDescriptors, managementTools, } from './mcp.js';
+export { actionTools, callMcpTool, createMcpTools, findMcpTool, managementTools, } from './mcp.js';
 export { createMcpServer } from './mcp-server.js';
 export { Notifications, createNotificationsDriver, notificationToolDefinition, } from './notifications.js';
 export { createProxyEmailDelivery } from './proxy-email.js';

package/dist/mcp-server.d.ts

@@ -1,7 +1,7 @@
 import readline from 'node:readline';
 import type { Readable, Writable } from 'node:stream';
 import { Toolbox } from './toolbox.js';
-import type { McpOptions, ToolboxOptions } from './types.js';
+import type { ToolboxOptions } from './types.js';
 interface Request {
     jsonrpc?: string;
     id?: string | number;
@@ -10,7 +10,6 @@ interface Request {
 }
 declare function createMcpServer(options?: ToolboxOptions & {
     toolbox?: Toolbox;
-    mcp?: McpOptions;
 }): {
     toolbox: Toolbox;
     handle: (request: Request) => Promise<unknown>;

package/dist/mcp-server.js

@@ -7,7 +7,6 @@ function descriptor(tool) {
 }
 function createMcpServer(options = {}) {
     const toolbox = options.toolbox || new Toolbox(options);
-    const mcpOptions = options.mcp || {};
     async function handle(request) {
         if (request.method === 'initialize') {
             return {
@@ -18,12 +17,12 @@ function createMcpServer(options = {}) {
         }
         if (request.method === 'ping')
             return {};
-        const tools = createMcpTools(toolbox, mcpOptions);
+        const tools = createMcpTools(toolbox);
         if (request.method === 'tools/list')
             return { tools: tools.map(descriptor) };
         if (request.method === 'tools/call') {
             try {
-                return await callMcpTool(toolbox, String(request.params?.name || ''), request.params?.arguments || {}, mcpOptions);
+                return await callMcpTool(toolbox, String(request.params?.name || ''), request.params?.arguments || {});
             }
             catch (error) {
                 if (error instanceof Error && error.message.startsWith('Unknown tool:')) {

package/dist/mcp.d.ts

@@ -1,10 +1,9 @@
 import type { Toolbox } from './toolbox.js';
 import type { JsonSchema, McpOptions, McpTool } from './types.js';
 declare function portable(schema: JsonSchema): JsonSchema;
-declare function managementToolDescriptors(): Array<Omit<McpTool, 'handler'>>;
 declare function managementTools(toolbox: Toolbox): McpTool[];
 declare function actionTools(toolbox: Toolbox, options?: McpOptions): McpTool[];
 declare function createMcpTools(toolbox: Toolbox, options?: McpOptions): McpTool[];
 declare function findMcpTool(toolbox: Toolbox, name: string, options?: McpOptions): McpTool | null;
 declare function callMcpTool(toolbox: Toolbox, name: string, input?: Record<string, unknown>, options?: McpOptions): Promise<import("./types.js").ToolResult>;
-export { actionTools, callMcpTool, createMcpTools, findMcpTool, managementTools, managementToolDescriptors, portable, };
+export { actionTools, callMcpTool, createMcpTools, findMcpTool, managementTools, portable, };

package/dist/mcp.js

@@ -21,57 +21,45 @@ function managed(definition, handler) {
         },
     };
 }
-function managementToolDescriptors() {
+function managementTools(toolbox) {
     const idProperty = { id: { type: 'string', description: 'Tool or action id' } };
     return [
-        {
+        managed({
             name: 'toolbox_tools_list', description: 'List the canonical Toolbox catalog.',
             inputSchema: { type: 'object', properties: {}, additionalProperties: false },
-        },
-        {
+        }, () => toolbox.catalog()),
+        managed({
             name: 'toolbox_tool_get', description: 'Get one tool and its actions.',
             inputSchema: { type: 'object', properties: idProperty, required: ['id'], additionalProperties: false },
-        },
-        {
+        }, ({ id }) => {
+            const result = toolbox.get(String(id));
+            if (!result)
+                throw new Error(`Unknown tool: ${id}`);
+            return result;
+        }),
+        managed({
             name: 'toolbox_tool_apply', description: 'Atomically apply an authoritative tool definition.',
             inputSchema: {
                 type: 'object', required: ['tool'], additionalProperties: false,
                 properties: { tool: { type: 'object', description: 'Complete tool definition' } },
             },
-        },
-        {
+        }, ({ tool }) => toolbox.apply(tool)),
+        managed({
             name: 'toolbox_record_enable', description: 'Enable one user-owned tool or action.',
             inputSchema: { type: 'object', properties: idProperty, required: ['id'], additionalProperties: false },
-        },
-        {
+        }, ({ id }) => toolbox.setStatus(String(id), 'enabled')),
+        managed({
             name: 'toolbox_record_disable', description: 'Disable one user-owned tool or action.',
             inputSchema: { type: 'object', properties: idProperty, required: ['id'], additionalProperties: false },
-        },
-        {
+        }, ({ id }) => toolbox.setStatus(String(id), 'disabled')),
+        managed({
             name: 'toolbox_record_remove', description: 'Remove one user-owned tool or action.',
             inputSchema: { type: 'object', properties: idProperty, required: ['id'], additionalProperties: false },
-        },
-        {
+        }, ({ id }) => toolbox.remove(String(id))),
+        managed({
             name: 'toolbox_mcp_connections', description: 'List external MCP connections for the composing host.',
             inputSchema: { type: 'object', properties: {}, additionalProperties: false },
-        },
-    ];
-}
-function managementTools(toolbox) {
-    const [list, get, apply, enable, disable, remove, connections] = managementToolDescriptors();
-    return [
-        managed(list, () => toolbox.catalog()),
-        managed(get, ({ id }) => {
-            const result = toolbox.get(String(id));
-            if (!result)
-                throw new Error(`Unknown tool: ${id}`);
-            return result;
-        }),
-        managed(apply, ({ tool }) => toolbox.apply(tool)),
-        managed(enable, ({ id }) => toolbox.setStatus(String(id), 'enabled')),
-        managed(disable, ({ id }) => toolbox.setStatus(String(id), 'disabled')),
-        managed(remove, ({ id }) => toolbox.remove(String(id))),
-        managed(connections, () => toolbox.connections()),
+        }, () => toolbox.connections()),
     ];
 }
 function actionTools(toolbox, options = {}) {
@@ -104,4 +92,4 @@ async function callMcpTool(toolbox, name, input = {}, options = {}) {
         throw new Error(`Unknown tool: ${name}`);
     return tool.handler(input);
 }
-export { actionTools, callMcpTool, createMcpTools, findMcpTool, managementTools, managementToolDescriptors, portable, };
+export { actionTools, callMcpTool, createMcpTools, findMcpTool, managementTools, portable, };

package/dist/notifications.js

@@ -18,12 +18,11 @@ function contextSessionId(value) {
 function notificationToolDefinition() {
     return {
         id: 'notifications',
-        name: 'Channels',
+        name: 'Notifications',
         description: 'Notify the current user about important results, completions, and failures.',
         owner: 'amalgm',
         origin: 'system',
-        source: { type: 'mcp', transport: 'host', serverName: 'channels', route: '/mcp/channels' },
-        policy: { firstParty: true },
+        source: { type: 'mcp', transport: 'host', serverName: 'notifications' },
         actions: [{
                 name: 'notify_user',
                 description: 'Send the current user an email notification. Keep it concise and actionable.',
@@ -92,7 +91,7 @@ function createNotificationsDriver(notifications) {
             return tool.id === 'notifications'
                 && tool.source.type === 'mcp'
                 && tool.source.transport === 'host'
-                && tool.source.serverName === 'channels';
+                && tool.source.serverName === 'notifications';
         },
         async call({ action, input, options }) {
             if (action.id !== 'notifications.notify_user')

package/dist/schema.js

@@ -21,21 +21,6 @@ function migrate(db) {
       UNIQUE(tool_id, id)
     );
     CREATE INDEX IF NOT EXISTS actions_tool_id ON actions(tool_id);
-
-    CREATE TABLE IF NOT EXISTS tool_deployments (
-      id TEXT PRIMARY KEY,
-      tool_id TEXT NOT NULL,
-      previous_deployment_id TEXT,
-      created_at TEXT NOT NULL,
-      record_json TEXT NOT NULL
-    );
-    CREATE INDEX IF NOT EXISTS tool_deployments_tool_id
-      ON tool_deployments(tool_id, created_at, id);
-
-    CREATE TABLE IF NOT EXISTS tool_heads (
-      tool_id TEXT PRIMARY KEY,
-      deployment_id TEXT NOT NULL REFERENCES tool_deployments(id)
-    );
   `);
 }
 export { migrate };

package/dist/store.d.ts

@@ -1,5 +1,5 @@
 import Database from 'better-sqlite3';
-import type { ActionRecord, ApplyResult, Catalog, ToolDeployment, ToolDeploymentActivation, ToolDeploymentSnapshot, ToolRecord } from './types.js';
+import type { ActionRecord, ApplyResult, Catalog, Status, ToolRecord } from './types.js';
 declare class Store {
     readonly db: Database.Database;
     constructor(file: string);
@@ -8,23 +8,10 @@ declare class Store {
     getTool(id: string): ToolRecord | null;
     getAction(id: string): ActionRecord | null;
     actionsFor(toolId: string): ActionRecord[];
-    heads(): Record<string, string>;
     catalog(): Catalog;
-    currentDeploymentId(toolId: string): string | null;
-    getDeployment(id: string): ToolDeployment | null;
-    deploymentsFor(toolId: string): ToolDeployment[];
-    allDeployments(): ToolDeployment[];
-    deploymentSnapshot(): ToolDeploymentSnapshot;
-    /** Add a baseline for a pre-deployment database without changing its catalog bytes. */
-    adoptDeployment(activation: ToolDeploymentActivation): void;
-    applyDeployment(activation: ToolDeploymentActivation): {
-        changed: boolean;
-        result: ApplyResult | null;
-    };
-    replaceDeploymentSnapshot(snapshot: ToolDeploymentSnapshot): void;
-    private insertDeployment;
-    private setHead;
-    private materializeDefinition;
+    apply(result: ApplyResult): ApplyResult;
+    setStatus(id: string, status: Status, now: string): ToolRecord | ActionRecord | null;
+    remove(id: string): ToolRecord | ActionRecord | null;
     close(): void;
 }
 export { Store };