Jei-sKappa

discussion

Interview the user to settle decisions into the thread's log, ADRs, and glossary.

open-thread

Open a durable thread on disk from a rough idea, a tracker ticket, or a roadmap entry.

open-ticket

File a rough idea as a tracker ticket whose body reads as a thread's genesis narrative.

resolve-pending-decisions

Settle the thread's queued pending decisions with the user and write each outcome into the thread.

archive-thread

Relocate a thread into docs/threads/archive/ so the active docs/threads/ listing shows only live work; use when the user explicitly asks to archive a finished or abandoned thread.

Inspect what a thread has produced, surface any unresolved delivery signals, then hand the current branch off the way the user chooses — create a PR, merge into a confirmed target, or leave as-is; use when work is ready to deliver and you want an evidence-backed branch handoff.

Web & Frontend Listed

whats-next

Read a thread's observable state, then advise plausible next actions without inferring hidden operations or writing anything; use when you want a quick, evidence-based read on where a thread stands and what to do next.

implement-plan-with-subagents

Execute a strict plan folder task by task through implementer and reviewer subagents, committing per task.

implement-plan

Execute a strict plan folder task by task on the current working tree, committing per task.

implement

Carry a plan folder, an artifact, an issue, or a prompt to working code on the working tree, committing per derived task.

merge-artifacts

Reconcile two or more competing candidate drafts of one artifact into a single canonical thread-root artifact, folding every candidate's unique content and queueing any genuine design divergence that needs a human decision; use when a multi-draft bake-off must be collapsed into one artifact.

plan-brief

Turn the thread's design into a one-screen plan.md inside a fresh stamped plan folder.

allocate-thread

Use only when an invoking caller supplies a complete caller-authorization block for a new thread and a normalized thread folder must be allocated — create `docs/threads/<YYMMDDHHMMSSZ-slug>/`, write `seed.md` from the supplied fields, and eagerly create a header-only `decisions.md`.

append-roadmap-feedback

Use only when an invoking caller supplies a descendant-thread discovery carrying parent- or sibling-level impact together with its parent roadmap reference, and that discovery must be appended as the next record in the parent thread's `roadmap-feedback.md`.

emit-pending-decisions

Use only when an invoking caller supplies open human decisions with their producing context and needs them queued as a `.pending-decisions/` bundle for a human to settle later; never for defects, observations, or report material — only genuine open human decisions.

emit-pending-review

Use only when an invoking caller supplies already-validated, evidenced review findings for a target and needs them recorded for later attention — allocate a uniquely named bundle under the active thread's `.pending-reviews/` folder and write its routing header and severity-ordered findings.

Data & Documents Listed

update-implementation-report

Use only when an invoking caller supplies a verified current implementation outcome and the thread's singleton `implementation-report.md` must be created or merged in place to describe that outcome.

propose

Turn a rough prompt or referenced artifact into a freeform, direction-setting proposal.md at a thread root; use when a unit of work needs its direction sketched and written down before it is specified.

reconcile-plan

Make a thread's strict plan — its plan.md index and plan-tasks/ briefs — faithfully executable against the spec that governs it, repairing plan faults in place and queueing anything that needs a fresh human decision; use when a plan should be made to satisfy its spec.

reconcile-proposal

Align a thread-root proposal.md with the decisions that govern it — correcting supported discrepancies in place and queueing anything that needs a fresh human decision; use when a proposal should be made faithful to its thread's established intent.

reconcile-roadmap

Make a thread-root roadmap.md and its decomposition faithful to the decisions that govern the thread — correcting contradictions, adding omitted decisions, removing unsupported commitments, repairing incomplete child briefs, and queueing any decomposition change that alters human intent; use when a roadmap should be brought back in line with its thread's established intent.

Testing & QA Listed

reconcile-spec

Make a thread-root spec.md a lossless, additive-free expression of the decisions that govern it — adding omitted decisions, correcting contradictions, removing invented commitments, and queueing anything that needs a fresh human decision; use when a spec should be made faithful to its thread's established intent.

review-code

Judge code on its own merits — quality, safety, idioms, and testability.

review-implementation

Check delivered work against the thread's durable intent and test the report's account of it.

review-roadmap

Read a thread-root roadmap.md as a decomposition handoff and judge whether each child brief could become an independently executable thread without inventing intent, reporting any findings as a single pending-review bundle; use when a roadmap should be checked for handoff readiness before its children are materialized.

review-spec

Judge a thread's spec.md as a downstream handoff and record any findings.

materialize-roadmap-threads

Turn a roadmap's child briefs into child threads idempotently — create a thread for each brief that has no materialized reference, skip and verify the ones that do, and stamp each new thread's reference back into its brief; use when a roadmap.md is settled and its children need opening on disk.

roadmap

Author a settled direction into a project-level roadmap index of ordered entries.

Testing & QA Listed

spec

Author the thread's design truth into a handoff-grade spec.md, and amend it in place on re-invocation.

close-thread

Close a thread by landing its ADRs and glossary terms into the project layer.

check-plan

Check a plan folder against the thread's spec and correct in place every fault the spec settles.

plan-strict

Turn the thread's design into a strict-granularity plan, an index plus one dispatchable brief per task.

consult-adrs

Read the project's decision records before acting on any work that could rest on a project decision or contradict one — before reading a thread's artifacts, designing, specifying, planning, implementing, reviewing, or closing. Do not invoke it when `docs/adr/` is absent or holds no `.md` file, it would be pointless.

consult-glossary

Read the project's glossary before writing any prose, name, or identifier in a project that holds `docs/glossary.md`, and whenever a term's meaning is in doubt. Do not invoke it when `docs/glossary.md` is absent or empty, it would be pointless.