@itsshadowai/refinery 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Shadow AI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,228 @@
+# refinery
+
+Refinery is a Codex-first memory review CLI. It reads bounded Codex memory
+files, runs a dry-run Coral-coordinated specialist review, and emits proposal
+artifacts that a coding agent or host app can inspect before applying changes
+elsewhere.
+
+Refinery does not approve proposals, apply edits, or own durable memory truth.
+For the first useful version, Codex memories are the only built-in memory
+surface.
+
+## Requirements
+
+- Node.js >= 22.
+- Codex memories enabled and available under `~/.codex/memories`, or another
+  explicitly provided directory named `memories`.
+- Model credentials for live review, usually `OPENROUTER_API_KEY` or
+  `MODEL_API_KEY`.
+
+## Install
+
+```bash
+npm install -g @itsshadowai/refinery
+refinery init --json
+refinery doctor --json
+```
+
+`refinery init` creates global Refinery state under `~/.refinery` and installs
+the bundled `$refinery` Codex skill into `${CODEX_HOME:-~/.codex}/skills/refinery`.
+It preserves an existing installed skill unless `--force` is passed.
+
+## Commands
+
+```bash
+# Verify the local Codex memory source is readable.
+refinery doctor --json
+
+# Verify the installed CLI version.
+refinery version --json
+
+# Verify a non-default Codex memory directory.
+refinery doctor --memory-home /path/to/memories --json
+
+# Run a dry-run stale-memory audit over Codex memories.
+refinery review \
+  --project . \
+  --intent stale-audit \
+  --request "Find Codex memories that may be stale after recent repo moves." \
+  --json
+
+# Seed a live Coral Console debate/critique session without writing run artifacts.
+refinery console run \
+  --project . \
+  --intent stale-audit \
+  --json
+
+# Inspect an existing run without invoking Coral or a model.
+refinery trial inspect --run-dir ~/.refinery/runs/by-project/<project-key>/<run-id> --json
+```
+
+The CLI always emits structured JSON for these commands. Failures use
+`ok: false` with `error.code`, `error.message`, and `error.phase` when known.
+Secrets are not emitted.
+
+## Memory Source
+
+The built-in Codex memory reader is intentionally bounded. It accepts only a
+directory named `memories`, normally `~/.codex/memories`, and does not crawl all
+of `~/.codex`.
+
+Indexed files:
+
+- `MEMORY.md`
+- `memory_summary.md`
+- `rollout_summaries/*.md`
+- `extensions/ad_hoc/**/*.md`
+
+Records use opaque IDs such as `codex-source:<hash>` and
+`codex-memory:<hash>`. Proposal targets should use those opaque IDs rather than
+database IDs or file offsets.
+
+## Review
+
+`refinery review` is dry-run only. It starts or targets Coral, creates bounded
+proposal and critique threads, runs the five Refinery specialists, writes a run
+directory, and returns proposed memory-maintenance actions.
+
+The default workflow is debate/critique. Claim Scout extracts candidate memory
+claims, Memory Cartographer maps nearby active memories, Evidence Auditor checks
+support and provenance, Proposal Editor turns surviving claims into typed
+proposal packets, and Decision Synthesizer resolves challenges into final
+proposals, rejected candidates, and unresolved questions. Each specialist
+message is persisted under that step's `messages/` artifact directory.
+
+Supported review intents:
+
+```text
+general-review
+stale-audit
+forget-candidates
+update-candidates
+conflict-audit
+scope-audit
+```
+
+Proposal actions:
+
+```text
+create, update, supersede, merge, archive, retag, quarantine,
+promote, demote, ttl_update, contradiction_review
+```
+
+Proposal lifecycle states:
+
+```text
+proposed, needs_review, accepted, rejected, deferred,
+applied_externally, superseded, archived_for_audit
+```
+
+New proposals default to `lifecycle: "proposed"`. Applying or rejecting them is
+owned by the caller.
+
+## Trial Artifacts
+
+Runtime state is globally organized by default:
+
+```text
+~/.refinery/
+  config/
+  credentials/
+  runs/
+    by-project/
+      <project-key>/
+        <run-id>/
+          input.json
+          manifest.json
+          metadata.json
+          proposals.json
+          rejected.json
+          claims.json
+          challenge-ledger.json
+          deliberation.json
+          review.json
+          coral.json
+          transcript.json
+          steps/
+            claim-scout/{input.json,output.raw.md,output.parsed.json}
+            memory-cartographer/{input.json,output.raw.md,output.parsed.json}
+            evidence-auditor/{input.json,output.raw.md,output.parsed.json}
+            proposal-editor/{input.json,output.raw.md,output.parsed.json}
+            decision-synthesizer/{input.json,output.raw.md,output.parsed.json}
+```
+
+Failed reviews that reach a run directory write `status.json`, failed
+`review.json`, and any available step error artifacts. Use `trial inspect` for a
+stable summary instead of scraping file paths.
+
+Use `--home ./.refinery` only when you intentionally want project-local
+Refinery state. The default keeps run artifacts and future credentials/config
+global while grouping runs by project key.
+
+## Coral Runtime
+
+The default runtime is Coral. Refinery owns local executable agent manifests
+under `coral/agents/*` and a repo-local config at `coral/refinery-config.toml`.
+The CLI can also attach to an existing Coral server:
+
+```bash
+refinery review \
+  --coral-url http://localhost:5555 \
+  --coral-no-start \
+  --json
+```
+
+Caller-owned Coral sessions and threads are not torn down by Refinery.
+
+## Console Mode
+
+`refinery console run` is a local development command for Coral Console
+inspection. It reads the bounded Codex memory source, starts Coral when
+`--coral-url` is not provided, creates a session and thread set, seeds the
+default debate/critique workflow, prints the console URL and session
+identifiers, and does not write run artifacts.
+
+The default console topology is `debate-critique`. When Refinery starts the
+Coral server, the command stays in the foreground so the Console remains
+available until interrupted.
+
+## Development
+
+```bash
+npm test
+npm run build
+npm link
+refinery version --json
+```
+
+The test suite covers the Codex memory adapter, Codex-first CLI contract, Coral
+worker/conductor helpers, artifact inspection, model client, intents, MCP
+specialist prompt tools, and specialist contracts.
+
+### Codex Skill
+
+Use one Codex skill for Refinery memory work:
+
+```text
+$refinery
+```
+
+Example prompt:
+
+```text
+Use $refinery to inspect the current project Codex memories with intent update-candidates, source-limit 1, source-char-limit 2500, and summarize the proposed edits.
+```
+
+The companion skill should be installed once in the Codex global skill root:
+
+```text
+~/.codex/skills/refinery/SKILL.md
+```
+
+Do not keep repo-local alternate copies of the Refinery skill; they create
+duplicate suggestions and teach agents old invocation names. `$refinery`
+defaults to live `refinery review`. For deterministic rehearsal only:
+
+```bash
+refinery dev fixture memory-proposal --json
+```

package/coral/agents/claim-scout/coral-agent.toml

@@ -0,0 +1,23 @@
+edition = 4
+
+[agent]
+name = "refinery-claim-scout"
+version = "0.1.0"
+description = "Refinery Claim Scout specialist as a Coral executable agent."
+summary = "Claim Scout extracts candidate memory claims from source evidence."
+readme = "Executable Refinery specialist. Worker owns Coral wait/send and maps to src/core/specialists/claim-scout."
+
+[agent.license]
+type = "spdx"
+expression = "MIT"
+
+[options]
+MODEL_NAME = { type = "string", default = "deepseek/deepseek-v4-pro" }
+MODEL_BASE_URL = { type = "string", default = "https://openrouter.ai/api/v1" }
+REASONING_EFFORT = { type = "string", default = "low" }
+REFINERY_CORAL_MAX_TURNS = { type = "string", default = "1" }
+
+[runtimes.executable]
+path = "../run-worker.sh"
+arguments = ["--specialist", "claim-scout"]
+transport = "streamable_http"

package/coral/agents/decision-synthesizer/coral-agent.toml

@@ -0,0 +1,23 @@
+edition = 4
+
+[agent]
+name = "refinery-decision-synthesizer"
+version = "0.1.0"
+description = "Refinery Decision Synthesizer specialist as a Coral executable agent."
+summary = "Decision Synthesizer resolves challenges into final proposed edits, rejected candidates, and unresolved questions."
+readme = "Executable Refinery specialist. Worker owns Coral wait/send and maps to src/core/specialists/decision-synthesizer."
+
+[agent.license]
+type = "spdx"
+expression = "MIT"
+
+[options]
+MODEL_NAME = { type = "string", default = "deepseek/deepseek-v4-pro" }
+MODEL_BASE_URL = { type = "string", default = "https://openrouter.ai/api/v1" }
+REASONING_EFFORT = { type = "string", default = "low" }
+REFINERY_CORAL_MAX_TURNS = { type = "string", default = "1" }
+
+[runtimes.executable]
+path = "../run-worker.sh"
+arguments = ["--specialist", "decision-synthesizer"]
+transport = "streamable_http"

package/coral/agents/evidence-auditor/coral-agent.toml

@@ -0,0 +1,23 @@
+edition = 4
+
+[agent]
+name = "refinery-evidence-auditor"
+version = "0.1.0"
+description = "Refinery Evidence Auditor specialist as a Coral executable agent."
+summary = "Evidence Auditor checks support, provenance, truncation, lineage, and write risk."
+readme = "Executable Refinery specialist. Worker owns Coral wait/send and maps to src/core/specialists/evidence-auditor."
+
+[agent.license]
+type = "spdx"
+expression = "MIT"
+
+[options]
+MODEL_NAME = { type = "string", default = "deepseek/deepseek-v4-pro" }
+MODEL_BASE_URL = { type = "string", default = "https://openrouter.ai/api/v1" }
+REASONING_EFFORT = { type = "string", default = "low" }
+REFINERY_CORAL_MAX_TURNS = { type = "string", default = "1" }
+
+[runtimes.executable]
+path = "../run-worker.sh"
+arguments = ["--specialist", "evidence-auditor"]
+transport = "streamable_http"

package/coral/agents/memory-cartographer/coral-agent.toml

@@ -0,0 +1,23 @@
+edition = 4
+
+[agent]
+name = "refinery-memory-cartographer"
+version = "0.1.0"
+description = "Refinery Memory Cartographer specialist as a Coral executable agent."
+summary = "Memory Cartographer maps nearby memories, duplicates, conflicts, and supersession targets."
+readme = "Executable Refinery specialist. Worker owns Coral wait/send and maps to src/core/specialists/memory-cartographer."
+
+[agent.license]
+type = "spdx"
+expression = "MIT"
+
+[options]
+MODEL_NAME = { type = "string", default = "deepseek/deepseek-v4-pro" }
+MODEL_BASE_URL = { type = "string", default = "https://openrouter.ai/api/v1" }
+REASONING_EFFORT = { type = "string", default = "low" }
+REFINERY_CORAL_MAX_TURNS = { type = "string", default = "1" }
+
+[runtimes.executable]
+path = "../run-worker.sh"
+arguments = ["--specialist", "memory-cartographer"]
+transport = "streamable_http"

package/coral/agents/proposal-editor/coral-agent.toml

@@ -0,0 +1,23 @@
+edition = 4
+
+[agent]
+name = "refinery-proposal-editor"
+version = "0.1.0"
+description = "Refinery Proposal Editor specialist as a Coral executable agent."
+summary = "Proposal Editor turns surviving claims into typed memory proposal packets."
+readme = "Executable Refinery specialist. Worker owns Coral wait/send and maps to src/core/specialists/proposal-editor."
+
+[agent.license]
+type = "spdx"
+expression = "MIT"
+
+[options]
+MODEL_NAME = { type = "string", default = "deepseek/deepseek-v4-pro" }
+MODEL_BASE_URL = { type = "string", default = "https://openrouter.ai/api/v1" }
+REASONING_EFFORT = { type = "string", default = "low" }
+REFINERY_CORAL_MAX_TURNS = { type = "string", default = "1" }
+
+[runtimes.executable]
+path = "../run-worker.sh"
+arguments = ["--specialist", "proposal-editor"]
+transport = "streamable_http"

package/coral/agents/run-worker.sh

@@ -0,0 +1,19 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+REPO_ROOT="$(cd "${SCRIPT_DIR}/../.." && pwd)"
+
+if [[ -n "${REFINERY_NODE_BIN:-}" ]]; then
+  NODE_BIN="${REFINERY_NODE_BIN}"
+elif [[ -x "${HOME}/.nvm/versions/node/v24.10.0/bin/node" ]]; then
+  NODE_BIN="${HOME}/.nvm/versions/node/v24.10.0/bin/node"
+else
+  NODE_BIN="node"
+fi
+
+cd "${REPO_ROOT}"
+if [[ -f "${REPO_ROOT}/dist/coral/worker.js" ]]; then
+  exec "${NODE_BIN}" dist/coral/worker.js "$@"
+fi
+exec "${NODE_BIN}" src/coral/worker.ts "$@"

package/coral/refinery-config.toml

@@ -0,0 +1,16 @@
+[network]
+bind_address = "127.0.0.1"
+external_address = "127.0.0.1"
+bind_port = 5555
+allow_any_host = true
+
+[auth]
+keys = ["refinery-dev"]
+
+[registry]
+include_coral_home_agents = false
+include_debug_agents = false
+export_debug_agents = false
+watch_local_agents = true
+local_agent_rescan_timer = "10s"
+local_agents = ["/Users/bambozlor/Lab/Research-Desk/refinery/coral/agents/*"]

package/dist/adapters/codex-memory.d.ts

@@ -0,0 +1,6 @@
+import type { MemoryStoreAdapter } from "../core/adapter.ts";
+export interface CodexMemoryAdapterOptions {
+    memoryHome?: string;
+}
+export declare function resolveCodexMemoryHome(memoryHome?: string): string;
+export declare function createCodexMemoryAdapter(options?: CodexMemoryAdapterOptions): MemoryStoreAdapter;

package/dist/adapters/codex-memory.js

@@ -0,0 +1,264 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { RefineryError } from "../core/errors.js";
+export function resolveCodexMemoryHome(memoryHome) {
+    return path.resolve(memoryHome ?? path.join(os.homedir(), ".codex", "memories"));
+}
+function hashId(prefix, parts) {
+    const hash = crypto.createHash("sha256");
+    for (const part of parts)
+        hash.update(part).update("\0");
+    return `${prefix}:${hash.digest("hex").slice(0, 16)}`;
+}
+function compactText(text, max = 4000) {
+    const compact = text.replace(/\s+/g, " ").trim();
+    if (compact.length <= max)
+        return compact;
+    return `${compact.slice(0, max - 3).trimEnd()}...`;
+}
+function assertSafeMemoryHome(memoryHome) {
+    if (path.basename(memoryHome) !== "memories") {
+        throw new RefineryError("CODEX_MEMORY_HOME_UNSAFE", "memoryHome must point to a directory named memories, such as ~/.codex/memories.", { phase: "adapter", details: { memoryHome } });
+    }
+}
+function ensureMemoryHome(memoryHome) {
+    if (!fs.existsSync(memoryHome) || !fs.statSync(memoryHome).isDirectory()) {
+        throw new RefineryError("CODEX_MEMORY_HOME_NOT_FOUND", `Codex memory home does not exist: ${memoryHome}`, { phase: "adapter", details: { memoryHome } });
+    }
+}
+function readIfExists(memoryHome, relPath) {
+    const absPath = path.join(memoryHome, relPath);
+    if (!fs.existsSync(absPath) || !fs.statSync(absPath).isFile())
+        return null;
+    return toDocument(memoryHome, absPath);
+}
+function walkMarkdown(dir) {
+    if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory())
+        return [];
+    const out = [];
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const abs = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            out.push(...walkMarkdown(abs));
+        }
+        else if (entry.isFile() && entry.name.endsWith(".md")) {
+            out.push(abs);
+        }
+    }
+    return out.sort();
+}
+function originKindForRelPath(relPath) {
+    if (relPath === "MEMORY.md")
+        return "memory-index";
+    if (relPath === "memory_summary.md")
+        return "memory-summary";
+    if (relPath === "raw_memories.md")
+        return "raw-memory";
+    if (relPath === "phase2_workspace_diff.md")
+        return "workspace-diff";
+    if (relPath.startsWith("rollout_summaries/"))
+        return "rollout-summary";
+    if (relPath.startsWith("extensions/ad_hoc/"))
+        return "ad-hoc-note";
+    return "other";
+}
+function sourceKindForOrigin(originKind) {
+    switch (originKind) {
+        case "memory-index":
+            return "codex-memory-index";
+        case "memory-summary":
+            return "codex-memory-summary";
+        case "rollout-summary":
+            return "codex-rollout-summary";
+        case "ad-hoc-note":
+            return "codex-ad-hoc-note";
+        case "raw-memory":
+            return "codex-raw-memory";
+        case "workspace-diff":
+            return "codex-workspace-diff";
+        case "other":
+            return "codex-memory-document";
+    }
+}
+function firstMetadataValue(text, field) {
+    const match = text.match(new RegExp(`^${field}:\\s*(.+)$`, "m"));
+    return match ? match[1].trim() : null;
+}
+function parseRolloutListMetadata(text) {
+    const match = text.match(/\(([^)]*thread_id=[^)]+)\)/);
+    if (!match)
+        return {};
+    const body = match[1];
+    const metadata = {};
+    for (const part of body.split(/,\s*/)) {
+        const eq = part.indexOf("=");
+        if (eq <= 0)
+            continue;
+        const key = part.slice(0, eq).trim();
+        const value = part.slice(eq + 1).trim();
+        if (key === "thread_id")
+            metadata.threadId = value;
+        else if (key === "updated_at")
+            metadata.updatedAt = value;
+        else if (key === "rollout_path")
+            metadata.rolloutPath = value;
+        else if (key === "cwd")
+            metadata.cwd = value;
+        else
+            metadata[key] = value;
+    }
+    return metadata;
+}
+function metadataFor(relPath, text, originKind) {
+    const metadata = {
+        originKind,
+        relPath,
+    };
+    if (originKind === "rollout-summary") {
+        metadata.threadId = firstMetadataValue(text, "thread_id");
+        metadata.updatedAt = firstMetadataValue(text, "updated_at");
+        metadata.rolloutPath = firstMetadataValue(text, "rollout_path");
+        metadata.cwd = firstMetadataValue(text, "cwd");
+    }
+    Object.assign(metadata, parseRolloutListMetadata(text));
+    return Object.fromEntries(Object.entries(metadata).filter(([, value]) => value !== null && value !== undefined));
+}
+function toDocument(memoryHome, absPath) {
+    const relPath = path.relative(memoryHome, absPath).split(path.sep).join("/");
+    const text = fs.readFileSync(absPath, "utf8");
+    const originKind = originKindForRelPath(relPath);
+    return {
+        relPath,
+        absPath,
+        text,
+        originKind,
+        sourceKind: sourceKindForOrigin(originKind),
+        metadata: metadataFor(relPath, text, originKind),
+    };
+}
+function loadDocuments(memoryHome) {
+    assertSafeMemoryHome(memoryHome);
+    ensureMemoryHome(memoryHome);
+    const docs = [];
+    for (const relPath of ["MEMORY.md", "memory_summary.md", "raw_memories.md", "phase2_workspace_diff.md"]) {
+        const doc = readIfExists(memoryHome, relPath);
+        if (doc)
+            docs.push(doc);
+    }
+    for (const abs of walkMarkdown(path.join(memoryHome, "rollout_summaries")))
+        docs.push(toDocument(memoryHome, abs));
+    for (const abs of walkMarkdown(path.join(memoryHome, "extensions/ad_hoc")))
+        docs.push(toDocument(memoryHome, abs));
+    return docs;
+}
+function documentToSource(doc) {
+    return {
+        id: hashId("codex-source", [doc.relPath, doc.text]),
+        kind: doc.sourceKind,
+        path: doc.relPath,
+        text: compactText(doc.text, 8000),
+        refs: [{ source_path: doc.relPath, origin_kind: doc.originKind }],
+        metadata: doc.metadata,
+    };
+}
+function headingForLine(lines, lineIndex) {
+    for (let i = lineIndex; i >= 0; i -= 1) {
+        const match = lines[i].match(/^#{1,6}\s+(.+)$/);
+        if (match)
+            return match[1].trim();
+    }
+    return null;
+}
+function inferMemoryType(originKind, heading, body) {
+    const text = `${heading ?? ""} ${body}`.toLowerCase();
+    if (text.includes("preference") || text.includes("when the user") || text.includes("should "))
+        return "operational";
+    if (text.includes("failure") || text.includes("fix:") || text.includes("symptom:"))
+        return "procedural";
+    if (originKind === "ad-hoc-note")
+        return "semantic";
+    return "semantic";
+}
+function documentToMemories(doc) {
+    const lines = doc.text.split(/\r?\n/);
+    const records = [];
+    lines.forEach((line, index) => {
+        const bullet = line.match(/^\s*-\s+(.+)$/);
+        if (!bullet)
+            return;
+        const body = bullet[1].trim();
+        if (!body)
+            return;
+        const heading = headingForLine(lines, index);
+        records.push({
+            id: hashId("codex-memory", [doc.relPath, String(index + 1), body]),
+            type: inferMemoryType(doc.originKind, heading, body),
+            scope: "project",
+            status: "active",
+            body,
+            confidence: null,
+            provenance: {
+                originKind: doc.originKind,
+                sourcePath: doc.relPath,
+                heading,
+                line: index + 1,
+                threadId: typeof doc.metadata.threadId === "string" ? doc.metadata.threadId : null,
+                updatedAt: typeof doc.metadata.updatedAt === "string" ? doc.metadata.updatedAt : null,
+            },
+        });
+    });
+    if (records.length === 0 && doc.originKind === "ad-hoc-note" && doc.text.trim()) {
+        records.push({
+            id: hashId("codex-memory", [doc.relPath, doc.text]),
+            type: "semantic",
+            scope: "project",
+            status: "active",
+            body: compactText(doc.text, 1600),
+            confidence: null,
+            provenance: {
+                originKind: doc.originKind,
+                sourcePath: doc.relPath,
+                heading: null,
+                line: 1,
+            },
+        });
+    }
+    return records;
+}
+function filterByQuery(items, query) {
+    const q = query.toLowerCase();
+    return items.filter((item) => [item.body, item.text, item.path].some((value) => typeof value === "string" && value.toLowerCase().includes(q)));
+}
+function limitItems(items, limit) {
+    return typeof limit === "number" && Number.isFinite(limit) && limit > 0 ? items.slice(0, limit) : items;
+}
+export function createCodexMemoryAdapter(options = {}) {
+    const memoryHome = resolveCodexMemoryHome(options.memoryHome);
+    assertSafeMemoryHome(memoryHome);
+    const readSources = () => loadDocuments(memoryHome).map(documentToSource);
+    const readMemories = () => loadDocuments(memoryHome).flatMap(documentToMemories);
+    return {
+        name: "codex-memory",
+        async listSourceEvidence(input) {
+            return limitItems(readSources(), input.limit);
+        },
+        async searchSourceEvidence(input) {
+            return limitItems(filterByQuery(readSources(), input.query), input.limit);
+        },
+        async getSourceEvidence(input) {
+            return readSources().find((source) => source.id === input.id) ?? null;
+        },
+        async listActiveMemories(input) {
+            return limitItems(readMemories(), input.limit);
+        },
+        async searchActiveMemories(input) {
+            return limitItems(filterByQuery(readMemories(), input.query), input.limit);
+        },
+        async getActiveMemory(input) {
+            return readMemories().find((memory) => memory.id === input.id) ?? null;
+        },
+    };
+}
+//# sourceMappingURL=codex-memory.js.map