@atrib/annotate 0.2.40 → 1.0.0

package/README.md

@@ -1,5 +1,14 @@
 # @atrib/annotate
 
+**Legacy home.** The write-verb implementation moved to
+[`@atrib/attest`](../atrib-attest/README.md) per the attest/recall rename
+([D164](../../DECISIONS.md#d164-attestrecall-verb-rename-and-primitive-surface-collapse)).
+Annotation folds into `attest` with `ref: { kind: "annotates", target }`.
+This package re-exports the same surface and forwards the `atrib-annotate`
+binary to `@atrib/attest`'s handlers. Records are byte-identical. The
+`atrib-annotate` tool name stays mounted as a permanent alias during the
+alias window, alongside the new `attest` tool.
+
 MCP server exposing the `atrib-annotate` tool for atrib's verifiable action layer. Marks a past signed record with importance, a one-line summary, and topics, so future recall can surface what mattered without re-scanning every record flat.
 
 Closes the producer-side recall-fidelity gap: an agent reading back its own past loses enormous nuance compared to the agent that signed it. An annotation lets the agent at signing time say "future-self: this one is critical, and here's why in one line", and the graph carries that judgment forward.

package/dist/index.d.ts

@@ -1,48 +1,2 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { z } from 'zod';
-import { type EmitLocalSubstrateShadowOptions, type ResolvedKey } from '@atrib/emit';
-export declare const Importance: z.ZodEnum<{
-    critical: "critical";
-    high: "high";
-    medium: "medium";
-    low: "low";
-    noise: "noise";
-}>;
-export declare const AnnotateInput: z.ZodObject<{
-    annotates: z.ZodString;
-    importance: z.ZodEnum<{
-        critical: "critical";
-        high: "high";
-        medium: "medium";
-        low: "low";
-        noise: "noise";
-    }>;
-    summary: 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 AtribAnnotateServer {
-    /** Underlying McpServer; expose for testing or composition. */
-    mcp: McpServer;
-    /** Drain pending submissions (for tests/shutdown). */
-    flush(): Promise<void>;
-}
-export interface CreateAtribAnnotateServerOptions {
-    /** 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;
-}
-/**
- * Wire up the atrib-annotate MCP server with one `atrib-annotate` tool.
- * Per D079: this is a specialized form of @atrib/emit; the underlying
- * signing pipeline is shared via handleEmit so annotation records are
- * byte-identical regardless of which tool produced them.
- */
-export declare function createAtribAnnotateServer(options?: CreateAtribAnnotateServerOptions): Promise<AtribAnnotateServer>;
+export { AnnotateInput, Importance, createAtribAnnotateServer, registerAnnotateTool, } from '@atrib/attest';
+export type { AtribAnnotateServer, CreateAtribAnnotateServerOptions } from '@atrib/attest';

package/dist/index.js

@@ -1,116 +1,8 @@
-// @atrib/annotate MCP server: cognitive primitive #2 of D079.
-//
-// Specialized form of @atrib/emit that narrows the schema to the annotation
-// event_type (spec §1.2.7 / D058). Per D079's package layering: depends on
-// @atrib/emit as the canonical record-signing surface and wraps handleEmit
-// with a narrow Zod schema enforcing the annotation-specific required fields
-// (annotates + importance + summary). The signing + chain composition path
-// is byte-identical to atrib-emit's; a verifier MUST NOT distinguish
-// annotation records signed via this tool from those signed via emit's
-// polymorphic surface.
-//
-// Scope:
-//   - One tool: atrib-annotate
-//   - Narrow input schema: REQUIRES annotates (sha256:<64-hex>), importance, summary
-//   - One key per process (same identity as the wrapper + atrib-emit)
-//   - Persists to the same JSONL mirror convention as atrib-emit
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { z } from 'zod';
-import { resolveEmitLocalSubstrateShadowFromEnv, handleEmit, resolveKey, } from '@atrib/emit';
-import { createSubmissionQueue, EVENT_TYPE_ANNOTATION_URI, } from '@atrib/mcp';
-const SHA256_REF_PATTERN = /^sha256:[0-9a-f]{64}$/;
-const HEX_32_PATTERN = /^[0-9a-f]{32}$/;
-export const Importance = z.enum(['critical', 'high', 'medium', 'low', 'noise']);
-export const AnnotateInput = z.object({
-    annotates: z.string().regex(SHA256_REF_PATTERN).describe("'sha256:<64-hex>' record_hash this annotation describes per spec §1.2.7 / D058. " +
-        'REQUIRED. The target record can be any prior record (yours or another agent\'s).'),
-    importance: Importance.describe('Felt importance for future-self recall ranking. ' +
-        "'critical' (decisions that shape future recall, identity claims), " +
-        "'high' (worth surfacing in default recall), " +
-        "'medium' (general signal), " +
-        "'low' (background noting), " +
-        "'noise' (deliberately deprioritized for recall)."),
-    summary: z.string().min(1).max(2048).describe('One-line semantic gist of the annotation. The recall pipeline reads this verbatim ' +
-        'for snippet display; keep it under ~120 chars when possible. ' +
-        'Distinct from the annotated record\'s own content, this summary captures what ' +
-        'future-you should know about why this record matters.'),
-    topics: z.array(z.string().min(1).max(128)).max(16).optional().describe('Optional topic tags. Used by recall_my_attribution_history\'s topics filter. ' +
-        'Lowercase-hyphenated convention (e.g. "bug-fix", "design-decision").'),
-    context_id: z.string().regex(HEX_32_PATTERN).optional().describe('32-hex context_id. Defaults to process.env.ATRIB_CONTEXT_ID per D078 when omitted; ' +
-        'falls back to a fresh genesis context_id if neither is set.'),
-    informed_by: z.array(z.string().regex(SHA256_REF_PATTERN)).optional().describe("Array of 'sha256:<64-hex>' record_hashes that informed this annotation. " +
-        'Sorted lexicographically before signing per §1.2.5. The `annotates` reference ' +
-        'is separate from `informed_by` and need not be duplicated here.'),
-});
-/**
- * Wire up the atrib-annotate MCP server with one `atrib-annotate` tool.
- * Per D079: this is a specialized form of @atrib/emit; the underlying
- * signing pipeline is shared via handleEmit so annotation records are
- * byte-identical regardless of which tool produced them.
- */
-export async function createAtribAnnotateServer(options = {}) {
-    const resolveServerKey = createServerKeyResolver(options);
-    const logEndpoint = options.logEndpoint ?? process.env['ATRIB_LOG_ENDPOINT'];
-    const queue = createSubmissionQueue(logEndpoint);
-    const localSubstrate = options.localSubstrate === false
-        ? undefined
-        : (options.localSubstrate ??
-            resolveEmitLocalSubstrateShadowFromEnv({
-                producer: 'atrib-annotate',
-                transport: 'stdio-mcp-server',
-            }));
-    const mcp = new McpServer({ name: 'atrib-annotate', version: '0.1.0' });
-    mcp.registerTool('atrib-annotate', {
-        description: 'Mark a past record\'s importance and meaning without superseding it. ' +
-            'Cognitive primitive #2 of D079; produces a signed annotation event ' +
-            '(spec §1.2.7 / D058) that adds an ANNOTATES graph edge to the target. ' +
-            'Use when you want future-self or other agents to read back this past ' +
-            'record with weighted importance and a one-line gist.',
-        inputSchema: AnnotateInput.shape,
-    }, async (rawInput) => {
-        const input = AnnotateInput.parse(rawInput);
-        const result = await handleEmit({
-            input: {
-                event_type: EVENT_TYPE_ANNOTATION_URI,
-                content: {
-                    annotates: input.annotates,
-                    importance: input.importance,
-                    summary: input.summary,
-                    ...(input.topics ? { topics: input.topics } : {}),
-                },
-                annotates: input.annotates,
-                ...(input.context_id ? { context_id: input.context_id } : {}),
-                ...(input.informed_by ? { informed_by: input.informed_by } : {}),
-            },
-            key: await resolveServerKey(),
-            queue,
-            producer: 'atrib-annotate',
-            localSubstrate,
-        });
-        const out = {
-            record_hash: result.record_hash,
-            log_index: result.log_index,
-            inclusion_proof: result.inclusion_proof,
-            context_id: result.context_id,
-            warnings: result.warnings,
-        };
-        return {
-            content: [{ type: 'text', text: JSON.stringify(out, null, 2) }],
-        };
-    });
-    return {
-        mcp,
-        flush: () => queue.flush(),
-    };
-}
-function createServerKeyResolver(options) {
-    if (Object.prototype.hasOwnProperty.call(options, 'key')) {
-        const fixed = options.key ?? null;
-        return async () => fixed;
-    }
-    let resolved = null;
-    return async () => {
-        resolved ??= resolveKey();
-        return resolved;
-    };
-}
+// SPDX-License-Identifier: Apache-2.0
+// @atrib/annotate is the legacy home of the atrib-annotate write primitive
+// (cognitive primitive #2 of D079). The implementation lives in
+// @atrib/attest: annotation folds into the write verb as
+// attest ref.kind='annotates', and the atrib-annotate tool name stays
+// mounted as a permanent alias over the same handler. Records signed
+// through either surface are byte-identical in canonical form.
+export { AnnotateInput, Importance, createAtribAnnotateServer, registerAnnotateTool, } from '@atrib/attest';

package/dist/main.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
-// atrib-annotate standalone binary. Wires the McpServer to a stdio transport
-// so it can be launched as a subprocess by an MCP host (Claude Code,
-// Claude Desktop, etc.).
+// atrib-annotate standalone binary (forwarding shim). Serves the legacy
+// atrib-annotate server, which mounts `atrib-annotate` plus `attest` per
+// the alias-window rule W1.
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { createAtribAnnotateServer } from './index.js';
+import { createAtribAnnotateServer } from '@atrib/attest';
 async function main() {
     const { mcp } = await createAtribAnnotateServer();
     const transport = new StdioServerTransport();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@atrib/annotate",
-  "version": "0.2.40",
-  "description": "MCP server for atrib's verifiable action layer. Lets agents mark a past record's importance and meaning for later recall.",
+  "version": "1.0.0",
+  "description": "Legacy home of atrib's annotate write primitive. Superseded by @atrib/attest (the write verb, ref.kind=\"annotates\"); this package re-exports the same surface and forwards the atrib-annotate binary.",
   "author": "atrib <hello@atrib.dev>",
   "keywords": [
     "atrib",
@@ -24,9 +24,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "zod": "^3.25.76",
-    "@atrib/mcp": "0.20.0",
-    "@atrib/emit": "0.17.2"
+    "@atrib/attest": "0.1.0"
   },
   "devDependencies": {
     "@types/node": "^25.9.3",