@polderlabs/openkan 0.4.0

package/dist/.claude/skills/ok-planning/references/integration.md

@@ -0,0 +1,153 @@
+# Integration — how the pieces fit
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                       Claude Code                                │
+│                                                                  │
+│  ┌─────────────┐  SessionStart   ┌──────────────┐                │
+│  │  ok-init.mjs │ ───────────────▶│  bin/ok.ts   │                │
+│  │   (hook)     │                 │  (CLI entry) │                │
+│  └─────────────┘                 └──────┬───────┘                │
+│                                         │                         │
+│                                         ▼                         │
+│                              ┌─────────────────────┐              │
+│                              │  ok/commands/*.ts    │              │
+│                              │  task / plan / prd   │              │
+│                              │  index / doctor      │              │
+│                              └──────────┬──────────┘              │
+│                                         │                         │
+│                                         ▼                         │
+│                              ┌─────────────────────┐              │
+│                              │  ok/storage.ts       │              │
+│                              │  ok/lock.ts          │              │
+│                              │  ok/schemas.ts       │              │
+│                              └──────────┬──────────┘              │
+└─────────────────────────────────────────┼────────────────────────┘
+                                          │
+                                          ▼
+                                  ┌─────────────────┐
+                                  │     .ok/        │
+                                  │ config.json     │
+                                  │ index.json      │
+                                  │ tasks/<id>.json │
+                                  │ plans/<id>.json │
+                                  │ prds/<id>.json  │
+                                  │ locks/<id>.lock │
+                                  └────────┬────────┘
+                                           │
+                                  dual-write (every board persist)
+                                           │
+                                           ▼
+                                  ┌─────────────────┐
+                                  │  kanban/board.ts │
+                                  │  OpenKan engine  │
+                                  └─────────────────┘
+```
+
+## Pieces
+
+### 1. `bin/ok.ts` (CLI entry)
+
+Dispatches to subcommands. Run via `node --experimental-strip-types
+bin/ok.ts …` or through `bin/ok.mjs` which is a small Node launcher.
+
+### 2. `ok/commands/*.ts` (subcommands)
+
+Each file exports a `runX(args)` function and optionally runs as a
+subprocess via the bottom-of-file `if (import.meta.url === …)` block.
+
+- `task.ts` — `ok task add|list|show|update|claim|heartbeat|complete|cancel|release`
+- `plan.ts` — `ok plan add|list|show|update`
+- `prd.ts` — `ok prd add|list|show|update`
+- `index.ts` — `ok index` and `ok doctor`
+- `init.ts` — `ok init`
+
+### 3. `ok/storage.ts` (storage layer)
+
+Async JSON I/O with atomic writes. Path helpers (`paths(root)`) resolve
+every well-known file/dir under `.ok/`. The core operations are
+typed: `readTask`, `writeTask`, `listTasks`, etc.
+
+### 4. `ok/lock.ts` (claim/heartbeat/release)
+
+Advisory JSON locks under `.ok/locks/`. Rejects concurrent writes from
+different owners; leases expire after `--lease-ms` (default 1h).
+
+### 5. `ok/schemas.ts` (validation)
+
+TypeScript types and runtime validation. `ok doctor` runs every file
+through the corresponding validator.
+
+### 6. `ok/migrate.ts` (legacy import)
+
+One-shot import of `.openkan/tasks.json` and `.openkan/board.json` into
+`.ok/tasks/<id>.json`. Idempotent; second run is a no-op.
+
+### 7. `.claude/hooks/ok-init.mjs` (SessionStart hook)
+
+Reads `process.env.CLAUDE_PROJECT_DIR` and runs `ok init` if `.ok/`
+doesn't exist. Always exits 0 (hooks never block Claude).
+
+### 8. `kanban/board.ts` (OpenKan engine)
+
+Persists the OpenKan board to `.ok/board.json` AND mirrors each task
+into `.ok/tasks/<id>.json` (via `mirrorToOkStore`). This is the
+integration point: every board write becomes a planning-system write.
+
+### 9. `.claude/skills/ok-planning/` (this skill)
+
+The agent-facing surface. Self-contained: a Claude Code agent that loads
+the skill gets everything needed to plan, track, and recover work.
+
+## Adding a new subcommand
+
+1. Create `ok/commands/<name>.ts` exporting `run<X>(args)` that
+   returns `{ code: number }`.
+2. Register it in `bin/ok.ts` under the main switch.
+3. Add a test in `tests/ok-<name>.test.mts` exercising the happy path
+   and the most common failures (parse errors, lock contention, schema
+   drift).
+4. Mention the subcommand in the skill body and in `docs/OK-PLANNING.md`.
+
+Keep one logical operation per commit: the subcommand, its tests, and
+its docs land together.
+
+## Why dual-write?
+
+The OpenKan engine's existing API surface (`withWrite`, `persist`) is
+unchanged. The mirror write in `mirrorToOkStore` adds a side-effect
+that materialises the planning-system JSON files. Two paths write the
+same data:
+
+- `ok task add` → writes `.ok/tasks/<id>.json` directly.
+- OpenKan UI → `kanban/board.ts:persist()` → mirror writes each task.
+
+Both paths produce identical `.ok/tasks/<id>.json` content. The mirror
+write is idempotent and safe to call repeatedly.
+
+## What if the mirror write fails?
+
+The board persist still succeeds; the mirror write is wrapped in
+try/catch and never aborts the engine. If the mirror fails (disk full,
+permission error), the next `ok index` will notice the missing file
+and surface it via `ok doctor`.
+
+## Why no SQLite / no central DB?
+
+- JSON files are diffable in PRs.
+- One file per entity scales to thousands of tasks per project.
+- No native bindings → runs anywhere Node runs.
+- The `ok doctor` + `ok index` pair gives you DB-equivalent consistency
+  checks without the runtime.
+
+## Limits
+
+The `.ok/` layout assumes:
+
+- A single project per directory (the workspace is project-scoped).
+- Trust between writers (advisory locks, not fcntl).
+- File-system atomic rename (every supported platform).
+- Node ≥ 22 (for `--experimental-strip-types`).
+
+If any of these assumptions breaks in your environment, the planning
+system is the wrong tool — use a database.

package/dist/.claude/skills/ok-planning/references/schemas.md

@@ -0,0 +1,270 @@
+# Full schema reference — `ok` planning layer
+
+This document expands the abridged schemas in `SKILL.md` with field-level
+descriptions, validation rules, and worked examples.
+
+All entities follow the same pattern:
+
+```jsonc
+{
+  "schema": "ok.<entity>.v1",
+  // ... entity-specific fields ...
+}
+```
+
+The `schema` discriminator is the only identity you should rely on for
+parsing. `ok doctor` checks it before any other validation.
+
+---
+
+## Task — `ok.task.v1`
+
+An atomic unit of work. Atomicity is intentional: every task should be
+representable in a single commit; multi-commit work is decomposed into
+multiple tasks or promoted to a Plan.
+
+```ts
+{
+  schema: "ok.task.v1",
+  id: string,                  // "tsk-<nanoid-8>"
+  title: string,               // 1..200 chars
+  description?: string,        // optional markdown-lite
+  owner?: string,              // agent/user; free-form
+  status: "pending" | "in_progress" | "review" | "done" | "cancelled",
+  priority?: "p0" | "p1" | "p2" | "p3",
+  plan?: string,               // "pln-<id>"
+  prd?: string,                // "prd-<id>"
+  scopes?: string[],           // tags / paths / identifiers
+  deps?: string[],             // task ids this depends on
+  createdAt: string,           // ISO
+  updatedAt: string,           // ISO
+  startedAt?: string,          // ISO; set on first in_progress
+  completedAt?: string,        // ISO; set on done/cancelled
+  evidence?: string[],         // commit shas, file:line, URLs
+  acceptance?: string[],       // definition-of-done bullets
+}
+```
+
+### Status transitions
+
+```
+pending ──claim──▶ in_progress ──update──▶ review ──update──▶ done
+   │                    │                      │                 
+   └────cancel──────────┴──────────────────────┘                 
+```
+
+- `claim` transitions `pending → in_progress` and writes a lock.
+- `update --status review` moves an in-progress task into review.
+- `complete` is the only transition to `done`; it requires `--evidence`.
+- `cancel` is terminal; it requires `--reason` (recorded as evidence).
+
+The status enum is the canonical lifecycle indicator. Column placement
+in OpenKan's UI is a presentation concern and is mapped back to `status`
+on read.
+
+### Example
+
+```json
+{
+  "schema": "ok.task.v1",
+  "id": "tsk-9brjCkWa",
+  "title": "Implement claim helper",
+  "description": "Cover happy path, expired lease, and double-claim.",
+  "owner": "alice",
+  "status": "in_progress",
+  "priority": "p1",
+  "plan": "pln-7Hg2Vu3W",
+  "prd": "prd-T6g9Pz_X",
+  "scopes": ["ok/lock.ts", "tests/ok-lock.test.mts"],
+  "deps": [],
+  "createdAt": "2026-09-04T10:00:00.000Z",
+  "updatedAt": "2026-09-04T10:01:30.000Z",
+  "startedAt": "2026-09-04T10:01:30.000Z",
+  "acceptance": ["two test cases per branch", "no fcntl dependency"]
+}
+```
+
+---
+
+## Plan — `ok.plan.v1`
+
+A medium-lived container for a cohesive set of tasks.
+
+```ts
+{
+  schema: "ok.plan.v1",
+  id: string,                   // "pln-<nanoid-8>"
+  title: string,
+  summary: string,              // 1-2 sentence elevator pitch
+  prd?: string,                 // parent PRD id
+  phase?: string,               // current phase label (free-form)
+  status: "draft" | "active" | "blocked" | "complete" | "abandoned",
+  tasks: string[],              // ordered task ids
+  acceptance: string[],         // plan-level DoD
+  createdAt: string,            // ISO
+  updatedAt: string,            // ISO
+}
+```
+
+### Status transitions
+
+```
+draft ──update──▶ active ──update──▶ complete
+   │                │
+   └─update─────────┴──update──▶ abandoned
+   │
+   └─update──▶ blocked ──update──▶ active
+```
+
+- `draft` is the only state in which a plan can be edited without
+  justification (acceptance bullets, task list, phase label).
+- `active` plans show up in `ok plan list` defaults.
+- `complete` is terminal.
+
+### Example
+
+```json
+{
+  "schema": "ok.plan.v1",
+  "id": "pln-7Hg2Vu3W",
+  "title": "v0.1: schemas + storage",
+  "summary": "Ship the .ok/ storage layer end-to-end.",
+  "prd": "prd-T6g9Pz_X",
+  "phase": "M2",
+  "status": "active",
+  "tasks": ["tsk-9brjCkWa", "tsk-AbCdEfGh", "tsk-IjKlMnOp"],
+  "acceptance": ["all schemas validate", "tests green", "doctor returns 0 issues"],
+  "createdAt": "2026-09-04T09:55:00.000Z",
+  "updatedAt": "2026-09-04T10:01:30.000Z"
+}
+```
+
+---
+
+## PRD — `ok.prd.v1`
+
+A long-horizon Product Requirements Document.
+
+```ts
+{
+  schema: "ok.prd.v1",
+  id: string,                   // "prd-<nanoid-8>"
+  title: string,
+  vision: string,               // one paragraph
+  goals: PrdGoal[],             // see below
+  nonGoals: string[],
+  successMetrics: PrdSuccessMetric[],   // see below
+  milestones: PrdMilestone[],           // see below
+  risks: PrdRisk[],                     // see below
+  plans: string[],              // plan ids that contribute
+  owners: string[],             // agents/users
+  reviewCadence?: string,       // "weekly", "monthly", etc.
+  status: "draft" | "active" | "shipped" | "abandoned",
+  createdAt: string,
+  updatedAt: string,
+  nextReviewAt?: string,        // ISO
+}
+```
+
+### Sub-shapes
+
+```ts
+type PrdGoal = { id: string; text: string; status: "open" | "in_progress" | "met" | "dropped" };
+type PrdSuccessMetric = { name: string; target: string; current?: string };
+type PrdMilestone = { id: string; title: string; dueBy?: string; status: "open" | "hit" | "missed" | "dropped" };
+type PrdRisk = { id: string; text: string; severity: "low" | "med" | "high"; mitigation?: string };
+```
+
+### Goal / milestone ids
+
+Goal ids default to `g1`, `g2`, … in creation order. Milestone ids
+default to `m1`, `m2`, …. Risk ids are auto-assigned by `ok doctor` if
+you write the file by hand.
+
+### Example
+
+```json
+{
+  "schema": "ok.prd.v1",
+  "id": "prd-T6g9Pz_X",
+  "title": "Self-contained planning workspace",
+  "vision": "Every project ships with .ok/ for tasks, plans, and PRDs.",
+  "goals": [
+    { "id": "g1", "text": "ship CLI", "status": "met" },
+    { "id": "g2", "text": "ship skill", "status": "open" },
+    { "id": "g3", "text": "ship auto-init", "status": "open" }
+  ],
+  "nonGoals": ["Windows support", "TUI"],
+  "successMetrics": [
+    { "name": "active planning workspaces", "target": "20", "current": "0" },
+    { "name": "p50 session bootstrap", "target": "< 200ms", "current": "n/a" }
+  ],
+  "milestones": [
+    { "id": "m1", "title": "v0.1 schema", "dueBy": "2026-10-01T00:00:00Z", "status": "open" },
+    { "id": "m2", "title": "v1.0 launch", "dueBy": "2026-12-15T00:00:00Z", "status": "open" }
+  ],
+  "risks": [
+    { "id": "r1", "text": "agent role confusion", "severity": "med", "mitigation": "skill body disambiguates triggers" }
+  ],
+  "plans": ["pln-7Hg2Vu3W"],
+  "owners": ["karen", "todd"],
+  "reviewCadence": "weekly",
+  "status": "active",
+  "createdAt": "2026-09-04T09:00:00.000Z",
+  "updatedAt": "2026-09-04T10:00:00.000Z",
+  "nextReviewAt": "2026-09-11T09:00:00Z"
+}
+```
+
+---
+
+## Config — `ok.config.v1`
+
+Workspace metadata. One per project. Never carries entity data.
+
+```ts
+{
+  schema: "ok.config.v1",
+  version: 1,
+  defaultOwner?: string,
+  createdAt: string,
+  updatedAt: string,
+}
+```
+
+`defaultOwner` is applied to new tasks that omit `--owner`. Useful for
+single-operator projects.
+
+---
+
+## Index — `ok.index.v1`
+
+A compact pointer file for fast listings. Rebuilt via `ok index`.
+
+```ts
+{
+  schema: "ok.index.v1",
+  tasks: IndexEntry[],          // {id, status, title, updatedAt}
+  plans: IndexEntry[],
+  prds: IndexEntry[],
+  updatedAt: string,
+}
+```
+
+Each entry is sorted by `updatedAt` descending. Agents that just want
+"what is open?" can read this file and skip the per-task JSONs.
+
+---
+
+## Validation rules summary
+
+- All ids must match their kind's regex (`tsk-…`, `pln-…`, `prd-…`).
+- `title` on a Task must be 1..200 chars.
+- Status enums are exact-match; arbitrary strings are rejected.
+- `createdAt` / `updatedAt` must be ISO timestamps (`Date.parse` works).
+- Array fields must be string arrays when present.
+- Unknown fields are ignored (forward-compat); missing required fields
+  are rejected.
+
+If you write the file by hand and want validation feedback, run
+`ok doctor` after writing.

package/dist/.claude/skills/ok-planning/references/workflows.md

@@ -0,0 +1,185 @@
+# Workflows — six end-to-end agent flows
+
+Each workflow shows the goal, the `ok` commands, and what the agent
+should look for in the output. Run them in any order; each is
+self-contained.
+
+---
+
+## 1. Start a session and claim work
+
+Goal: discover open tasks, take ownership of one before starting.
+
+```sh
+# 1. Ensure the workspace exists
+ok init
+
+# 2. Find work
+ok task list --status pending --json
+ok task list --status in_progress --json    # avoid collisions
+
+# 3. Read the chosen task
+ok task show <id> --json
+
+# 4. Claim it (writes a lock for 1h default)
+ok task claim <id> --owner <self>
+```
+
+What to watch for:
+
+- If `ok task claim` prints `locked by …`, the lock is held by another
+  agent. Coordinate or wait for the lease to expire (default 1h).
+- `--lease-ms` lets you claim for longer if you know the work is big:
+  `ok task claim <id> --owner <self> --lease-ms 3600000`.
+
+---
+
+## 2. End a session with concrete evidence
+
+Goal: leave the workspace in a state the next agent can pick up.
+
+```sh
+# Did you finish?
+ok task complete <id> --owner <self> --evidence "<sha-or-path-or-summary>"
+# or, did you decide to drop?
+ok task cancel <id> --owner <self> --reason "<why>"
+# or, did you just stop without finishing?
+ok task release <id> --owner <self>
+
+# Always refresh the index so the next agent sees fresh state
+ok index
+```
+
+Evidence expectations:
+
+- A commit sha (`abc1234`)
+- A `path:line` reference (`ok/lock.ts:60-105`)
+- A URL (`https://…`)
+- A one-line summary of what shipped
+
+Anything that lets the next agent (or the user) verify the work without
+chatting with you.
+
+---
+
+## 3. Scope a feature as PRD → Plan → Tasks
+
+Goal: capture a long-horizon goal, group it into a milestone, and break
+that into atomic tasks.
+
+```sh
+# 1. Define the north star
+ok prd add "<short title>" \
+  --vision "<one paragraph north star>" \
+  --goals "g1|g2|g3" \
+  --milestones "v0.1|v1.0" \
+  --non-goals "X|Y" \
+  --owners "<agent1>,<agent2>" \
+  --review-cadence weekly
+# → prd-AbCdEfGh
+
+# 2. Group tasks under the PRD
+ok plan add "v0.1: <milestone>" \
+  --prd prd-AbCdEfGh \
+  --summary "<elevator pitch>" \
+  --acceptance "ship a" "ship b" \
+  --tasks tsk-…,tsk-…
+# → pln-XyZ12345
+
+# 3. Add tasks with back-link to the plan (optional)
+ok task add "<task>" --plan pln-XyZ12345 --owner <self>
+ok task add "<task>" --prd prd-AbCdEfGh --owner <self>
+```
+
+Tip: keep PRDs stable across many sessions. Plans are short-lived;
+don't promote plans to PRDs unless the work spans weeks.
+
+---
+
+## 4. Recover from drift or corruption
+
+Goal: bring a `.ok/` tree back to a known-good state.
+
+```sh
+# 1. Diagnose
+ok doctor
+
+# 2. If the index is stale, rebuild
+ok index
+
+# 3. If a single file is corrupt, fix or remove it
+rm .ok/tasks/tsk-bad.json
+ok index
+ok doctor
+```
+
+Common drift scenarios:
+
+- **Stale lock** — `ok task claim <id> --owner <self>` after the lease
+  expires, or `ok task release <id> --owner <stale-owner>` if you know
+  the owner.
+- **Index out of sync** — `ok index` rebuilds it from the filesystem.
+- **Schema version mismatch** — bump the schema field and add a
+  migration in `ok/storage.ts`; never silently drop fields.
+- **Partial write leftover** — `.tmp-<pid>-<ts>` files are safe to
+  delete; `ok init` will recreate them as needed.
+
+---
+
+## 5. Hand off to another agent
+
+Goal: pass ownership cleanly without losing the lock or the work.
+
+```sh
+# Releasing agent
+ok task update <id> --evidence "handoff to <new-agent>: <summary of state>"
+ok task release <id> --owner <self>
+
+# Picking-up agent
+ok task claim <id> --owner <new-agent>
+```
+
+If the handover is bigger than a task (a whole plan or PRD), use
+`--append-plan` on the PRD to record the new plan, and update
+`prd.owners` via a JSON edit (or wait for the `ok prd update --owners`
+flag to land).
+
+---
+
+## 6. Migrate from a legacy `.openkan/` workspace
+
+Goal: bring an existing OpenKan board under the new `.ok/` planning
+layer.
+
+```sh
+ok migrate-from-openkan             # one-shot, idempotent
+ok doctor                           # validate the result
+ok index                            # rebuild the index
+```
+
+Status mapping (legacy → planning):
+
+| Legacy state | Planning status |
+|--------------|-----------------|
+| `done` | `done` |
+| `running`, `waiting-for-input` | `in_progress` |
+| `cancelled`, `failed` | `cancelled` |
+| column `review` (state idle) | `review` |
+| column `doing` (state idle) | `in_progress` |
+| otherwise | `pending` |
+
+Archived tasks become `cancelled`. Priority `urgent` → `p0`,
+`normal` → `p2`, `low` → `p3`.
+
+If a task has both a `tasks.json` and a `board.json` entry, the
+`tasks.json` version wins (it's the older source of truth).
+
+---
+
+## Diagnostic commands
+
+- `ok help` — usage summary.
+- `ok doctor` — schema validation across the tree.
+- `ok index` — rebuild `.ok/index.json` from the filesystem.
+- `ok task list --json | jq '. | length'` — quick counts.
+- `ok task show <id> --json` — full record.

package/dist/.claude/skills/ok-planning/scripts/ok-init.sh

@@ -0,0 +1,14 @@
+#!/usr/bin/env bash
+# ok-init.sh — bash wrapper that runs `ok init` and prints the layout.
+#
+# Usage: ok-init.sh [project-root]
+#        (defaults to the current directory)
+
+set -euo pipefail
+
+ROOT="${1:-$(pwd)}"
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+# Resolve the repo root (the directory that contains bin/ok.ts).
+REPO_ROOT="$(cd "$SCRIPT_DIR/../../.." && pwd)"
+
+( cd "$ROOT" && node --experimental-strip-types "$REPO_ROOT/bin/ok.ts" init )

package/dist/.claude/skills/ok-planning/scripts/ok-resume.sh

@@ -0,0 +1,38 @@
+#!/usr/bin/env bash
+# ok-resume.sh — bash wrapper that prints an at-a-glance summary of what's
+# open, in progress, and shippable.
+#
+# Reads .ok/index.json if it exists, else rebuilds it on the fly.
+# Sorts each section by `updatedAt` descending.
+
+set -euo pipefail
+
+ROOT="${1:-$(pwd)}"
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+REPO_ROOT="$(cd "$SCRIPT_DIR/../../.." && pwd)"
+
+cd "$ROOT"
+
+INDEX=".ok/index.json"
+if [[ ! -f "$INDEX" ]]; then
+  node --experimental-strip-types "$REPO_ROOT/bin/ok.ts" index >/dev/null
+fi
+
+if command -v jq >/dev/null 2>&1; then
+  tasks_total=$(jq '.tasks | length' "$INDEX")
+  plans_total=$(jq '.plans | length' "$INDEX")
+  prds_total=$(jq '.prds | length' "$INDEX")
+  tasks_open=$(jq '[.tasks[] | select(.status == "pending" or .status == "in_progress" or .status == "review")] | length' "$INDEX")
+  plans_active=$(jq '[.plans[] | select(.status == "active")] | length' "$INDEX")
+  prds_active=$(jq '[.prds[] | select(.status == "active")] | length' "$INDEX")
+
+  echo "tasks: $tasks_open open / $tasks_total total"
+  echo "plans: $plans_active active / $plans_total total"
+  echo "prds:  $prds_active active / $prds_total total"
+  echo "---"
+  echo "most-recently-updated items:"
+  jq -r '((.tasks + .plans + .prds) | sort_by(-.updatedAt) | .[0:5] | .[] | "  [\(.status)] \(.id)  \(.title)")' "$INDEX"
+else
+  echo "open tasks: $(node --experimental-strip-types "$REPO_ROOT/bin/ok.ts" task list --status pending --json | wc -l) bytes of JSON"
+  echo "(install jq for the full breakdown)"
+fi

package/dist/.claude/skills/ok-planning/scripts/ok-status.sh

@@ -0,0 +1,24 @@
+#!/usr/bin/env bash
+# ok-status.sh — bash wrapper that prints a quick health summary.
+#
+# Runs `ok doctor && ok task list --status pending --json | jq '. | length'`.
+# Falls back gracefully when `jq` is not installed.
+
+set -euo pipefail
+
+ROOT="${1:-$(pwd)}"
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+REPO_ROOT="$(cd "$SCRIPT_DIR/../../.." && pwd)"
+
+cd "$ROOT"
+
+node --experimental-strip-types "$REPO_ROOT/bin/ok.ts" doctor
+
+if command -v jq >/dev/null 2>&1; then
+  open=$(node --experimental-strip-types "$REPO_ROOT/bin/ok.ts" task list --status pending --json | jq 'length')
+  in_progress=$(node --experimental-strip-types "$REPO_ROOT/bin/ok.ts" task list --status in_progress --json | jq 'length')
+  review=$(node --experimental-strip-types "$REPO_ROOT/bin/ok.ts" task list --status review --json | jq 'length')
+  echo "open tasks: $open   in progress: $in_progress   in review: $review"
+else
+  echo "(install jq for full counts; `ok task list --status pending --json` returns the array)"
+fi