deskwork

Provision the fleet control plane's accepted bearer token, or serve the plane HTTP endpoint (stackctl plane provision-token | serve) — the fleet control plane a single operator's sidecars uplink to (specs/036-fleet-control-plane). Wraps `stackctl plane`.

Elect and run the per-installation sidecar daemon that uplinks telemetry to the fleet control plane and receives commands over SSE (stackctl sidecar run) — specs/036-fleet-control-plane. Wraps `stackctl sidecar`.

Run a Spec Kit spec by dispatching each task to a fresh, right-sized subagent at the model its declared [tier:] resolves to (model-sized dispatch), with deskwork governance firing automatically afterward (cross-model audit-barrage + finding lift)

Author a NEW Spec Kit spec for a new feature, in-session — drive native /speckit-specify and the downstream authoring chain via the in-session agent, confirming state with stackctl spec-check (spec-authoring only; does not create worktree/docs infra)

Open the designing phase for a roadmap item — an opinionated frontend that drives a swappable design backend (default superpowers:brainstorming) IN-SESSION, sets the design: pointer on entry, re-injects capture-over-YAGNI, routes the handoff to /stack-control:define, and writes the installation-anchored design record the design-to-spec gate checks

Close a shipped roadmap item and everything it contains — the operator-confirmed post-ship terminal move. Shows the full transitive cascade (the item's part-of subtree's recorded closes: ids) as a dry-run, prompts you to confirm (and, when self-hosting, to validate the installed release), then runs `roadmap advance --to closed` which closes the deduped backlog ids and advances the item to the terminal `closed` phase. Never closes automatically.

The one on-rail ship step: govern-converged precondition → open PR → operator confirms CI green → merge → non-discretionarily record status:shipped (fire graduate). Welds the merge to recording shipped so there is no skippable second step. No skip/defer/shortcut branch.

Bounded retention for the audit-barrage run dirs under .stack-control/audit-runs (stackctl audit-runs) — list the accumulated run dirs with their sizes, or prune them by keep-last-N or older-than-T-days (dry-run unless --apply). The barrage never deletes its run dirs, so they grow without bound; this is the sanctioned sweep.

Structured slush pile for found-mid-work bugs/gaps, kept deliberately separate from the curated ROADMAP.md. Capture a found bug/gap in ONE move (capture ≠ scope) and return to your task; list the pile; seed it once from open GitHub issues; route audit-barrage parked residuals into it; promote an item into the feature-rigor tier (record-only) when it earns the full spec-driven treatment. Triage/inspection use the configured backlog backend when needed. Wraps `stackctl backlog`.

Capture-only session close. Assembles a journal entry (auto-deriving the mechanical/quantitative sections from git log, leaving the narrative for the agent), captures surfaced tooling friction, runs an advisory clone-snapshot, surfaces the backlog items that progressed (evidence; operator owns the status transition), then commits AND pushes the doc changes. No refuse-to-end gates. Wraps `stackctl session-end`.

Refine an EXISTING Spec Kit spec in place, in-session — report state with stackctl spec-check, then run the edit/iterate/review loop (/speckit-clarify, re-/speckit-plan, re-/speckit-tasks, edits) reusing the current spec dir, bringing it to a runnable state

Assert the stack-control front door has not silently regressed (stackctl check-front-door). Over the derived fronted-operations registry it checks four invariants: every operation's sanctioned /stack-control:* skill exists, every verb/sub-action emits working --help, every mutating operation is mediation-registered (read-only ops exempt), and skill↔verb parity holds in both directions. Read-only; exits 0 on a clean surface, non-zero naming each gap.

Reason over and curate the stack-control roadmap — a governed heading-keyed DAG of work items with first-class depends-on / part-of / deferred-until edges. Answer next-ready / why-blocked / what-this-blocks, derive order, render a mermaid graph, reconcile against on-disk spec progress (report-only), and mutate (add / advance / decompose / reclassify / defer / cluster / group / close-related). Dry-run first, then apply. Wraps `stackctl roadmap`.

Read-only boot orientation for a fresh agent session. Resolves the enclosing stack-control installation and reports the roadmap ready/blocked frontier, the active Spec Kit spec's chain position (+ the next /speckit-* step), the latest journal entry, the open local backlog, and a branch-staleness advisory — then STOPS. No authoring or implementation step fires. Wraps `stackctl session-start`.

Keep a live governed document lean by moving its terminal-status items into a sibling archive file (with an in-archive provenance ledger). Dry-run first, then apply on confirmation. Wraps `stackctl archive`.

Keep a live governed document correct: check it is well-formed, well-ordered, and properly archived, recognize (never run) a declared reconciliation seam, and report ledger↔archive coherence. Dry-run first, then apply on confirmation. Wraps `stackctl curate`.

Low-friction insight capture for the governed design inbox: capture an out-of-sequence idea in ONE move mid-thread (capture ≠ scope), then triage in a separate deliberate pass — promote (record a graduation target, reuse existing creators) or drop (record a reason). List entries; keep lean with curate/archive. Dry-run first, --apply to write. Wraps `stackctl inbox`.

Check the portable stack-control release contract and use the shared release surface instead of host-owned release semantics.

Scaffold a stack-control installation in a project: write .stack-control/config.yaml and the governed working files (ROADMAP.md, DESIGN-INBOX.md, the backlog store, the program audit log) the inbox/roadmap/backlog/governance verbs read through. Non-destructive + idempotent; dry-run first, --apply to write. Fails loud on a malformed required file. Wraps `stackctl setup`.

Return a named archived item to its live governed document at its declared-order position, removing its provenance-ledger entry. The reversibility half of archive. Dry-run first, then apply on confirmation. Wraps `stackctl unarchive`.

Draft or maintain the project's design-language spec — the hand-authorable markdown artifact that anchors visual identity (palette/type/spacing tokens + signature components, each rule linked to live CSS + ≥1 example). Hand-authoring is the default and needs NO engine; the optional /frontend-design accelerator drafts from approved wireframe intent and is judged by the same check-design-spec gate.

Govern the just-implemented work — cross-model audit-barrage + lift findings

Release the deskwork monorepo (bump → tag → push → CI publishes → local assert + smoke). Hard-gated procedure with operator pauses at version, post-bump diff, tag message, and final push. CI publishes via npm Trusted Publisher (OIDC); the skill runs assert-published + marketplace smoke LOCALLY after publish completes (faster turnaround than waiting on GH Actions minutes). Pass `--skip-publish-wait` to bypass local assert + smoke when the operator already published manually via `make publish`. Project-internal — for monorepo maintainers, not adopters.

Run the hard-gated deskwork monorepo release flow: preconditions, version bump, operator-side publish, smoke, tag, and atomic push.

Mark a feature complete by moving its docs to `003-COMPLETE`, updating tracking docs, and closing related issues before merge.

Interview the user to define a feature, then write a structured feature-definition draft under `.agents/.tmp/` for later setup.

Extend an in-progress feature by appending scope and new phases, then get PRD/workplan approval again before filing new issues.

Show the canonical feature lifecycle and summarize the current state of in-progress features without starting work.

Drive the implementation loop by selecting the next workplan task, verifying PRD/workplan approval, doing the work, and updating progress.

Create a parent feature issue and per-phase implementation issues from the approved workplan, then link them back into the docs.

Resume a feature by reading its docs, issue state, and last session notes, then propose the next step without starting implementation.

Review recent feature changes for bugs, regressions, and missing tests, then report findings without fixing them.

Create feature infrastructure: branch, worktree, and docs files from a prior feature-definition draft.

Prepare a feature for merge by verifying completion, running tests and review, pushing the branch, and opening a PR without merging it.

Govern the just-implemented work — cross-model audit-barrage + lift findings

Author a deliberately lo-fi wireframe for a named UI surface change — operator-driven, sketch-kit-based, and lint-enforced (zero check-wireframe findings before the draft may be presented). The optional /frontend-design accelerator routes through the same lint.

Fan the parallel discovery agents over a feature's PRD + module-root and emit a schema-validated scope-manifest.yaml (stackctl scope-inventory) — upfront surface discovery BEFORE implementation; surfaces novel/unmatched shapes deterministically so a green run is NOT read as 'no novel anti-patterns'

Re-run the discovery agents against an operator complaint mid-implementation and surface the NEW surfaces the original scope-inventory missed (stackctl scope-widen) — additive delta against the prior manifest; default dry-run, --apply to merge

Find per-codebase files that should import a canonical primitive but don't (stackctl check-adopters) — walks adopter-manifests.yaml, flags glob-matched files that hold out from the canonical `from` path, honoring exceptions and tracked-holdouts; scoped to the enclosing stack-control installation; an empty or absent registry is a clean no-op (exit 0); --gate-mode exits 1 on holdouts

Scan the per-codebase source tree for legacy shapes registered in anti-patterns.yaml (stackctl check-anti-patterns) — finds code matching a registered legacy fingerprint (regex / multi-pattern proximity) scoped to the enclosing stack-control installation; an empty or absent registry is a clean no-op (exit 0); --gate-mode exits 1 on findings