@sigrun/memory-honcho 0.0.0-stage → 0.1.1

package/dist/delivery.js

@@ -0,0 +1,264 @@
+/**
+ * The delivery engine: session establishment (with the fork clone rules)
+ * and outbox delivery.
+ *
+ * Every public method runs inside the conversation's serialization chain
+ * (`client.for(id).chain`) — the spec's one-chain-per-conversation rule,
+ * so establishment and delivery never race and the double-clone race
+ * cannot happen.
+ *
+ * `deliverPending` acquires the outbox mutex exactly once per flow
+ * (`withOutbox` around the read → ledger flip → rewrite cycle); it never
+ * nests a second `withOutbox` inside it (the mutex is not re-entrant),
+ * and the sweeper (Task 7) calls it per conversation OUTSIDE any outbox
+ * lock — lock acquisition lives in one place per flow. A flipped batch
+ * also updates the `state/last-delivery.json` marker in the same critical
+ * section (the status route's newest-delivery read survives the sweeper's
+ * delivered-record drop that way).
+ */
+import { pickCloneAnchor } from "./fork-rules.js";
+/** The session configuration applied on get-or-create AND on clones. */
+const SESSION_CONFIGURATION = {
+    summary: { enabled: true },
+    dream: { enabled: true },
+};
+export class DeliveryEngine {
+    #client;
+    #stores;
+    #settings;
+    #hooks;
+    constructor(client, stores, settings, hooks = {}) {
+        this.#client = client;
+        this.#stores = stores;
+        this.#settings = settings;
+        this.#hooks = hooks;
+    }
+    /**
+     * Establish the conversation's Honcho session: plain get-or-create, or
+     * a clone-with-mapping when a pending-fork record points at a parent
+     * ledger with a usable anchor. Idempotent (chain-serialized).
+     */
+    establish(conversationId, owner) {
+        return this.#client
+            .for(String(conversationId))
+            .chain(() => this.#establishLocked(conversationId, owner));
+    }
+    /**
+     * The establish body, WITHOUT chain acquisition — call it only from
+     * inside the conversation's chain (`establish`, or `deliverPending`'s
+     * establish-on-miss). Calling the public `establish` from inside the
+     * chain re-enters `chain("conversation:<id>")` and deadlocks (the
+     * inner run queues behind the outer one it awaits).
+     */
+    async #establishLocked(conversationId, owner) {
+        {
+            const conversation = this.#client.for(String(conversationId));
+            const existing = await this.#stores.readLedger(conversationId);
+            if (existing?.honchoSessionId !== undefined) {
+                conversation.markEstablished(this.#client.session(existing.honchoSessionId));
+                return;
+            }
+            const pendingFork = await this.#stores.readPendingFork(conversationId);
+            if (pendingFork !== undefined && pendingFork.resolvedAt === undefined) {
+                // The parent id is on the record; no event api needed.
+                const parentLedger = await this.#stores.readLedger(pendingFork.parentId);
+                if (parentLedger?.honchoSessionId !== undefined) {
+                    const parent = await this.#client.session(parentLedger.honchoSessionId);
+                    const decision = pickCloneAnchor(parentLedger.anchors, pendingFork.at);
+                    if (decision.kind === "clone") {
+                        const cloned = await parent.clone(decision.messageId);
+                        await cloned.setConfiguration(SESSION_CONFIGURATION);
+                        await this.#stores.writeLedger(conversationId, {
+                            conversationId,
+                            honchoSessionId: cloned.id,
+                            clonedFrom: pendingFork.parentId,
+                            ownerAtFirstCapture: owner,
+                            deliveredBatchIds: [],
+                            anchors: [],
+                        });
+                        await this.#stores.resolvePendingFork(conversationId);
+                        conversation.markEstablished(Promise.resolve(cloned));
+                        return;
+                    }
+                    const session = await this.#getOrCreate(conversationId, owner);
+                    await this.#stores.writeLedger(conversationId, {
+                        conversationId,
+                        honchoSessionId: session.id,
+                        clonedFrom: pendingFork.parentId,
+                        inherit: decision.inherit,
+                        ownerAtFirstCapture: owner,
+                        deliveredBatchIds: [],
+                        anchors: [],
+                    });
+                    await this.#stores.resolvePendingFork(conversationId);
+                    conversation.markEstablished(Promise.resolve(session));
+                    return;
+                }
+                // No parent ledger entry (parent never captured): there is
+                // nothing to inherit, so the record can never become resolvable —
+                // resolve it now rather than leave it to trip the sweeper's
+                // fork-first pass every 15 minutes, then fall through to the
+                // plain get-or-create.
+                await this.#stores.resolvePendingFork(conversationId);
+            }
+            const session = await this.#getOrCreate(conversationId, owner);
+            await this.#stores.writeLedger(conversationId, {
+                conversationId,
+                honchoSessionId: session.id,
+                ownerAtFirstCapture: owner,
+                deliveredBatchIds: [],
+                anchors: [],
+            });
+            conversation.markEstablished(Promise.resolve(session));
+        }
+    }
+    /**
+     * Deliver this conversation's pending outbox records, oldest first.
+     * Delivered batches flip status, fold their batchId into the ledger's
+     * delivered window, and fold a fork anchor ONLY when an agent entry was
+     * in the batch — keyed by THAT agent entry's returned `Message.id`
+     * (unanswered and user-only batches fold no anchor).
+     */
+    async deliverPending(conversationId, owner) {
+        // Whether this pass flipped at least one batch. Read AFTER the chain
+        // settles: the `onDelivered` hook runs OUT of the chain callback —
+        // hook implementations (the factory's leading-edge refresh) re-enter
+        // `chain("conversation:<id>")` on this same label, so calling the
+        // hook inside the callback is a circular wait (the outer run awaits
+        // the hook, which queues behind the tail the outer run must settle).
+        let delivered = false;
+        await this.#client.for(String(conversationId)).chain(async () => {
+            const conversation = this.#client.for(String(conversationId));
+            // Establish on miss: a rebuilt client (key/settings change) loses
+            // its in-memory session marks while the LEDGER survives — a re-read
+            // drives re-establishment (Task-5 review forward hazard; the
+            // sweeper's normal path on a fresh process lands here too). A
+            // rejected mark (a failed get-or-create) is treated as missing.
+            // When the ledger is absent too, no caller established this
+            // conversation — keep the loud "not established" failure rather
+            // than silently creating a session. `#establishLocked` directly:
+            // we are INSIDE the chain; re-entering it would deadlock.
+            const marked = conversation.hasSession()
+                ? await conversation.established().then(() => true, () => false)
+                : false;
+            if (!marked &&
+                (await this.#stores.readLedger(conversationId)) !== undefined) {
+                await this.#establishLocked(conversationId, owner);
+            }
+            const session = await conversation.established();
+            const userPeer = await this.#client.userPeerFor(owner);
+            const agentPeer = await this.#client.agentPeer();
+            await this.#stores.withOutbox(async () => {
+                const records = await this.#stores.readOutbox();
+                const mine = records.filter((record) => record.conversationId === conversationId);
+                if (mine.length === 0)
+                    return;
+                let ledger = await this.#stores.readLedger(conversationId);
+                if (ledger === undefined)
+                    return;
+                // Delivered-set = the ledger's window plus every batchId sent in
+                // this pass: a re-queued copy of an already-delivered batchId is
+                // skipped, never re-sent.
+                const seen = new Set(ledger.deliveredBatchIds);
+                let flipped = false;
+                for (const record of mine) {
+                    if (record.status === "delivered" || seen.has(record.batchId)) {
+                        continue;
+                    }
+                    const messages = record.entries.map((entry) => {
+                        const peer = entry.peer === "agent" ? agentPeer : userPeer;
+                        return peer.message(entry.text, { metadata: entry.metadata });
+                    });
+                    const sent = await session.addMessages(messages);
+                    seen.add(record.batchId);
+                    if (this.#hooks.failAfterSend === true) {
+                        // The accepted crash window: the send landed, the ledger never
+                        // learned — the next pass re-sends (documented duplicate).
+                        continue;
+                    }
+                    ledger = fold(ledger, record, sent);
+                    flipped = true;
+                }
+                if (!flipped)
+                    return;
+                await this.#stores.writeLedger(conversationId, ledger);
+                const rewritten = records.map((record) => record.conversationId === conversationId &&
+                    record.status === "pending" &&
+                    seen.has(record.batchId) &&
+                    this.#hooks.failAfterSend !== true
+                    ? { ...record, status: "delivered" }
+                    : record);
+                await this.#stores.rewriteOutbox(rewritten);
+                // The persistent newest-delivery marker, in the SAME critical
+                // section as the flip: the sweeper drops delivered records every
+                // 15 minutes, so the status route derives `lastDeliveryAt` from
+                // this marker (the retained-records derivation dies with them).
+                // `at` = the newest delivered record's createdAt — a monotonic
+                // max, so a stale flip can never move the marker backwards.
+                const newest = rewritten
+                    .filter((record) => record.status === "delivered")
+                    .reduce((max, record) => max === undefined || record.createdAt > max
+                    ? record.createdAt
+                    : max, undefined);
+                if (newest !== undefined) {
+                    const current = await this.#stores.readLastDelivery();
+                    if (current === undefined || newest > current.at) {
+                        await this.#stores.writeLastDelivery({ at: newest });
+                    }
+                }
+                delivered = true;
+            });
+        });
+        // Out of the chain (see the declaration above): the hook's own work
+        // (a representation refresh) chains behind the delivery that just
+        // settled, never behind itself.
+        if (delivered)
+            await this.#hooks.onDelivered?.(conversationId);
+    }
+    /**
+     * Fire-and-forget delivery (the capture path's posture): self-catching,
+     * logs rather than rejecting. Establishment is LAZY (spec §Capture: the
+     * capture path runs the establishment path inside the fire-and-forget
+     * attempt) — `establish` inside the attempt is chain-serialized ahead of
+     * the delivery, is a no-op when the conversation is already established,
+     * and re-marks a rebuilt client that lost its in-memory session promise.
+     */
+    kick(conversationId, owner) {
+        void this.establish(conversationId, owner)
+            .then(() => this.deliverPending(conversationId, owner))
+            .catch((error) => {
+            console.error(`memory-honcho: delivery kick failed for conversation ${conversationId}`, error);
+        });
+    }
+    /** Get-or-create `sigrun-<id>` with the per-peer observe config. */
+    async #getOrCreate(conversationId, owner) {
+        const session = await this.#client.session(`sigrun-${conversationId}`);
+        const userPeer = await this.#client.userPeerFor(owner);
+        const agentPeer = await this.#client.agentPeer();
+        // The SDK's zod union (PeerAdditionSchema) does NOT accept the
+        // documented map form — only string | Peer | array | tuple. The
+        // tuple form [peerId, config] transforms to the API's per-peer
+        // observe config (verified live 2026-10-31 against honcho v3.0.9:
+        // tuple-array 200s, map form fails client-side validation).
+        await session.addPeers([
+            [userPeer.id, { observeMe: true, observeOthers: true }],
+            [agentPeer.id, { observeMe: true, observeOthers: true }],
+        ]);
+        await session.setConfiguration(SESSION_CONFIGURATION);
+        return session;
+    }
+}
+/** Flip one record's bookkeeping into the ledger (batchId + optional anchor). */
+function fold(ledger, record, sent) {
+    const anchors = [...ledger.anchors];
+    const agentIndex = record.entries.findIndex((entry) => entry.peer === "agent");
+    const agentMessage = agentIndex >= 0 ? sent[agentIndex] : undefined;
+    if (record.answerEntryId !== undefined && agentMessage !== undefined) {
+        anchors.push({ entryId: record.answerEntryId, messageId: agentMessage.id });
+    }
+    return {
+        ...ledger,
+        deliveredBatchIds: [...ledger.deliveredBatchIds, record.batchId],
+        anchors,
+    };
+}

package/dist/fork-rules.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Fork clone-anchor selection (spec §Forks, the five-branch table).
+ *
+ * Pure — no I/O, no Honcho. The "no pending-fork record" branch lives in
+ * `establish` (src/delivery.ts): `pickCloneAnchor` sees only a ledger's
+ * anchors and never decides whether a fork happened at all.
+ *
+ * A whole-session `clone()` is NEVER selected (it would import post-fork
+ * content — the anti-goal); a clone always names a message id.
+ */
+import type { LedgerAnchor } from "./types.js";
+export type CloneAnchorDecision = {
+    readonly kind: "clone";
+    readonly messageId: string;
+} | {
+    readonly kind: "fresh";
+    /** Why a fresh session was started instead of a clone. */
+    readonly inherit: "none-window" | "none-empty";
+};
+/**
+ * Pick the clone anchor for a fork at entry id `at`:
+ *
+ * 1. Newest anchor with `entryId <= at` → clone at that anchor's message.
+ * 2. `at` after the newest retained anchor (a trailing user input, or
+ *    delivery lag while a batch is still pending) → clone at the newest
+ *    anchor; bounded under-inclusion only, never past-fork content.
+ * 3. `at` before the oldest retained anchor (the window moved past the
+ *    fork point) → fresh, `inherit: "none-window"`.
+ * 4. Empty anchor list (ledger exists, nothing ever delivered) → fresh,
+ *    `inherit: "none-empty"`.
+ */
+export declare function pickCloneAnchor(anchors: readonly LedgerAnchor[], at: number): CloneAnchorDecision;

package/dist/fork-rules.js

@@ -0,0 +1,42 @@
+/**
+ * Fork clone-anchor selection (spec §Forks, the five-branch table).
+ *
+ * Pure — no I/O, no Honcho. The "no pending-fork record" branch lives in
+ * `establish` (src/delivery.ts): `pickCloneAnchor` sees only a ledger's
+ * anchors and never decides whether a fork happened at all.
+ *
+ * A whole-session `clone()` is NEVER selected (it would import post-fork
+ * content — the anti-goal); a clone always names a message id.
+ */
+/**
+ * Pick the clone anchor for a fork at entry id `at`:
+ *
+ * 1. Newest anchor with `entryId <= at` → clone at that anchor's message.
+ * 2. `at` after the newest retained anchor (a trailing user input, or
+ *    delivery lag while a batch is still pending) → clone at the newest
+ *    anchor; bounded under-inclusion only, never past-fork content.
+ * 3. `at` before the oldest retained anchor (the window moved past the
+ *    fork point) → fresh, `inherit: "none-window"`.
+ * 4. Empty anchor list (ledger exists, nothing ever delivered) → fresh,
+ *    `inherit: "none-empty"`.
+ */
+export function pickCloneAnchor(anchors, at) {
+    if (anchors.length === 0)
+        return { kind: "fresh", inherit: "none-empty" };
+    let newest;
+    for (const anchor of anchors) {
+        if (anchor.entryId <= at && (newest === undefined || anchor.entryId > newest.entryId)) {
+            newest = anchor;
+        }
+    }
+    if (newest !== undefined)
+        return { kind: "clone", messageId: newest.messageId };
+    const oldest = anchors.reduce((min, anchor) => anchor.entryId < min.entryId ? anchor : min);
+    if (at > oldest.entryId) {
+        // `at` precedes no anchor yet isn't before the oldest ⇒ it sits after
+        // the newest: clone at the newest retained anchor.
+        const latest = anchors.reduce((max, anchor) => anchor.entryId > max.entryId ? anchor : max);
+        return { kind: "clone", messageId: latest.messageId };
+    }
+    return { kind: "fresh", inherit: "none-window" };
+}

package/dist/honcho.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Honcho client wrapper.
+ *
+ * Owns the SDK instance (constructed lazily — no network at construction,
+ * each Peer/Session object performs its get-or-create HTTP call on first
+ * use and is memoized after), the per-conversation ConversationClients,
+ * and the shutdown drain over every conversation's serialization chain.
+ */
+import { type Peer, type Session } from "@honcho-ai/sdk";
+import type { HonchoSettings } from "./config.js";
+/**
+ * Structural slice of the SDK the client uses — fakes in tests implement
+ * this instead of the real network client.
+ */
+export interface HonchoSdk {
+    peer(id: string): Promise<Peer>;
+    session(id: string): Promise<Session>;
+}
+/** Test seam: construct the SDK from resolved settings + api key. */
+export type CreateSdk = (settings: HonchoSettings, apiKey: string | undefined) => HonchoSdk;
+/** Map an arbitrary name to a valid Honcho peer/session id. */
+export declare function sanitize(name: string): string;
+/**
+ * Per-conversation handle: its own serial chain plus the established
+ * Honcho session (set by the establish flow in a later task).
+ */
+export declare class ConversationClient {
+    #private;
+    /** Run work serialized with all other work for this conversation. */
+    readonly chain: <T>(work: () => Promise<T>) => Promise<T>;
+    constructor(conversationId: string);
+    /**
+     * The established Honcho session for this conversation. Throws until
+     * the establish flow has run (Task 4 wires `markEstablished`).
+     */
+    established(): Promise<Session>;
+    /** Internal: record the establish promise (used by Task 4). */
+    markEstablished(session: Promise<Session>): void;
+    /**
+     * Whether a session promise has EVER been marked — distinguishes "no
+     * mark" from "mark present but rejected" (a failed get-or-create);
+     * `deliverPending`'s establish-on-miss treats both as missing.
+     */
+    hasSession(): boolean;
+}
+export declare class HonchoClient {
+    #private;
+    constructor(settings: HonchoSettings, apiKey: string | undefined, createSdk?: CreateSdk);
+    /** Get-or-create a peer by id, memoized (rejections are NOT memoized: a
+     *  transient failure must not stick — the outbox retry story depends on it). */
+    peer(id: string): Promise<Peer>;
+    /** The per-conversation client, memoized. */
+    for(conversationId: string): ConversationClient;
+    /** The peer for a conversation owner; ownerless conversations map to "user". */
+    userPeerFor(owner: string | undefined): Promise<Peer>;
+    /** The agent's own peer (settings.agentPeerId). */
+    agentPeer(): Promise<Peer>;
+    /** Get-or-create a session by id (the SDK performs the HTTP call on first use). */
+    session(id: string): Promise<Session>;
+    /**
+     * Wait for every live chain to settle, giving up after `deadlineMs`.
+     * The drain hook `harnessShutdown` awaits.
+     */
+    drainAll(deadlineMs: number): Promise<void>;
+}

package/dist/honcho.js

@@ -0,0 +1,127 @@
+/**
+ * Honcho client wrapper.
+ *
+ * Owns the SDK instance (constructed lazily — no network at construction,
+ * each Peer/Session object performs its get-or-create HTTP call on first
+ * use and is memoized after), the per-conversation ConversationClients,
+ * and the shutdown drain over every conversation's serialization chain.
+ */
+import { Honcho } from "@honcho-ai/sdk";
+import { chain, chainTails } from "./chains.js";
+const defaultCreateSdk = (settings, apiKey) => {
+    const config = {
+        workspaceId: settings.workspaceId,
+    };
+    // Omit rather than pass undefined so the SDK's own env/default
+    // resolution still applies.
+    if (apiKey !== undefined)
+        config.apiKey = apiKey;
+    if (settings.baseUrl !== undefined)
+        config.baseURL = settings.baseUrl;
+    return new Honcho(config);
+};
+/** Map an arbitrary name to a valid Honcho peer/session id. */
+export function sanitize(name) {
+    const cleaned = name.replace(/[^a-zA-Z0-9_-]/g, "_");
+    return cleaned === "" ? "_" : cleaned;
+}
+/**
+ * Per-conversation handle: its own serial chain plus the established
+ * Honcho session (set by the establish flow in a later task).
+ */
+export class ConversationClient {
+    /** Run work serialized with all other work for this conversation. */
+    chain;
+    #sessionPromise;
+    constructor(conversationId) {
+        this.chain = (work) => chain(`conversation:${conversationId}`, work);
+    }
+    /**
+     * The established Honcho session for this conversation. Throws until
+     * the establish flow has run (Task 4 wires `markEstablished`).
+     */
+    established() {
+        if (this.#sessionPromise === undefined) {
+            return Promise.reject(new Error("memory-honcho: session not established"));
+        }
+        return this.#sessionPromise;
+    }
+    /** Internal: record the establish promise (used by Task 4). */
+    markEstablished(session) {
+        this.#sessionPromise = session;
+    }
+    /**
+     * Whether a session promise has EVER been marked — distinguishes "no
+     * mark" from "mark present but rejected" (a failed get-or-create);
+     * `deliverPending`'s establish-on-miss treats both as missing.
+     */
+    hasSession() {
+        return this.#sessionPromise !== undefined;
+    }
+}
+export class HonchoClient {
+    #settings;
+    #sdk;
+    #createSdk;
+    #apiKey;
+    #peers = new Map();
+    #conversations = new Map();
+    constructor(settings, apiKey, createSdk = defaultCreateSdk) {
+        this.#settings = settings;
+        this.#apiKey = apiKey;
+        this.#createSdk = createSdk;
+    }
+    get #client() {
+        this.#sdk ??= this.#createSdk(this.#settings, this.#apiKey);
+        return this.#sdk;
+    }
+    /** Get-or-create a peer by id, memoized (rejections are NOT memoized: a
+     *  transient failure must not stick — the outbox retry story depends on it). */
+    peer(id) {
+        const existing = this.#peers.get(id);
+        if (existing !== undefined)
+            return existing;
+        const created = this.#client.peer(id);
+        this.#peers.set(id, created);
+        created.catch(() => {
+            if (this.#peers.get(id) === created)
+                this.#peers.delete(id);
+        });
+        return created;
+    }
+    /** The per-conversation client, memoized. */
+    for(conversationId) {
+        const existing = this.#conversations.get(conversationId);
+        if (existing !== undefined)
+            return existing;
+        const created = new ConversationClient(conversationId);
+        this.#conversations.set(conversationId, created);
+        return created;
+    }
+    /** The peer for a conversation owner; ownerless conversations map to "user". */
+    userPeerFor(owner) {
+        return this.peer(sanitize(owner ?? "user"));
+    }
+    /** The agent's own peer (settings.agentPeerId). */
+    agentPeer() {
+        return this.peer(this.#settings.agentPeerId);
+    }
+    /** Get-or-create a session by id (the SDK performs the HTTP call on first use). */
+    session(id) {
+        return this.#client.session(id);
+    }
+    /**
+     * Wait for every live chain to settle, giving up after `deadlineMs`.
+     * The drain hook `harnessShutdown` awaits.
+     */
+    async drainAll(deadlineMs) {
+        // unref: a fast drain must not hold the event loop open until the deadline.
+        await Promise.race([
+            chainTails(),
+            new Promise((resolve) => {
+                const deadline = setTimeout(resolve, deadlineMs);
+                deadline.unref();
+            }),
+        ]);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @sigrun/memory-honcho: the public surface.
+ *
+ * The DEFAULT export is the factory the sigrun extension loader calls.
+ * ARITY IS THE CONTRACT: the loader passes the host only when
+ * `factory.length > 0`, and a defaulted FIRST parameter would consume the
+ * host as a real dependency — so the host is declared bare and the test
+ * seam (`deps`) is the defaulted SECOND parameter, keeping `length === 1`.
+ *
+ * The factory composes Tasks 1-4: per-event it resolves settings and the
+ * API key LIVE (a key written after boot applies at the next event), gates
+ * capture on the conversation's extension selection (POSITIVE verdicts
+ * memoized per conversation — a cached `false` is re-read on the next
+ * event, so a mid-conversation opt-in captures; a mid-conversation
+ * array-form opt-out keeps capturing until restart, the accepted residual
+ * the README documents), appends the outbox record ALWAYS (a missing key
+ * skips only the kick; the sweeper delivers later), and kicks
+ * fire-and-forget delivery. The engine is constructed lazily on first use.
+ *
+ * Task 8's wiring: both prompt sections render from the representation
+ * cache (`renderMemorySection`, sync reads only); the delivery engine's
+ * `onDelivered` is the LEADING-EDGE injection point — a delivered
+ * conversation with NO cache file refreshes once; and the idle/archived
+ * worker re-refreshes from the ledger's owner.
+ */
+import type { SigrunExtensionResult, SigrunHost } from "@sigrun/sigrun/extension";
+import { type HonchoSettings } from "./config.js";
+import { DeliveryEngine, type DeliveryHooks } from "./delivery.js";
+import { HonchoClient } from "./honcho.js";
+import { ExtensionStores } from "./stores.js";
+import type { WorkerRunStatus } from "./types.js";
+/** The factory result, plus the worker bookkeeping Task 8 reports from. */
+export type SigrunExtensionResultLike = SigrunExtensionResult & {
+    readonly workerStatus: ReadonlyMap<string, WorkerRunStatus>;
+};
+/** Test seam: replace the engine/client construction (never the stores). */
+export interface FactoryDeps {
+    createEngine?: (client: HonchoClient, stores: ExtensionStores, settings: HonchoSettings, hooks: DeliveryHooks) => DeliveryEngine;
+    createClient?: (settings: HonchoSettings, apiKey: string | undefined) => HonchoClient;
+}
+export declare function createHonchoMemory(host: SigrunHost, deps?: FactoryDeps): SigrunExtensionResultLike;
+export default createHonchoMemory;