work-kit-cli 0.2.8 → 0.3.0

package/README.md

@@ -1,6 +1,6 @@
 # work-kit
 
-Structured development workflow for [Claude Code](https://claude.com/claude-code). Two modes, 6 phases, 27 sub-stages — orchestrated by a TypeScript CLI with reusable skill files.
+Structured development workflow for [Claude Code](https://claude.com/claude-code). Two modes, 6 phases, 27 steps — orchestrated by a TypeScript CLI with reusable skill files.
 
 ## Installation
 
@@ -33,13 +33,13 @@ npx work-kit-cli setup
 
 ### `/full-kit <description>`
 
-Runs every phase and sub-stage in strict order. No shortcuts.
+Runs every phase and step in strict order. No shortcuts.
 
 Best for: large features, new systems, maximum rigor.
 
 ### `/auto-kit <description>`
 
-Classifies the request (bug-fix, small-change, refactor, feature, large-feature) and builds a dynamic workflow with only the sub-stages needed.
+Classifies the request (bug-fix, small-change, refactor, feature, large-feature) and builds a dynamic workflow with only the steps needed.
 
 Best for: bug fixes, small changes, refactors, well-understood tasks.
 
@@ -48,9 +48,9 @@ Best for: bug fixes, small changes, refactors, well-understood tasks.
 | Command | Description |
 |---------|-------------|
 | `init <description>` | Initialize a new workflow with a task description |
-| `next` | Advance to the next sub-stage |
-| `complete` | Mark the current sub-stage as complete |
-| `status` | Show current workflow state (phase, sub-stage, progress) |
+| `next` | Advance to the next step |
+| `complete` | Mark the current step as complete |
+| `status` | Show current workflow state (phase, step, progress) |
 | `context` | Generate context summary for the current phase |
 | `validate` | Validate state integrity and phase prerequisites |
 | `loopback` | Route back to a previous stage (max 2 per route) |
@@ -60,7 +60,7 @@ Best for: bug fixes, small changes, refactors, well-understood tasks.
 
 ## Phases
 
-| Phase | Sub-stages | Agent |
+| Phase | Steps | Agent |
 |-------|-----------|-------|
 | **Plan** | Clarify, Investigate, Sketch, Scope, UX Flow, Architecture, Blueprint, Audit | Single |
 | **Build** | Setup, Migration, Red, Core, UI, Refactor, Integration, Commit | Single |
@@ -81,7 +81,7 @@ Phases communicate through **Final sections** in `.work-kit/state.md`. Each phas
 
 Dual state files in `.work-kit/`:
 
-- **tracker.json** — state machine (current phase, sub-stage, transitions, loop-back counts)
+- **tracker.json** — state machine (current phase, step, transitions, loop-back counts)
 - **state.md** — content (working notes, Final sections, accumulated context)
 
 All writes are atomic to prevent state corruption.
@@ -129,15 +129,15 @@ work-kit/
     full-kit/SKILL.md   # /full-kit orchestrator
     auto-kit/SKILL.md   # /auto-kit orchestrator
     plan/SKILL.md       # Plan phase runner
-    plan/stages/        # 8 stage files
+    plan/steps/        # 8 step files
     build/SKILL.md      # Build phase runner
-    build/stages/       # 8 stage files
+    build/steps/       # 8 step files
     test/SKILL.md       # Test phase runner
-    test/stages/        # 3 stage files
+    test/steps/        # 3 step files
     review/SKILL.md     # Review phase runner
-    review/stages/      # 5 stage files
+    review/steps/      # 5 step files
     deploy/SKILL.md     # Deploy phase runner
-    deploy/stages/      # 3 stage files
+    deploy/steps/      # 3 step files
     wrap-up/SKILL.md    # Final summary + cleanup
   package.json
 ```

package/cli/src/commands/bootstrap.ts

@@ -1,5 +1,7 @@
 import fs from "node:fs";
-import { findWorktreeRoot, readState, statePath } from "../state/store.js";
+import { findWorktreeRoot, readState, writeState, statePath } from "../state/store.js";
+import { unpause } from "../state/helpers.js";
+import { CLI_BINARY, STALE_THRESHOLD_MS } from "../config/constants.js";
 
 export interface BootstrapResult {
   active: boolean;
@@ -7,13 +9,20 @@ export interface BootstrapResult {
   branch?: string;
   mode?: string;
   phase?: string | null;
-  subStage?: string | null;
+  step?: string | null;
   status?: string;
+  pausedAt?: string;
+  resumed?: boolean;
+  resumeReason?: string;
   nextAction?: string;
   recovery?: string | null;
 }
 
-export function bootstrapCommand(startDir?: string): BootstrapResult {
+export interface BootstrapOptions {
+  autoResume?: boolean;
+}
+
+export function bootstrapCommand(startDir?: string, options: BootstrapOptions = {}): BootstrapResult {
   const root = findWorktreeRoot(startDir);
 
   if (!root) {
@@ -26,29 +35,44 @@ export function bootstrapCommand(startDir?: string): BootstrapResult {
 
   const state = readState(root);
 
-  // Check for staleness: if state file hasn't been modified in over 1 hour
   let recovery: string | null = null;
+  let isStale = false;
   try {
-    const stateFile = statePath(root);
-    const stat = fs.statSync(stateFile);
-    const hourAgo = Date.now() - 60 * 60 * 1000;
-    if (stat.mtimeMs < hourAgo) {
+    const stat = fs.statSync(statePath(root));
+    if (Date.now() - stat.mtimeMs > STALE_THRESHOLD_MS) {
+      isStale = true;
       const hoursAgo = Math.round((Date.now() - stat.mtimeMs) / (60 * 60 * 1000));
-      recovery = `State appears stale (last update ~${hoursAgo}h ago). Run \`npx work-kit-cli status\` to diagnose. If the agent crashed mid-stage, run \`npx work-kit-cli next\` to resume.`;
+      recovery = `State appears stale (last update ~${hoursAgo}h ago). Run \`${CLI_BINARY} status\` to diagnose. If the agent crashed mid-step, run \`${CLI_BINARY} next\` to resume.`;
     }
   } catch {
-    // Ignore stat errors
+    // ignore stat errors
+  }
+
+  let resumed = false;
+  let resumeReason: string | undefined;
+  if (options.autoResume) {
+    if (unpause(state)) {
+      writeState(root, state);
+      resumed = true;
+      resumeReason = "Was paused — auto-resumed.";
+    } else if (state.status === "in-progress" && isStale) {
+      resumed = true;
+      resumeReason = "Stale in-progress — proceeding from current step.";
+      recovery = null;
+    }
   }
 
   let nextAction: string;
   if (state.status === "completed") {
     nextAction = "Work-kit session is complete. Run wrap-up or start a new session.";
   } else if (state.status === "failed") {
-    nextAction = "Work-kit session failed. Run `npx work-kit-cli status` to see details.";
+    nextAction = `Work-kit session failed. Run \`${CLI_BINARY} status\` to see details.`;
+  } else if (state.status === "paused" && !resumed) {
+    nextAction = `Work-kit is paused${state.pausedAt ? ` (since ${state.pausedAt})` : ""}. Run \`${CLI_BINARY} resume\` to continue.`;
   } else if (recovery) {
     nextAction = recovery;
   } else {
-    nextAction = `Continue ${state.currentPhase ?? "next phase"}${state.currentSubStage ? "/" + state.currentSubStage : ""}. Run \`npx work-kit-cli next\` to get the agent prompt.`;
+    nextAction = `Continue ${state.currentPhase ?? "next phase"}${state.currentStep ? "/" + state.currentStep : ""}. Run \`${CLI_BINARY} next\` to get the agent prompt.`;
   }
 
   return {
@@ -57,8 +81,10 @@ export function bootstrapCommand(startDir?: string): BootstrapResult {
     branch: state.branch,
     mode: state.mode,
     phase: state.currentPhase,
-    subStage: state.currentSubStage,
+    step: state.currentStep,
     status: state.status,
+    ...(state.pausedAt && { pausedAt: state.pausedAt }),
+    ...(resumed && { resumed: true, resumeReason }),
     nextAction,
     recovery,
   };

package/cli/src/commands/cancel.ts

@@ -1,7 +1,7 @@
 import { execFileSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { readState, findWorktreeRoot, stateDir } from "../state/store.js";
+import { readState, findWorktreeRoot, stateDir, resolveMainRepoRoot } from "../state/store.js";
 
 export interface CancelResult {
   action: "cancelled" | "error";
@@ -12,21 +12,6 @@ export interface CancelResult {
   message: string;
 }
 
-function resolveMainRepoRoot(worktreeRoot: string): string {
-  try {
-    const output = execFileSync("git", ["worktree", "list", "--porcelain"], {
-      cwd: worktreeRoot,
-      encoding: "utf-8",
-      timeout: 5000,
-    });
-    const firstLine = output.split("\n").find(l => l.startsWith("worktree "));
-    if (firstLine) return firstLine.slice("worktree ".length).trim();
-  } catch {
-    // fallback
-  }
-  return worktreeRoot;
-}
-
 export function cancelCommand(worktreeRoot?: string): CancelResult {
   const root = worktreeRoot || findWorktreeRoot();
   if (!root) {

package/cli/src/commands/complete.ts

@@ -1,12 +1,13 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { execFileSync } from "node:child_process";
-import { readState, writeState, findWorktreeRoot, readStateMd, statePath } from "../state/store.js";
-import { isPhaseComplete, nextSubStageInPhase } from "../engine/transitions.js";
-import { checkLoopback } from "../engine/loopbacks.js";
-import { PHASE_ORDER } from "../config/phases.js";
+import { readState, writeState, findWorktreeRoot, readStateMd, statePath, resolveMainRepoRoot, clearBlockingMarkers, STATE_MD_FILE, STATE_FILE } from "../state/store.js";
+import { isPhaseComplete, nextStepInPhase } from "../workflow/transitions.js";
+import { checkLoopback, countLoopbacksForRoute } from "../workflow/loopbacks.js";
+import { PHASE_ORDER } from "../config/workflow.js";
 import { parseLocation, resetToLocation } from "../state/helpers.js";
-import type { Action, PhaseName, WorkKitState } from "../state/schema.js";
+import { TRACKER_DIR, ARCHIVE_DIR, INDEX_FILE, SUMMARY_FILE, MAX_LOOPBACKS_PER_ROUTE, CLI_BINARY } from "../config/constants.js";
+import { isStepOutcome, STEP_OUTCOMES, type Action, type PhaseName, type StepOutcome, type WorkKitState } from "../state/schema.js";
+import { stateMdPath } from "../state/store.js";
 
 export function completeCommand(target: string, outcome?: string, worktreeRoot?: string): Action {
   const root = worktreeRoot || findWorktreeRoot();
@@ -14,55 +15,62 @@ export function completeCommand(target: string, outcome?: string, worktreeRoot?:
     return { action: "error", message: "No work-kit state found. Run `work-kit init` first." };
   }
 
+  // Forward state transition → clear any stale "blocked on user" markers
+  clearBlockingMarkers(root);
+
+  // Validate outcome against the closed enum
+  let typedOutcome: StepOutcome | undefined;
+  if (outcome) {
+    if (!isStepOutcome(outcome)) {
+      return {
+        action: "error",
+        message: `Invalid outcome "${outcome}".`,
+        suggestion: `Valid outcomes: ${STEP_OUTCOMES.join(", ")}`,
+      };
+    }
+    typedOutcome = outcome;
+  }
+
   const state = readState(root);
-  const { phase, subStage } = parseLocation(target);
+  const { phase, step } = parseLocation(target);
 
-  // Validate phase exists
   if (!state.phases[phase]) {
     return { action: "error", message: `Unknown phase: ${phase}` };
   }
 
-  // Validate sub-stage exists
-  const ssState = state.phases[phase].subStages[subStage];
-  if (!ssState) {
-    return { action: "error", message: `Unknown sub-stage: ${phase}/${subStage}` };
+  const stepState = state.phases[phase].steps[step];
+  if (!stepState) {
+    return { action: "error", message: `Unknown step: ${phase}/${step}` };
   }
 
-  // Validate sub-stage is in a completable state
-  if (ssState.status === "completed") {
-    return { action: "error", message: `${phase}/${subStage} is already completed.` };
+  if (stepState.status === "completed") {
+    return { action: "error", message: `${phase}/${step} is already completed.` };
   }
-  if (ssState.status === "skipped") {
-    return { action: "error", message: `${phase}/${subStage} is skipped and cannot be completed. Add it to the workflow first.` };
+  if (stepState.status === "skipped") {
+    return { action: "error", message: `${phase}/${step} is skipped and cannot be completed. Add it to the workflow first.` };
   }
 
-  // Mark sub-stage complete
-  ssState.status = "completed";
-  ssState.completedAt = new Date().toISOString();
-  if (outcome) {
-    ssState.outcome = outcome;
+  stepState.status = "completed";
+  stepState.completedAt = new Date().toISOString();
+  if (typedOutcome) {
+    stepState.outcome = typedOutcome;
   }
 
-  // Check for loop-back triggers
-  const loopback = checkLoopback(phase, subStage, outcome);
+  const loopback = checkLoopback(phase, step, typedOutcome);
   if (loopback) {
-    // Enforce max 2 loopbacks per route
-    const sameRouteCount = state.loopbacks.filter(
-      (lb) => lb.from.phase === phase && lb.from.subStage === subStage
-        && lb.to.phase === loopback.to.phase && lb.to.subStage === loopback.to.subStage
-    ).length;
-
-    if (sameRouteCount >= 2) {
-      // Max reached — proceed without looping back, note the caveat
+    const from = { phase, step };
+    const sameRouteCount = countLoopbacksForRoute(state.loopbacks, from, loopback.to);
+
+    if (sameRouteCount >= MAX_LOOPBACKS_PER_ROUTE) {
       writeState(root, state);
       return {
         action: "wait_for_user",
-        message: `${phase}/${subStage} triggered loopback (outcome: ${outcome}) but max loopback count (2) reached for this route. Proceeding with noted caveats.`,
+        message: `${phase}/${step} triggered loopback (outcome: ${typedOutcome}) but max loopback count (${MAX_LOOPBACKS_PER_ROUTE}) reached for this route. Proceeding with noted caveats.`,
       };
     }
 
     state.loopbacks.push({
-      from: { phase, subStage },
+      from,
       to: loopback.to,
       reason: loopback.reason,
       timestamp: new Date().toISOString(),
@@ -70,135 +78,121 @@ export function completeCommand(target: string, outcome?: string, worktreeRoot?:
 
     resetToLocation(state, loopback.to);
     state.currentPhase = loopback.to.phase;
-    state.currentSubStage = loopback.to.subStage;
+    state.currentStep = loopback.to.step;
 
     writeState(root, state);
 
     return {
       action: "loopback",
-      from: { phase, subStage },
+      from,
       to: loopback.to,
       reason: loopback.reason,
     };
   }
 
-  // Check if the phase is now complete
   if (isPhaseComplete(state, phase)) {
     state.phases[phase].status = "completed";
     state.phases[phase].completedAt = new Date().toISOString();
 
-    // Find next phase
     const phaseIdx = PHASE_ORDER.indexOf(phase);
     const nextPhases = PHASE_ORDER.slice(phaseIdx + 1);
-    let nextPhase: PhaseName | null = null;
+    let nextPhaseName: PhaseName | null = null;
 
     for (const np of nextPhases) {
       if (state.phases[np].status !== "skipped") {
-        nextPhase = np;
+        nextPhaseName = np;
         break;
       }
     }
 
-    if (!nextPhase) {
+    if (!nextPhaseName) {
       state.status = "completed";
       state.currentPhase = null;
-      state.currentSubStage = null;
+      state.currentStep = null;
       writeState(root, state);
-      archiveCompleted(root, state);
+      archiveOnComplete(root, state);
       return { action: "complete", message: "All phases complete. Work-kit finished." };
     }
 
-    // Mark the first pending sub-stage of the next phase as "waiting"
-    // so the observer can distinguish "running" from "waiting for human"
-    const nextSubs = Object.entries(state.phases[nextPhase].subStages);
-    const firstPending = nextSubs.find(([_, ss]) => ss.status === "pending");
+    const nextSteps = Object.entries(state.phases[nextPhaseName].steps);
+    const firstPending = nextSteps.find(([_, s]) => s.status === "pending");
     if (firstPending) {
       firstPending[1].status = "waiting";
     }
 
-    state.currentPhase = nextPhase;
-    state.currentSubStage = firstPending ? firstPending[0] : null;
+    state.currentPhase = nextPhaseName;
+    state.currentStep = firstPending ? firstPending[0] : null;
     writeState(root, state);
 
     return {
       action: "wait_for_user",
-      message: `${phase} phase complete. Ready to start ${nextPhase}. Proceed?`,
+      message: `${phase} phase complete. Ready to start ${nextPhaseName}. Proceed?`,
     };
   }
 
-  // Advance currentSubStage to the next pending sub-stage so the observer refreshes
-  const nextSS = nextSubStageInPhase(state, phase);
-  if (nextSS) {
-    state.currentSubStage = nextSS;
-  } else {
-    state.currentSubStage = null;
-  }
+  const next = nextStepInPhase(state, phase);
+  state.currentStep = next ?? null;
 
   writeState(root, state);
 
   return {
     action: "wait_for_user",
-    message: `${phase}/${subStage} complete${outcome ? ` (outcome: ${outcome})` : ""}. Run \`npx work-kit-cli next\` to continue.`,
+    message: `${phase}/${step} complete${typedOutcome ? ` (outcome: ${typedOutcome})` : ""}. Run \`${CLI_BINARY} next\` to continue.`,
   };
 }
 
 // ── Archive on completion ──────────────────────────────────────────
 
-function resolveMainRepoRoot(worktreeRoot: string): string {
-  try {
-    // git worktree list --porcelain — first "worktree" line is always the main repo
-    const output = execFileSync("git", ["worktree", "list", "--porcelain"], {
-      cwd: worktreeRoot,
-      encoding: "utf-8",
-      timeout: 5000,
-    });
-    const firstLine = output.split("\n").find(l => l.startsWith("worktree "));
-    if (firstLine) return firstLine.slice("worktree ".length).trim();
-  } catch {
-    // fallback
-  }
-  return worktreeRoot;
+function archiveFolderName(slug: string, completedAt: string): string {
+  return `${slug}-${completedAt.split("T")[0]}`;
 }
 
-function archiveCompleted(worktreeRoot: string, state: WorkKitState): void {
+/**
+ * Single-step archive: copies state.md, tracker.json, and summary.md (if the
+ * wrap-up step wrote one) into `<main>/.work-kit-tracker/archive/<slug>-<date>/`,
+ * then appends a row to the index. Uses a single timestamp captured at the
+ * moment of completion to avoid date drift across multiple archive calls.
+ */
+function archiveOnComplete(worktreeRoot: string, state: WorkKitState): void {
   const mainRoot = resolveMainRepoRoot(worktreeRoot);
-  const date = new Date().toISOString().split("T")[0];
   const slug = state.slug;
-  const wkDir = path.join(mainRoot, ".work-kit-tracker");
-  const folderName = `${slug}-${date}`;
-  const archiveDir = path.join(wkDir, "archive", folderName);
+  const completedAt = new Date().toISOString();
+  const date = completedAt.split("T")[0];
+
+  const wkDir = path.join(mainRoot, TRACKER_DIR);
+  const folderName = archiveFolderName(slug, completedAt);
+  const archiveDir = path.join(wkDir, ARCHIVE_DIR, folderName);
 
-  // Ensure archive folder exists
   fs.mkdirSync(archiveDir, { recursive: true });
 
-  // Archive state.md (full phase outputs)
   const stateMd = readStateMd(worktreeRoot);
   if (stateMd) {
-    fs.writeFileSync(path.join(archiveDir, "state.md"), stateMd, "utf-8");
+    fs.writeFileSync(path.join(archiveDir, STATE_MD_FILE), stateMd, "utf-8");
   }
 
-  // Archive tracker.json (full JSON with phases, timing, status)
-  const trackerPath = statePath(worktreeRoot);
-  if (fs.existsSync(trackerPath)) {
-    fs.copyFileSync(trackerPath, path.join(archiveDir, "tracker.json"));
+  const trackerSrc = statePath(worktreeRoot);
+  if (fs.existsSync(trackerSrc)) {
+    fs.copyFileSync(trackerSrc, path.join(archiveDir, STATE_FILE));
   }
 
-  // Write placeholder summary.md (wrap-up skill will overwrite with distilled summary)
-  const summaryPath = path.join(archiveDir, "summary.md");
-  if (!fs.existsSync(summaryPath)) {
-    const completedPhases = PHASE_ORDER
-      .filter(p => state.phases[p].status === "completed")
-      .join("→");
-    fs.writeFileSync(summaryPath, `---\nslug: ${slug}\nbranch: ${state.branch}\nstarted: ${state.started.split("T")[0]}\ncompleted: ${date}\nstatus: completed\n---\n\n## Summary\n\nPhases: ${completedPhases}\n\n_Pending wrap-up summary._\n`, "utf-8");
-  }
-
-  // Compute completed phases
+  const summarySrc = path.join(path.dirname(stateMdPath(worktreeRoot)), SUMMARY_FILE);
+  const summaryDest = path.join(archiveDir, SUMMARY_FILE);
   const completedPhases = PHASE_ORDER
     .filter(p => state.phases[p].status === "completed")
     .join("→");
 
-  // Append to index.md with links to summary and archive folder
-  const indexPath = path.join(wkDir, "index.md");
+  if (fs.existsSync(summarySrc)) {
+    fs.copyFileSync(summarySrc, summaryDest);
+  } else {
+    // Placeholder summary if the wrap-up agent didn't write one
+    fs.writeFileSync(
+      summaryDest,
+      `---\nslug: ${slug}\nbranch: ${state.branch}\nstarted: ${state.started.split("T")[0]}\ncompleted: ${date}\nstatus: completed\n---\n\n## Summary\n\nPhases: ${completedPhases}\n\n_Pending wrap-up summary._\n`,
+      "utf-8"
+    );
+  }
+
+  const indexPath = path.join(wkDir, INDEX_FILE);
   let indexContent = "";
   if (fs.existsSync(indexPath)) {
     indexContent = fs.readFileSync(indexPath, "utf-8");
@@ -206,8 +200,8 @@ function archiveCompleted(worktreeRoot: string, state: WorkKitState): void {
   if (!indexContent.includes("| Date ")) {
     indexContent = "| Date | Slug | PR | Status | Phases | Summary | Archive |\n| --- | --- | --- | --- | --- | --- | --- |\n";
   }
-  const summaryLink = `[summary](archive/${folderName}/summary.md)`;
-  const archiveLink = `[archive](archive/${folderName}/)`;
+  const summaryLink = `[summary](${ARCHIVE_DIR}/${folderName}/${SUMMARY_FILE})`;
+  const archiveLink = `[archive](${ARCHIVE_DIR}/${folderName}/)`;
   indexContent += `| ${date} | ${slug} | n/a | completed | ${completedPhases} | ${summaryLink} | ${archiveLink} |\n`;
   fs.writeFileSync(indexPath, indexContent, "utf-8");
 }

package/cli/src/commands/completions.ts

@@ -33,7 +33,7 @@ _work_kit() {
   commands=(
     'init:Create worktree and initialize state'
     'next:Get the next action to perform'
-    'complete:Mark a phase/sub-stage as complete'
+    'complete:Mark a phase/step as complete'
     'status:Show current state summary'
     'context:Extract Final sections needed for a phase agent'
     'validate:Check prerequisites for a phase'
@@ -92,7 +92,7 @@ complete -c work-kit -f
 # Top-level commands
 complete -c work-kit -n '__fish_use_subcommand' -a 'init' -d 'Create worktree and initialize state'
 complete -c work-kit -n '__fish_use_subcommand' -a 'next' -d 'Get the next action to perform'
-complete -c work-kit -n '__fish_use_subcommand' -a 'complete' -d 'Mark a phase/sub-stage as complete'
+complete -c work-kit -n '__fish_use_subcommand' -a 'complete' -d 'Mark a phase/step as complete'
 complete -c work-kit -n '__fish_use_subcommand' -a 'status' -d 'Show current state summary'
 complete -c work-kit -n '__fish_use_subcommand' -a 'context' -d 'Extract Final sections needed for a phase agent'
 complete -c work-kit -n '__fish_use_subcommand' -a 'validate' -d 'Check prerequisites for a phase'

package/cli/src/commands/doctor.ts

@@ -62,7 +62,7 @@ export function doctorCommand(worktreeRoot?: string): { ok: boolean; checks: Che
   if (root && stateExists(root)) {
     try {
       const state = readState(root);
-      if (state.version === 1 && state.slug && state.status) {
+      if (state.version === 2 && state.slug && state.status) {
         checks.push({ name: "state", status: "pass", message: `Active work-kit: "${state.slug}" (${state.status})` });
       } else {
         checks.push({ name: "state", status: "warn", message: "tracker.json exists but has unexpected structure" });