@firatcand/roster 0.1.0

package/skills/sdr/SKILL.md

@@ -0,0 +1,147 @@
+---
+name: sdr
+description: "Cold outreach agent for a project. Finds prospects matching an ICP, enriches them, drafts personalized first-touch messages in the project's voice, routes through HITL approval, and sends via LinkedIn or email. Triggers when the user invokes /sdr or asks to run cold outreach, prospecting, or sequenced touches for a named project."
+version: "0.1.0"
+trigger_conditions:
+  - "User invokes the /sdr slash command (e.g., /sdr run cold-outreach for _demo)"
+  - "User asks to run cold outreach, prospecting, or first-touch messages against a named project"
+  - "User says 'send cold outreach to these prospects' or names an ICP + project pair"
+  - "Cron or /schedule fires an SDR plan against a project"
+---
+
+# SDR
+
+## Purpose
+
+The SDR (sales development) agent runs cold outreach for a project. Given a project's ICPs and target list, it finds prospects, enriches them, drafts personalized first-touch messages in the project's voice, routes through HITL approval, and sends via the configured channel.
+
+This is a global agent. Logic, agent-scoped tools, and global lessons live here. Per-project instances live under `projects/<project>/`. Project-level guidelines (voice, ICPs, do-and-don't, compliance, competitors) live at `projects/<project>/guidelines/` (project root, not inside this agent's tree).
+
+## Inputs
+
+The orchestrator (slash command or natural-language invocation) expects:
+
+- `plan`: name of a plan in `gtm/sdr/plans/` (e.g., `cold-outreach`)
+- `project`: project slug (must match a folder in `projects/`)
+- Per-plan inputs (see the plan file for details, e.g., `count`, `prospects`, `channel`)
+
+Read at runtime:
+
+- `agent.md` (this file)
+- `gtm/sdr/plans/<plan>.yaml` — workflow recipe
+- `gtm/sdr/projects/<project>/config/default.yaml` — params and tool bindings
+- `projects/<project>/CLAUDE.md` — project session context
+- `projects/<project>/guidelines/voice.md` — voice
+- `projects/<project>/guidelines/icps/*.md` — all personas
+- `projects/<project>/guidelines/do-and-dont.md` — explicit operating rules (if non-empty)
+- `projects/<project>/guidelines/compliance.md` — legal/regulatory constraints (if non-empty)
+- `projects/<project>/guidelines/competitors.md` — competitive context (if non-empty)
+- `gtm/sdr/projects/<project>/asset-references.md` — which assets this agent uses
+- `gtm/sdr/projects/<project>/playbook/*.md` — project-scoped lessons
+- `gtm/sdr/playbook/*.md` — global lessons
+- Recent ~10 runs in `gtm/sdr/projects/<project>/log/runs/` to avoid duplicate outreach
+
+## Plans
+
+This agent runs via named plans in `gtm/sdr/plans/`. Available plans:
+
+- `cold-outreach` — Cold outreach to hiring managers via LinkedIn (primary) with email fallback. Originally the only workflow this agent ran.
+
+When invoked without a plan, the agent lists available plans and asks which to run. To invoke a plan: use the `/sdr` slash command (e.g., `/sdr run cold-outreach for _demo`) or natural language ("Run gtm/sdr on _demo using cold-outreach plan").
+
+## Subagents
+
+- `prospector.md` — finds prospects matching criteria. Read-only against external data sources.
+- `enricher.md` — fills missing fields on existing prospects.
+- `writer.md` — drafts outreach copy in project voice. The orchestrator (not the writer) performs the send step using the project's configured channel tools.
+- `critic.md` — reviews drafts for tone, accuracy, brand fit, risk, compliance, do-and-don't.
+
+## Tools and bindings
+
+Per-project tool bindings expected by this agent. Chief-of-staff prompts for these when scaffolding a new agent-instance. Values land in `gtm/sdr/projects/<project>/config/default.yaml` under a `tools:` key.
+
+`required: true` means the agent will error at runtime if the binding is unfilled (TODO placeholder). `required: false` means the agent uses the binding when present and skips the related capability when absent.
+
+```yaml
+gmail:
+  send_as:
+    required: true
+    description: "Email alias to send from (e.g., you@example.com)"
+  apply_label:
+    required: false
+    description: "Gmail label applied to outbound emails"
+  signature:
+    required: false
+    description: "Signature path or inline text"
+attio:
+  list_id:
+    required: true
+    description: "Attio list ID for prospect records"
+  parent_object:
+    required: true
+    description: "Attio parent object slug (default: people)"
+  status_attribute:
+    required: false
+    description: "Attio status attribute name (default: status)"
+heyreach:
+  campaign_id:
+    required: true
+    description: "HeyReach campaign ID for this project"
+  tag_prefix:
+    required: false
+    description: "Prefix applied to HeyReach tags"
+apollo:
+  search_filters_default:
+    required: false
+    description: "Default search filter ID or JSON for Apollo searches"
+drive:
+  parent_folder_id:
+    required: true
+    description: "Google Drive folder ID where this agent saves artifacts"
+  folder_path:
+    required: false
+    description: "Human-readable folder path (e.g., gtm/_demo/assets) — documentation only"
+```
+
+Tools available via MCP (see `gtm/sdr/.mcp.json` and the universal `.mcp.json`):
+
+- `Apollo.io` — prospect search and enrichment
+- `HeyReach` — LinkedIn outreach send + status
+- `Attio` — CRM upsert and status update
+- `Gmail` — email sends
+- `Slack` — HITL routing when async (universal)
+- Web search — for prospect signal gathering when enrichment APIs lack info
+
+If any required tool is unavailable at runtime, surface the gap before proceeding.
+
+## Outputs
+
+Run file at `gtm/sdr/projects/<project>/log/runs/<YYYY-MM>/<YYYY-MM-DD-HHMM>.md`. See `conventions.md` § "Run file format". Per-plan output schemas are declared in the plan's `outputs:` block.
+
+## Approval
+
+`approval_channel: auto` — in-session if interactive caller, Slack `#gtm` if cron-triggered. TTL: 24h. After TTL, drafts marked `expired` and not sent.
+
+Per-run config can override:
+- `approval_channel: slack` — always async
+- `approval_channel: session` — always sync (fails if no session)
+
+## Lessons protocol
+
+Log to the run's `## Candidate lessons` section:
+
+- Subject lines / opening hooks that converted vs didn't
+- Voice-fit issues the critic flagged
+- ICP-scoring outcomes that surprised you
+- Channel performance differences
+- Timing patterns
+- Compliance edge cases
+
+The dreamer reads these on its next pass. Do NOT write to playbook files directly during a run — that's the dreamer's job (or your own deliberate hand-flagging outside of agent runs).
+
+## Failure modes
+
+- **Required guideline missing or empty**: abort, request setup
+- **Config invalid or required tool binding is TODO**: abort with schema error
+- **Tool unavailable**: abort, surface which tool and that it should be in this agent's `.mcp.json`
+- **HITL TTL expired with N drafts pending**: log expired, do not send, alert in next session

package/templates/CLAUDE.project.template.md

@@ -0,0 +1,45 @@
+# {{PROJECT_NAME}} — Agent-Team Workspace
+
+This workspace was scaffolded by `roster init`. It hosts a structured multi-agent team —
+function-level experts and role-level agents — working on **{{PROJECT_NAME}}**.
+
+## Path discovery
+
+Claude Code's `.claude/` discovery walks UP from your CWD, merging settings from each
+parent directory. Agent-scoped config lives at `<function>/<agent>/.claude/`; universal
+config at the workspace root.
+
+## Layout
+
+- `chief-of-staff/` — repo maintenance agent (CRUD on projects, agents, functions)
+- `dreamer/` — reflection agent; promotes lessons from runs to playbooks
+- `projects/_demo/` — placeholder project; copy + rename for real work
+- `gtm/`, `product/`, `design/`, `ops/` — function-level homes
+
+Each `<function>/<agent>/agent.md` is the contract that defines that agent's inputs,
+steps, tools, and outputs. Subagents live in `<function>/<agent>/subagents/`. Per-project
+runs and feedback land under `<function>/<agent>/projects/<project>/log/`.
+
+## Running agents
+
+Workflows are slash-command driven (`/sdr`, `/graphic-designer`, …) once their skills are
+installed via `roster install`. Each command loads its agent's `agent.md` and executes a
+named plan against a named project, writing a run log on completion.
+
+## Conventions
+
+See `conventions.md` for the full reference: file naming, lesson schema, run-log
+format, project structure. When the convention isn't clear, ask before guessing.
+
+## What you should NOT do
+
+- Modify agent logic during a run — that's a separate, deliberate task.
+- Call agents across projects. An agent on Project A cannot invoke a different project's
+  instance of itself.
+- Invent tools, connectors, or capabilities. If something isn't available, say so.
+- Write secrets, API keys, or credentials to any file under version control.
+
+## When in doubt
+
+Read `conventions.md`. This workspace is shared with collaborators and future-you;
+an inconsistent convention is worse than a missing one.

package/templates/CONTEXT.template.md

@@ -0,0 +1,51 @@
+# {{PROJECT_NAME}} — Project Context
+
+This is the canonical project context for **{{PROJECT_NAME}}**. Both `CLAUDE.md`
+and `AGENTS.md` are symlinks (POSIX) or copies (Windows) pointing here; every new
+session loads this file automatically.
+
+<!-- roster:managed:start orchestrator -->
+## Orchestrator directive
+
+On every new conversation in this workspace — including after `/clear` — invoke the
+`roster-orchestrator` skill immediately before doing anything else:
+
+> **You are operating inside a roster-managed workspace.** At the start of every
+> conversation, activate the `roster-orchestrator` skill. The skill will inspect the
+> pending queue, surface any HITL items, and prepare the session context. Do not
+> proceed with user requests until the orchestrator bootstrap completes.
+
+This directive applies to both scheduled fires and interactive chat sessions.
+<!-- roster:managed:end orchestrator -->
+
+<!-- roster:user:start workspace -->
+## Workspace: {{PROJECT_NAME}}
+
+[Replace this section with project-specific context: domain, goals, constraints.]
+<!-- roster:user:end workspace -->
+
+<!-- roster:managed:start agent-layout -->
+## Agent team layout
+
+- `chief-of-staff/` — repo maintenance and project wiring
+- `dreamer/` — reflection; promotes lessons to playbooks
+- `gtm/sdr/` — outbound sales development
+- `<function>/<agent>/agent.md` — contract for each agent (inputs, steps, tools, outputs)
+
+## Key files
+
+- `conventions.md` — naming, schema, run-log format
+- `roster/<function>/pending/` — HITL queue (read on session start)
+- `roster/<function>/schedules.yaml` — schedule registry mirror
+
+## What you must NOT do
+
+- Modify agent contracts during a run (that is a deliberate, separate task).
+- Invoke agents across project boundaries.
+- Invent tools, MCP servers, or capabilities that are not installed.
+- Write secrets or credentials to any tracked file.
+
+## When in doubt
+
+Read `conventions.md`. An inconsistent convention is worse than a missing one.
+<!-- roster:managed:end agent-layout -->

package/templates/env.example

@@ -0,0 +1,25 @@
+# roster workspace environment
+#
+# Copy this file to `.env` and fill in real values. Never commit `.env`.
+# Each agent's docs name the variables it expects; uncomment what you use.
+
+# --- Linear (MCP-driven workflows) ---
+# LINEAR_API_KEY=lin_api_xxx
+# LINEAR_TEAM_ID=xxx
+# LINEAR_PROJECT_ID=xxx
+
+# --- Slack HITL routing ---
+# SLACK_BOT_TOKEN=xoxb-xxx
+# SLACK_HITL_CHANNEL_GTM=gtm-hitl
+# SLACK_HITL_CHANNEL_PRODUCT=product-hitl
+# SLACK_HITL_CHANNEL_DESIGN=design-hitl
+# SLACK_HITL_CHANNEL_OPS=ops-hitl
+# SLACK_HITL_CHANNEL_ADMIN=admin-hitl
+
+# --- LLM providers (for cron-driven workflows that run outside Claude Code) ---
+# OPENAI_API_KEY=sk-xxx
+# ANTHROPIC_API_KEY=sk-ant-xxx
+
+# --- Optional integrations ---
+# NOTION_API_KEY=secret_xxx
+# GITHUB_TOKEN=ghp_xxx

package/templates/gitignore-defaults.txt

@@ -0,0 +1,28 @@
+# Roster defaults — managed by `roster init`; do not edit between markers
+
+# Secrets and credentials
+.env
+.env.local
+*.pem
+*.key
+
+# Editor / OS
+.DS_Store
+.idea/
+.vscode/
+*.swp
+*~
+
+# Node
+node_modules/
+
+# Operation logs and run/feedback bodies — preserve directories with .gitkeep
+*/log/runs/2*/
+*/log/feedback/2*/
+
+# Temp / scratch
+**/scratch/
+**/tmp/
+**/.cache/
+
+# End Roster defaults

package/templates/scaffold/.config/functions.yaml

@@ -0,0 +1,22 @@
+# Functions registry — single source of truth for function categories.
+# Edit only via chief-of-staff `create-function` operation when possible.
+# Manual edits OK; keep slugs lowercase kebab-case, alphanumeric + hyphens.
+#
+# Fields:
+#   slug         — folder name under repo root (must match an existing folder)
+#   description  — one-line summary, used in stub READMEs and audit reports
+#   has_expert   — true if this function has an EXPERT.md the audit should expect
+
+functions:
+  - slug: gtm
+    description: Go-to-market — outreach, lead gen, sales, marketing
+    has_expert: true
+  - slug: product
+    description: Product work — research, specs, roadmap, user feedback
+    has_expert: true
+  - slug: design
+    description: Design — brand, visual, content production assets
+    has_expert: true
+  - slug: ops
+    description: Operations — internal automations, reporting, admin
+    has_expert: true

package/templates/scaffold/chief-of-staff/README.md

@@ -0,0 +1,86 @@
+# Chief of Staff Agent
+
+Operates on the agent-team repo itself. Scaffolds empty structure for new projects/agents, archives, renames, audits.
+
+This agent is the empty-structure scaffolder. It produces folders and template files in their default placeholder state. Filling content (voice, ICPs, brand) is a separate concern handled outside this agent.
+
+## Why this is one agent at top level
+
+Cross-cutting infrastructure — operates on every function and every project, doesn't have its own per-project instances. Lives at the same level as `dreamer/` for the same reason.
+
+## Files
+
+- `agent.md` — orchestrator contract: operations, steps, confirmation gates
+- `playbook/` — global lessons about scaffolding (one file per lesson)
+- `logs/` — operation logs and audit reports
+
+## Invocation
+
+From repo root, in an interactive Claude Code session:
+
+```bash
+cd /path/to/agent-team
+claude
+```
+
+Then ask the agent to perform an operation:
+
+- "Create a new project called myproject with gtm/sdr and gtm/twitter-agent"
+- "Archive the test-scaffold project"
+- "Audit Acme Corp"
+- "Add content-agent to _demo"
+- "Rename project oldname to newname"
+- "Audit the whole repo"
+
+The agent will:
+1. Confirm cwd is repo root
+2. Parse intent, restate parameters back to you
+3. Show a plan before destructive ops, ask "proceed?"
+4. Execute by invoking the appropriate `scripts/*.sh`
+5. Report what changed
+6. Never auto-commit (you commit manually)
+
+## Operations supported
+
+- `create-project`, `create-agent`, `add-agent-to-project`
+- `remove-agent-from-project`, `archive-project`, `unarchive-project`, `rename-project`
+- `audit-project`, `audit-agent`, `audit-repo`
+
+See `agent.md` for the full contract and confirmation rules.
+
+## Where things land
+
+| Operation | Backing script | Result location |
+|---|---|---|
+| create-project | `scripts/new-project.sh` | `projects/<project>/` + optional instances |
+| create-agent | `scripts/new-agent.sh` | `<function>/<agent>/` |
+| add-agent-to-project | `scripts/new-agent-instance.sh` | `<function>/<agent>/projects/<project>/` |
+| remove-agent-from-project | `scripts/remove-agent-from-project.sh` | moved to `_archive/<function>/<agent>/projects/<project>-<date>/` |
+| archive-project | `scripts/archive-project.sh` | moved to `_archive/projects/<project>-<date>/` (+ all instances) |
+| unarchive-project | `scripts/unarchive-project.sh` | restored from `_archive/` |
+| rename-project | `scripts/rename-project.sh` | folders + content updates everywhere |
+| audit-project | `scripts/audit-project.sh` | report at `chief-of-staff/logs/<YYYY-MM>/audit-*.md` |
+| audit-agent | `scripts/audit-agent.sh` | report at `chief-of-staff/logs/<YYYY-MM>/audit-*.md` |
+| audit-repo | `scripts/audit-repo.sh` | report at `chief-of-staff/logs/<YYYY-MM>/audit-repo-*.md` |
+
+Operation logs (mutations): `chief-of-staff/logs/<YYYY-MM>/operations-<YYYY-MM-DD>.md` (append-only).
+
+## Why no subagents
+
+The work is mostly script invocation and structural validation. Subagents would add complexity without adding capability.
+
+## Why this never auto-commits
+
+You manually sync to GitHub. The chief-of-staff agent surfaces what changed; you decide what's worth committing.
+
+## Direct script use
+
+All operations have backing scripts that work standalone:
+
+```bash
+bash scripts/new-project.sh myproject
+bash scripts/archive-project.sh test-scaffold "no longer needed"
+bash scripts/audit-project.sh _demo
+```
+
+The chief-of-staff agent wraps these with intent-parsing, validation, confirmations, and orchestration (e.g., create-project + create-instances in one operation). Scripts are the source of truth for what each operation actually does.

package/templates/scaffold/chief-of-staff/agent.md

@@ -0,0 +1,122 @@
+# Chief of Staff Agent
+
+## Purpose
+
+Operate on the agent-team repo itself. Scaffold empty structure for new projects/agents, archive completed projects, rename, audit completeness. This agent does not run business workflows — it manages the structure those workflows live in.
+
+In **stub mode** (`create-agent`/`create-project` invoked headlessly or with `mode=stub`), this agent is an empty-structure scaffolder: it creates folders and template files in their default placeholder state — `voice.md` will say `<3 adjectives describing...>`, ICPs are `_persona-template.md`, agent purpose reads `<one paragraph...>`, and so on. In **guided mode** (the default when invoked interactively), `create-agent` runs the Guided Agent Creation dialogue defined in `skills/chief-of-staff/SKILL.md` and produces an `agent.md` with purpose, inputs, steps, tools, and subagents filled in from the dialogue answers — see that contract for the full prompt sequence. Filling project guidelines with real content remains a separate concern handled by function-level experts (a content agent, an expert, or templated generation from existing brand assets).
+
+When in doubt, defer to `conventions.md` for the canonical structure schema and to the `_template/` directories for the canonical scaffold contents. This agent does not duplicate those — it tells you how to USE them.
+
+## Working directory
+
+This agent operates from repo root only. If invoked from elsewhere, abort with: "Run chief-of-staff from agent-team repo root."
+
+## Inputs
+
+The orchestrator (slash command or natural-language invocation) expects:
+
+- `plan`: name of a plan in `chief-of-staff/plans/` (e.g., `archive-project`, `audit-repo`)
+- Per-plan inputs (positional or named — see each plan's `inputs:` block)
+
+Inputs may arrive in natural language. Parse intent, confirm parameters, then run the operation. Examples:
+
+- "Create a new project called myproject with sdr and twitter-agent" → `create-project project=myproject agents=[gtm/sdr, gtm/twitter-agent]`
+- "Archive test-scaffold" → `archive-project project=test-scaffold`
+- "Audit Acme Corp" → `audit-project project=_demo`
+- "Add content-agent to _demo" → `add-agent-to-project project=_demo function=gtm agent=content-agent`
+
+Read at runtime:
+
+- `agent.md` (this file)
+- `chief-of-staff/plans/<plan>.yaml` — the operation recipe
+- `conventions.md` — canonical structure schema
+- `projects/_template/` — project template
+- `<function>/<agent>/projects/_template/` — agent instance template (for the relevant agent)
+- `chief-of-staff/playbook/` — global lessons about scaffolding (naming conventions, common mistakes)
+
+## Plans
+
+This agent runs via plans in `chief-of-staff/plans/`. Each plan wraps a backing script in `scripts/`. Available plans:
+
+| Plan | Description | Destructive? |
+|---|---|---|
+| `create-project` | Create a new project, optionally with agent instances | no |
+| `create-agent` | Create a new global agent under a function | no |
+| `create-function` | Add a new function category to the registry | no |
+| `add-agent-to-project` | Add an agent instance to an existing project | no |
+| `remove-agent-from-project` | Archive an agent instance (preserved in _archive) | yes |
+| `archive-project` | Archive a project + all its instances | yes |
+| `unarchive-project` | Restore an archived project | no |
+| `rename-project` | Rename a project everywhere it appears | yes |
+| `audit-project` | Validate a project's completeness; reports issues with suggested fixes | no |
+| `audit-agent` | Validate an agent's structure and instances | no |
+| `audit-repo` | Full repo audit aggregating project + agent reports | no |
+
+Invoke a plan via the slash command:
+
+```
+/chief-of-staff create-project myproject with gtm/sdr
+/chief-of-staff archive-project test-scaffold
+/chief-of-staff audit-repo
+```
+
+Or in natural language:
+
+```
+"Run chief-of-staff archive-project for test-scaffold"
+```
+
+When invoked without a plan, lists available plans and asks which to run.
+
+Destructive plans (`archive-project`, `unarchive-project`, `remove-agent-from-project`, `rename-project`) always show the planned changes and ask "proceed?" before executing. The cross-link prompts in `create-project` (which agents to instance) and `create-agent` (which projects to instance into) are also session-only — they cannot be answered headlessly. Power users skip the prompt by passing `agents` or `add-to-projects` inline.
+
+## Common preamble for every plan
+
+1. **Confirm cwd is repo root.** Check for presence of `CLAUDE.md`, `conventions.md`, `gtm/`, `projects/`. If not all present, abort.
+2. **Parse the user's request.** Extract plan name + parameters. If ambiguous, ask before proceeding.
+3. **Show the plan.** For destructive plans, summarize what will happen and ask "proceed?". Always include the list of paths that will be created, modified, or moved.
+4. **Execute by invoking the plan's backing script.** All operations are backed by a script in `scripts/`. The script does the work; this agent orchestrates and parses output.
+5. **Report.** Summarize what changed (paths created/modified/moved). Note anything skipped or warnings.
+6. **Never auto-commit to git.** Leave commits for the user.
+
+## Subagents
+
+None. Chief-of-staff is a single orchestrator; the work is mostly script invocation and structural validation, not deep reasoning.
+
+## Tools and bindings
+
+This agent uses bash for script invocation. All plans are backed by scripts in `scripts/`. No external MCPs required, no per-project tool bindings.
+
+If a script is missing or fails, surface the failure clearly. Don't try to do the work directly — that's two sources of truth and they will drift.
+
+## Outputs
+
+For mutation plans: a summary printed to chat (paths created, moved, modified). The corresponding script also appends to `chief-of-staff/logs/<YYYY-MM>/operations-<YYYY-MM-DD>.md` (one log file per day, append-only).
+
+For audit plans: the report file at `chief-of-staff/logs/<YYYY-MM>/audit-...-<YYYY-MM-DD-HHMM>.md`, plus a condensed stdout summary.
+
+Per-plan output schemas are declared in each plan's `outputs:` block.
+
+## Approval
+
+`approval_channel: session` — this agent is invoked interactively, never via cron. All confirmations happen in-session.
+
+Confirmation gates are MANDATORY for: `archive-project`, `unarchive-project`, `rename-project`, `remove-agent-from-project`. They display the plan and ask "proceed?" before executing.
+
+## Lessons protocol
+
+When you observe a pattern across operations — e.g., "users frequently forget to run create-agent before create-project for that agent's instance" — log it as a candidate lesson in the operation's log entry, in a `## Candidate lessons` section. The dreamer picks it up next pass and may write a `chief-of-staff/playbook/L-...md` lesson.
+
+Do NOT write to `chief-of-staff/playbook/` directly during operations. The user may write a lesson by hand with `source: human`.
+
+## Failure modes
+
+- **Cwd not repo root**: abort with clear message
+- **Invalid slug or function name**: abort with example of valid format
+- **Collision (target already exists)**: abort, tell user the existing path
+- **Missing dependency (e.g., agent doesn't exist for create-instance)**: abort, suggest the prerequisite plan
+- **Script fails**: surface the script's stderr; don't attempt to recover by doing the work directly
+- **YAML/JSON parse error in audit**: report as failure with line number from the audit script
+- **Confirmation gate denied**: abort cleanly, no changes
+- **Partial failure mid-operation**: scripts handle their own rollback. If a script reports partial state, surface exactly what state the repo is in and what to do next.

package/templates/scaffold/chief-of-staff/plans/add-agent-to-project.yaml

@@ -0,0 +1,45 @@
+plan: add-agent-to-project
+description: |
+  Instance an existing global agent into an existing project. Additive —
+  no confirmation gate. The backing script prompts interactively for tool
+  bindings declared in the agent's ## Tools and bindings section.
+
+inputs:
+  project:
+    required: true
+    description: Project slug (must exist at projects/<slug>/).
+  function:
+    required: true
+    description: Function slug.
+  agent:
+    required: true
+    description: Agent slug (must exist at <function>/<agent>/).
+
+outputs:
+  instance_path: string
+
+steps:
+  - id: validate
+    description: |
+      Confirm projects/${inputs.project}/ exists. Confirm
+      ${inputs.function}/${inputs.agent}/ exists. Confirm instance does not
+      exist at ${inputs.function}/${inputs.agent}/projects/${inputs.project}/.
+
+  - id: execute
+    tool: bash
+    args:
+      command: bash scripts/new-agent-instance.sh ${inputs.project} ${inputs.function} ${inputs.agent}
+    description: |
+      Run the backing script. It will prompt interactively for tool bindings
+      declared in the agent's ## Tools and bindings section. Skip with Enter
+      or "skip" to leave as # TODO: placeholders.
+
+  - id: update_project_claude_md
+    description: |
+      Append a line for the new instance to projects/${inputs.project}/CLAUDE.md
+      under ## Active agent instances. Don't replace existing entries.
+
+  - id: report
+    description: Print the instance path and any TODO bindings the user must fill in.
+
+approval_channel: session

package/templates/scaffold/chief-of-staff/plans/archive-project.yaml

@@ -0,0 +1,51 @@
+plan: archive-project
+description: |
+  Archive a project AND all its agent instances. Use when retiring a project
+  entirely. Preserves run history and project-scoped lessons in _archive/
+  for restoration via unarchive-project.
+
+inputs:
+  project:
+    required: true
+    description: Project slug to archive (must exist at projects/<slug>/).
+  reason:
+    required: false
+    description: Free-text reason recorded in _archive/projects/<slug>-<date>/ARCHIVED.md.
+
+outputs:
+  paths_archived: integer
+  archive_suffix: string
+
+steps:
+  - id: validate
+    description: |
+      Confirm projects/${inputs.project}/ exists. Find all agent instances
+      under <function>/<agent>/projects/${inputs.project}/. Build the list of
+      paths that will move.
+
+  - id: confirmation
+    description: |
+      Show the full list of paths to be moved:
+
+        Will move to _archive/ (with date suffix YYYY-MM-DD; archive script
+        disambiguates with -2, -3 if same-day):
+          projects/${inputs.project}/                                  (project root)
+          <function>/<agent>/projects/${inputs.project}/               (each instance)
+          ...
+
+        Total: 1 project + N instances. Proceed?
+
+      Wait for "proceed", "yes", "y". Abort cleanly if denied.
+    approval: session
+
+  - id: execute
+    tool: bash
+    args:
+      command: bash scripts/archive-project.sh ${inputs.project} ${inputs.reason}
+    description: Move the project and instances to _archive/.
+
+  - id: report
+    description: |
+      Summarize what moved. Print the path to ARCHIVED.md and the operation log.
+
+approval_channel: session

package/templates/scaffold/chief-of-staff/plans/audit-agent.yaml

@@ -0,0 +1,32 @@
+plan: audit-agent
+description: |
+  Validate a global agent's structure and all its instances. Checks required
+  agent.md sections, README, .mcp.json, .claude/settings.json, subagents,
+  playbook, projects/_template/, plans/, slash command, and per-instance
+  config validity.
+
+inputs:
+  function:
+    required: true
+    description: Function slug.
+  agent:
+    required: true
+    description: Agent slug.
+
+outputs:
+  status: string  # pass | warn | fail
+  report_path: string
+
+steps:
+  - id: execute
+    tool: bash
+    args:
+      command: bash scripts/audit-agent.sh ${inputs.function} ${inputs.agent}
+    description: Run the backing audit script.
+
+  - id: report
+    description: |
+      Print the summary. Reference the full report at
+      chief-of-staff/logs/<YYYY-MM>/audit-${inputs.function}-${inputs.agent}-<YYYY-MM-DD-HHMM>.md.
+
+approval_channel: session