@cjhyy/code-shell 0.1.7 → 0.3.0

package/dist/plugins/types.d.ts

@@ -1,4 +1,75 @@
 /**
- * Plugin type definitions.
+ * Plugin marketplace type definitions for codeshell. Schemas mirror Claude
+ * Code's plugin system (see claude-code-sourcemap/restored-src/src/utils/plugins/schemas.ts)
+ * at the MVP subset documented in
+ * docs/superpowers/specs/2026-05-19-plugin-marketplace-design.md.
  */
-export type { PluginManifest, LoadedPlugin } from "./loader.js";
+export type MarketplaceSource = {
+    source: "github";
+    repo: string;
+} | {
+    source: "git";
+    url: string;
+};
+export interface KnownMarketplace {
+    source: MarketplaceSource;
+    installLocation: string;
+    lastUpdated: string;
+}
+export type KnownMarketplaces = Record<string, KnownMarketplace>;
+export type PluginEntrySource = string | {
+    source: "git";
+    url: string;
+    ref?: string;
+    sha?: string;
+} | {
+    source: "github";
+    repo: string;
+    ref?: string;
+    sha?: string;
+} | {
+    source: "git-subdir";
+    url: string;
+    path: string;
+    ref?: string;
+    sha?: string;
+};
+export interface PluginMarketplaceEntry {
+    name: string;
+    description?: string;
+    author?: {
+        name: string;
+        email?: string;
+    };
+    category?: string;
+    source: PluginEntrySource;
+    homepage?: string;
+}
+export interface PluginMarketplace {
+    name: string;
+    description?: string;
+    owner: {
+        name: string;
+        email?: string;
+    };
+    plugins: PluginMarketplaceEntry[];
+}
+export interface PluginInstallEntry {
+    scope: "user";
+    installPath: string;
+    version: string;
+    installedAt: string;
+    lastUpdated: string;
+    gitCommitSha?: string;
+}
+export interface InstalledPluginsV2 {
+    version: 2;
+    plugins: Record<string, PluginInstallEntry[]>;
+}
+export type ValidationResult<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: string;
+};

package/dist/plugins/varRewrite.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Plugin variable rewriter.
+ *
+ * After a plugin is materialized into the cache dir, walk its files and
+ * rewrite every occurrence of `CLAUDE_PLUGIN_ROOT` to `CODESHELL_PLUGIN_ROOT`.
+ *
+ * Why: plugins authored against Claude Code's protocol embed
+ * `${CLAUDE_PLUGIN_ROOT}` in their hooks.json command strings and inside
+ * shell scripts. codeshell uses its own env var name (`CODESHELL_PLUGIN_ROOT`)
+ * to keep plugin-side host detection unambiguous — so we rewrite the file
+ * tree at install time once, instead of dual-setting env vars at every hook
+ * invocation (which would let plugins falsely conclude they're running on
+ * Claude Code and emit CC-specific output formats).
+ *
+ * The rewrite is whole-token (not regex with word boundaries — Node's
+ * `String.replaceAll` on a literal substring is sufficient because no
+ * substring of the source contains the target as a prefix/suffix of another
+ * identifier in any plugin we've seen). If a plugin author chose
+ * `CLAUDE_PLUGIN_ROOT_SUFFIX` as an identifier this would also get rewritten,
+ * but that case is implausible enough we accept the risk over more complex
+ * tokenization.
+ *
+ * Binary files are skipped via NUL-byte heuristic on first 8 KiB.
+ *
+ * A breadcrumb file (`.code-shell-installed.json`) records the rewrite so
+ * a user debugging "why does this file differ from upstream?" has an
+ * explanation in-place.
+ */
+export interface RewriteSummary {
+    filesScanned: number;
+    filesRewritten: number;
+    rewrittenPaths: string[];
+}
+/**
+ * Rewrite every `CLAUDE_PLUGIN_ROOT` → `CODESHELL_PLUGIN_ROOT` under
+ * `installPath`, then drop a breadcrumb file at the root.
+ *
+ * Idempotent: re-running on an already-rewritten tree is a no-op for the
+ * rewrite (no `CLAUDE_PLUGIN_ROOT` left) but refreshes the breadcrumb's
+ * timestamp so the user can see when the most recent install/update ran.
+ */
+export declare function rewritePluginVars(installPath: string): RewriteSummary;

package/dist/product/index.js

@@ -1 +1 @@
-export{a as defineProduct}from'../chunk-KCXSARAA.js';import'../chunk-NMBYBGC7.js';import'../chunk-2NS3JMNK.js';import'../chunk-WI6FSWGU.js';import'../chunk-P6JSTIFM.js';import'../chunk-SNFAPSLA.js';import'../chunk-XDOWC7EG.js';import'../chunk-W47Z7MGS.js';import'../chunk-T222K6IV.js';import'../chunk-QTWU7UNA.js';import'../chunk-UDPUTFQT.js';import'../chunk-Q4O2HGWS.js';import'../chunk-Y2NS6HPO.js';import'../chunk-NVAZJ5XS.js';import'../chunk-FU7AHZNN.js';import'../chunk-B7K2OWKC.js';import'../chunk-3QP5BQ3L.js';
+export{a as defineProduct}from'../chunk-GGVAOPI7.js';import'../chunk-Z5HKHAO7.js';import'../chunk-SKIX2M5Z.js';import'../chunk-MLCTC53I.js';import'../chunk-WI6FSWGU.js';import'../chunk-P6JSTIFM.js';import'../chunk-SNFAPSLA.js';import'../chunk-D3TVASD2.js';import'../chunk-FZXY554D.js';import'../chunk-M7VU4YVY.js';import'../chunk-T222K6IV.js';import'../chunk-QTWU7UNA.js';import'../chunk-K4HILJ6G.js';import'../chunk-WONQHE4P.js';import'../chunk-GKAQH2DG.js';import'../chunk-FU7AHZNN.js';import'../chunk-DI26OUIU.js';import'../chunk-3QP5BQ3L.js';

package/dist/protocol/client.d.ts

@@ -45,7 +45,7 @@ export declare class AgentClient {
     /**
      * Query server state.
      */
-    query(type: QueryParams["type"], sessionId?: string, ...extra: unknown[]): Promise<QueryResult>;
+    query(type: QueryParams["type"], arg?: string | Record<string, unknown>, ...extra: unknown[]): Promise<QueryResult>;
     /**
      * Inject context into the session transcript without triggering a LLM turn.
      * Used to make arena results, tool outputs, etc. visible to subsequent LLM calls.

package/dist/protocol/helpers.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Helpers for spinning up an in-process AgentServer + AgentClient pair.
+ *
+ * All internal codeshell paths that want to run an engine should go through
+ * the protocol layer (AgentServer wraps the engine, AgentClient is the
+ * consumer-facing handle). This helper exists so callers don't repeat the
+ * 6-line "create transport / new server / new client / wire onStream /
+ * try-finally close" boilerplate at every call site.
+ *
+ * Existing call sites that should use this:
+ *   - src/cli/commands/run.ts        (headless CLI)
+ *   - src/run/EngineRunner.ts         (RunManager)
+ *
+ * The REPL builds its own server+client because it needs the long-lived
+ * AgentClient instance to drive the React UI's lifecycle (subscribing to
+ * stream events, approval requests, status changes). One-shot callers want
+ * the simpler "give me a client, hand back close()" shape this helper
+ * provides.
+ */
+import type { Engine } from "../engine/engine.js";
+import type { StreamCallback } from "../types.js";
+import { AgentClient } from "./client.js";
+export interface InProcessClientHandle {
+    /** The client; pass to `client.run(task, sessionId)` to execute. */
+    readonly client: AgentClient;
+    /**
+     * Tear down server + client + transports. Call from a `finally` block.
+     * Safe to call multiple times; subsequent calls are no-ops.
+     */
+    close(): void;
+}
+export interface CreateInProcessClientOptions {
+    /** Stream callback to receive every event the server emits. */
+    onStream?: StreamCallback;
+}
+/**
+ * Wrap an Engine in an in-process AgentServer and return a client handle.
+ * The handle's `close()` tears the whole pair down in the correct order:
+ * client first (so its pending requests reject cleanly), then server (which
+ * aborts any active run and clears approval timers).
+ */
+export declare function createInProcessClient(engine: Engine, options?: CreateInProcessClientOptions): InProcessClientHandle;

package/dist/render/clearTerminal.d.ts

@@ -3,10 +3,16 @@
  * Detects modern terminals that support ESC[3J for clearing scrollback.
  */
 /**
- * Returns the ANSI escape sequence to clear the terminal including scrollback.
- * Automatically detects terminal capabilities.
+ * Returns the ANSI escape sequence to clear the terminal.
+ *
+ * `preserveScrollback=true` omits ERASE_SCROLLBACK (CSI 3J) so the user's
+ * scrollback buffer (and scroll position) survives a mid-stream fullReset.
+ * Used by log-update when emitting a flicker reset in flow mode — alt-screen
+ * has no user-visible scrollback so the default (clear it) is fine there.
  */
-export declare function getClearTerminalSequence(): string;
+export declare function getClearTerminalSequence(options?: {
+    preserveScrollback?: boolean;
+}): string;
 /**
  * Clears the terminal screen. On supported terminals, also clears scrollback.
  */

package/dist/render/components/App.d.ts

@@ -15,6 +15,7 @@ type Props = {
     readonly terminalRows: number;
     readonly selection: SelectionState;
     readonly onSelectionChange: () => void;
+    readonly onSelectionFinish: () => void;
     readonly onClickAt: (col: number, row: number) => boolean;
     readonly onHoverAt: (col: number, row: number) => void;
     readonly getHyperlinkAt: (col: number, row: number) => string | undefined;

package/dist/render/components/Static.d.ts

@@ -0,0 +1,23 @@
+import { type ReactNode, type ReactElement } from 'react';
+import '../global.d.ts';
+interface StaticProps<T> {
+    /** Stable array; only NEW items past the previously-emitted index get rendered. */
+    items: readonly T[];
+    /** Render fn — same shape as Array.prototype.map. */
+    children: (item: T, index: number) => ReactNode;
+}
+/**
+ * Append-only output component. Each time `items` grows, the NEW items are
+ * rendered to ANSI and written directly to stdout. They are never touched by
+ * the diff engine again — they live permanently in the terminal scrollback.
+ *
+ * Shape matches ink's <Static>: https://github.com/vadimdemedes/ink#static
+ *
+ * Implementation: we use a custom host element 'ink-static' so ink.tsx can
+ * detect it in onRender. The pendingStaticElement prop carries the React
+ * subtree for the new items. ink.tsx renders that element via renderToScreen,
+ * converts to ANSI, writes to stdout, then the next render cycle sees
+ * emittedCount === items.length and passes null (nothing to flush).
+ */
+export declare function Static<T>({ items, children }: StaticProps<T>): ReactElement;
+export {};

package/dist/render/devtools.d.ts

@@ -1,5 +1,9 @@
-/**
- * Devtools connection stub — conditionally imported by the reconciler
- * when NODE_ENV === 'development'. No-op in production.
- */
+import type { FrameEvent } from "./frame.js";
+type Mode = "off" | "summary" | "verbose";
+export declare function recordFrame(event: FrameEvent): void;
+export declare const renderDevtools: {
+    enabled: boolean;
+    mode: Mode;
+    recordFrame: typeof recordFrame;
+};
 export {};

package/dist/render/dom.d.ts

@@ -7,7 +7,7 @@ type InkNode = {
     style: Styles;
 };
 export type TextName = '#text';
-export type ElementNames = 'ink-root' | 'ink-box' | 'ink-text' | 'ink-virtual-text' | 'ink-link' | 'ink-progress' | 'ink-raw-ansi';
+export type ElementNames = 'ink-root' | 'ink-box' | 'ink-text' | 'ink-virtual-text' | 'ink-link' | 'ink-progress' | 'ink-raw-ansi' | 'ink-static';
 export type NodeNames = ElementNames | TextName;
 export type DOMElement = {
     nodeName: ElementNames;
@@ -35,6 +35,7 @@ export type DOMElement = {
     };
     focusManager?: FocusManager;
     debugOwnerChain?: string[];
+    pendingStaticElement?: any;
 } & InkNode;
 export type TextNode = {
     nodeName: TextName;

package/dist/render/frame.d.ts

@@ -61,6 +61,7 @@ export type Patch = {
         prevLine: string;
         nextLine: string;
     };
+    preserveScrollback?: boolean;
 } | {
     type: 'cursorHide';
 } | {

package/dist/render/index.d.ts

@@ -15,6 +15,16 @@ export declare function useStdout(): {
     };
     write: (data: string) => boolean;
 };
+export declare function forceRedraw(options?: {
+    stdout?: NodeJS.WriteStream;
+    clearScrollback?: boolean;
+}): void;
 export { default as ScrollBox, type ScrollBoxHandle, type ScrollBoxProps } from "./components/ScrollBox.js";
 export { AlternateScreen } from "./components/AlternateScreen.js";
+export { Ansi } from "./Ansi.js";
+export { NoSelect } from "./components/NoSelect.js";
+export { default as Button } from "./components/Button.js";
+export { default as Link } from "./components/Link.js";
+export { RawAnsi } from "./components/RawAnsi.js";
+export { Static } from "./components/Static.js";
 export { default as render, renderSync, createRoot, type RenderOptions, type Instance } from "./root.js";

package/dist/render/ink.d.ts

@@ -39,6 +39,8 @@ export default class Ink {
     private backFrame;
     private lastPoolResetTime;
     private drainTimer;
+    private drainConsecutive;
+    private drainTrace;
     private lastYogaCounters;
     private altScreenParkPatch;
     readonly selection: SelectionState;
@@ -78,6 +80,17 @@ export default class Ink {
      * returns, fullscreen scroll is dead.
      */
     exitAlternateScreen(): void;
+    /**
+     * Walk the DOM tree looking for 'ink-static' nodes that have a pending
+     * React element to flush. For each such node, render the element via
+     * renderToScreen, convert the resulting Screen to an ANSI string, and
+     * write it directly to stdout. Children are then detached from the node
+     * so they don't appear in the next frame's cell buffer.
+     *
+     * Called at the start of onRender, before the main renderer runs, so the
+     * diff engine never sees the static content.
+     */
+    private flushStaticNodes;
     onRender(): void;
     pause(): void;
     resume(): void;
@@ -93,9 +106,17 @@ export default class Ink {
      * The traditional readline ctrl+l — clears the visible screen and
      * redraws the current content. Also the recovery path when the terminal
      * was cleared externally (macOS Cmd+K) and Ink's diff engine thinks
-     * unchanged cells don't need repainting. Scrollback is preserved.
+     * unchanged cells don't need repainting.
+     *
+     * `clearScrollback`: also emit CSI 3J (ERASE_SCROLLBACK) so the terminal's
+     * native scrollback buffer is wiped. Use at view-boundary transitions
+     * where the previous frame's content is unrelated to the next (e.g.
+     * switching from a sub-agent transcript back to main). Default false —
+     * scrollback preservation matches readline ctrl+l semantics.
      */
-    forceRedraw(): void;
+    forceRedraw(options?: {
+        clearScrollback?: boolean;
+    }): void;
     /**
      * Mark the previous frame as untrustworthy for blit, forcing the next
      * render to do a full-damage diff instead of the per-node fast path.
@@ -265,6 +286,7 @@ export default class Ink {
      */
     subscribeToSelectionChange(cb: () => void): () => void;
     private notifySelectionChange;
+    private notifySelectionFinish;
     /**
      * Hit-test the rendered DOM tree at (col, row) and bubble a ClickEvent
      * from the deepest hit node up through ancestors with onClick handlers.

package/dist/render/log-update.d.ts

@@ -1,5 +1,5 @@
 import type { Diff, Frame } from './frame.js';
-import { type StylePool } from './screen.js';
+import { type Screen, type StylePool } from './screen.js';
 type Options = {
     isTTY: boolean;
     stylePool: StylePool;
@@ -14,4 +14,15 @@ export declare class LogUpdate {
     private getRenderOpsForDone;
     render(prev: Frame, next: Frame, altScreen?: boolean, decstbmSafe?: boolean): Diff;
 }
+/**
+ * Convert a Screen buffer to a plain ANSI string suitable for direct stdout
+ * write. Each row is rendered with style transitions and separated by \r\n.
+ * Trailing blank cells (spaces without background) are trimmed per row to
+ * avoid leaking background colors into the terminal's natural line length.
+ * Ends with a final style reset so the caller's terminal state is clean.
+ *
+ * Used by the <Static> flush path in ink.tsx to commit finalized items to
+ * terminal scrollback without going through the diff engine.
+ */
+export declare function screenToAnsi(screen: Screen, stylePool: StylePool): string;
 export {};

package/dist/render/selection.d.ts

@@ -130,7 +130,7 @@ export declare function moveFocus(s: SelectionState, col: number, row: number):
  * with shiftSelectionForFollow's top-edge check, but bidirectional: keyboard
  * scroll can jump either way.
  */
-export declare function shiftSelection(s: SelectionState, dRow: number, minRow: number, maxRow: number, width: number): void;
+export declare function shiftSelection(s: SelectionState, dRow: number, minRow: number, maxRow: number, width: number, clearOnFullOvershoot?: boolean): void;
 /**
  * Shift the anchor row by dRow, clamped to [minRow, maxRow]. Used during
  * drag-to-scroll: when the ScrollBox scrolls by N rows, the content that

package/dist/run/index.js

@@ -1 +1 @@
-export{a as createRunManager}from'../chunk-RP26WO4R.js';export{_ as ArtifactTracker,Z as CheckpointWriter,ca as CompositeEvaluator,da as EngineRunner,V as FileRunStore,aa as Heartbeat,ba as NoopEvaluator,X as RunApprovalBackend,$ as RunLock,ea as RunManager,W as RunQueue,U as VALID_TRANSITIONS,Y as createRunAskUserFn}from'../chunk-NMBYBGC7.js';import'../chunk-2NS3JMNK.js';import'../chunk-WI6FSWGU.js';import'../chunk-P6JSTIFM.js';import'../chunk-SNFAPSLA.js';import'../chunk-XDOWC7EG.js';import'../chunk-W47Z7MGS.js';import'../chunk-T222K6IV.js';import'../chunk-QTWU7UNA.js';import'../chunk-UDPUTFQT.js';import'../chunk-Q4O2HGWS.js';import'../chunk-Y2NS6HPO.js';import'../chunk-NVAZJ5XS.js';import'../chunk-FU7AHZNN.js';import'../chunk-B7K2OWKC.js';import'../chunk-3QP5BQ3L.js';
+export{a as createRunManager}from'../chunk-5QIVXFCT.js';export{Y as ArtifactTracker,X as CheckpointWriter,aa as CompositeEvaluator,fa as EngineRunner,T as FileRunStore,_ as Heartbeat,$ as NoopEvaluator,V as RunApprovalBackend,Z as RunLock,ga as RunManager,U as RunQueue,S as VALID_TRANSITIONS,W as createRunAskUserFn}from'../chunk-Z5HKHAO7.js';import'../chunk-SKIX2M5Z.js';import'../chunk-MLCTC53I.js';import'../chunk-WI6FSWGU.js';import'../chunk-P6JSTIFM.js';import'../chunk-SNFAPSLA.js';import'../chunk-D3TVASD2.js';import'../chunk-FZXY554D.js';import'../chunk-M7VU4YVY.js';import'../chunk-T222K6IV.js';import'../chunk-QTWU7UNA.js';import'../chunk-K4HILJ6G.js';import'../chunk-WONQHE4P.js';import'../chunk-GKAQH2DG.js';import'../chunk-FU7AHZNN.js';import'../chunk-DI26OUIU.js';import'../chunk-3QP5BQ3L.js';

package/dist/{seatbelt-WBYROQT6.js → seatbelt-L54CNI2Y.js}

@@ -1,7 +1,7 @@
-import {h,a}from'./chunk-3QP5BQ3L.js';import {mkdtempSync,writeFileSync}from'fs';import {tmpdir}from'os';import {join}from'path';h();function x(e){return {name:"seatbelt",wrap(o,l){let r=b(e),t=mkdtempSync(join(tmpdir(),"codeshell-sandbox-")),a=join(t,"profile.sb");return writeFileSync(a,r,"utf-8"),{file:"/usr/bin/sandbox-exec",args:["-f",a,l.shell,"-c",o]}},hintForBlockedOutput(o){if(/Operation not permitted|sandbox/.test(o))return `
-[sandbox:seatbelt] A syscall was blocked by the sandbox. If this path should be writable or this network call legitimate, ask the user to update sandbox.writableRoots / sandbox.network in settings.json.`}}}a(x,"createSeatbeltBackend");function b(e){let o=e.writableRoots.map(t=>`  (subpath ${d(t)})`).join(`
+import {h,a}from'./chunk-3QP5BQ3L.js';import {mkdtempSync,writeFileSync,rmSync}from'fs';import {tmpdir}from'os';import {join}from'path';h();function y(e){return {name:"seatbelt",wrap(o,l){let n=b(e),t=mkdtempSync(join(tmpdir(),"codeshell-sandbox-")),a$1=join(t,"profile.sb");return writeFileSync(a$1,n,"utf-8"),{file:"/usr/bin/sandbox-exec",args:["-f",a$1,l.shell,"-c",o],cleanup:a(()=>{try{rmSync(t,{recursive:!0,force:!0});}catch{}},"cleanup")}},hintForBlockedOutput(o){if(/Operation not permitted|sandbox/.test(o))return `
+[sandbox:seatbelt] A syscall was blocked by the sandbox. If this path should be writable or this network call legitimate, ask the user to update sandbox.writableRoots / sandbox.network in settings.json.`}}}a(y,"createSeatbeltBackend");function b(e){let o=e.writableRoots.map(t=>`  (subpath ${d(t)})`).join(`
 `),l=e.deniedReads.map(t=>`  (subpath ${d(t)})`).join(`
-`),r=e.network==="deny"?"(deny network-outbound)":"(allow network*)";return `(version 1)
+`),n=e.network==="deny"?"(deny network-outbound)":"(allow network*)";return `(version 1)
 (deny default)
 
 ;; Process control
@@ -33,5 +33,5 @@ ${o})
 (allow iokit-open)
 
 ;; Network
-${r}
-`}a(b,"buildProfile");function d(e){return `"${e.replace(/"/g,'\\"')}"`}a(d,"quote");export{x as createSeatbeltBackend};
+${n}
+`}a(b,"buildProfile");function d(e){return `"${e.replace(/"/g,'\\"')}"`}a(d,"quote");export{y as createSeatbeltBackend};

package/dist/services/index.d.ts

@@ -8,3 +8,4 @@ export { diagnostics } from "./diagnostics.js";
 export { buildExtractionPrompt, parseExtractionResponse, type ExtractedMemory, } from "./extract-memories.js";
 export { shouldAutoDream, recordSession, recordDreamComplete, buildDreamPrompt, } from "./auto-dream.js";
 export { saveSessionMemory, loadSessionMemory, listSessionMemories, searchSessionMemories, buildSessionMemoryPrompt, } from "./session-memory.js";
+export { MemoryOrchestrator, type MemoryOrchestratorOptions, type MemoryOrchestratorResult, } from "./memory-orchestrator.js";

package/dist/services/memory-orchestrator.d.ts

@@ -0,0 +1,39 @@
+/**
+ * MemoryOrchestrator — ties extract-memories, session-memory, and auto-dream
+ * into a single end-of-session pipeline.
+ *
+ * Called by Engine.run() after the turn loop completes. Runs memory extraction
+ * and session summarisation via lightweight LLM calls, then conditionally
+ * triggers auto-dream consolidation. None of this blocks the Engine result.
+ */
+import { MemoryManager } from "../session/memory.js";
+export interface MemoryOrchestratorOptions {
+    /** Lightweight LLM call — must be a non-streaming summarisation call. */
+    callLLM: (systemPrompt: string, userMsg: string) => Promise<string>;
+    /** Project root; when set, memories are scoped per-project. */
+    projectDir?: string;
+    /** Optional pre-constructed MemoryManager (avoids re-creating for every call). */
+    memoryManager?: MemoryManager;
+}
+export interface MemoryOrchestratorResult {
+    /** Number of new memory entries extracted and saved. */
+    extracted: number;
+    /** Whether the auto-dream consolidation was triggered. */
+    dreamTriggered: boolean;
+}
+export declare class MemoryOrchestrator {
+    private readonly options;
+    constructor(options: MemoryOrchestratorOptions);
+    /**
+     * Run the full end-of-session memory pipeline.
+     *
+     *  1. Extract durable memories from the transcript (extract-memories)
+     *  2. Summarise the session (session-memory)
+     *  3. Record a completed session for auto-dream tracking
+     *  4. Conditionally trigger auto-dream consolidation
+     */
+    run(transcript: Array<{
+        role: string;
+        content: string;
+    }>, sessionId: string): Promise<MemoryOrchestratorResult>;
+}