@helmetfire-labs/cartridge-common 0.2.0 → 0.3.0

package/README.md

@@ -204,3 +204,4 @@ npm run build       # compile TypeScript
 npm run typecheck   # type-check only
 npm test            # run tests (239 tests)
 ```
+

package/dist/agent-reducer.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Agent conversation reducer — the behavioral contract for AI agent cartridges.
+ *
+ * Tracks conversation-level state transitions: messages received, responses
+ * sent, sessions reset, errors. This is separate from the container lifecycle
+ * reducer (start/stop/crash) — the lifecycle reducer is managed by the
+ * supervisor, while the agent reducer is managed by the container itself.
+ *
+ * State tracks aggregates (turn counts, token totals, cost) rather than
+ * message content. Content capture is handled by traffic-mirror; the agent
+ * reducer provides the auditable state machine for conversation flow.
+ *
+ * Patent M: Reducer-Based Auditable Cartridge Runtime
+ */
+import type { DurableReducer } from "./durable-reducer.js";
+import { type ActionSchema } from "./action-schema.js";
+export type AgentStatus = "idle" | "processing" | "error";
+export interface AgentState {
+    status: AgentStatus;
+    turnCount: number;
+    totalInputTokens: number;
+    totalOutputTokens: number;
+    totalCost: number;
+    sessionId: string | null;
+    lastMessageAt: number;
+    updatedAt: number;
+}
+export type AgentAction = {
+    type: "message_received";
+    ts: number;
+} | {
+    type: "response_sent";
+    inputTokens: number;
+    outputTokens: number;
+    cost: number;
+    ts: number;
+} | {
+    type: "session_reset";
+    reason: string;
+    ts: number;
+} | {
+    type: "session_updated";
+    sessionId: string;
+    ts: number;
+} | {
+    type: "error";
+    code: string;
+    ts: number;
+};
+export declare const agentReducer: DurableReducer<AgentState, AgentAction>;
+export declare const agentActionSchema: ActionSchema;

package/dist/agent-reducer.js

@@ -0,0 +1,98 @@
+/**
+ * Agent conversation reducer — the behavioral contract for AI agent cartridges.
+ *
+ * Tracks conversation-level state transitions: messages received, responses
+ * sent, sessions reset, errors. This is separate from the container lifecycle
+ * reducer (start/stop/crash) — the lifecycle reducer is managed by the
+ * supervisor, while the agent reducer is managed by the container itself.
+ *
+ * State tracks aggregates (turn counts, token totals, cost) rather than
+ * message content. Content capture is handled by traffic-mirror; the agent
+ * reducer provides the auditable state machine for conversation flow.
+ *
+ * Patent M: Reducer-Based Auditable Cartridge Runtime
+ */
+import { defineActionSchema, action } from "./action-schema.js";
+// ── Reducer ─────────────────────────────────────────────────────────────────
+function reduce(state, action) {
+    switch (action.type) {
+        case "message_received":
+            if (state.status === "processing")
+                return state; // already processing
+            return {
+                ...state,
+                status: "processing",
+                turnCount: state.turnCount + 1,
+                lastMessageAt: action.ts,
+                updatedAt: action.ts,
+            };
+        case "response_sent":
+            if (state.status !== "processing")
+                return state;
+            return {
+                ...state,
+                status: "idle",
+                totalInputTokens: state.totalInputTokens + action.inputTokens,
+                totalOutputTokens: state.totalOutputTokens + action.outputTokens,
+                totalCost: state.totalCost + action.cost,
+                updatedAt: action.ts,
+            };
+        case "session_reset":
+            return {
+                ...state,
+                status: "idle",
+                sessionId: null,
+                updatedAt: action.ts,
+            };
+        case "session_updated":
+            return {
+                ...state,
+                sessionId: action.sessionId,
+                updatedAt: action.ts,
+            };
+        case "error":
+            if (state.status !== "processing")
+                return state;
+            return {
+                ...state,
+                status: "error",
+                updatedAt: action.ts,
+            };
+        default:
+            return state;
+    }
+}
+// ── DurableReducer implementation ───────────────────────────────────────────
+export const agentReducer = {
+    reduce,
+    init: () => ({
+        status: "idle",
+        turnCount: 0,
+        totalInputTokens: 0,
+        totalOutputTokens: 0,
+        totalCost: 0,
+        sessionId: null,
+        lastMessageAt: 0,
+        updatedAt: 0,
+    }),
+    serialize: (state) => ({ ...state }),
+    deserialize: (raw) => ({
+        status: raw.status ?? "idle",
+        turnCount: raw.turnCount ?? 0,
+        totalInputTokens: raw.totalInputTokens ?? 0,
+        totalOutputTokens: raw.totalOutputTokens ?? 0,
+        totalCost: raw.totalCost ?? 0,
+        sessionId: raw.sessionId ?? null,
+        lastMessageAt: raw.lastMessageAt ?? 0,
+        updatedAt: raw.updatedAt ?? 0,
+    }),
+};
+// ── Action schema (runtime-inspectable declaration) ─────────────────────────
+export const agentActionSchema = defineActionSchema("agent", [
+    action("message_received", { ts: "number" }, "User message received, begin processing"),
+    action("response_sent", { inputTokens: "number", outputTokens: "number", cost: "number", ts: "number" }, "Agent response completed"),
+    action("session_reset", { reason: "string", ts: "number" }, "Conversation session reset"),
+    action("session_updated", { sessionId: "string", ts: "number" }, "Session ID changed"),
+    action("error", { code: "string", ts: "number" }, "Processing error occurred"),
+]);
+//# sourceMappingURL=agent-reducer.js.map

package/dist/agent-reducer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-reducer.js","sourceRoot":"","sources":["../src/agent-reducer.ts"],"names":[],"mappings":"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"}

package/dist/anchor.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Local anchor service — placeholder for public chain anchoring.
+ *
+ * Implements the AnchorService interface by writing receipts to a local
+ * JSON file. The same interface will be backed by a Base L2 contract
+ * when public anchoring is ready — swapping the transport without
+ * changing the chain structure above or below.
+ *
+ * Patent N: Hierarchical Anchor Chains for Verifiable Agent Accountability
+ */
+export interface AnchorReceipt {
+    merkleRoot: string;
+    timestamp: number;
+    level: string;
+}
+export interface AnchorService {
+    /** Post a Merkle root anchor. Returns the receipt. */
+    anchor(merkleRoot: string, level: string): AnchorReceipt;
+    /** Look up an anchor by Merkle root. Returns null if not found. */
+    verify(merkleRoot: string): AnchorReceipt | null;
+    /** List all anchors. */
+    list(): AnchorReceipt[];
+}
+/**
+ * Create an AnchorService backed by a local JSON file.
+ *
+ * The file is a JSON array of AnchorReceipt objects. Each anchor() call
+ * appends a receipt and writes the file. verify() scans for a matching root.
+ */
+export declare function createLocalAnchorService(filePath: string): AnchorService;

package/dist/anchor.js

@@ -0,0 +1,70 @@
+/**
+ * Local anchor service — placeholder for public chain anchoring.
+ *
+ * Implements the AnchorService interface by writing receipts to a local
+ * JSON file. The same interface will be backed by a Base L2 contract
+ * when public anchoring is ready — swapping the transport without
+ * changing the chain structure above or below.
+ *
+ * Patent N: Hierarchical Anchor Chains for Verifiable Agent Accountability
+ */
+import assert from "node:assert";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+// ── Local file implementation ───────────────────────────────────────────────
+/**
+ * Create an AnchorService backed by a local JSON file.
+ *
+ * The file is a JSON array of AnchorReceipt objects. Each anchor() call
+ * appends a receipt and writes the file. verify() scans for a matching root.
+ */
+export function createLocalAnchorService(filePath) {
+    assert(filePath, "filePath is required — cannot create anchor service without a storage path");
+    function ensureDir() {
+        const dir = dirname(filePath);
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+    }
+    function readAnchors() {
+        if (!existsSync(filePath))
+            return [];
+        try {
+            const content = readFileSync(filePath, "utf-8");
+            const parsed = JSON.parse(content);
+            assert(Array.isArray(parsed), "anchors file must contain a JSON array");
+            return parsed;
+        }
+        catch {
+            return [];
+        }
+    }
+    function writeAnchors(anchors) {
+        ensureDir();
+        writeFileSync(filePath, JSON.stringify(anchors, null, 2), "utf-8");
+    }
+    return {
+        anchor(merkleRoot, level) {
+            assert(merkleRoot, "merkleRoot is required");
+            assert(level, "level is required");
+            const receipt = {
+                merkleRoot,
+                timestamp: Date.now(),
+                level,
+            };
+            const anchors = readAnchors();
+            anchors.push(receipt);
+            writeAnchors(anchors);
+            return receipt;
+        },
+        verify(merkleRoot) {
+            assert(merkleRoot, "merkleRoot is required");
+            const anchors = readAnchors();
+            return anchors.find(a => a.merkleRoot === merkleRoot) ?? null;
+        },
+        list() {
+            return readAnchors();
+        },
+    };
+}
+//# sourceMappingURL=anchor.js.map

package/dist/anchor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"anchor.js","sourceRoot":"","sources":["../src/anchor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,MAAM,MAAM,aAAa,CAAC;AACjC,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAC7E,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAmBpC,+EAA+E;AAE/E;;;;;GAKG;AACH,MAAM,UAAU,wBAAwB,CAAC,QAAgB;IACvD,MAAM,CAAC,QAAQ,EAAE,4EAA4E,CAAC,CAAC;IAE/F,SAAS,SAAS;QAChB,MAAM,GAAG,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;QAC9B,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;YACrB,SAAS,CAAC,GAAG,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QACtC,CAAC;IACH,CAAC;IAED,SAAS,WAAW;QAClB,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC;YAAE,OAAO,EAAE,CAAC;QACrC,IAAI,CAAC;YACH,MAAM,OAAO,GAAG,YAAY,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;YAChD,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;YACnC,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,wCAAwC,CAAC,CAAC;YACxE,OAAO,MAAyB,CAAC;QACnC,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,EAAE,CAAC;QACZ,CAAC;IACH,CAAC;IAED,SAAS,YAAY,CAAC,OAAwB;QAC5C,SAAS,EAAE,CAAC;QACZ,aAAa,CAAC,QAAQ,EAAE,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC;IACrE,CAAC;IAED,OAAO;QACL,MAAM,CAAC,UAAkB,EAAE,KAAa;YACtC,MAAM,CAAC,UAAU,EAAE,wBAAwB,CAAC,CAAC;YAC7C,MAAM,CAAC,KAAK,EAAE,mBAAmB,CAAC,CAAC;YAEnC,MAAM,OAAO,GAAkB;gBAC7B,UAAU;gBACV,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE;gBACrB,KAAK;aACN,CAAC;YAEF,MAAM,OAAO,GAAG,WAAW,EAAE,CAAC;YAC9B,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YACtB,YAAY,CAAC,OAAO,CAAC,CAAC;YAEtB,OAAO,OAAO,CAAC;QACjB,CAAC;QAED,MAAM,CAAC,UAAkB;YACvB,MAAM,CAAC,UAAU,EAAE,wBAAwB,CAAC,CAAC;YAC7C,MAAM,OAAO,GAAG,WAAW,EAAE,CAAC;YAC9B,OAAO,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,UAAU,KAAK,UAAU,CAAC,IAAI,IAAI,CAAC;QAChE,CAAC;QAED,IAAI;YACF,OAAO,WAAW,EAAE,CAAC;QACvB,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/disclosure.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Selective disclosure — package and verify a cartridge's behavioral proof.
+ *
+ * A DisclosurePackage contains everything a verifier needs to confirm that
+ * a specific cartridge behaved according to its reducer, and that its chain
+ * is anchored in an operator-level Merkle root — without revealing any
+ * information about other cartridges in the tree.
+ *
+ * Patent N: Hierarchical Anchor Chains for Verifiable Agent Accountability
+ */
+import type { DurableReducer } from "./durable-reducer.js";
+import { type MerkleProof } from "./merkle.js";
+export interface DisclosurePackage {
+    /** The cartridge's action log entries (JSONL strings) */
+    actionLog: string[];
+    /** Hash of the reducer / action schema (from static.json or action-schema.json) */
+    reducerRef: string;
+    /** Genesis state for replay */
+    initialState: Record<string, unknown>;
+    /** Merkle inclusion proof linking this cartridge's chain head to the operator anchor */
+    merkleProof: MerkleProof;
+    /** The anchor_batch action.log line containing the Merkle root */
+    anchorEntry: string;
+}
+export interface DisclosureResult {
+    ok: boolean;
+    /** Reducer replay passed — every action produced the recorded state */
+    reducerReplayOk: boolean;
+    /** Hash chain is intact — no insertions, deletions, or modifications */
+    chainIntegrityOk: boolean;
+    /** Merkle proof links chain head to the anchor's Merkle root */
+    merkleInclusionOk: boolean;
+    /** Number of action log entries verified */
+    entriesVerified: number;
+    /** Description of the first failure, if any */
+    failure?: string;
+}
+/**
+ * Verify a selective disclosure package.
+ *
+ * Performs three independent checks:
+ *   1. Reducer replay — feed actionLog through the reducer, confirm stateHashes match
+ *   2. Chain integrity — confirm hash chain links are intact
+ *   3. Merkle inclusion — confirm the chain head is anchored in the operator's root
+ *
+ * All checks run regardless of earlier failures — the result reports each independently.
+ */
+export declare function verifyDisclosure<S, A extends {
+    type: string;
+}>(disclosure: DisclosurePackage, reducer: DurableReducer<S, A>): DisclosureResult;

package/dist/disclosure.js

@@ -0,0 +1,81 @@
+/**
+ * Selective disclosure — package and verify a cartridge's behavioral proof.
+ *
+ * A DisclosurePackage contains everything a verifier needs to confirm that
+ * a specific cartridge behaved according to its reducer, and that its chain
+ * is anchored in an operator-level Merkle root — without revealing any
+ * information about other cartridges in the tree.
+ *
+ * Patent N: Hierarchical Anchor Chains for Verifiable Agent Accountability
+ */
+import assert from "node:assert";
+import { hashLine } from "./durable-reducer.js";
+import { verify } from "./verify.js";
+import { verifyProof } from "./merkle.js";
+// ── Verification ────────────────────────────────────────────────────────────
+/**
+ * Verify a selective disclosure package.
+ *
+ * Performs three independent checks:
+ *   1. Reducer replay — feed actionLog through the reducer, confirm stateHashes match
+ *   2. Chain integrity — confirm hash chain links are intact
+ *   3. Merkle inclusion — confirm the chain head is anchored in the operator's root
+ *
+ * All checks run regardless of earlier failures — the result reports each independently.
+ */
+export function verifyDisclosure(disclosure, reducer) {
+    assert(disclosure.actionLog.length > 0, "disclosure must contain at least one action log entry");
+    // ── 1 & 2: Reducer replay + chain integrity ──────────────────────────
+    const replayResult = verify(disclosure.actionLog, reducer);
+    const reducerReplayOk = replayResult.ok;
+    const chainIntegrityOk = replayResult.ok || (replayResult.failure?.type !== "chain_broken" &&
+        replayResult.failure?.type !== "parse_error");
+    // ── 3: Merkle inclusion ──────────────────────────────────────────────
+    // The chain head is the hash of the last action log line.
+    const lastLine = disclosure.actionLog[disclosure.actionLog.length - 1];
+    const chainHead = hashLine(lastLine);
+    // The Merkle proof's leaf should be the chain head
+    const leafMatchesChainHead = disclosure.merkleProof.leaf === chainHead;
+    // Parse the anchor entry to extract the Merkle root
+    let anchorMerkleRoot = null;
+    try {
+        const anchorAction = JSON.parse(disclosure.anchorEntry);
+        anchorMerkleRoot = anchorAction.action?.merkleRoot ?? null;
+    }
+    catch {
+        // parse failure handled below
+    }
+    const proofRootMatchesAnchor = anchorMerkleRoot !== null &&
+        disclosure.merkleProof.root === anchorMerkleRoot;
+    const proofValid = verifyProof(disclosure.merkleProof);
+    const merkleInclusionOk = leafMatchesChainHead && proofRootMatchesAnchor && proofValid;
+    // ── Build result ─────────────────────────────────────────────────────
+    const ok = reducerReplayOk && chainIntegrityOk && merkleInclusionOk;
+    let failure;
+    if (!ok) {
+        if (!reducerReplayOk && replayResult.failure) {
+            failure = `reducer replay failed: ${replayResult.failure.type} at line ${"line" in replayResult.failure ? replayResult.failure.line : "?"}`;
+        }
+        else if (!chainIntegrityOk && replayResult.failure) {
+            failure = `chain integrity failed: ${replayResult.failure.type}`;
+        }
+        else if (!leafMatchesChainHead) {
+            failure = "merkle proof leaf does not match action log chain head";
+        }
+        else if (!proofRootMatchesAnchor) {
+            failure = "merkle proof root does not match anchor entry merkleRoot";
+        }
+        else if (!proofValid) {
+            failure = "merkle proof verification failed — sibling path does not reconstruct root";
+        }
+    }
+    return {
+        ok,
+        reducerReplayOk,
+        chainIntegrityOk,
+        merkleInclusionOk,
+        entriesVerified: replayResult.entriesVerified,
+        failure,
+    };
+}
+//# sourceMappingURL=disclosure.js.map

package/dist/disclosure.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"disclosure.js","sourceRoot":"","sources":["../src/disclosure.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -32,6 +32,12 @@ export type { DispatcherConfig } from './durable-dispatcher.js';
 export { verify } from './verify.js';
 export { containerReducer, containerActionSchema } from './container-reducer.js';
 export type { ContainerStatus, ContainerState, ContainerAction, } from './container-reducer.js';
+export { agentReducer, agentActionSchema } from './agent-reducer.js';
+export type { AgentStatus, AgentState, AgentAction, } from './agent-reducer.js';
+export { operatorAnchorReducer, operatorAnchorActionSchema } from './operator-reducer.js';
+export type { OperatorAnchorState, OperatorAnchorAction, AnchorChildEntry, } from './operator-reducer.js';
+export { computeMerkleRoot, generateProof, verifyProof } from './merkle.js';
+export type { MerkleProof } from './merkle.js';
 export { defineActionSchema, action, writeActionSchema, getSchemaHash, validateAction, } from './action-schema.js';
 export type { ActionSchema, ActionVariant, FieldType, } from './action-schema.js';
 export { hashPolicy, writePolicy, readPolicy, verifyPolicy, isNetworkAllowed, isFilesystemAllowed, isSpawnAllowed, DEFAULT_POLICY, INSTALL_POLICY, } from './policy.js';

package/dist/index.js

@@ -25,6 +25,9 @@ export { sha256, hashState, hashLine } from './durable-reducer.js';
 export { DurableDispatcher } from './durable-dispatcher.js';
 export { verify } from './verify.js';
 export { containerReducer, containerActionSchema } from './container-reducer.js';
+export { agentReducer, agentActionSchema } from './agent-reducer.js';
+export { operatorAnchorReducer, operatorAnchorActionSchema } from './operator-reducer.js';
+export { computeMerkleRoot, generateProof, verifyProof } from './merkle.js';
 export { defineActionSchema, action, writeActionSchema, getSchemaHash, validateAction, } from './action-schema.js';
 // ── Process Policy (Patent M §3.11) ─────────────────────────────────────────
 export { hashPolicy, writePolicy, readPolicy, verifyPolicy, isNetworkAllowed, isFilesystemAllowed, isSpawnAllowed, DEFAULT_POLICY, INSTALL_POLICY, } from './policy.js';

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAGvC,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAG7C,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAGvC,OAAO,EACL,eAAe,EACf,cAAc,EACd,aAAa,EACb,UAAU,EACV,QAAQ,GACT,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE1C,OAAO,EACL,iBAAiB,EACjB,aAAa,EACb,YAAY,GACb,MAAM,aAAa,CAAC;AAGrB,OAAO,EACL,gBAAgB,EAChB,kBAAkB,GACnB,MAAM,gBAAgB,CAAC;AAQxB,+EAA+E;AAE/E,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAQnE,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAG5D,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC,OAAO,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAOjF,OAAO,EACL,kBAAkB,EAClB,MAAM,EACN,iBAAiB,EACjB,aAAa,EACb,cAAc,GACf,MAAM,oBAAoB,CAAC;AAO5B,+EAA+E;AAE/E,OAAO,EACL,UAAU,EACV,WAAW,EACX,UAAU,EACV,YAAY,EACZ,gBAAgB,EAChB,mBAAmB,EACnB,cAAc,EACd,cAAc,EACd,cAAc,GACf,MAAM,aAAa,CAAC;AAUrB,+EAA+E;AAE/E,OAAO,EACL,aAAa,EACb,OAAO,EACP,OAAO,GACR,MAAM,kBAAkB,CAAC;AAO1B,+EAA+E;AAE/E,OAAO,EACL,iBAAiB,EACjB,UAAU,EACV,gBAAgB,EAChB,iBAAiB,EACjB,UAAU,EACV,sBAAsB,EACtB,aAAa,EACb,iBAAiB,EACjB,sBAAsB,EACtB,kBAAkB,EAClB,kBAAkB,EAClB,kBAAkB,EAClB,YAAY,EACZ,wBAAwB,EACxB,oBAAoB,EACpB,WAAW,GACZ,MAAM,kBAAkB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAGvC,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAG7C,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAGvC,OAAO,EACL,eAAe,EACf,cAAc,EACd,aAAa,EACb,UAAU,EACV,QAAQ,GACT,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE1C,OAAO,EACL,iBAAiB,EACjB,aAAa,EACb,YAAY,GACb,MAAM,aAAa,CAAC;AAGrB,OAAO,EACL,gBAAgB,EAChB,kBAAkB,GACnB,MAAM,gBAAgB,CAAC;AAQxB,+EAA+E;AAE/E,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAQnE,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAG5D,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC,OAAO,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAOjF,OAAO,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAOrE,OAAO,EAAE,qBAAqB,EAAE,0BAA0B,EAAE,MAAM,uBAAuB,CAAC;AAO1F,OAAO,EAAE,iBAAiB,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAG5E,OAAO,EACL,kBAAkB,EAClB,MAAM,EACN,iBAAiB,EACjB,aAAa,EACb,cAAc,GACf,MAAM,oBAAoB,CAAC;AAO5B,+EAA+E;AAE/E,OAAO,EACL,UAAU,EACV,WAAW,EACX,UAAU,EACV,YAAY,EACZ,gBAAgB,EAChB,mBAAmB,EACnB,cAAc,EACd,cAAc,EACd,cAAc,GACf,MAAM,aAAa,CAAC;AAUrB,+EAA+E;AAE/E,OAAO,EACL,aAAa,EACb,OAAO,EACP,OAAO,GACR,MAAM,kBAAkB,CAAC;AAO1B,+EAA+E;AAE/E,OAAO,EACL,iBAAiB,EACjB,UAAU,EACV,gBAAgB,EAChB,iBAAiB,EACjB,UAAU,EACV,sBAAsB,EACtB,aAAa,EACb,iBAAiB,EACjB,sBAAsB,EACtB,kBAAkB,EAClB,kBAAkB,EAClB,kBAAkB,EAClB,YAAY,EACZ,wBAAwB,EACxB,oBAAoB,EACpB,WAAW,GACZ,MAAM,kBAAkB,CAAC"}

package/dist/merkle.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Merkle tree — deterministic binary tree over sorted leaves.
+ *
+ * Used by the anchor hierarchy (Patent N) to aggregate chain head hashes
+ * into a single root. Supports proof generation for selective disclosure:
+ * prove one leaf is included in the root without revealing sibling leaves.
+ *
+ * Construction rules:
+ *   - Leaves are sorted lexicographically before tree construction
+ *   - Odd leaf counts: last leaf is duplicated (standard padding)
+ *   - Pairing: SHA-256(left || right) at each level
+ *   - Empty input: SHA-256 of empty string
+ *
+ * Patent N: Hierarchical Anchor Chains for Verifiable Agent Accountability
+ */
+export interface MerkleProof {
+    /** The leaf hash being proven */
+    leaf: string;
+    /** Leaf position in sorted order */
+    index: number;
+    /** Sibling hashes from leaf to root, with direction */
+    siblings: Array<{
+        hash: string;
+        direction: "left" | "right";
+    }>;
+    /** The claimed Merkle root */
+    root: string;
+}
+/**
+ * Compute the Merkle root of a set of leaf hashes.
+ *
+ * Leaves are NOT pre-sorted — the caller provides them in the desired order.
+ * For anchor chains, sort by child name before calling.
+ */
+export declare function computeMerkleRoot(leaves: string[]): string;
+/**
+ * Generate a Merkle inclusion proof for the leaf at `index`.
+ *
+ * The proof contains sibling hashes and directions needed to reconstruct
+ * the root from the leaf. The verifier learns the tree depth and leaf
+ * position but not the content of any sibling leaf.
+ */
+export declare function generateProof(leaves: string[], index: number): MerkleProof;
+/**
+ * Verify a Merkle inclusion proof.
+ *
+ * Reconstructs the root from the leaf and sibling hashes, then compares
+ * against the claimed root. Returns true if they match.
+ */
+export declare function verifyProof(proof: MerkleProof): boolean;

package/dist/merkle.js

@@ -0,0 +1,99 @@
+/**
+ * Merkle tree — deterministic binary tree over sorted leaves.
+ *
+ * Used by the anchor hierarchy (Patent N) to aggregate chain head hashes
+ * into a single root. Supports proof generation for selective disclosure:
+ * prove one leaf is included in the root without revealing sibling leaves.
+ *
+ * Construction rules:
+ *   - Leaves are sorted lexicographically before tree construction
+ *   - Odd leaf counts: last leaf is duplicated (standard padding)
+ *   - Pairing: SHA-256(left || right) at each level
+ *   - Empty input: SHA-256 of empty string
+ *
+ * Patent N: Hierarchical Anchor Chains for Verifiable Agent Accountability
+ */
+import { sha256 } from "./durable-reducer.js";
+import assert from "node:assert";
+// ── Tree construction ───────────────────────────────────────────────────────
+/**
+ * Compute the Merkle root of a set of leaf hashes.
+ *
+ * Leaves are NOT pre-sorted — the caller provides them in the desired order.
+ * For anchor chains, sort by child name before calling.
+ */
+export function computeMerkleRoot(leaves) {
+    if (leaves.length === 0)
+        return sha256("");
+    let level = [...leaves];
+    while (level.length > 1) {
+        // Odd count: duplicate last leaf
+        if (level.length % 2 !== 0) {
+            level.push(level[level.length - 1]);
+        }
+        const nextLevel = [];
+        for (let i = 0; i < level.length; i += 2) {
+            nextLevel.push(sha256(level[i] + level[i + 1]));
+        }
+        level = nextLevel;
+    }
+    return level[0];
+}
+// ── Proof generation ────────────────────────────────────────────────────────
+/**
+ * Generate a Merkle inclusion proof for the leaf at `index`.
+ *
+ * The proof contains sibling hashes and directions needed to reconstruct
+ * the root from the leaf. The verifier learns the tree depth and leaf
+ * position but not the content of any sibling leaf.
+ */
+export function generateProof(leaves, index) {
+    assert(leaves.length > 0, "cannot generate proof for empty tree");
+    assert(index >= 0 && index < leaves.length, `index ${index} out of bounds for ${leaves.length} leaves`);
+    const root = computeMerkleRoot(leaves);
+    // Single leaf — no siblings needed
+    if (leaves.length === 1) {
+        return { leaf: leaves[0], index, siblings: [], root };
+    }
+    let level = [...leaves];
+    let currentIndex = index;
+    const siblings = [];
+    while (level.length > 1) {
+        if (level.length % 2 !== 0) {
+            level.push(level[level.length - 1]);
+        }
+        const siblingIndex = currentIndex % 2 === 0 ? currentIndex + 1 : currentIndex - 1;
+        const direction = currentIndex % 2 === 0 ? "right" : "left";
+        siblings.push({ hash: level[siblingIndex], direction });
+        // Move up: parent index is floor(currentIndex / 2)
+        currentIndex = Math.floor(currentIndex / 2);
+        const nextLevel = [];
+        for (let i = 0; i < level.length; i += 2) {
+            nextLevel.push(sha256(level[i] + level[i + 1]));
+        }
+        level = nextLevel;
+    }
+    return { leaf: leaves[index], index, siblings, root };
+}
+// ── Proof verification ──────────────────────────────────────────────────────
+/**
+ * Verify a Merkle inclusion proof.
+ *
+ * Reconstructs the root from the leaf and sibling hashes, then compares
+ * against the claimed root. Returns true if they match.
+ */
+export function verifyProof(proof) {
+    let hash = proof.leaf;
+    for (const sibling of proof.siblings) {
+        if (sibling.direction === "right") {
+            // sibling is on the right, current hash is on the left
+            hash = sha256(hash + sibling.hash);
+        }
+        else {
+            // sibling is on the left, current hash is on the right
+            hash = sha256(sibling.hash + hash);
+        }
+    }
+    return hash === proof.root;
+}
+//# sourceMappingURL=merkle.js.map

package/dist/merkle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"merkle.js","sourceRoot":"","sources":["../src/merkle.ts"],"names":[],"mappings":"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"}

package/dist/operator-reducer.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Operator anchor reducer — aggregates cartridge chain heads into a Merkle root.
+ *
+ * The operator anchor is a DurableReducer whose state tracks the chain head
+ * hashes of all cartridges (agents, services, infrastructure) under one
+ * supervisor. Periodically, the bridge dispatches an anchor_batch action
+ * that records the Merkle root over all children — the value that would
+ * be anchored to the next level (section/org/public).
+ *
+ * This reducer is structurally identical to a cartridge reducer: same
+ * dispatch, hash-chain, persist, verify primitives. The difference is
+ * what it tracks: chain head hashes of children, not application state.
+ *
+ * Patent N: Hierarchical Anchor Chains for Verifiable Agent Accountability
+ */
+import type { DurableReducer } from "./durable-reducer.js";
+import { type ActionSchema } from "./action-schema.js";
+export interface AnchorChildEntry {
+    chainHead: string;
+    seq: number;
+    anchoredAt: number;
+}
+export interface OperatorAnchorState {
+    children: Record<string, AnchorChildEntry>;
+    merkleRoot: string | null;
+    anchorCount: number;
+    updatedAt: number;
+}
+export type OperatorAnchorAction = {
+    type: "anchor_child";
+    name: string;
+    chainHead: string;
+    seq: number;
+    ts: number;
+} | {
+    type: "anchor_batch";
+    merkleRoot: string;
+    childCount: number;
+    ts: number;
+} | {
+    type: "child_added";
+    name: string;
+    ts: number;
+} | {
+    type: "child_removed";
+    name: string;
+    ts: number;
+};
+export declare const operatorAnchorReducer: DurableReducer<OperatorAnchorState, OperatorAnchorAction>;
+export declare const operatorAnchorActionSchema: ActionSchema;

package/dist/operator-reducer.js

@@ -0,0 +1,104 @@
+/**
+ * Operator anchor reducer — aggregates cartridge chain heads into a Merkle root.
+ *
+ * The operator anchor is a DurableReducer whose state tracks the chain head
+ * hashes of all cartridges (agents, services, infrastructure) under one
+ * supervisor. Periodically, the bridge dispatches an anchor_batch action
+ * that records the Merkle root over all children — the value that would
+ * be anchored to the next level (section/org/public).
+ *
+ * This reducer is structurally identical to a cartridge reducer: same
+ * dispatch, hash-chain, persist, verify primitives. The difference is
+ * what it tracks: chain head hashes of children, not application state.
+ *
+ * Patent N: Hierarchical Anchor Chains for Verifiable Agent Accountability
+ */
+import assert from "node:assert";
+import { defineActionSchema, action } from "./action-schema.js";
+// ── Reducer ─────────────────────────────────────────────────────────────────
+function reduce(state, action) {
+    switch (action.type) {
+        case "anchor_child": {
+            assert(action.name, "anchor_child requires a name");
+            assert(action.chainHead, "anchor_child requires a chainHead");
+            return {
+                ...state,
+                children: {
+                    ...state.children,
+                    [action.name]: {
+                        chainHead: action.chainHead,
+                        seq: action.seq,
+                        anchoredAt: action.ts,
+                    },
+                },
+                updatedAt: action.ts,
+            };
+        }
+        case "anchor_batch": {
+            // No children → no batch. The bridge should not dispatch this.
+            const childCount = Object.keys(state.children).length;
+            if (childCount === 0)
+                return state;
+            assert(action.merkleRoot, "anchor_batch requires a merkleRoot");
+            return {
+                ...state,
+                merkleRoot: action.merkleRoot,
+                anchorCount: state.anchorCount + 1,
+                updatedAt: action.ts,
+            };
+        }
+        case "child_added": {
+            assert(action.name, "child_added requires a name");
+            // Already exists → no-op (idempotent)
+            if (state.children[action.name])
+                return state;
+            return {
+                ...state,
+                children: {
+                    ...state.children,
+                    [action.name]: { chainHead: "", seq: 0, anchoredAt: 0 },
+                },
+                updatedAt: action.ts,
+            };
+        }
+        case "child_removed": {
+            assert(action.name, "child_removed requires a name");
+            // Doesn't exist → no-op
+            if (!state.children[action.name])
+                return state;
+            const { [action.name]: _, ...rest } = state.children;
+            return {
+                ...state,
+                children: rest,
+                updatedAt: action.ts,
+            };
+        }
+        default:
+            return state;
+    }
+}
+// ── DurableReducer implementation ───────────────────────────────────────────
+export const operatorAnchorReducer = {
+    reduce,
+    init: () => ({
+        children: {},
+        merkleRoot: null,
+        anchorCount: 0,
+        updatedAt: 0,
+    }),
+    serialize: (state) => ({ ...state }),
+    deserialize: (raw) => ({
+        children: raw.children ?? {},
+        merkleRoot: raw.merkleRoot ?? null,
+        anchorCount: raw.anchorCount ?? 0,
+        updatedAt: raw.updatedAt ?? 0,
+    }),
+};
+// ── Action schema ───────────────────────────────────────────────────────────
+export const operatorAnchorActionSchema = defineActionSchema("operator-anchor", [
+    action("anchor_child", { name: "string", chainHead: "string", seq: "number", ts: "number" }, "Record a child cartridge's chain head hash"),
+    action("anchor_batch", { merkleRoot: "string", childCount: "number", ts: "number" }, "Record Merkle root over all children"),
+    action("child_added", { name: "string", ts: "number" }, "Register a new child chain"),
+    action("child_removed", { name: "string", ts: "number" }, "Remove a child chain"),
+]);
+//# sourceMappingURL=operator-reducer.js.map

package/dist/operator-reducer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operator-reducer.js","sourceRoot":"","sources":["../src/operator-reducer.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@helmetfire-labs/cartridge-common",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Shared logging, error boundaries, trace helpers, and durable reducer runtime for infrastructure cartridges",
   "type": "module",
   "main": "dist/index.js",
@@ -27,4 +27,4 @@
     "typescript": "^5.0.0",
     "vitest": "^3.0.0"
   }
-}
+}