@launchsecure/launch-kit 0.0.27 → 0.0.29

package/scaffolds/ls-marketplace/plugins/kit/commands/show-mcp-status.md

@@ -0,0 +1,109 @@
+---
+description: Show the health of launch-kit's daemon-style MCPs (today just launch-recall). Default output is a terse one-line summary per daemon; pass `full` for expanded details — PID, pidfile, last snapshot, debounce, shadow repo size, recent activity. Read-only; never mutates state.
+---
+
+# /kit:show-mcp-status
+
+Reports the liveness and recent activity of launch-kit's long-running MCP daemons. The recall watcher is the only daemon today; this command is structured so additional daemons can be added without changing its interface.
+
+Read $ARGUMENTS to decide output verbosity:
+- empty (`/kit:show-mcp-status`) → terse one-liner per daemon. Goal: fits in one or two visual lines.
+- `full` (`/kit:show-mcp-status full`) → expanded report per daemon. Goal: enough detail to diagnose health problems.
+
+## Preflight
+
+1. Verify the launch-recall MCP is wired by checking whether `mcp__launch-recall__recall_status` (or `mcp__local-launch-recall__recall_status` for dev repos) is callable. If neither is available, say so plainly: "launch-recall MCP not wired in this project — nothing to report" and stop.
+2. Pick whichever recall MCP is available. Prefer the project-level published one (`mcp__launch-recall__*`) unless only the local dev one is wired.
+
+## Daemons
+
+Today: **launch-recall** (the shadow-git file watcher).
+
+Structure your output so adding more daemons later is a copy-paste — one section per daemon, same shape.
+
+## Default output (no arguments)
+
+Call `mcp__launch-recall__recall_status`. Format as ONE LINE per daemon, then a single summary line. Example:
+
+```
+recall    ✓ alive  pid 12456  last snap 2m ago
+
+All daemons healthy.
+```
+
+Or if dead:
+
+```
+recall    ✗ dead   pidfile missing/stale
+
+1 daemon down. Run /kit:show-mcp-status full for details, or restart the watcher (kill any stale pid, then either start a new Claude Code session — the SessionStart hook respawns it — or run `node packages/cli/dist/server/recall-entry.js watch` from this repo).
+```
+
+Rules for the default view:
+- One line per daemon — name, glyph, status word, key metric.
+- `✓` (green) for alive, `✗` (red) for dead.
+- "X ago" for timestamps — relative time, easier to scan than ISO.
+- Summary line on a fresh line at the end. If anything is wrong, include a one-sentence recovery hint.
+- No JSON, no PID files paths, no debug info — that's for `full`.
+
+## Full output (`/kit:show-mcp-status full`)
+
+For each daemon, call BOTH `recall_status` AND `recall_report`. Combine into a per-daemon block:
+
+```
+recall — launch-recall watcher (shadow-git backup)
+
+  Status:        ✓ alive
+  PID:           12456
+  Watch tree:    /Users/prajyot/Documents/Work/AutomateWithUs/launchsecure-v2
+  Shadow repo:   /Users/prajyot/Documents/Work/AutomateWithUs/launchsecure-v2/.recall/repo.git
+
+  Last snapshot: 2026-05-21T12:05:45+05:30 (2m ago)
+  Total snaps:   1,247
+  Shadow size:   1.4 MB
+  Debounce:      3000ms
+  Retention:     keepLast 5000, maxAgeDays 30
+
+  Recent activity (last 5 snaps):
+    a1b2c3d  2m ago     snap 2026-05-21T06:35:45Z
+    9f8e7d6  14m ago    snap 2026-05-21T06:21:42Z
+    2557799  53m ago    snap 2026-05-21T05:52:35Z
+    8349edb  17h ago    snap 2026-05-20T13:36:39Z
+    e5a05cf  17h ago    snap 2026-05-20T13:32:05Z
+
+All daemons healthy.
+```
+
+If a daemon is dead, the block should still appear but with status `✗ dead` and as many fields as can be derived from the on-disk shadow repo + pidfile. Include a concrete recovery command at the end of the block (the same SessionStart restart path from the default view, plus the manual command for impatient users).
+
+Rules for the full view:
+- Two-column field labels — visually aligned, easier to skim.
+- Times: ISO timestamp + relative ("2m ago") in parens.
+- Sizes: human-readable (KB/MB), not bytes.
+- Last 5 snapshots only — newer first.
+- One blank line between daemon blocks (for when there are more than one).
+- Summary line at the end, same as the default view.
+
+## Health classification
+
+Use these rules to decide alive vs dead vs degraded:
+
+- **alive**: `recall_status.running === true` AND `lastSnapshotAt` is within the last 6 hours (heuristic — for an active repo, snaps happen every few minutes; 6h of silence suggests the watcher is wedged or no files have changed, both worth surfacing).
+- **dead**: `recall_status.running === false` OR `recall_status` errors out.
+- **degraded** (still print as alive but note it): `running === true` BUT `lastSnapshotAt` is older than 6h. Add a single inline note `(no activity in 6h — possibly idle or wedged)`.
+
+Don't over-warn — if a repo has genuinely been idle (e.g. you opened it for the first time today after a week), a 6h+ gap is normal. The note is informational, not an error.
+
+## Constraints
+
+- **Read-only.** This command never mutates state, never restarts watchers, never modifies config. Recovery is a recommendation in the output, not an automatic action.
+- **Fast.** Default view should be sub-second. The MCP tools are cheap; don't add scrubbing or heavy formatting.
+- **Plain text.** No markdown headers, no fenced blocks in the actual output — Claude Code renders them but the human eye scans monospace plain text fastest.
+- **Output what the user asked for.** If they ran the default, don't dump the full report "just in case." If they ran `full`, don't abbreviate.
+
+## Notes for the assistant
+
+- Use the wired `launch-recall` MCP tools — do not shell out to `node packages/cli/dist/server/recall-entry.js status` even though it works. Going through MCP makes this command portable across projects that have launch-kit init'd via npx vs dev-build.
+- When listing recent snaps, use the `recentSnapshots` array from `recall_report`. It's already sorted newest-first; just truncate.
+- For "X ago" formatting, do the math yourself. Don't fetch any time service.
+- If you find yourself wanting to add features beyond status display (restart the watcher, prune snaps, etc.) — stop. Those belong in separate `/kit:*` commands. This one is a status pane.

package/scaffolds/ls-marketplace/plugins/kit/commands/standup.md

@@ -0,0 +1,191 @@
+---
+description: Draft a daily standup from work done since the last push, surface in-progress local work and follow-ups, show the draft, and post to LaunchSecure Comm Hub as a daily_update after explicit confirmation.
+---
+
+# Standup
+
+Generates a daily-update comment for the LaunchSecure Comm Hub. Pulls commits since the last push (with fallbacks), surfaces what's still in-flight locally (uncommitted work, explicit follow-ups, in-progress work items), drafts a summary in the project's house style, shows it to the user, and posts only after the user confirms. Never posts without explicit "yes".
+
+## Preflight
+
+1. Verify `.launch-secure.cred.config` exists at the repo root. If missing, abort and tell the user to run `npx @launchsecure/launch-kit init` first — without the cred file the `launch-secure` MCP cannot authenticate, so we cannot read prior standups or post the new one.
+2. Verify we are inside a git repo (`git rev-parse --git-dir`). If not, abort with a clear message.
+3. Record the current branch (`git rev-parse --abbrev-ref HEAD`) and current git email (`git config user.email`).
+
+## Gather
+
+Pull data from layered sources, in this order. Default to git + commit messages — they already carry the structure. Only reach for `launch-chart` in the explicit case described in step 3.
+
+### 1. Determine the window
+
+- **Primary**: `git log --reverse --pretty=format:'%h%x09%an%x09%ae%x09%s%n%b%n%x00' @{push}..HEAD`. The `@{push}` revspec resolves to where this branch was last pushed; the diff is commits ahead of upstream.
+- **Fallback 1**: if the primary returns empty OR `@{push}` errors with `unknown revision`, query the `launch-secure` MCP via `communication_read({ tag: "daily_update", limit: 1 })`. Take the most recent comment's `createdAt`; gather commits since then via `git log --since="<that timestamp>"`.
+- **Fallback 2**: if no prior `daily_update` exists either, use `git log --since="24 hours ago"`.
+
+Tell the user which window was used in one short line ("Using commits since last push (12 commits)" or "No commits since last push — falling back to commits since 2026-05-20 14:01 (last standup)").
+
+### 2. Collect change context
+
+- `git diff --stat @{push}..HEAD` (or whichever window was chosen) — file paths + line counts. Drives theme grouping.
+- `git log --pretty=format:'%h %s' <window>` — short subject lines for quick scan.
+- `git log --pretty=format:'%h%n%B%n---' <window>` — full commit bodies. Needed for step 4 (follow-up detection).
+- Branch names + PR references in commit messages (look for `#<digits>`, `LS-<id>`, branch slugs like `fix/foo-bar`). These are work-item handles.
+
+### 3. Group into themes
+
+**Default: group by commit-message scope.** Conventional-commit subjects like `feat(launch-kit): …`, `refactor(server): …`, `chore(lint): …` already declare the theme — use the scope as the theme name. Multiple commits with the same scope collapse into one `→ <Scope>` section.
+
+**Only escalate to `launch-chart` when ALL of these are true:**
+- Window has ≥20 changed files across ≥5 top-level directories, AND
+- Commit scopes are missing, inconsistent, or too coarse to reveal structure (e.g. everything is `chore: …` or untagged).
+
+In that case: call `mcp__launch-chart__detect_project_stack` to verify the chart is wired, then for each changed file call `mcp__launch-chart__read_graph({ search: "<basename>" })` and group by the resolved node's `module` field. Common LS modules: `auth`, `pda`, `pda-guides`, `pda-shell`, `radar`, `chart`, `orbit`, `recall`, `comms`, `board`, `webhooks`, `feedback`, `briefs`, `mcp`.
+
+Files that don't resolve in the chart (new files, non-TS, config) bucket under "Misc" or by directory.
+
+### 4. Collect in-progress signals (the "what's still in flight" data)
+
+This is the data that makes the standup honest about what's still open, not just what shipped. Always run all three:
+
+**4a. Uncommitted local work** — `git status --short`. Group by area (e.g. `scripts/`, `.claude/`, untracked dirs). Filter out build artifacts that don't represent intentional work (`.launchsecure/graphs/*.json`, `node_modules`, `dist`, `.next`). What remains is in-flight code or scaffolds — surface it under "Pending / in-progress".
+
+**4b. Follow-up flags in commit bodies** — grep the full commit bodies pulled in step 2 for these patterns (case-insensitive): `follow-up`, `followup`, `TODO`, `flagged`, `deferred`, `not patched`, `rolled back`, `revert`, `queued`, `to be solved`, `next pass`. Each hit is a self-declared open item by the author — surface the sentence verbatim or paraphrased under "Pending / in-progress".
+
+**4c. In-progress work items assigned to current user** — call `mcp__launch-secure__work_items_list({ assignee_email: "<git email from preflight>", status: "IN_PROGRESS" })`. For each returned item, capture title + id. Don't list more than 5; if more exist, list 5 + "(N more)".
+
+If any of 4a/4b/4c return nothing, that section just doesn't appear in the draft. Don't fabricate filler.
+
+### 5. Work-item closure linkage
+
+For each work-item handle found in commit messages from step 2 (regex `#\d+|LS-\w+`), call `mcp__launch-secure__work_item_get({ id: "<id>" })` (or `work_items_list` with id filter). If any status changed to DONE/COMPLETED, call them out in the closing `----` block as a one-liner.
+
+Skip this step if no handles were found in commit messages — don't pull the full work-items list to fish for closures.
+
+### 6. Release detection
+
+A commit qualifies the post for the `release` tag if ANY of the following are true:
+- `package.json` `version` field changed in `git diff @{push}..HEAD -- package.json`
+- A migration file under `prisma/migrations/` was added or `prisma/schema.prisma` changed
+- A deploy/publish was mentioned in commit subjects (regex: `\b(publish|release|deploy|bump)\b`)
+- A new bin or export was added to a package's `package.json`
+
+If any are true, set `addReleaseTag = true`. Otherwise `false`.
+
+## Draft
+
+Produce the standup in the **exact** house format. This is the format Prajyot uses for human-written daily updates (verified against the May 18, 19, 20, 21 posts in the Comm Hub):
+
+```
+Hey @everyone
+
+Pushed <N> commits to <branch> today. Highlights:
+
+→ <Theme 1>
+- <outcome bullet, not a commit message>
+- <outcome bullet>
+
+→ <Theme 2>
+- <outcome bullet>
+
+→ <Theme N>
+- <outcome bullet>
+
+----
+
+Pending / in-progress:
+
+→ <Pending area 1>
+- <one-line item — what's open, why, where>
+
+→ <Pending area 2>
+- <one-line item>
+
+----
+
+<one-line PSA or deploy-safety note. Examples: "TS clean, no schema/migration changes, safe to deploy." or "Includes prisma migration <name> — run migrate-with-backup.sh before deploy.">
+
+Thanks
+```
+
+**Strict format rules:**
+
+- `Hey @everyone` — exactly this. Not "Hey team", not "Hi everyone". Single line, blank line after.
+- `Pushed N commits to <branch> today. Highlights:` — replace `<branch>` with the actual branch from preflight. If the window was a fallback (not "since last push"), say "Drafted N commits' worth of work on <branch> today. Highlights:" instead — be honest about the window.
+- `→ <Theme>` — right-arrow + space + theme name. Theme names come from commit-message scope (default) or chart module grouping (escalated case). Capitalize the first letter.
+- `- <bullet>` — plain hyphen + space. Bullets are **outcomes**, not commit messages. Translate "feat(radar): add transcript view" into "Structured transcript view with overlay reply drawer". Drop scope prefixes and verb tense.
+- Blank line between themes.
+- `----` — four hyphens, on its own line, blank line above and below. Used twice: once to open the Pending block, once to close it.
+- **Pending / in-progress block** — omit entirely if steps 4a/4b/4c all returned nothing. If present, populate from those three sources. Each `→` sub-heading names an area (e.g. `→ Feedback widget`, `→ Codex config writer`, `→ Beacon monitor UX`). Bullets are short, factual, name the file or symbol when relevant.
+- Closing block: one short line is fine. Don't pad. Mention work-item closures + any deploy-affecting changes here.
+- `Thanks` — exact word, no comma, no name signature (the post's author is attached automatically).
+
+**Constraints:**
+
+- Plain text only. No `**bold**`, no `*italic*`, no backticks, no `# headers`, no markdown link syntax. The Comm Hub renders as plain text.
+- Aim for ≤ 400 words total (was 350; bumped to accommodate the Pending block). Standups are skim-able; trim aggressively.
+- Top 3–6 themes is the sweet spot. If you have 20 commits in 12 different modules, collapse the small ones into a "→ Misc" theme.
+- Bullets should be **outcome-shaped**: what landed in the product, not what the diff did. "Multi-select EventTypesPicker on subscription forms" beats "modified components/webhooks/EventTypesPicker.tsx".
+- Pending items are honest snapshots, not commitments. "Drawer fix reverted — to be solved fresh" is fine; "will be fixed by EOD" is not.
+
+## Confirm
+
+Show the draft to the user verbatim in a code-fenced block (so they see plain-text formatting as-is), then ask **exactly**:
+
+> "Post this as a daily_update to LS Comm Hub? Reply `yes` to post, `edit` to revise, or `cancel` to abort."
+
+Responses:
+
+- **`yes`, `y`, `ok`, `post it`** — proceed to duplicate check + post.
+- **`edit`, `change <thing>`, free-form revisions** — apply the edits, regenerate the draft, re-show, re-ask.
+- **`cancel`, `no`, `nope`** — abort. Don't post. Don't keep partial state.
+
+Anything ambiguous → treat as "edit, what would you like changed?".
+
+## Duplicate check
+
+Before posting, call `mcp__launch-secure__communication_read({ tag: "daily_update", limit: 5 })`. If any returned comment has:
+- `resourceType: "comment"` (not `"daily_update"` — that's bot-only, distinct stream)
+- `author.email` matches the current user's email (from preflight)
+- `createdAt` within the last 12 hours
+
+…then a manual daily_update already exists from today. Offer:
+
+> "A daily_update already exists from you today (posted at <time>, <preview-50-chars>). Choose: `replace` to update it (communication_update), `append` to post another, `cancel` to stop."
+
+- **replace** → call `mcp__launch-secure__communication_update({ id: "<existing-id>", content: <new-draft> })`. Preserve tags.
+- **append** → proceed to post.
+- **cancel** → abort.
+
+## Post
+
+Call `mcp__launch-secure__communication_write`:
+
+```
+{
+  resourceType: "comment",
+  content: "<the final draft, plain text>",
+  tags: addReleaseTag ? ["daily_update", "release"] : ["daily_update"]
+}
+```
+
+`org_slug` and `project_slug` are auto-supplied from the cred config via the MCP's headersHelper — do NOT pass them yourself.
+
+On success: report the comment ID and a friendly "posted to LS Comm Hub" line. If the response includes a URL field, surface it.
+
+On failure: surface the error verbatim. Don't retry automatically — auth or schema errors deserve human attention. The draft is preserved in chat so the user can retry manually.
+
+## Idempotency
+
+Re-running `/kit:standup`:
+- Always re-pulls the window fresh. No cached state.
+- Duplicate check handles same-day reposts.
+- The draft is never written to disk — only shown in chat. User can copy it manually if they cancel.
+
+## Notes for the assistant
+
+- **Default to git, not the chart.** Conventional-commit scopes already declare themes; only reach for `launch-chart` when scopes are missing or inconsistent across ≥20 files / ≥5 directories. This was the most common failure of the previous prompt — chart calls produced no different grouping than commit-scope grouping would have.
+- **The Pending / in-progress block is the standup's main job, not the shipped-themes block.** Shipped work is visible in `git log`; what's still open isn't. Always run the three step-4 gathers.
+- **Don't ask clarifying questions before drafting.** Produce a first cut from whatever data step 1–6 returned, then iterate. The draft is cheap; the conversation isn't.
+- **Outcome bullet, not commit message** is the single most important transform. A standup full of "feat(x): add y" reads like a changelog, not a status.
+- **Never assume `release` tag without evidence** (see step 6). False positives confuse downstream consumers.
+- **If a step's tool fails**, note it inline and continue with the remaining sources — don't abort the whole standup over one failed call.

package/scaffolds/recall-hook/scripts/ensure-recall.sh

@@ -0,0 +1,69 @@
+#!/usr/bin/env bash
+# Ensures the launch-recall watcher is running. Designed for the Claude Code
+# SessionStart hook (.claude/settings.json). Idempotent: silently no-ops if
+# recall isn't configured, logs OK if watcher is already alive, spawns a
+# detached watcher if it isn't.
+#
+# Portable across two layouts:
+#   - Dev: project has packages/cli/dist/server/recall-entry.js (e.g.
+#     launchsecure-v2 itself) → spawn via `node`.
+#   - Customer: project doesn't ship launch-kit → spawn via
+#     `npx -y -p @launchsecure/launch-kit launch-recall watch`. First run
+#     downloads from npm (slow); subsequent runs use the npx cache.
+#
+# Exits 0 in all cases — recall failing should never block Claude Code startup.
+
+set -u
+
+REPO_ROOT="${CLAUDE_PROJECT_DIR:-$(pwd)}"
+RECALL_DIR="$REPO_ROOT/.recall"
+PIDFILE="$RECALL_DIR/watch.pid"
+LOCAL_RECALL_BIN="$REPO_ROOT/packages/cli/dist/server/recall-entry.js"
+
+# No recall configured here — exit quietly. Hook is safe to ship in any repo;
+# it only acts when there's a shadow-git to protect.
+if [[ ! -d "$RECALL_DIR/repo.git" ]]; then
+  exit 0
+fi
+
+# Watcher already alive?
+if [[ -f "$PIDFILE" ]]; then
+  pid="$(cat "$PIDFILE" 2>/dev/null || true)"
+  if [[ -n "${pid:-}" ]] && kill -0 "$pid" 2>/dev/null; then
+    echo "[recall] watcher alive (pid $pid)" >&2
+    exit 0
+  fi
+fi
+
+# Pick spawn command. Prefer the local dev build (instant) over npx (slow on
+# first run because of the npm download).
+if [[ -f "$LOCAL_RECALL_BIN" ]]; then
+  SPAWN_CMD=(node "$LOCAL_RECALL_BIN" watch)
+  via="local dev build"
+else
+  SPAWN_CMD=(npx -y -p @launchsecure/launch-kit launch-recall watch)
+  via="npx (initial download may take a moment)"
+fi
+
+echo "[recall] starting watcher via $via" >&2
+
+# Spawn detached. nohup + redirected fds + & keeps the watcher alive past this
+# script's exit. disown removes it from the shell's job table.
+nohup "${SPAWN_CMD[@]}" >/dev/null 2>&1 &
+disown 2>/dev/null || true
+
+# Brief check — long enough for the local-dev path, not long enough to block
+# session start when npx is downloading.
+sleep 0.5
+
+if [[ -f "$PIDFILE" ]]; then
+  newpid="$(cat "$PIDFILE" 2>/dev/null || true)"
+  if [[ -n "${newpid:-}" ]] && kill -0 "$newpid" 2>/dev/null; then
+    echo "[recall] watcher started (pid $newpid)" >&2
+    exit 0
+  fi
+fi
+
+# Spawn is still in flight (likely npx download). Don't block session start.
+echo "[recall] watcher spawn initiated — check with /ls:show-mcp-status in a moment" >&2
+exit 0

package/scaffolds/statusline/statusline-mcp.sh

@@ -0,0 +1,192 @@
+#!/usr/bin/env bash
+# launch-kit MCP chip generator.
+# Emits a colored one-line summary of MCP daemon health, one chip per daemon.
+# Composes into any existing statusline via the launch-kit wrapper.
+#
+# Usage:
+#   statusline-mcp.sh                       # all known chips (recall, chart, deck, council)
+#   statusline-mcp.sh --show=recall,chart   # only the listed chips
+#   statusline-mcp.sh --compact             # collapse to `mcp <up>/<total>`
+#                                             green when all up, red if any down
+#
+# Project root is inferred from $LK_STATUSLINE_CWD (set by the wrapper) or
+# $PWD by walking up until a `.launchsecure` dir is found. Silent exit when
+# the cwd is not inside a launchsecure project.
+set -u
+
+show=""
+compact=0
+for arg in "$@"; do
+  case "$arg" in
+    --show=*) show="${arg#--show=}" ;;
+    --compact) compact=1 ;;
+  esac
+done
+[ -z "$show" ] && show="recall,chart,deck,council"
+
+GREEN=$'\033[32m'
+ORANGE=$'\033[33m'
+RED=$'\033[31m'
+RESET=$'\033[0m'
+
+find_project_root() {
+  # `.recall` only exists at the repo root (launch-recall init creates it
+  # there). `.launchsecure` can appear in subdirs too (e.g. packages/cli
+  # when graphs are generated for a sub-project), so we prefer .recall as
+  # the canonical root marker. Fallback: outermost `.launchsecure` ancestor
+  # (walk up and keep overwriting → keeps the highest match).
+  local d="${1:-$PWD}"
+  local recall_root=""
+  local outermost_launchsecure=""
+  while [ -n "$d" ] && [ "$d" != "/" ]; do
+    if [ -z "$recall_root" ] && [ -d "$d/.recall" ]; then
+      recall_root="$d"
+    fi
+    if [ -d "$d/.launchsecure" ]; then
+      outermost_launchsecure="$d"
+    fi
+    d=$(dirname "$d")
+  done
+  if [ -n "$recall_root" ]; then echo "$recall_root"; return 0; fi
+  if [ -n "$outermost_launchsecure" ]; then echo "$outermost_launchsecure"; return 0; fi
+  return 1
+}
+
+PROJECT_ROOT=$(find_project_root "${LK_STATUSLINE_CWD:-$PWD}") || exit 0
+
+iso_to_epoch() {
+  # Input is always UTC (ISO timestamps from .freshness.json end in Z).
+  # macOS BSD `date` defaults to local TZ, so without TZ=UTC the timestamp
+  # gets misread as local time → wildly wrong age (e.g. 6h instead of 55m).
+  local ts="$1"
+  ts="${ts%%.*}"; ts="${ts%%Z*}"; ts="${ts%%+*}"
+  TZ=UTC date -j -f "%Y-%m-%dT%H:%M:%S" "$ts" +%s 2>/dev/null
+}
+
+fmt_age() {
+  local then="$1"
+  local now diff
+  now=$(date +%s)
+  diff=$((now - then))
+  if [ "$diff" -lt 60 ]; then echo "${diff}s"
+  elif [ "$diff" -lt 3600 ]; then echo "$((diff/60))m"
+  elif [ "$diff" -lt 86400 ]; then echo "$((diff/3600))h"
+  else echo "$((diff/86400))d"
+  fi
+}
+
+pid_from_lockfile() {
+  grep -o '"pid"[^,}]*' "$1" 2>/dev/null | head -1 | sed 's/[^0-9]//g'
+}
+
+# Each chip_* function sets two globals so the caller can use both the
+# colored display string (verbose mode) and the abstract state (compact mode)
+# without re-running the underlying probe. Must be called as a bare command
+# (no subshell) so the assignments survive.
+_state=""
+_display=""
+
+chip_recall() {
+  local pidfile="$PROJECT_ROOT/.recall/watch.pid"
+  local repo="$PROJECT_ROOT/.recall/repo.git"
+  if [ ! -f "$pidfile" ]; then _state="red"; _display="${RED}recall${RESET}"; return; fi
+  local pid
+  pid=$(cat "$pidfile" 2>/dev/null) || pid=""
+  if [ -z "$pid" ] || ! kill -0 "$pid" 2>/dev/null; then
+    _state="red"; _display="${RED}recall${RESET}"
+    return
+  fi
+  if [ -d "$repo" ]; then
+    local last
+    last=$(git --git-dir="$repo" log -1 --format=%ct 2>/dev/null)
+    if [ -n "$last" ]; then
+      local now diff age
+      now=$(date +%s); diff=$((now - last)); age=$(fmt_age "$last")
+      if [ "$diff" -gt 21600 ]; then
+        _state="orange"; _display="${ORANGE}recall(${age})${RESET}"
+      else
+        _state="green"; _display="${GREEN}recall(${age})${RESET}"
+      fi
+      return
+    fi
+  fi
+  _state="green"; _display="${GREEN}recall${RESET}"
+}
+
+chip_chart() {
+  local freshness="$PROJECT_ROOT/.launchsecure/graphs/.freshness.json"
+  if [ ! -f "$freshness" ]; then _state="red"; _display="${RED}chart${RESET}"; return; fi
+  local last
+  last=$(grep -o '"lastFullRegenAt"[^,}]*' "$freshness" | head -1 | sed 's/.*"\([0-9TZ:.+-]*\)".*/\1/')
+  local lock="$PROJECT_ROOT/.launchsecure/launch-chart.lock"
+  local color="$ORANGE"; local state="orange"
+  if [ -f "$lock" ]; then
+    local pid
+    pid=$(pid_from_lockfile "$lock")
+    if [ -n "$pid" ] && kill -0 "$pid" 2>/dev/null; then
+      color="$GREEN"; state="green"
+    fi
+  fi
+  if [ -n "$last" ] && [ "$last" != "null" ]; then
+    local epoch age
+    epoch=$(iso_to_epoch "$last")
+    if [ -n "$epoch" ]; then
+      age=$(fmt_age "$epoch")
+      _state="$state"; _display="${color}chart(${age})${RESET}"
+      return
+    fi
+  fi
+  _state="$state"; _display="${color}chart${RESET}"
+}
+
+chip_deck() {
+  local lock="$PROJECT_ROOT/.launchsecure/launch-deck.lock"
+  if [ -f "$lock" ]; then
+    local pid; pid=$(pid_from_lockfile "$lock")
+    if [ -n "$pid" ] && kill -0 "$pid" 2>/dev/null; then
+      _state="green"; _display="${GREEN}deck${RESET}"; return
+    fi
+  fi
+  _state="orange"; _display="${ORANGE}deck${RESET}"
+}
+
+chip_council() {
+  local lock="$PROJECT_ROOT/.launchsecure/launch-council.lock"
+  if [ -f "$lock" ]; then
+    local pid; pid=$(pid_from_lockfile "$lock")
+    if [ -n "$pid" ] && kill -0 "$pid" 2>/dev/null; then
+      _state="green"; _display="${GREEN}council${RESET}"; return
+    fi
+  fi
+  _state="orange"; _display="${ORANGE}council${RESET}"
+}
+
+show_list=$(echo "$show" | tr ',' ' ')
+total=0
+up=0
+out=""
+for d in $show_list; do
+  case "$d" in
+    recall) chip_recall ;;
+    chart)  chip_chart ;;
+    deck)   chip_deck ;;
+    council) chip_council ;;
+    *) continue ;;
+  esac
+  total=$((total + 1))
+  [ "$_state" = "green" ] && up=$((up + 1))
+  if [ "$compact" = "0" ]; then
+    if [ -z "$out" ]; then out="$_display"; else out="${out} · ${_display}"; fi
+  fi
+done
+
+if [ "$compact" = "1" ]; then
+  if [ "$total" -eq 0 ]; then exit 0; fi
+  if [ "$up" -eq "$total" ]; then
+    printf '%smcp %d/%d%s' "$GREEN" "$up" "$total" "$RESET"
+  else
+    printf '%smcp %d/%d%s' "$RED" "$up" "$total" "$RESET"
+  fi
+else
+  printf '%s' "$out"
+fi

package/scaffolds/statusline/statusline-wrapper.sh

@@ -0,0 +1,50 @@
+#!/usr/bin/env bash
+# launch-kit statusline wrapper.
+# Runs the user's original statusline command, then appends MCP chip output.
+# Reads Claude Code's statusline JSON from stdin once, fans it out.
+#
+# The original command is stored under `_launchKitStatuslineOriginal.command`
+# in ~/.claude/settings.json (written by `launch-kit statusline activate`).
+# `launch-kit statusline deactivate` restores it to `statusLine.command`.
+set -u
+
+input=$(cat)
+settings="$HOME/.claude/settings.json"
+
+original_cmd=""
+if [ -f "$settings" ] && command -v jq >/dev/null 2>&1; then
+  original_cmd=$(jq -r '._launchKitStatuslineOriginal.command // empty' "$settings" 2>/dev/null || true)
+fi
+
+original_output=""
+if [ -n "$original_cmd" ]; then
+  original_output=$(printf '%s' "$input" | bash -c "$original_cmd" 2>/dev/null || true)
+fi
+
+cwd=""
+if command -v jq >/dev/null 2>&1; then
+  cwd=$(printf '%s' "$input" | jq -r '.workspace.current_dir // .cwd // empty' 2>/dev/null || true)
+fi
+
+chips=""
+if [ -x "$HOME/.launchsecure/statusline-mcp.sh" ]; then
+  # Build args array conditionally; `set -u` + empty `"${args[@]}"` would
+  # error on bash 4 (default macOS bash), so test length before expanding.
+  args=()
+  [ -n "${LK_STATUSLINE_SHOW:-}" ] && args+=("--show=$LK_STATUSLINE_SHOW")
+  [ "${LK_STATUSLINE_COMPACT:-0}" = "1" ] && args+=("--compact")
+  if [ "${#args[@]}" -eq 0 ]; then
+    chips=$(LK_STATUSLINE_CWD="$cwd" "$HOME/.launchsecure/statusline-mcp.sh" 2>/dev/null || true)
+  else
+    chips=$(LK_STATUSLINE_CWD="$cwd" "$HOME/.launchsecure/statusline-mcp.sh" "${args[@]}" 2>/dev/null || true)
+  fi
+fi
+
+sep=$'\033[2m | \033[0m'
+if [ -n "$original_output" ] && [ -n "$chips" ]; then
+  printf '%s%s%s' "$original_output" "$sep" "$chips"
+elif [ -n "$original_output" ]; then
+  printf '%s' "$original_output"
+elif [ -n "$chips" ]; then
+  printf '%s' "$chips"
+fi