@9thprotocol/agent-core 0.1.0

package/dist/skills.js

@@ -0,0 +1,56 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+/**
+ * Skills: markdown files with optional `--- name/description ---` frontmatter, loaded
+ * from ~/.9p/skills and <cwd>/.9p/skills (project wins on name clash). Anti-bloat rule
+ * (PLAN.md §4.1): a skill's body enters context only when the user invokes /<name>.
+ */
+export function loadSkills(cwd) {
+    const dirs = [path.join(os.homedir(), ".9p", "skills"), path.join(cwd, ".9p", "skills")];
+    const byName = new Map();
+    for (const dir of dirs) {
+        let files = [];
+        try {
+            files = fs.readdirSync(dir).filter((f) => f.endsWith(".md"));
+        }
+        catch {
+            continue;
+        }
+        for (const file of files) {
+            const source = path.join(dir, file);
+            let raw;
+            try {
+                raw = fs.readFileSync(source, "utf8");
+            }
+            catch {
+                continue;
+            }
+            const skill = parseSkill(raw, path.basename(file, ".md"), source);
+            byName.set(skill.name, skill);
+        }
+    }
+    return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+function parseSkill(raw, fallbackName, source) {
+    let name = fallbackName;
+    let description = "";
+    let body = raw;
+    const fm = /^---\n([\s\S]*?)\n---\n?/.exec(raw);
+    if (fm?.[1] !== undefined) {
+        body = raw.slice(fm[0].length);
+        for (const line of fm[1].split("\n")) {
+            const m = /^(name|description):\s*(.+)$/.exec(line.trim());
+            if (m?.[1] === "name" && m[2])
+                name = m[2].trim();
+            if (m?.[1] === "description" && m[2])
+                description = m[2].trim();
+        }
+    }
+    return { name, description, body: body.trim(), source };
+}
+/** The message sent when a user invokes /<skill> [args]. */
+export function skillMessage(skill, args) {
+    return `The user invoked the "${skill.name}" skill. Follow these instructions:\n\n${skill.body}${args ? `\n\nUser input for this invocation: ${args}` : ""}`;
+}
+//# sourceMappingURL=skills.js.map

package/dist/tools/bash.d.ts

@@ -0,0 +1,2 @@
+import { type ToolDef } from "./types.js";
+export declare const bashTool: ToolDef;

package/dist/tools/bash.js

@@ -0,0 +1,38 @@
+import { exec } from "node:child_process";
+import { str, truncate } from "./types.js";
+const MAX_OUTPUT = 30_000;
+const DEFAULT_TIMEOUT_MS = 120_000;
+const MAX_TIMEOUT_MS = 600_000;
+export const bashTool = {
+    name: "bash",
+    description: "Run a shell command in the working directory and return its output. Not interactive, no prompts, no editors.",
+    kind: "exec",
+    parameters: {
+        type: "object",
+        properties: {
+            command: { type: "string" },
+            timeout_ms: { type: "number", description: `Default ${DEFAULT_TIMEOUT_MS}, max ${MAX_TIMEOUT_MS}` },
+        },
+        required: ["command"],
+    },
+    summarize: (i) => `bash: ${truncate(String(i.command ?? ""), 120).split("\n")[0]}`,
+    run(input, ctx) {
+        const command = str(input.command);
+        const timeout = Math.min(Number(input.timeout_ms ?? DEFAULT_TIMEOUT_MS), MAX_TIMEOUT_MS);
+        return new Promise((resolvePromise) => {
+            exec(command, { cwd: ctx.cwd, timeout, maxBuffer: 10 * 1024 * 1024, shell: "/bin/zsh" }, (err, stdout, stderr) => {
+                let out = stdout + (stderr ? (stdout ? "\n" : "") + stderr : "");
+                out = truncate(out, MAX_OUTPUT);
+                if (err) {
+                    const e = err;
+                    const reason = e.killed ? `timed out after ${timeout}ms` : `exit code ${e.code ?? "?"}`;
+                    resolvePromise(`[${reason}]\n${out}` || `[${reason}]`);
+                }
+                else {
+                    resolvePromise(out || "[no output]");
+                }
+            });
+        });
+    },
+};
+//# sourceMappingURL=bash.js.map

package/dist/tools/fs-tools.d.ts

@@ -0,0 +1,5 @@
+import { truncate, type ToolDef } from "./types.js";
+export declare const readTool: ToolDef;
+export declare const writeTool: ToolDef;
+export declare const editTool: ToolDef;
+export { truncate };

package/dist/tools/fs-tools.js

@@ -0,0 +1,115 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { str, truncate } from "./types.js";
+const MAX_LINES = 2000;
+const MAX_LINE_CHARS = 500;
+function resolve(cwd, p) {
+    return path.resolve(cwd, p);
+}
+export const readTool = {
+    name: "read",
+    description: "Read a file. Returns numbered lines. Use offset/limit for large files; whole-file reads over the size threshold are refused and must go through bulk_read.",
+    kind: "read",
+    parameters: {
+        type: "object",
+        properties: {
+            file_path: { type: "string", description: "Path (absolute or relative to cwd)" },
+            offset: { type: "number", description: "1-based line to start from" },
+            limit: { type: "number", description: "Max lines to return" },
+        },
+        required: ["file_path"],
+    },
+    summarize: (i) => `read ${i.file_path}`,
+    async run(input, ctx) {
+        const file = resolve(ctx.cwd, str(input.file_path));
+        const raw = await fs.readFile(file, "utf8");
+        const lines = raw.split("\n");
+        // The size gate. A targeted read is always allowed: it means the caller
+        // already knows which section it wants, which is the case delegation
+        // cannot serve, since editing needs exact bytes and a worker's summary
+        // carries no reliable ones.
+        //
+        // This refuses before `readFiles.add`, deliberately. Marking a file read
+        // here would let write/edit clear their read-before-modify check on a body
+        // nobody ever saw.
+        const targeted = input.offset !== undefined || input.limit !== undefined;
+        if (ctx.delegation && !targeted && lines.length > ctx.delegation.minLines) {
+            return (`Refused: ${file} is ${lines.length} lines (threshold ${ctx.delegation.minLines}). ` +
+                `Reading it whole would cost roughly ${Math.ceil(raw.length / 4)} tokens of context, on this turn and every turn after it.\n` +
+                `- To learn something from it: bulk_read with a specific question. The file goes to a worker model, not into this conversation, so follow-up questions about the same paths are free.\n` +
+                `- To edit it: read again with offset/limit for the section you need. Targeted reads are never refused. Use grep first to find the line.`);
+        }
+        ctx.readFiles.add(file);
+        const offset = Math.max(1, Number(input.offset ?? 1));
+        const limit = Math.min(Number(input.limit ?? MAX_LINES), MAX_LINES);
+        const slice = lines.slice(offset - 1, offset - 1 + limit);
+        const body = slice
+            .map((l, i) => `${offset + i}\t${l.length > MAX_LINE_CHARS ? l.slice(0, MAX_LINE_CHARS) + "…" : l}`)
+            .join("\n");
+        const remaining = lines.length - (offset - 1 + slice.length);
+        return remaining > 0 ? `${body}\n… [${remaining} more lines. Use offset=${offset + slice.length}]` : body;
+    },
+};
+export const writeTool = {
+    name: "write",
+    description: "Create or overwrite a file. Overwriting an existing file requires reading it first.",
+    kind: "mutate",
+    parameters: {
+        type: "object",
+        properties: {
+            file_path: { type: "string" },
+            content: { type: "string" },
+        },
+        required: ["file_path", "content"],
+    },
+    summarize: (i) => `write ${i.file_path}`,
+    async run(input, ctx) {
+        const file = resolve(ctx.cwd, str(input.file_path));
+        const exists = await fs.access(file).then(() => true, () => false);
+        if (exists && !ctx.readFiles.has(file)) {
+            throw new Error(`${file} exists. Read it before overwriting`);
+        }
+        await fs.mkdir(path.dirname(file), { recursive: true });
+        const content = str(input.content);
+        await fs.writeFile(file, content, "utf8");
+        ctx.readFiles.add(file);
+        return `Wrote ${content.split("\n").length} lines to ${file}`;
+    },
+};
+export const editTool = {
+    name: "edit",
+    description: "Replace an exact string in a file (must be unique unless replace_all). Read the file first; match its exact indentation.",
+    kind: "mutate",
+    parameters: {
+        type: "object",
+        properties: {
+            file_path: { type: "string" },
+            old_string: { type: "string" },
+            new_string: { type: "string" },
+            replace_all: { type: "boolean" },
+        },
+        required: ["file_path", "old_string", "new_string"],
+    },
+    summarize: (i) => `edit ${i.file_path}`,
+    async run(input, ctx) {
+        const file = resolve(ctx.cwd, str(input.file_path));
+        if (!ctx.readFiles.has(file))
+            throw new Error(`Read ${file} before editing it`);
+        const oldStr = str(input.old_string);
+        const newStr = str(input.new_string);
+        if (oldStr === newStr)
+            throw new Error("old_string and new_string are identical");
+        const raw = await fs.readFile(file, "utf8");
+        const count = raw.split(oldStr).length - 1;
+        if (count === 0)
+            throw new Error(`old_string not found in ${file}, re-read the file; match exact text`);
+        if (count > 1 && !input.replace_all) {
+            throw new Error(`old_string appears ${count} times. Add more context to make it unique, or set replace_all`);
+        }
+        const next = input.replace_all ? raw.split(oldStr).join(newStr) : raw.replace(oldStr, newStr);
+        await fs.writeFile(file, next, "utf8");
+        return `Replaced ${input.replace_all ? count : 1} occurrence(s) in ${file}`;
+    },
+};
+export { truncate };
+//# sourceMappingURL=fs-tools.js.map

package/dist/tools/registry.d.ts

@@ -0,0 +1,5 @@
+import type { ToolDef } from "./types.js";
+import type { ToolSchema } from "../model/openrouter.js";
+export declare const CORE_TOOLS: ToolDef[];
+export declare function getTool(name: string): ToolDef | undefined;
+export declare function toolSchemas(): ToolSchema[];

package/dist/tools/registry.js

@@ -0,0 +1,12 @@
+import { toSchema } from "./types.js";
+import { readTool, writeTool, editTool } from "./fs-tools.js";
+import { globTool, grepTool } from "./search-tools.js";
+import { bashTool } from "./bash.js";
+export const CORE_TOOLS = [readTool, writeTool, editTool, globTool, grepTool, bashTool];
+export function getTool(name) {
+    return CORE_TOOLS.find((t) => t.name === name);
+}
+export function toolSchemas() {
+    return CORE_TOOLS.map(toSchema);
+}
+//# sourceMappingURL=registry.js.map

package/dist/tools/search-tools.d.ts

@@ -0,0 +1,3 @@
+import { type ToolDef } from "./types.js";
+export declare const globTool: ToolDef;
+export declare const grepTool: ToolDef;

package/dist/tools/search-tools.js

@@ -0,0 +1,84 @@
+import { glob as fsGlob } from "node:fs/promises";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { str, truncate } from "./types.js";
+const pExecFile = promisify(execFile);
+const SKIP = /(^|\/)(node_modules|\.git|dist|build|\.next)(\/|$)/;
+export const globTool = {
+    name: "glob",
+    description: 'Find files by glob pattern, e.g. "**/*.ts" or "src/**/config.*". Returns paths relative to cwd.',
+    kind: "read",
+    parameters: {
+        type: "object",
+        properties: {
+            pattern: { type: "string" },
+            path: { type: "string", description: "Base directory (default: cwd)" },
+        },
+        required: ["pattern"],
+    },
+    summarize: (i) => `glob ${i.pattern}`,
+    async run(input, ctx) {
+        const results = [];
+        for await (const entry of fsGlob(str(input.pattern), {
+            cwd: input.path ? String(input.path) : ctx.cwd,
+        })) {
+            if (SKIP.test(entry))
+                continue;
+            results.push(entry);
+            if (results.length >= 500)
+                break;
+        }
+        if (!results.length)
+            return "No files matched.";
+        results.sort();
+        return results.join("\n") + (results.length >= 500 ? "\n… [capped at 500]" : "");
+    },
+};
+export const grepTool = {
+    name: "grep",
+    description: "Search file contents with a regex (POSIX extended). Returns file:line:text matches.",
+    kind: "read",
+    parameters: {
+        type: "object",
+        properties: {
+            pattern: { type: "string" },
+            path: { type: "string", description: "File or directory to search (default: cwd)" },
+            include: { type: "string", description: 'Only files matching this glob, e.g. "*.ts"' },
+            case_insensitive: { type: "boolean" },
+        },
+        required: ["pattern"],
+    },
+    summarize: (i) => `grep ${i.pattern}`,
+    async run(input, ctx) {
+        const args = [
+            "-rnE",
+            "-I",
+            "--exclude-dir=node_modules",
+            "--exclude-dir=.git",
+            "--exclude-dir=dist",
+            "--exclude-dir=build",
+        ];
+        if (input.case_insensitive)
+            args.push("-i");
+        if (input.include)
+            args.push(`--include=${String(input.include)}`);
+        args.push("-e", str(input.pattern), input.path ? String(input.path) : ".");
+        try {
+            const { stdout } = await pExecFile("grep", args, {
+                cwd: ctx.cwd,
+                maxBuffer: 10 * 1024 * 1024,
+            });
+            const lines = stdout.trimEnd().split("\n");
+            const capped = lines.slice(0, 250);
+            return (capped.map((l) => truncate(l, 400)).join("\n") +
+                (lines.length > 250 ? `\n… [${lines.length - 250} more matches]` : ""));
+        }
+        catch (err) {
+            const e = err;
+            if (e.code === 1)
+                return "No matches.";
+            throw new Error(`grep failed: ${e.message}`);
+        }
+    },
+};
+//# sourceMappingURL=search-tools.js.map

package/dist/tools/types.d.ts

@@ -0,0 +1,27 @@
+import type { ToolSchema } from "../model/openrouter.js";
+/** read: always auto-allowed · mutate: file changes · exec: arbitrary commands */
+export type ToolKind = "read" | "mutate" | "exec";
+export interface ToolContext {
+    cwd: string;
+    /** Absolute paths read this session. Write/edit require reading existing files first. */
+    readFiles: Set<string>;
+    /**
+     * Set when the session can delegate I/O to a worker model. Its presence is
+     * what arms the read tool's size gate: with no worker to redirect to, a
+     * refusal would leave the agent with no way to see the file at all.
+     */
+    delegation?: {
+        minLines: number;
+    };
+}
+export interface ToolDef {
+    name: string;
+    description: string;
+    kind: ToolKind;
+    parameters: Record<string, unknown>;
+    summarize(input: Record<string, unknown>): string;
+    run(input: Record<string, unknown>, ctx: ToolContext): Promise<string>;
+}
+export declare function toSchema(t: ToolDef): ToolSchema;
+export declare function str(v: unknown): string;
+export declare function truncate(s: string, max: number): string;

package/dist/tools/types.js

@@ -0,0 +1,15 @@
+export function toSchema(t) {
+    return {
+        type: "function",
+        function: { name: t.name, description: t.description, parameters: t.parameters },
+    };
+}
+export function str(v) {
+    if (typeof v !== "string")
+        throw new Error("expected a string");
+    return v;
+}
+export function truncate(s, max) {
+    return s.length > max ? s.slice(0, max) + `\n… [truncated ${s.length - max} chars]` : s;
+}
+//# sourceMappingURL=types.js.map

package/dist/types.d.ts

@@ -0,0 +1,130 @@
+export type PermissionMode = "default" | "accept-edits" | "plan" | "bypass";
+export interface UsageTotals {
+    inputTokens: number;
+    cachedTokens: number;
+    outputTokens: number;
+    requests: number;
+}
+export interface ToolCallRequest {
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+}
+export type AgentEvent = {
+    type: "text_delta";
+    text: string;
+}
+/** Auto routing resolved this turn's model, hosts surface it (PLAN.md §5.5 transparency). */
+ | {
+    type: "model_selected";
+    model: string;
+    complexity: string;
+    reason: string;
+}
+/** History was summarised to stay inside the context window. */
+ | {
+    type: "compacted";
+    beforeTokens: number;
+    afterTokens: number;
+} | {
+    type: "tool_start";
+    call: ToolCallRequest;
+    summary: string;
+} | {
+    type: "tool_end";
+    call: ToolCallRequest;
+    output: string;
+    isError: boolean;
+    durationMs: number;
+} | {
+    type: "permission_denied";
+    call: ToolCallRequest;
+    summary: string;
+} | {
+    type: "turn_end";
+    usage: UsageTotals;
+} | {
+    type: "error";
+    message: string;
+    code?: string;
+};
+export interface PermissionRequest {
+    tool: string;
+    summary: string;
+    input: Record<string, unknown>;
+}
+/** Host-provided gate for tool calls the mode doesn't auto-allow. */
+export type PermissionDecider = (req: PermissionRequest) => Promise<boolean>;
+export interface AskUserQuestion {
+    question: string;
+    options?: string[];
+}
+/** Host-provided handler for the ask_user tool. Returns the user's answer. */
+export type AskUserHandler = (q: AskUserQuestion) => Promise<string>;
+export interface SessionOptions {
+    /** OpenRouter key (BYOK), or a 9th Protocol access token when `platform` is set. */
+    apiKey: string;
+    /** A model id, or `"auto"` to route per turn (PLAN.md §5.5). See `autoRouter`. */
+    model: string;
+    cwd: string;
+    mode?: PermissionMode;
+    decide?: PermissionDecider;
+    askUser?: AskUserHandler;
+    maxTurnsPerMessage?: number;
+    /**
+     * Route through the 9th Protocol API (metered, server-assembled system prompt)
+     * instead of calling OpenRouter directly.
+     */
+    platform?: {
+        baseUrl: string;
+    };
+    /** Connected MCP servers whose tools join the session (share one manager per process). */
+    mcp?: import("./mcp.js").McpManager;
+    /** "read-only" restricts to read-kind tools (explore sub-agents). */
+    toolset?: "all" | "read-only";
+    /** Sub-agent nesting depth (internal). Task tool disappears at depth 2. */
+    depth?: number;
+    /**
+     * Config for `model: "auto"`. `catalog` comes from GET /v1/models so routing
+     * respects plan locks; omit it in BYOK mode, where every model is allowed.
+     */
+    autoRouter?: {
+        bias?: import("./model/router.js").RouterBias;
+        catalog?: import("./model/router.js").RouterCandidate[];
+    };
+    /** Sub-agent kind (internal), explore agents route to economy models. */
+    subagent?: "explore" | "general";
+    /**
+     * Reuse an existing session id instead of generating one. Sub-agents pass the
+     * parent's so their spend rolls into the same session; hosts can pass a stored
+     * id to continue a session across process restarts.
+     */
+    sessionId?: string;
+    /** Set false to disable automatic compaction (`/compact` still works). */
+    autoCompact?: boolean;
+    /** Context window override when the catalog has no entry for the model. */
+    contextTokens?: number;
+    /** Model used to summarise history. Defaults to a cheap long-context one. */
+    compactionModel?: string;
+    /**
+     * I/O delegation (`delegate.ts`): bulk reads and boilerplate run on a worker
+     * model so their payload never enters this session's context. On by default.
+     * Turning it off also disarms the read tool's size gate, since a refusal with
+     * nowhere to redirect to would just be a broken read.
+     */
+    delegation?: {
+        enabled?: boolean;
+        /** Worker model. Defaults to the cheapest model the plan allows. */
+        model?: string;
+        /** Whole-file reads above this many lines are refused. */
+        minLines?: number;
+    };
+}
+/** What delegation kept out of the context, for hosts that want to show it. */
+export interface DelegationTotals {
+    calls: number;
+    /** Tokens of file corpus that never entered the conversation. */
+    contextTokensSaved: number;
+    /** What the worker model actually cost. Delegation is cheaper, not free. */
+    workerUsage: UsageTotals;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/vault.d.ts

@@ -0,0 +1,13 @@
+/** Project config at <cwd>/.9p/config.json */
+export interface ProjectConfig {
+    /** Path to the Obsidian-style vault (absolute, or relative to the project). */
+    vault?: string;
+}
+export declare function loadProjectConfig(cwd: string): ProjectConfig;
+export declare function saveProjectConfig(cwd: string, cfg: ProjectConfig): void;
+/** Absolute vault path if configured and existing, else null. */
+export declare function resolveVault(cwd: string): string | null;
+/** Create the vault structure. Returns the files created (existing files untouched). */
+export declare function scaffoldVault(vaultPath: string): string[];
+/** Standing rules injected into the system prompt when a vault is configured. */
+export declare function vaultProtocol(vaultPath: string): string;

package/dist/vault.js

@@ -0,0 +1,81 @@
+import fs from "node:fs";
+import path from "node:path";
+export function loadProjectConfig(cwd) {
+    try {
+        return JSON.parse(fs.readFileSync(path.join(cwd, ".9p", "config.json"), "utf8"));
+    }
+    catch {
+        return {};
+    }
+}
+export function saveProjectConfig(cwd, cfg) {
+    const dir = path.join(cwd, ".9p");
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(path.join(dir, "config.json"), JSON.stringify(cfg, null, 2) + "\n");
+}
+/** Absolute vault path if configured and existing, else null. */
+export function resolveVault(cwd) {
+    const cfg = loadProjectConfig(cwd);
+    if (!cfg.vault)
+        return null;
+    const abs = path.resolve(cwd, cfg.vault);
+    return fs.existsSync(abs) ? abs : null;
+}
+const INDEX_MD = `# Vault index
+
+Master map of this vault. Every note should be reachable from here via [[wiki links]].
+
+## Sections
+- [[jobs/README|Jobs]], reusable procedures the agent follows step by step
+- [[decisions/README|Decisions]], what was decided and why
+- daily/, one note per working day; the newest note is the current state of work
+- projects/. One folder per project; each has a master note named after its folder
+- graph/, generated codebase maps (run \`9p map\` to create or refresh)
+`;
+const JOBS_README = `# Jobs
+
+Reusable procedures ("do X" playbooks). One note per job, named after the job.
+The note lists numbered steps and [[wiki links]] to every note the job depends on -
+reading the job note should give the agent everything it needs to do the job.
+`;
+const DECISIONS_README = `# Decisions
+
+One note per significant decision: what was decided, why, alternatives rejected,
+and [[wiki links]] to affected notes/files. Newest decisions at the top of each note.
+`;
+const DAILY_README = `# Daily notes
+
+One note per working day, named YYYY-MM-DD.md. Format: a short index of the day's
+entries at the top, details below. Written by the agent at the end of significant work -
+this is how sessions (and multiple agents) stay in sync.
+`;
+/** Create the vault structure. Returns the files created (existing files untouched). */
+export function scaffoldVault(vaultPath) {
+    const created = [];
+    const writeIfMissing = (rel, content) => {
+        const file = path.join(vaultPath, rel);
+        if (fs.existsSync(file))
+            return;
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        fs.writeFileSync(file, content);
+        created.push(file);
+    };
+    fs.mkdirSync(path.join(vaultPath, "projects"), { recursive: true });
+    fs.mkdirSync(path.join(vaultPath, "graph"), { recursive: true });
+    writeIfMissing("INDEX.md", INDEX_MD);
+    writeIfMissing("jobs/README.md", JOBS_README);
+    writeIfMissing("decisions/README.md", DECISIONS_README);
+    writeIfMissing("daily/README.md", DAILY_README);
+    return created;
+}
+/** Standing rules injected into the system prompt when a vault is configured. */
+export function vaultProtocol(vaultPath) {
+    return `Vault memory protocol. This project keeps long-term memory in an Obsidian-style vault at: ${vaultPath}
+- The vault is your memory. For unfamiliar tasks, first read ${vaultPath}/INDEX.md and follow the relevant [[wiki links]] instead of re-exploring from scratch.
+- Append to existing notes rather than creating new ones, unless a genuinely new topic demands its own note. Bloat is the enemy.
+- Connect notes with [[wiki links]] and keep INDEX.md pointing at anything new.
+- After completing significant work, log it in ${vaultPath}/daily/YYYY-MM-DD.md using today's date from your context (never guess the date): short index at the top of the note, details below.
+- Record important decisions and their reasons in ${vaultPath}/decisions/.
+- If ${vaultPath}/graph/ contains codebase maps, consult them before broadly re-reading raw files.`;
+}
+//# sourceMappingURL=vault.js.map

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@9thprotocol/agent-core",
+  "version": "0.1.0",
+  "description": "9th Protocol agent engine: loop, tools, permissions, sub-agents, context management",
+  "license": "SEE LICENSE IN LICENSE",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": ["dist", "LICENSE", "README.md"],
+  "publishConfig": { "access": "public" },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Samso9th/9th-protocol-packages"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.11.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.5",
+    "typescript": "^5.7.3"
+  }
+}