/capabilities

name: capabilities
description: |
  Your capability catalog — read this at boot. Lists the temporal date-range
  skills and the external integrations (reached via the loopback broker)
  available to you as a spawned worker, and exactly how to call each. Read-only.
  Consult it whenever you're unsure what tools/integrations you have or how to
  invoke them.
allowed-tools:
  - Bash

Worker Capability Catalog

You are an autonomous worker spawned by the hive to do one objective and report back. This catalog tells you **what you can do and how to call it** — your temporal skills and your external integrations — so you don't have to guess. Everything here is read-only to invoke (the integrations themselves may act, but they are mediated and credential-free from your side).

1. Your environment

The harness injects these env vars (use them; don't hard-code paths):

• `AGENT_ID`, `AGENT_NAME` — your identity in the hive.
• `AGENT_DIR` — your private workspace (`identity.md`, `memory.md`, `inbox/`,

`outbox/`, and `.claude/skills/`). Your bundled skills live under `$AGENT_DIR/.claude/skills/`.

• `HIVE_ROOT` — the shared hive (`PROTOCOL.md`, the kanban, other agents).

At boot you also have `identity.md` (who you are) and `HIVE_ROOT/PROTOCOL.md` (the full coordination protocol). To message god or another agent, write ONE message JSON into `$AGENT_DIR/outbox/` (schema in PROTOCOL.md). When finished, send god an `"act":"done"` outbox message with a substantive result summary.

2. Temporal skills — concrete date ranges, relative to now

When your task is time-scoped, resolve the dates instead of computing them by hand. Each skill prints inclusive civil dates (`YYYY-MM-DD`, your local timezone) **and** the half-open `[startUtc, endExclusiveUtc)` instants for timestamp queries. All are read-only (clock + stdout only; no writes, no network).

Named shortcuts (invoke directly):

| Skill | Range it resolves | | --- | --- | | `/today`, `/yesterday` | the single civil day | | `/thisWeek`, `/lastWeek` | ISO week (Mon-start); this = Mon→today, last = prior full week | | `/last7Days`, `/last30Days` | rolling N-day window ending today | | `/thisMonth`, `/lastMonth` | this = 1st→today; last = prior full month | | `/thisQuarter`, `/lastQuarter` | this = quarter-start→today; last = prior full quarter | | `/thisYear`, `/lastYear` | this = Jan 1→today (YTD); last = prior full year |

For **any** window — including `last90Days`, `last12Months`, or arbitrary `lastNdays` / `lastNweeks` / `lastNmonths` — use `/temporal`, or call the resolver directly:

node "$AGENT_DIR/.claude/skills/temporal/when.mjs" last30Days   # one window
node "$AGENT_DIR/.claude/skills/temporal/when.mjs"             # all windows
node "$AGENT_DIR/.claude/skills/temporal/when.mjs" --json 90d  # JSON only
node "$AGENT_DIR/.claude/skills/temporal/when.mjs" --list      # keywords

Convention: `this*` windows are **period-start → today** (to-date); `last*` named periods are the **full prior complete period**.

3. Integrations — via the loopback broker

External services are reached through the hive's **loopback broker**: a local, authenticated endpoint the harness runs on `127.0.0.1`. You call the broker; it holds the credentials and performs the outbound call on your behalf. You never see or store a secret, and only loopback callers are accepted — so integration access is brokered, auditable, and credential-free from your side.

How integrations are surfaced to you is **environment-dependent** — the exact set enabled depends on how you were spawned and the hive's configuration — so discover what's live at run time rather than assuming. The broker pattern is stable even as specific integrations are added; treat the list below as the current surface, not a fixed contract.

Concrete capabilities you may have right now (check availability before relying on one):

• **Reply to the originating Slack thread.** If your objective arrived from

Slack, your dispatch includes the exact loopback reply command — `node "<helper>" --channel <C> --thread <T> --text "<mrkdwn>"`. Use *that* command verbatim to post your result back to the thread. Send a substantive reply (a short `*bold*` headline + the actual outcome/links), never a bare "done".

• **Hive messaging.** Coordinate or hand off by writing an outbox message JSON

to god or another agent (`$AGENT_DIR/outbox/`). This is your always-available channel.

• **Semantic memory (MemPalace).** If enabled for you: `mempalace search

"<query>"` to recall shared knowledge, `mempalace wake-up` for a digest.

• **Enterprise Knowledge Graph.** If enabled: `node "$KG_CLI" search "<query>"`

for ranked passages, `node "$KG_CLI" list`, `node "$KG_CLI" get <id>` — use it for company-specific facts instead of guessing.

• **MCP integrations** (filesystem, git, and others) come pre-wired into your

session settings when enabled; invoke them as normal tools. The set is gated by the hive's consent configuration.

As additional brokered integrations land (calendar, mail, docs, web fetch, …), they follow the same shape: a brokered, credential-free call discoverable at run time. Pair them with the temporal skills above — resolve the date window first, then pass those concrete ISO bounds to the integration query.

4. Boundaries

• Temporal skills are **read-only** helpers — they never write or reach the

network. The broker mediates all external calls; you hold no credentials.

• Do **not** push or tag to any remote. Commit locally; **god** is the sole

integrator. Pause only for high-severity actions (remote push, paid/infra changes, deleting something you didn't create) — otherwise work autonomously.

• Finish by reporting to god (`"act":"done"`) with a real, substantive summary.