@amalgm/tools 0.1.2 → 0.1.3

package/PURPOSE.md

@@ -81,11 +81,16 @@ 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.
 
 ## Predictable behavior
 
-Applying the same definition twice produces the same catalog. Applying a
-changed action set replaces the old set atomically. Selecting a whole tool
+Applying the same definition twice produces the same catalog. 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
 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/dist/artifact-files.d.ts

@@ -1,3 +1,4 @@
+import type { ToolboxIndexDocument } from './artifacts.js';
 import type { ActionRecord, Catalog, ToolRecord } from './types.js';
 declare class ArtifactFiles {
     private readonly directory;
@@ -9,6 +10,7 @@ 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 is an explicit mutation. */

package/dist/artifact-files.js

@@ -51,6 +51,13 @@ 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 is an explicit mutation. */

package/dist/artifacts.d.ts

@@ -57,10 +57,12 @@ 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, 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, portableRecordSemantic, preserveProjectionTime, toolboxIndexDocument, userArtifactFileName, };
 export type { ArtifactFileWrite, LegacyMigrationPlan, ToolArtifactDocument, ToolboxIndexDocument };

package/dist/artifacts.js

@@ -81,6 +81,19 @@ 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
@@ -109,4 +122,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, 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, portableRecordSemantic, preserveProjectionTime, toolboxIndexDocument, userArtifactFileName, };

package/dist/toolbox.js

@@ -3,6 +3,7 @@ import path from 'node:path';
 import { resolveProductStateDir } from '@amalgm/core/identity';
 import { apiDriver } from './api-driver.js';
 import { ArtifactFiles } from './artifact-files.js';
+import { portableRecordSemantic, preserveProjectionTime } from './artifacts.js';
 import { cliDriver } from './cli-driver.js';
 import { normalizeDefinition } from './definition.js';
 import { assertMcpNamesUnique, id, mcpName } from './ids.js';
@@ -11,10 +12,6 @@ import { callableActions, queryTools, resolveAction, resolveCallableAction } fro
 import { findSelected, selected } from './selection.js';
 import { Store } from './store.js';
 import { updateAction, updateTool, upsertAction } from './updates.js';
-function semantic(value) {
-    const { createdAt, updatedAt, ...record } = value;
-    return JSON.stringify(record);
-}
 function defaultDatabase(options) {
     if (options.databaseFile)
         return path.resolve(options.databaseFile);
@@ -40,6 +37,7 @@ class Toolbox {
         const databaseFile = defaultDatabase(options);
         this.store = new Store(databaseFile);
         this.artifacts = new ArtifactFiles(path.dirname(databaseFile));
+        const priorIndex = this.artifacts.readIndex();
         this.onChange = options.onChange;
         for (const driver of [cliDriver, apiDriver, ...(options.drivers || [])])
             this.drivers.set(driver.type, driver);
@@ -49,8 +47,8 @@ class Toolbox {
             const normalized = normalizeDefinition({ ...definition, origin: 'system' });
             if (tools.some((tool) => tool.id === normalized.tool.id))
                 throw new Error(`Duplicate system tool: ${normalized.tool.id}`);
-            tools.push(normalized.tool);
-            actions.push(...normalized.actions);
+            tools.push(preserveProjectionTime(normalized.tool, priorIndex?.tools[normalized.tool.id]));
+            actions.push(...normalized.actions.map((action) => preserveProjectionTime(action, priorIndex?.toolActions[action.id])));
         }
         assertMcpNamesUnique(actions);
         this.system = { version: 1, revision: 0, tools, actions };
@@ -116,9 +114,10 @@ class Toolbox {
             ...normalized.actions,
         ];
         assertMcpNamesUnique(candidateActions);
-        const unchanged = existing && semantic(existing) === semantic(normalized.tool)
+        const unchanged = existing && portableRecordSemantic(existing) === portableRecordSemantic(normalized.tool)
             && normalized.actions.length === oldActions.size
-            && normalized.actions.every((action) => semantic(action) === semantic(oldActions.get(action.id)));
+            && normalized.actions.every((action) => portableRecordSemantic(action)
+                === portableRecordSemantic(oldActions.get(action.id)));
         if (unchanged)
             return { tool: existing, actions: [...oldActions.values()].sort((a, b) => a.id.localeCompare(b.id)) };
         const result = this.store.apply(normalized);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amalgm/tools",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Local-first tool definitions, Toolbox registry, and agent execution surfaces.",
   "license": "UNLICENSED",
   "private": false,
@@ -49,7 +49,7 @@
     "node": ">=20"
   },
   "dependencies": {
-    "@amalgm/core": "^0.1.0",
+    "@amalgm/core": "0.2.0",
     "better-sqlite3": "^12.6.2"
   },
   "devDependencies": {