agent-relay-server 0.104.5 → 0.105.0

package/runner/plugins/claude/monitors/relay-monitor.provisioned.mjs

@@ -847,13 +847,109 @@ function messageBodyMaxCharsFromEnv() {
   return process.env.AGENT_RELAY_MESSAGE_BODY_MAX_CHARS;
 }
 
-// runner/src/relay-instructions.ts
-var CLAUDE_RELAY_CONTEXT = `[agent-relay] Relay is available. Follow the Agent Relay rules in CLAUDE.md when present, or run agent-relay /guide. Reply through Relay only when a response is needed; do not send status-only follow-ups after the useful Relay response was already delivered.`;
-var CLAUDE_READ_ONLY_RELAY_CONTEXT = `${CLAUDE_RELAY_CONTEXT}
+// src/prompt-template-defaults-runner.ts
+function lines(...parts) {
+  return parts.join(`
+`);
+}
+var RUNNER_PROMPT_TEMPLATE_DEFAULTS = [
+  {
+    slug: "relay.manual.claude",
+    category: "runner",
+    title: "Claude Relay Manual",
+    description: "Bundled CLAUDE.md relay manual written into provisioned Claude homes.",
+    template: lines("# Agent Relay", "", "- Agent Relay messages may come from humans, channels, or other agents.", "- Read the delivered message body and do the requested work.", "- Reply through Relay only when the sender still needs an answer.", "- Prefer the inline MCP tools `relay_reply` or `relay_send_message` for the actual answer to an incoming Relay message.", "- Do not send `/message` with the useful answer and then a separate `/reply` that only says it was sent.", "- If multiple Relay messages arrive together, answer once to the latest relevant message and cover the current request. Do not separately acknowledge stale greetings or context.", '- If the useful response was already delivered through Relay, do not send an extra "sent", "done", or "drafts sent" confirmation unless the user explicitly asked for one.', "- No reply is needed for pure info messages, passive acknowledgements, or reactions that do not ask for action.", "- NEVER reply to a notification-class message. The server marks these and renders a single `\u21AA Notification \u2014 no reply needed.` line instead of the reply reminder \u2014 it is a fire-and-forget signal (a merge notice, lifecycle event, or FYI). Act on the information if relevant, but do not send any reply, status confirmation, or reaction back.", '- Use `agent-relay /react <messageId> <emoji>` instead of a text reply for lightweight acknowledgement, approval, thanks, or "good job" after a completed work update.', "- Good reaction uses: acknowledge praise with \uD83D\uDC4D or \u2764\uFE0F, mark a completed handoff as seen, approve a proposed next step, or acknowledge a passive FYI.", "- Do not use reactions when the user asked a question, gave a new task, reported a bug, or needs a textual result.", "- A thumbs-up reaction to your question means approval to proceed. A thumbs-up reaction to your completed status means no further action.", "- Use `agent-relay get-message <id>` when a delivered preview is truncated.", "- Use `agent-relay /status --json` to inspect your current Relay identity and `agent-relay /guide` for command details."),
+    defaultTemplate: lines("# Agent Relay", "", "- Agent Relay messages may come from humans, channels, or other agents.", "- Read the delivered message body and do the requested work.", "- Reply through Relay only when the sender still needs an answer.", "- Prefer the inline MCP tools `relay_reply` or `relay_send_message` for the actual answer to an incoming Relay message.", "- Do not send `/message` with the useful answer and then a separate `/reply` that only says it was sent.", "- If multiple Relay messages arrive together, answer once to the latest relevant message and cover the current request. Do not separately acknowledge stale greetings or context.", '- If the useful response was already delivered through Relay, do not send an extra "sent", "done", or "drafts sent" confirmation unless the user explicitly asked for one.', "- No reply is needed for pure info messages, passive acknowledgements, or reactions that do not ask for action.", "- NEVER reply to a notification-class message. The server marks these and renders a single `\u21AA Notification \u2014 no reply needed.` line instead of the reply reminder \u2014 it is a fire-and-forget signal (a merge notice, lifecycle event, or FYI). Act on the information if relevant, but do not send any reply, status confirmation, or reaction back.", '- Use `agent-relay /react <messageId> <emoji>` instead of a text reply for lightweight acknowledgement, approval, thanks, or "good job" after a completed work update.', "- Good reaction uses: acknowledge praise with \uD83D\uDC4D or \u2764\uFE0F, mark a completed handoff as seen, approve a proposed next step, or acknowledge a passive FYI.", "- Do not use reactions when the user asked a question, gave a new task, reported a bug, or needs a textual result.", "- A thumbs-up reaction to your question means approval to proceed. A thumbs-up reaction to your completed status means no further action.", "- Use `agent-relay get-message <id>` when a delivered preview is truncated.", "- Use `agent-relay /status --json` to inspect your current Relay identity and `agent-relay /guide` for command details."),
+    variables: []
+  },
+  {
+    slug: "relay.context.claude",
+    category: "runner",
+    title: "Claude Relay Context",
+    description: "One-line relay context note for Claude sessions.",
+    template: "[agent-relay] Relay is available. Follow the Agent Relay rules in CLAUDE.md when present, or run agent-relay /guide. Reply through Relay only when a response is needed; do not send status-only follow-ups after the useful Relay response was already delivered.",
+    defaultTemplate: "[agent-relay] Relay is available. Follow the Agent Relay rules in CLAUDE.md when present, or run agent-relay /guide. Reply through Relay only when a response is needed; do not send status-only follow-ups after the useful Relay response was already delivered.",
+    variables: []
+  },
+  {
+    slug: "relay.context.claude.readonly",
+    category: "runner",
+    title: "Claude Relay Context (Read Only)",
+    description: "Read-only relay context note for Claude sessions.",
+    template: lines("[agent-relay] Relay is available. Follow the Agent Relay rules in CLAUDE.md when present, or run agent-relay /guide. Reply through Relay only when a response is needed; do not send status-only follow-ups after the useful Relay response was already delivered.", "", "This Claude session is running with restricted read-only Relay permissions. Do not invoke Agent Relay skills. If you need to reply, use this Bash command shape:", "", 'agent-relay /reply <messageId> "<your reply>"'),
+    defaultTemplate: lines("[agent-relay] Relay is available. Follow the Agent Relay rules in CLAUDE.md when present, or run agent-relay /guide. Reply through Relay only when a response is needed; do not send status-only follow-ups after the useful Relay response was already delivered.", "", "This Claude session is running with restricted read-only Relay permissions. Do not invoke Agent Relay skills. If you need to reply, use this Bash command shape:", "", 'agent-relay /reply <messageId> "<your reply>"'),
+    variables: []
+  },
+  {
+    slug: "relay.context.codex",
+    category: "runner",
+    title: "Codex Relay Context",
+    description: "Relay context note injected into Codex sessions.",
+    template: "[agent-relay] You are connected to Agent Relay, a real-time message bus between agents and users. When you receive a relay message: read it, do what it asks, and reply through the relay when a text response is needed. Use agent-relay /react <messageId> <emoji> for lightweight acknowledgement or approval. If Relay MCP tools are available, prefer relay_reply, relay_get_message, relay_get_thread, relay_send_message, relay_upload_artifact, relay_attach_artifact, relay_agent_status, relay_find_agents, relay_compact_and_resume, relay_recall, relay_spawn_agent, and relay_shutdown_agent. You never need to know or pass your own agent id \u2014 relay fills it from your token; use relay_whoami only if you need to reason about yourself. relay_compact_and_resume is for clean-seam self-resume after a context advisory: pass workingState and optional ruledOut; Relay owns the objective envelope. relay_recall searches your own archived pre-compaction segments by keyword when a discarded detail is needed. relay_spawn_targets / relay_spawn_agent / relay_shutdown_agent only appear if your profile grants spawning (a live-children quota); when present, call relay_spawn_targets FIRST for the live host/provider/model matrix + your quota, then stand up long-living child agents and shut down your own \u2014 find them later with relay_find_agents spawnedBy:me. For replies, prefer relay_reply or relay_send_message; CLI fallback: agent-relay /reply <messageId> \"<your reply>\". If a delivered message says it was truncated, fetch the full body with: agent-relay get-message <messageId>. For command details, run: agent-relay /guide",
+    defaultTemplate: "[agent-relay] You are connected to Agent Relay, a real-time message bus between agents and users. When you receive a relay message: read it, do what it asks, and reply through the relay when a text response is needed. Use agent-relay /react <messageId> <emoji> for lightweight acknowledgement or approval. If Relay MCP tools are available, prefer relay_reply, relay_get_message, relay_get_thread, relay_send_message, relay_upload_artifact, relay_attach_artifact, relay_agent_status, relay_find_agents, relay_compact_and_resume, relay_recall, relay_spawn_agent, and relay_shutdown_agent. You never need to know or pass your own agent id \u2014 relay fills it from your token; use relay_whoami only if you need to reason about yourself. relay_compact_and_resume is for clean-seam self-resume after a context advisory: pass workingState and optional ruledOut; Relay owns the objective envelope. relay_recall searches your own archived pre-compaction segments by keyword when a discarded detail is needed. relay_spawn_targets / relay_spawn_agent / relay_shutdown_agent only appear if your profile grants spawning (a live-children quota); when present, call relay_spawn_targets FIRST for the live host/provider/model matrix + your quota, then stand up long-living child agents and shut down your own \u2014 find them later with relay_find_agents spawnedBy:me. For replies, prefer relay_reply or relay_send_message; CLI fallback: agent-relay /reply <messageId> \"<your reply>\". If a delivered message says it was truncated, fetch the full body with: agent-relay get-message <messageId>. For command details, run: agent-relay /guide",
+    variables: []
+  },
+  {
+    slug: "workspace.lifecycle",
+    category: "runner",
+    title: "Runner Workspace Lifecycle Note",
+    description: "Lifecycle note injected by the runner for isolated workspaces.",
+    template: lines("[agent-relay] Isolated workspace: you are in a git worktree on branch {{branch}}, based on {{baseRef}} \u2014 NOT the main checkout. Other agents may work in parallel and land to {{baseRef}}, so {{baseRef}} will move under you. That is expected; don't fight it.", "Do NOT push this branch yourself \u2014 not with `git push`, not with `tl push` or any other push wrapper, and do not manually rebase or merge. A steward may be auto-rebasing this branch in the background; pushing concurrently races it and can leave the worktree mid-rebase. Just commit your work here. When the task is done, run `agent-relay workspace ready` \u2014 Relay rebases onto the latest {{baseRef}}, lands your work, and pushes for you. If the installed `agent-relay` binary is stale and says the workspace command is unknown, run the repo-local fallback: `bun src/index.ts workspace ready`.", "After `ready`, the status becomes `review_requested` \u2014 this is the NORMAL, healthy hand-off state, NOT an escalation or a stall. Relay auto-merges clean rebases roughly every 2 minutes; a steward agent is spawned (after a short delay) ONLY if it can't land deterministically, so seeing no steward means it's working, not stuck. Stop your turn after `ready` and go idle; do NOT wait or poll the steward queue. Relay wakes you with `landed-success` when your branch lands and refreshes, or `landed-failure` if landing fatally fails. On success you'll be on a fresh rebased branch whose name gains a `--N` suffix \u2014 expected, keep working there. Never `cd` into the main checkout, and never merge/push/resolve conflicts yourself \u2014 Relay and the steward own all of that. `agent-relay workspace status` anytime shows your current state and the exact next step."),
+    defaultTemplate: lines("[agent-relay] Isolated workspace: you are in a git worktree on branch {{branch}}, based on {{baseRef}} \u2014 NOT the main checkout. Other agents may work in parallel and land to {{baseRef}}, so {{baseRef}} will move under you. That is expected; don't fight it.", "Do NOT push this branch yourself \u2014 not with `git push`, not with `tl push` or any other push wrapper, and do not manually rebase or merge. A steward may be auto-rebasing this branch in the background; pushing concurrently races it and can leave the worktree mid-rebase. Just commit your work here. When the task is done, run `agent-relay workspace ready` \u2014 Relay rebases onto the latest {{baseRef}}, lands your work, and pushes for you. If the installed `agent-relay` binary is stale and says the workspace command is unknown, run the repo-local fallback: `bun src/index.ts workspace ready`.", "After `ready`, the status becomes `review_requested` \u2014 this is the NORMAL, healthy hand-off state, NOT an escalation or a stall. Relay auto-merges clean rebases roughly every 2 minutes; a steward agent is spawned (after a short delay) ONLY if it can't land deterministically, so seeing no steward means it's working, not stuck. Stop your turn after `ready` and go idle; do NOT wait or poll the steward queue. Relay wakes you with `landed-success` when your branch lands and refreshes, or `landed-failure` if landing fatally fails. On success you'll be on a fresh rebased branch whose name gains a `--N` suffix \u2014 expected, keep working there. Never `cd` into the main checkout, and never merge/push/resolve conflicts yourself \u2014 Relay and the steward own all of that. `agent-relay workspace status` anytime shows your current state and the exact next step."),
+    variables: ["branch", "baseRef"]
+  },
+  {
+    slug: "workspace.deps.symlink",
+    category: "runner",
+    title: "Runner Workspace Deps Symlink Note",
+    description: "Symlinked node_modules caveat injected by the runner.",
+    template: "[agent-relay] Isolated workspace: this is a git worktree, and its node_modules are SYMLINKED from the main checkout \u2014 dependencies are already installed and ready to use. Do NOT run a clean dependency install (`bun install` / `npm install` / `pnpm install`): it writes through the symlink and mutates the main checkout's shared node_modules. Build caches written under node_modules are shared too. If typecheck/build fails on a missing module (a dependency added to the base AFTER this worktree was created), run `agent-relay workspace deps` \u2014 it re-provisions only the stale dirs with a real isolated install, safely, without touching the shared node_modules. If you genuinely need to change dependencies in isolation, ask the host to spawn with AGENT_RELAY_WORKSPACE_DEPS=install.",
+    defaultTemplate: "[agent-relay] Isolated workspace: this is a git worktree, and its node_modules are SYMLINKED from the main checkout \u2014 dependencies are already installed and ready to use. Do NOT run a clean dependency install (`bun install` / `npm install` / `pnpm install`): it writes through the symlink and mutates the main checkout's shared node_modules. Build caches written under node_modules are shared too. If typecheck/build fails on a missing module (a dependency added to the base AFTER this worktree was created), run `agent-relay workspace deps` \u2014 it re-provisions only the stale dirs with a real isolated install, safely, without touching the shared node_modules. If you genuinely need to change dependencies in isolation, ask the host to spawn with AGENT_RELAY_WORKSPACE_DEPS=install.",
+    variables: []
+  },
+  {
+    slug: "workspace.deps.none",
+    category: "runner",
+    title: "Runner Workspace Deps None Note",
+    description: "Missing dependency provisioning caveat injected by the runner.",
+    template: "[agent-relay] Isolated workspace: dependencies were not provisioned (AGENT_RELAY_WORKSPACE_DEPS=none). You may need to install node_modules before typecheck/test/build work.",
+    defaultTemplate: "[agent-relay] Isolated workspace: dependencies were not provisioned (AGENT_RELAY_WORKSPACE_DEPS=none). You may need to install node_modules before typecheck/test/build work.",
+    variables: []
+  },
+  {
+    slug: "workspace.symlinks",
+    category: "runner",
+    title: "Runner Workspace Symlink Note",
+    description: "Write-through symlink caveat injected by the runner.",
+    template: "[agent-relay] Isolated workspace: these untracked paths are SYMLINKED from the main checkout: {{linked}}. They resolve to the real files in main, so editing or deleting them writes THROUGH to main \u2014 treat them as read-only unless you intend to change main.",
+    defaultTemplate: "[agent-relay] Isolated workspace: these untracked paths are SYMLINKED from the main checkout: {{linked}}. They resolve to the real files in main, so editing or deleting them writes THROUGH to main \u2014 treat them as read-only unless you intend to change main.",
+    variables: ["linked"]
+  }
+];
 
-This Claude session is running with restricted read-only Relay permissions. Do not invoke Agent Relay skills. If you need to reply, use this Bash command shape:
+// runner/src/template-resolver.ts
+var RUNNER_DEFAULTS = new Map(RUNNER_PROMPT_TEMPLATE_DEFAULTS.map((template) => [template.slug, template.defaultTemplate]));
+var templateCache = new Map;
+function renderValue(value) {
+  return value ?? "";
+}
+function applyVariables(template, vars) {
+  return template.replace(/\{\{(\w+)\}\}/g, (_, key) => renderValue(vars[key]));
+}
+function renderRunnerTemplate(slug, vars = {}) {
+  const template = templateCache.get(slug) ?? RUNNER_DEFAULTS.get(slug);
+  if (template === undefined)
+    throw new Error(`unknown runner prompt template slug: ${slug}`);
+  return applyVariables(template, vars);
+}
 
-agent-relay /reply <messageId> "<your reply>"`;
+// runner/src/relay-instructions.ts
+function claudeRelayContext() {
+  return renderRunnerTemplate("relay.context.claude");
+}
+function claudeReadOnlyRelayContext() {
+  return renderRunnerTemplate("relay.context.claude.readonly");
+}
 function relayReplyActionText(messageId) {
   return `relay_reply (messageId: ${messageId}, body: "<your reply>"). CLI fallback: agent-relay /reply ${messageId} "<your reply>"`;
 }
@@ -865,9 +961,9 @@ function workspaceDepsNote(input) {
     return "";
   switch (input.depsMode) {
     case "symlink":
-      return "[agent-relay] Isolated workspace: this is a git worktree, and its node_modules are SYMLINKED from the main checkout \u2014 dependencies are already installed and ready to use. Do NOT run a clean dependency install (`bun install` / `npm install` / `pnpm install`): it writes through the symlink and mutates the main checkout's shared node_modules. Build caches written under node_modules are shared too. If typecheck/build fails on a missing module (a dependency added to the base AFTER this worktree was created), run `agent-relay workspace deps` \u2014 it re-provisions only the stale dirs with a real isolated install, safely, without touching the shared node_modules. If you genuinely need to change dependencies in isolation, ask the host to spawn with AGENT_RELAY_WORKSPACE_DEPS=install.";
+      return renderRunnerTemplate("workspace.deps.symlink");
     case "none":
-      return "[agent-relay] Isolated workspace: dependencies were not provisioned (AGENT_RELAY_WORKSPACE_DEPS=none). You may need to install node_modules before typecheck/test/build work.";
+      return renderRunnerTemplate("workspace.deps.none");
     default:
       return "";
   }
@@ -877,17 +973,12 @@ function workspaceLifecycleNote(input) {
     return "";
   const branch = input.branch ? `\`${input.branch}\`` : "an isolated agent branch";
   const base = input.baseRef ? `\`${input.baseRef}\`` : "the base branch";
-  return [
-    `[agent-relay] Isolated workspace: you are in a git worktree on branch ${branch}, based on ${base} \u2014 NOT the main checkout. Other agents may work in parallel and land to ${base}, so ${base} will move under you. That is expected; don't fight it.`,
-    `Do NOT push this branch yourself \u2014 not with \`git push\`, not with \`tl push\` or any other push wrapper, and do not manually rebase or merge. A steward may be auto-rebasing this branch in the background; pushing concurrently races it and can leave the worktree mid-rebase. Just commit your work here. When the task is done, run \`agent-relay workspace ready\` \u2014 Relay rebases onto the latest ${base}, lands your work, and pushes for you. If the installed \`agent-relay\` binary is stale and says the workspace command is unknown, run the repo-local fallback: \`bun src/index.ts workspace ready\`.`,
-    `After \`ready\`, the status becomes \`review_requested\` \u2014 this is the NORMAL, healthy hand-off state, NOT an escalation or a stall. Relay auto-merges clean rebases roughly every 2 minutes; a steward agent is spawned (after a short delay) ONLY if it can't land deterministically, so seeing no steward means it's working, not stuck. Stop your turn after \`ready\` and go idle; do NOT wait or poll the steward queue. Relay wakes you with \`landed-success\` when your branch lands and refreshes, or \`landed-failure\` if landing fatally fails. On success you'll be on a fresh rebased branch whose name gains a \`--N\` suffix \u2014 expected, keep working there. Never \`cd\` into the main checkout, and never merge/push/resolve conflicts yourself \u2014 Relay and the steward own all of that. \`agent-relay workspace status\` anytime shows your current state and the exact next step.`
-  ].join(`
-`);
+  return renderRunnerTemplate("workspace.lifecycle", { branch, baseRef: base });
 }
 function workspaceSymlinksNote(linked) {
   if (!linked.length)
     return "";
-  return `[agent-relay] Isolated workspace: these untracked paths are SYMLINKED from the main checkout: ${linked.join(", ")}. They resolve to the real files in main, so editing or deleting them writes THROUGH to main \u2014 treat them as read-only unless you intend to change main.`;
+  return renderRunnerTemplate("workspace.symlinks", { linked: linked.join(", ") });
 }
 function workspaceDepsNoteFromEnv(env = process.env) {
   const json = env.AGENT_RELAY_WORKSPACE_JSON;
@@ -948,7 +1039,7 @@ function providerAttachmentText(message) {
   const refs = attachmentRefs(message);
   if (!refs.length)
     return;
-  const lines = refs.flatMap((ref) => {
+  const lines2 = refs.flatMap((ref) => {
     const artifactId = typeof ref.artifactId === "string" ? ref.artifactId : "unknown-artifact";
     const source = isRecord(ref.ref) ? [
       typeof ref.ref.provider === "string" ? ref.ref.provider : undefined,
@@ -974,7 +1065,7 @@ function providerAttachmentText(message) {
   ];
   return [
     "Attachments:",
-    ...lines,
+    ...lines2,
     ...guidance
   ].join(`
 `);
@@ -984,18 +1075,18 @@ function providerAttachmentText(message) {
 var REMINDER_EVERY_DELIVERIES = 5;
 var TASK_CLAIM_INSTRUCTION = "Claim this task before working it, then update task status when finished.";
 function stripRelayScaffolding(body) {
-  const lines = body.split(`
+  const lines2 = body.split(`
 `);
   const popTrailingBlanks = () => {
-    while (lines.length && (lines.at(-1) ?? "").trim() === "")
-      lines.pop();
+    while (lines2.length && (lines2.at(-1) ?? "").trim() === "")
+      lines2.pop();
   };
   popTrailingBlanks();
-  if (lines.at(-1) === TASK_CLAIM_INSTRUCTION) {
-    lines.pop();
+  if (lines2.at(-1) === TASK_CLAIM_INSTRUCTION) {
+    lines2.pop();
     popTrailingBlanks();
   }
-  return lines.join(`
+  return lines2.join(`
 `);
 }
 function isMemoryInjection(message) {
@@ -1100,7 +1191,7 @@ ws.onmessage = (event) => {
   const messages2 = payload.messages;
   deliveryCount += 1;
   if (firstDelivery) {
-    console.log(process.env.AGENT_RELAY_APPROVAL === "read-only" ? CLAUDE_READ_ONLY_RELAY_CONTEXT : CLAUDE_RELAY_CONTEXT);
+    console.log(process.env.AGENT_RELAY_APPROVAL === "read-only" ? claudeReadOnlyRelayContext() : claudeRelayContext());
     const wsNote = workspaceDepsNoteFromEnv();
     if (wsNote) {
       console.log("");

package/runner/plugins/claude/monitors/relay-monitor.ts

@@ -1,6 +1,6 @@
 import type { Message } from "agent-relay-sdk";
 import { claudeProviderMessageText } from "../../../src/adapters/claude-delivery";
-import { CLAUDE_READ_ONLY_RELAY_CONTEXT, CLAUDE_RELAY_CONTEXT, workspaceDepsNoteFromEnv } from "../../../src/relay-instructions";
+import { claudeReadOnlyRelayContext, claudeRelayContext, workspaceDepsNoteFromEnv } from "../../../src/relay-instructions";
 
 const port = process.env.AGENT_RELAY_RUNNER_PORT;
 if (!port) process.exit(0);
@@ -15,7 +15,7 @@ ws.onmessage = (event) => {
   const messages = payload.messages as Message[];
   deliveryCount += 1;
   if (firstDelivery) {
-    console.log(process.env.AGENT_RELAY_APPROVAL === "read-only" ? CLAUDE_READ_ONLY_RELAY_CONTEXT : CLAUDE_RELAY_CONTEXT);
+    console.log(process.env.AGENT_RELAY_APPROVAL === "read-only" ? claudeReadOnlyRelayContext() : claudeRelayContext());
     const wsNote = workspaceDepsNoteFromEnv();
     if (wsNote) {
       console.log("");

package/runner/src/adapter.ts

@@ -4,6 +4,7 @@ import type { LivenessInputs } from "./liveness";
 import type { SessionEvent } from "./session-insights";
 import { messageBodyMaxCharsFromEnv } from "./config";
 import { relayReplyReminderText } from "./relay-instructions";
+import { renderRunnerTemplate } from "./template-resolver";
 
 export type SemanticStatus = "idle" | "busy" | "offline" | "error";
 type ProviderWorkKind = "provider-turn" | "subagent" | "background-script";
@@ -226,7 +227,9 @@ export function profileIsVanillaBase(config: Pick<RunnerSpawnConfig, "agentProfi
   return config.agentProfile?.base === "vanilla";
 }
 
-export const RELAY_CONTEXT = `[agent-relay] You are connected to Agent Relay, a real-time message bus between agents and users. When you receive a relay message: read it, do what it asks, and reply through the relay when a text response is needed. Use agent-relay /react <messageId> <emoji> for lightweight acknowledgement or approval. If Relay MCP tools are available, prefer relay_reply, relay_get_message, relay_get_thread, relay_send_message, relay_upload_artifact, relay_attach_artifact, relay_agent_status, relay_find_agents, relay_compact_and_resume, relay_recall, relay_spawn_agent, and relay_shutdown_agent. You never need to know or pass your own agent id — relay fills it from your token; use relay_whoami only if you need to reason about yourself. relay_compact_and_resume is for clean-seam self-resume after a context advisory: pass workingState and optional ruledOut; Relay owns the objective envelope. relay_recall searches your own archived pre-compaction segments by keyword when a discarded detail is needed. relay_spawn_targets / relay_spawn_agent / relay_shutdown_agent only appear if your profile grants spawning (a live-children quota); when present, call relay_spawn_targets FIRST for the live host/provider/model matrix + your quota, then stand up long-living child agents and shut down your own — find them later with relay_find_agents spawnedBy:me. For replies, prefer relay_reply or relay_send_message; CLI fallback: agent-relay /reply <messageId> "<your reply>". If a delivered message says it was truncated, fetch the full body with: agent-relay get-message <messageId>. For command details, run: agent-relay /guide`;
+export function relayContext(): string {
+  return renderRunnerTemplate("relay.context.codex");
+}
 
 // #306 — deliver the FULL message body by default. Only a pathological body beyond this
 // high cap truncates (with a get-message hint) so it can't nuke an agent's context; the 99%

package/src/agent-lifecycle-events.ts

@@ -2,6 +2,7 @@ import { emitRelayEvent } from "./events";
 import { routeNotification } from "./notification-router";
 import { getAgent, markAgentReadyNotified, recordCrashReport, recordTerminalEvent } from "./db";
 import { crashReportFor } from "./agent-death-diagnosis";
+import { renderTemplate } from "./prompt-resolver";
 import type { AgentCard, AgentDeathDiagnosis } from "./types";
 
 /** One-line cause tag appended to a death notification body, e.g. " · why: Clean exit (exit code 0)". */
@@ -122,7 +123,11 @@ export function notifyAgentReady(childId: string): void {
       recipients: [parent],
       message: {
         subject: "Spawn recovered",
-        body: `♻️ Correction: your earlier spawn failure${spawnRequestId ? ` for \`${spawnRequestId}\`` : ""} was a false alarm — ${describe(child)} actually registered and is ready and idle. Disregard the failure and do NOT retry; send it work with relay_send_message to \`${childId}\`.`,
+        body: renderTemplate("notify.spawn.recovered", {
+          spawnRequestId: spawnRequestId ? ` for \`${spawnRequestId}\`` : "",
+          label: describe(child),
+          childId,
+        }),
         payload: { kind: "agent.spawn_recovered", agentId: childId, parent, provider: providerOf(child), spawnRequestId, supersedes: "agent.spawn_failed" },
         replyExpected: false,
       },
@@ -135,7 +140,7 @@ export function notifyAgentReady(childId: string): void {
     recipients: [parent],
     message: {
       subject: "Spawned agent ready",
-      body: `✅ Your spawned agent ${describe(child)} is ready and idle — send it work with relay_send_message to \`${childId}\`.`,
+      body: renderTemplate("notify.agent.ready", { label: describe(child), childId }),
       payload: { kind: "agent.ready", agentId: childId, parent, provider: providerOf(child), spawnRequestId },
       replyExpected: false,
     },
@@ -178,7 +183,11 @@ export function notifyAgentOffline(childId: string, reason: string, diagnosis?:
       recipients: [parent],
       message: {
         subject: "Spawned agent exited",
-        body: `⏹ Your spawned agent ${describe(child)} exited — ${reason}${diagnosisSuffix(diagnosis)}.`,
+        body: renderTemplate("notify.agent.exited", {
+          label: describe(child),
+          reason,
+          diagnosis: diagnosisSuffix(diagnosis),
+        }),
         payload: { kind: "agent.exited", agentId: childId, parent, reason, ...(diagnosis ? { diagnosis } : {}) },
         replyExpected: false,
       },
@@ -201,7 +210,11 @@ export function notifyAgentOffline(childId: string, reason: string, diagnosis?:
     recipients: [parent],
     message: {
       subject: "Spawn failed",
-      body: `❌ Your spawned agent ${describe(child)} went offline before ever becoming ready — ${reason}${diagnosisSuffix(diagnosis)}. Likely a crash-loop, onboarding gate, or bad launch; call relay_spawn_targets to re-check provider availability before retrying.`,
+      body: renderTemplate("notify.agent.never-ready", {
+        label: describe(child),
+        reason,
+        diagnosis: diagnosisSuffix(diagnosis),
+      }),
       payload: { kind: "agent.spawn_failed", agentId: childId, parent, reason, ...(diagnosis ? { diagnosis } : {}) },
       replyExpected: false,
     },
@@ -231,7 +244,10 @@ export function notifyAgentSpawnFailed(input: { parent: string; spawnRequestId?:
     recipients: [input.parent],
     message: {
       subject: "Spawn failed",
-      body: `❌ Your spawn request${input.spawnRequestId ? ` \`${input.spawnRequestId}\`` : ""} failed — ${input.reason}. Call relay_spawn_targets to check live provider/host availability before retrying.`,
+      body: renderTemplate("notify.spawn.failed", {
+        spawnRequestId: input.spawnRequestId ? ` \`${input.spawnRequestId}\`` : "",
+        reason: input.reason,
+      }),
       payload: { kind: "agent.spawn_failed", parent: input.parent, spawnRequestId: input.spawnRequestId, provider: input.provider, reason: input.reason },
       replyExpected: false,
     },

package/src/automations/reconcile.ts

@@ -1,5 +1,6 @@
 import { createCommand } from "../commands-db";
 import { getAgent, getTask, listOrchestrators, sendMessage, updateTaskStatus } from "../db";
+import { renderTemplate } from "../prompt-resolver";
 import { CLOSED_TASK_STATUS } from "./constants";
 import {
   ensureAutomationTables,
@@ -132,7 +133,9 @@ function maybeWarnRuntimeBudget(run: AutomationRun, task: Task, now: number): Me
     to: target,
     kind: "control",
     subject: "Automation runtime budget warning",
-    body: budget.warningMessage ?? `Runtime budget warning: this automation run will be shut down in about ${remainingMinutes} minute${remainingMinutes === 1 ? "" : "s"}. Finish current work, commit and push anything worth keeping, then stop cleanly before the deadline.`,
+    body: budget.warningMessage ?? renderTemplate("notify.automation.budget-warning", {
+      remainingMinutes: `${remainingMinutes} minute${remainingMinutes === 1 ? "" : "s"}`,
+    }),
     payload: {
       automationId: run.automationId,
       automationRunId: run.id,

package/src/branch-landed.ts

@@ -3,6 +3,7 @@ import { emitRelayEvent } from "./events";
 import { routeNotification, INFORMATIONAL_TTL_MS } from "./notification-router";
 import { registerDefaultAudienceRules, audiencePredicates } from "./notification-rules";
 import { createActivityEvent, getAgent, updateWorkspaceStatus } from "./db";
+import { renderTemplate } from "./prompt-resolver";
 import { handleLandedIssueLifecycle } from "./services/issue-lifecycle";
 import type { WorkspaceMergePreview, WorkspaceRecord } from "./types";
 
@@ -170,7 +171,13 @@ export function notifyBranchLanded(input: BranchLandedInput): void {
       ttlMs: null,
       message: {
         subject: "Your branch landed",
-        body: `✅ ${branchLabel} landed on \`${base}\`${shaLabel}${subjectLabel}.${publishLabel}${continueLabel}`,
+        body: renderTemplate("notify.land.success", {
+          branch: branchLabel,
+          base,
+          sha: `${shaLabel}${subjectLabel}`,
+          publishLabel,
+          continueLabel,
+        }),
         payload: { ...payload, notification: "landed-success" },
         replyExpected: false,
       },
@@ -241,7 +248,7 @@ export function notifyBranchLandFailed(input: {
     ttlMs: null,
     message: {
       subject: "Workspace land failed",
-      body: `❌ ${branchLabel} did not land on \`${base}\`: ${reason}. You were woken by \`landed-failure\`; inspect workspace status before doing more work. Do NOT push, rebase, merge, or touch the main checkout yourself.`,
+      body: renderTemplate("notify.land.failure", { branch: branchLabel, base, reason }),
       payload,
       replyExpected: false,
     },
@@ -300,7 +307,12 @@ export function notifyStewardHandoff(input: {
       ttlMs: null,
       message: {
         subject: "Your merge is now with a steward",
-        body: `🛟 ${branchLabel} couldn't be auto-merged to \`${base}\` and is now being handled by steward agent \`${input.stewardId}\`${reasonLabel}. The steward will rebase/resolve and land it. Do NOT push, rebase, merge, or touch the main checkout yourself; stay idle until you're woken with the result.`,
+        body: renderTemplate("notify.land.steward-taken", {
+          branch: branchLabel,
+          base,
+          stewardId: input.stewardId,
+          reasonLabel,
+        }),
         payload: { ...payload, notification: "steward-handoff" },
         replyExpected: false,
       },
@@ -318,7 +330,13 @@ export function notifyStewardHandoff(input: {
       ttlMs: null,
       message: {
         subject: "A branch agent's merge is now with a steward",
-        body: `🛟 Your branch agent \`${owner ?? "?"}\`'s merge (${branchLabel} → \`${base}\`) couldn't be auto-merged and is now with steward agent \`${input.stewardId}\`${reasonLabel}. The steward will land it or escalate to you if it can't.`,
+        body: renderTemplate("notify.land.steward-taken.coordinator", {
+          owner: owner ?? "?",
+          branch: branchLabel,
+          base,
+          stewardId: input.stewardId,
+          reasonLabel,
+        }),
         payload: { ...payload, notification: "steward-handoff", audience: "coordinator" },
         replyExpected: false,
       },

package/src/config-store.ts

@@ -11,6 +11,7 @@ import {
 import { DEFAULT_SELF_RESUME_CONFIG, validateSelfResumeConfig } from "./self-resume-config";
 import { TEAM_TEMPLATE_NAMESPACE, validateTeamTemplate } from "./team-template-config";
 import { PROJECT_INSTRUCTION_POLICY_NAMES } from "./project-instructions";
+import { renderTemplate } from "./prompt-resolver";
 import { PROJECT_MCP_POLICY_NAMES } from "./project-mcp";
 import { PROJECT_SETTINGS_POLICY_NAMES } from "./project-settings";
 import { PROJECT_SKILLS_POLICY_NAMES } from "./project-skills";
@@ -60,28 +61,23 @@ const VALID_PERMISSION_MODES = ["open", "guarded", "read-only"] as const;
 const VALID_POLICY_MODES = ["always-on", "on-demand"] as const;
 const VALID_MANAGED_STATUSES = ["stopped", "starting", "running", "stopping", "backoff", "failed"] as const;
 export const DEFAULT_SPAWN_PROFILE_NAME = "default-relay";
-const COORDINATION_CHARTER = "Coordination charter: stay at helicopter altitude; delegate implementation to spawned workers; write briefs, maintain the blackboard and plan DAG; coordinate, review, and release; do not drift into mechanical edits when a worker can do them; protect your context for coordination.";
-const OPS_ASSISTANT_BRIEF = [
-  "Ops-assistant standing brief: execute mechanical operations on your coordinator's behalf: test suites, release commands such as `bun run release`, smoke and verification probes, gates, and host/version/status checks.",
-  "When running a self-verifying long script, especially `bun run release` (gates -> CI-watch -> deploy -> host-verify, then one final result), redirect its output to a file rather than letting it stream into your context: `bun run release > /tmp/ar-release.log 2>&1`. Wait for it to exit, then read only the final result with `tail /tmp/ar-release.log`. Never run it with inline streaming output. Do not poll, monitor, tail logs, run parallel status/version checks, or otherwise babysit it while it runs. Trust the script; act only on its final result. This generalizes to any long-running command whose intermediate output you do not need.",
-  "Hold and apply session-local ops conventions the coordinator gives you. Report crisp outcomes only: command/gate, pass/fail, commit/version/host evidence, and the next blocker when one exists. Do not dump logs unless asked.",
-  "Do not make strategy, design, scope, or release-timing calls. Escalate those decisions to your spawn-parent. Report operational results to your spawn-parent by default and keep their context clean.",
-].join("\n");
 const BUILT_IN_AGENT_PROFILE_NAMES = new Set([DEFAULT_SPAWN_PROFILE_NAME, "minimal", "isolated-research", "vanilla", "lean-worker", "coordinator", "ops-assistant", "worker", "reviewer"]);
 // Tool group set for worker-style profiles (#551): excludes spawn/coordinator-only surface.
 const WORKER_TOOL_GROUPS = ["core", "workspace", "memory", "artifacts", "blackboard", "subscriptions"];
 
-const BUILT_IN_AGENT_PROFILES: AgentProfile[] = [
-  agentProfileDefaults({ name: DEFAULT_SPAWN_PROFILE_NAME, icon: "🤖", description: "Relay-aware spawned agent with bundled Relay context, skills, plugins, and status integration.", base: "host", mcp: { mode: "none" }, relay: { tools: { groups: WORKER_TOOL_GROUPS } } }),
-  agentProfileDefaults({ name: "minimal", icon: "▫️", description: "Repo-focused spawned agent with Relay affordances disabled and host/global extras avoided where supported.", base: "minimal" }),
-  agentProfileDefaults({ name: "isolated-research", icon: "🔬", description: "Strict profile for autonomous research runs: repo context only, no Relay prompt surface, no global extras where supported.", base: "isolated" }),
-  agentProfileDefaults({ name: "vanilla", icon: "🫥", description: "Zero host bleed (#552): isolated provider home with host plugins, skills, hooks, MCP, and the CLAUDE.md/AGENTS.md cascade (repo + global) all suppressed at launch. Relay provisions any surface explicitly per profile.", base: "vanilla" }),
-  agentProfileDefaults({ name: "lean-worker", icon: "🪶", description: "Lean worker profile (#570): vanilla host-dependency drop with only Relay context/MCP restored and Project knowledge injected from the spawn cwd.", base: "vanilla", relay: { context: true, skills: false, plugins: false, statusLine: false, mcp: true, tools: { groups: WORKER_TOOL_GROUPS } }, projectInstructions: { policy: "all" } }),
-  agentProfileDefaults({ name: "coordinator", icon: "🧭", description: "Relay-aware coordination lead for spawning worker teams, maintaining shared state, and driving review and release.", base: "host", instructions: { append: [COORDINATION_CHARTER], repoInstructions: "allow", globalInstructions: "allow" }, maxSpawnedAgents: 8 }),
-  agentProfileDefaults({ name: "ops-assistant", icon: "🛠️", description: "Relay-aware ops lieutenant for a coordinator: runs tests, releases, smoke probes, gates, and host checks, then reports crisp outcomes back up.", provider: "codex", base: "host", instructions: { append: [OPS_ASSISTANT_BRIEF], repoInstructions: "allow", globalInstructions: "allow" }, permissions: { mode: "open", filesystem: "host" } }),
-  agentProfileDefaults({ name: "worker", icon: "🔨", description: "Relay-aware focused implementer with open approval posture and no delegated spawn capability.", base: "host", mcp: { mode: "none" }, permissions: { mode: "open", filesystem: "host" }, relay: { tools: { groups: WORKER_TOOL_GROUPS } } }),
-  agentProfileDefaults({ name: "reviewer", icon: "🔍", description: "Relay-aware read-only reviewer for audit and review passes without file writes.", base: "host", mcp: { mode: "none" }, permissions: { mode: "read-only", filesystem: "host" }, relay: { tools: { groups: WORKER_TOOL_GROUPS } } }),
-].map((profile) => ({ ...profile, builtIn: true }));
+function builtInAgentProfiles(): AgentProfile[] {
+  return [
+    agentProfileDefaults({ name: DEFAULT_SPAWN_PROFILE_NAME, icon: "🤖", description: "Relay-aware spawned agent with bundled Relay context, skills, plugins, and status integration.", base: "host", mcp: { mode: "none" }, relay: { tools: { groups: WORKER_TOOL_GROUPS } } }),
+    agentProfileDefaults({ name: "minimal", icon: "▫️", description: "Repo-focused spawned agent with Relay affordances disabled and host/global extras avoided where supported.", base: "minimal" }),
+    agentProfileDefaults({ name: "isolated-research", icon: "🔬", description: "Strict profile for autonomous research runs: repo context only, no Relay prompt surface, no global extras where supported.", base: "isolated" }),
+    agentProfileDefaults({ name: "vanilla", icon: "🫥", description: "Zero host bleed (#552): isolated provider home with host plugins, skills, hooks, MCP, and the CLAUDE.md/AGENTS.md cascade (repo + global) all suppressed at launch. Relay provisions any surface explicitly per profile.", base: "vanilla" }),
+    agentProfileDefaults({ name: "lean-worker", icon: "🪶", description: "Lean worker profile (#570): vanilla host-dependency drop with only Relay context/MCP restored and Project knowledge injected from the spawn cwd.", base: "vanilla", relay: { context: true, skills: false, plugins: false, statusLine: false, mcp: true, tools: { groups: WORKER_TOOL_GROUPS } }, projectInstructions: { policy: "all" } }),
+    agentProfileDefaults({ name: "coordinator", icon: "🧭", description: "Relay-aware coordination lead for spawning worker teams, maintaining shared state, and driving review and release.", base: "host", instructions: { append: [renderTemplate("profile.coordinator.charter")], repoInstructions: "allow", globalInstructions: "allow" }, maxSpawnedAgents: 8 }),
+    agentProfileDefaults({ name: "ops-assistant", icon: "🛠️", description: "Relay-aware ops lieutenant for a coordinator: runs tests, releases, smoke probes, gates, and host checks, then reports crisp outcomes back up.", provider: "codex", base: "host", instructions: { append: [renderTemplate("profile.ops-assistant.brief")], repoInstructions: "allow", globalInstructions: "allow" }, permissions: { mode: "open", filesystem: "host" } }),
+    agentProfileDefaults({ name: "worker", icon: "🔨", description: "Relay-aware focused implementer with open approval posture and no delegated spawn capability.", base: "host", instructions: { system: renderTemplate("profile.worker.system"), append: [], repoInstructions: "allow", globalInstructions: "allow" }, mcp: { mode: "none" }, permissions: { mode: "open", filesystem: "host" }, relay: { tools: { groups: WORKER_TOOL_GROUPS } } }),
+    agentProfileDefaults({ name: "reviewer", icon: "🔍", description: "Relay-aware read-only reviewer for audit and review passes without file writes.", base: "host", mcp: { mode: "none" }, permissions: { mode: "read-only", filesystem: "host" }, relay: { tools: { groups: WORKER_TOOL_GROUPS } } }),
+  ].map((profile) => ({ ...profile, builtIn: true }));
+}
 
 interface ConfigRow {
   namespace: string;
@@ -455,7 +451,7 @@ function agentProfileOverrideDiff(base: unknown, merged: unknown): unknown {
 }
 
 function validateAgentProfileOverride(key: string, value: unknown): Partial<AgentProfile> {
-  const builtIn = BUILT_IN_AGENT_PROFILES.find((profile) => profile.name === key);
+  const builtIn = builtInAgentProfiles().find((profile) => profile.name === key);
   if (!builtIn) throw new ValidationError("agent profile override target must be a built-in profile");
   if (!isRecord(value)) throw new ValidationError("agent-profile override value must be an object");
   const merged = mergeProfileOverride(builtIn, { ...value, name: key, builtIn: true });
@@ -891,7 +887,7 @@ function builtInProfileEntry(profile: AgentProfile): ConfigEntry<AgentProfile> {
 }
 
 export function getAgentProfile(name: string): ConfigEntry<AgentProfile> | null {
-  const builtIn = BUILT_IN_AGENT_PROFILES.find((profile) => profile.name === name);
+  const builtIn = builtInAgentProfiles().find((profile) => profile.name === name);
   if (builtIn) return builtInProfileEntry(builtIn);
   return getConfig<AgentProfile>(AGENT_PROFILE_NAMESPACE, name);
 }
@@ -922,7 +918,7 @@ export function toolGroupsForProfile(profileName: string | undefined): string[]
 export function listAgentProfiles(): ConfigEntry<AgentProfile>[] {
   const custom = listConfig<AgentProfile>(AGENT_PROFILE_NAMESPACE);
   return [
-    ...BUILT_IN_AGENT_PROFILES.map(builtInProfileEntry),
+    ...builtInAgentProfiles().map(builtInProfileEntry),
     ...custom,
   ].sort((a, b) => Number(Boolean(b.value.builtIn)) - Number(Boolean(a.value.builtIn)) || a.key.localeCompare(b.key));
 }

package/src/context-advisory.ts

@@ -7,6 +7,7 @@ import { NOTIFICATIONS_DEFAULT_KEY, NOTIFICATIONS_NAMESPACE, notificationAgentKe
 import { getDb } from "./db/connection.ts";
 import { emitRelayEvent } from "./events";
 import { routeNotification } from "./notification-router";
+import { renderTemplate } from "./prompt-resolver";
 import { effectiveProviderCatalogList } from "./provider-catalog-store";
 import type { AgentCard, Command, ContextState } from "./types";
 
@@ -71,12 +72,18 @@ function notifyContextAdvisory(input: ContextAdvisoryInput): void {
 }
 
 function contextAdvisoryBody(input: ContextAdvisoryInput): string {
-  const usage = `${formatTokens(input.tokens)} / ${formatTokens(input.windowTokens)} tokens used (${input.percent}% of window, ${input.band}% band)`;
+  const tokens = `${formatTokens(input.tokens)} / ${formatTokens(input.windowTokens)} tokens used`;
+  const percent = `${input.percent}% of window, ${input.band}% band`;
   const threshold = `resolved self-compact threshold ${input.selfCompactPercent}% (${input.thresholdSource})`;
   if (input.stage === "warn") {
-    return `Context warning: ${usage}. You are approaching the ${threshold}; if the current task is at a clean seam, prepare to call relay_compact_and_resume before continuing.`;
+    return renderTemplate("context.advisory.warn", { tokens, percent, threshold });
   }
-  return `Context advisory: ${usage}. You are over the ${threshold}; call relay_compact_and_resume at the next clean seam between tasks or waves, not mid-edit. The ${input.hardBackstopPercent}% hard backstop may request compaction if usage keeps climbing.`;
+  return renderTemplate("context.advisory.compact", {
+    tokens,
+    percent,
+    threshold,
+    hardBackstop: `${input.hardBackstopPercent}%`,
+  });
 }
 
 function contextAdvisoryBand(utilization: number, threshold: EffectiveContextThreshold): { band: number; stage: ContextAdvisoryStage } | null {

package/src/db/index.ts

@@ -38,3 +38,4 @@ export * from "./provisioning-registry.ts";
 export * from "./provider-quotas.ts";
 export * from "./provider-quota-leases.ts";
 export * from "./scheduled-timers.ts";
+export * from "./prompt-templates.ts";

package/src/db/projects.ts

@@ -247,6 +247,35 @@ export function resolveProjectForCwd(cwd: string): Project | null {
   return best ? getProject(best.projectId) : null;
 }
 
+/** Batch cwd→project resolution using the same longest-root-match rule as the scalar helper. */
+export function resolveProjectsForCwds(cwds: string[]): Map<string, Project> {
+  const requested = [...new Set(cwds.filter(Boolean))];
+  const resolved = new Map<string, { projectId: string; len: number }>();
+  if (requested.length === 0) return new Map();
+  const rows = getDb()
+    .query("SELECT project_id, root_path, created_at FROM project_roots")
+    .all() as ProjectRootRow[];
+  for (const cwd of requested) {
+    for (const row of rows) {
+      const current = resolved.get(cwd);
+      if (isPathWithinBase(cwd, row.root_path) && (!current || row.root_path.length > current.len)) {
+        resolved.set(cwd, { projectId: row.project_id, len: row.root_path.length });
+      }
+    }
+  }
+  const mapped = new Map<string, Project>();
+  const projectsById = new Map<string, Project>();
+  for (const [cwd, match] of resolved.entries()) {
+    let project = projectsById.get(match.projectId);
+    if (!project) {
+      project = getProject(match.projectId) ?? undefined;
+      if (project) projectsById.set(match.projectId, project);
+    }
+    if (project) mapped.set(cwd, project);
+  }
+  return mapped;
+}
+
 // ── Composition graph (#406) ────────────────────────────────────────────────
 // project_edges models two relations, asymmetric by design:
 //   • contains    — umbrella → sub-project hierarchy. INHERITS: resolving a

package/src/db/prompt-templates-schema.ts

@@ -0,0 +1,20 @@
+import { defaultPromptTemplates } from "../prompt-resolver";
+import { seedTemplates } from "./prompt-templates";
+
+export const PROMPT_TEMPLATES_SCHEMA_SQL = `
+    CREATE TABLE IF NOT EXISTS prompt_templates (
+      slug TEXT PRIMARY KEY,
+      category TEXT NOT NULL,
+      title TEXT NOT NULL,
+      description TEXT,
+      template TEXT NOT NULL,
+      default_template TEXT NOT NULL,
+      variables TEXT NOT NULL DEFAULT '[]',
+      updated_at INTEGER NOT NULL,
+      created_at INTEGER NOT NULL
+    );
+`;
+
+export function seedPromptTemplatesIfNeeded(): void {
+  seedTemplates(defaultPromptTemplates());
+}