atoll-api

Atoll API

This ClawHub listing is kept as a compatibility alias for existing atoll-api installs. For new installs, prefer the atoll skill and configure skills.entries.atoll in ~/.openclaw/openclaw.json.

Base URL: https://atollhq.com

How Atoll Works

Atoll connects strategy to execution through a reasoning chain:

Goals (directional objectives with deadlines)
  → KPIs (live metrics — manual, webhook, or API-fed)
    → Initiatives (bets expected to move specific KPIs)
      → Milestones + Issues (execution work)

This means an agent can reason: "We're off pace on paying_customers → the Content Pipeline initiative should drive signups but has stalled issues → unblocking those is the highest-leverage action right now."

Agents are organization members using the same API and authorization model as humans. Effective organization role and project scope still govern each action; agent identity does not bypass those checks.

Authentication

All requests require: Authorization: Bearer sk_atoll_

API keys are generated in Agents (for agents) or Settings > Members > Create API Key (for integrations). Each key is scoped to one org. Store both values as env vars:

export ATOLL_API_KEY="sk_atoll_..."
export ATOLL_ORG_ID="..."          # UUID of the org the key belongs to

For OpenClaw / ClawHub, prefer skill-scoped config in ~/.openclaw/openclaw.json instead of global shell exports:

If you are intentionally staying on this legacy alias, keep the atoll-api entry:

{
  skills: {
    entries: {
      "atoll-api": {
        enabled: true,
        apiKey: "sk_atoll_...",
        env: {
          ATOLL_ORG_ID: "..."
        }
      }
    }
  }
}

apiKey maps to ATOLL_API_KEY; optional defaults such as ATOLL_PROJECT, ATOLL_TEAM, and ATOLL_BASE_URL belong under env.

Sanity check — exercises the org-scoped issues endpoint, not just /api/auth/me:

: "${ATOLL_API_KEY:?missing}" "${ATOLL_ORG_ID:?missing}" && \
  curl -sS -o /dev/null -w "HTTP:%{http_code}\n" \
    "https://atollhq.com/api/orgs/$ATOLL_ORG_ID/issues?limit=1" \
    -H "Authorization: Bearer $ATOLL_API_KEY"
# Expect: HTTP:200

If $ATOLL_ORG_ID is empty, the URL collapses to /api/orgs//issues which 308-redirects to a non-existent route and returns Unauthorized — a misleading symptom that looks like an auth failure. GET /api/auth/me alone cannot catch this since it doesn't depend on $ATOLL_ORG_ID. Always guard both vars.

For agent diagnostics, /api/auth/me reports the organization role in auth.role and live per-project view/edit/admin grants in auth.projectAccess[]. Project-scoped agents intentionally remain org guests. Organization-role and project-access changes are read live and do not require key rotation; scopes: [] is normal for a standard agent key.

Quick Start — CLI (recommended)

Install globally or use via npx:

npm install -g @atollhq/cli   # or: npx @atollhq/cli ...

Configure once:

atoll auth login --key sk_atoll_...
atoll config set-org org-uuid

For machines or agents that need multiple credentials, use auth profiles:

atoll auth login --profile agent-a --key sk_atoll_... --org-id org-uuid
atoll auth login --profile agent-b --key sk_atoll_... --org-id org-uuid --project project-id --team team-id
atoll auth profiles
atoll auth use agent-a

# Run one command as a specific profile
atoll --profile agent-b issue list

Profiles can store default org ID, project, team, and base URL values. For named profiles, always persist --org-id or pass --org-id per command. Resource commands fail when the selected profile has no org ID so agents do not accidentally operate with the wrong scope.

Env vars remain supported for CI, containers, and one-off runtime usage, but persistent developer/agent machines should prefer profiles. When a profile is selected, ambient ATOLL_* env vars do not silently override profile context; conflicting env values fail before network calls. Pass --profile, use repo-local .atoll/context.json, or opt into env mode with --env-mode / ATOLL_ENV_MODE=1.

Repo-local baseUrl values cannot reuse a saved profile key unless that same base URL is stored in the profile. Set ATOLL_TRUST_REPO_BASE_URL=1 only for a single process after verifying both the repository and destination host.

atoll issue list and atoll issue create apply the selected default team unless a command-level --team override is passed. Issue command --project flags accept a project ID, slug, or exact name, including list and bulk defaults. In bulk JSON items, project accepts those references while projectId and project_id are canonical IDs. --milestone accepts a milestone ID, or an exact milestone name when a project is selected with --project or the active profile's default project.

atoll issue list --open excludes terminal statuses done and cancelled, plus archived issues, while preserving every custom and other non-terminal status. It composes with other list filters, ordering, pagination, and JSON, and cannot be combined with --include-archived.

Common commands:

# Agent orientation
atoll heartbeat
atoll heartbeat --signals-only
atoll heartbeat --severity critical
atoll heartbeat --json
atoll agent-context

# List tasks
atoll issue list --json
atoll issue list --open
atoll issue list --status todo --priority 1 --limit 25
atoll issue list --scope blocked --initiative initiative-uuid --order-by due_date --order-dir asc

# View a task
atoll issue get ATOLL-42
atoll issue view ATOLL-42   # alias kept for humans

# Create a task
atoll issue create --title "Fix login bug" --status todo --priority 1
atoll issue create --title "Plan rollout" --project project-slug --milestone "Launch"
atoll issue create --title "Weekly status review" --due-date 2026-07-06 --recurrence weekly
atoll issue create --title "MWF status review" --due-date 2026-07-06 --recurrence weekly --recurrence-days mon,wed,fri
atoll issue upsert --match-title --project  --title "Fix login bug" --status todo
atoll issue bulk-create --file ./issues.json --continue-on-error

# Update a task
atoll issue update ATOLL-42 --status in_progress
atoll issue update ATOLL-42 --status in_progress --comment-body "Starting this because the activation KPI is off pace."
atoll issue upsert ATOLL-42 --status in_progress
atoll issue bulk-update --file ./updates.json --dry-run

# Assign a task
atoll issue assign ATOLL-42 --to 
atoll issue assign ATOLL-42 --to self

# Comments
atoll comment add ATOLL-42 --body "Working on this now"
atoll comment add ATOLL-42 --body "tagging..." --mention-member 
atoll comment add ATOLL-42 --body "tagging..." --mention "Raphael Ubales"
atoll comment add ATOLL-42 --body "Agent update" --source-harness codex --source-thread-id 
atoll comment add ATOLL-42 --body "Continuing this" --reply-to-comment 

# --mention-member uses a stable Atoll org member ID; --mention exact-matches display names and fails on ambiguity.

# Labels, notifications, subtasks, activity
atoll label list
atoll label add ATOLL-42 bug
atoll notification list --json
atoll notification ack notification-uuid
atoll inbox list --json
atoll inbox view email-uuid --json
atoll inbox triage email-uuid --category support --priority 1 --status action_required
atoll inbox resolve email-uuid --note "Handled in ATOLL-123"
# Draft only; this does not send:
atoll inbox draft email-uuid --from support@atollhq.com --to user@example.com --subject "Re: Help" --body-file ./reply.txt
atoll subtask create ATOLL-42 --title "Verify recurrence"
atoll activity issue ATOLL-42

# Read-only API fallback for uncommon inspection gaps
atoll api get /api/orgs/$ATOLL_ORG_ID/labels --json

# Dependencies
atoll dependency bulk-add --file ./dependencies.json --continue-on-error

# Graph plans
atoll plan validate --file ./plan.json
atoll plan apply --file ./plan.json --dry-run

# Safe removal
atoll issue archive ATOLL-42
atoll issue unarchive ATOLL-42
atoll issue delete ATOLL-42 --dry-run
atoll issue delete ATOLL-42 --force

# Report friction to Atoll maintainers
atoll feedback "The status error should list custom board statuses"

# Projects & milestones
atoll project list
atoll board-column create --project  --key review --label "In Review" --description "Ready for review"
atoll project delete  --confirm DELETE
atoll milestone list --project 
atoll milestone upsert --project  --name "v1.0" --date 2026-06-01

# Goals, KPIs, and initiatives
atoll goal create --title "Reach 100 paying customers by Q2" --target-date 2026-06-30
atoll kpi create --name paying_customers --goal "Reach 100 paying customers by Q2" --unit count --target 100 --current 34
atoll kpi create --name mvp_tasks_done --goal "Launch MVP" --internal-task-completion
atoll initiative create --title "Content pipeline" --goal "Reach 100 paying customers by Q2" --status active
atoll initiative kpi link "Content pipeline" paying_customers --impact "+30 customers/mo"
atoll initiative target create "Content pipeline" --title "Publish 10 comparison posts" --mode progress --target 10 --current 0 --unit count --unit-label posts
atoll initiative target create "Retailer coverage" --title "Get 5 retailers live by July 5" --mode gate --target 5 --current 0 --unit count --unit-label retailers --target-date 2026-07-05 --due-soon-days 7
atoll initiative target issue link "Retailer coverage" "Get 5 retailers live by July 5" ATOLL-42
atoll kpi snapshot add paying_customers --value 42 --initiative "Content pipeline" --issue ATOLL-42 --note "End-of-week Stripe check"
atoll kpi snapshot list paying_customers --include-attribution --json
atoll heartbeat --explain-kpi paying_customers --json

# Audit the strategy chain for gaps (orphaned initiatives, goals with no KPI, etc.)
atoll strategy audit
atoll strategy audit --severity critical --json

Prefer the CLI for routine task operations, heartbeat checks, comments, feedback, and strategy setup. Use direct API calls when the CLI does not expose the needed endpoint yet.

CLI JSON conventions:

• Use --json for machine-readable output.
• List commands return { resource, items, total, limit, offset, nextOffset, truncated, hint }.
• Project-scoped atoll issue list --json includes project_context; atoll issue get/view --json includes status_column plus project_context when available.
• For initiative execution context via API, GET /api/orgs/{id}/initiatives/{initiativeId}/issues?details=1 returns accessible task details from linked projects, direct issue links, and linked milestones.
• Diagnostics and errors go to stderr.
• Machine-readable JSON preserves API strings exactly; human terminal output removes ANSI/VT, control, and bidirectional formatting characters from API-supplied strings.
• Interactive CLI update notices also go to stderr and are suppressed for JSON/non-TTY/CI/completion flows.
• atoll agent-context returns a versioned command/flag manifest, available profile context, and structured cli.update_available metadata.
• Weekly issue recurrence accepts unique selected weekdays with --recurrence weekly --recurrence-days mon,wed,fri. Read JSON exposes normalized recurrence_days and recurrence_schedule; unrelated updates preserve the schedule.
• atoll heartbeat --json includes the same structured cli update metadata for agents, plus attention_items, attention_summary, and recommended_action when Atoll can propose one concrete strategy-backed next action. atoll heartbeat --signals-only --json preserves filtered signals, attention_items, attention_summary, and recommended_action for short polling. Handle direct attention items first, then call each handled item's ack_endpoint. Follow recommended_action.usage_guidance: prefer suggested_write.operation when it still matches the board, preserve KPI/initiative/initiative_target/why-now/expected-impact/first-step/success-criteria evidence, and avoid copying deferred busywork into issue or comment payloads. If a start_work recommendation uses issue.update with a body, update the issue status and preserve that body as an issue comment; PATCH /issues/{issueId} accepts comment_body for this same-request progress note.
• atoll plan validate/apply consumes schemaVersion: "atoll.plan.v1" files with milestones, issues, dependencies, initiativeLinks, and milestoneLinks; local key values can be referenced by milestoneKey, issueKey, dependsOn, blockedBy, or blocks.

KPI HTTP Sync Drafts

When a human asks you to help automate a KPI from a third-party API, use this Atoll skill. If the current agent environment does not have the atoll skill or this legacy atoll-api alias installed, tell the user to install the atoll skill before continuing or use the Atoll CLI/MCP tools directly if they are available.

Organization-wide non-guest agents may create draft syncs and validate proposed configs for KPIs they can read, but only after a human admin has allowlisted the exact destination host in Atoll. Guest and project-scoped agents cannot use the KPI or nested sync routes. Human admins must create or review the draft in Settings > Integrations > KPI syncs, edit supported request/extraction fields and secrets through structured UI, dry-run, publish, disable, or run-now with snapshot writing.

atoll kpi sync validate  \
  --name "PostHog visitors" \
  --schedule daily \
  --url https://us.posthog.com/api/projects/123/query/ \
  --pointer /results/0/value \
  --auth-secret-ref posthog_api_key

atoll kpi sync draft  --file sync-draft.json

Draft configs must be GET only, https only, JSON only, no redirects, no request bodies, no inline query strings, no secret values, and an already-allowlisted exact destination host. Use secret reference names only for Authorization: Bearer or X-API-Key: .

Never include API keys, bearer tokens, cookies, raw third-party response bodies, or secret values in prompts, draft files, comments, or issue descriptions. If a human pasted a secret into chat, stop and ask them to rotate it and enter the replacement directly in Atoll.

Remote MCP Server

Use @atollhq/mcp-server when an agent or ChatGPT-style client needs Atoll access but cannot run a local CLI command or read local auth profiles.

npm install -g @atollhq/mcp-server
PORT=8787 atoll-mcp

HTTP mode binds to 127.0.0.1 by default. External binding requires both ATOLL_MCP_HOST= and ATOLL_MCP_ALLOW_EXTERNAL=1 and should be used only behind a trusted TLS/authenticated network boundary.

Remote MCP clients call POST /mcp with Streamable HTTP and must send Authorization: Bearer sk_atoll_... per request. HTTP requests never fall back to a process-level ATOLL_API_KEY; that fallback is available only in explicit --stdio mode. HTTP deployments may set ATOLL_ORG_ID and ATOLL_BASE_URL as defaults.

The server validates each HTTP bearer token through /api/auth/me before MCP dispatch and rejects request bodies over 1 MiB, including chunked requests.

The MCP server mirrors core CLI workflows with tools such as atoll_get_heartbeat, issue/project/goal/KPI/initiative/milestone tools, dependency tools, webhook tools, atoll_send_feedback, and atoll_api_request for advanced endpoints. atoll_add_comment accepts structured mentions, reply_to_comment_id, and explicit agent source_metadata; it does not infer harness thread IDs. atoll_update_issue accepts comment_body for durable progress comments.

Keep Atoll skills separate from the MCP package. Skills are client-side agent guidance; the MCP server is runtime infrastructure for auth, transport, validation, and Atoll API calls.

AI-Assisted Setup

When a user needs help setting up Atoll, lean into the AI workflow. Atoll is most useful when the user's AI assistant helps turn messy context into projects, issues, goals, KPIs, and agent instructions.

If you are the AI assistant with CLI access, prefer doing the setup directly after confirming the intended org/profile and scope. Start with read-only orientation:

atoll auth profiles
atoll heartbeat --json
atoll issue list --json --limit 10

If the user is setting up Atoll in another AI tool, give them a copyable prompt. Keep secrets out of chat: tell the user to run auth commands locally and never ask them to paste sk_atoll_... keys into a model conversation unless they explicitly choose that risk.

If the user is in Atoll's first-run setup wizard, the key may be setup-scoped. In that mode, inspect the repo or interview the user, then create or revise the setup proposal only. Do not try to create projects, goals, KPIs, initiatives, or issues directly, and do not approve/apply the proposal. The human reviews the editable proposal in Atoll and approves it there. Treat the setup key as temporary: it expires after 24 hours and Atoll revokes it when setup is applied, skipped, or failed. Continued use requires a separately minted ordinary key.

Prompt: Create the First Board

I am setting up Atoll for my team. Help me create the first project an AI agent could understand.
Ask me 3-5 questions about the current push, then propose:
- one project name
- the outcome this project should drive
- 3-5 initial issues with clear titles, context, priorities, and owners if known
- which issue an agent should pick up first and why
Keep the setup small. I want a useful first board, not a full migration.

Prompt: Turn a Project Into Issues

I have an Atoll project but need help turning it into actionable issues.
Interview me about the project, then write 5 issues an AI agent could execute.
For each issue include:
- title
- why it matters
- acceptance criteria
- suggested priority
- any context the agent would need before starting
Make the issues specific enough that I can paste them into Atoll with minimal editing.

Prompt: Install and Authenticate the CLI

Help me connect this workspace to Atoll.
First, explain what the Atoll CLI will let you do and what credentials you need.
Then walk me through installing @atollhq/cli, adding an agent in Atoll, authenticating with the API key, and running a safe read-only check like `atoll issue list`.
Do not ask me to paste secrets into chat unless I explicitly choose to. Tell me where to run each command locally.

Prompt: Run the First Heartbeat

You are helping me set up Atoll for agentic project management.
Use the Atoll CLI to orient before doing any work.
Run `atoll heartbeat`, summarize what you can see, identify the highest-leverage next action, and tell me whether you have enough access to list issues and update your assigned work.
If anything is missing, explain the exact setup step I need to complete in Atoll.

Prompt: Draft the Strategy Chain

Help me define the strategy chain for my Atoll workspace.
Ask me what business outcome matters most this month, then propose:
- one goal with a clear target date
- 1-2 KPIs that show whether we are on pace
- one initiative expected to move the KPI
- 3 issues that belong under that initiative
Keep it practical. I want the smallest strategy layer that would help an AI agent choose better work.

Quick Start — API (for advanced use)

All CLI commands map to REST endpoints. Use atoll api get for GET-only inspection gaps when a typed command does not exist yet. The CLI blocks /api/internal/*, billing, and KPI sync admin routes because some GET endpoints can run jobs, synchronize external state, or require human-admin review. Use direct API calls for writes only when the CLI does not cover a specific operation and the workflow is not human-admin-gated.

atoll api get "/api/orgs/$ATOLL_ORG_ID/issues?status=todo" --json

# Prereq: both env vars exported (see Authentication above)
atoll() {
  : "${ATOLL_API_KEY:?ATOLL_API_KEY not set}"
  : "${ATOLL_ORG_ID:?ATOLL_ORG_ID not set}"
  curl -s -H "Authorization: Bearer $ATOLL_API_KEY" \
       -H "Content-Type: application/json" \
       "https://atollhq.com$1" "${@:2}"
}

atoll "/api/orgs/$ATOLL_ORG_ID/issues?status=todo"

The Heartbeat Loop

The primary pattern for autonomous agents. Prefer atoll heartbeat --json when the CLI is available; it wraps GET /api/orgs/{id}/heartbeat and returns the same computed briefing:

• Goal status with days remaining
• KPI pace: pace_needed vs pace_actual, trend (accelerating/decelerating/flat), staleness
• Initiative progress: total/completed/stalled/blocked issue counts, expected KPI impacts, and initiative targets
• Assigned work for this agent
• Project context: relevant board columns, including optional descriptions that explain stage criteria for agents. Project-scoped guests receive every explicitly accessible board while idle; personal agents retain relevant inherited-project context.
• Signals sorted by severity — the agent's prioritized to-do list
• Attention items: direct current-member notifications such as mentions, assignments, assignee comments, and creator-visible status changes, with an ack_endpoint to call after handling
• Recommended action: one deterministic strategy-backed next action when Atoll has enough evidence (create_work, start_work, escalate_blocker, refresh_metric, or investigate), including why-now, expected impact, first step, success criteria, quality warnings, and any suggested write. An investigation can use suggested_write.operation: "none" when heartbeat lacks enough detail for a safe write.

Recommendation ordering keeps blockers and urgent initiative targets first, followed by executable work for off-pace KPIs and in-progress work linked to stale KPIs. Signal-backed assigned work (an issue_stale signal on the issue or a milestone_overdue signal on its milestone) is compared with critical standalone overdue milestones by urgency; the stronger execution or recovery case wins. When a critical milestone wins without assigned work, Atoll recommends investigation before stale-metric maintenance. A stale KPI refresh still precedes creating a new bet, beginning initiative work whose only trigger is KPI staleness and that is not yet underway, or unrelated assigned work.

Heartbeat is org-scoped, but project-bound payload details are filtered by the caller's project access. Owners/admins receive full org context; members/guests only receive project-bound strategy, work health, assigned work, milestone signals, and board context for accessible projects. Project-scoped guests receive every explicitly accessible board while idle; personal agents retain relevant inherited-project context. Non-guest members can also see unprojected org-level strategy. Shared initiatives can appear with counts and signals based only on accessible work.

Signal types: kpi_off_pace, kpi_stale, issue_stale, issue_blocked, milestone_overdue, initiative_stalled, initiative_target_due_soon, initiative_target_overdue, initiative_target_blocked, webhook_failing. Severity: info, warning, critical.

Targets under initiatives are commitments, not business KPIs. KPIs measure business outcomes such as MRR, traffic, paying customers, or onboarding success. Use progress targets for initiative outputs such as "publish 10 comparison posts." Use gate targets for launch prerequisites such as "get 5 retailers live by July 5." Gate targets emit stateful due/blocked messages and should not be converted into fractional KPI pace such as "0.07 retailers/day."

Useful CLI forms:

atoll heartbeat
atoll heartbeat --signals-only
atoll heartbeat --severity critical
atoll heartbeat --json

The agent loop:

1. Call heartbeat
2. Handle direct attention_items that need a reply, task update, or blocker follow-up
3. Call each handled item's ack_endpoint
4. Read remaining signals (highest severity first)
5. Reason about highest-leverage action given direct attention, gate targets, KPI pace, and initiative state
6. Execute (unblock issues, update KPIs, create work, report progress)
7. Repeat

Other Common Workflows

Pick up and complete a task

atoll heartbeat --signals-only                        # orient first
atoll issue list --status todo --assignee self --json # find assigned work
atoll issue update ATOLL-42 --status in_progress --comment-body "Starting because the linked KPI is off pace." # start work with durable context
atoll comment add ATOLL-42 --body "Progress update…"  # report progress
atoll issue update ATOLL-42 --status done              # complete

Set up the strategy chain

1. POST /api/orgs/{id}/goals -- create goal with target_date
2. POST /api/orgs/{id}/kpis -- attach KPI with goal_id, target_value, target_direction; for launch-style goals you can use source_type: "formula" with source_config.formula: "goal_linked_issue_completion" to calculate done directly linked and milestone-linked tasks over total linked tasks
3. POST /api/orgs/{id}/kpis/{kpiId}/snapshots -- record measurement (auto-updates current_value)
4. POST /api/orgs/{id}/initiatives -- create initiative linked to goal
5. POST /api/orgs/{id}/initiatives/{id}/kpi-impacts -- declare expected KPI impact
6. POST /api/orgs/{id}/initiatives/{id}/targets -- create progress or gate targets for initiative commitments
7. Link issues and milestones to the initiative and to specific targets when the work exists to satisfy that target

CLI equivalent:

atoll goal create --title "Reach 100 paying customers by Q2" --target-date 2026-06-30
atoll kpi create --name paying_customers --goal "Reach 100 paying customers by Q2" --unit count --target 100 --current 34
atoll initiative create --title "Content pipeline" --goal "Reach 100 paying customers by Q2" --status active
atoll initiative kpi link "Content pipeline" paying_customers --impact "+30 customers/mo"
atoll initiative target create "Content pipeline" --title "Publish 10 comparison posts" --mode progress --target 10 --current 0 --unit count --unit-label posts
atoll initiative target create "Retailer coverage" --title "Get 5 retailers live by July 5" --mode gate --target 5 --current 0 --unit count --unit-label retailers --target-date 2026-07-05 --due-soon-days 7
atoll kpi snapshot add paying_customers --value 42 --initiative "Content pipeline" --issue ATOLL-42 --note "End-of-week Stripe check"
atoll kpi snapshot list paying_customers --include-attribution --json

Project-scoped agent profiles apply their default project to atoll initiative list and atoll initiative create. Use --project to override that project, or --org-wide to intentionally suppress the default project. API callers can pass project_id or projectId on create, and ?project_id=... on list; guest/project-scoped callers must use a project they can access, and create requires edit/admin project access. Projectless organization-wide initiative creation requires an organization owner/admin.

Project-linked initiative reads require access to at least one linked project. The authoritative set includes explicit project links and projects inferred from direct issue/milestone links. Updating an initiative or mutating its issue, milestone, or target links requires edit/admin access to every linked project; a requested issue or milestone project must already be linked when it is project-bound. Eligible non-guests may link and unlink writable projectless issues; projectless milestones are unsupported. KPI-impact reads omit unreadable KPIs and KPI-impact writes require owner/admin Strategy access. Projectless initiative writes require an organization owner/admin. Treat 404 as concealed absence or unreadable scope and 403 as insufficient write access to a readable initiative.

KPIs are organization-wide Strategy resources. Owners/admins may read and write; other non-guest organization members may read values, snapshots, and redacted per-KPI sync metadata but cannot create, update, delete, or record snapshots. Guest/project-scoped agents receive 403 for the collection and concealed 404 responses for direct KPI, snapshot, and per-KPI sync read/draft routes. Verify the active profile's organization-wide role before running KPI commands.

Every KPI snapshot can be attributed to an initiative or issue, building a record of what actually moved the numbers. Keep KPI-to-initiative impact links separate from snapshot attribution: an initiative link means the initiative is expected to move the KPI, while snapshot attribution records the source of one measurement. Heartbeat reports one canonical status per KPI and can explain a KPI with atoll heartbeat --explain-kpi --json.

Audit and improve the strategy

Use the audit to review the strategy chain visible to the caller at a high level and fix structural problems — the common one being initiatives created without a goal.

atoll strategy audit            # human-readable, grouped by severity
atoll strategy audit --json     # findings[] for programmatic remediation

GET /api/orgs/{id}/strategy/audit returns findings[] (each with a type, severity, the relevant entity id, and a concrete suggested_fix) plus summary counts. It diagnoses; you remediate with the normal write endpoints. Typical loop:

The audit follows the caller's project access. Owners/admins receive organization-wide execution evidence. Other non-guests receive project-bound issues, milestones, target links, and target findings only for readable projects. A restricted caller with no readable projects receives no issue or target execution evidence. Guests cannot run the audit.

1. atoll strategy audit --json to get findings.
2. For each finding, apply its suggested_fix, e.g.:
   • initiative_orphaned → atoll initiative update "" --goal "" (or PATCH .../initiatives/{id} { goal_id })
   • goal_missing_kpi → atoll kpi create --goal "" --name ... --target ...
   • kpi_missing_target → atoll kpi update --target ... --direction increase
   • kpi_unrecorded / kpi_stale → atoll kpi snapshot add --value ...
   • initiative_missing_impact → atoll initiative kpi link "" --impact "..."
3. Re-run the audit to confirm the findings cleared.

This is the structural-health lens (is the strategy well-formed?), complementary to heartbeat, which is the operational lens (what should I do today?).

Bulk create tasks from a plan

POST /api/orgs/{id}/issues/bulk with { "issues": [{...}, ...] } (max 50).

Google Chat notifications

Google Chat is a separate notification channel. Notification preferences accept channel: "google_chat" for mention.created; muting it does not acknowledge or clear in-app notifications.

User pairing is human-driven. When verified-email auto-linking is ambiguous, Google Chat receives REQUEST_CONFIG and sends the user to Atoll to sign in, choose one of their own workspace memberships, and return to Chat. Sending the stable word connect in the Atoll direct message explicitly starts this flow for reconnects or additional workspaces. GET|POST /api/integrations/google-chat/connect-session and the org-scoped member status, disconnect, and test endpoints require an authenticated human web session and reject sk_atoll_... agent or integration keys. POST /api/orgs/{id}/integrations/google-chat/link-token remains a manual fallback. Do not call /api/integrations/google-chat/events as an Atoll API client: Google Chat calls that endpoint with a Google-signed OIDC ID token whose audience is the callback URL.

Mention notifications are queued durably and dispatched asynchronously immediately after the notification request. A 15-minute recovery drain retries interrupted or transiently failed deliveries with deterministic Google request/message IDs, exponential backoff, and a five-attempt limit.

Config sessions and unused manual connect tokens expire after 10 minutes. Session completion and identical event replays are idempotent and cannot establish a different member or direct-message link.

Outbound webhooks

POST /api/webhooks creates outbound webhooks. Receiver URLs must be HTTPS DNS hostnames; Atoll rejects IP literals, localhost, .local hosts, URL credentials, and fragments at creation. Delivery also resolves DNS and refuses private, loopback, link-local, documentation, multicast, and other non-public addresses; redirects are not followed.

Webhook creation returns a raw whsec_... secret once. Delivery requests include:

• X-Atoll-Signature: sha256= plus an HMAC-SHA256 over the raw body, keyed by the SHA-256 hex digest of the raw secret.
• X-Atoll-Signature-Version: the primary signing-key version.
• X-Atoll-Signatures: versioned signatures during a bounded key-overlap window.
• X-Atoll-Delivery-Id: stable delivery id for receiver-side deduplication.

Webhook administration is owner/admin only. Lists return an origin-only destination_display; paths, queries, and signing material are never returned. Payload schema version 2 is allowlisted and omits descriptions, comment bodies, and raw change values. Delivery rows expose safe delivery_id, status, status_code, error_code, and retry timing, but not payloads, receiver response bodies, or raw errors. Network failures and 5xx responses retry quickly in-process, then persist status: retry_pending with next_retry_at; an internal drain retries due deliveries every 15 minutes.

Billing and plan limits

Owners/admins can read billing state with GET /api/orgs/{id}/billing and start a self-serve Stripe billing flow with POST /api/orgs/{id}/billing/checkout using { "plan": "starter" }, { "plan": "team" }, or { "plan": "pro" }. Owner/admin read requests sync Stripe first and return 502 with Stripe billing sync failed if that sync cannot complete, rather than serving stale local billing state. New subscribers use Checkout; existing active, trialing, or past-due subscribers use a Billing Portal update confirmation.

Creation endpoints can return 402 with code: "PLAN_LIMIT_REACHED" when an org reaches limits for humans, agents/integrations, active projects, or active issues.

API Reference

Full endpoint tables and field schemas:

• references/api-endpoints.md -- all endpoints organized by resource
• references/api-fields.md -- request/response schemas, field definitions, enums

Key resources

Initiative create accepts title or legacy name, plus camelCase aliases goalId, ownerId, and targetDate.

All endpoints are under /api/orgs/{orgId}/....

Issue comments inherit issue project permissions: listing comments requires access to the issue's project, comment writes (add, edit, delete) require write access to that project, edit/delete still require comment authorship, and guests cannot access comments on unprojected issues.

Project-bound milestone, status-update, board-column, issue-activity, and PR-link reads require effective project access. Milestone create/update, status-update create, board-column mutations, and project-bound PR-link create require edit or admin; eligible non-guests may read issue activity and read or attach PR links for projectless issues. Milestone delete remains organization owner/admin-only. Issue activity is read-only. Organization activity and analytics are limited to the caller's accessible projects, with eligible non-guests also receiving projectless data; project-health contains accessible projects only. Do not treat org membership alone as project authorization.

Issue templates follow the same effective-project boundary: project-template reads require project access and writes require edit/admin. Organization-wide templates are readable by non-guests and manageable only by organization owners/admins; guest/project-scoped agents never receive them. Avatar mutations require both caller and target to belong to the organization in the request path. Avatar pointer changes use compare-and-set semantics; concurrent changes return 409, and successful mutations with durable Storage cleanup still queued return 202 with cleanup_pending: true. A conflict can also include cleanup_pending: true when cleanup of a staged or retired object remains queued. An authenticated 15-minute worker drains due jobs independently, with avatar requests providing an additional opportunistic sweep.

Comment bodies accept Markdown/plain text or existing rich-text HTML. Atoll stores and returns comment bodies as sanitized HTML. If sanitization leaves no visible text or safe media, the request returns 400 with body is required for direct comments or comment_body is required for issue updates with comment_body.

Structured mentions are recommended for agents and integrations. Direct comment requests accept mentions: [{ "member_id": "member-id" }]; issue updates that create comments accept comment_mentions: [{ "member_id": "member-id" }]. member_id is the stable Atoll org member ID, not an auth user ID or display name. Markdown and HTML atoll:member links remain backward-compatible.

Use reply_to_comment_id for a direct reply. List/read responses include the relationship plus reply_to_comment.source_metadata, allowing an orchestration agent to route a human reply back to the originating harness thread without a separate run resource.

Agent-authored direct comments may include explicit source_metadata with harness, thread_id and/or session_id, and optional host_id. Unknown keys are rejected, humans cannot submit agent provenance, and harnesses must supply values explicitly. Never include credentials or secrets. Issue-update comments accept the same object as comment_source_metadata.

Responses that create comments include mentions: { requested, created, skipped }. Each skipped[] entry includes member_id and reason; reasons are invalid_member_id, not_found, self_mention, no_project_access, guest_unprojected_issue, unsupported_member_type, and mentions_muted.

Issue attachments inherit the same issue permissions. Project-scoped reads require project access; upload and delete require edit or admin. Guests cannot access attachments on unprojected issues, while non-guests follow the org-level issue rule.

Attachment metadata contains id, filename, file_size, mime_type, uploaded_by, created_at, and a relative url. Resolve url against the Atoll base URL