@synap-core/workspace-templates 0.12.0 → 0.24.0

package/capabilities/claude-managed-agents.capability.json

@@ -0,0 +1,215 @@
+{
+  "apiVersion": "synap/v1",
+  "kind": "capability",
+  "meta": {
+    "slug": "claude-managed-agents",
+    "name": "Claude Managed Agents",
+    "description": "Hand a Synap session's work to a Claude Managed Agent that Anthropic runs. It reports back in the session room, asks you before pushing or merging, and shows its PR. Needs an Anthropic API key and a one-time agent setup.",
+    "tags": [
+      "capability",
+      "agents",
+      "anthropic",
+      "opt-in"
+    ],
+    "isPublic": true,
+    "syncByDefault": false
+  },
+  "spec": {
+    "key": "claude-managed-agents",
+    "name": "Claude Managed Agents",
+    "description": "Hands Synap work to a Claude Managed Agent (Anthropic hosts the agent loop and its sandbox) — the first agent binding. Installs ONE external-agent tool (claude_managed_agents, kind external, executor external-agent) whose config.agentBinding names four verbs, all intent delegate_agent_task: <key>_dispatch (start: POST /v1/sessions with the fenced task in initial_events), <key>_send (an answer becomes user.message; a pending tool approval becomes user.tool_confirmation only for a decision naming its event id), <key>_cancel (user.interrupt) and <key>_get_status (READ ONLY, metadata.readOnly: session status + recent events -> running | needs_input | done | failed, with the Console URL and any PR link). The agent reports back through the Synap MCP server under ITS OWN Synap key; it closes a run by ending its final message with the line 'SYNAP_STATUS: done' (a turn that ends without it reads as needs_input). ONE-TIME SETUP (agents are created once, never per run): (1) Synap agent identity: mint a dedicated agent user + key with `synap mcp url --client claude-managed-agents` (prints the pod MCP URL https://<pod>/mcp and the key once). /mcp refuses a bare user key. (2) Anthropic side (Console or `ant apply` files): create an environment {name, config:{type:'cloud', networking:{type:'limited', allow_mcp_servers:true, allow_package_managers:true, allowed_hosts:['github.com','api.github.com']}}}; create the agent {name:'Synap coding agent', model:'claude-opus-5-5', system:<how you want it to work>, mcp_servers:[{type:'url', name:'synap', url:'https://<pod>/mcp'}, {type:'url', name:'github', url:'https://api.githubcopilot.com/mcp/'}], tools:[{type:'agent_toolset_20260401', default_config:{permission_policy:{type:'auto'}}, configs:[{name:'web_search', enabled:false},{name:'web_fetch', enabled:false}]}, {type:'mcp_toolset', mcp_server_name:'synap', default_config:{permission_policy:{type:'always_allow'}}}, {type:'mcp_toolset', mcp_server_name:'github', default_config:{permission_policy:{type:'auto'}}, configs:[{name:'push_files', permission_policy:{type:'always_ask'}},{name:'create_or_update_file', permission_policy:{type:'always_ask'}},{name:'delete_file', permission_policy:{type:'always_ask'}},{name:'merge_pull_request', permission_policy:{type:'always_ask'}}]}]}. Synap governs every write the agent makes through its MCP server, so that toolset is always_allow; pushes and merges are always_ask, which pauses the session (requires_action) and surfaces as needs_input in the session room, settled only by the person's approve / reject on the approval card naming that call (a plan or deploy decision, or any reply in words, never approves a push). Keep repository WRITES on the GitHub MCP tools: give the git-mount token Contents: Read only, so a bash `git push` cannot bypass always_ask. (3) Anthropic vault: create a vault, then add credentials {display_name:'Synap', auth:{type:'static_bearer', mcp_server_url:'https://<pod>/mcp', token:<the agent key from step 1>}} and {display_name:'GitHub', auth:{type:'static_bearer', mcp_server_url:'https://api.githubcopilot.com/mcp/', token:<GitHub PAT: contents + pull requests>}}. Note its vlt_ id. (4) Install this capability on the pod with: the Anthropic API key, the agent_ id, the env_ id, the vlt_ id(s), a read-only GitHub token, optional default repos and the Console workspace id. (5) Bind: `agentUsers.setBinding({ agentUserId: <agent user from step 1>, toolId: <the claude_managed_agents tool id> })` (a person only), approve the capability, and grant that agent auto-run on the dispatch/send/cancel verbs (otherwise every hand-off is a proposal). A verb's own calls to the claude_managed_agents tool are part of that one approved act and are not gated again. REPOS: the run's repos (else the default repos) are mounted as github_repository resources at /workspace/<name>, with the read-only GitHub token redeemed from THIS capability's own vault secret (the applier hands the start verb its vault://<id> at install). Redemption is grant-gated like every secret: grant the GitHub-token secret to whoever runs the verb, or the token reads as absent and the repos are named in the kickoff instead (NOT mounted) for the agent to clone through its GitHub access. PRECONDITION: an Anthropic API key with Managed Agents access (beta managed-agents-2026-04-01).",
+    "params": [
+      {
+        "name": "anthropicApiKey",
+        "label": "Anthropic API key",
+        "type": "password",
+        "required": true,
+        "description": "An Anthropic API key with Managed Agents access, in the workspace that owns the agent and environment. Stored server-encrypted in the vault; never persisted in the template."
+      },
+      {
+        "name": "managedAgentId",
+        "label": "Managed agent id",
+        "type": "text",
+        "required": true,
+        "description": "The agent_... id of the managed agent created once in setup step 2. Its mcp_servers must include this pod's /mcp URL — the dispatch verb checks it before every start."
+      },
+      {
+        "name": "environmentId",
+        "label": "Environment id",
+        "type": "text",
+        "required": true,
+        "description": "The env_... id of the environment the sessions run in (setup step 2)."
+      },
+      {
+        "name": "anthropicVaultIds",
+        "label": "Anthropic vault ids",
+        "type": "text",
+        "required": false,
+        "default": "",
+        "description": "Comma-separated vlt_... ids attached to every session (setup step 3: the Synap MCP bearer + GitHub credentials). Without one the agent cannot reach Synap or GitHub."
+      },
+      {
+        "name": "githubToken",
+        "label": "GitHub token (read-only)",
+        "type": "password",
+        "required": true,
+        "description": "A fine-grained GitHub token with Contents: Read on the repositories, for github_repository mounts. Read-only on purpose: writes go through the GitHub MCP tools, which ask first. Stored server-encrypted in the vault."
+      },
+      {
+        "name": "defaultRepos",
+        "label": "Default repositories",
+        "type": "text",
+        "required": false,
+        "default": "",
+        "description": "Comma-separated owner/repo (or https://github.com/owner/repo) used when a run names no repos."
+      },
+      {
+        "name": "consoleWorkspace",
+        "label": "Anthropic Console workspace id",
+        "type": "text",
+        "required": false,
+        "default": "default",
+        "description": "The workspace id in Console session links (https://platform.claude.com/workspaces/<id>/sessions/<session>). 'default' only for the org's Default workspace."
+      }
+    ],
+    "vault": [
+      {
+        "ref": "anthropicApiKeySecret",
+        "name": "{{name}} Anthropic API key",
+        "value": "{{anthropicApiKey}}",
+        "type": "api_key",
+        "service": "anthropic",
+        "description": "Anthropic API key for the claude_managed_agents binding tool (sent as x-api-key)."
+      },
+      {
+        "ref": "githubTokenSecret",
+        "name": "{{name}} GitHub token (read-only)",
+        "value": "{{githubToken}}",
+        "type": "api_key",
+        "service": "github",
+        "description": "Read-only GitHub token for github_repository mounts on Managed Agents sessions."
+      }
+    ],
+    "tools": [
+      {
+        "name": "claude_managed_agents",
+        "kind": "external",
+        "executor": "external-agent",
+        "description": "The dispatch binding to Claude Managed Agents. Synap never runs the agent: its verbs create, message, interrupt and read a Managed Agents session over https://api.anthropic.com. The vaulted Anthropic key is injected as x-api-key; the credentialRef is remapped to vault://<id> at apply time.",
+        "credentialRef": "anthropicApiKeySecret",
+        "config": {
+          "baseUrl": "https://api.anthropic.com",
+          "auth": {
+            "in": "header",
+            "name": "x-api-key",
+            "prefix": ""
+          },
+          "agentBinding": {
+            "protocol": "vendor:anthropic-managed-agents",
+            "provider": "claude-managed-agents",
+            "supports": {
+              "push": false,
+              "inputRequired": true,
+              "cancel": true
+            },
+            "verbs": {
+              "start": "{{key}}_dispatch",
+              "send": "{{key}}_send",
+              "cancel": "{{key}}_cancel",
+              "status": "{{key}}_get_status"
+            }
+          }
+        }
+      }
+    ],
+    "skills": [
+      {
+        "name": "{{key}}_dispatch",
+        "intent": "delegate_agent_task",
+        "kind": "code",
+        "scope": "pod",
+        "description": "Starts a Claude Managed Agents session for a Synap task (the binding's start verb): checks the agent lists this pod's MCP server, creates the session with the vaults, any mounted repos and the fenced task as its first message. Returns { externalId (sesn_...), url (Console) }.",
+        "requires": [
+          "claude_managed_agents"
+        ],
+        "executionMode": "sync",
+        "timeoutSeconds": 60,
+        "parameters": {
+          "task": "object",
+          "sessionId": "string",
+          "pod": "object",
+          "agent": "object",
+          "repos": "array?",
+          "branch": "string?",
+          "workBranch": "string?",
+          "runId": "string?",
+          "channelId": "string?"
+        },
+        "code": "// Claude Managed Agents binding verb. Statement body: the executor wraps it as\n// (async function(args, context){ <code> }). Request shapes follow the Managed\n// Agents API (beta header managed-agents-2026-04-01): POST /v1/sessions,\n// GET /v1/sessions/{id}, GET|POST /v1/sessions/{id}/events.\n// callProvider('claude_managed_agents', ...) resolves the binding tool by NAME,\n// injects the vaulted Anthropic key as `x-api-key` (tool config.auth) and pins\n// the host to https://api.anthropic.com (tool config.baseUrl).\nconst MA_HEADERS = {\n  'anthropic-version': '2023-06-01',\n  'anthropic-beta': 'managed-agents-2026-04-01',\n};\nasync function ma(method, path, body) {\n  const res = await callProvider('claude_managed_agents', method, path, body, { headers: MA_HEADERS });\n  if (res && res.proposed) {\n    throw new Error(\n      'claude-managed-agents: the Anthropic call was queued for review (proposal ' + res.proposalId + ') instead of running. ' +\n      'Approve that proposal, or check the claude_managed_agents tool is enabled, then run again.'\n    );\n  }\n  return res && res.body !== undefined ? res.body : res;\n}\nfunction sessionIdOf(raw) {\n  const id = String(raw == null ? '' : raw).trim();\n  if (!/^sesn_[A-Za-z0-9_-]+$/.test(id)) {\n    throw new Error('claude-managed-agents: \"' + id + '\" is not a Managed Agents session id (sesn_...)');\n  }\n  return id;\n}\nasync function recentEvents(id) {\n  // Newest first. The last 100 events always hold the latest status_idle and the\n  // events it is blocked on (an idle is emitted after them).\n  const page = await ma('GET', '/v1/sessions/' + id + '/events?order=desc&limit=100');\n  if (!page || !Array.isArray(page.data)) {\n    throw new Error('claude-managed-agents: unreadable event list for ' + id);\n  }\n  return page.data;\n}\nfunction latestIdle(events) {\n  return events.find((e) => e && e.type === 'session.status_idle') || null;\n}\nfunction pendingConfirmations(events) {\n  const idle = latestIdle(events);\n  if (!idle || !idle.stop_reason || idle.stop_reason.type !== 'requires_action') return [];\n  const ids = Array.isArray(idle.stop_reason.event_ids) ? idle.stop_reason.event_ids : [];\n  return ids\n    .map((eid) => events.find((e) => e && e.id === eid))\n    .filter((e) => e && (e.type === 'agent.tool_use' || e.type === 'agent.mcp_tool_use') && e.evaluated_permission === 'ask');\n}\n\n// ── start: create a Managed Agents session for the task ─────────────────────\n// Install-time config, interpolated by the applier. These are IDs, not secrets\n// (the Anthropic key and the GitHub token live in the pod vault). Each is\n// validated before use: a blank or malformed value fails loudly.\nconst CFG = {\n  agentId: '{{managedAgentId}}',\n  environmentId: '{{environmentId}}',\n  vaultIds: '{{anthropicVaultIds}}',\n  defaultRepos: '{{defaultRepos}}',\n  consoleWorkspace: '{{consoleWorkspace}}',\n  // The pod vault ref of the GitHub token, for `github_repository` mounts: the\n  // applier rewrites this placeholder to this template's OWN vault://<id> at\n  // install. secrets.get redeems it only under a vault grant for the caller;\n  // without one it reads null and the repos are named, NOT mounted. Never a raw\n  // token here.\n  githubTokenRef: '{{vault:githubTokenSecret}}',\n};\nconst ID_RE = /^[A-Za-z0-9_-]+$/;\nfunction configured(name, value, prefix) {\n  const v = String(value || '').trim();\n  if (!v || !ID_RE.test(v) || v.indexOf(prefix) !== 0) {\n    throw new Error('claude-managed-agents: ' + name + ' is not configured (expected ' + prefix + '...). Re-apply the capability with it.');\n  }\n  return v;\n}\nconst agentId = configured('managedAgentId', CFG.agentId, 'agent_');\nconst environmentId = configured('environmentId', CFG.environmentId, 'env_');\nconst vaultIds = String(CFG.vaultIds || '')\n  .split(',')\n  .map((s) => s.trim())\n  .filter(Boolean)\n  .map((v) => configured('anthropicVaultIds', v, 'vlt_'));\nconst workspace = ID_RE.test(String(CFG.consoleWorkspace || '').trim()) ? String(CFG.consoleWorkspace).trim() : 'default';\n\nconst task = args.task && typeof args.task === 'object' ? args.task : null;\nif (!task || typeof task.goal !== 'string' || !task.goal.trim()) {\n  throw new Error('claude-managed-agents: task.goal is required');\n}\nconst pod = args.pod && typeof args.pod === 'object' ? args.pod : {};\nconst mcpUrl = typeof pod.mcpUrl === 'string' ? pod.mcpUrl.trim() : '';\nif (!mcpUrl) {\n  throw new Error('claude-managed-agents: the pod has no public MCP URL, so the agent could not report back. Set the pod public origin first.');\n}\n\n// The agent must reach Synap: its definition has to list the pod MCP server\n// (the vault static_bearer credential is matched to it by URL).\nfunction normUrl(u) {\n  const m = /^(https?):\\/\\/([^/?#]+)([^?#]*)/i.exec(String(u || '').trim());\n  if (!m) return null;\n  const scheme = m[1].toLowerCase();\n  let host = m[2].toLowerCase();\n  if ((scheme === 'https' && /:443$/.test(host)) || (scheme === 'http' && /:80$/.test(host))) host = host.replace(/:\\d+$/, '');\n  return scheme + '://' + host + m[3].replace(/\\/+$/, '');\n}\nconst agent = await ma('GET', '/v1/agents/' + agentId);\nconst servers = agent && Array.isArray(agent.mcp_servers) ? agent.mcp_servers : [];\nif (!servers.some((s) => s && normUrl(s.url) === normUrl(mcpUrl))) {\n  throw new Error(\n    'claude-managed-agents: managed agent ' + agentId + ' does not list the Synap MCP server ' + mcpUrl +\n    ' in mcp_servers, so it could not report back. Add it (setup step 2) and run again.'\n  );\n}\n\n// Repositories: the run's, else the install default.\nfunction repoOf(raw) {\n  const s = String(raw || '').trim().replace(/\\.git$/, '').replace(/\\/+$/, '');\n  const m = /^https:\\/\\/github\\.com\\/([\\w.-]+)\\/([\\w.-]+)$/.exec(s) || /^([\\w.-]+)\\/([\\w.-]+)$/.exec(s);\n  if (!m) throw new Error('claude-managed-agents: \"' + s + '\" is not a GitHub repository (owner/repo or https://github.com/owner/repo)');\n  return { url: 'https://github.com/' + m[1] + '/' + m[2], full: m[1] + '/' + m[2], name: m[2] };\n}\nconst repoInputs = Array.isArray(args.repos) && args.repos.length\n  ? args.repos\n  : String(CFG.defaultRepos || '').split(',').map((s) => s.trim()).filter(Boolean);\nconst repos = repoInputs.map(repoOf);\n// `branch` = a branch the run NAMES: it exists, so the repos mount on it\n// (checkout). `workBranch` = the per-session branch Synap defaulted: it does NOT\n// exist yet, so it is never a checkout — the repos mount at their default\n// branch and the kickoff tells the agent to create it and push its work there.\nfunction branchName(v) {\n  if (typeof v !== 'string' || !v.trim()) return null;\n  const b = v.trim();\n  if (!/^[\\w./-]{1,255}$/.test(b)) throw new Error('claude-managed-agents: \"' + b + '\" is not a branch name');\n  return b;\n}\nconst branch = branchName(args.branch);\nconst workBranch = branch ? null : branchName(args.workBranch);\n\nlet githubToken = null;\nif (repos.length && /^vault:\\/\\//.test(CFG.githubTokenRef) && typeof secrets !== 'undefined') {\n  githubToken = await secrets.get(CFG.githubTokenRef);\n}\nconst resources = githubToken\n  ? repos.map((r) => {\n      const res = { type: 'github_repository', url: r.url, authorization_token: githubToken };\n      if (branch) res.checkout = { type: 'branch', name: branch };\n      return res;\n    })\n  : [];\n\n// The kickoff. task.goal / task.feedback arrive ALREADY fenced as untrusted data.\nconst lines = [\n  'Synap handed you this task. Synap session ' + String(args.sessionId || '') + (args.runId ? ', run ' + args.runId : '') + '.',\n  '',\n  'Report back through the Synap MCP server configured on you (' + mcpUrl + '), as yourself:',\n  args.channelId\n    ? '- post progress, questions and results in the session room with post_message, channelId ' + args.channelId + ';'\n    : '- post progress, questions and results in the Synap session;',\n  '- when you need a person (a question, a choice), ask it there, then end your turn with a final line `SYNAP_STATUS: needs_input`. Their answer arrives here as your next message;',\n  '- when the task is complete, post the result (PR link, branch, preview URL) there and end your final message with the line `SYNAP_STATUS: done`.',\n  '',\n];\n// Subject name / profile / stage are a person's words and sit OUTSIDE the\n// fenced task: one line each, capped, so they cannot open a new instruction\n// line (or forge a fence marker) in the kickoff.\nfunction oneLine(v, max) {\n  return String(v == null ? '' : v).replace(/[\\r\\n\\u2028\\u2029]+/g, ' ').replace(/-{3,}/g, '-').trim().slice(0, max);\n}\nif (task.currentStage) lines.push('Current stage: ' + oneLine(task.currentStage, 120));\nif (task.subject && task.subject.id) {\n  lines.push('Subject: ' + oneLine(task.subject.name || task.subject.id, 200) + (task.subject.profile ? ' (' + oneLine(task.subject.profile, 80) + ')' : '') + ', Synap id ' + oneLine(task.subject.id, 80));\n}\nif (repos.length) {\n  lines.push(\n    resources.length\n      ? 'Repositories (mounted at /workspace/<name>): ' + repos.map((r) => r.full).join(', ') + (branch ? ' on branch ' + branch : '')\n      : 'Repositories (NOT mounted; use your GitHub access): ' + repos.map((r) => r.url).join(', ') + (branch ? ' (branch ' + branch + ')' : '')\n  );\n  if (workBranch) {\n    lines.push('Work branch: create ' + workBranch + ' from the default branch, push your work to it, and open the pull request from it. Never push to the default branch.');\n  }\n}\nlines.push('', 'The task:', task.goal);\nif (typeof task.feedback === 'string' && task.feedback.trim()) lines.push('', 'Reviewer feedback on an earlier attempt:', task.feedback);\n\nconst metadata = {};\nif (args.sessionId) metadata.synap_session_id = String(args.sessionId).slice(0, 512);\nif (args.runId) metadata.synap_run_id = String(args.runId).slice(0, 512);\nif (args.channelId) metadata.synap_channel_id = String(args.channelId).slice(0, 512);\nif (args.agent && args.agent.agentUserId) metadata.synap_agent_user_id = String(args.agent.agentUserId).slice(0, 512);\n\nconst subjectName = task.subject && task.subject.name ? oneLine(task.subject.name, 180) : 'task';\nconst body = {\n  agent: agentId,\n  environment_id: environmentId,\n  title: ('Synap: ' + subjectName).slice(0, 200),\n  metadata,\n  initial_events: [{ type: 'user.message', content: [{ type: 'text', text: lines.join('\\n') }] }],\n};\nif (vaultIds.length) body.vault_ids = vaultIds;\nif (resources.length) body.resources = resources;\n\nconst session = await ma('POST', '/v1/sessions', body);\nif (!session || typeof session.id !== 'string') {\n  throw new Error('claude-managed-agents: the session create returned no id');\n}\nreturn {\n  externalId: session.id,\n  url: 'https://platform.claude.com/workspaces/' + workspace + '/sessions/' + session.id,\n  status: session.status || null,\n  repos: repos.map((r) => r.full),\n  reposMounted: resources.length > 0,\n};\n"
+      },
+      {
+        "name": "{{key}}_send",
+        "intent": "delegate_agent_task",
+        "kind": "code",
+        "scope": "pod",
+        "description": "Passes a person's answer or decision to the running session (the binding's send verb). A pending tool approval is settled with user.tool_confirmation ONLY by an approved / rejected decision naming its event id (message.confirmationId); every other answer or decision goes in as user.message.",
+        "requires": [
+          "claude_managed_agents"
+        ],
+        "executionMode": "sync",
+        "timeoutSeconds": 60,
+        "parameters": {
+          "sessionId": "string",
+          "externalId": "string",
+          "message": "object",
+          "runId": "string?",
+          "channelId": "string?"
+        },
+        "code": "// Claude Managed Agents binding verb. Statement body: the executor wraps it as\n// (async function(args, context){ <code> }). Request shapes follow the Managed\n// Agents API (beta header managed-agents-2026-04-01): POST /v1/sessions,\n// GET /v1/sessions/{id}, GET|POST /v1/sessions/{id}/events.\n// callProvider('claude_managed_agents', ...) resolves the binding tool by NAME,\n// injects the vaulted Anthropic key as `x-api-key` (tool config.auth) and pins\n// the host to https://api.anthropic.com (tool config.baseUrl).\nconst MA_HEADERS = {\n  'anthropic-version': '2023-06-01',\n  'anthropic-beta': 'managed-agents-2026-04-01',\n};\nasync function ma(method, path, body) {\n  const res = await callProvider('claude_managed_agents', method, path, body, { headers: MA_HEADERS });\n  if (res && res.proposed) {\n    throw new Error(\n      'claude-managed-agents: the Anthropic call was queued for review (proposal ' + res.proposalId + ') instead of running. ' +\n      'Approve that proposal, or check the claude_managed_agents tool is enabled, then run again.'\n    );\n  }\n  return res && res.body !== undefined ? res.body : res;\n}\nfunction sessionIdOf(raw) {\n  const id = String(raw == null ? '' : raw).trim();\n  if (!/^sesn_[A-Za-z0-9_-]+$/.test(id)) {\n    throw new Error('claude-managed-agents: \"' + id + '\" is not a Managed Agents session id (sesn_...)');\n  }\n  return id;\n}\nasync function recentEvents(id) {\n  // Newest first. The last 100 events always hold the latest status_idle and the\n  // events it is blocked on (an idle is emitted after them).\n  const page = await ma('GET', '/v1/sessions/' + id + '/events?order=desc&limit=100');\n  if (!page || !Array.isArray(page.data)) {\n    throw new Error('claude-managed-agents: unreadable event list for ' + id);\n  }\n  return page.data;\n}\nfunction latestIdle(events) {\n  return events.find((e) => e && e.type === 'session.status_idle') || null;\n}\nfunction pendingConfirmations(events) {\n  const idle = latestIdle(events);\n  if (!idle || !idle.stop_reason || idle.stop_reason.type !== 'requires_action') return [];\n  const ids = Array.isArray(idle.stop_reason.event_ids) ? idle.stop_reason.event_ids : [];\n  return ids\n    .map((eid) => events.find((e) => e && e.id === eid))\n    .filter((e) => e && (e.type === 'agent.tool_use' || e.type === 'agent.mcp_tool_use') && e.evaluated_permission === 'ask');\n}\n\n// ── send: a person's answer or decision reaches the running session ─────────\n// A pending tool confirmation (always_ask: pushes / merges) is settled ONLY by\n// a decision that NAMES it (message.confirmationId — the event id the status\n// verb reported, carried on the approval card Synap showed the person). Every\n// other message — an answer, a plan / deploy decision, any free text — goes\n// in as a user.message, never as an approval: approving a plan is not\n// approving a push.\nconst id = sessionIdOf(args.externalId);\nconst message = args.message && typeof args.message === 'object' ? args.message : null;\nif (!message || (message.kind !== 'answer' && message.kind !== 'decision')) {\n  throw new Error('claude-managed-agents: message.kind must be \"answer\" or \"decision\"');\n}\nconst fenced = typeof message.text === 'string' ? message.text : '';\nconst confirmationId = message.confirmationId == null ? null : String(message.confirmationId).trim();\nif (confirmationId !== null) {\n  if (message.kind !== 'decision' || (message.decision !== 'approved' && message.decision !== 'rejected')) {\n    throw new Error('claude-managed-agents: a tool confirmation is settled only by an approved / rejected decision');\n  }\n  if (!/^[A-Za-z0-9_-]{1,200}$/.test(confirmationId)) {\n    throw new Error('claude-managed-agents: \"' + confirmationId + '\" is not a Managed Agents event id');\n  }\n}\n\nconst session = await ma('GET', '/v1/sessions/' + id);\nif (!session || typeof session.status !== 'string') {\n  throw new Error('claude-managed-agents: unreadable session ' + id);\n}\nif (session.status === 'terminated') {\n  throw new Error('claude-managed-agents: session ' + id + ' has ended; start a new run to continue');\n}\n\nlet events;\nif (confirmationId !== null) {\n  const pending = session.status === 'idle' ? pendingConfirmations(await recentEvents(id)) : [];\n  const target = pending.find((e) => e.id === confirmationId);\n  if (!target) {\n    throw new Error('claude-managed-agents: tool call ' + confirmationId + ' is no longer waiting for approval in session ' + id);\n  }\n  events = [\n    message.decision === 'approved'\n      ? { type: 'user.tool_confirmation', tool_use_id: target.id, result: 'allow' }\n      : { type: 'user.tool_confirmation', tool_use_id: target.id, result: 'deny', deny_message: ('A person in Synap refused this call.\\n' + fenced).slice(0, 4000) },\n  ];\n} else {\n  // proposalId / decision / slotKey sit OUTSIDE the fence: one line each,\n  // capped, so they cannot open a new instruction line (or forge a fence\n  // marker). Same sanitizer as the start verb's subject line.\n  const oneLine = (v, max) => String(v == null ? '' : v).replace(/[\\r\\n\\u2028\\u2029]+/g, ' ').replace(/-{3,}/g, '-').trim().slice(0, max);\n  const head = message.kind === 'decision'\n    ? 'A decision from Synap' + (message.proposalId ? ' on proposal ' + oneLine(message.proposalId, 200) : '') + ': ' + oneLine(message.decision || 'noted', 50) + '.'\n    : 'A person answered in the Synap session' + (message.slotKey ? ' (about: ' + oneLine(message.slotKey, 200) + ')' : '') + '.';\n  events = [{ type: 'user.message', content: [{ type: 'text', text: head + '\\n' + fenced }] }];\n}\nawait ma('POST', '/v1/sessions/' + id + '/events', { events });\nreturn { externalId: id, sent: events.map((e) => e.type), confirmed: confirmationId };\n"
+      },
+      {
+        "name": "{{key}}_cancel",
+        "intent": "delegate_agent_task",
+        "kind": "code",
+        "scope": "pod",
+        "description": "Stops the running session with user.interrupt (the binding's cancel verb). An already-ended session reports alreadyEnded.",
+        "requires": [
+          "claude_managed_agents"
+        ],
+        "executionMode": "sync",
+        "timeoutSeconds": 30,
+        "parameters": {
+          "sessionId": "string",
+          "externalId": "string",
+          "runId": "string?"
+        },
+        "code": "// Claude Managed Agents binding verb. Statement body: the executor wraps it as\n// (async function(args, context){ <code> }). Request shapes follow the Managed\n// Agents API (beta header managed-agents-2026-04-01): POST /v1/sessions,\n// GET /v1/sessions/{id}, GET|POST /v1/sessions/{id}/events.\n// callProvider('claude_managed_agents', ...) resolves the binding tool by NAME,\n// injects the vaulted Anthropic key as `x-api-key` (tool config.auth) and pins\n// the host to https://api.anthropic.com (tool config.baseUrl).\nconst MA_HEADERS = {\n  'anthropic-version': '2023-06-01',\n  'anthropic-beta': 'managed-agents-2026-04-01',\n};\nasync function ma(method, path, body) {\n  const res = await callProvider('claude_managed_agents', method, path, body, { headers: MA_HEADERS });\n  if (res && res.proposed) {\n    throw new Error(\n      'claude-managed-agents: the Anthropic call was queued for review (proposal ' + res.proposalId + ') instead of running. ' +\n      'Approve that proposal, or check the claude_managed_agents tool is enabled, then run again.'\n    );\n  }\n  return res && res.body !== undefined ? res.body : res;\n}\nfunction sessionIdOf(raw) {\n  const id = String(raw == null ? '' : raw).trim();\n  if (!/^sesn_[A-Za-z0-9_-]+$/.test(id)) {\n    throw new Error('claude-managed-agents: \"' + id + '\" is not a Managed Agents session id (sesn_...)');\n  }\n  return id;\n}\nasync function recentEvents(id) {\n  // Newest first. The last 100 events always hold the latest status_idle and the\n  // events it is blocked on (an idle is emitted after them).\n  const page = await ma('GET', '/v1/sessions/' + id + '/events?order=desc&limit=100');\n  if (!page || !Array.isArray(page.data)) {\n    throw new Error('claude-managed-agents: unreadable event list for ' + id);\n  }\n  return page.data;\n}\nfunction latestIdle(events) {\n  return events.find((e) => e && e.type === 'session.status_idle') || null;\n}\nfunction pendingConfirmations(events) {\n  const idle = latestIdle(events);\n  if (!idle || !idle.stop_reason || idle.stop_reason.type !== 'requires_action') return [];\n  const ids = Array.isArray(idle.stop_reason.event_ids) ? idle.stop_reason.event_ids : [];\n  return ids\n    .map((eid) => events.find((e) => e && e.id === eid))\n    .filter((e) => e && (e.type === 'agent.tool_use' || e.type === 'agent.mcp_tool_use') && e.evaluated_permission === 'ask');\n}\n\n// ── cancel: interrupt the running session (user.interrupt jumps the queue and\n// forces it idle). An already-ended session is reported, not an error.\nconst id = sessionIdOf(args.externalId);\nconst session = await ma('GET', '/v1/sessions/' + id);\nif (!session || typeof session.status !== 'string') {\n  throw new Error('claude-managed-agents: unreadable session ' + id);\n}\nif (session.status === 'terminated') {\n  return { externalId: id, cancelled: true, alreadyEnded: true };\n}\nawait ma('POST', '/v1/sessions/' + id + '/events', { events: [{ type: 'user.interrupt' }] });\nreturn { externalId: id, cancelled: true, alreadyEnded: false };\n"
+      },
+      {
+        "name": "{{key}}_get_status",
+        "intent": "delegate_agent_task",
+        "kind": "code",
+        "scope": "pod",
+        "description": "Reads the session and its recent events and normalizes them (the binding's status verb, polled while a run is active). Read-only. Returns { state: running | needs_input | done | failed, url, prUrl?, summary?, confirmationId? } — confirmationId names the ONE tool call waiting for approval.",
+        "requires": [
+          "claude_managed_agents"
+        ],
+        "executionMode": "sync",
+        "timeoutSeconds": 30,
+        "parameters": {
+          "sessionId": "string",
+          "externalId": "string",
+          "runId": "string?"
+        },
+        "code": "// Claude Managed Agents binding verb. Statement body: the executor wraps it as\n// (async function(args, context){ <code> }). Request shapes follow the Managed\n// Agents API (beta header managed-agents-2026-04-01): POST /v1/sessions,\n// GET /v1/sessions/{id}, GET|POST /v1/sessions/{id}/events.\n// callProvider('claude_managed_agents', ...) resolves the binding tool by NAME,\n// injects the vaulted Anthropic key as `x-api-key` (tool config.auth) and pins\n// the host to https://api.anthropic.com (tool config.baseUrl).\nconst MA_HEADERS = {\n  'anthropic-version': '2023-06-01',\n  'anthropic-beta': 'managed-agents-2026-04-01',\n};\nasync function ma(method, path, body) {\n  const res = await callProvider('claude_managed_agents', method, path, body, { headers: MA_HEADERS });\n  if (res && res.proposed) {\n    throw new Error(\n      'claude-managed-agents: the Anthropic call was queued for review (proposal ' + res.proposalId + ') instead of running. ' +\n      'Approve that proposal, or check the claude_managed_agents tool is enabled, then run again.'\n    );\n  }\n  return res && res.body !== undefined ? res.body : res;\n}\nfunction sessionIdOf(raw) {\n  const id = String(raw == null ? '' : raw).trim();\n  if (!/^sesn_[A-Za-z0-9_-]+$/.test(id)) {\n    throw new Error('claude-managed-agents: \"' + id + '\" is not a Managed Agents session id (sesn_...)');\n  }\n  return id;\n}\nasync function recentEvents(id) {\n  // Newest first. The last 100 events always hold the latest status_idle and the\n  // events it is blocked on (an idle is emitted after them).\n  const page = await ma('GET', '/v1/sessions/' + id + '/events?order=desc&limit=100');\n  if (!page || !Array.isArray(page.data)) {\n    throw new Error('claude-managed-agents: unreadable event list for ' + id);\n  }\n  return page.data;\n}\nfunction latestIdle(events) {\n  return events.find((e) => e && e.type === 'session.status_idle') || null;\n}\nfunction pendingConfirmations(events) {\n  const idle = latestIdle(events);\n  if (!idle || !idle.stop_reason || idle.stop_reason.type !== 'requires_action') return [];\n  const ids = Array.isArray(idle.stop_reason.event_ids) ? idle.stop_reason.event_ids : [];\n  return ids\n    .map((eid) => events.find((e) => e && e.id === eid))\n    .filter((e) => e && (e.type === 'agent.tool_use' || e.type === 'agent.mcp_tool_use') && e.evaluated_permission === 'ask');\n}\n\n// ── status: READ ONLY. Session status + its recent events → the normalized\n// { state: running|needs_input|done|failed, url, prUrl?, summary? }.\n// Only GETs; declared metadata.readOnly so a poll never becomes a proposal.\nconst WS = '{{consoleWorkspace}}'.trim();\nconst CONSOLE_WORKSPACE = /^[A-Za-z0-9_-]+$/.test(WS) ? WS : 'default';\nconst id = sessionIdOf(args.externalId);\nconst session = await ma('GET', '/v1/sessions/' + id);\nif (!session || typeof session.status !== 'string') {\n  throw new Error('claude-managed-agents: unreadable session ' + id);\n}\nconst events = await recentEvents(id);\n\nconst out = { url: 'https://platform.claude.com/workspaces/' + CONSOLE_WORKSPACE + '/sessions/' + id };\nfunction textOf(e) {\n  return Array.isArray(e && e.content)\n    ? e.content.filter((c) => c && c.type === 'text' && typeof c.text === 'string').map((c) => c.text).join('\\n')\n    : '';\n}\n// The newest PR link the agent wrote or a GitHub tool returned.\nconst PR_RE = /https:\\/\\/github\\.com\\/[\\w.-]+\\/[\\w.-]+\\/pull\\/\\d+/;\nfor (const e of events) {\n  if (!e || (e.type !== 'agent.message' && e.type !== 'agent.mcp_tool_result' && e.type !== 'agent.tool_result')) continue;\n  const m = PR_RE.exec(JSON.stringify(e.content == null ? '' : e.content));\n  if (m) { out.prUrl = m[0]; break; }\n}\nconst lastMessage = events.find((e) => e && e.type === 'agent.message' && textOf(e).trim());\nconst lastText = lastMessage ? textOf(lastMessage) : '';\nconst STATUS_RE = /^\\s*SYNAP_STATUS:\\s*(done|needs_input)\\s*$/im;\nconst declared = (STATUS_RE.exec(lastText) || [])[1] || null;\nconst said = lastText.replace(new RegExp(STATUS_RE.source, 'gim'), '').trim().slice(0, 1500);\nfunction errorText(predicate) {\n  const err = events.find((e) => e && e.type === 'session.error' && (!predicate || predicate(e)));\n  return err && err.error && typeof err.error.message === 'string' ? err.error.message : null;\n}\n\nswitch (session.status) {\n  case 'running':\n  case 'rescheduling':\n    return Object.assign({ state: 'running' }, out);\n  case 'terminated': {\n    // Terminated is completion OR an unrecoverable error: a terminal-retry error says which.\n    const fatal = errorText((e) => e.error && e.error.retry_status && e.error.retry_status.type === 'terminal');\n    return fatal\n      ? Object.assign({ state: 'failed', summary: fatal }, out)\n      : Object.assign({ state: 'done' }, said ? { summary: said } : {}, out);\n  }\n  case 'idle': {\n    const idle = latestIdle(events);\n    const stop = idle && idle.stop_reason ? idle.stop_reason.type : null;\n    if (stop === 'requires_action') {\n      // ONE confirmation at a time: its event id rides on the approval card, and\n      // only a decision naming it settles it (the send verb). The next poll\n      // reports the next one, if several were waiting.\n      const ask = pendingConfirmations(events)[0];\n      const name = ask ? (ask.mcp_server_name ? ask.mcp_server_name + '.' : '') + String(ask.name || 'a tool') : null;\n      return Object.assign(\n        ask\n          ? { state: 'needs_input', confirmationId: ask.id, summary: 'The agent is waiting for your approval to run ' + name + '.' }\n          : { state: 'needs_input', summary: 'The agent is waiting on an action before it can continue.' },\n        out\n      );\n    }\n    if (stop === 'budget_reached') {\n      return Object.assign({\n        state: 'needs_input',\n        summary: 'The agent paused at its spend budget. Raise or remove the session budget in the Anthropic Console to continue.',\n      }, out);\n    }\n    if (stop === 'retries_exhausted') {\n      return Object.assign({ state: 'failed', summary: errorText() || 'The agent stopped after repeated errors.' }, out);\n    }\n    if (stop === 'refusal') {\n      return Object.assign({ state: 'failed', summary: 'The model declined to continue this task.' }, out);\n    }\n    if (stop === 'end_turn') {\n      // Only the agent's own `SYNAP_STATUS: done` line closes the run. A turn that\n      // ends without it (a question, an interrupt) waits on a person.\n      if (declared === 'done') return Object.assign({ state: 'done' }, said ? { summary: said } : {}, out);\n      return Object.assign({\n        state: 'needs_input',\n        summary: said || 'The agent stopped and is waiting for you.',\n      }, out);\n    }\n    throw new Error('claude-managed-agents: session ' + id + ' is idle for an unrecognized reason (' + String(stop) + ')');\n  }\n  default:\n    throw new Error('claude-managed-agents: unrecognized session status \"' + session.status + '\"');\n}\n",
+        "metadata": {
+          "readOnly": true
+        }
+      }
+    ],
+    "provides": [
+      "delegate_agent_task"
+    ]
+  },
+  "dependencies": []
+}

package/capabilities/client-comms-report.capability.json

@@ -0,0 +1,246 @@
+{
+  "apiVersion": "synap/v1",
+  "kind": "capability",
+  "meta": {
+    "slug": "client-comms-report",
+    "name": "Client Comms Report",
+    "description": "Posts a daily summary of each client's recent messages to that client's internal team channel, never to the client. Includes an on-demand catch-up playbook. The daily report ships turned off; enable it when ready.",
+    "tags": [
+      "capability"
+    ],
+    "isPublic": true,
+    "syncByDefault": true
+  },
+  "spec": {
+    "key": "client-comms-report",
+    "name": "Client Comms Report",
+    "description": "Portable daily client-comms digest. Install on any pod to post a per-client summary of recent inbound messages to each client's internal team channel (never client-facing), with an on-demand report playbook too. Message-first and schema-free — for teams that want per-client comms readouts without the full Operations delivery workspace. For durable, queryable client-briefing records over time, use the Operations workspace's built-in daily briefing.",
+    "params": [],
+    "vault": [],
+    "tools": [],
+    "skills": [
+      {
+        "name": "client-comms-report-method",
+        "kind": "instruction",
+        "scope": "pod",
+        "description": "How to digest a client's communication channel into a concise report for the internal team channel.",
+        "code": "# Client comms report — methodology\n\nWhen digesting a client's communication channel into a report for the internal team:\n\n- Surface only REAL signal: status changes, decisions, deals/opportunities, competitor mentions, new leads or contacts, risks/blockers, and any deadline or commitment. Skip small talk and noise.\n- Resolve identity BEFORE treating anything as new — match on strong signals (email, phone, url, handle) against existing entities.\n- Distinguish the CLIENT's people from OUR team.\n- Be skimmable: lead with what matters most, group by theme, keep it tight. If nothing crossed the bar, say so in one line.\n- FIREWALL (never bend this): the report is for the INTERNAL TEAM channel only. Never post the report — or any AI message — into the client-facing comms channel. Resolve the team channel via `channel.resolve` with `branchPurpose: \"team\"`, and post there and only there."
+      }
+    ],
+    "provides": [],
+    "playbooks": [
+      {
+        "name": "Client Comms Report",
+        "description": "On-demand \"catch me up on this client\": read the client's bound comms channel, extract the real signal, propose any CRM updates (governed), and post a concise report to the client's TEAM channel.",
+        "subjectProfile": {
+          "profileSlug": "company"
+        },
+        "params": [
+          {
+            "name": "client",
+            "label": "Client",
+            "type": "entity",
+            "required": true,
+            "description": "The client this report runs for (the session subject)."
+          }
+        ],
+        "channelSpec": {
+          "type": "THREAD",
+          "aiReactionMode": "only_mentioned"
+        },
+        "executor": "is-agent",
+        "status": "active",
+        "goalTemplate": "Produce a client-comms report for the subject client, following the `client-comms-report-method` methodology.\n\n1. Resolve this client's comms channel: run_capability channel.resolve { contextObjectType: \"entity\", contextObjectId: <the subject client's id>, branchPurpose: \"client-comms\" }. If it returns no channel, stop and say \"no comms channel is bound for this client yet\".\n2. Read the recent window: run_capability feed.read { channelId: <that channel id>, limit: 40 }.\n3. Extract the real signal (status, deals, competitors, new leads, risks, deadlines). Resolve identity before creating anything.\n4. PROPOSE any CRM updates through the normal governed doors (update_entity / attach_facet / capture). A \"proposed\" result is success, not failure — never force writes.\n5. Resolve the TEAM channel: run_capability channel.resolve { contextObjectType: \"entity\", contextObjectId: <the subject client's id>, branchPurpose: \"team\" }. If it returns no team channel, stop and say so (do NOT fall back to the client channel).\n6. Post a concise report: run_capability feed.post { channelId: <the team channel id>, content: <the report> }. FIREWALL: the team channel only, never the client channel."
+      }
+    ],
+    "automations": [
+      {
+        "name": "Client Comms — Daily Report",
+        "description": "Each morning, for every client, read their bound comms channel, and if there's real signal post a concise digest to the client's TEAM channel. Firewall-safe (team channel only). Seeded as draft — enable it after a manual dogfood run.",
+        "triggerType": "cron",
+        "triggerConfig": {
+          "expression": "0 8 * * *"
+        },
+        "status": "draft",
+        "_note": "KEPT AS DRAFT (decision 7 — 'keep both as different jobs'). Enrichment + the daily client read rode the ONE daily comms read in the (since-removed, D5 2026-09-25) Stellar grant capability's 'Stellar Grant — Client Sync' automation (its single `assess` pass over the same clients emits progress + contextSummary + need signal). Activating THIS standalone daily cron on the same pod would be a SECOND whole-fleet read + LLM pass + team-channel post over the same clients — redundant. ⚠️ THAT DELEGATION IS NOT LIVE TODAY (recorded 2026-09-07): 'Stellar Grant — Client Sync' is ITSELF seeded `status:\"draft\"` — the Stellar grant workspace is not currently operated — so while both stay draft the daily client-comms read happens NOWHERE. This is still the right call (nobody is doing the work), but the redundancy argument above only becomes true again once Client Sync is activated; if THIS automation is ever activated, the note over there must be revisited too. So this daily automation stays draft; the capability and its on-demand 'Client Comms Report' playbook ('catch me up on this client') remain fully intact and ACTIVE for portable, message-first installs that do NOT run the Stellar grant workspace. Do NOT delete this file from CAPABILITY_FILES (prune cascade would strand installed containers) — the quieting is a status flag, not a removal.",
+        "flowDefinition": {
+          "nodes": [
+            {
+              "id": "trigger",
+              "type": "trigger",
+              "position": {
+                "x": 0,
+                "y": 0
+              },
+              "data": {
+                "triggerType": "cron",
+                "label": "Daily at 08:00",
+                "config": {
+                  "expression": "0 8 * * *"
+                }
+              }
+            },
+            {
+              "id": "list-clients",
+              "type": "query",
+              "position": {
+                "x": 0,
+                "y": 120
+              },
+              "data": {
+                "label": "List client companies",
+                "profileSlug": "company",
+                "filter": "",
+                "limit": 100,
+                "_filterNote": "v1 loops ALL companies; only those with a bound client-comms channel AND real signal produce a post (the read + hasSignal switch make it self-limiting). To restrict up-front, set `filter` to a JSON object of property equalities."
+              }
+            },
+            {
+              "id": "client-loop",
+              "type": "loop",
+              "position": {
+                "x": 0,
+                "y": 240
+              },
+              "data": {
+                "label": "For each client",
+                "iteratorExpression": "steps.list-clients.output.entities",
+                "itemVariable": "client"
+              }
+            },
+            {
+              "id": "read-comms",
+              "type": "messages_query",
+              "position": {
+                "x": 0,
+                "y": 360
+              },
+              "data": {
+                "label": "Read the client's comms channel",
+                "subjectEntityId": "{{loop.item.id}}",
+                "limit": 40,
+                "errorHandling": {
+                  "continueOnError": true
+                }
+              }
+            },
+            {
+              "id": "extract",
+              "type": "command",
+              "position": {
+                "x": 0,
+                "y": 480
+              },
+              "data": {
+                "label": "Extract the real signal → report",
+                "commandTitle": "Digest a client's recent comms into a team report",
+                "inputMapping": {
+                  "messages": "{{steps.read-comms.output.messages}}",
+                  "clientName": "{{loop.item.title}}"
+                },
+                "promptOverride": "You are digesting a client's recent communications into a concise report for the INTERNAL team channel, following the client-comms-report methodology. The client is {{loop.item.title}}. Their recent messages are provided as input (chronological).\n\nExtract ONLY real signal: status changes, decisions, deals/opportunities, competitor mentions, new leads/contacts, risks/blockers, deadlines/commitments. Distinguish the client's people from our team. Be skimmable — lead with what matters, group by theme, omit noise.\n\nRespond with STRICT JSON and nothing else: { \"hasSignal\": \"true\" or \"false\" (a STRING, not a boolean), \"report\": \"<a short markdown report for the team when hasSignal is 'true'; empty string when 'false'>\" }. Set hasSignal to \"false\" when there is no notable activity (e.g. no messages, or only chatter).",
+                "errorHandling": {
+                  "continueOnError": true
+                }
+              }
+            },
+            {
+              "id": "gate",
+              "type": "condition",
+              "position": {
+                "x": 0,
+                "y": 600
+              },
+              "data": {
+                "label": "Only post when there's real signal",
+                "expression": "{{steps.extract.output.hasSignal}}"
+              }
+            },
+            {
+              "id": "resolve-team",
+              "type": "capability",
+              "position": {
+                "x": 0,
+                "y": 720
+              },
+              "data": {
+                "label": "Resolve the client's TEAM channel (FIREWALL: never the client channel)",
+                "verbId": "channel.resolve",
+                "inputMapping": {
+                  "contextObjectType": "entity",
+                  "contextObjectId": "{{loop.item.id}}",
+                  "branchPurpose": "team"
+                },
+                "errorHandling": {
+                  "continueOnError": true
+                }
+              }
+            },
+            {
+              "id": "post-report",
+              "type": "output",
+              "position": {
+                "x": 0,
+                "y": 840
+              },
+              "data": {
+                "label": "Post the report to the TEAM channel (FIREWALL: never the client channel)",
+                "outputType": "channel_message",
+                "config": {
+                  "channelId": "{{steps.resolve-team.output.channelId}}",
+                  "content": "{{steps.extract.output.report}}",
+                  "metadata": {
+                    "automationMessage": true,
+                    "kind": "client-comms-report"
+                  }
+                },
+                "errorHandling": {
+                  "continueOnError": true
+                }
+              }
+            }
+          ],
+          "edges": [
+            {
+              "id": "e1",
+              "source": "trigger",
+              "target": "list-clients"
+            },
+            {
+              "id": "e2",
+              "source": "list-clients",
+              "target": "client-loop"
+            },
+            {
+              "id": "e-loop",
+              "source": "client-loop",
+              "target": "read-comms"
+            },
+            {
+              "id": "e3",
+              "source": "read-comms",
+              "target": "extract"
+            },
+            {
+              "id": "e4",
+              "source": "extract",
+              "target": "gate"
+            },
+            {
+              "id": "e5",
+              "source": "gate",
+              "target": "resolve-team",
+              "sourceHandle": "yes"
+            },
+            {
+              "id": "e6",
+              "source": "resolve-team",
+              "target": "post-report"
+            }
+          ]
+        }
+      }
+    ]
+  },
+  "dependencies": []
+}

package/capabilities/content-idea-to-production.capability.json

@@ -0,0 +1,29 @@
+{
+  "apiVersion": "synap/v1",
+  "kind": "capability",
+  "meta": {
+    "slug": "content-idea-to-production",
+    "name": "Content Idea → Production",
+    "description": "Retired: this capability no longer adds anything. Produce Content and Plan Next Content now ship with the Content OS workspace template; install Content OS to get them. Spaces that already have these playbooks keep them.",
+    "tags": [
+      "capability",
+      "content",
+      "proactive"
+    ],
+    "isPublic": true,
+    "syncByDefault": false
+  },
+  "spec": {
+    "key": "content-idea-to-production",
+    "name": "Content Idea → Production",
+    "description": "Retired: this capability no longer adds anything. Produce Content and Plan Next Content ship with the Content OS workspace template; install Content OS to get them. Spaces that already have these playbooks keep them.",
+    "params": [],
+    "vault": [],
+    "tools": [],
+    "skills": [],
+    "provides": [],
+    "playbooks": [],
+    "automations": []
+  },
+  "dependencies": []
+}