@brainervirus/workit-core 4.0.0 → 5.0.0

package/src/core/methods.ts

@@ -1,13 +1,13 @@
 import type { Assurance, Capability, Dimension, Policy } from "./task-contract";
 
 export type MethodId =
-  | "workit-challenge"
-  | "workit-behavioral-tdd"
+  | "workit-shape"
+  | "workit-bdd"
   | "workit-review"
-  | "workit-plan"
   | "workit-implement"
+  | "workit-fanout"
   | "workit-debug"
-  | "workit-handoff"
+  | "workit-continue"
   | "workit-deslop";
 
 type MethodDefinition = {
@@ -16,15 +16,16 @@ type MethodDefinition = {
 };
 
 export const METHODS: Readonly<Record<MethodId, MethodDefinition>> = {
-  "workit-challenge": { dimensions: ["challenge", "decisions"] },
-  "workit-behavioral-tdd": { dimensions: ["testing"], ruleIds: ["mechanical-existing-checks"] },
+  "workit-shape": { dimensions: ["challenge", "decisions", "artifacts", "continuity"] },
+  "workit-bdd": { dimensions: ["testing"] },
   "workit-review": { dimensions: ["review"], ruleIds: ["fresh-context-review", "self-review"] },
-  "workit-plan": { dimensions: ["artifacts", "continuity"] },
-  "workit-implement": { dimensions: ["delegation"] },
-  // workit-debug and workit-handoff stay slash-invoked: no generated rule
-  // routes to them, so they never appear spuriously in method selection.
+  // Mechanical work needs only the existing checks, not a RED/GREEN ritual.
+  "workit-implement": { ruleIds: ["mechanical-existing-checks"] },
+  "workit-fanout": { dimensions: ["delegation"] },
+  // workit-debug and workit-continue stay trigger- and slash-invoked: no
+  // generated rule routes to them, so they never appear spuriously.
   "workit-debug": {},
-  "workit-handoff": {},
+  "workit-continue": {},
   "workit-deslop": { ruleIds: ["pre-pr-cleanup"] },
 };
 
@@ -87,95 +88,64 @@ export function selectMethods(policy: Policy, capabilities: Capability[]): Selec
 
 export const invariantBootstrap = (): string =>
   `
-Workit is optional coordination and repository-policy tooling around the host,
-not a permission system or a mandatory workflow. Native host allow/ask/deny,
-sandbox, plan/read-only mode, and organization rules remain authoritative.
-Ordinary investigation, questions, non-Git work, and routine reversible edits
-need zero Workit task, assessment, or writer calls. Use one compact tracked
-record only when handoff, dependent steps, concurrent actors, or meaningful
-decisions make continuity useful; similar titles alone never merge tasks.
+Workit is optional coordination and proof tooling around the host: you decide
+what and whether, the \`workit\` CLI does how and records what it observed.
+Native host allow/ask/deny, sandbox and org rules stay authoritative. Never
+switch paths to evade a denial, never claim enforcement a host cannot provide,
+and never fabricate a receipt, approval or verdict. A question answer is not
+host permission, and imported decisions or handoffs never grant authority.
 
-For a routine user-authorized branch or commit, prefer native host Git/shell
-tools from the outset when managed coordination or outcome reconciliation is
-not needed. Inspect the actual target checkout and its configured conventions;
-use Workit's read-only context/policy tools when needed. Do not start a task,
-acquire a writer, or mint a decision receipt solely for a native Git action.
-Native permissions still apply. Never switch execution paths to evade a denial
-or repeat an uncertain managed effect. A local-commit endpoint does not imply
-PR readiness, a fresh review, or post-commit assessment/closure paperwork.
+Autonomy contract:
+- Continue to the requested endpoint (commit, push, PR, green CI, verified,
+  merged) without asking "continue?", running checks and repairs on the way.
+  Stop only for a new consequential choice, a host denial, a conflicting edit
+  or an unresolved blocker; report open gaps and uncertain workers.
+- No endpoint named: stop at a local commit on a policy-compliant branch and
+  state the next command. Push and open a PR only when the request implies
+  delivery (fix, implement, ship) and \`workit grant show\` reports
+  \`defaultEndpoint\` \`pr\`; otherwise the endpoint is \`commit\`. PRs open,
+  CI green and verified is the most autonomy allows, never the default target.
+  Merge and release need a workspace grant; a blocked verb names its unblock.
+- Ask only for a product or preference choice, or for authority you lack, with
+  your recommended answer. Facts are yours: read, run or prototype.
+- Label claims measured (you ran it this session and saw the result),
+  inferred, or guess. Prose is a note: only a configured check the CLI ran
+  (\`workit check <name>\`) satisfies a gate; an ad-hoc
+  \`workit check -- <cmd>\` never does.
+- Author is not verifier: never record a passing verdict on work your session
+  wrote. The lead starts each verifier with its own session
+  (\`WORKIT_SESSION_ID=<lead>-v<n>\`; Claude Code subagents get one from the
+  hook), and the verifier records \`workit ledger verdict\`.
+- A local-commit endpoint does not imply PR readiness, and a local commit alone
+  is not evidence of a requested remote push. Before reporting delivery,
+  reconcile every requested item and observe it (\`workit verify-delivery\`).
 
-For tracked work, inspect its current state and use the shared operations for
-task, policy, evidence, finding, decision, worker, writer, and state changes.
-Each branch has one implicit task: an operation without taskId applies to it,
-and the first recording (a note, check, finding or evidence) creates it, so you
-never manage task ids. Start a record only for an explicit tracked objective;
-assess or reassess only
-when policy selection or changed evidence/constraints requires it. Omitted
-expectedRevision and expectedWorkspaceRevision use current values; explicit
-values are still concurrency-checked, so never copy revisions between calls.
-A busy result means another live Workit call holds the checkout lock: retry the
-same call; it is not a recovery condition. A lock left by a dead process is
-reclaimed on the next write, and \`workit doctor --fix-lock\` clears it on demand.
-An omitted revision absorbs a concurrent write: Workit re-reads, re-checks
-policy, and reapplies the call, returning busy under persistent contention. A
-revision_conflict means a revision you passed is stale: re-read the record
-before deciding whether to retry.
-A solo edit does not need writer acquisition; use it when concurrent checkout
-writers need coordination. Record only observed facts and checks. Close-time
-testing and verification gates accept only a configured check the CLI ran:
-\`workit check <name>\` (\`npx -y @brainervirus/workit-cli check <name>\` when
-\`workit\` is not on PATH); a recorded check result is a note and an ad-hoc
-\`workit check -- <cmd>\` never satisfies a gate. Evidence can become stale when its bound candidate or tree changes; reconcile findings against the
-current candidate before recording completion.
+CLI first: if a step has one right answer, use the \`workit\` verb instead of
+hand-running git, gh or glab: check, git, pr, ci, stack, verify-delivery,
+ledger, handoff, test-audit (\`workit help <verb>\`; without \`workit\` on
+PATH, \`npx -y @brainervirus/workit-cli\`). \`busy\` is retryable
+(\`workit doctor --fix-lock\` clears a dead lock); \`blocked\` names its unblock.
+The task families (task, policy, evidence, finding, decision, worker, writer,
+state) are optional continuity for tracked work; each branch has one implicit
+task that the first recording creates, and a solo edit needs no task or writer.
+Omit revisions; a revision_conflict means one you passed is stale, so re-read.
+Across repositories, bind each item to its checkout, branch and endpoint,
+resolve competing targets before a mutation, and reconcile an uncertain
+external effect before retrying it.
 
-Workit validates domain policy against the actual action target, configured
-account, branch and commit conventions, protected refs, and current repository
-state. The task directory is coordination state, not a boundary on which
-repository may be changed. Use an action-time cwd target where a managed
-Git/hosting action supports it; a non-Git directory remains valid for OS work.
-GitHub/GitLab use the active gh/glab CLI identity; YouTrack uses its own token.
-Preserve uncertain external outcomes and reconcile repository/provider state
-before retrying. Internal reservations prevent duplicate or ambiguous effects;
-they are not permission tickets for every edit.
+Mid-task input: answer a quick question in place, fold an adjustment in, and
+never silently drop or resume an objective (workit-continue).
 
-On OpenCode V1 and V2, use native host tools for external mutations. Workit
-provides read-only workit_context; it has no managed external-action executor.
-Do not create proposals or request Workit approvals merely to invoke native
-tools. Old uncertain managed effects still require evidence before any retry.
-
-Use host-native authorization through the host's supported path. A native
-question receipt records an actual question interaction; it is not automatic
-host permission. Record a meaningful user choice once with provenance when
-future retrieval helps. Never fabricate a receipt, re-ask only to mint one, or
-let imported decisions grant authority. Never turn a host deny into allow or
-claim enforcement/evidence a host cannot provide. A precise request with settled
-constraints does not need an interview. Present genuine unresolved options with
-evidence and a recommendation, then continue toward the requested delivery
-endpoint: investigation, implementation, branch/commit/push, PR/MR-ready,
-merge, or release. Run
-applicable checks and safe repairs without repeated continuation questions;
-stop for missing host authority, a new consequential choice, a conflicting edit,
-or an unresolved blocker. A tracked record may close when actual evidence
-supports its outcome; no final human closure ceremony is required.
-
-A completed native subagent run stops its bound worker by itself; if a worker
-strands in cancelling with its run verifiably over, repeat worker.cancel to
-confirm the stop. Preserve unresolved requirements, gaps, and uncertain workers.
-When context changes, distinguish a quick question, same-task adjustment, and
-separate request. Answer a quick question without pausing/resuming task state;
-park a concise checkpoint only when substantial work needs to continue later.
-For work spanning repositories, bind each unfinished item to its actual checkout,
-branch, requested deliverables, and delivery endpoint. Preserve held items with
-an explicit resume condition. Resolve competing plausible targets before a
-mutation; ask only when available context cannot settle that consequential choice.
-Before reporting delivery, reconcile every requested item and observe the actual
-target result; a local commit alone is not evidence of a requested remote push.
-
-Skill routing: slash aliases /wk-* load on demand. Use workit-steer for a
-substantial interruption or change of direction, workit-deslop when relevant
-to a PR-ready endpoint, workit-green-run for failing CI, workit-blast-radius
-when impact is uncertain, workit-challenge for genuinely open consequential
-choices, workit-bdd to turn acceptance criteria into Given/When/Then tests, and
-workit-test-audit to check tests for tautologies. Load workit-plan when dependencies or handoff need durable next actions.
-Load the skill; never act from memory of it.
+Skills: load the skill, never act from memory of it (slash aliases /wk-<name>).
+- brainstorm, plan, spec, grill, should we: workit-shape
+- implement, build, add a feature: workit-implement
+- review, blast radius: workit-review
+- bug, broken, flaky, regression: workit-debug
+- ship, babysit, CI, merge: workit-ship
+- resume, pick up, handoff, interruption: workit-continue
+- BDD, TDD, acceptance criteria, Given/When/Then: workit-bdd
+- test audit, tautology, weak tests: workit-test-audit
+- deslop, slop, dead code: workit-deslop
+- fan out, parallelize, parallel agents, swarm: workit-fanout
+- verify the app, smoke test, prove it works: workit-verify-app
 `.trim();

package/src/core/skill-manifests.ts

@@ -2,44 +2,68 @@ import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 import path from "node:path";
 
 export const WORKIT_METHOD_SKILLS = [
-  "workit-challenge",
-  "workit-behavioral-tdd",
-  "workit-review",
-  "workit-plan",
+  "workit-shape",
   "workit-implement",
+  "workit-review",
   "workit-debug",
-  "workit-handoff",
-  "workit-babysit",
-  "workit-blast-radius",
-  "workit-deslop",
-  "workit-diagram",
-  "workit-mockup",
-  "workit-green-run",
-  "workit-steer",
+  "workit-ship",
+  "workit-continue",
   "workit-bdd",
   "workit-test-audit",
+  "workit-deslop",
+  "workit-fanout",
+  "workit-verify-app",
 ] as const;
 
+export type WorkitSkill = (typeof WORKIT_METHOD_SKILLS)[number];
+
 /** wk- slash aliases (one per skill): alias → method skill. An alias routes
  * through policy to model skills; an alias never calls another alias. */
 export const WORKIT_SKILL_ALIASES = {
-  "wk-challenge": "workit-challenge",
-  "wk-babysit": "workit-babysit",
+  "wk-shape": "workit-shape",
   "wk-implement": "workit-implement",
-  "wk-plan": "workit-plan",
-  "wk-debug": "workit-debug",
   "wk-review": "workit-review",
-  "wk-handoff": "workit-handoff",
-  "wk-tdd": "workit-behavioral-tdd",
-  "wk-blast-radius": "workit-blast-radius",
-  "wk-deslop": "workit-deslop",
-  "wk-diagram": "workit-diagram",
-  "wk-mockup": "workit-mockup",
-  "wk-green-run": "workit-green-run",
-  "wk-steer": "workit-steer",
+  "wk-debug": "workit-debug",
+  "wk-ship": "workit-ship",
+  "wk-continue": "workit-continue",
   "wk-bdd": "workit-bdd",
   "wk-test-audit": "workit-test-audit",
-} as const;
+  "wk-deslop": "workit-deslop",
+  "wk-fanout": "workit-fanout",
+  "wk-verify-app": "workit-verify-app",
+} as const satisfies Record<string, WorkitSkill>;
+
+/**
+ * The words a user types that should load each skill. Each skill's
+ * description and its bootstrap routing line carry every one of them, and no
+ * two skills share one (checked by test), so a trigger routes to one skill.
+ */
+export const WORKIT_SKILL_TRIGGERS: Readonly<Record<WorkitSkill, readonly string[]>> = {
+  "workit-shape": ["brainstorm", "plan", "spec", "grill", "should we"],
+  "workit-implement": ["implement", "build", "add a feature"],
+  "workit-review": ["review", "blast radius"],
+  "workit-debug": ["bug", "broken", "flaky", "regression"],
+  "workit-ship": ["ship", "babysit", "CI", "merge"],
+  "workit-continue": ["resume", "pick up", "handoff", "interruption"],
+  "workit-bdd": ["BDD", "TDD", "acceptance criteria", "Given/When/Then"],
+  "workit-test-audit": ["test audit", "tautology", "weak tests"],
+  "workit-deslop": ["deslop", "slop", "dead code"],
+  "workit-fanout": ["fan out", "parallelize", "parallel agents", "swarm"],
+  "workit-verify-app": ["verify the app", "smoke test", "prove it works"],
+};
+
+/** The `description:` frontmatter value of a SKILL.md (one line, unquoted). */
+export const skillDescription = (skillMd: string): string => {
+  const frontmatter = /^---\r?\n([\s\S]*?)\r?\n---/.exec(skillMd)?.[1] ?? "";
+  const line = /^description:\s*(.+)$/m.exec(frontmatter)?.[1] ?? "";
+  return line.trim().replace(/^(["'])(.*)\1$/, "$2");
+};
+
+/** A generated Cursor slash command for one alias; `commands/` is committed
+ * because Cursor discovers the plugin from git, so the build writes these and
+ * a drift test compares them to the committed copies. */
+export const cursorCommandText = (alias: string, skill: string, description: string): string =>
+  `# /${alias}\n\nLoad and apply the bundled \`${skill}\` skill. ${description}\n\nExtra context: $ARGUMENTS\n`;
 
 export const skillManifestNames = (root: string): string[] =>
   existsSync(root)

package/src/hooks/handle.ts

@@ -17,14 +17,35 @@ const offered = new Set<string>();
  * `workit:implementer` is ours: a bare or other-plugin `implementer` is not. */
 const CLAUDE_WORKTREE_IMPLEMENTER = "workit:implementer";
 
+/** The plugin's read-only judges: each records verdicts as its own session. */
+const CLAUDE_JUDGES: ReadonlySet<string> = new Set(["workit:verifier", "workit:reviewer"]);
+
+/** `<lead session>:<agent id>`, safe for the ledger's session grammar. */
+const subagentSession = (session: string | null, agentId: string): string =>
+  [session, agentId]
+    .filter((part): part is string => Boolean(part))
+    .join(":")
+    .replace(/[^A-Za-z0-9_.:@/+-]/g, "-")
+    .slice(0, 128);
+
 const subagentStartText = (
   host: HookInput["host"],
+  session: string | null,
   descriptor: HostDescriptor,
   event: Extract<HookInput["event"], { kind: "subagent.start" }>,
-): string =>
-  host === "claude_code" && event.agentType === CLAUDE_WORKTREE_IMPLEMENTER
-    ? `Workit observed ${descriptor.label} subagent ${event.agentId} (${event.agentType}) working in its own git worktree: it may edit and commit there, within its brief's scope. Before the first commit, switch to a policy-compliant branch (\`git switch -c <type>/<slug>\`, e.g. feature/<slug>); branch policy hooks still deny protected or non-compliant branches. Never push, open a PR, or merge unless the brief asks for it.`
-    : `Workit observed ${descriptor.label} subagent ${event.agentId} (${event.agentType}) as read-only/agent-guided; writer delegation is unavailable.`;
+): string => {
+  if (host === "claude_code" && event.agentType === CLAUDE_WORKTREE_IMPLEMENTER)
+    return `Workit observed ${descriptor.label} subagent ${event.agentId} (${event.agentType}) working in its own git worktree: it may edit and commit there, within its brief's scope. Before the first commit, switch to a policy-compliant branch with \`workit git branch <branch> --base <base>\` (e.g. feature/<slug>); branch policy hooks still deny protected or non-compliant branches. Never record a verdict on your own work. Never push, open a PR, or merge unless the brief asks for it.`;
+  const readOnly = `Workit observed ${descriptor.label} subagent ${event.agentId} (${event.agentType}) as read-only/agent-guided; writer delegation is unavailable.`;
+  if (
+    host === "claude_code" &&
+    event.agentType &&
+    CLAUDE_JUDGES.has(event.agentType) &&
+    event.agentId
+  )
+    return `${readOnly} Its own Workit session is ${subagentSession(session, event.agentId)}: record verdicts with \`workit ledger verdict <result> --session ${subagentSession(session, event.agentId)} ...\` so the ledger tells it apart from the author.`;
+  return readOnly;
+};
 
 export function handleHook(input: HookInput, deps: HookDeps): HookDecision {
   const { descriptor } = deps;
@@ -50,7 +71,10 @@ export function handleHook(input: HookInput, deps: HookDeps): HookDecision {
     case "shell.pre":
       return usable(descriptor.shellPolicy.deny) ? shellPolicy(input.cwd, event.command) : NONE;
     case "subagent.start":
-      return { kind: "context", text: subagentStartText(input.host, descriptor, event) };
+      return {
+        kind: "context",
+        text: subagentStartText(input.host, input.session.id ?? null, descriptor, event),
+      };
     case "compact.pre":
       return {
         kind: "notice",

package/src/hooks/hosts/codex.ts

@@ -294,5 +294,5 @@ export const codexAdapter: HostAdapter = {
   render,
   // Without a session id there is no actor to bind a writer to.
   addendum: (input) =>
-    `<workit-codex-mutations>Codex MCP is read-only: unattested callers cannot mutate. Run the workit CLI for task mutations: node_modules/.bin/workit <family> <action> --json --confirm${input.session.id ? `; bind the writer to this session with node_modules/.bin/workit writer acquire --task <id> --revision <rev> --actor ${input.session.id} --confirm` : ""}. Binding decisions and external actions need a human.</workit-codex-mutations>`,
+    `<workit-codex-mutations>Codex MCP is read-only: unattested callers cannot mutate. Run workit verbs with the workit CLI on the shell (node_modules/.bin/workit, or npx -y @brainervirus/workit-cli): check, git branch|commit|push, pr, ci, stack, ledger, handoff; task-family mutations take --json --confirm${input.session.id ? `; bind the writer to this session with node_modules/.bin/workit writer acquire --task <id> --revision <rev> --actor ${input.session.id} --confirm` : ""}. A verifier or reviewer records workit ledger verdict under a session the lead assigns (WORKIT_SESSION_ID=<lead>-v<n>), never the author's. Merge and release need a workspace grant; a question answer is not host permission.</workit-codex-mutations>`,
 };

package/src/ledger.ts

@@ -1071,6 +1071,12 @@ export function recordVerdict(
     surface?: string | null;
     self?: boolean;
     evidenceRefs?: string[];
+    /**
+     * A role id derived from another session (`--as`): the session it was
+     * derived from. `null` means it was derived from no session, which makes
+     * the verdict self. An author's derived id is refused like the author.
+     */
+    derivedFrom?: string | null;
   },
 ): LedgerResult<VerdictRow> {
   if (!(VERDICT_RESULTS as readonly string[]).includes(input.result))
@@ -1105,19 +1111,22 @@ export function recordVerdict(
     );
   const session = context.actor.session;
   const selfReason: SelfReason | null =
-    input.self === true ? "flag" : session ? null : "no_session";
+    input.self === true ? "flag" : session && input.derivedFrom !== null ? null : "no_session";
   const self = selfReason !== null;
-  if (
-    !self &&
-    session &&
-    authorSessions(context.cwd, ledger.value.rows, branch, { base: key.base, head: key.head }).has(
-      session,
-    )
-  )
+  const authors = authorSessions(context.cwd, ledger.value.rows, branch, {
+    base: key.base,
+    head: key.head,
+  });
+  const authoring = [session, input.derivedFrom].find(
+    (candidate): candidate is string => typeof candidate === "string" && authors.has(candidate),
+  );
+  if (!self && authoring)
     return err(
       "blocked",
-      `author_verdict: session ${session} authored ${branch}; a verdict must come from a different session`,
-      'have a non-author session record the verdict, or pass --self (a self verdict is never accepted by merge:"verified")',
+      `author_verdict: session ${authoring} authored ${branch}; a verdict must come from a different session`,
+      input.derivedFrom === undefined
+        ? 'have a non-author session record the verdict, or pass --self (a self verdict is never accepted by merge:"verified")'
+        : "run the verifier as a separate session: the lead spawns it with its own WORKIT_SESSION_ID (Claude Code: subagents get one from the SubagentStart hook)",
     );
   const link = checkSupersede(context, "verdict", self);
   if (!link.ok) return link;

package/templates/plan-template.md

@@ -1,27 +1,26 @@
-# <Feature> Implementation Plan
+# <Feature> plan
 
-> **For agentic workers:** Load `workit-implement` when policy selects implementation. Use bounded `workit_worker` delegation when the host supports it; otherwise execute inline within writer scope. Steps use checkbox (`- [ ]`) syntax for tracking.
+Spec: `docs/<slug>/spec.md` · Goal: <one sentence>
 
-**Spec:** `docs/<slug>/spec.md`
-**Branch:** `feature/<slug>`
+A plan records decisions, not code: per slice the branch, what it touches, its
+acceptance, how it is verified, and what it depends on (workit-shape
+`references/slicing.md`). Independent slices fan out (workit-fanout);
+dependent ones stack (`workit stack plan <bottom> … <top>`).
 
-**Goal:** <one sentence>
+## Global constraints
 
-## Global Constraints
-
-- Each task lands exactly one contiguous non-empty commit range (`base..head`): fix rounds append commits to that range and never rewrite/amend an active review range; record the real base..head shas in task progress.
-- The final task closes the lead Workit task with `workit_task` `action: "close"` (CLI: `workit task close --payload … [--confirm]`) once requirements are satisfied and repository verification passes — never finish while the task is still `active` or `paused`.
-- <project-wide requirements, one line each>
+- <project-wide requirement, one line each>
 
 ---
 
-### Task N: <Component>
-
-- [ ] **Step 1: <action>**
+### S1 <type>/<slug>  (base: main)
 
-<!-- per-task criteria: how this task is verified -->
-**Criteria:** <verifiable check>
+Touches: <areas, not line numbers>
+Acceptance:
+- Given <state>, When <action>, Then <observable result>
+Verify: `workit check test`; verify-<app> "<feature>"
+Decisions: <ledger refs or one-line rulings>
 
-| Status | Task |
-| --- | --- |
-| pending | N: <Component> |
+| Slice | Branch | Depends on | Status |
+| --- | --- | --- | --- |
+| S1 | <type>/<slug> | — | pending |

package/templates/spec-template.md

@@ -19,14 +19,15 @@ no durable agreement: `Spec: none (<reason>)`, no file.)
 
 ## Architecture
 
-<!-- May be `N/A (<reason>)` when the change has no flows or architecture. -->
-<!-- Otherwise REQUIRED: render a mermaid diagram (workit-diagram skill). -->
+<!-- Optional: only when a diagram argues a decision (workit-shape
+     references/diagrams.md); otherwise delete this section. -->
 ```mermaid
 flowchart TD
   A[Start] --> B[Step]
 ```
 
-<!-- REQUIRED if this spec touches UI: render an ASCII wireframe (workit-mockup skill). -->
+<!-- Optional: a UI choice still open gets an ASCII sketch (workit-shape
+     references/mockups.md). -->
 ```text
 ┌──────────────┐
 │ Header       │

package/skills/workit-babysit/SKILL.md

@@ -1,37 +0,0 @@
----
-name: workit-babysit
-description: Use when the user asks to babysit a PR or explicitly opts in to PR follow-up
----
-
-# Babysit a PR to PR-ready
-
-PR creation does not start babysitting. `babysit:true` opts into this skill;
-omission means no follow-up. A PR URL by itself is not an instruction to drive
-it. When the user asks to babysit a URL from a route Workit did not enforce,
-help without claiming the Workit route was enforced. Never mutate PR topology
-(no rebase strategy changes, no force-push).
-
-
-## Method
-
-1. Default to drive mode for an explicit babysit request: resolve conflicts,
-   address review threads, and get checks green. Watch reports status only;
-   threads-only addresses review threads. Ask about mode only when the choice
-   materially changes the work.
-2. Work toward PR-ready in order: conflicts → review threads → CI. Keep a brief
-   checkpoint when continuity needs it; task progress is optional.
-3. Classify CI before retry: flake (rerun once) vs stale base (verify with
-   `git merge-base --is-ancestor` before updating) vs real failure (fix).
-4. Triage bot findings skeptically: reproduce or quote code before acting;
-   invalid bots get a reasoned dismissal, never silent ignore.
-5. Batch fixes into one push wave; re-verify green after every push.
-6. Stop at PR-ready. A PR creation or babysit request does not authorize merge
-   or release. Continue to merge or release only when the user explicitly sets
-   that delivery endpoint and host authority allows the action.
-
-## Completion
-
-Report PR-ready status with evidence for fixes, or a brief blocker report. If
-the user explicitly authorized merge, honor the configured strategy only after
-checks and required approval. After a squash merge, re-record evidence against
-the new base commit before closing tracked work.

package/skills/workit-behavioral-tdd/SKILL.md

@@ -1,56 +0,0 @@
----
-name: workit-behavioral-tdd
-description: Use when policy identifies behavior, side effects, permissions, or data handling that may change and a regression boundary is needed
----
-
-# Behavioral TDD
-
-Test the observable behavior at a stable boundary, not the implementation shape.
-Use this method when assessment selects the `testing` dimension.
-
-
-## Method
-
-1. Inspect the task requirement, current candidate, intended behavior, and real
-   verification entry point with shared `task`, `policy`, and `evidence` operations.
-2. State one behavior and its observable result. Choose the narrowest stable
-   boundary a caller or user depends on; avoid private helpers and incidental
-   representations.
-3. Write one vertical RED slice that fails for the missing behavior and run it
-   through the CLI so the failure is observed: `workit check test` (the repo's
-   configured `test` check; `npx -y @brainervirus/workit-cli check test` when
-   `workit` is not on PATH). Implement the smallest change, then run the same
-   check GREEN. Close accepts only a fresh passing run of the configured check
-   that `workit check` observed; a recorded "tests pass" is a note, and an
-   ad-hoc `workit check -- <cmd>` never satisfies the gate. If no `test` check
-   is configured or detected, add `workit.checks.json` (committed) with it.
-4. Add only another slice for a distinct behavior or risk. Any edit makes the
-   observed check stale: re-run `workit check test` before closing.
-
-## Reject noisy tests
-
-- A dependency/version-pin assertion is not behavioral evidence.
-- A test that mirrors branches, private calls, or exact implementation structure
-  is coupled to internals; replace it with the public effect.
-- Duplicate assertions and tests that add no distinct failure signal are noise;
-  delete them.
-- Do not claim a passing test satisfies a different requirement.
-- Banned: tautologies (asserts what the code says, not what it must do),
-  ghost loops (assert inside a possibly-empty loop), smoke-only renders,
-  type-only or CSS-class coupling. If the test still passes when every
-  imported function returns undefined, rewrite the assertion or delete it.
-  `workit test-audit --diff` flags these; triage them with workit-test-audit.
-  Turning acceptance criteria into scenarios and seams is workit-bdd.
-
-Run RED/GREEN through `workit check`, which records the observed result on the
-current task; shared `evidence` operations are for notes and non-test evidence.
-Do not add a second lifecycle, approval chain, or test workflow outside the
-current task state.
-
-## Common mistakes
-
-| Mistake | Correction |
-| --- | --- |
-| "The pin changed, so assert the new string" | Exercise the affected consumer behavior. |
-| "The code is obvious" | A small vertical slice still proves the contract. |
-| Keeping a passing test after the boundary moved | Re-run `workit check test` on the current tree. |

package/skills/workit-blast-radius/SKILL.md

@@ -1,26 +0,0 @@
----
-name: workit-blast-radius
-description: Use when a small-looking change could break something else, before close or merge
----
-
-# Blast radius beyond the diff
-
-A small diff is not a small risk. Prove the one fact it is safe because of,
-with runnable proof — not assertion.
-
-
-## Method
-
-1. List what the change touches: callers, shared state, contracts, config,
-   migrations. Grep every caller of each touched function.
-2. For each: state the one fact it is safe because of (type boundary,
-   existing test, unreachable path) plus how to run the proof.
-3. Run the proofs. Unproven claims stay labeled UNPROVEN in findings —
-   never silently treated as safe.
-4. Fix at the shared root (one guard where all callers route through),
-   not per caller.
-
-## Completion
-
-Blast-radius note in evidence or review: each risk with fact + proof
-command, or an UNPROVEN finding for what could not be proven.