join

Category: Tools & Productivity | Uploader: agentweave | Downloads: 0 | Version: v1.0（Latest）
Join the Cortex agent team — reads agent config from team directory, generates .cortex.md protocol, updates CLAUDE.local.md. Idempotent — safe to re-run as a sync.
Changelog: Source: GitHub https://github.com/agentweave/cortex
Directory Structure

Current level: tree/main/skills/join/
📄 SKILL.md 9.0 KB
SKILL.md

---
name: join
description: Join the Cortex agent team — reads agent config from team directory, generates .cortex.md protocol, updates CLAUDE.local.md. Idempotent — safe to re-run as a sync.
user_invocable: true
argument-hint: <agent-name>
---

# /join — Join the Cortex Agent Team

Onboard this agent to Cortex by reading its config from the team directory and generating the local protocol file.

## Arguments

`<agent-name>` — the agent's name (e.g., "Billing Dev", "Chief of Staff"). If not provided, ask: "What is this agent's name in Cortex?"

## Steps

### 1. Read config

Read `~/.cortex/config.yaml` to get `team_dir`, `heartbeat_minutes`, `daily_briefing`, and `daily_review`.

If config doesn't exist, stop and respond:
> "Cortex is not set up yet. Run `/setup` first."

### 2. Resolve name and slug

Use the provided `<agent-name>`.

Derive the slug: lowercase, replace spaces with hyphens, strip any characters that are not alphanumeric or hyphens.

### 3. Read agent note

Read `<team_dir>/agents/<slug>.md`.

If the file doesn't exist, stop and respond:
> "Agent `<name>` is not registered in Cortex. Run `/register <name>` to create the agent note first."

### 4. Extract config from agent note

From the frontmatter and body, extract:
- `name` — from frontmatter
- `slug` — derived from name
- `project` — from frontmatter (the project directory path)
- `projects` — from ## Projects section (list of project slugs)
- `role` — from ## Role section (first line after heading)

### 5. Determine if this is a re-run

Check if `.cortex.md` exists in the current working directory. If it does, this is a sync (re-run).

### 6. Generate .cortex.md

Write `.cortex.md` in the current working directory.

If the agent slug is `chief-of-staff`, generate the **coordinator .cortex.md** (see Section A below).

Otherwise, generate the **worker .cortex.md** (see Section B below).

Replace all `{placeholder}` values with the actual extracted values.

### 7. Update CLAUDE.local.md

Read the CLAUDE.local.md in the current working directory.

If it exists and does NOT already contain the text "## Cortex":
- Append this section at the very end:

```
## Cortex
On session start, run /join <name> to sync with Cortex. See .cortex.md for full protocol.
```

If CLAUDE.local.md doesn't exist, create it with just that content.

If CLAUDE.local.md already contains "## Cortex", do nothing (already configured).

### 8. Start heartbeat

Use CronCreate to start the heartbeat automatically. The cron fires every `{heartbeat_minutes}` minutes.

**For worker agents** (slug is NOT `chief-of-staff`), create a cron with:
- cron: `*/{heartbeat_minutes} * * * *`
- prompt:

```
Heartbeat: Poll for new work per .cortex.md protocol.

1. Read agent note at {team_dir}/agents/{slug}.md
2. Check for new tasks in linked project work queues — read each project note listed in ## Projects and check its ## Work Queue for tasks with status "ready"
3. If any tasks have status "ready":
   - Mark them "in-progress" (edit the file)
   - Do the work
   - Mark them "done" and append a summary
   - Update agent note Session Log
4. Update last-heartbeat in agent note frontmatter to current ISO timestamp (YYYY-MM-DDTHH:MM)
5. If no new work, just update last-heartbeat (silent heartbeat)
```

**For chief of staff** (slug IS `chief-of-staff`), create a cron with:
- cron: `*/{heartbeat_minutes} * * * *`
- prompt:

```
Heartbeat: Coordinator poll per .cortex.md protocol.

1. Check for user messages (via Telegram if configured)
2. Read all agent notes in {team_dir}/agents/ — check last-heartbeat for staleness (> 30 min = likely down), check ## Session Log for blockers
3. Read all project notes in {team_dir}/projects/ — check ## Work Queue for status updates
4. Flag any issues to the user
5. Update last-heartbeat in {team_dir}/agents/chief-of-staff.md frontmatter to current ISO timestamp (YYYY-MM-DDTHH:MM)
```

### 9. Confirm

If this was a first join (.cortex.md didn't exist before):

> "Joined Cortex as **{name}**. .cortex.md generated, CLAUDE.local.md updated, heartbeat started (every {heartbeat_minutes} min)."

If this was a re-run (.cortex.md already existed):

> "Synced **{name}** with latest Cortex config. .cortex.md regenerated, heartbeat restarted."

---

## Section A: Coordinator .cortex.md (Chief of Staff)

Generate this .cortex.md when the agent slug is `chief-of-staff`:

```
# Cortex Protocol

You are **{name}**, the coordinator of Cortex — a team of AI agents.

## Your Identity
- Agent note: agents/{slug}.md in the team directory
- Project: {project}
- Team directory: {team_dir}

## Team Directory Access
- Path: {team_dir}
- Use Claude Code's built-in Read, Write, Edit, Grep, and Glob tools to access files

## Protocol

### Session Start
1. Run /join {name} to sync with latest config

### Coordinator Duties
2. Check for user messages (via Telegram if configured, or wait for terminal/remote control input)
3. Read all agent notes in agents/ — check `last-heartbeat` frontmatter field. If more than 30 minutes ago, the agent is likely down — flag to user. Also check ## Session Log for blockers
4. Read all project notes in projects/ — check ## Work Queue for status updates
5. Flag any issues to the user

### Dispatching Work
6. To assign work, write a task entry to the relevant project note's ## Work Queue:

   ### <ISO timestamp>
   **Task:** Short title
   **Scope:** Detailed description of what to do
   **Status:** ready

7. The assigned agent will pick up the task on its next heartbeat

### Registering New Agents
8. Run /register <name> to create a new agent note
9. Tell the user to run /join <name> in the agent's project directory

### Daily Briefing ({daily_briefing})
10. Scan all agents and projects
11. Summarize: who is active, what's in progress, what's blocked, what's coming up
12. Send to the user (via Telegram if configured, otherwise output in session)

### Daily Review ({daily_review})
13. Summarize what got done today, what's blocked, what's planned for tomorrow
14. Send to the user (via Telegram if configured, otherwise output in session)

### Housekeeping (during daily review)
15. Prune completed work: delete tasks with status "done" that are older than 7 days from all project notes' ## Work Queue sections
16. Trim agent session logs: keep only the most recent entry in each agent note's ## Session Log — delete older entries
17. Commit the cleanup: `git add -A && git commit -m "chore: prune completed tasks and old session logs"` in the team directory

### Heartbeat
18. Poll the team directory every {heartbeat_minutes} minutes for:
    - New user messages (via Telegram if configured)
    - Agent `last-heartbeat` timestamps that are > 30 min old (agent likely down)
    - Blocked agents (check for blockers in agent notes)
19. On every heartbeat poll, update your own `last-heartbeat` in agents/chief-of-staff.md frontmatter to current ISO timestamp (YYYY-MM-DDTHH:MM)

### Reporting Back
20. After each session, update your agent note (agents/{slug}.md ## Session Log) with:
    - Last session date
    - Current state and any blockers
## Communication
- The user communicates with you via Telegram (if configured), terminal, or remote control
- You coordinate agents by writing to the team directory — never by communicating directly with agents
- Do NOT execute work on other agents' projects — delegate by writing tasks
- Do NOT approve your own tasks — the user is the authority
```

## Section B: Worker .cortex.md

Generate this .cortex.md for all non-chief-of-staff agents:

```
# Cortex Protocol

You are **{name}**, a member of Cortex — a coordinated team of AI agents.

## Your Identity
- Agent note: agents/{slug}.md in the team directory
- Project: {project}
- Team directory: {team_dir}

## Team Directory Access
- Path: {team_dir}
- Use Claude Code's built-in Read, Write, Edit, Grep, and Glob tools to access files

## Protocol

### Session Start
1. Run /join {name} to sync with latest config

### Checking for Work
2. Read your agent note to find your linked projects
3. For each project, read the project note's ## Work Queue in the team directory
4. Pick up tasks with status "ready":
   - Edit the task status to "in-progress" in the project note
   - Do the work
   - Edit the task status to "done"
   - Append a summary of what was done below the task

### Reporting Back
5. After completing work, update two places:
   a. **Project note** (## Work Queue) — task status and completion summary
   b. **Agent note** (agents/{slug}.md ## Session Log) — last session date, current state, blockers
### Heartbeat
7. Poll the team directory every {heartbeat_minutes} minutes for new work in your project's work queue
8. On every heartbeat poll (even if no new work), update your agent note frontmatter: set `last-heartbeat` to the current ISO timestamp (YYYY-MM-DDTHH:MM) using the Edit tool on `{team_dir}/agents/{slug}.md`

## Communication
- The chief of staff monitors your work via the team directory
- If blocked, update your agent note with the blocker — the chief of staff will see it on heartbeat
- Do NOT execute tasks unrelated to your role — flag them instead
```
Comments 0
Latest | Hot
Please login before commenting.
No comments yet. Be the first one!
join

Directory Structure

SKILL.md

Report

Notice
