@jshookmcp/jshook 0.2.3 → 0.2.5

package/dist/src/server/domains/trace/definitions.tools.js

@@ -1,208 +1,53 @@
+import { tool } from '../../registry/tool-builder.js';
 export const TRACE_TOOLS = [
-    {
-        name: 'start_trace_recording',
-        description: `Start recording CDP events, debugger state, and memory writes into a SQLite trace database.
-
-Recording captures events from:
-- Debugger: breakpoints, pauses, script parsing
-- Runtime: console calls, exceptions
-- Network: requests, responses
-- Page: navigation events
-- EventBus: tool calls, memory scans, browser events
-
-Call stop_trace_recording to end the recording session.
-
-Examples:
-start_trace_recording()
-start_trace_recording(cdpDomains=["Debugger", "Network"])`,
-        inputSchema: {
-            type: 'object',
-            properties: {
-                cdpDomains: {
-                    type: 'array',
-                    items: { type: 'string' },
-                    description: 'CDP domains to record (default: Debugger, Runtime, Network, Page)',
-                },
-                recordMemoryDeltas: {
-                    type: 'boolean',
-                    description: 'Record memory write deltas (default: true)',
-                },
-            },
-        },
-    },
-    {
-        name: 'stop_trace_recording',
-        description: `Stop the active trace recording and finalize the SQLite database.
-
-Returns session summary including:
-- Database file path
-- Total event count
-- Memory delta count
-- Heap snapshot count
-- Recording duration
-
-Examples:
-stop_trace_recording()`,
-        inputSchema: {
-            type: 'object',
-            properties: {},
-        },
-    },
-    {
-        name: 'query_trace_sql',
-        description: `Execute a read-only SQL query against a trace database.
-
-Available tables:
-- events(id, timestamp, category, event_type, data, script_id, line_number)
-- memory_deltas(id, timestamp, address, old_value, new_value, size, value_type)
-- heap_snapshots(id, timestamp, snapshot_data, summary)
-- metadata(key, value)
-
-Returns columns, rows, and row count.
-
-Examples:
-query_trace_sql(sql="SELECT * FROM events WHERE category='debugger' ORDER BY timestamp")
-query_trace_sql(sql="SELECT address, COUNT(*) as writes FROM memory_deltas GROUP BY address ORDER BY writes DESC LIMIT 10")
-query_trace_sql(sql="SELECT * FROM events WHERE timestamp BETWEEN 1000 AND 2000", dbPath="artifacts/traces/my-trace.db")`,
-        inputSchema: {
-            type: 'object',
-            properties: {
-                sql: {
-                    type: 'string',
-                    description: 'SQL query to execute (SELECT only — write operations are rejected)',
-                },
-                dbPath: {
-                    type: 'string',
-                    description: 'Path to trace DB file. Uses the active recording if omitted.',
-                },
-            },
-            required: ['sql'],
-        },
-    },
-    {
-        name: 'seek_to_timestamp',
-        description: `Reconstruct application state at a specific timestamp from a recorded trace.
-
-Returns a structured snapshot including:
-- Events near the timestamp
-- Debugger state (last pause, call stack)
-- Memory state (latest values per address)
-- Network state (completed requests)
-- Nearest heap snapshot
-
-Examples:
-seek_to_timestamp(timestamp=1711000000000)
-seek_to_timestamp(timestamp=1711000000000, windowMs=500)
-seek_to_timestamp(timestamp=1711000000000, dbPath="artifacts/traces/my-trace.db")`,
-        inputSchema: {
-            type: 'object',
-            properties: {
-                timestamp: {
-                    type: 'number',
-                    description: 'Target timestamp in milliseconds since epoch',
-                },
-                dbPath: {
-                    type: 'string',
-                    description: 'Path to trace DB file. Uses the active recording if omitted.',
-                },
-                windowMs: {
-                    type: 'number',
-                    description: 'Time window around timestamp to include in ms (default: 100)',
-                },
-            },
-            required: ['timestamp'],
-        },
-    },
-    {
-        name: 'diff_heap_snapshots',
-        description: `Compare two heap snapshots from a trace and return the differences.
-
-Shows:
-- New object types (in snapshot 2 but not 1)
-- Deleted object types (in snapshot 1 but not 2)
-- Changed objects (count or size differs)
-- Total size delta
-
-Useful for identifying state changes in obfuscated code.
-
-Examples:
-diff_heap_snapshots(snapshotId1=1, snapshotId2=2)
-diff_heap_snapshots(snapshotId1=1, snapshotId2=3, dbPath="artifacts/traces/my-trace.db")`,
-        inputSchema: {
-            type: 'object',
-            properties: {
-                snapshotId1: {
-                    type: 'number',
-                    description: 'First snapshot ID (earlier)',
-                },
-                snapshotId2: {
-                    type: 'number',
-                    description: 'Second snapshot ID (later)',
-                },
-                dbPath: {
-                    type: 'string',
-                    description: 'Path to trace DB file. Uses the active recording if omitted.',
-                },
-            },
-            required: ['snapshotId1', 'snapshotId2'],
-        },
-    },
-    {
-        name: 'export_trace',
-        description: `Export a trace database to Chrome Trace Event JSON format.
-
-The resulting file can be loaded in:
-- chrome://tracing
-- Perfetto UI (ui.perfetto.dev)
-
-Maps events to the standard trace event format with name, category, phase, timestamp.
-
-Examples:
-export_trace()
-export_trace(dbPath="artifacts/traces/my-trace.db")
-export_trace(outputPath="my-export.json")`,
-        inputSchema: {
-            type: 'object',
-            properties: {
-                dbPath: {
-                    type: 'string',
-                    description: 'Path to trace DB file. Uses the active recording if omitted.',
-                },
-                outputPath: {
-                    type: 'string',
-                    description: 'Output JSON file path. Auto-generated if omitted.',
-                },
-            },
-        },
-    },
-    {
-        name: 'summarize_trace',
-        description: `Generate a compact, LLM-friendly summary of a trace database.
-
-Avoids sending raw trace data that may exceed context windows. Three detail levels:
-- compact: category aggregation + timeline overview (~10% of raw size)
-- balanced: compact + key moments (breakpoints, exceptions, network completions) [DEFAULT]
-- full: passthrough — returns all events without compression
-
-Also detects memory anomalies: addresses with significantly more writes than average.
-
-Examples:
-summarize_trace()
-summarize_trace(detail="compact")
-summarize_trace(detail="balanced", dbPath="artifacts/traces/my-trace.db")`,
-        inputSchema: {
-            type: 'object',
-            properties: {
-                detail: {
-                    type: 'string',
-                    enum: ['compact', 'balanced', 'full'],
-                    description: 'Summary detail level (default: balanced)',
-                },
-                dbPath: {
-                    type: 'string',
-                    description: 'Path to trace DB file. Uses the active recording if omitted.',
-                },
-            },
-        },
-    },
+    tool('start_trace_recording')
+        .desc('Start recording CDP events, debugger state, and memory writes into a SQLite trace database.\n\nRecording captures events from:\n- Debugger: breakpoints, pauses, script parsing\n- Runtime: console calls, exceptions\n- Network: requests, responses\n- Page: navigation events\n- EventBus: tool calls, memory scans, browser events\n\nCall stop_trace_recording to end the recording session.\n\nExamples:\nstart_trace_recording()\nstart_trace_recording(cdpDomains=["Debugger", "Network"])')
+        .array('cdpDomains', { type: 'string' }, 'CDP domains to record (default: Debugger, Runtime, Network, Page)')
+        .boolean('recordMemoryDeltas', 'Record memory write deltas', { default: true })
+        .idempotent()
+        .build(),
+    tool('stop_trace_recording')
+        .desc('Stop the active trace recording and finalize the SQLite database.\n\nReturns session summary including:\n- Database file path\n- Total event count\n- Memory delta count\n- Heap snapshot count\n- Recording duration\n\nExamples:\nstop_trace_recording()')
+        .build(),
+    tool('query_trace_sql')
+        .desc('Execute a read-only SQL query against a trace database.\n\nAvailable tables:\n- events(id, timestamp, category, event_type, data, script_id, line_number)\n- memory_deltas(id, timestamp, address, old_value, new_value, size, value_type)\n- heap_snapshots(id, timestamp, snapshot_data, summary)\n- metadata(key, value)\n\nReturns columns, rows, and row count.\n\nExamples:\nquery_trace_sql(sql="SELECT * FROM events WHERE category=\'debugger\' ORDER BY timestamp")\nquery_trace_sql(sql="SELECT address, COUNT(*) as writes FROM memory_deltas GROUP BY address ORDER BY writes DESC LIMIT 10")\nquery_trace_sql(sql="SELECT * FROM events WHERE timestamp BETWEEN 1000 AND 2000", dbPath="artifacts/traces/my-trace.db")')
+        .string('sql', 'SQL query to execute (SELECT only — write operations are rejected)')
+        .string('dbPath', 'Path to trace DB file. Uses the active recording if omitted.')
+        .required('sql')
+        .readOnly()
+        .idempotent()
+        .build(),
+    tool('seek_to_timestamp')
+        .desc('Reconstruct application state at a specific timestamp from a recorded trace.\n\nReturns a structured snapshot including:\n- Events near the timestamp\n- Debugger state (last pause, call stack)\n- Memory state (latest values per address)\n- Network state (completed requests)\n- Nearest heap snapshot\n\nExamples:\nseek_to_timestamp(timestamp=1711000000000)\nseek_to_timestamp(timestamp=1711000000000, windowMs=500)\nseek_to_timestamp(timestamp=1711000000000, dbPath="artifacts/traces/my-trace.db")')
+        .number('timestamp', 'Target timestamp in milliseconds since epoch')
+        .string('dbPath', 'Path to trace DB file. Uses the active recording if omitted.')
+        .number('windowMs', 'Time window around timestamp to include in ms', { default: 100 })
+        .required('timestamp')
+        .readOnly()
+        .idempotent()
+        .build(),
+    tool('diff_heap_snapshots')
+        .desc('Compare two heap snapshots from a trace and return the differences.\n\nShows:\n- New object types (in snapshot 2 but not 1)\n- Deleted object types (in snapshot 1 but not 2)\n- Changed objects (count or size differs)\n- Total size delta\n\nUseful for identifying state changes in obfuscated code.\n\nExamples:\ndiff_heap_snapshots(snapshotId1=1, snapshotId2=2)\ndiff_heap_snapshots(snapshotId1=1, snapshotId2=3, dbPath="artifacts/traces/my-trace.db")')
+        .number('snapshotId1', 'First snapshot ID (earlier)')
+        .number('snapshotId2', 'Second snapshot ID (later)')
+        .string('dbPath', 'Path to trace DB file. Uses the active recording if omitted.')
+        .required('snapshotId1', 'snapshotId2')
+        .readOnly()
+        .idempotent()
+        .build(),
+    tool('export_trace')
+        .desc('Export a trace database to Chrome Trace Event JSON format.\n\nThe resulting file can be loaded in:\n- chrome://tracing\n- Perfetto UI (ui.perfetto.dev)\n\nMaps events to the standard trace event format with name, category, phase, timestamp.\n\nExamples:\nexport_trace()\nexport_trace(dbPath="artifacts/traces/my-trace.db")\nexport_trace(outputPath="my-export.json")')
+        .string('dbPath', 'Path to trace DB file. Uses the active recording if omitted.')
+        .string('outputPath', 'Output JSON file path. Auto-generated if omitted.')
+        .idempotent()
+        .build(),
+    tool('summarize_trace')
+        .desc('Generate a compact, LLM-friendly summary of a trace database.\n\nAvoids sending raw trace data that may exceed context windows. Three detail levels:\n- compact: category aggregation + timeline overview (~10% of raw size)\n- balanced: compact + key moments (breakpoints, exceptions, network completions) [DEFAULT]\n- full: passthrough — returns all events without compression\n\nAlso detects memory anomalies: addresses with significantly more writes than average.\n\nExamples:\nsummarize_trace()\nsummarize_trace(detail="compact")\nsummarize_trace(detail="balanced", dbPath="artifacts/traces/my-trace.db")')
+        .enum('detail', ['compact', 'balanced', 'full'], 'Summary detail level', {
+        default: 'balanced',
+    })
+        .string('dbPath', 'Path to trace DB file. Uses the active recording if omitted.')
+        .readOnly()
+        .idempotent()
+        .build(),
 ];

package/dist/src/server/domains/trace/handlers.js

@@ -2,7 +2,7 @@ import { writeFile } from 'node:fs/promises';
 import { TraceDB } from '../../../modules/trace/TraceDB.js';
 import {} from '../../../modules/trace/TraceRecorder.js';
 import { resolveArtifactPath } from '../../../utils/artifacts.js';
-import { summarizeEvents, summarizeMemoryDeltas } from '../../domains/trace/TraceSummarizer.js';
+import { summarizeEvents, summarizeMemoryDeltas, } from '../../domains/trace/TraceSummarizer.js';
 export class TraceToolHandlers {
     recorder;
     ctx;
@@ -42,9 +42,7 @@ export class TraceToolHandlers {
     }
     async handleStopTraceRecording() {
         const session = this.recorder.stop();
-        const duration = session.stoppedAt
-            ? session.stoppedAt - session.startedAt
-            : 0;
+        const duration = session.stoppedAt ? session.stoppedAt - session.startedAt : 0;
         return {
             status: 'stopped',
             sessionId: session.sessionId,
@@ -103,16 +101,16 @@ export class TraceToolHandlers {
                 tempDb = db;
             const events = db.getEventsByTimeRange(timestamp - windowMs, timestamp + windowMs);
             const debuggerEventsResult = db.query(`SELECT * FROM events WHERE category = 'debugger' AND timestamp <= ${timestamp} ORDER BY timestamp DESC LIMIT 5`);
-            const memoryStateResult = db.query(`SELECT m1.* FROM memory_deltas m1
-         INNER JOIN (SELECT address, MAX(timestamp) as max_ts FROM memory_deltas WHERE timestamp <= ${timestamp} GROUP BY address) m2
-         ON m1.address = m2.address AND m1.timestamp = m2.max_ts
+            const memoryStateResult = db.query(`SELECT m1.* FROM memory_deltas m1
+         INNER JOIN (SELECT address, MAX(timestamp) as max_ts FROM memory_deltas WHERE timestamp <= ${timestamp} GROUP BY address) m2
+         ON m1.address = m2.address AND m1.timestamp = m2.max_ts
          ORDER BY m1.address`);
             const networkResult = db.query(`SELECT * FROM events WHERE category = 'network' AND event_type = 'Network.loadingFinished' AND timestamp <= ${timestamp} ORDER BY timestamp DESC LIMIT 20`);
             const snapshotResult = db.query(`SELECT id, timestamp, summary FROM heap_snapshots WHERE timestamp <= ${timestamp} ORDER BY timestamp DESC LIMIT 1`);
             return {
                 seekTimestamp: timestamp,
                 windowMs,
-                events: events.map(e => ({
+                events: events.map((e) => ({
                     timestamp: e.timestamp,
                     category: e.category,
                     eventType: e.eventType,
@@ -121,13 +119,13 @@ export class TraceToolHandlers {
                     lineNumber: e.lineNumber,
                 })),
                 debuggerState: {
-                    recentEvents: debuggerEventsResult.rows.map(row => this.rowToObject(debuggerEventsResult.columns, row)),
+                    recentEvents: debuggerEventsResult.rows.map((row) => this.rowToObject(debuggerEventsResult.columns, row)),
                 },
                 memoryState: {
-                    addressValues: memoryStateResult.rows.map(row => this.rowToObject(memoryStateResult.columns, row)),
+                    addressValues: memoryStateResult.rows.map((row) => this.rowToObject(memoryStateResult.columns, row)),
                 },
                 networkState: {
-                    completedRequests: networkResult.rows.map(row => this.rowToObject(networkResult.columns, row)),
+                    completedRequests: networkResult.rows.map((row) => this.rowToObject(networkResult.columns, row)),
                 },
                 nearestHeapSnapshot: snapshotResult.rows.length > 0
                     ? this.rowToObject(snapshotResult.columns, snapshotResult.rows[0])
@@ -225,7 +223,7 @@ export class TraceToolHandlers {
             const allEvents = db.query('SELECT timestamp, category, event_type, data, script_id, line_number FROM events ORDER BY timestamp ASC');
             const PAIRED_BEGIN = new Set(['Debugger.paused']);
             const PAIRED_END = new Set(['Debugger.resumed']);
-            const traceEvents = allEvents.rows.map(row => {
+            const traceEvents = allEvents.rows.map((row) => {
                 const ts = row[0] * 1000;
                 const cat = row[1];
                 const name = row[2];

package/dist/src/server/domains/trace/index.d.ts

@@ -1 +1,2 @@
-export { TraceToolHandlers } from '../../domains/trace/handlers.js';
+export * from './definitions.tools.js';
+export { TraceToolHandlers } from './handlers.js';

package/dist/src/server/domains/trace/index.js

@@ -1 +1,2 @@
-export { TraceToolHandlers } from '../../domains/trace/handlers.js';
+export * from './definitions.tools.js';
+export { TraceToolHandlers } from './handlers.js';

package/dist/src/server/domains/trace/manifest.js

@@ -38,11 +38,23 @@ const manifest = {
         hint: 'Start recording → perform actions → stop recording → summarize/query/seek/diff/export',
     },
     registrations: [
-        { tool: t('start_trace_recording'), domain: DOMAIN, bind: b((h, a) => h.handleStartTraceRecording(a)) },
-        { tool: t('stop_trace_recording'), domain: DOMAIN, bind: b((h) => h.handleStopTraceRecording()) },
+        {
+            tool: t('start_trace_recording'),
+            domain: DOMAIN,
+            bind: b((h, a) => h.handleStartTraceRecording(a)),
+        },
+        {
+            tool: t('stop_trace_recording'),
+            domain: DOMAIN,
+            bind: b((h) => h.handleStopTraceRecording()),
+        },
         { tool: t('query_trace_sql'), domain: DOMAIN, bind: b((h, a) => h.handleQueryTraceSql(a)) },
         { tool: t('seek_to_timestamp'), domain: DOMAIN, bind: b((h, a) => h.handleSeekToTimestamp(a)) },
-        { tool: t('diff_heap_snapshots'), domain: DOMAIN, bind: b((h, a) => h.handleDiffHeapSnapshots(a)) },
+        {
+            tool: t('diff_heap_snapshots'),
+            domain: DOMAIN,
+            bind: b((h, a) => h.handleDiffHeapSnapshots(a)),
+        },
         { tool: t('export_trace'), domain: DOMAIN, bind: b((h, a) => h.handleExportTrace(a)) },
         { tool: t('summarize_trace'), domain: DOMAIN, bind: b((h, a) => h.handleSummarizeTrace(a)) },
     ],

package/dist/src/server/domains/transform/definitions.js

@@ -1,212 +1,52 @@
+import { tool } from '../../registry/tool-builder.js';
+const transformsEnum = [
+    'constant_fold',
+    'string_decrypt',
+    'dead_code_remove',
+    'control_flow_flatten',
+    'rename_vars',
+];
 export const transformTools = [
-    {
-        name: 'ast_transform_preview',
-        description: 'Preview lightweight AST-like transforms (string/regex based) and return before/after diff.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                code: {
-                    type: 'string',
-                    description: 'Source code to transform.',
-                },
-                transforms: {
-                    type: 'array',
-                    description: 'Ordered transform list.',
-                    items: {
-                        type: 'string',
-                        enum: [
-                            'constant_fold',
-                            'string_decrypt',
-                            'dead_code_remove',
-                            'control_flow_flatten',
-                            'rename_vars',
-                        ],
-                    },
-                },
-                preview: {
-                    type: 'boolean',
-                    description: 'Whether to generate line diff output.',
-                    default: true,
-                },
-            },
-            required: ['code', 'transforms'],
-        },
-        annotations: {
-            readOnlyHint: false,
-            destructiveHint: false,
-            idempotentHint: false,
-            openWorldHint: false,
-        },
-    },
-    {
-        name: 'ast_transform_chain',
-        description: 'Create and store an in-memory transform chain.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                name: {
-                    type: 'string',
-                    description: 'Chain name.',
-                },
-                transforms: {
-                    type: 'array',
-                    description: 'Ordered transform list.',
-                    items: {
-                        type: 'string',
-                        enum: [
-                            'constant_fold',
-                            'string_decrypt',
-                            'dead_code_remove',
-                            'control_flow_flatten',
-                            'rename_vars',
-                        ],
-                    },
-                },
-                description: {
-                    type: 'string',
-                    description: 'Optional chain description.',
-                },
-            },
-            required: ['name', 'transforms'],
-        },
-        annotations: {
-            readOnlyHint: false,
-            destructiveHint: false,
-            idempotentHint: false,
-            openWorldHint: false,
-        },
-    },
-    {
-        name: 'ast_transform_apply',
-        description: 'Apply transforms to input code or a live page scriptId.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                scriptId: {
-                    type: 'string',
-                    description: 'Target script ID from page debugger context.',
-                },
-                code: {
-                    type: 'string',
-                    description: 'Direct source code input.',
-                },
-                chainName: {
-                    type: 'string',
-                    description: 'Use a saved transform chain by name.',
-                },
-                transforms: {
-                    type: 'array',
-                    description: 'Direct transform list (used when chainName is not provided).',
-                    items: {
-                        type: 'string',
-                        enum: [
-                            'constant_fold',
-                            'string_decrypt',
-                            'dead_code_remove',
-                            'control_flow_flatten',
-                            'rename_vars',
-                        ],
-                    },
-                },
-            },
-            required: [],
-        },
-        annotations: {
-            readOnlyHint: false,
-            destructiveHint: false,
-            idempotentHint: false,
-            openWorldHint: false,
-        },
-    },
-    {
-        name: 'crypto_extract_standalone',
-        description: 'Extract crypto/sign/encrypt function from current page and generate standalone runnable code.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                targetFunction: {
-                    type: 'string',
-                    description: 'Target function name/path, e.g. "window.sign".',
-                },
-                includePolyfills: {
-                    type: 'boolean',
-                    description: 'Include minimal runtime polyfills.',
-                    default: true,
-                },
-            },
-            required: ['targetFunction'],
-        },
-        annotations: {
-            readOnlyHint: false,
-            destructiveHint: false,
-            idempotentHint: false,
-            openWorldHint: false,
-        },
-    },
-    {
-        name: 'crypto_test_harness',
-        description: 'Run extracted crypto code in worker_threads + vm sandbox and return deterministic test results.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                code: {
-                    type: 'string',
-                    description: 'Standalone function code.',
-                },
-                functionName: {
-                    type: 'string',
-                    description: 'Exported function name to execute.',
-                },
-                testInputs: {
-                    type: 'array',
-                    description: 'Input list for test execution.',
-                    items: {
-                        type: 'string',
-                    },
-                },
-            },
-            required: ['code', 'functionName', 'testInputs'],
-        },
-        annotations: {
-            readOnlyHint: false,
-            destructiveHint: false,
-            idempotentHint: false,
-            openWorldHint: false,
-        },
-    },
-    {
-        name: 'crypto_compare',
-        description: 'Compare two crypto implementations against identical test vectors.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                code1: {
-                    type: 'string',
-                    description: 'Implementation A code.',
-                },
-                code2: {
-                    type: 'string',
-                    description: 'Implementation B code.',
-                },
-                functionName: {
-                    type: 'string',
-                    description: 'Function name shared by both implementations.',
-                },
-                testInputs: {
-                    type: 'array',
-                    description: 'Input list for comparison.',
-                    items: {
-                        type: 'string',
-                    },
-                },
-            },
-            required: ['code1', 'code2', 'functionName', 'testInputs'],
-        },
-        annotations: {
-            readOnlyHint: false,
-            destructiveHint: false,
-            idempotentHint: false,
-            openWorldHint: false,
-        },
-    },
+    tool('ast_transform_preview')
+        .desc('Preview lightweight AST-like transforms (string/regex based) and return before/after diff.')
+        .string('code', 'Source code to transform.')
+        .array('transforms', { type: 'string', enum: transformsEnum }, 'Ordered transform list.')
+        .boolean('preview', 'Whether to generate line diff output.', { default: true })
+        .required('code', 'transforms')
+        .build(),
+    tool('ast_transform_chain')
+        .desc('Create and store an in-memory transform chain.')
+        .string('name', 'Chain name.')
+        .array('transforms', { type: 'string', enum: transformsEnum }, 'Ordered transform list.')
+        .string('description', 'Optional chain description.')
+        .required('name', 'transforms')
+        .build(),
+    tool('ast_transform_apply')
+        .desc('Apply transforms to input code or a live page scriptId.')
+        .string('scriptId', 'Target script ID from page debugger context.')
+        .string('code', 'Direct source code input.')
+        .string('chainName', 'Use a saved transform chain by name.')
+        .array('transforms', { type: 'string', enum: transformsEnum }, 'Direct transform list (used when chainName is not provided).')
+        .build(),
+    tool('crypto_extract_standalone')
+        .desc('Extract crypto/sign/encrypt function from current page and generate standalone runnable code.')
+        .string('targetFunction', 'Target function name/path, e.g. "window.sign".')
+        .boolean('includePolyfills', 'Include minimal runtime polyfills.', { default: true })
+        .required('targetFunction')
+        .build(),
+    tool('crypto_test_harness')
+        .desc('Run extracted crypto code in worker_threads + vm sandbox and return deterministic test results.')
+        .string('code', 'Standalone function code.')
+        .string('functionName', 'Exported function name to execute.')
+        .array('testInputs', { type: 'string' }, 'Input list for test execution.')
+        .required('code', 'functionName', 'testInputs')
+        .build(),
+    tool('crypto_compare')
+        .desc('Compare two crypto implementations against identical test vectors.')
+        .string('code1', 'Implementation A code.')
+        .string('code2', 'Implementation B code.')
+        .string('functionName', 'Function name shared by both implementations.')
+        .array('testInputs', { type: 'string' }, 'Input list for comparison.')
+        .required('code1', 'code2', 'functionName', 'testInputs')
+        .build(),
 ];