Log — Capture Front Door

Muscle-memory capture, run gateway-inline in the calling session — no dispatch. Takes one observation or a batch, classifies each into BUG / DEBT / GAP, checks against open cards, and writes each clear entry as docs/work/{ID}.md in docs/work/TEMPLATE.md's shape. Capture is unconditional about worth (bugs, debt, design gaps, unverified ideas all land); the real/worth/now call runs at /super-bootstrap:triage on pickup.

All new cards route through this door — user-initiated and Claude-initiated captures alike. Hand-copying docs/work/TEMPLATE.md with an ID from step 4's generator is the same door, by hand.

When it fires

• User — explicit /super-bootstrap:log <observation>, or natural-language "log this / track that / note this down". Bare /super-bootstrap:log → ask what to capture (one line).
• Claude — its own captures: a bug spotted mid-task, out-of-scope findings a review or returned subagent surfaced. Batch them into one pass.

A card is owed only for deferred or dropped work — work that exits the current flow incomplete. Work completed in-flow carries no card debt. The trigger is completion-state (observable), not worth.

Out of lane: root-cause investigation (the triage lane), card deletion (the resolving session), rewriting existing blocks (threads are append-only). Feature ideas and unverified hunches are in lane — they log as GAP.

Procedure

1. Read docs/work/README.md — categories and thread contract. README absent → write nothing; route: "run /super-bootstrap:harness-bootstrap to plant the work substrate, then re-log." When present: run bash <skill-base>/assets/closed-forks.sh from the repo root, issued as its own tool call — <skill-base> is the Base directory for this skill: path surfaced at invocation. It resolves docs/decisions.md § Closed Forks to one line per row, or to absent, and ends with the outcome checklist step 2 emits. A non-zero exit names the file and the cause → surface the script's message and hold for the user's pick: they fix the doc and re-log, or the batch logs on with decisions.md § Closed Forks — unresolved as each entry's step-2 outcome. The doc fix is the user's. Read docs/parked.md's header and docs/outward/README.md's header too — each skipped silently when absent.
2. Classify each entry — BUG (broken behavior) / DEBT (works but rotting) / GAP (design hole or unverified idea). Three gates per entry, in order:
   • Mover — ask once, whose hands move the next step — the repo's, yours, or an outside party's? The repo → a card, through the gates below. Yours or an outside party's (a taste sitting, a line-by-line review, a portal registration, a reply to wait for) → an outward thread at docs/outward/{ID}.md when the folder exists, its OUT ID from step 4: origin block only, docs/outward/TEMPLATE.md's shape (H1 # {ID} — {summary}, then Logged: / Source: / Next move: / Waiting on: / Repo tail — fires on:, plus Owning card: when a card waits on that step; drop the template's leading comment). Ask for the repo tail in one line whenever the observation doesn't name one — the answer lands the thread; only an item with no tail at all drops, per the container README. No docs/outward/ but a flat docs/outward.md → the container predates the folder shape: write nothing for that entry and route: "run /super-bootstrap:harness-bootstrap — its sync splits docs/outward.md into docs/outward/ — then re-log." Neither present → a card whose Problem: line names waiting on {party}, which the board's wait override reads. Mixed → split at capture: the repo's remainder is the card, the other step the thread, carrying Owning card: when the card waits on that step.
   • Card shape — every card names something to do, fix, or decide. A standing-watch entry (monitor / revisit later) rephrases as an action; names a trigger + docs/parked.md exists → park as a ### {ID} — {summary} entry, its PARK ID from step 4; otherwise return it with the real fork: wire an observer at the fire-moment, or drop.
   • Closed forks — hold each entry against the rows step 1's script printed, and emit one outcome line per entry that reaches this gate, in the reply, whatever the read found: decisions.md § Closed Forks — collides: <row> / decisions.md § Closed Forks — no collision / decisions.md § Closed Forks — absent (or — unresolved, per step 1's pick). Collides → surface the fork (open the row for its Because + Ref) instead of logging; genuinely new counter-evidence → ask as a reopen question. Never silently re-log a closed direction.
3. Dedup — the call is the user's, not capture's. Grep the open cards — plus the docs/outward/OUT-*.md threads when present — for each entry's subject (title keywords, Area: paths for cards; H1 summary or Repo tail path for outward threads); open a suspected match to confirm coverage. A suspected dup — pure duplicate or duplicate-with-new-fact alike — writes nothing yet: surface the entry, the covering card or thread (ID + the covering line), and the pick — amend (append the new fact) / new card (genuinely distinct) / drop. Execute the pick: amend → append ## Amendment — {date} · {source} at the owning card's or outward thread's end, the new fact alone, nothing restated — on an outward thread whose Next move / Waiting on the fact changes, that block restates those two lines and leads from there.
4. Assign IDs — run bash <skill-base>/assets/new-id.sh <CAT>... from the repo root, once for the whole batch, issued as its own tool call: one category argument (BUG / DEBT / GAP / OUT / PARK) per file about to be written (a mixed entry = card + OUT), in entry order. It prints one ID per argument, in the same order — {CAT}-xxxx, a random 4-char suffix the script redraws on any ID already in the repo or its commit messages. Use each printed ID verbatim for its entry's file name and heading. Never compose, edit, or increment an ID by hand, and never derive one from the live files or another ID — a hand-made ID is the cross-clone collision the generator exists to prevent. A non-zero exit → surface its message and write nothing. Legacy numeric IDs (GAP-101) on existing cards stay valid; there is no counter to bump.
5. Write each clear entry as docs/work/{ID}.md — origin block only, TEMPLATE.md's shape (H1 + Logged: / Source: / Problem: / Area: / Prior:; drop the template's leading comment). Stamp today's date. Capture the claim faithfully — this is the richest-context moment; the pickup session reads it cold. Prior: is a one-line suspected cause at most — later work falsifies it. Scale-module fact fields ride the origin block as further field lines when known at capture.
6. An entry too thin to classify or phrase as a readable card → hold it unwritten and ask its one discriminating question (e.g. "broken now, or works-but-suboptimal?"); the answer lands it.

Rules

• Batch over loop. Classify the whole batch in one pass; clear entries land immediately, dup and too-thin entries surface together — never block clear writes waiting on one fork.
• Capture, don't gate. Write every classifiable, non-duplicate entry — unverified ideas included. Worth is triage's call at pickup.
• Append, never overwrite. Origin blocks are frozen at capture; the only write to an existing card is a new dated ## Amendment at end of file — and only on the user's amend pick.
• Write cards, never investigate. No root-cause prose, no fix design.
• Minimum questions. One discriminating question per genuinely ambiguous entry — capture dies if logging becomes an interrogation.