@brainervirus/workit-claude-code 2.6.0

package/hooks/hooks.json

@@ -0,0 +1,68 @@
+{
+  "description": "Workit host hooks: task context on session start (incl. compaction restore and forks) and when it changes per turn, branch policy on git shell commands, and worktree guidance for subagents. Only events that change Claude's behavior are registered.",
+  "hooks": {
+    "SessionStart": [
+      {
+        "matcher": "startup|resume|clear|compact|fork",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node",
+            "args": ["${CLAUDE_PLUGIN_ROOT}/bin/workit-hook.mjs"],
+            "timeout": 10
+          }
+        ]
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node",
+            "args": ["${CLAUDE_PLUGIN_ROOT}/bin/workit-hook.mjs"],
+            "timeout": 5
+          }
+        ]
+      }
+    ],
+    "PreToolUse": [
+      {
+        "matcher": "Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "if": "Bash(git *)",
+            "command": "node",
+            "args": ["${CLAUDE_PLUGIN_ROOT}/bin/workit-hook.mjs"],
+            "timeout": 5
+          }
+        ]
+      },
+      {
+        "matcher": "PowerShell",
+        "hooks": [
+          {
+            "type": "command",
+            "if": "PowerShell(git *)",
+            "command": "node",
+            "args": ["${CLAUDE_PLUGIN_ROOT}/bin/workit-hook.mjs"],
+            "timeout": 5
+          }
+        ]
+      }
+    ],
+    "SubagentStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node",
+            "args": ["${CLAUDE_PLUGIN_ROOT}/bin/workit-hook.mjs"],
+            "timeout": 5
+          }
+        ]
+      }
+    ]
+  }
+}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@brainervirus/workit-claude-code",
+  "version": "2.6.0",
+  "private": false,
+  "description": "Workit Claude Code plugin — session and per-turn task context, branch policy on git shell commands, workit method skills, and verifier/reviewer/implementer agents",
+  "keywords": [
+    "agentic-coding",
+    "ai-agents",
+    "claude-code",
+    "hooks",
+    "plugin",
+    "skills",
+    "workflow"
+  ],
+  "homepage": "https://github.com/BrainerVirus/workit#readme",
+  "bugs": {
+    "url": "https://github.com/BrainerVirus/workit/issues"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/BrainerVirus/workit.git"
+  },
+  "files": [
+    ".claude-plugin/",
+    "hooks/hooks.json",
+    "bin/",
+    "agents/",
+    "skills/",
+    "assets/",
+    "dist/",
+    "README.md"
+  ],
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "bun scripts/build.ts"
+  },
+  "devDependencies": {
+    "@brainervirus/workit-cli": "^2.6.0",
+    "@brainervirus/workit-core": "^2.6.0"
+  },
+  "engines": {
+    "node": ">=24"
+  }
+}

package/skills/babysit/SKILL.md

@@ -0,0 +1,46 @@
+---
+name: 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.
+
+
+## In Claude Code
+
+Workit operations (`task`, `evidence`, `policy`, `decision`, …) run through
+the `workit` CLI on the Bash tool: `workit <family> <action> --json`
+(`workit --help` lists the verbs). The plugin's `verifier`, `reviewer`
+and `implementer` agents take independent verification, fresh-context
+review and isolated implementation.

package/skills/behavioral-tdd/SKILL.md

@@ -0,0 +1,57 @@
+---
+name: 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, run it, and
+   preserve the actual failure as evidence. Implement the smallest change, then
+   run the same slice GREEN and record its result. Close enforces the order: a
+   testing requirement with GREEN but no preceding RED evidence stays unsatisfied.
+4. Add only another slice for a distinct behavior or risk. Reconcile stale
+   evidence if the candidate changes.
+
+## 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.
+
+Use shared `evidence` operations for RED/GREEN results. 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 | Mark it stale and retest the current candidate. |
+
+
+## In Claude Code
+
+Workit operations (`task`, `evidence`, `policy`, `decision`, …) run through
+the `workit` CLI on the Bash tool: `workit <family> <action> --json`
+(`workit --help` lists the verbs). The plugin's `verifier`, `reviewer`
+and `implementer` agents take independent verification, fresh-context
+review and isolated implementation.

package/skills/blast-radius/SKILL.md

@@ -0,0 +1,35 @@
+---
+name: 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.
+
+
+## In Claude Code
+
+Workit operations (`task`, `evidence`, `policy`, `decision`, …) run through
+the `workit` CLI on the Bash tool: `workit <family> <action> --json`
+(`workit --help` lists the verbs). The plugin's `verifier`, `reviewer`
+and `implementer` agents take independent verification, fresh-context
+review and isolated implementation.

package/skills/challenge/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: challenge
+description: Use when requirements or consequences leave a real decision open
+---
+
+# Challenge open choices with evidence
+
+Skip this method for a precise, settled request.
+
+## Method
+
+1. Ground the outcome, constraints, evidence, and important unknowns. Inspect
+   code and project docs before asking about facts they can answer.
+2. Separate observations, inferences, and proposals. Test assumptions that
+   could change the recommendation.
+3. When viable alternatives exist, present two or three genuinely different
+   approaches. Recommend one; for each, give its benefit, cost or risk, when it
+   fits, and the smallest useful validation. Do not invent a weak alternative.
+4. Ask only consequential questions, in dependency order. Group independent
+   choices into one small round. If an authorized reversible default works,
+   state it and proceed.
+5. Record a settled choice once in the existing conversation or task context.
+   A discussion decision is knowledge; never fabricate a native permission
+   receipt or reopen it without new evidence.
+6. Create durable documentation only when requested or when the decision needs
+   a future reader. Brainstorming alone does not require a spec.
+
+Say directly when evidence shows a proposal is weak, overcomplicated, or solves
+the wrong problem. Raise a counter-case only when it adds a real constraint.
+
+## Guardrails
+
+- Do not create a universal spec, plan, approval chain, or second lifecycle.
+- Unknowns that affect an action remain unresolved until evidence or a user
+  decision closes them.
+- Use shared operations for tracked state and provenance; never write task
+  metadata directly.
+- An in-session counter-case is not fresh-context review.
+
+## Common mistakes
+
+| Mistake | Correction |
+| --- | --- |
+| Asking what code or docs already answer | Ground first; the user owns choices, not lookups. |
+| Listing every hypothetical objection | Raise only objections that can change the decision. |
+| Asking for agreement without a recommendation | Recommend an option and explain the tradeoff. |
+| Treating a discussion decision as permission | Record it as knowledge; preserve native host authority. |
+
+
+## In Claude Code
+
+Workit operations (`task`, `evidence`, `policy`, `decision`, …) run through
+the `workit` CLI on the Bash tool: `workit <family> <action> --json`
+(`workit --help` lists the verbs). The plugin's `verifier`, `reviewer`
+and `implementer` agents take independent verification, fresh-context
+review and isolated implementation.

package/skills/debug/SKILL.md

@@ -0,0 +1,48 @@
+---
+name: debug
+description: Use when behavior is failing, surprising, contradictory, or regressed and the root cause is not established
+---
+
+# Debug the root cause
+
+Debugging is investigation, not a fast symptom patch. Use this method when
+assessment selects `root-cause-investigation` or behavior is failing without an
+established root cause.
+
+
+## Method
+
+1. Inspect task scope, caller authority, candidate identity, existing evidence,
+   findings, and worker/writer state with shared `task`, `policy`, `evidence`, and
+   `finding` operations.
+2. Reproduce the failure at a stable behavioral boundary. Record observed facts,
+   inferences, and unknowns with references; trace the failing value and all
+   relevant callers before editing.
+3. State the root-cause hypothesis and the smallest in-scope fix. Write a focused
+   regression at the boundary when practical, then run RED and GREEN checks.
+4. Acquire writer authority through `writer` before mutation. Reconcile the
+   candidate, evidence, and findings after the change; investigate sibling paths
+   and stale conclusions rather than assuming the first patch worked.
+
+Respect the user's scope and native authority. For a deterministic failure, make
+one focused reproduction that exercises the affected boundary and add a
+regression check when practical. If no direct reproduction exists, gather the
+available evidence and state what remains uncertain instead of inventing a red
+loop or blocking unrelated work.
+
+## Common mistakes
+
+| Mistake                               | Correction                                             |
+| ------------------------------------- | ------------------------------------------------------ |
+| Patching the nearest stack frame      | Trace the input, callers, and shared cause.            |
+| Reproducing only after editing        | Capture the failure before mutation.                   |
+| Treating one passing command as proof | Verify the affected behavior and record real evidence. |
+
+
+## In Claude Code
+
+Workit operations (`task`, `evidence`, `policy`, `decision`, …) run through
+the `workit` CLI on the Bash tool: `workit <family> <action> --json`
+(`workit --help` lists the verbs). The plugin's `verifier`, `reviewer`
+and `implementer` agents take independent verification, fresh-context
+review and isolated implementation.

package/skills/deslop/SKILL.md

@@ -0,0 +1,40 @@
+---
+name: deslop
+description: Use before opening a PR or after implementation to remove AI slop from code and prose
+---
+
+# Deslop code and prose
+
+Throughput without quality is slop. Clean it with a minimal diff — deslop
+never refactors behavior.
+
+
+## Method
+
+1. Code: delete dead helpers, redundant validators, stub references, and
+   comments that restate the code. Comments die by default; keep one only
+   with proof of an unchangeable constraint, encoded structurally if cheap.
+2. Prose (PR body, spec, docs): cut filler, keep real symbol names and
+   before→after numbers. One doc, one purpose.
+3. Keep the diff minimal: deslop removes lines, never moves logic. If a
+   cleanup wants behavior change, it becomes its own tasked change.
+
+## Completion
+
+A smaller diff with identical behavior and green checks. Report lines
+removed, not lines written.
+
+Record passing check evidence linked to the `pre-pr-cleanup` requirement id
+from the current policy (`kind: check`, `result: passed`, summary naming what
+was removed). That requirement gates `hosting.pull_request` and close. If the
+change genuinely has nothing to clean, ask for an approved limitation
+decision instead of recording evidence that did not happen.
+
+
+## In Claude Code
+
+Workit operations (`task`, `evidence`, `policy`, `decision`, …) run through
+the `workit` CLI on the Bash tool: `workit <family> <action> --json`
+(`workit --help` lists the verbs). The plugin's `verifier`, `reviewer`
+and `implementer` agents take independent verification, fresh-context
+review and isolated implementation.

package/skills/diagram/SKILL.md

@@ -0,0 +1,36 @@
+---
+name: diagram
+description: Use when a spec or plan needs a flow or architecture diagram
+---
+
+# Mermaid when needed, never by default
+
+Tables first, ASCII trees second, mermaid only when a flow or architecture
+needs it. Flowchart, sequence, state, or ER only. No renderer, no network.
+
+
+## Syntax rules (mermaid v11)
+
+- Fence as ` ```mermaid `, no surrounding prose inside the fence.
+- Quote node labels containing punctuation: `A["input (x, y)"]`.
+- One direction per diagram (`TD` or `LR`); keep nodes under twelve.
+- Name actors exactly as the codebase names them (real symbols only).
+
+## Verify
+
+Re-read the fence before commit: balanced quotes/brackets, every node
+reachable, labels match spec terms. If it cannot be verified by reading,
+delete it.
+
+## Completion
+
+One diagram that argues a decision, or nothing. Never a diagram suite.
+
+
+## In Claude Code
+
+Workit operations (`task`, `evidence`, `policy`, `decision`, …) run through
+the `workit` CLI on the Bash tool: `workit <family> <action> --json`
+(`workit --help` lists the verbs). The plugin's `verifier`, `reviewer`
+and `implementer` agents take independent verification, fresh-context
+review and isolated implementation.

package/skills/green-run/SKILL.md

@@ -0,0 +1,33 @@
+---
+name: green-run
+description: Use to drive a red CI pipeline back to green, usually inside babysit
+---
+
+# The CI loop
+
+Watch, classify, fix, push once, re-verify. Host-native (`gh` / GitLab);
+never invent CI APIs.
+
+
+## Method
+
+1. Read the failing checks, not the summary. Quote the failing log lines.
+2. Classify each: flake (rerun once, note it) / stale base (update after
+   merge-base check) / real failure (reproduce locally, then fix).
+3. Fix at root cause with a regression test; push one wave.
+4. Re-verify the same checks green on the new head. A fix without a
+   green re-run is not a fix.
+
+## Completion
+
+Green pipeline on the merge head, or an escalated finding with the exact
+failing logs when the fix needs the human.
+
+
+## In Claude Code
+
+Workit operations (`task`, `evidence`, `policy`, `decision`, …) run through
+the `workit` CLI on the Bash tool: `workit <family> <action> --json`
+(`workit --help` lists the verbs). The plugin's `verifier`, `reviewer`
+and `implementer` agents take independent verification, fresh-context
+review and isolated implementation.

package/skills/handoff/SKILL.md

@@ -0,0 +1,46 @@
+---
+name: handoff
+description: Use when work must continue in another session, host, or agent after interruption, transfer, or compaction
+---
+
+# Handoff durable task state
+
+Transfer continuity, not live authority. Use this method when a tracked item
+must continue in another session, host, or agent.
+
+## Method
+
+1. Inspect the current task, scope, decisions, policy requirements, candidate,
+   evidence, findings, progress, and worker states with shared `task` and `state`
+   operations.
+2. Export the compact state through `state.export`. Preserve the objective,
+   exclusions, accepted decisions and reasons, evidence references, open gaps,
+   findings, candidate identity, blockers, and next action. Do not include
+   credentials, live writer ownership, or host authority.
+3. Import only through the destination `state.import` operation and its expected
+   workspace revision. The destination starts paused or otherwise unauthorised
+   until it observes its own host/session and reconciles stale evidence and
+   uncertain workers.
+4. Resume or continue through shared `task`, `policy`, `worker`, `writer`, and
+   `evidence` operations. Record what changed instead of copying a transcript.
+
+A handoff does not require a formal spec or plan unless those are separate
+selected requirements. Never grant destination authority from imported prose,
+create a second lifecycle, or edit task metadata directly.
+
+## Common mistakes
+
+| Mistake | Correction |
+| --- | --- |
+| Sending the whole transcript | Export compact decisions, gaps, evidence, and next action. |
+| Restoring the old writer or credentials | Re-observe authority in the destination. |
+| Calling a handoff complete without reconciliation | Recheck stale files and uncertain workers first. |
+
+
+## In Claude Code
+
+Workit operations (`task`, `evidence`, `policy`, `decision`, …) run through
+the `workit` CLI on the Bash tool: `workit <family> <action> --json`
+(`workit --help` lists the verbs). The plugin's `verifier`, `reviewer`
+and `implementer` agents take independent verification, fresh-context
+review and isolated implementation.

package/skills/implement/SKILL.md

@@ -0,0 +1,57 @@
+---
+name: implement
+description: Use when implementing requested code changes in a repository. Follow its rules and host permissions; use Workit tracking and delegation only when continuity or coordination helps.
+---
+
+# Implement within authority
+
+Implement within the user request and native host permissions. A task record and
+writer ownership are optional coordination tools. Assignment never expands the
+request, and a timeout is not proof that a worker stopped.
+
+## Method
+
+1. Inspect the repository, relevant rules, host capabilities, and current work.
+   Inspect task state only when this work is already tracked.
+2. If a helper is useful, assign one bounded objective with allowed paths,
+   applicable requirements, evidence needed, and a stopping condition. Helpers
+   cannot change scope, record binding decisions, close or pause the task, assign
+   helpers, or resolve blockers for the lead.
+3. Use writer ownership only when another Workit actor may mutate the same
+   checkout; release it when coordination ends. Cancellation remains uncertain
+   until process exit or explicit recovery.
+4. Reconcile helper reports and run the checks appropriate to the requested
+   outcome. If delegation is unavailable, continue inline when useful.
+5. Before a cross-repo mutation, resolve the actual checkout, branch and remote
+   from the request and current context. Ask only if competing plausible targets
+   remain unresolved. Branch, commit, direct push, PR-ready, merge and release
+   are distinct endpoints; perform only the authorized one under target rules.
+   Before saying done, reconcile every named deliverable against that checkout
+   and verify the requested result. For a push, observe the destination remote
+   ref and confirm it contains the delivered commit; report drift or missing
+   items as blockers instead of treating local success as remote delivery.
+
+Do not edit Workit metadata directly, create nested helper trees, widen paths, or
+create a second lifecycle. Read-only investigation and bounded reports do not
+grant product-write ownership.
+
+Do not request writer ownership for a solo edit. If a concurrent Workit writer
+cannot be fenced, stop only the conflicting managed writes; ordinary writes still
+follow the native host permission and sandbox.
+
+## Common mistakes
+
+| Mistake                                        | Correction                                          |
+| ---------------------------------------------- | --------------------------------------------------- |
+| "The helper timed out, so the writer is free"  | Observe exit or perform explicit recovery.          |
+| Letting a helper approve its own exception     | Return the decision to the lead/user.               |
+| Running a build while another writer is active | Treat builds and tests that mutate state as writes. |
+
+
+## In Claude Code
+
+Workit operations (`task`, `evidence`, `policy`, `decision`, …) run through
+the `workit` CLI on the Bash tool: `workit <family> <action> --json`
+(`workit --help` lists the verbs). The plugin's `verifier`, `reviewer`
+and `implementer` agents take independent verification, fresh-context
+review and isolated implementation.

package/skills/mockup/SKILL.md

@@ -0,0 +1,32 @@
+---
+name: mockup
+description: Use when a UI decision needs sketching before implementation
+---
+
+# ASCII mockups before UI code
+
+Sketch, don't build. Three genuinely different layout hypotheses maximum,
+ASCII only, no code output.
+
+
+## Method
+
+1. Fix a legend (`┌─┐ │ └─┘ ░ ≈ [ ] ( )`) and keep sketches 60-80 cols,
+   8-20 rows.
+2. Per hypothesis: regions, component reuse vs new (named against the
+   existing codebase), empty/loading/populated/error states, nav flow.
+3. Ask at most one clarifying question, then recommend. Flag hi-fi
+   escalation when ASCII cannot settle it (density, motion, brand).
+
+## Completion
+
+The sketch plus the decision lands in the spec dir. Throwaway by design.
+
+
+## In Claude Code
+
+Workit operations (`task`, `evidence`, `policy`, `decision`, …) run through
+the `workit` CLI on the Bash tool: `workit <family> <action> --json`
+(`workit --help` lists the verbs). The plugin's `verifier`, `reviewer`
+and `implementer` agents take independent verification, fresh-context
+review and isolated implementation.

package/skills/plan/SKILL.md

@@ -0,0 +1,54 @@
+---
+name: plan
+description: Use when dependencies, sequencing, coordination, or resumption make durable next actions useful
+---
+
+# Plan useful coordination
+
+A plan is useful when work has dependent steps, a handoff, concurrent actors, or
+meaningful unresolved choices. It is never a prerequisite for implementation.
+
+## Method
+
+1. Establish the requested outcome, constraints, dependencies, and important
+   unknowns from the available code, docs, and configuration before asking.
+2. Record only the useful sequence: objective, dependency, bounded outcome,
+   evidence needed, and next action. Reuse the project's existing format.
+3. Start a tracked record only when handoff, dependent steps, coordination, or
+   durable decisions need continuity. Infer observable facts instead of asking
+   the user to fill redundant protocol fields.
+4. Create a spec when a durable behavior contract or interface is requested or
+   will help a future reader. Use an ADR for a consequential trade-off and a
+   glossary for stable terms. A small fix needs no document.
+5. If the user authorized implementation, proceed through the agreed endpoint
+   and applicable checks. Do not ask for a separate plan approval or repeat
+   "continue?". Stop for a new consequential choice, host denial, conflict, or
+   blocker that cannot be resolved safely.
+6. Update a checkpoint at meaningful boundaries when another session may need
+   to resume. Keep settled decisions, changed files, actual checks, blockers,
+   and the next action; omit transcript and process trivia.
+
+## Shape
+
+Plan slices as small end-to-end outcomes with explicit dependencies and checks.
+Keep repo policy and native host authority separate. Preserve the user's branch
+and commit conventions. Do not prescribe one commit per step or create a second
+approval chain unless the user asked for that delivery format.
+
+## Common mistakes
+
+| Mistake | Correction |
+| --- | --- |
+| Writing a packet for a bounded reversible change | Leave the change undocumented. |
+| Asking what repository state or code can answer | Inspect it first. |
+| Treating the plan as authority | Follow the user's scope and native host permissions. |
+| Copying a transcript into the plan | Keep decisions, evidence, gaps, and next action only. |
+
+
+## In Claude Code
+
+Workit operations (`task`, `evidence`, `policy`, `decision`, …) run through
+the `workit` CLI on the Bash tool: `workit <family> <action> --json`
+(`workit --help` lists the verbs). The plugin's `verifier`, `reviewer`
+and `implementer` agents take independent verification, fresh-context
+review and isolated implementation.