@atrib/attest 0.1.0 → 0.3.0

package/README.md

@@ -54,18 +54,20 @@ attest({
   provenance_token?: string,
   tool_name?: string,
   args_hash?: string,
+  args_salt?: string,            // base64url 16-byte salt; requires args_hash
   result_hash?: string,
+  result_salt?: string,          // base64url 16-byte salt; requires result_hash
   producer?: string,              // sidecar label override; defaults to 'atrib-attest'
 })
 ```
 
 ### Ref mapping
 
-| `ref` argument | Signed record | Signed field carried |
-| --- | --- | --- |
-| absent | observation | none |
-| `{ kind: "annotates", target, ... }` | annotation | signed `annotates` field |
-| `{ kind: "revises", target, reason, ... }` (`reason` required) | revision | signed `revises` field |
+| `ref` argument                                                 | Signed record | Signed field carried     |
+| -------------------------------------------------------------- | ------------- | ------------------------ |
+| absent                                                         | observation   | none                     |
+| `{ kind: "annotates", target, ... }`                           | annotation    | signed `annotates` field |
+| `{ kind: "revises", target, reason, ... }` (`reason` required) | revision      | signed `revises` field   |
 
 The three shapes route through the same `handleEmit` funnel used by the
 legacy tools. There is no separate signing path for `attest`: the ref
@@ -110,10 +112,10 @@ re-export shims.
 
 ```typescript
 import {
-  createAtribAttestServer,       // mounts the four-tool write union
-  createAtribEmitServer,          // legacy factory; also mounts attest
-  createAtribAnnotateServer,      // legacy factory; also mounts attest
-  createAtribReviseServer,        // legacy factory; also mounts attest
+  createAtribAttestServer, // mounts the four-tool write union
+  createAtribEmitServer, // legacy factory; also mounts attest
+  createAtribAnnotateServer, // legacy factory; also mounts attest
+  createAtribReviseServer, // legacy factory; also mounts attest
   handleAttest,
   attestInProcess,
 
@@ -123,7 +125,7 @@ import {
   EmitInput,
   resolveKey,
   emitSessionCheckpoint,
-} from "@atrib/attest";
+} from '@atrib/attest'
 ```
 
 Each legacy factory (`createAtribEmitServer`, `createAtribAnnotateServer`,
@@ -144,6 +146,12 @@ Environment variables are unchanged from the legacy emit surface:
 table with descriptions; the values and resolution order carried over
 unchanged.
 
+Programmatic callers can set `mirrorPath` and `autochainSource` in
+`EmitInProcessOptions`. `mirrorPath` selects the write target for one call.
+`autochainSource` selects its mirror-based chain inheritance source. When only
+`mirrorPath` is set, it is also the read source. Calls that omit both options
+retain the environment and per-agent default ladder above.
+
 ## Degradation and privacy
 
 atrib failures never affect the primary call ([spec §5.8](../../atrib-spec.md#58-degradation-contract)), and for the write
@@ -160,6 +168,11 @@ verb that contract is the most important thing to know:
   carries only the replay-checkable `args_hash` commitment over it. The
   public log stores the 90-byte commitment entry (record hash, creator key,
   context_id, timestamp, event_type byte), never the content.
+- **Salted direct commitments.** `args_salt` and `result_salt` let direct
+  attest callers carry the same salted commitment posture as middleware.
+  Each salt must be canonical base64url for exactly 16 bytes and requires its
+  matching explicit hash. The shared `@atrib/mcp` commitment helper computes
+  and verifies the bytes used by both paths.
 - **Refused writes are loud, not silent.** A malformed call (unknown
   `ref.kind`, missing revises reason, a `ref`/content contradiction, a
   provenance_token off genesis, or no resolvable signing key) returns

package/dist/attest.d.ts

@@ -24,7 +24,9 @@ export declare const AttestInput: z.ZodObject<{
     provenance_token: z.ZodOptional<z.ZodString>;
     tool_name: z.ZodOptional<z.ZodString>;
     args_hash: z.ZodOptional<z.ZodString>;
+    args_salt: z.ZodOptional<z.ZodString>;
     result_hash: z.ZodOptional<z.ZodString>;
+    result_salt: z.ZodOptional<z.ZodString>;
     producer: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type AttestInputT = z.infer<typeof AttestInput>;
@@ -46,7 +48,9 @@ export interface MappedAttestInput {
         revises?: string;
         tool_name?: string;
         args_hash?: string;
+        args_salt?: string;
         result_hash?: string;
+        result_salt?: string;
     };
 }
 export interface AttestMappingRefusal {

package/dist/attest.js

@@ -16,19 +16,29 @@
 // (matching what atrib-annotate / atrib-revise compose today), so the
 // D099 default args_hash commitment is byte-identical across both names.
 import { z } from 'zod';
-import { EVENT_TYPE_ANNOTATION_URI, EVENT_TYPE_REVISION_URI, SHA256_REF_PATTERN, } from '@atrib/mcp';
+import { EVENT_TYPE_ANNOTATION_URI, EVENT_TYPE_REVISION_URI, SHA256_REF_PATTERN } from '@atrib/mcp';
 const HEX_32_PATTERN = /^[0-9a-f]{32}$/;
 // 16 bytes encoded as base64url with no padding = 22 chars per spec §1.2.6.
 const PROVENANCE_TOKEN_PATTERN = /^[A-Za-z0-9_-]{22}$/;
 const OBSERVATION_URI = 'https://atrib.dev/v1/types/observation';
 export const AttestRef = z.object({
-    kind: z.enum(['annotates', 'revises']).describe("Declared-relationship kind. 'annotates' marks a past record's importance " +
+    kind: z
+        .enum(['annotates', 'revises'])
+        .describe("Declared-relationship kind. 'annotates' marks a past record's importance " +
         "and meaning (spec §1.2.7 / D058); 'revises' supersedes a prior position " +
         'with a stated reason (spec §1.2.9 / D059). Omit `ref` entirely for a ' +
         'plain observation.'),
-    target: z.string().regex(SHA256_REF_PATTERN).describe("'sha256:<64-hex>' record_hash the relationship points at. The target can " +
+    target: z
+        .string()
+        .regex(SHA256_REF_PATTERN)
+        .describe("'sha256:<64-hex>' record_hash the relationship points at. The target can " +
         "be any prior record (yours or another agent's)."),
-    reason: z.string().min(1).max(4096).optional().describe("Why the position changed. REQUIRED when kind is 'revises'; composed into " +
+    reason: z
+        .string()
+        .min(1)
+        .max(4096)
+        .optional()
+        .describe("Why the position changed. REQUIRED when kind is 'revises'; composed into " +
         'the content body exactly as atrib-revise composes it today.'),
 });
 export const AttestInput = z.object({
@@ -76,20 +86,29 @@ export const AttestInput = z.object({
     tool_name: z
         .string()
         .min(1)
-        .max(64)
         .optional()
-        .describe('Optional §8.2 tool_name disclosure, unchanged from the legacy emit tool.'),
+        .describe('Optional §8.2 tool_name disclosure. The 64-character cap applies only to opaque labels; hashed and verbatim forms follow §8.2.'),
     args_hash: z
         .string()
         .regex(SHA256_REF_PATTERN)
         .optional()
         .describe('Optional §8.3 args_hash commitment override. When omitted, attest signs ' +
         'sha256(JCS(content)) per D099, identical to the legacy write names.'),
+    args_salt: z
+        .string()
+        .regex(/^[A-Za-z0-9_-]{22}$/)
+        .optional()
+        .describe('Optional base64url 16-byte salt paired with args_hash per §8.3.'),
     result_hash: z
         .string()
         .regex(SHA256_REF_PATTERN)
         .optional()
         .describe('Optional §8.3 result_hash commitment, unchanged from the legacy emit tool.'),
+    result_salt: z
+        .string()
+        .regex(/^[A-Za-z0-9_-]{22}$/)
+        .optional()
+        .describe('Optional base64url 16-byte salt paired with result_hash per §8.3.'),
     producer: z
         .string()
         .min(1)
@@ -122,7 +141,9 @@ export function mapAttestInput(input) {
         ...(input.provenance_token ? { provenance_token: input.provenance_token } : {}),
         ...(input.tool_name ? { tool_name: input.tool_name } : {}),
         ...(input.args_hash ? { args_hash: input.args_hash } : {}),
+        ...(input.args_salt ? { args_salt: input.args_salt } : {}),
         ...(input.result_hash ? { result_hash: input.result_hash } : {}),
+        ...(input.result_salt ? { result_salt: input.result_salt } : {}),
     };
     if (!input.ref) {
         const conflict = contentRefConflicts(input.content, undefined);
@@ -185,7 +206,7 @@ function contentRefConflicts(content, ref) {
     if (!ref) {
         if (contentAnnotates !== undefined || contentRevises !== undefined) {
             return ('content carries a relationship field (annotates/revises) but no ref was declared; ' +
-                "declare ref: { kind, target } instead of embedding the relationship in content");
+                'declare ref: { kind, target } instead of embedding the relationship in content');
         }
         return null;
     }
@@ -205,9 +226,7 @@ function contentRefConflicts(content, ref) {
     if (contentRevises !== undefined && contentRevises !== ref.target) {
         return `content.revises (${String(contentRevises)}) contradicts ref.target (${ref.target})`;
     }
-    if (contentReason !== undefined &&
-        ref.reason !== undefined &&
-        contentReason !== ref.reason) {
+    if (contentReason !== undefined && ref.reason !== undefined && contentReason !== ref.reason) {
         return 'content.reason contradicts ref.reason';
     }
     return null;

package/dist/index.d.ts

@@ -3,6 +3,7 @@ import { z } from 'zod';
 import { type LocalSubstrateCoordinatorTransport, type LocalSubstrateDegradationPolicy, type LocalSubstrateHarnessClass, type LocalSubstrateProducer, type LocalSubstrateWalJoin, type ProofBundle, type SubmissionQueue, type TryLocalSubstrateCoordinatorResult } from '@atrib/mcp';
 import { type ResolvedKey } from './keys.js';
 import { type RecordReferenceResolver } from './reference-resolution.js';
+import { resolveMirrorWritePath } from './storage.js';
 import { type AttestInputT } from './attest.js';
 declare function keyResolveRetryMs(): number;
 export declare function requiresExplicitContextId(env?: NodeJS.ProcessEnv): boolean;
@@ -18,7 +19,9 @@ declare const EmitInput: z.ZodObject<{
     revises: z.ZodOptional<z.ZodString>;
     tool_name: z.ZodOptional<z.ZodString>;
     args_hash: z.ZodOptional<z.ZodString>;
+    args_salt: z.ZodOptional<z.ZodString>;
     result_hash: z.ZodOptional<z.ZodString>;
+    result_salt: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 type EmitSignedOutput = {
     signed: true;
@@ -183,6 +186,13 @@ interface HandleEmitInput {
      */
     producer?: string;
     logEndpoint?: string | undefined;
+    /** Explicit write target for this call. Falls back to ATRIB_MIRROR_FILE. */
+    mirrorPath?: string | undefined;
+    /**
+     * Explicit read source for mirror-based chain inheritance. When omitted,
+     * mirrorPath wins before the legacy environment and default path ladder.
+     */
+    autochainSource?: string | undefined;
     recordReferenceResolver?: RecordReferenceResolver | undefined;
     localSubstrate?: EmitLocalSubstrateShadowOptions | undefined;
     localSubstrateCommit?: EmitLocalSubstrateCommitOptions | undefined;
@@ -191,7 +201,7 @@ interface HandleEmitInput {
  * Build, sign, submit, mirror. Refused writes return `signed: false`;
  * signed degradations stay `signed: true` and surface in `warnings`.
  */
-declare function handleEmit({ input, key, queue, producer, logEndpoint, recordReferenceResolver, localSubstrate, localSubstrateCommit, }: HandleEmitInput): Promise<EmitOutput>;
+declare function handleEmit({ input, key, queue, producer, logEndpoint, mirrorPath, autochainSource, recordReferenceResolver, localSubstrate, localSubstrateCommit, }: HandleEmitInput): Promise<EmitOutput>;
 export declare function resolveEmitLocalSubstrateShadowFromEnv(options?: ResolveEmitLocalSubstrateShadowFromEnvOptions): EmitLocalSubstrateShadowOptions | undefined;
 export declare function resolveEmitLocalSubstrateCommitFromEnv(options?: ResolveEmitLocalSubstrateCommitFromEnvOptions): EmitLocalSubstrateCommitOptions | undefined;
 export interface EmitInProcessOptions {
@@ -208,6 +218,17 @@ export interface EmitInProcessOptions {
      * consumers can bucket records by emitter without inspecting envelopes.
      */
     producer?: string;
+    /**
+     * Explicit mirror write target for this call. When omitted,
+     * ATRIB_MIRROR_FILE and the per-agent default remain unchanged fallbacks.
+     */
+    mirrorPath?: string | undefined;
+    /**
+     * Explicit mirror read source for chain inheritance. When omitted, an
+     * explicit mirrorPath is also the read source before the environment
+     * fallback ladder.
+     */
+    autochainSource?: string | undefined;
     /**
      * Upper bound on the post-sign queue flush, in milliseconds. Default
      * 5000ms. The submission queue itself has a 30s retry budget against an
@@ -275,6 +296,8 @@ export interface HandleAttestInput {
     /** Sidecar label; defaults to 'atrib-attest'. input.producer wins. */
     producer?: string;
     logEndpoint?: string | undefined;
+    mirrorPath?: string | undefined;
+    autochainSource?: string | undefined;
     recordReferenceResolver?: RecordReferenceResolver | undefined;
     localSubstrate?: EmitLocalSubstrateShadowOptions | undefined;
     localSubstrateCommit?: EmitLocalSubstrateCommitOptions | undefined;
@@ -299,6 +322,7 @@ export declare const __test_only__: {
     keyResolveRetryMs: typeof keyResolveRetryMs;
 };
 export { handleEmit, EmitInput };
+export { resolveMirrorWritePath };
 export type { EmitOutput };
 export { resolveKey } from './keys.js';
 export type { ResolvedKey } from './keys.js';
@@ -308,5 +332,5 @@ export { AttestInput, AttestRef, mapAttestInput, isAttestMappingRefusal } from '
 export type { AttestInputT, MappedAttestInput, AttestMappingRefusal } from './attest.js';
 export { AnnotateInput, Importance, createAtribAnnotateServer, registerAnnotateTool, } from './annotate.js';
 export type { AtribAnnotateServer, CreateAtribAnnotateServerOptions } from './annotate.js';
-export { ReviseInput, createAtribReviseServer, registerReviseTool, } from './revise.js';
+export { ReviseInput, createAtribReviseServer, registerReviseTool } from './revise.js';
 export type { AtribReviseServer, CreateAtribReviseServerOptions } from './revise.js';

package/dist/index.js

@@ -17,14 +17,12 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { z } from 'zod';
 import { randomBytes } from 'node:crypto';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
 import { EVENT_TYPE_ANNOTATION_URI, EVENT_TYPE_REVISION_URI, LOCAL_SUBSTRATE_DEFAULT_TIMEOUT_MS, LOCAL_SUBSTRATE_REQUEST_SCHEMA, canonicalRecord, createHttpLocalSubstrateTransport, createSubmissionQueue, genesisChainRoot, hexEncode, inheritChainContext, isValidEventTypeUri, normalizeEventType, parentRecordHashFromEnv, resolveEnvContextId, SHA256_REF_PATTERN, sha256, tryLocalSubstrateCoordinator, } from '@atrib/mcp';
 import { resolveKey } from './keys.js';
 import { filterResolvableInformedBy } from './reference-resolution.js';
 import { buildAndSignEmitRecord } from './sign.js';
-import { mirrorRecord } from './storage.js';
-import { AttestInput, isAttestMappingRefusal, mapAttestInput, } from './attest.js';
+import { mirrorRecord, resolveMirrorWritePath } from './storage.js';
+import { AttestInput, isAttestMappingRefusal, mapAttestInput } from './attest.js';
 import { registerAnnotateTool } from './annotate.js';
 import { registerReviseTool } from './revise.js';
 // Read-side mirror inheritance: ATRIB_AUTOCHAIN_SOURCE points at the file
@@ -33,14 +31,16 @@ import { registerReviseTool } from './revise.js';
 // rarely useful as a read source, but kept for backward compatibility),
 // then to the per-agent default. Distinct from ATRIB_MIRROR_FILE which is
 // where emit's own records are persisted.
-function readMirrorPath() {
-    return (process.env['ATRIB_AUTOCHAIN_SOURCE'] ??
-        process.env['ATRIB_MIRROR_FILE'] ??
-        join(homedir(), '.atrib', 'records', `atrib-emit-${process.env['ATRIB_AGENT'] ?? 'claude-code'}.jsonl`));
+function readMirrorPath(options = {}) {
+    return (options.autochainSource ??
+        options.mirrorPath ??
+        process.env['ATRIB_AUTOCHAIN_SOURCE'] ??
+        resolveMirrorWritePath());
 }
 const HEX_32_PATTERN = /^[0-9a-f]{32}$/;
 // 16 bytes encoded as base64url with no padding = 22 chars per spec §1.2.6.
 const PROVENANCE_TOKEN_PATTERN = /^[A-Za-z0-9_-]{22}$/;
+const COMMITMENT_SALT_PATTERN = /^[A-Za-z0-9_-]{22}$/;
 const DEFAULT_KEY_RESOLVE_RETRY_MS = 30_000;
 const TRUE_ENV_VALUES = new Set(['1', 'true', 'yes', 'on']);
 function keyResolveRetryMs() {
@@ -126,10 +126,11 @@ const EmitInput = z.object({
     tool_name: z
         .string()
         .min(1)
-        .max(64)
         .optional()
         .describe('Optional §8.2 tool_name disclosure. Verbatim or transformed name (verbatim, opaque, ' +
-        'or hashed per §8.2). Lets emit-signed records carry the tool name for downstream ' +
+        'or hashed per §8.2). The 64-character cap applies only to opaque-label form; ' +
+        'the hashed form is sha256:<64 lowercase hex>, and verbatim names have no ' +
+        'protocol-wide length cap. Lets emit-signed records carry the tool name for downstream ' +
         'consumers (e.g. recall_my_attribution_history filtering by tool_name). Absence ' +
         'indicates the §8.1 default posture (no disclosure).'),
     args_hash: z
@@ -138,17 +139,24 @@ const EmitInput = z.object({
         .optional()
         .describe('Optional §8.3 args_hash commitment. Format: "sha256:" + 64 lowercase hex. Lets ' +
         'emit-signed records carry a commitment to canonical args bytes for downstream ' +
-        'consumers (e.g. recall filtering by args_hash, or replay detection). Salted vs ' +
-        'plain forms hash identically on the wire; the salt (when used) is carried in the ' +
-        'separate args_salt field, which this surface does not yet expose.'),
+        'consumers (e.g. recall filtering by args_hash, or replay detection).'),
+    args_salt: z
+        .string()
+        .regex(COMMITMENT_SALT_PATTERN)
+        .optional()
+        .describe('Optional base64url 16-byte salt paired with args_hash per §8.3.'),
     result_hash: z
         .string()
         .regex(SHA256_REF_PATTERN)
         .optional()
         .describe('Optional §8.3 result_hash commitment. Format: "sha256:" + 64 lowercase hex. Lets ' +
         'emit-signed records carry a commitment to canonical result bytes for downstream ' +
-        'consumers. Salted vs plain forms hash identically on the wire; the salt (when used) ' +
-        'is carried in the separate result_salt field, which this surface does not yet expose.'),
+        'consumers.'),
+    result_salt: z
+        .string()
+        .regex(COMMITMENT_SALT_PATTERN)
+        .optional()
+        .describe('Optional base64url 16-byte salt paired with result_hash per §8.3.'),
 });
 const DEFAULT_LOCAL_SUBSTRATE_DEGRADATION = {
     if_unavailable: 'sign locally in producer and continue without coordinator receipt',
@@ -212,7 +220,7 @@ export function registerEmitTool(mcp, deps) {
  */
 export function registerAttestTool(mcp, deps) {
     mcp.registerTool('attest', {
-        description: 'Make a signed statement now: atrib\'s write verb. Signs an observation by default; ' +
+        description: "Make a signed statement now: atrib's write verb. Signs an observation by default; " +
             'declare ref: { kind: "annotates", target } to mark a past record\'s importance, or ' +
             'ref: { kind: "revises", target, reason } to supersede a prior position. One handler ' +
             'behind the legacy emit / atrib-annotate / atrib-revise names; records are ' +
@@ -331,7 +339,7 @@ function createServerKeyResolver(options) {
  * Build, sign, submit, mirror. Refused writes return `signed: false`;
  * signed degradations stay `signed: true` and surface in `warnings`.
  */
-async function handleEmit({ input, key, queue, producer, logEndpoint, recordReferenceResolver, localSubstrate, localSubstrateCommit, }) {
+async function handleEmit({ input, key, queue, producer, logEndpoint, mirrorPath, autochainSource, recordReferenceResolver, localSubstrate, localSubstrateCommit, }) {
     const warnings = [];
     const eventType = normalizeEventType(input.event_type);
     if (!isValidEventTypeUri(eventType)) {
@@ -422,10 +430,14 @@ async function handleEmit({ input, key, queue, producer, logEndpoint, recordRefe
     // is the primary case that needs preserving; pre-fix this produced isolated
     // genesis records because atrib-emit's local resolver short-circuited on
     // caller context.
+    const autochainMirrorPath = readMirrorPath({ autochainSource, mirrorPath });
     const chain = await inheritChainContext({
         callerContextId,
         callerChainRoot: input.chain_root,
-        mirrorPath: readMirrorPath(),
+        mirrorPath: autochainMirrorPath,
+        ...((mirrorPath !== undefined || autochainSource !== undefined) && {
+            mirrorScope: 'file',
+        }),
         randomContextId,
     });
     const contextId = chain.contextId;
@@ -456,6 +468,9 @@ async function handleEmit({ input, key, queue, producer, logEndpoint, recordRefe
         allowUnresolved: input.allow_unresolved_informed_by,
         resolver: recordReferenceResolver,
         logEndpoint,
+        ...((mirrorPath !== undefined || autochainSource !== undefined) && {
+            localMirrorPaths: [resolveMirrorWritePath(mirrorPath), autochainMirrorPath],
+        }),
         warnings,
     });
     const effectiveInformedBy = validParentHash
@@ -475,11 +490,15 @@ async function handleEmit({ input, key, queue, producer, logEndpoint, recordRefe
             revises: input.revises,
             toolName: input.tool_name,
             argsHash: input.args_hash,
+            argsSalt: input.args_salt,
             resultHash: input.result_hash,
+            resultSalt: input.result_salt,
         });
     }
     catch (e) {
-        return refusalOutput(contextId, [`signing failed: ${e instanceof Error ? e.message : String(e)}`]);
+        return refusalOutput(contextId, [
+            `signing failed: ${e instanceof Error ? e.message : String(e)}`,
+        ]);
     }
     const recordHash = hashRecord(record);
     const unsignedRecordBody = unsignedRecordBodyFromSigned(record);
@@ -527,7 +546,7 @@ async function handleEmit({ input, key, queue, producer, logEndpoint, recordRefe
     await mirrorRecord(record, getProofFor(queue, recordHash) ?? null, {
         content: input.content,
         producer: producer ?? 'atrib-emit',
-    });
+    }, mirrorPath);
     // Try to read a proof if the queue submitted synchronously and the log
     // returned one within the same tick. Most submissions return null here
     // and the proof shows up on a later poll via getProof.
@@ -905,6 +924,8 @@ export async function emitInProcess(rawInput, options = {}) {
         queue,
         producer: options.producer,
         logEndpoint,
+        mirrorPath: options.mirrorPath,
+        autochainSource: options.autochainSource,
         recordReferenceResolver: options.recordReferenceResolver,
         localSubstrate: resolveLocalSubstrateOption(options.localSubstrate, {
             producer: options.producer ?? 'atrib-emit',
@@ -967,6 +988,8 @@ export async function handleAttest(args) {
         queue: args.queue,
         producer: args.input.producer ?? args.producer ?? 'atrib-attest',
         logEndpoint: args.logEndpoint,
+        mirrorPath: args.mirrorPath,
+        autochainSource: args.autochainSource,
         recordReferenceResolver: args.recordReferenceResolver,
         localSubstrate: args.localSubstrate,
         localSubstrateCommit: args.localSubstrateCommit,
@@ -1013,6 +1036,7 @@ export const __test_only__ = { createServerKeyResolver, handleEmit, keyResolveRe
 //
 // Stable as of @atrib/emit@0.8.0. Breaking changes here require a major bump.
 export { handleEmit, EmitInput };
+export { resolveMirrorWritePath };
 export { resolveKey } from './keys.js';
 // Session-checkpoint emission (§1.2.10 / D139): reads the ordered record
 // hashes for a context from the local mirror per §5.9 and emits the
@@ -1025,4 +1049,4 @@ export { AttestInput, AttestRef, mapAttestInput, isAttestMappingRefusal } from '
 // Legacy specialized writers, kept as permanent aliases over the attest
 // funnel. The @atrib/annotate and @atrib/revise packages re-export these.
 export { AnnotateInput, Importance, createAtribAnnotateServer, registerAnnotateTool, } from './annotate.js';
-export { ReviseInput, createAtribReviseServer, registerReviseTool, } from './revise.js';
+export { ReviseInput, createAtribReviseServer, registerReviseTool } from './revise.js';

package/dist/reference-resolution.d.ts

@@ -4,6 +4,7 @@ interface FilterResolvableInformedByOptions {
     allowUnresolved?: boolean | undefined;
     resolver?: RecordReferenceResolver | undefined;
     logEndpoint?: string | undefined;
+    localMirrorPaths?: readonly string[] | undefined;
     warnings: string[];
 }
 export declare const defaultRecordReferenceResolver: typeof sharedDefaultRecordReferenceResolver;

package/dist/reference-resolution.js

@@ -8,7 +8,9 @@ export async function filterResolvableInformedBy(refs, options) {
         return unique;
     const kept = [];
     const resolver = options.resolver ??
-        ((recordHash) => defaultRecordReferenceResolver(recordHash, options.logEndpoint));
+        ((recordHash) => defaultRecordReferenceResolver(recordHash, options.logEndpoint, {
+            localMirrorPaths: options.localMirrorPaths,
+        }));
     for (const ref of unique) {
         const resolution = await resolver(ref);
         if (resolution === 'found') {

package/dist/sign.d.ts

@@ -46,11 +46,15 @@ export interface BuildEmitRecordInput {
      * replay-checkable without exposing the body to the public log.
      */
     argsHash?: string | undefined;
+    /** Optional 16-byte base64url salt paired with argsHash. */
+    argsSalt?: string | undefined;
     /**
      * Optional §8.3 result_hash commitment. Same posture semantics and wire
      * format as args_hash, but commits to the tool result bytes.
      */
     resultHash?: string | undefined;
+    /** Optional 16-byte base64url salt paired with resultHash. */
+    resultSalt?: string | undefined;
 }
 /**
  * Build, sign, and return a complete AtribRecord ready for submission.

package/dist/sign.js

@@ -23,6 +23,12 @@ const encoder = new TextEncoder();
  * Pure aside from the signing primitive itself; no network I/O here.
  */
 export async function buildAndSignEmitRecord(input) {
+    if (input.argsSalt && !input.argsHash) {
+        throw new TypeError('args_salt requires an explicit args_hash');
+    }
+    if (input.resultSalt && !input.resultHash) {
+        throw new TypeError('result_salt requires result_hash');
+    }
     const publicKey = base64urlEncode(await getPublicKey(input.privateKey));
     const toolName = leafOfEventTypeUri(input.eventType);
     const contentId = computeContentId(SYNTHETIC_SERVER_URL, toolName);
@@ -30,9 +36,7 @@ export async function buildAndSignEmitRecord(input) {
     // informed_by must be sorted lexicographically per §1.2.5 to keep the
     // canonical form stable across emitters. Omitted entirely (not null,
     // not empty) when no references are given, presence affects JCS.
-    const informedBySorted = input.informedBy && input.informedBy.length > 0
-        ? [...input.informedBy].sort()
-        : undefined;
+    const informedBySorted = input.informedBy && input.informedBy.length > 0 ? [...input.informedBy].sort() : undefined;
     const record = {
         spec_version: 'atrib/1.0',
         content_id: contentId,
@@ -45,8 +49,10 @@ export async function buildAndSignEmitRecord(input) {
         ...(informedBySorted ? { informed_by: informedBySorted } : {}),
         ...(input.annotates ? { annotates: input.annotates } : {}),
         ...(argsHash ? { args_hash: argsHash } : {}),
+        ...(input.argsSalt ? { args_salt: input.argsSalt } : {}),
         ...(input.provenanceToken ? { provenance_token: input.provenanceToken } : {}),
         ...(input.resultHash ? { result_hash: input.resultHash } : {}),
+        ...(input.resultSalt ? { result_salt: input.resultSalt } : {}),
         ...(input.revises ? { revises: input.revises } : {}),
         ...(input.toolName ? { tool_name: input.toolName } : {}),
     };

package/dist/storage.d.ts

@@ -18,10 +18,11 @@ export interface MirrorLine {
     /** Optional local-only sidecar; absent on legacy entries. */
     _local?: LocalSidecar;
 }
+export declare function resolveMirrorWritePath(explicitPath?: string): string;
 /**
  * Append one record + optional proof + optional local sidecar to the
  * mirror file. Failures log with the atrib-emit prefix and otherwise
  * no-op, per §5.8 the mirror is best-effort and never blocks the
  * agent.
  */
-export declare function mirrorRecord(record: AtribRecord, proof: ProofBundle | null, localSidecar?: LocalSidecar): Promise<void>;
+export declare function mirrorRecord(record: AtribRecord, proof: ProofBundle | null, localSidecar?: LocalSidecar, explicitPath?: string): Promise<void>;

package/dist/storage.js

@@ -30,8 +30,9 @@ import { appendFile, mkdir } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
 let ensuredDirs = new Set();
-function mirrorPath() {
-    return (process.env['ATRIB_MIRROR_FILE'] ??
+export function resolveMirrorWritePath(explicitPath) {
+    return (explicitPath ??
+        process.env['ATRIB_MIRROR_FILE'] ??
         join(homedir(), '.atrib', 'records', `atrib-emit-${process.env['ATRIB_AGENT'] ?? 'claude-code'}.jsonl`));
 }
 /**
@@ -40,8 +41,8 @@ function mirrorPath() {
  * no-op, per §5.8 the mirror is best-effort and never blocks the
  * agent.
  */
-export async function mirrorRecord(record, proof, localSidecar) {
-    const path = mirrorPath();
+export async function mirrorRecord(record, proof, localSidecar, explicitPath) {
+    const path = resolveMirrorWritePath(explicitPath);
     const line = { record, proof, written_at: Date.now() };
     if (localSidecar) {
         line._local = localSidecar;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atrib/attest",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "MCP server for atrib's write verb. One attest tool signs observations, annotations, and revisions; the legacy emit, atrib-annotate, and atrib-revise tool names stay mounted as aliases over the same handler.",
   "keywords": [
     "atrib",
@@ -45,13 +45,13 @@
     "@noble/hashes": "^2.2.0",
     "canonicalize": "^3.0.0",
     "zod": "^3.25.76",
-    "@atrib/mcp": "0.21.0"
+    "@atrib/mcp": "0.23.0"
   },
   "devDependencies": {
-    "@types/node": "^25.9.3",
-    "tsx": "^4.22.4",
+    "@types/node": "^26.1.1",
+    "tsx": "^4.23.1",
     "typescript": "^6.0.3",
-    "vitest": "^4.1.8"
+    "vitest": "^4.1.10"
   },
   "files": [
     "dist"