@agentproto/agent-runtime 0.1.0-alpha.0

package/dist/manifest.d.ts

@@ -0,0 +1,56 @@
+import { z } from 'zod';
+
+/**
+ * MultiAgentRuntime manifest schema + loader.
+ *
+ * The manifest is markdown with YAML frontmatter (matching @agentproto's
+ * doctype convention used by ROLE.md, OPERATOR.md, etc.). The frontmatter
+ * is the structured contract; the markdown body is human-readable
+ * documentation of what the swarm does.
+ *
+ * Loader is filesystem-bound but parsing is pure — the schema can be used
+ * by tests with inline strings via `parseManifest()`.
+ */
+
+declare const MULTI_AGENT_RUNTIME_SCHEMA = "agentruntimes/v1";
+declare const MULTI_AGENT_RUNTIME_KIND = "MultiAgentRuntime";
+declare const MultiAgentRuntimeManifestSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"agentruntimes/v1">;
+    kind: z.ZodLiteral<"MultiAgentRuntime">;
+    id: z.ZodString;
+    participants: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        executor: z.ZodString;
+        displayName: z.ZodOptional<z.ZodString>;
+        role: z.ZodOptional<z.ZodString>;
+        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$loose>>;
+    substrate: z.ZodObject<{
+        kind: z.ZodString;
+    }, z.core.$loose>;
+    dispatcher: z.ZodObject<{
+        kind: z.ZodString;
+    }, z.core.$loose>;
+    state: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodString;
+    }, z.core.$loose>>;
+    lifecycle: z.ZodOptional<z.ZodObject<{
+        onTurnEnd: z.ZodOptional<z.ZodBoolean>;
+        onMention: z.ZodOptional<z.ZodBoolean>;
+        onIdle: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$loose>;
+type MultiAgentRuntimeManifest = z.infer<typeof MultiAgentRuntimeManifestSchema>;
+type LoadedManifest = {
+    readonly manifest: MultiAgentRuntimeManifest;
+    readonly body: string;
+    readonly path: string;
+    /** Absolute directory of the manifest file — adapter configs that reference paths resolve relative to this. */
+    readonly baseDir: string;
+};
+declare function parseManifest(source: string): MultiAgentRuntimeManifest;
+declare function loadManifest(path: string): Promise<LoadedManifest>;
+/** Resolve a path string from a manifest field, relative to the manifest's directory. */
+declare function resolveManifestPath(loaded: LoadedManifest, value: string): string;
+
+export { type LoadedManifest, MULTI_AGENT_RUNTIME_KIND, MULTI_AGENT_RUNTIME_SCHEMA, type MultiAgentRuntimeManifest, MultiAgentRuntimeManifestSchema, loadManifest, parseManifest, resolveManifestPath };

package/dist/manifest.mjs

@@ -0,0 +1,61 @@
+import { readFile } from 'fs/promises';
+import { resolve, dirname } from 'path';
+import matter from 'gray-matter';
+import { z } from 'zod';
+
+/**
+ * @agentproto/agent-runtime v0.1.0-alpha
+ * MultiAgentRuntime kernel — swappable ports + reference adapters
+ * (file substrate, mention dispatcher, fs state, agent-cli participant).
+ * Transport-specific adapters ship in separate packages.
+ */
+
+var MULTI_AGENT_RUNTIME_SCHEMA = "agentruntimes/v1";
+var MULTI_AGENT_RUNTIME_KIND = "MultiAgentRuntime";
+var AdapterConfigSchema = z.object({
+  kind: z.string().min(1)
+}).loose();
+var ParticipantManifestSchema = z.object({
+  id: z.string().min(1),
+  executor: z.string().min(1),
+  displayName: z.string().min(1).optional(),
+  role: z.string().optional(),
+  meta: z.record(z.string(), z.unknown()).optional()
+}).loose();
+var MultiAgentRuntimeManifestSchema = z.object({
+  schema: z.literal(MULTI_AGENT_RUNTIME_SCHEMA),
+  kind: z.literal(MULTI_AGENT_RUNTIME_KIND),
+  id: z.string().min(1),
+  participants: z.array(ParticipantManifestSchema).min(1),
+  substrate: AdapterConfigSchema,
+  dispatcher: AdapterConfigSchema,
+  state: AdapterConfigSchema.optional(),
+  lifecycle: z.object({
+    onTurnEnd: z.boolean().optional(),
+    onMention: z.boolean().optional(),
+    onIdle: z.boolean().optional()
+  }).optional()
+}).loose();
+function parseManifest(source) {
+  const parsed = matter(source);
+  return MultiAgentRuntimeManifestSchema.parse(parsed.data);
+}
+async function loadManifest(path) {
+  const abs = resolve(path);
+  const raw = await readFile(abs, "utf8");
+  const parsed = matter(raw);
+  const manifest = MultiAgentRuntimeManifestSchema.parse(parsed.data);
+  return {
+    manifest,
+    body: parsed.content,
+    path: abs,
+    baseDir: dirname(abs)
+  };
+}
+function resolveManifestPath(loaded, value) {
+  return resolve(loaded.baseDir, value);
+}
+
+export { MULTI_AGENT_RUNTIME_KIND, MULTI_AGENT_RUNTIME_SCHEMA, MultiAgentRuntimeManifestSchema, loadManifest, parseManifest, resolveManifestPath };
+//# sourceMappingURL=manifest.mjs.map
+//# sourceMappingURL=manifest.mjs.map

package/dist/manifest.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/manifest.ts"],"names":["resolvePath"],"mappings":";;;;;;;;;;;;AAiBO,IAAM,0BAAA,GAA6B;AACnC,IAAM,wBAAA,GAA2B;AAExC,IAAM,mBAAA,GAAsB,EACzB,MAAA,CAAO;AAAA,EACN,IAAA,EAAM,CAAA,CAAE,MAAA,EAAO,CAAE,IAAI,CAAC;AACxB,CAAC,EACA,KAAA,EAAM;AAET,IAAM,yBAAA,GAA4B,EAC/B,MAAA,CAAO;AAAA,EACN,EAAA,EAAI,CAAA,CAAE,MAAA,EAAO,CAAE,IAAI,CAAC,CAAA;AAAA,EACpB,QAAA,EAAU,CAAA,CAAE,MAAA,EAAO,CAAE,IAAI,CAAC,CAAA;AAAA,EAC1B,aAAa,CAAA,CAAE,MAAA,GAAS,GAAA,CAAI,CAAC,EAAE,QAAA,EAAS;AAAA,EACxC,IAAA,EAAM,CAAA,CAAE,MAAA,EAAO,CAAE,QAAA,EAAS;AAAA,EAC1B,IAAA,EAAM,CAAA,CAAE,MAAA,CAAO,CAAA,CAAE,MAAA,IAAU,CAAA,CAAE,OAAA,EAAS,CAAA,CAAE,QAAA;AAC1C,CAAC,EACA,KAAA,EAAM;AAEF,IAAM,+BAAA,GAAkC,EAC5C,MAAA,CAAO;AAAA,EACN,MAAA,EAAQ,CAAA,CAAE,OAAA,CAAQ,0BAA0B,CAAA;AAAA,EAC5C,IAAA,EAAM,CAAA,CAAE,OAAA,CAAQ,wBAAwB,CAAA;AAAA,EACxC,EAAA,EAAI,CAAA,CAAE,MAAA,EAAO,CAAE,IAAI,CAAC,CAAA;AAAA,EACpB,cAAc,CAAA,CAAE,KAAA,CAAM,yBAAyB,CAAA,CAAE,IAAI,CAAC,CAAA;AAAA,EACtD,SAAA,EAAW,mBAAA;AAAA,EACX,UAAA,EAAY,mBAAA;AAAA,EACZ,KAAA,EAAO,oBAAoB,QAAA,EAAS;AAAA,EACpC,SAAA,EAAW,EACR,MAAA,CAAO;AAAA,IACN,SAAA,EAAW,CAAA,CAAE,OAAA,EAAQ,CAAE,QAAA,EAAS;AAAA,IAChC,SAAA,EAAW,CAAA,CAAE,OAAA,EAAQ,CAAE,QAAA,EAAS;AAAA,IAChC,MAAA,EAAQ,CAAA,CAAE,OAAA,EAAQ,CAAE,QAAA;AAAS,GAC9B,EACA,QAAA;AACL,CAAC,EACA,KAAA;AAcI,SAAS,cAAc,MAAA,EAA2C;AACvE,EAAA,MAAM,MAAA,GAAS,OAAO,MAAM,CAAA;AAC5B,EAAA,OAAO,+BAAA,CAAgC,KAAA,CAAM,MAAA,CAAO,IAAI,CAAA;AAC1D;AAEA,eAAsB,aAAa,IAAA,EAAuC;AACxE,EAAA,MAAM,GAAA,GAAMA,QAAY,IAAI,CAAA;AAC5B,EAAA,MAAM,GAAA,GAAM,MAAM,QAAA,CAAS,GAAA,EAAK,MAAM,CAAA;AACtC,EAAA,MAAM,MAAA,GAAS,OAAO,GAAG,CAAA;AACzB,EAAA,MAAM,QAAA,GAAW,+BAAA,CAAgC,KAAA,CAAM,MAAA,CAAO,IAAI,CAAA;AAClE,EAAA,OAAO;AAAA,IACL,QAAA;AAAA,IACA,MAAM,MAAA,CAAO,OAAA;AAAA,IACb,IAAA,EAAM,GAAA;AAAA,IACN,OAAA,EAAS,QAAQ,GAAG;AAAA,GACtB;AACF;AAGO,SAAS,mBAAA,CAAoB,QAAwB,KAAA,EAAuB;AACjF,EAAA,OAAOA,OAAA,CAAY,MAAA,CAAO,OAAA,EAAS,KAAK,CAAA;AAC1C","file":"manifest.mjs","sourcesContent":["/**\n * MultiAgentRuntime manifest schema + loader.\n *\n * The manifest is markdown with YAML frontmatter (matching @agentproto's\n * doctype convention used by ROLE.md, OPERATOR.md, etc.). The frontmatter\n * is the structured contract; the markdown body is human-readable\n * documentation of what the swarm does.\n *\n * Loader is filesystem-bound but parsing is pure — the schema can be used\n * by tests with inline strings via `parseManifest()`.\n */\n\nimport { readFile } from \"node:fs/promises\"\nimport { resolve as resolvePath, dirname } from \"node:path\"\nimport matter from \"gray-matter\"\nimport { z } from \"zod\"\n\nexport const MULTI_AGENT_RUNTIME_SCHEMA = \"agentruntimes/v1\"\nexport const MULTI_AGENT_RUNTIME_KIND = \"MultiAgentRuntime\"\n\nconst AdapterConfigSchema = z\n  .object({\n    kind: z.string().min(1),\n  })\n  .loose()\n\nconst ParticipantManifestSchema = z\n  .object({\n    id: z.string().min(1),\n    executor: z.string().min(1),\n    displayName: z.string().min(1).optional(),\n    role: z.string().optional(),\n    meta: z.record(z.string(), z.unknown()).optional(),\n  })\n  .loose()\n\nexport const MultiAgentRuntimeManifestSchema = z\n  .object({\n    schema: z.literal(MULTI_AGENT_RUNTIME_SCHEMA),\n    kind: z.literal(MULTI_AGENT_RUNTIME_KIND),\n    id: z.string().min(1),\n    participants: z.array(ParticipantManifestSchema).min(1),\n    substrate: AdapterConfigSchema,\n    dispatcher: AdapterConfigSchema,\n    state: AdapterConfigSchema.optional(),\n    lifecycle: z\n      .object({\n        onTurnEnd: z.boolean().optional(),\n        onMention: z.boolean().optional(),\n        onIdle: z.boolean().optional(),\n      })\n      .optional(),\n  })\n  .loose()\n\nexport type MultiAgentRuntimeManifest = z.infer<\n  typeof MultiAgentRuntimeManifestSchema\n>\n\nexport type LoadedManifest = {\n  readonly manifest: MultiAgentRuntimeManifest\n  readonly body: string\n  readonly path: string\n  /** Absolute directory of the manifest file — adapter configs that reference paths resolve relative to this. */\n  readonly baseDir: string\n}\n\nexport function parseManifest(source: string): MultiAgentRuntimeManifest {\n  const parsed = matter(source)\n  return MultiAgentRuntimeManifestSchema.parse(parsed.data)\n}\n\nexport async function loadManifest(path: string): Promise<LoadedManifest> {\n  const abs = resolvePath(path)\n  const raw = await readFile(abs, \"utf8\")\n  const parsed = matter(raw)\n  const manifest = MultiAgentRuntimeManifestSchema.parse(parsed.data)\n  return {\n    manifest,\n    body: parsed.content,\n    path: abs,\n    baseDir: dirname(abs),\n  }\n}\n\n/** Resolve a path string from a manifest field, relative to the manifest's directory. */\nexport function resolveManifestPath(loaded: LoadedManifest, value: string): string {\n  return resolvePath(loaded.baseDir, value)\n}\n"]}

package/dist/ports.d.ts

@@ -0,0 +1,165 @@
+/**
+ * Port contracts for the MultiAgentRuntime kernel.
+ *
+ * A runtime composes a Substrate + Dispatcher + StateStore + Participant
+ * Executors (one per `executor` kind). Each adapter declares its `kind`;
+ * the kernel dispatches polymorphically by looking up factories in the
+ * registry, never by matching kind strings inside the kernel itself.
+ */
+type ParticipantId = string;
+type TurnId = string;
+type Turn = {
+    readonly id: TurnId;
+    readonly participantId: ParticipantId;
+    readonly content: string;
+    readonly timestamp: string;
+    readonly meta?: Readonly<Record<string, unknown>>;
+};
+type TurnInput = Omit<Turn, "id" | "timestamp"> & {
+    readonly timestamp?: string;
+};
+interface Substrate {
+    readonly kind: string;
+    /** Append a turn. Returns the materialised Turn with id + timestamp. */
+    append(turn: TurnInput): Promise<Turn>;
+    /** Snapshot. If `since` is provided, returns turns strictly newer than that TurnId, oldest first. */
+    read(since?: TurnId): Promise<readonly Turn[]>;
+}
+type ParticipantDescriptor = {
+    readonly id: ParticipantId;
+    readonly displayName: string;
+    /** Executor kind — keys into RuntimePorts.executors. e.g. "agent-cli". */
+    readonly executor: string;
+    readonly role?: string;
+    readonly meta?: Readonly<Record<string, unknown>>;
+};
+type ParticipantExecuteInput = {
+    readonly participant: ParticipantDescriptor;
+    readonly recentTurns: readonly Turn[];
+    readonly triggerTurn: Turn;
+    readonly state: Readonly<Record<string, unknown>>;
+    readonly signal?: AbortSignal;
+};
+type ParticipantExecuteOutput = {
+    readonly content: string;
+    readonly meta?: Readonly<Record<string, unknown>>;
+    readonly stateUpdate?: Readonly<Record<string, unknown>>;
+};
+interface ParticipantExecutor {
+    readonly kind: string;
+    executeTurn(input: ParticipantExecuteInput): Promise<ParticipantExecuteOutput>;
+}
+type DispatcherInput = {
+    readonly recentTurns: readonly Turn[];
+    readonly participants: readonly ParticipantDescriptor[];
+};
+interface Dispatcher {
+    readonly kind: string;
+    /**
+     * Inspect recent turns and return the participants who should speak next.
+     * Empty array = no one speaks, the runtime stays idle.
+     */
+    selectNext(input: DispatcherInput): Promise<readonly ParticipantId[]>;
+}
+interface StateStore {
+    readonly kind: string;
+    read(participantId: ParticipantId): Promise<Readonly<Record<string, unknown>>>;
+    write(participantId: ParticipantId, state: Readonly<Record<string, unknown>>): Promise<void>;
+}
+interface Lifecycle {
+    onTurnEnd?(turn: Turn): Promise<void> | void;
+    onMention?(target: ParticipantId, byTurn: Turn): Promise<void> | void;
+    onIdle?(): Promise<void> | void;
+}
+/**
+ * Discriminated union of every event the kernel emits during a cycle.
+ *
+ * Every event carries `cycleId` (a per-cycle ULID-ish identifier) and
+ * `at` (ISO timestamp), so a sink can rebuild OTEL-style spans by
+ * grouping on cycleId.
+ *
+ * Sinks MUST tolerate unknown kinds — future kernel versions may add
+ * event types under the same `agentproto/telemetry/v1` schema.
+ */
+type TelemetryEvent = {
+    readonly kind: "cycle.started";
+    readonly cycleId: string;
+    readonly at: string;
+    readonly since?: TurnId;
+} | {
+    readonly kind: "substrate.read";
+    readonly cycleId: string;
+    readonly at: string;
+    readonly substrateKind: string;
+    readonly turnCount: number;
+    readonly durationMs: number;
+} | {
+    readonly kind: "dispatch.decided";
+    readonly cycleId: string;
+    readonly at: string;
+    readonly dispatcherKind: string;
+    readonly selected: readonly ParticipantId[];
+    readonly durationMs: number;
+} | {
+    readonly kind: "participant.started";
+    readonly cycleId: string;
+    readonly at: string;
+    readonly participantId: ParticipantId;
+    readonly executorKind: string;
+} | {
+    readonly kind: "participant.finished";
+    readonly cycleId: string;
+    readonly at: string;
+    readonly participantId: ParticipantId;
+    readonly executorKind: string;
+    readonly durationMs: number;
+    readonly contentLength: number;
+} | {
+    readonly kind: "participant.failed";
+    readonly cycleId: string;
+    readonly at: string;
+    readonly participantId: ParticipantId;
+    readonly executorKind: string;
+    readonly error: string;
+} | {
+    readonly kind: "substrate.appended";
+    readonly cycleId: string;
+    readonly at: string;
+    readonly turnId: TurnId;
+    readonly participantId: ParticipantId;
+} | {
+    readonly kind: "state.written";
+    readonly cycleId: string;
+    readonly at: string;
+    readonly participantId: ParticipantId;
+} | {
+    readonly kind: "cycle.idle";
+    readonly cycleId: string;
+    readonly at: string;
+} | {
+    readonly kind: "cycle.finished";
+    readonly cycleId: string;
+    readonly at: string;
+    readonly outcome: "executed" | "idle";
+    readonly turnsAppended: number;
+    readonly durationMs: number;
+};
+interface Telemetry {
+    emit(event: TelemetryEvent): void;
+}
+type RuntimePorts = {
+    readonly substrate: Substrate;
+    readonly dispatcher: Dispatcher;
+    readonly state: StateStore;
+    readonly lifecycle?: Lifecycle;
+    /**
+     * Optional structured-event sink. Wire to log lines, an OTEL exporter,
+     * an in-memory array (tests), or anything else. When omitted, the
+     * kernel skips emission entirely — zero overhead.
+     */
+    readonly telemetry?: Telemetry;
+    readonly participants: readonly ParticipantDescriptor[];
+    readonly executors: ReadonlyMap<string, ParticipantExecutor>;
+};
+
+export type { Dispatcher, DispatcherInput, Lifecycle, ParticipantDescriptor, ParticipantExecuteInput, ParticipantExecuteOutput, ParticipantExecutor, ParticipantId, RuntimePorts, StateStore, Substrate, Telemetry, TelemetryEvent, Turn, TurnId, TurnInput };

package/dist/ports.mjs

@@ -0,0 +1,3 @@
+
+//# sourceMappingURL=ports.mjs.map
+//# sourceMappingURL=ports.mjs.map

package/dist/ports.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"ports.mjs"}

package/dist/util/mention-parser.d.mts

@@ -0,0 +1,8 @@
+/**
+ * Type sidecar for `mention-parser.mjs`. The implementation file is
+ * vanilla JavaScript so runtime profiles can stamp its source into
+ * Claude Code hooks at build time; this `.d.mts` keeps the TS-side
+ * type contract crisp.
+ */
+
+export function textContainsMention(text: string, name: string): boolean

package/dist/util/mention-parser.mjs

@@ -0,0 +1,33 @@
+/**
+ * Canonical @-mention parser.
+ *
+ * Lives as raw JavaScript (no types) because it's consumed in two
+ * places that don't share a build:
+ *
+ *   1. The kernel imports `textContainsMention` from this file as a
+ *      normal ESM module (the dispatcher in `adapters/dispatcher-mention.ts`).
+ *
+ *   2. Runtime profiles inline this file's source into Claude Code
+ *      hooks at profile-build time, because `.claude/` has no
+ *      module-resolution at hook-execution time. The build script
+ *      reads this file as text and stamps it into the hook template.
+ *
+ * Two cases:
+ *   1. Literal `@<name>` substring (case-sensitive, full name).
+ *   2. For multi-word names, also `@<firstName>` with non-word
+ *      boundary (case-insensitive).
+ *
+ * Edit here only — both consumers stay in sync via build pipelines.
+ */
+
+/** @param {string} text @param {string} name @returns {boolean} */
+export function textContainsMention(text, name) {
+  if (text.includes(`@${name}`)) return true
+  if (name.includes(" ")) {
+    const firstName = name.split(" ")[0]?.trim()
+    if (!firstName) return false
+    const regex = new RegExp(`@${firstName}(?!\\w)`, "i")
+    return regex.test(text)
+  }
+  return false
+}

package/package.json

@@ -0,0 +1,108 @@
+{
+  "name": "@agentproto/agent-runtime",
+  "version": "0.1.0-alpha.0",
+  "description": "@agentproto/agent-runtime — MultiAgentRuntime kernel: swappable ports (substrate, dispatcher, participant executors, state, lifecycle, effectors) plus reference adapters (file journal substrate, mention dispatcher, fs state store, agent-cli participant). Transport-specific adapters (chat servers, MCP bridges, etc.) ship in separate packages and register through the agentproto CLI's plugin API.",
+  "keywords": [
+    "agentproto",
+    "agent-runtime",
+    "multi-agent",
+    "swarm",
+    "substrate",
+    "dispatcher"
+  ],
+  "homepage": "https://agentproto.sh",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/agentproto/ts",
+    "directory": "packages/agent-runtime"
+  },
+  "bugs": {
+    "url": "https://github.com/agentproto/ts/issues"
+  },
+  "license": "MIT",
+  "type": "module",
+  "main": "dist/index.mjs",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    },
+    "./ports": {
+      "types": "./dist/ports.d.ts",
+      "import": "./dist/ports.mjs",
+      "default": "./dist/ports.mjs"
+    },
+    "./manifest": {
+      "types": "./dist/manifest.d.ts",
+      "import": "./dist/manifest.mjs",
+      "default": "./dist/manifest.mjs"
+    },
+    "./adapters/substrate-file": {
+      "types": "./dist/adapters/substrate-file.d.ts",
+      "import": "./dist/adapters/substrate-file.mjs",
+      "default": "./dist/adapters/substrate-file.mjs"
+    },
+    "./adapters/dispatcher-mention": {
+      "types": "./dist/adapters/dispatcher-mention.d.ts",
+      "import": "./dist/adapters/dispatcher-mention.mjs",
+      "default": "./dist/adapters/dispatcher-mention.mjs"
+    },
+    "./adapters/state-fs": {
+      "types": "./dist/adapters/state-fs.d.ts",
+      "import": "./dist/adapters/state-fs.mjs",
+      "default": "./dist/adapters/state-fs.mjs"
+    },
+    "./adapters/participant-agent-cli": {
+      "types": "./dist/adapters/participant-agent-cli.d.ts",
+      "import": "./dist/adapters/participant-agent-cli.mjs",
+      "default": "./dist/adapters/participant-agent-cli.mjs"
+    },
+    "./adapters/telemetry": {
+      "types": "./dist/adapters/telemetry.d.ts",
+      "import": "./dist/adapters/telemetry.mjs",
+      "default": "./dist/adapters/telemetry.mjs"
+    },
+    "./util/mention-parser": {
+      "types": "./dist/util/mention-parser.d.mts",
+      "import": "./dist/util/mention-parser.mjs",
+      "default": "./dist/util/mention-parser.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "ARCHITECTURE.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "gray-matter": "^4.0.3",
+    "zod": "^4.4.3",
+    "@agentproto/cli-exec": "0.1.0-alpha.1"
+  },
+  "devDependencies": {
+    "@types/node": "^25.6.2",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "vitest": "^3.2.4",
+    "@agentproto/tooling": "0.1.0-alpha.0"
+  },
+  "engines": {
+    "node": ">=20.9.0"
+  },
+  "scripts": {
+    "dev": "tsup --watch",
+    "build": "tsup",
+    "postbuild": "node scripts/copy-sidecars.mjs",
+    "clean": "rm -rf dist",
+    "check-types": "tsc --noEmit",
+    "test": "vitest run --passWithNoTests",
+    "test:watch": "vitest"
+  }
+}