@brainervirus/workit-core 4.0.0 → 6.0.0

package/src/forge/pr-ops.ts

@@ -15,7 +15,7 @@
 // The merge call carries the head SHA (GitHub `sha=`, GitLab `sha=`), so a
 // head that moves after the gates refuses instead of merging unverified code.
 // --delete-branch deletes with a lease on that same SHA.
-import { requireGrant } from "../autonomy";
+import { requireGrant, type AutonomySource } from "../autonomy";
 import { isProtectedTarget } from "../core/branch";
 import { vcsConfig } from "../core/vcs-config";
 import { deleteRemoteBranch } from "../git/ops";
@@ -257,7 +257,7 @@ export type MergeOutcome = {
   method: MergeMethod;
   mergeSha: string | null;
   verdict: { required: boolean; accepted: boolean; verdictId: string | null };
-  grant: { source: "autonomy" | "host_authority" };
+  grant: { source: AutonomySource };
   deletedBranch: boolean | { error: string };
   recorded: { id: string } | { error: string };
 };

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.`;
+  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/claude-code.ts

@@ -60,14 +60,6 @@ export const CLAUDE_CODE_DESCRIPTOR: HostDescriptor = {
   shellAvailable: "native",
   perEventCost: "low",
   capabilities: [
-    {
-      name: "interactive_decision",
-      surface: "AskUserQuestion",
-      refs: ["AskUserQuestion"],
-      requires: [],
-      assurance: "agent_guided",
-      reason: "Claude Code hooks expose no native question answer receipt",
-    },
     {
       name: "known_product_writes",
       surface: "PreToolUse",

package/src/hooks/hosts/codex.ts

@@ -77,14 +77,6 @@ export const CODEX_DESCRIPTOR: HostDescriptor = {
   shellAvailable: "native",
   perEventCost: "low",
   capabilities: [
-    {
-      name: "interactive_decision",
-      surface: "Question",
-      refs: ["Question"],
-      requires: [],
-      assurance: "agent_guided",
-      reason: "Codex hooks expose no native arbitrary-question answer receipt",
-    },
     {
       name: "known_product_writes",
       surface: "PreToolUse",
@@ -111,7 +103,7 @@ export const CODEX_DESCRIPTOR: HostDescriptor = {
       requires: ["event:subagent.start", "event:subagent.stop"],
       observed: ["subagent.start", "subagent.stop"],
       assurance: "agent_guided",
-      reason: "Codex reports stable child identities, but cannot block creation or bind a writer",
+      reason: "Codex reports stable child identities, but cannot block creation",
       unavailableReason: "Codex subagent lifecycle hooks are untrusted or incomplete",
     },
     {
@@ -292,7 +284,6 @@ 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${input.session.id ? ` --actor ${input.session.id}` : ""}. 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 (workit grant show); a question answer is not host permission.</workit-codex-mutations>`,
 };

package/src/hooks/hosts/cursor.ts

@@ -78,14 +78,6 @@ export const CURSOR_DESCRIPTOR: HostDescriptor = {
   // Every hook spawns `npx -y --prefer-online …@latest`: a registry round-trip per event.
   perEventCost: "npx-network",
   capabilities: [
-    {
-      name: "interactive_decision",
-      surface: "AskQuestion",
-      refs: ["AskQuestion"],
-      requires: [],
-      assurance: "agent_guided",
-      reason: "Cursor does not expose AskQuestion answers to Workit hooks or MCP",
-    },
     {
       name: "known_product_writes",
       surface: "preToolUse",

package/src/hooks/hosts/opencode.ts

@@ -40,14 +40,6 @@ export const OPENCODE_DESCRIPTOR: HostDescriptor = {
   shellAvailable: "native",
   perEventCost: "low",
   capabilities: [
-    {
-      name: "interactive_decision",
-      surface: "question",
-      refs: ["question"],
-      requires: ["interaction.questions"],
-      assurance: "enforced",
-      reason: "native question answers are observed by tool.execute.after and consumed once",
-    },
     {
       name: "known_product_writes",
       surface: "edit/shell",

package/src/hooks/hosts/pi.ts

@@ -49,16 +49,6 @@ export const PI_DESCRIPTOR: HostDescriptor = {
       reason:
         "Pi exposes a before-tool boundary for known built-in write tools; it enforces project trust while file targets stay host-policy.",
     },
-    {
-      name: "interactive_decision",
-      surface: "ui.confirm",
-      refs: ["ui.confirm"],
-      requires: ["interaction.questions"],
-      observed: ["ui"],
-      assurance: "enforced",
-      reason: "Pi supplies a native confirmation receipt when dialog UI is available.",
-      unavailableReason: "Pi is running without dialog UI, so required decisions need user input.",
-    },
     {
       name: "arbitrary_shell_write",
       surface: "bash",

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/templates/workit-contract.md

@@ -2,9 +2,10 @@
 
 Workit keeps one accountable lead and one shared task state. Inspect current
 task state before acting; use only the shared operations for task, policy,
-evidence, finding, decision, worker, writer, and state changes. Authority is
+evidence, finding, decision, worker, and state changes. Authority is
 bounded by the requested scope, current revision, caller/session provenance, and
-observed capabilities. Never claim host enforcement or evidence that the host
+observed capabilities; delivery is bounded by the workspace autonomy grants
+(`workit grant show`). Never claim host enforcement or evidence that the host
 cannot provide. Preserve unresolved requirements, gaps, and uncertain workers.
 
 Focused methods are loaded only when the resolved policy requires them. A method

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.

package/skills/workit-challenge/SKILL.md

@@ -1,47 +0,0 @@
----
-name: workit-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. |

package/skills/workit-diagram/SKILL.md

@@ -1,27 +0,0 @@
----
-name: workit-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.

package/skills/workit-green-run/SKILL.md

@@ -1,24 +0,0 @@
----
-name: workit-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.

package/skills/workit-handoff/SKILL.md

@@ -1,37 +0,0 @@
----
-name: workit-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. |

package/skills/workit-mockup/SKILL.md

@@ -1,23 +0,0 @@
----
-name: workit-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.

package/skills/workit-plan/SKILL.md

@@ -1,45 +0,0 @@
----
-name: workit-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. |