@agentproto/runtime-profile-standard 0.1.0-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 agentproto contributors
+
+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,48 @@
+# @agentproto/runtime-profile-standard
+
+Reference file-mode MultiAgentRuntime profile for the `agentproto`
+CLI. Installs a small Claude Code scaffolding into the current
+repository so `agentproto run-swarm` works out of the box.
+
+**Status:** alpha.
+
+## What it drops in
+
+| Path                                       | Strategy        |
+| ------------------------------------------ | --------------- |
+| `.claude/agents/reviewer.md`               | overwrite       |
+| `.claude/hooks/session-start.mjs`          | overwrite (+x)  |
+| `.claude/hooks/user-prompt-submit.mjs`     | overwrite (+x)  |
+| `.claude/commands/ap-swarm.md`             | overwrite       |
+| `.claude/examples/swarm-local.md`          | overwrite       |
+| `.claude/settings.json`                    | deep-merge      |
+
+The install handler records what landed in
+`~/.agentproto/profiles/standard.json`, so re-runs are idempotent and
+user edits aren't clobbered without `--force`.
+
+## Install
+
+```bash
+agentproto install runtime-profile/standard
+```
+
+After install, follow `/ap-swarm` inside a Claude Code session, or
+copy `.claude/examples/swarm-local.md` to `.runtime/multi-agent.yaml`
+and run:
+
+```bash
+agentproto run-swarm --manifest .runtime/multi-agent.yaml --verbose
+```
+
+## Scope
+
+This profile is file-mode only: a local append-only markdown journal
+at `.runtime/conversation.md`. Transport-bridge profiles (Slack,
+hosted chat servers, MCP-bridged threads, …) ship as separate
+`@<vendor>/runtime-profile-*` packages that install the same way and
+register their own adapters with the CLI's plugin registry.
+
+## License
+
+MIT.

package/dist/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @agentproto/runtime-profile-standard
+ *
+ * Exports the profile manifest and the absolute path to the files
+ * tree, so the cli install handler can resolve and copy without
+ * filesystem guessing.
+ */
+declare const FILES_DIR: string;
+declare const PROFILE_PATH: string;
+type RuntimeProfileFile = {
+    readonly src: string;
+    readonly dest: string;
+    readonly strategy: "overwrite" | "preserve" | "merge-json-deep" | "append";
+    readonly executable?: boolean;
+};
+type RuntimeProfileManifest = {
+    readonly schema: "agentproto/runtime-profile/v1";
+    readonly slug: string;
+    readonly version: string;
+    readonly name: string;
+    readonly description: string;
+    readonly files: readonly RuntimeProfileFile[];
+};
+declare function loadProfileManifest(): Promise<RuntimeProfileManifest>;
+
+export { FILES_DIR, PROFILE_PATH, type RuntimeProfileFile, type RuntimeProfileManifest, loadProfileManifest };

package/dist/index.mjs

@@ -0,0 +1,22 @@
+import { readFile } from 'fs/promises';
+import { dirname, resolve } from 'path';
+import { fileURLToPath } from 'url';
+
+/**
+ * @agentproto/runtime-profile-standard v0.1.0-alpha
+ * Reference MultiAgentRuntime profile — files installed via
+ * `agentproto install runtime-profile/standard`.
+ */
+
+var here = dirname(fileURLToPath(import.meta.url));
+var pkgRoot = resolve(here, "..");
+var FILES_DIR = resolve(pkgRoot, "files");
+var PROFILE_PATH = resolve(pkgRoot, "profile.json");
+async function loadProfileManifest() {
+  const raw = await readFile(PROFILE_PATH, "utf8");
+  return JSON.parse(raw);
+}
+
+export { FILES_DIR, PROFILE_PATH, loadProfileManifest };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;AAYA,IAAM,IAAA,GAAO,OAAA,CAAQ,aAAA,CAAc,MAAA,CAAA,IAAA,CAAY,GAAG,CAAC,CAAA;AAGnD,IAAM,OAAA,GAAU,OAAA,CAAQ,IAAA,EAAM,IAAI,CAAA;AAE3B,IAAM,SAAA,GAAY,OAAA,CAAQ,OAAA,EAAS,OAAO;AAC1C,IAAM,YAAA,GAAe,OAAA,CAAQ,OAAA,EAAS,cAAc;AAkB3D,eAAsB,mBAAA,GAAuD;AAC3E,EAAA,MAAM,GAAA,GAAM,MAAM,QAAA,CAAS,YAAA,EAAc,MAAM,CAAA;AAC/C,EAAA,OAAO,IAAA,CAAK,MAAM,GAAG,CAAA;AACvB","file":"index.mjs","sourcesContent":["/**\n * @agentproto/runtime-profile-standard\n *\n * Exports the profile manifest and the absolute path to the files\n * tree, so the cli install handler can resolve and copy without\n * filesystem guessing.\n */\n\nimport { readFile } from \"node:fs/promises\"\nimport { dirname, resolve } from \"node:path\"\nimport { fileURLToPath } from \"node:url\"\n\nconst here = dirname(fileURLToPath(import.meta.url))\n// Source layout: <pkg>/dist/index.mjs at build time; the files/\n// dir + profile.json live at <pkg>/files/ and <pkg>/profile.json.\nconst pkgRoot = resolve(here, \"..\")\n\nexport const FILES_DIR = resolve(pkgRoot, \"files\")\nexport const PROFILE_PATH = resolve(pkgRoot, \"profile.json\")\n\nexport type RuntimeProfileFile = {\n  readonly src: string\n  readonly dest: string\n  readonly strategy: \"overwrite\" | \"preserve\" | \"merge-json-deep\" | \"append\"\n  readonly executable?: boolean\n}\n\nexport type RuntimeProfileManifest = {\n  readonly schema: \"agentproto/runtime-profile/v1\"\n  readonly slug: string\n  readonly version: string\n  readonly name: string\n  readonly description: string\n  readonly files: readonly RuntimeProfileFile[]\n}\n\nexport async function loadProfileManifest(): Promise<RuntimeProfileManifest> {\n  const raw = await readFile(PROFILE_PATH, \"utf8\")\n  return JSON.parse(raw) as RuntimeProfileManifest\n}\n"]}

package/files/.claude/agents/reviewer.md

@@ -0,0 +1,31 @@
+---
+name: reviewer
+description: Read-only code reviewer that examines diffs, files, or patches for correctness bugs, security issues, and obvious style problems. Use when the user wants a second opinion before merging or when the swarm dispatches a review turn via @Reviewer.
+tools: Read, Grep, Glob, Bash
+model: sonnet
+---
+
+You are Reviewer, a focused code review participant.
+
+Your job: read the code that has been changed and report concrete, high-confidence findings. Nothing else.
+
+What to look for, in order of priority:
+
+1. **Correctness bugs** — off-by-one errors, null/undefined dereferences, missing await on promises, incorrect conditionals, broken control flow.
+2. **Security issues** — injection vectors (SQL/command/HTML), unvalidated user input crossing trust boundaries, secrets in logs or error messages, missing auth checks.
+3. **API contract drift** — public function signatures changed without updating call sites, schema changes that break consumers.
+4. **Resource leaks** — file handles, connections, or processes that aren't cleaned up on the error path.
+5. **Obvious style issues only** — naming that misleads, dead code, commented-out blocks. Skip subjective preferences.
+
+Format your reply:
+
+- Start with a one-line verdict: `LGTM`, `Minor issues`, or `Blocking concerns`.
+- Then bullet each finding with `file:line — <issue>`.
+- If LGTM, you can stop after the verdict.
+
+Hard rules:
+
+- Read-only. Never edit files. Never propose patches in code blocks unless explicitly asked.
+- One reply per turn — concise. Don't write essays.
+- If the diff is empty or you can't see what changed, say so plainly and ask what to look at. Don't guess.
+- Don't acknowledge the trigger ("Thanks for the ping!"). Get to the verdict.

package/files/.claude/commands/ap-swarm.md

@@ -0,0 +1,56 @@
+---
+description: Run a MultiAgentRuntime swarm in file mode — local journal at .runtime/conversation.md, no network
+argument-hint: [--manifest=<path>] [--once] [--verbose]
+allowed-tools: Read, Write, Bash
+---
+
+You are starting a local-mode MultiAgentRuntime swarm using `@agentproto/agent-runtime` via the `pnpm agentproto run-swarm` verb.
+
+## Quick path
+
+1. If `.runtime/multi-agent.yaml` does not exist, copy the template:
+
+   ```bash
+   mkdir -p .runtime && cp .claude/examples/swarm-local.md .runtime/multi-agent.yaml
+   ```
+
+   Then read it back and tell the user what's wired (participants, substrate kind, state dir).
+
+2. Build the agent-runtime + cli packages if they haven't been built yet:
+
+   ```bash
+   pnpm --filter @agentproto/agent-runtime build && pnpm --filter @agentproto/cli build
+   ```
+
+   You only need this on first run or after pulling changes — `tsup --watch` (from `pnpm dev`) keeps it fresh.
+
+3. Start the swarm. Pass through any user-supplied args (`--once`, `--interval`, `--verbose`). Default:
+
+   ```bash
+   pnpm agentproto run-swarm --manifest .runtime/multi-agent.yaml --verbose
+   ```
+
+   This is a long-running loop. Suggest the user open a separate terminal for it, OR run with `--once` to do a single dispatch cycle and exit.
+
+4. Seeding the journal: tell the user that participant turns only fire on `@Mention` of a known participant. Show them how to add a seed turn manually:
+
+   ```bash
+   cat <<'EOF' >> .runtime/conversation.md
+   === TURN id=t_seed participant=user ts=$(date -u +%FT%TZ) ===
+   @Reviewer please look at <file or topic>
+   EOF
+   ```
+
+   Or just edit `.runtime/conversation.md` directly in the editor.
+
+## Notes
+
+- The journal at `.runtime/conversation.md` is the source of truth for file mode. It's gitignored. Resetting = deleting the file.
+- Per-participant scratch state lives at `.runtime/state/<participantId>.json`. Also gitignored.
+- Other substrates (chat servers, MCP bridges, …) ship as separate plugin packages. Register them via `--plugin <module-id>` on `run-swarm`, or list them under `plugins[]` in `~/.agentproto/config.json`.
+
+## Errors to watch
+
+- "unknown substrate kind '<kind>'. Registered kinds: […]" → the manifest's `substrate.kind` has no matching factory. Either fix the kind, or install the plugin that provides it and pass `--plugin <module-id>`.
+- "manifest file not found" → check the path; the verb resolves it from the current cwd.
+- Spawned `claude` returning non-zero → the participant agent's command failed. Check stderr in the swarm process output.

package/files/.claude/examples/swarm-local.md

@@ -0,0 +1,84 @@
+---
+schema: agentruntimes/v1
+kind: MultiAgentRuntime
+id: local-swarm
+participants:
+  - id: reviewer
+    executor: agent-cli
+    displayName: Reviewer
+    role: ../../.claude/agents/reviewer.md
+substrate:
+  kind: file
+  path: ./conversation.md
+dispatcher:
+  kind: mention
+state:
+  kind: fs
+  dir: ./state
+---
+
+# Local swarm — file substrate
+
+One participant (Reviewer) coordinated through an append-only markdown
+journal at `.runtime/conversation.md`. No network, no remote services —
+useful as a starting template you copy and extend with your own
+participants.
+
+## How to run
+
+1. Copy this file to `.runtime/multi-agent.yaml` (the `.runtime/` dir is
+   gitignored, so manifests there are per-developer):
+
+   ```bash
+   mkdir -p .runtime && cp .claude/examples/swarm-local.md .runtime/multi-agent.yaml
+   ```
+
+2. Start the swarm in one terminal:
+
+   ```bash
+   agentproto run-swarm --manifest .runtime/multi-agent.yaml --verbose
+   ```
+
+3. In another terminal, seed the journal with a turn that mentions one
+   of the participants:
+
+   ```bash
+   cat <<'EOF' >> .runtime/conversation.md
+   === TURN id=t_seed participant=user ts=2026-05-23T10:00:00Z ===
+   @Reviewer please take a look at <file or topic>
+   EOF
+   ```
+
+4. The swarm process polls every 2s. Within one cycle it will detect the
+   @Reviewer mention, spawn `claude --print --output-format=json` with
+   Reviewer's role + the recent transcript, and append the reply as a
+   new turn in the journal.
+
+## Adding participants
+
+Each participant under `participants:` needs an `id`, an `executor`
+kind, a `displayName` (used for `@Name` detection), and an optional
+`role` (inline string or relative path to a markdown file).
+
+The reference `agent-cli` executor spawns `claude` by default; the
+`role` content is fed to it on stdin along with the recent transcript.
+Drop in additional `.claude/agents/*.md` files and reference them
+under `role:` to add specialists.
+
+## Other substrates
+
+`substrate.kind` resolves through the agentproto CLI's adapter
+registry. Built-in: `file`. Third-party substrates (chat servers,
+MCP bridges, …) register themselves when loaded — pass
+`--plugin <module-id>` to `run-swarm`, or list them under `plugins[]`
+in `~/.agentproto/config.json`.
+
+## Path conventions
+
+Paths in this manifest resolve relative to the manifest file itself.
+- `role: ../../.claude/agents/reviewer.md` works when the manifest is at
+  `.runtime/multi-agent.yaml`.
+- `substrate.path: ./conversation.md` resolves to `.runtime/conversation.md`.
+- `state.dir: ./state` resolves to `.runtime/state/`.
+
+If you put the manifest somewhere else, adjust the relative paths.

package/files/.claude/hooks/session-start.mjs

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+/**
+ * SessionStart hook — when a Claude Code session opens in this repo,
+ * if a MultiAgentRuntime journal exists at `.runtime/conversation.md`,
+ * inject the last few turns as `additionalContext` so Claude picks up
+ * mid-swarm without losing thread.
+ *
+ * No-ops if the journal file is absent.
+ */
+
+import { readFile, stat } from "node:fs/promises"
+import { resolve } from "node:path"
+
+const JOURNAL_PATH = resolve(process.cwd(), ".runtime/conversation.md")
+const TAIL_BYTES = 4000
+
+async function main() {
+  // Drain stdin (event payload) but ignore — we don't need its fields.
+  // SessionStart doesn't carry conversation-specific data.
+  for await (const _chunk of process.stdin) {
+    // discard
+  }
+
+  try {
+    await stat(JOURNAL_PATH)
+  } catch {
+    return // no journal, nothing to inject
+  }
+
+  const raw = await readFile(JOURNAL_PATH, "utf8")
+  const tail = raw.length > TAIL_BYTES ? raw.slice(-TAIL_BYTES) : raw
+  if (!tail.trim()) return
+
+  const additionalContext = [
+    "## Multi-Agent Runtime journal — recent turns",
+    "",
+    "A `pnpm agentproto run-swarm` swarm may be running against `.runtime/conversation.md` in this repo. Below is the tail of the journal so this Claude session has thread continuity.",
+    "",
+    "```",
+    tail.trimEnd(),
+    "```",
+    "",
+    "If the user asks about swarm activity, refer to this journal. If they want to seed a new turn, they can either edit the file directly or use `/ap-swarm` to learn the seeding command.",
+  ].join("\n")
+
+  process.stdout.write(JSON.stringify({ additionalContext }))
+}
+
+main().catch((err) => {
+  // Never crash the session on a hook failure — log and continue.
+  process.stderr.write(`session-start hook: ${err?.message ?? String(err)}\n`)
+  process.exit(0)
+})

package/files/.claude/hooks/user-prompt-submit.mjs

@@ -0,0 +1,124 @@
+#!/usr/bin/env node
+/**
+ * UserPromptSubmit hook — when the user submits a prompt, scan for
+ * @-mentions of any participant declared in `.runtime/multi-agent.yaml`.
+ * If a known participant is mentioned, inject a routing hint via
+ * `additionalContext` so Claude knows the swarm may pick this up.
+ *
+ * The hook does NOT itself route to the swarm. The swarm is a separate
+ * process polling the journal. This hook just makes the Claude session
+ * aware of the mention so it can mirror it into the journal if the user
+ * is in file-mode.
+ *
+ * The mention parser below is INLINED AT BUILD TIME from
+ * `@agentproto/agent-runtime/util/mention-parser`. Edit the parser
+ * there, not here — the next build regenerates this hook with the
+ * latest source.
+ */
+
+import { readFile, stat } from "node:fs/promises"
+import { resolve } from "node:path"
+
+const MANIFEST_PATH = resolve(process.cwd(), ".runtime/multi-agent.yaml")
+
+async function main() {
+  // Read event JSON from stdin.
+  const chunks = []
+  for await (const chunk of process.stdin) chunks.push(chunk)
+  let event = {}
+  try {
+    event = JSON.parse(Buffer.concat(chunks).toString("utf8"))
+  } catch {
+    return // malformed event — bail silently
+  }
+  const prompt = typeof event?.prompt === "string" ? event.prompt : ""
+  if (!prompt) return
+
+  try {
+    await stat(MANIFEST_PATH)
+  } catch {
+    return // no active swarm manifest
+  }
+
+  let participants = []
+  try {
+    const raw = await readFile(MANIFEST_PATH, "utf8")
+    participants = extractParticipants(raw)
+  } catch (err) {
+    process.stderr.write(`user-prompt-submit hook: manifest parse failed — ${err?.message ?? err}\n`)
+    return
+  }
+
+  const mentioned = participants.filter((p) => textContainsMention(prompt, p.name))
+  if (mentioned.length === 0) return
+
+  const list = mentioned.map((p) => `- \`${p.name}\` (id: ${p.id})`).join("\n")
+  const additionalContext = [
+    "## Multi-Agent Runtime — mention detected in prompt",
+    "",
+    `The user's prompt mentions ${mentioned.length} participant${mentioned.length === 1 ? "" : "s"} declared in \`.runtime/multi-agent.yaml\`:`,
+    "",
+    list,
+    "",
+    "If a `pnpm agentproto run-swarm` process is polling the journal, it will pick this up on its next cycle. If the user wants the mention to flow to those participants, mirror the prompt into `.runtime/conversation.md` as a `user` turn (see `/ap-swarm` for the seed format). Otherwise treat the mention as in-session context only.",
+  ].join("\n")
+
+  process.stdout.write(JSON.stringify({ additionalContext }))
+}
+
+// ── BEGIN inlined from @agentproto/agent-runtime/util/mention-parser ──
+// ── DO NOT EDIT — regenerated by scripts/build-hooks.mjs ──
+/** @param {string} text @param {string} name @returns {boolean} */
+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
+}
+// ── END inlined ──
+
+/**
+ * Minimal frontmatter parser for the participants list. The hook script can't
+ * resolve gray-matter at hook-execution time (.claude/ has no node_modules),
+ * and the manifest format is constrained enough that a hand-rolled extractor
+ * is fine. If the manifest grows complex, switch to `pnpm exec node ...`
+ * so module resolution finds the workspace install.
+ *
+ * Returns [{ id, name }] from a participants list shaped like:
+ *
+ *   participants:
+ *     - id: reviewer
+ *       displayName: Reviewer
+ *     - id: migration-writer
+ *       displayName: MigrationWriter
+ */
+function extractParticipants(raw) {
+  const fmMatch = /^---\n([\s\S]*?)\n---/.exec(raw)
+  if (!fmMatch) return []
+  const fm = fmMatch[1]
+
+  const listMatch = /^participants:\s*\n([\s\S]*?)(?=^[a-zA-Z][a-zA-Z0-9_-]*:|\Z)/m.exec(fm)
+  if (!listMatch) return []
+  const block = listMatch[1]
+
+  const out = []
+  const entries = block.split(/\n(?=\s*-\s)/)
+  for (const entry of entries) {
+    const idMatch = /\bid:\s*([^\n#]+)/.exec(entry)
+    const nameMatch = /\bdisplayName:\s*([^\n#]+)/.exec(entry)
+    if (!idMatch) continue
+    const id = idMatch[1].trim()
+    const name = (nameMatch?.[1] ?? id).trim()
+    if (id) out.push({ id, name })
+  }
+  return out
+}
+
+main().catch((err) => {
+  process.stderr.write(`user-prompt-submit hook: ${err?.message ?? String(err)}\n`)
+  process.exit(0)
+})

package/files/.claude/settings.json

@@ -0,0 +1,25 @@
+{
+  "$schema": "https://json.schemastore.org/claude-code-settings.json",
+  "hooks": {
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": ".claude/hooks/session-start.mjs"
+          }
+        ]
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": ".claude/hooks/user-prompt-submit.mjs"
+          }
+        ]
+      }
+    ]
+  }
+}

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@agentproto/runtime-profile-standard",
+  "version": "0.1.0-alpha.0",
+  "description": "@agentproto/runtime-profile-standard — reference file-mode MultiAgentRuntime profile. Drops a Claude Code reviewer sub-agent, session-start + user-prompt-submit hooks, an `/ap-swarm` slash command, and an example local swarm manifest into a repo so `agentproto run-swarm` works out of the box. Installed via `agentproto install runtime-profile/standard`.",
+  "keywords": [
+    "agentproto",
+    "agent-runtime",
+    "runtime-profile",
+    "claude-code"
+  ],
+  "homepage": "https://agentproto.sh",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/agentproto/ts",
+    "directory": "packages/runtime-profile-standard"
+  },
+  "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"
+    },
+    "./profile.json": "./profile.json",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "files",
+    "profile.json",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {},
+  "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",
+    "@agentproto/agent-runtime": "0.1.0-alpha.0"
+  },
+  "engines": {
+    "node": ">=20.9.0"
+  },
+  "scripts": {
+    "predev": "node scripts/build-hooks.mjs",
+    "dev": "tsup --watch",
+    "prebuild": "node scripts/build-hooks.mjs",
+    "build": "tsup",
+    "clean": "rm -rf dist files/.claude/hooks/user-prompt-submit.mjs",
+    "check-types": "tsc --noEmit",
+    "test": "vitest run --passWithNoTests",
+    "test:watch": "vitest",
+    "build:hooks": "node scripts/build-hooks.mjs"
+  }
+}

package/profile.json

@@ -0,0 +1,15 @@
+{
+  "schema": "agentproto/runtime-profile/v1",
+  "slug": "runtime-profile/standard",
+  "version": "0.1.0",
+  "name": "Standard MultiAgentRuntime profile",
+  "description": "Reference file-mode setup: an example reviewer sub-agent, session-start + user-prompt-submit Claude Code hooks, and an `/ap-swarm` slash command. Composes with the @agentproto/agent-runtime kernel and the @agentproto/cli `run-swarm` verb. Transport-bridge profiles (Slack, MCP servers, etc.) ship as separate `@<vendor>/runtime-profile-*` packages.",
+  "files": [
+    { "src": ".claude/agents/reviewer.md", "dest": ".claude/agents/reviewer.md", "strategy": "overwrite" },
+    { "src": ".claude/hooks/session-start.mjs", "dest": ".claude/hooks/session-start.mjs", "strategy": "overwrite", "executable": true },
+    { "src": ".claude/hooks/user-prompt-submit.mjs", "dest": ".claude/hooks/user-prompt-submit.mjs", "strategy": "overwrite", "executable": true },
+    { "src": ".claude/commands/ap-swarm.md", "dest": ".claude/commands/ap-swarm.md", "strategy": "overwrite" },
+    { "src": ".claude/examples/swarm-local.md", "dest": ".claude/examples/swarm-local.md", "strategy": "overwrite" },
+    { "src": ".claude/settings.json", "dest": ".claude/settings.json", "strategy": "merge-json-deep" }
+  ]
+}