@atrib/attest 0.0.0

package/dist/local-substrate-host.js

@@ -0,0 +1,467 @@
+#!/usr/bin/env node
+// SPDX-License-Identifier: Apache-2.0
+// Host-owned local substrate coordinator entrypoint.
+//
+// This is a supervised local process, not an MCP server. It reuses the
+// existing @atrib/emit key resolver so the coordinator signs under the same
+// creator identity as emit and the wrapper.
+import { LOCAL_SUBSTRATE_HARNESS_CLASSES, LOCAL_SUBSTRATE_NODE_DEFAULT_HOST, LOCAL_SUBSTRATE_NODE_DEFAULT_MAX_BODY_BYTES, LOCAL_SUBSTRATE_NODE_DEFAULT_PORT, base64urlEncode, bindLocalSubstrateCoordinatorNodeServer, createInProcessLocalSubstrateCoordinator, } from '@atrib/mcp';
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { resolveKey } from './keys.js';
+const DEFAULT_SHUTDOWN_TIMEOUT_MS = 2000;
+const supportedHarnessClasses = new Set(LOCAL_SUBSTRATE_HARNESS_CLASSES);
+function parseArgs(argv, env = process.env) {
+    const out = {
+        showVersion: false,
+        showHelp: false,
+        showDescribe: false,
+        jsonOutput: false,
+    };
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === '--version' || a === '-v') {
+            out.showVersion = true;
+            continue;
+        }
+        if (a === '--help' || a === '-h') {
+            out.showHelp = true;
+            continue;
+        }
+        if (a === '--describe') {
+            out.showDescribe = true;
+            continue;
+        }
+        if (a === '--json') {
+            out.jsonOutput = true;
+            continue;
+        }
+        if (a === '--host') {
+            out.host = requireValue(argv, ++i, '--host');
+            continue;
+        }
+        if (a === '--port') {
+            out.port = parsePort(requireValue(argv, ++i, '--port'), '--port');
+            continue;
+        }
+        if (a === '--max-body-bytes') {
+            out.maxBodyBytes = parsePositiveInt(requireValue(argv, ++i, '--max-body-bytes'), '--max-body-bytes');
+            continue;
+        }
+        if (a === '--log-endpoint') {
+            out.logEndpoint = requireValue(argv, ++i, '--log-endpoint');
+            continue;
+        }
+        if (a === '--log-submission') {
+            out.logSubmission = parseLogSubmission(requireValue(argv, ++i, '--log-submission'));
+            continue;
+        }
+        if (a === '--harness-classes') {
+            out.harnessClasses = parseHarnessClasses(requireValue(argv, ++i, '--harness-classes'));
+            continue;
+        }
+        if (a === '--shutdown-timeout-ms') {
+            out.shutdownTimeoutMs = parsePositiveInt(requireValue(argv, ++i, '--shutdown-timeout-ms'), '--shutdown-timeout-ms');
+            continue;
+        }
+        throw new Error(`unknown argument: ${a}`);
+    }
+    out.host = out.host ?? parseOptionalString(env['ATRIB_LOCAL_SUBSTRATE_HOST']);
+    out.port =
+        out.port ?? parseOptionalPort(env['ATRIB_LOCAL_SUBSTRATE_PORT'], 'ATRIB_LOCAL_SUBSTRATE_PORT');
+    out.maxBodyBytes =
+        out.maxBodyBytes ??
+            parseOptionalPositiveInt(env['ATRIB_LOCAL_SUBSTRATE_MAX_BODY_BYTES'], 'ATRIB_LOCAL_SUBSTRATE_MAX_BODY_BYTES');
+    out.logEndpoint = out.logEndpoint ?? parseOptionalString(env['ATRIB_LOG_ENDPOINT']);
+    out.logSubmission =
+        out.logSubmission ?? parseOptionalLogSubmission(env['ATRIB_LOCAL_SUBSTRATE_LOG_SUBMISSION']);
+    out.harnessClasses =
+        out.harnessClasses ?? parseOptionalHarnessClasses(env['ATRIB_LOCAL_SUBSTRATE_HARNESS_CLASSES']);
+    out.shutdownTimeoutMs =
+        out.shutdownTimeoutMs ??
+            parseOptionalPositiveInt(env['ATRIB_LOCAL_SUBSTRATE_SHUTDOWN_TIMEOUT_MS'], 'ATRIB_LOCAL_SUBSTRATE_SHUTDOWN_TIMEOUT_MS');
+    return out;
+}
+function requireValue(argv, index, flag) {
+    const value = argv[index];
+    if (value === undefined)
+        throw new Error(`${flag} requires a value`);
+    return value;
+}
+function parseOptionalString(raw) {
+    return raw === undefined || raw.trim() === '' ? undefined : raw;
+}
+function parsePort(raw, name) {
+    const n = Number(raw);
+    if (!Number.isInteger(n) || n < 0 || n > 65_535) {
+        throw new Error(`${name} must be an integer from 0 to 65535`);
+    }
+    return n;
+}
+function parseOptionalPort(raw, name) {
+    return raw === undefined || raw.trim() === '' ? undefined : parsePort(raw, name);
+}
+function parsePositiveInt(raw, name) {
+    const n = Number(raw);
+    if (!Number.isInteger(n) || n <= 0) {
+        throw new Error(`${name} must be a positive integer`);
+    }
+    return n;
+}
+function parseOptionalPositiveInt(raw, name) {
+    return raw === undefined || raw.trim() === '' ? undefined : parsePositiveInt(raw, name);
+}
+function parseLogSubmission(raw) {
+    if (raw === 'enabled' || raw === 'disabled')
+        return raw;
+    throw new Error('--log-submission must be enabled or disabled');
+}
+function parseOptionalLogSubmission(raw) {
+    return raw === undefined || raw.trim() === '' ? undefined : parseLogSubmission(raw);
+}
+function parseHarnessClasses(raw) {
+    const values = raw
+        .split(',')
+        .map((value) => value.trim())
+        .filter((value) => value.length > 0);
+    if (values.length === 0) {
+        throw new Error('harness classes must include at least one value');
+    }
+    for (const value of values) {
+        if (!supportedHarnessClasses.has(value)) {
+            throw new Error(`unsupported harness class ${value}; expected one of ${LOCAL_SUBSTRATE_HARNESS_CLASSES.join(', ')}`);
+        }
+    }
+    return [...new Set(values)];
+}
+function parseOptionalHarnessClasses(raw) {
+    return raw === undefined || raw.trim() === '' ? undefined : parseHarnessClasses(raw);
+}
+function readPackageVersion() {
+    try {
+        const here = dirname(fileURLToPath(import.meta.url));
+        const pkgPath = join(here, '..', 'package.json');
+        const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+        return pkg.version ?? 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+}
+function printHelp() {
+    process.stderr.write(`atrib-local-substrate ${readPackageVersion()}
+Run the host-owned P042 local substrate coordinator over loopback HTTP.
+
+USAGE
+  atrib-local-substrate [--json] [--host <host>] [--port <n>]
+  atrib-local-substrate --describe
+  atrib-local-substrate --version | --help
+
+OPTIONS
+  --host <host>              Bind host. Defaults to 127.0.0.1.
+  --port <n>                 Bind port. Defaults to 8787. Use 0 in tests.
+  --max-body-bytes <n>       Request body cap. Defaults to 1048576.
+  --log-endpoint <url>       Override ATRIB_LOG_ENDPOINT.
+  --log-submission <mode>    enabled or disabled. Defaults to enabled.
+  --harness-classes <csv>    startup-spawn,long-lived-agent,watcher-wal by default.
+  --shutdown-timeout-ms <n>  Best-effort flush bound on SIGTERM/SIGINT. Defaults to 2000.
+  --json                     Write the ready event as JSON on stdout.
+  --describe                 Emit a JSON description of this host binary.
+  --version                  Print package version.
+  --help                     Print this help.
+`);
+}
+function buildDescription() {
+    return {
+        name: 'atrib-local-substrate',
+        version: readPackageVersion(),
+        description: 'Host-owned local substrate coordinator for P042. It signs exact unsigned record bodies through @atrib/mcp and exposes POST /atrib/local-substrate plus health probes over loopback HTTP.',
+        options: [
+            { flag: '--host', takes_value: true, description: 'Bind host. Defaults to 127.0.0.1.' },
+            { flag: '--port', takes_value: true, description: 'Bind port. Defaults to 8787.' },
+            {
+                flag: '--max-body-bytes',
+                takes_value: true,
+                description: 'Maximum request body size in bytes.',
+            },
+            { flag: '--log-endpoint', takes_value: true, description: 'Override ATRIB_LOG_ENDPOINT.' },
+            {
+                flag: '--log-submission',
+                takes_value: true,
+                description: 'enabled or disabled. Disable only for tests and local proofs.',
+            },
+            {
+                flag: '--harness-classes',
+                takes_value: true,
+                description: 'Comma-separated supported harness classes.',
+            },
+            {
+                flag: '--shutdown-timeout-ms',
+                takes_value: true,
+                description: 'Best-effort flush bound on shutdown.',
+            },
+            { flag: '--json', takes_value: false, description: 'Write the ready event as JSON.' },
+        ],
+        env_vars: [
+            {
+                name: 'ATRIB_PRIVATE_KEY',
+                description: 'base64url Ed25519 32-byte seed. First key source tried.',
+                required: false,
+            },
+            {
+                name: 'ATRIB_KEY_FILE',
+                description: 'Path to a file containing the seed. Second key source.',
+                required: false,
+            },
+            {
+                name: 'ATRIB_AGENT',
+                description: 'Agent label used for the agent-scoped Keychain service.',
+                required: false,
+            },
+            {
+                name: 'ATRIB_LOCAL_SUBSTRATE_HOST',
+                description: 'Bind host override.',
+                required: false,
+            },
+            {
+                name: 'ATRIB_LOCAL_SUBSTRATE_PORT',
+                description: 'Bind port override.',
+                required: false,
+            },
+            {
+                name: 'ATRIB_LOCAL_SUBSTRATE_HARNESS_CLASSES',
+                description: 'Comma-separated harness classes the host accepts.',
+                required: false,
+            },
+            {
+                name: 'ATRIB_LOCAL_SUBSTRATE_LOG_SUBMISSION',
+                description: 'enabled or disabled. Defaults to enabled.',
+                required: false,
+            },
+        ],
+    };
+}
+function keyScope(key) {
+    if (key.source === 'keychain' && key.keychainService)
+        return `keychain:${key.keychainService}`;
+    return key.source;
+}
+async function startLocalSubstrateHost(options) {
+    const harnessClasses = options.harnessClasses ?? [...LOCAL_SUBSTRATE_HARNESS_CLASSES];
+    const coordinator = createInProcessLocalSubstrateCoordinator({
+        creatorKey: base64urlEncode(options.key.privateKey),
+        supportedHarnessClasses: harnessClasses,
+        ...(options.logEndpoint !== undefined ? { logEndpoint: options.logEndpoint } : {}),
+        ...(options.logSubmission !== undefined ? { logSubmission: options.logSubmission } : {}),
+        health: {
+            pid: process.pid,
+            version: readPackageVersion(),
+            transport: 'node-http',
+            creatorKeyScope: keyScope(options.key),
+            activeWrappers: 0,
+            staleChildren: 0,
+        },
+    });
+    let server;
+    try {
+        server = await bindLocalSubstrateCoordinatorNodeServer(coordinator, {
+            host: options.host ?? LOCAL_SUBSTRATE_NODE_DEFAULT_HOST,
+            port: options.port ?? LOCAL_SUBSTRATE_NODE_DEFAULT_PORT,
+            maxBodyBytes: options.maxBodyBytes ?? LOCAL_SUBSTRATE_NODE_DEFAULT_MAX_BODY_BYTES,
+        });
+    }
+    catch (error) {
+        coordinator.destroy();
+        throw error;
+    }
+    let closed = false;
+    const close = async () => {
+        if (closed)
+            return;
+        closed = true;
+        await server.close();
+        await withTimeout(coordinator.flush(), options.shutdownTimeoutMs ?? DEFAULT_SHUTDOWN_TIMEOUT_MS).catch(() => undefined);
+        coordinator.destroy();
+    };
+    return { coordinator, server, close };
+}
+async function withTimeout(promise, timeoutMs) {
+    let timer;
+    try {
+        return await Promise.race([
+            promise,
+            new Promise((_, reject) => {
+                timer = setTimeout(() => reject(new Error(`timed out after ${timeoutMs}ms`)), timeoutMs);
+            }),
+        ]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
+function writeReady(handle, jsonOutput) {
+    const event = {
+        event: 'ready',
+        name: 'atrib-local-substrate',
+        version: readPackageVersion(),
+        pid: process.pid,
+        url: handle.server.url,
+        endpoint: handle.server.endpoint,
+        health_endpoint: handle.server.healthEndpoint,
+    };
+    if (jsonOutput) {
+        process.stdout.write(`${JSON.stringify(event)}\n`);
+    }
+    else {
+        process.stderr.write(`atrib-local-substrate: listening at ${event.endpoint} (health ${event.health_endpoint})\n`);
+    }
+}
+/**
+ * Resolve the signing key, polling with exponential backoff instead of failing
+ * on the first miss.
+ *
+ * A login-managed host can start before the login Keychain is unlocked, so the
+ * first resolveKey() returns null. Exiting there makes the process crash-loop
+ * under a KeepAlive supervisor, and any dependent that waits on the substrate
+ * hangs. Instead we stay alive and retry until the Keychain unlocks and the key
+ * resolves, so a reboot self-heals with no manual restart.
+ *
+ * Returns null only when a finite ATRIB_KEY_RETRY_MAX_MS budget is exhausted
+ * (default 0 = wait indefinitely), preserving an explicit-failure escape hatch.
+ */
+export async function resolveSigningKeyWithRetry(options = {}) {
+    const resolve = options.resolve ?? resolveKey;
+    const initialDelayMs = options.initialDelayMs ?? 2_000;
+    const maxDelayMs = Math.max(options.maxDelayMs ?? 30_000, initialDelayMs);
+    const maxWaitMs = options.maxWaitMs ?? 0;
+    const now = options.now ?? (() => Date.now());
+    const sleep = options.sleep ??
+        ((ms) => new Promise((resolveSleep) => setTimeout(resolveSleep, ms)));
+    const log = options.log ?? ((message) => void process.stderr.write(message));
+    const startedAt = now();
+    let attempt = 0;
+    let delay = initialDelayMs;
+    for (;;) {
+        attempt += 1;
+        let key = null;
+        try {
+            key = await resolve();
+        }
+        catch (error) {
+            // A throw here (e.g. a transient ATRIB_KEY_FILE read) is treated like a
+            // miss and retried, but logged each time so a genuine misconfiguration
+            // stays visible instead of silently looping.
+            log(`atrib-local-substrate: key resolution error on attempt ${attempt}: ${error instanceof Error ? error.message : String(error)}\n`);
+        }
+        if (key) {
+            if (attempt > 1) {
+                const waitedSec = Math.round((now() - startedAt) / 1_000);
+                log(`atrib-local-substrate: signing key resolved after ${attempt} attempts (~${waitedSec}s)\n`);
+            }
+            return key;
+        }
+        if (maxWaitMs > 0 && now() - startedAt >= maxWaitMs)
+            return null;
+        if (attempt === 1) {
+            log('atrib-local-substrate: no signing key yet (the login Keychain may be locked at boot); ' +
+                'waiting and retrying with backoff. Set ATRIB_KEY_RETRY_MAX_MS to cap the wait.\n');
+        }
+        await sleep(delay);
+        delay = Math.min(delay * 2, maxDelayMs);
+    }
+}
+function keyRetryOptionsFromEnv() {
+    const options = {};
+    const initial = parseOptionalPositiveInt(process.env['ATRIB_KEY_RETRY_INTERVAL_MS'], 'ATRIB_KEY_RETRY_INTERVAL_MS');
+    if (initial !== undefined)
+        options.initialDelayMs = initial;
+    const maxDelay = parseOptionalPositiveInt(process.env['ATRIB_KEY_RETRY_MAX_INTERVAL_MS'], 'ATRIB_KEY_RETRY_MAX_INTERVAL_MS');
+    if (maxDelay !== undefined)
+        options.maxDelayMs = maxDelay;
+    const maxWaitRaw = process.env['ATRIB_KEY_RETRY_MAX_MS'];
+    if (maxWaitRaw !== undefined && maxWaitRaw.trim() !== '') {
+        const n = Number(maxWaitRaw);
+        if (!Number.isInteger(n) || n < 0) {
+            throw new Error('ATRIB_KEY_RETRY_MAX_MS must be a non-negative integer');
+        }
+        options.maxWaitMs = n;
+    }
+    return options;
+}
+async function main() {
+    let args;
+    try {
+        args = parseArgs(process.argv.slice(2));
+    }
+    catch (error) {
+        process.stderr.write(`atrib-local-substrate: ${error instanceof Error ? error.message : String(error)}\n`);
+        process.exit(1);
+    }
+    if (args.showVersion) {
+        process.stdout.write(`${readPackageVersion()}\n`);
+        return;
+    }
+    if (args.showHelp) {
+        printHelp();
+        return;
+    }
+    if (args.showDescribe) {
+        process.stdout.write(`${JSON.stringify(buildDescription(), null, 2)}\n`);
+        return;
+    }
+    const key = await resolveSigningKeyWithRetry(keyRetryOptionsFromEnv());
+    if (!key) {
+        process.stderr.write('atrib-local-substrate: no signing key resolved within ATRIB_KEY_RETRY_MAX_MS; set ATRIB_PRIVATE_KEY, ATRIB_KEY_FILE, or an atrib Keychain entry\n');
+        process.exit(1);
+    }
+    const handle = await startLocalSubstrateHost({
+        key,
+        ...(args.host !== undefined ? { host: args.host } : {}),
+        ...(args.port !== undefined ? { port: args.port } : {}),
+        ...(args.maxBodyBytes !== undefined ? { maxBodyBytes: args.maxBodyBytes } : {}),
+        ...(args.logEndpoint !== undefined ? { logEndpoint: args.logEndpoint } : {}),
+        ...(args.logSubmission !== undefined ? { logSubmission: args.logSubmission } : {}),
+        ...(args.harnessClasses !== undefined ? { harnessClasses: args.harnessClasses } : {}),
+        ...(args.shutdownTimeoutMs !== undefined ? { shutdownTimeoutMs: args.shutdownTimeoutMs } : {}),
+    });
+    writeReady(handle, args.jsonOutput);
+    let shuttingDown = false;
+    const shutdown = (signal) => {
+        if (shuttingDown)
+            return;
+        shuttingDown = true;
+        process.stderr.write(`atrib-local-substrate: received ${signal}, shutting down\n`);
+        handle
+            .close()
+            .then(() => process.exit(0))
+            .catch((error) => {
+            process.stderr.write(`atrib-local-substrate: shutdown error ${error instanceof Error ? error.message : String(error)}\n`);
+            process.exit(1);
+        });
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+    main().catch((error) => {
+        process.stderr.write(`atrib-local-substrate: fatal ${error instanceof Error ? (error.stack ?? error.message) : String(error)}\n`);
+        process.exit(1);
+    });
+}
+export const __test_only__ = {
+    buildDescription,
+    parseArgs,
+    startLocalSubstrateHost,
+    resolveSigningKeyWithRetry,
+};
+/**
+ * Run the local-substrate host entrypoint. Exists so forwarding bins (the
+ * @atrib/emit shim's `atrib-local-substrate`) can invoke the host without
+ * relying on the entrypoint guard above, which only fires when this file
+ * itself is process.argv[1].
+ */
+export async function runLocalSubstrateHost() {
+    return main();
+}

package/dist/main.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/main.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+// atrib-attest standalone binary. Serves the write-verb union (attest +
+// emit + atrib-annotate + atrib-revise) over a stdio transport so it can be
+// launched as a subprocess by an MCP host (Claude Code, Claude Desktop,
+// etc.). All four names dispatch to one handleEmit funnel; records are
+// byte-identical regardless of which name signed them.
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { createAtribAttestServer } from './index.js';
+async function main() {
+    const { mcp } = await createAtribAttestServer();
+    const transport = new StdioServerTransport();
+    await mcp.connect(transport);
+    // Stays alive on the stdio transport until the host closes it.
+}
+main().catch((e) => {
+    console.error('atrib-attest: fatal', e instanceof Error ? e.stack ?? e.message : String(e));
+    process.exit(1);
+});

package/dist/reference-resolution.d.ts

@@ -0,0 +1,12 @@
+import { defaultRecordReferenceResolver as sharedDefaultRecordReferenceResolver, type RecordReferenceResolution } from '@atrib/mcp';
+export type RecordReferenceResolver = (recordHash: string) => RecordReferenceResolution | Promise<RecordReferenceResolution>;
+interface FilterResolvableInformedByOptions {
+    allowUnresolved?: boolean | undefined;
+    resolver?: RecordReferenceResolver | undefined;
+    logEndpoint?: string | undefined;
+    warnings: string[];
+}
+export declare const defaultRecordReferenceResolver: typeof sharedDefaultRecordReferenceResolver;
+export declare function filterResolvableInformedBy(refs: string[] | undefined, options: FilterResolvableInformedByOptions): Promise<string[] | undefined>;
+export declare function clearRecordReferenceResolverCacheForTests(): void;
+export {};

package/dist/reference-resolution.js

@@ -0,0 +1,31 @@
+import { clearRecordReferenceResolverCacheForTests as clearSharedRecordReferenceResolverCacheForTests, defaultRecordReferenceResolver as sharedDefaultRecordReferenceResolver, } from '@atrib/mcp';
+export const defaultRecordReferenceResolver = sharedDefaultRecordReferenceResolver;
+export async function filterResolvableInformedBy(refs, options) {
+    if (!refs || refs.length === 0)
+        return undefined;
+    const unique = [...new Set(refs)];
+    if (options.allowUnresolved)
+        return unique;
+    const kept = [];
+    const resolver = options.resolver ??
+        ((recordHash) => defaultRecordReferenceResolver(recordHash, options.logEndpoint));
+    for (const ref of unique) {
+        const resolution = await resolver(ref);
+        if (resolution === 'found') {
+            kept.push(ref);
+            continue;
+        }
+        if (resolution === 'unknown') {
+            options.warnings.push(`dropped unvalidated informed_by reference ${shortHash(ref)}; validation unavailable`);
+            continue;
+        }
+        options.warnings.push(`dropped unresolved informed_by reference ${shortHash(ref)}; not found in local mirrors or log lookup`);
+    }
+    return kept.length > 0 ? kept : undefined;
+}
+function shortHash(recordHash) {
+    return `${recordHash.slice(0, 19)}...${recordHash.slice(-8)}`;
+}
+export function clearRecordReferenceResolverCacheForTests() {
+    clearSharedRecordReferenceResolverCacheForTests();
+}

package/dist/revise.d.ts

@@ -0,0 +1,43 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import { type EmitLocalSubstrateShadowOptions, type WriteToolDeps } from './index.js';
+import { type ResolvedKey } from './keys.js';
+export declare const ReviseInput: z.ZodObject<{
+    revises: z.ZodString;
+    prior_position: z.ZodString;
+    new_position: z.ZodString;
+    reason: z.ZodString;
+    topics: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    context_id: z.ZodOptional<z.ZodString>;
+    informed_by: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export interface AtribReviseServer {
+    /** Underlying McpServer; expose for testing or composition. */
+    mcp: McpServer;
+    /** Drain pending submissions (for tests/shutdown). */
+    flush(): Promise<void>;
+}
+export interface CreateAtribReviseServerOptions {
+    /** Override the resolved key (primarily for testing). */
+    key?: ResolvedKey | null | undefined;
+    /** Override the log endpoint (defaults to env or @atrib/mcp default). */
+    logEndpoint?: string | undefined;
+    /**
+     * Optional long-lived-agent local substrate shadow probe. `undefined` reads
+     * opt-in env config; `false` disables env config for this server.
+     */
+    localSubstrate?: EmitLocalSubstrateShadowOptions | false | undefined;
+}
+/**
+ * Register the legacy `atrib-revise` tool. The handler call shape is
+ * unchanged from the standalone @atrib/revise server, so historical
+ * behavior is preserved exactly; only the mounting surface moved.
+ */
+export declare function registerReviseTool(mcp: McpServer, deps: WriteToolDeps): void;
+/**
+ * Wire up the legacy atrib-revise MCP server. Mounts `atrib-revise` plus
+ * `attest` (alias-window rule W1). The underlying signing pipeline is
+ * shared via handleEmit so revision records are byte-identical regardless
+ * of which tool produced them.
+ */
+export declare function createAtribReviseServer(options?: CreateAtribReviseServerOptions): Promise<AtribReviseServer>;