Process handoff notes in inbox/ and new CEO requests or ideas in a ceo-of-agents hq. Updates state.md, adds decision cards and action items with namespaced codes, tracks tasks the CEO owns in the optional company/todo.md, opens issues in registered product repos and adds them to the tracker, flags escalations to the holding, deletes processed notes in the same hq commit. Use at session start when inbox/ has notes, or when the CEO brings a new idea, request or finding.
Installs into .claude/skills of the current project.
Sponsors
SSkills DirectorySkills Directory
Know which skills are safe — weekly.
SSkills DirectorySkills Directory
Is that skill safe to install?
Are you the author of Intake?
Add the live security badge to your README. It updates with every re-scan.
[](https://www.skillsdirectory.com/skills/iamgiolaga-intake)
---
name: intake
description: Process handoff notes in inbox/ and new CEO requests or ideas in a ceo-of-agents hq. Updates state.md, adds decision cards and action items with namespaced codes, tracks tasks the CEO owns in the optional company/todo.md, opens issues in registered product repos and adds them to the tracker, flags escalations to the holding, deletes processed notes in the same hq commit. Use at session start when inbox/ has notes, or when the CEO brings a new idea, request or finding.
user-invocable: false
allowed-tools: Read Grep Glob Edit Write Bash(git remote) Bash(git remote -v) Bash(git pull) Bash(git pull --ff-only) Bash(git status:*) Bash(git add:*) Bash(git commit:*) Bash(git rm:*) Bash(ls:*) Bash(wc:*) Bash(date:*) Bash(gh issue list:*) Bash(gh project view:*) Bash(gh project field-list:*)
---
# intake: process handoffs and new requests
Reply to the CEO in the chat language set in `org.yaml` (`language.chat`); write every file in the file language (`language.files`).
Closed org: when `org.status` in `org.yaml` is `closed`, do not frame or route new work. Say that the org is closed and that the CEO can reopen it (`close-org` skill). Leave handoff notes in `inbox/` unprocessed.
Only the chief of staff (CoS) runs this skill. A department agent must not process or delete `inbox/` notes, nor edit `company/state.md` or `company/decision-queue.md`; it leaves a handoff instead.
Formats are fixed: `${CLAUDE_PLUGIN_ROOT}/schemas/state.md`, `${CLAUDE_PLUGIN_ROOT}/schemas/decision-card.md`, `${CLAUDE_PLUGIN_ROOT}/schemas/handoff.md`, and `${CLAUDE_PLUGIN_ROOT}/schemas/todo.md` for the optional CEO todo list.
Every file this skill writes in the hq is written by a `worker` (one tier down, explicit model) from your instructions, and you read the diff; commits, pushes and `gh` writes stay with you.
## Inputs
1. Handoff notes: every file in `inbox/` except `README.md` (`inbox/YYYY-MM-DD-<from>-to-<to>-<slug>.md`, frontmatter `from`, `to`, `date`, `needs_ceo_decision`, `proposed_card` and the optional `initiative`, sections `Ask or finding`, `Done`, `Links`).
2. A new request, idea or finding the CEO states in chat.
## Steps
1. Sync. Run `git remote`. If it prints nothing, skip pull and push and say once: "No remote: pull and push skipped". Otherwise run `git pull`; if it fails, say so in one line and continue with the local copy. Skip this step if the session already synced hq.
2. Orient. Read `org.yaml`, `company/vision.md` and `company/strategy.md` (if present), `company/state.md`, `company/decision-queue.md` and `ls inbox/`. Note the org id, the level and the next codes (`next_action`, `next_decision`; `next_todo` in `company/todo.md` when the request is a CEO task). Search `decisions/` and the queue for duplicates and conflicts with the topic (Grep); also `initiatives/README.md` (if present), but only when the topic may span several sessions or departments or the note names an initiative. If `repos` in `org.yaml` is not empty, also search the open issues of the repo the topic touches and of the issues home, read-only (`gh issue list -R <slug> --state open --search "<words>"`); a match is a duplicate: add the new context as a comment (`gh issue comment -R <slug> <number> --body '<text>'`) instead of opening another issue. If the search fails, say so once and continue without it. If a topic is already decided, say so and cite the record rather than reopening it, unless the new input is a reason to supersede it. If a request does not serve the vision or the current focus, say so in one line, then follow the CEO. If this session has not run the version check yet (an hq generated before 0.7.0 has no such step in its `CLAUDE.md`), use the `hq-version` skill once, check only.
3. For a new CEO request (no note): restate it in one line. Classify it into exactly one primary route:
- Decision: a clear choice is needed, so add a card.
- Action: something only the CEO can do (an exact click, link, signature), so add an A item of kind `{do}`; an approval you then carry out is an A item of kind `{ok}`.
- CEO task: work the CEO will do on their own account and wants tracked (reply to someone, follow up on a review, chase an answer), with nothing the org waits on. Add an Open line to `company/todo.md` with the code `<ORG_ID>-T<next_todo>`, then increment `next_todo` and set `last_updated` (format and lifecycle: `${CLAUDE_PLUGIN_ROOT}/schemas/todo.md`). If the file is missing, create it from `${CLAUDE_PLUGIN_ROOT}/templates/instance/company/todo.md` with `{{DATE}}` set to today. Never put a T item in `company/state.md`. When the CEO says a T item is done, changed or dropped, update the file as the schema's Lifecycle says, pruning Done lines older than 7 days.
- Issue: a concrete piece of work in a registered product repo, with nothing to decide. Only when `repos` in `org.yaml` is not empty; otherwise use another route. See "Issue route" below.
- Department task: delegate with full context (a self-contained brief; the department leaves a handoff at the end). Dispatch a department by its agent name (`agent` in `org.yaml`; for a department without `agent`, in an hq not yet migrated to 0.7.0, its id). Keep it one task unless it must be split:
- split only where a part has a different owner, needs different permissions, can really run in parallel, must wait for another part (a hard prerequisite), or is an independent review;
- write each dependency into the briefs, for example "starts after engineering's PR is open";
- a split never adds an approval and never skips one: an action that needs an OK still needs it in whichever part runs it;
- a review brief stands on its own, without the author's context, and names who receives the verdict.
- Reasoning session: vague or strategic; propose a conversation first and record only what comes out of it.
- Later: does not fit now; park it as a low-urgency item rather than dropping it.
State the route in one short line, then execute. Do not ask for OKs the gate table does not require.
If the work spans several sessions or departments, open an initiative for it with the `initiatives` skill (or use the current one that covers it) and name its folder in every brief. Work that one department finishes in one go needs none.
A department task or a decision about work in a registered repo also gets its issue (see "Issue route"), unless one already exists.
Held work: when you open an issue or a follow-up and do not route it in this turn (cost, priority, capacity), add `- <ORG_ID>-A<n> [urgency] {ok}: start <issue or task>, <who would do it> (since YYYY-MM-DD)` to "Waiting on the CEO" in the same turn and increment `next_action`. The CEO's OK starts it; work already routed and running gets no item.
4. For each handoff note, read it fully, then:
- Update `company/state.md` where facts changed: Products and status, Key numbers (only with source and date; never invent a number), Risks (with owner). Sensitive detail (tax, personal legal, personal finance) stays out of state.md; keep it in the department folder.
- If `needs_ceo_decision: yes`, or the finding needs a CEO choice: add a decision card to `company/decision-queue.md` with the next code `<ORG_ID>-D<next_decision>`, fields `status: open`, `since`, `urgency`, exactly one of `proposed_by: <dept-id|cos>` or `needs analysis by: <dept-id>` (never both), `escalate: no` (company level, purpose product, startup or company; omit the line in a holding, a job or a personal hq), and sections Context, Options (lettered), Recommendation. Increment `next_decision`. Add the matching line to "Open decisions" and to "Waiting on the CEO" (`- <ORG_ID>-D<n> [urgency] {decide}: decide <question>, see decision queue (since YYYY-MM-DD)`).
- If something needs the CEO: add `- <ORG_ID>-A<n> [urgency] {kind}: <exact action: where, what, link> (since YYYY-MM-DD)` to "Waiting on the CEO" and increment `next_action`. The kind is `{ok}` when the CEO only approves and you (or a department) then carry it out, `{do}` when only the CEO can perform it (`${CLAUDE_PLUGIN_ROOT}/schemas/state.md`).
- Codes are namespaced, monotonic and never reused. Never reuse a code of a removed item.
- Remove "Waiting on the CEO" items the note shows are already done.
- If the note names an initiative (`initiative: <slug>` in its frontmatter, or a path under `initiatives/`), update that initiative with the `initiatives` skill (section Update).
5. Escalation (company level, purpose product, startup or company; the `escalate:` line does not exist in a holding, a job or a personal queue): if a decision touches money, personal liability or the portfolio, set `escalate: holding` on the card and append ` [escalate: holding]` to its line in "Open decisions". The holding reads it on its next portfolio brief. Never write to the holding repo. Tell the CEO the card is flagged and that the answer is still recorded here.
6. Finish state.md: set `last_updated` to today (`date +%F`), keep the five H2 sections in order, `- none` for empty ones. Keep each line to the formats in the schema: rewrite a line to the current fact, never append to it, and put the history that matters in `company/log.md`. Then measure what this run touched, before the commit of step 8: the check at write time (`${CLAUDE_PLUGIN_ROOT}/schemas/boot-set.md`, "Check at write time"; Grep and `wc -c`, not the script).
7. Delete each processed note (`git rm` or remove the file) in the same hq commit as the updates. Git history keeps them. Do not delete a note you could not fully process; say why.
8. Commit, in the same turn as the writes above and before you reply. The gate for `hq-commit` is "notice": write one line to the CEO before committing (what, where, content; for example "Committing to hq main: 2 notes processed, ACME-D4 added, state.md updated."), then commit on the current branch with a message like `chore: process inbox (<codes>)` and the attribution lines required by the session. Do not wait for an OK. The commit and the push are one `hq-commit` covered by that line: then push with `git push origin HEAD`, and skip the push when `git remote` is empty.
9. Reply with a short summary in the chat language: notes processed, new codes (A, D and T, with one-line meaning), escalations, and anything blocked or ambiguous. Cite codes, do not paste cards. If nothing was in the inbox and the CEO gave no request, say so in one line.
## Issue route
Skip this section entirely when `repos` in `org.yaml` is `[]` or absent (an `org/2` file). Issue, Project item and field, label and comment writes are free on a repo that is not protected: do them and mention them in one line. Write every GitHub write with one `-R <slug>` right after the subcommand and its text inline in single quotes (a `'` inside is written `'\''`), never with `--body-file` or `-F`: Claude Code asks before each GitHub write, and its prompt then shows the repo and the whole text. That prompt is not a gate's OK and needs no A item.
1. Pick the repo: the registered repo the work touches; if it spans several repos or none in particular, the item with `issues_home: true`.
Protected repo: if that repo has `protected: true` in `repos:` (or matches an owner pattern `owner/*` with `protected: true`, or is not registered at all), every write below needs the CEO's explicit OK first. Do not write: ask one narrow question naming the repo and the writes (for example "May I open the issue <title> in owner/repo?"), or add one A item of kind `{ok}` for them, and put the intended issue text in the reply so nothing is lost. The hq is never protected.
2. Create the issue: `gh issue create -R <slug> --title '<title>' --body '<body>'`. The body states the goal and acceptance criteria. If the work comes from a card or a record, link it: in a private repo (or an issues home that is the hq) write the code (`<ORG_ID>-D<n>`, record `NNNN`); in a repo with `visibility: public` write no internal names, codes or hq content, and put the issue URL in hq instead (the card, the record's Links or `company/state.md`).
3. Tracker (skip when `tracker` is `none` or absent): `gh project item-add <number> --owner <owner> --url <issue url> --format json` returns the item (its `id` is the item id). Then set the status: the project id is the `id` from `gh project view <number> --owner <owner> --format json`; the field id and option ids are the `id` of the status field and of its `options` in `gh project field-list <number> --owner <owner> --format json`; and run `gh project item-edit --id <item id> --project-id <project id> --field-id <status field id> --single-select-option-id <option id>`. Use the field named in `tracker.status_field` and the option that matches the work (for example a to-do status for new work).
4. If `gh` fails (not installed, not signed in, no `project` scope), do not retry in a loop: say so, add an A item of kind `{do}` with the exact command for the CEO (for example `gh auth refresh -s project`) unless one is already open, and record the intended issue as a line in the reply so nothing is lost.
5. Record the issue URL in hq (the card, `company/state.md`, the initiative's status or the note it came from) and commit it in this same turn (step 8), then report the URL and the status set. Never leave an issue you opened unrecorded until later in the session.
## Rules
- hq is the single source of truth: whatever the CEO says that matters ends up written down before you reply.
- Same turn: the hq update and its commit happen in the same turn as every outward write (issue, comment, pull request) and every decision the CEO takes in chat. Never defer recording to the end of the session or of a batch, also when the CEO reports several things in a row: record each in the turn it arrives. Batching stays allowed for routing work to a department, never for recording it.
- One card = one D code, shown in both `decision-queue.md` and `state.md`.
- Do not record a decision the CEO has not taken. Intake adds questions, not answers; answers go through the `record-decision` skill.
- Keep recommendations honest: the card names who proposes (`proposed_by:`), or says `needs analysis by: <dept-id>` instead. In `state.md` the matching "Open decisions" line reads `proposed by <dept-id|cos>` or `needs analysis by <dept-id>`.
- If a note is malformed (missing frontmatter), process what is clear and list what you assumed.