stageflow 0.36.0 → 0.40.0

package/dist/mcp/pipelineAuthorSupport.js

@@ -0,0 +1,10 @@
+import { loadDraftPackage, validateDraftPackage } from "../config/draftPackage.js";
+import { publishDraftPackage } from "../config/publishDraftPackage.js";
+export { loadDraftPackage, validateDraftPackage };
+/** Write a package the way the Workshop's save does, flattening its result shape. */
+export async function publishDraftPackageFacade(projectRoot, input, mode) {
+    const { write } = await publishDraftPackage(projectRoot, input, mode);
+    if (!write.ok)
+        return { ok: false, error: write.error, status: write.status };
+    return { ok: true, pipelinePath: write.pipelinePath, stagePaths: write.stagePaths, ...(write.taskPath !== undefined ? { taskPath: write.taskPath } : {}) };
+}

package/dist/mcp/pipelineAuthorTools.d.ts

@@ -0,0 +1,8 @@
+import type { McpServer } from "@modelcontextprotocol/server";
+import type { McpToolDeps } from "./deps.js";
+/**
+ * Author pipelines and tasks straight on disk. Each mutation loads the package,
+ * applies the same builder the Workshop uses, and writes it back through the
+ * Workshop's publish path (validate first, nothing written when invalid).
+ */
+export declare function registerPipelineAuthorTools(server: McpServer, deps: McpToolDeps): void;

package/dist/mcp/pipelineAuthorTools.js

@@ -0,0 +1,109 @@
+import path from "node:path";
+import { z } from "zod";
+import { loadDraftPackage, publishDraftPackageFacade, validateDraftPackage } from "./pipelineAuthorSupport.js";
+import { buildCreatePipelineDraft, buildCreateStageDraft, buildCreateTaskDraft, buildEditPipelineDraft, buildEditStageDraft, buildEditTaskDraft, } from "../operatorAgent/profiles/workshopAuthorTools.js";
+import { textResult } from "./toolResults.js";
+const pipelinePath = z
+    .string()
+    .describe("Pipeline YAML path relative to the project root, e.g. workshop/release/pipeline.yaml");
+const record = z.record(z.string(), z.unknown());
+const allowInvalid = z
+    .boolean()
+    .optional()
+    .describe("Write even when validation fails, so a pipeline can be built up step by step. Default false.");
+/**
+ * Author pipelines and tasks straight on disk. Each mutation loads the package,
+ * applies the same builder the Workshop uses, and writes it back through the
+ * Workshop's publish path (validate first, nothing written when invalid).
+ */
+export function registerPipelineAuthorTools(server, deps) {
+    const root = () => deps.projectRoot ?? deps.cwd;
+    async function mutate(relPath, mode, build, options = {}) {
+        const projectRoot = root();
+        let draft = { pipeline: { id: "", stages: [] } };
+        if (mode === "overwrite") {
+            const loaded = await loadDraftPackage(projectRoot, relPath, options.taskPath ? { taskPath: options.taskPath } : {});
+            if (!loaded.ok)
+                return textResult({ error: loaded.error, status: loaded.status }, true);
+            draft = loaded.draft;
+        }
+        const built = build(draft);
+        if (!built.ok)
+            return textResult({ error: built.error }, true);
+        const directory = path.posix.dirname(relPath.replace(/\\/g, "/")) || ".";
+        const published = await publishDraftPackageFacade(projectRoot, {
+            directory,
+            draft: built.nextDraft,
+            pipelineFilename: path.posix.basename(relPath),
+            ...(options.allowInvalid ? { allowInvalid: true } : {}),
+        }, mode);
+        if (!published.ok)
+            return textResult({ error: published.error, status: published.status }, true);
+        return textResult({ pipelinePath: published.pipelinePath, stagePaths: published.stagePaths, taskPath: published.taskPath ?? null });
+    }
+    server.registerTool("read_pipeline", {
+        description: "Read a pipeline package from disk (pipeline, stage files, optional task) with its validation result. Use before editing.",
+        inputSchema: z.object({ path: pipelinePath, task_path: z.string().optional().describe("Task file to include, relative to the project root") }),
+    }, async ({ path: relPath, task_path }) => {
+        const loaded = await loadDraftPackage(root(), relPath, task_path ? { taskPath: task_path } : {});
+        if (!loaded.ok)
+            return textResult({ error: loaded.error, status: loaded.status }, true);
+        const validation = await validateDraftPackage(loaded.draft, { cwd: deps.cwd, projectRoot: root() });
+        return textResult({ draft: loaded.draft, destination: loaded.destination, validation });
+    });
+    server.registerTool("create_pipeline", {
+        description: "Create a new pipeline package on disk (id, optional model/stages). Fails if it already exists; use edit_pipeline instead. A pipeline needs at least one stage to validate, so add stages or pass allow_invalid and then create_stage.",
+        inputSchema: z.object({
+            directory: z.string().describe("Catalog folder relative to the project root, e.g. workshop/release. The file is written as <id>.pipeline.yaml"),
+            id: z.string(),
+            model: z.string().optional(),
+            agent: z.unknown().optional(),
+            stages: z.array(record).optional(),
+            pipeline: record.optional().describe("Whole pipeline object, instead of id/model/stages"),
+            allow_invalid: allowInvalid,
+        }),
+    }, ({ directory, allow_invalid, ...args }) => {
+        const folder = directory.replace(/[\\/]+$/, "");
+        const file = `${typeof args.id === "string" ? args.id : ""}.pipeline.yaml`;
+        return mutate(folder === "" || folder === "." ? file : `${folder}/${file}`, "create", (draft) => buildCreatePipelineDraft(draft, args), { allowInvalid: allow_invalid });
+    });
+    server.registerTool("edit_pipeline", {
+        description: "Edit pipeline fields on disk (id, model, agent, stages wiring, schemas, requires). Pass the fields to change under patch.",
+        inputSchema: z.object({ path: pipelinePath, patch: record, allow_invalid: allowInvalid }),
+    }, ({ path: relPath, patch, allow_invalid }) => mutate(relPath, "overwrite", (draft) => buildEditPipelineDraft(draft, { patch }), { allowInvalid: allow_invalid }));
+    server.registerTool("create_stage", {
+        description: "Add a file-backed stage to a pipeline on disk (uses: ./id.yaml plus the stage body with io).",
+        inputSchema: z.object({
+            path: pipelinePath,
+            id: z.string().optional(),
+            summary: z.string().optional(),
+            system_prompt: z.string().optional(),
+            model: z.string().optional(),
+            entry: z.boolean().optional(),
+            route: z.array(record).optional(),
+            io: record.optional(),
+            body: record.optional().describe("Extra stage body fields"),
+            allow_invalid: allowInvalid,
+        }),
+    }, ({ path: relPath, allow_invalid, ...args }) => mutate(relPath, "overwrite", (draft) => buildCreateStageDraft(draft, args), { allowInvalid: allow_invalid }));
+    server.registerTool("edit_stage", {
+        description: "Edit an existing stage on disk by id: body fields and/or its pipeline entry (route, entry, uses).",
+        inputSchema: z.looseObject({ path: pipelinePath, id: z.string(), allow_invalid: allowInvalid }),
+    }, ({ path: relPath, allow_invalid, ...args }) => mutate(relPath, "overwrite", (draft) => buildEditStageDraft(draft, args), { allowInvalid: allow_invalid }));
+    server.registerTool("create_task", {
+        description: "Create or replace the task beside a pipeline on disk (id and goal, optional body).",
+        inputSchema: z.object({ path: pipelinePath, id: z.string().optional(), goal: z.string().optional(), filename: z.string().optional(), body: record.optional(), allow_invalid: allowInvalid }),
+    }, ({ path: relPath, allow_invalid, ...args }) => mutate(relPath, "overwrite", (draft) => buildCreateTaskDraft(draft, args), { allowInvalid: allow_invalid }));
+    server.registerTool("edit_task", {
+        description: "Edit the task of a pipeline on disk (id, goal, body fields).",
+        inputSchema: z.object({
+            path: pipelinePath,
+            task_path: z.string().describe("Task file relative to the project root"),
+            id: z.string().optional(),
+            goal: z.string().optional(),
+            patch: record.optional(),
+            body: record.optional(),
+            allow_invalid: allowInvalid,
+        }),
+    }, ({ path: relPath, task_path, allow_invalid, ...args }) => mutate(relPath, "overwrite", (draft) => buildEditTaskDraft(draft, args), { taskPath: task_path, allowInvalid: allow_invalid }));
+}

package/dist/mcp/server.js

@@ -44,6 +44,11 @@ function toolDepsFrom(deps) {
             : {}),
         ...(deps.projectRoot !== undefined ? { projectRoot: deps.projectRoot } : {}),
         ...(deps.providerBoot !== undefined ? { providerBoot: deps.providerBoot } : {}),
+        ...(deps.agentService !== undefined ? { agentService: deps.agentService } : {}),
+        ...(deps.agentChat !== undefined ? { agentChat: deps.agentChat } : {}),
+        ...(deps.agentConversationBackend !== undefined
+            ? { agentConversationBackend: deps.agentConversationBackend }
+            : {}),
     };
 }
 function attachBusNotifications(server, bus) {

package/dist/mcp/tools.js

@@ -3,10 +3,12 @@ import { registerCatalogTools } from "./catalogTools.js";
 import { registerCheckoutTools } from "./checkoutTools.js";
 import { registerControlTools } from "./controlTools.js";
 import { registerProjectMcpTools } from "./projectMcpTools.js";
+import { registerPipelineAuthorTools } from "./pipelineAuthorTools.js";
 import { registerProviderTools } from "./providerTools.js";
 import { registerTriggerTools } from "./triggerTools.js";
 import { textResult } from "./toolResults.js";
 import { DEFAULT_TIMEOUT_MS, waitRun } from "./waitRun.js";
+import { registerAgentTools } from "./agentTools.js";
 import { registerGetStartedTool } from "./getStartedTool.js";
 export function registerMcpTools(server, deps) {
     const { store } = deps;
@@ -17,6 +19,8 @@ export function registerMcpTools(server, deps) {
     registerProviderTools(server, deps);
     registerProjectMcpTools(server, deps);
     registerTriggerTools(server, deps);
+    registerPipelineAuthorTools(server, deps);
+    registerAgentTools(server, deps);
     server.registerTool("wait_run", {
         description: "Long-poll until a run is waiting for HITL input and/or terminal (succeeded/failed), or until timeout_ms. Default until=any wakes on waiting OR terminal. Abort cancels only this wait (not the run). Optional notifications/progress when the client supplies _meta.progressToken. Compose: wait_run → answer_gate → wait_run.",
         inputSchema: z.object({

package/dist/mcp/triggerTools.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { CatalogPathError, catalogPathErrorBody, resolveWritableCatalogRoot, } from "../config/catalogRelativePath.js";
 import { createTrigger, parseCreateTriggerBody } from "../config/createTrigger.js";
+import { parsePatchTriggerBody, parsePutTriggerBody, updateTriggerDefinition, updateTriggerEnabled } from "../config/updateTrigger.js";
 import { loadCatalogTriggers } from "../config/triggerCatalog.js";
 import { writeAudit } from "../logging/audit.js";
 import { logger as rootLogger } from "../logging/logger.js";
@@ -167,4 +168,35 @@ export function registerTriggerTools(server, deps) {
         });
         return textResult(result.trigger);
     });
+    server.registerTool("update_trigger", {
+        description: "Replace a trigger's definition (pipeline, task, kind, schedule or event, enabled). Same validation and write path as PUT /api/triggers/:id; the id cannot change.",
+        inputSchema: z.object({
+            id: z.string(),
+            project_root: z.string().optional(),
+            pipeline: z.string(),
+            task: z.string().optional(),
+            kind: z.enum(["manual", "schedule", "event"]),
+            schedule: triggerScheduleSchema.optional(),
+            event: triggerEventSchema.optional(),
+            enabled: z.boolean().optional(),
+        }),
+    }, async ({ id, project_root, ...body }) => {
+        const parsed = parsePutTriggerBody(body, id);
+        if ("ok" in parsed)
+            return textResult({ error: parsed.error, status: parsed.status }, true);
+        const result = await updateTriggerDefinition(cwd, store, id, parsed, { projectRootFilter: project_root });
+        writeAudit(auditLog, { caller_id: callerIdFromRequestAuth(), surface: getRequestAuth()?.surface ?? "mcp", action: "trigger_update", outcome: result.ok ? "ok" : "error" });
+        return result.ok ? textResult(result.trigger) : textResult({ error: result.error, status: result.status }, true);
+    });
+    server.registerTool("set_trigger_enabled", {
+        description: "Enable or disable a trigger. Same write path as PATCH /api/triggers/:id.",
+        inputSchema: z.object({ id: z.string(), enabled: z.boolean(), project_root: z.string().optional() }),
+    }, async ({ id, enabled, project_root }) => {
+        const parsed = parsePatchTriggerBody({ enabled });
+        if ("ok" in parsed)
+            return textResult({ error: parsed.error, status: parsed.status }, true);
+        const result = await updateTriggerEnabled(cwd, store, id, parsed.enabled, { projectRootFilter: project_root });
+        writeAudit(auditLog, { caller_id: callerIdFromRequestAuth(), surface: getRequestAuth()?.surface ?? "mcp", action: "trigger_patch", outcome: result.ok ? "ok" : "error" });
+        return result.ok ? textResult(result.trigger) : textResult({ error: result.error, status: result.status }, true);
+    });
 }

package/dist/memory/access.d.ts

@@ -0,0 +1,36 @@
+import { type MemoryCardHit, type MemoryHost, type MemoryMeta } from "./host.js";
+/** What a stage or agent session is allowed to do with the memories attached to it. */
+export type StageMemory = {
+    attachments: MemoryMeta[];
+    refreshAttachments(): Promise<MemoryMeta[]>;
+    read(id: string): Promise<string>;
+    replace(id: string, content: string): Promise<void>;
+    addCard(id: string, key: string, body: string): Promise<void>;
+    updateCard(id: string, key: string, body: string): Promise<void>;
+    readCard(id: string, key: string): Promise<string>;
+    searchCards(id: string, query: string): Promise<MemoryCardHit[]>;
+};
+/** Unchecked reads and writes. The attachment allowlist sits in front of this. */
+export type MemoryPort = {
+    meta(id: string): Promise<MemoryMeta>;
+    read(id: string): Promise<string>;
+    replace(id: string, content: string): Promise<void>;
+    addCard(id: string, key: string, body: string): Promise<void>;
+    updateCard(id: string, key: string, body: string): Promise<void>;
+    readCard(id: string, key: string): Promise<string>;
+    searchCards(id: string, query: string): Promise<MemoryCardHit[]>;
+};
+declare const MEMORY_VERBS: readonly ["memory.read", "memory.replace", "memory.meta", "memory.addCard", "memory.updateCard", "memory.readCard", "memory.searchCards"];
+export type MemoryVerb = (typeof MEMORY_VERBS)[number];
+export declare function isMemoryVerb(type: string | undefined): type is MemoryVerb;
+/** One allowlist in front of either the host or the worker port. */
+export declare function attachMemory(ids: readonly string[], port: MemoryPort): Promise<StageMemory>;
+export declare function bindStageMemory(host: MemoryHost, ids: readonly string[]): Promise<StageMemory>;
+/** Parent-side dispatch for a stage worker. Refuses an id the stage was not given. */
+export declare function runMemoryRequest(host: MemoryHost, allowed: readonly string[], type: MemoryVerb, input: unknown): Promise<{
+    body?: string;
+    meta?: MemoryMeta;
+    hits?: MemoryCardHit[];
+}>;
+export declare function formatMemoryPrompt(attachments: readonly MemoryMeta[]): string;
+export {};

package/dist/memory/access.js

@@ -0,0 +1,116 @@
+import { MemoryError } from "./host.js";
+const MEMORY_VERBS = [
+    "memory.read",
+    "memory.replace",
+    "memory.meta",
+    "memory.addCard",
+    "memory.updateCard",
+    "memory.readCard",
+    "memory.searchCards",
+];
+export function isMemoryVerb(type) {
+    return type !== undefined && MEMORY_VERBS.includes(type);
+}
+function gate(allowed, id) {
+    if (!allowed.has(id))
+        throw new MemoryError("MEMORY_NOT_ATTACHED");
+}
+/** One allowlist in front of either the host or the worker port. */
+export async function attachMemory(ids, port) {
+    const attachments = [];
+    for (const id of ids)
+        attachments.push(await port.meta(id));
+    const allowed = new Set(ids);
+    return {
+        attachments,
+        async refreshAttachments() {
+            const next = [];
+            for (const id of ids)
+                next.push(await port.meta(id));
+            attachments.length = 0;
+            attachments.push(...next);
+            return next;
+        },
+        async read(id) {
+            gate(allowed, id);
+            return port.read(id);
+        },
+        async replace(id, content) {
+            gate(allowed, id);
+            await port.replace(id, content);
+        },
+        async addCard(id, key, body) {
+            gate(allowed, id);
+            await port.addCard(id, key, body);
+        },
+        async updateCard(id, key, body) {
+            gate(allowed, id);
+            await port.updateCard(id, key, body);
+        },
+        async readCard(id, key) {
+            gate(allowed, id);
+            return port.readCard(id, key);
+        },
+        async searchCards(id, query) {
+            gate(allowed, id);
+            return port.searchCards(id, query);
+        },
+    };
+}
+export function bindStageMemory(host, ids) {
+    return attachMemory(ids, {
+        meta: (id) => host.readMeta(id),
+        read: (id) => host.read(id),
+        replace: (id, content) => host.replace(id, content),
+        addCard: (id, key, body) => host.addCard(id, key, body),
+        updateCard: (id, key, body) => host.updateCard(id, key, body),
+        readCard: (id, key) => host.readCard(id, key),
+        searchCards: (id, query) => host.searchCards(id, query),
+    });
+}
+/** Parent-side dispatch for a stage worker. Refuses an id the stage was not given. */
+export async function runMemoryRequest(host, allowed, type, input) {
+    const args = (input ?? {});
+    const id = args.memory;
+    if (typeof id !== "string" || !allowed.includes(id))
+        throw new MemoryError("MEMORY_NOT_ATTACHED");
+    if (type === "memory.read")
+        return { body: await host.read(id) };
+    if (type === "memory.replace") {
+        if (typeof args.content !== "string")
+            throw new MemoryError("MEMORY_UNREADABLE");
+        await host.replace(id, args.content);
+        return {};
+    }
+    if (type === "memory.addCard" || type === "memory.updateCard") {
+        if (typeof args.key !== "string")
+            throw new MemoryError("MEMORY_INVALID_KEY");
+        if (typeof args.content !== "string")
+            throw new MemoryError("MEMORY_UNREADABLE");
+        if (type === "memory.addCard")
+            await host.addCard(id, args.key, args.content);
+        else
+            await host.updateCard(id, args.key, args.content);
+        return {};
+    }
+    if (type === "memory.readCard") {
+        if (typeof args.key !== "string")
+            throw new MemoryError("MEMORY_INVALID_KEY");
+        return { body: await host.readCard(id, args.key) };
+    }
+    if (type === "memory.searchCards") {
+        const query = typeof args.query === "string" ? args.query : "";
+        return { hits: await host.searchCards(id, query) };
+    }
+    return { meta: await host.readMeta(id) };
+}
+export function formatMemoryPrompt(attachments) {
+    const lines = attachments.map((item) => `- ${item.id}: ${item.description}`);
+    return [
+        "Memories you can read and replace:",
+        ...lines,
+        "Call read_memory with the memory id to get the page. Call replace_memory with the full new page.",
+        "Call add_memory_card, update_memory_card, and read_memory_card with the memory id and the card key. Call search_memory_cards with the memory id and a query.",
+        "The page is not shown here. Card bodies are not shown here. Do not try to open memory files yourself.",
+    ].join("\n");
+}

package/dist/memory/agentIssues.d.ts

@@ -0,0 +1,3 @@
+import type { AgentIssue } from "../config/loadAgent.js";
+/** Hard errors for an agent that names a memory the data directory does not have. */
+export declare function agentMemoryIssues(ids: readonly string[] | undefined, env?: NodeJS.ProcessEnv): AgentIssue[];

package/dist/memory/agentIssues.js

@@ -0,0 +1,23 @@
+import { inspectMemorySync, memoryHome } from "./host.js";
+const MESSAGE = {
+    MEMORY_NOT_FOUND: (id) => `Memory "${id}" does not exist. Create it before attaching it.`,
+    MEMORY_MISMATCH: (id) => `Memory "${id}" does not match the id in its file.`,
+    MEMORY_UNREADABLE: (id) => `Memory "${id}" could not be read.`,
+    MEMORY_INVALID_ID: (id) => `Memory "${id}" is not a valid id.`,
+};
+/** Hard errors for an agent that names a memory the data directory does not have. */
+export function agentMemoryIssues(ids, env = process.env) {
+    if (!ids?.length)
+        return [];
+    const home = memoryHome(env);
+    return ids.flatMap((id, index) => {
+        const inspected = inspectMemorySync(home, id);
+        if (inspected.ok)
+            return [];
+        return [{
+                path: `memories.${index}`,
+                code: "agent.memory_unavailable",
+                message: (MESSAGE[inspected.code] ?? MESSAGE.MEMORY_UNREADABLE)(id),
+            }];
+    });
+}

package/dist/memory/bashDeny.d.ts

@@ -0,0 +1,6 @@
+import type { ExtensionFactory } from "@earendil-works/pi-coding-agent";
+export declare const MEMORY_STORE_BASH_DENIED = "The memory store cannot be accessed with shell commands. Use the memory tools.";
+export declare function memoryStorePathInCommand(command: string, home: string): boolean;
+export declare function createMemoryStoreBashDenyExtension(options: {
+    home: string;
+}): ExtensionFactory;

package/dist/memory/bashDeny.js

@@ -0,0 +1,35 @@
+import path from "node:path";
+export const MEMORY_STORE_BASH_DENIED = "The memory store cannot be accessed with shell commands. Use the memory tools.";
+const MEMORY_STORE_SEGMENT = /\/memories\/[a-z][a-z0-9_-]{0,63}\b/;
+export function memoryStorePathInCommand(command, home) {
+    const trimmed = command.trim();
+    if (trimmed.length === 0)
+        return false;
+    const store = path.resolve(path.join(home, "memories"));
+    const variants = [store, store.split(path.sep).join("/")];
+    for (const candidate of variants) {
+        if (candidate.length > 0 && trimmed.includes(candidate))
+            return true;
+    }
+    if (MEMORY_STORE_SEGMENT.test(trimmed))
+        return true;
+    if (/\$STAGEFLOW_HOME\/memories\b/.test(trimmed) || /\$\{STAGEFLOW_HOME\}\/memories\b/.test(trimmed)) {
+        return true;
+    }
+    return false;
+}
+export function createMemoryStoreBashDenyExtension(options) {
+    const { home } = options;
+    return (pi) => {
+        pi.on("tool_call", async (event) => {
+            if (event.toolName !== "bash")
+                return undefined;
+            const command = event.input.command;
+            if (typeof command !== "string")
+                return undefined;
+            if (!memoryStorePathInCommand(command, home))
+                return undefined;
+            return { block: true, reason: MEMORY_STORE_BASH_DENIED };
+        });
+    };
+}

package/dist/memory/host.d.ts

@@ -0,0 +1,51 @@
+export declare const MEMORY_ERROR_CODES: readonly ["MEMORY_INVALID_ID", "MEMORY_INVALID_DESCRIPTION", "MEMORY_INVALID_KEY", "MEMORY_EXISTS", "MEMORY_NOT_FOUND", "MEMORY_NO_PREVIOUS", "MEMORY_CARD_EXISTS", "MEMORY_CARD_NOT_FOUND", "MEMORY_TOO_MANY_CARDS", "MEMORY_MISMATCH", "MEMORY_UNREADABLE", "MEMORY_TOO_LARGE", "MEMORY_NOT_ATTACHED"];
+export type MemoryErrorCode = (typeof MEMORY_ERROR_CODES)[number];
+export declare class MemoryError extends Error {
+    readonly code: MemoryErrorCode;
+    constructor(code: MemoryErrorCode);
+}
+export type MemoryMeta = {
+    id: string;
+    description: string;
+};
+export type MemoryListItem = MemoryMeta & {
+    cardCount: number;
+};
+export type MemoryRecord = MemoryMeta & {
+    body: string;
+};
+export type MemoryCardHit = {
+    key: string;
+    snippet: string;
+};
+export type MemoryHost = {
+    create(input: {
+        id: string;
+        description: string;
+    }): Promise<MemoryRecord>;
+    list(): Promise<MemoryListItem[]>;
+    read(id: string): Promise<string>;
+    readMeta(id: string): Promise<MemoryMeta>;
+    replace(id: string, body: string): Promise<void>;
+    readPreviousCover(id: string): Promise<string>;
+    addCard(id: string, key: string, body: string): Promise<void>;
+    updateCard(id: string, key: string, body: string): Promise<void>;
+    readCard(id: string, key: string): Promise<string>;
+    readPreviousCard(id: string, key: string): Promise<string>;
+    listCards(id: string): Promise<string[]>;
+    searchCards(id: string, query: string): Promise<MemoryCardHit[]>;
+    deleteCard(id: string, key: string): Promise<void>;
+};
+export declare function memoryHome(env?: NodeJS.ProcessEnv): string;
+export declare function memoryDir(home: string, id: string): string;
+type InspectResult = {
+    ok: true;
+    meta: MemoryMeta;
+} | {
+    ok: false;
+    code: MemoryErrorCode;
+};
+export declare function inspectMemorySync(home: string, id: string): InspectResult;
+export declare function createMemoryHost(home: string): MemoryHost;
+export declare function memoryHostFor(env?: NodeJS.ProcessEnv): MemoryHost;
+export {};