@stylusnexus/work-plan 2026.6.13 → 2026.6.14-1

package/skills/work-plan/commands/plan_baseline.py

@@ -0,0 +1,85 @@
+"""plan-baseline — stamp the CURRENT computed verdict into a plan/spec doc's YAML
+frontmatter as a drift baseline (#286 slice 2).
+
+Distinct from `plan-confirm` (a human *pin* that overrides the verdict) and from
+the body status banner (`plan-status --stamp`). This records `verdict_baseline:
+<computed>` so `plan-status` can later flag **drift** — when the live computed
+verdict diverges from the stamped baseline (e.g. a once-shipped plan whose
+declared files were deleted, silently regressing to partial). It is the third
+"started, then drifted off" signal the Plans view otherwise can't see.
+
+Frontmatter-only (never the body/manifest/checkboxes/banner). The baseline value
+is computed authoritatively here (the same evaluator plan-status uses), not taken
+from the caller.
+
+Usage:
+    work_plan.py plan-baseline --repo=<key> [--confirm=<token>] -- <rel>
+    work_plan.py plan-baseline --repo=<key> --clear [--confirm=<token>] -- <rel>
+"""
+import sys
+from datetime import date
+
+from lib import config as config_mod
+from lib import doc_discovery
+from lib import plan_fm
+from lib import verdict as verdict_mod
+from lib.prompts import parse_flags
+from commands.plan_status import evaluate_doc
+
+KNOWN = {"--repo", "--clear", "--confirm"}
+
+
+def run(args: list) -> int:
+    flags, positional = parse_flags(args, KNOWN)
+
+    repo = flags.get("--repo")
+    if not repo or repo is True:
+        print("ERROR: --repo=<key> is required.", file=sys.stderr)
+        return 2
+    if not positional:
+        print("usage: work_plan.py plan-baseline --repo=<key> [--clear] -- <rel>",
+              file=sys.stderr)
+        return 2
+    rel = positional[0]
+    clear = bool(flags.get("--clear"))
+
+    try:
+        cfg = config_mod.load_config()
+    except config_mod.ConfigError as e:
+        print(f"ERROR: {e}", file=sys.stderr)
+        return 1
+
+    local = config_mod.resolve_local_path_for_folder(repo, cfg)
+    if not local or not local.exists():
+        print(f"repo '{repo}' has no resolvable local path in config", file=sys.stderr)
+        return 2
+
+    doc_path = plan_fm.resolve_doc_path(local, rel)
+    if doc_path is None:
+        print(f"ERROR: '{rel}' is not a file inside {local}", file=sys.stderr)
+        return 1
+
+    slug = config_mod.resolve_github_for_folder(repo, cfg)
+    action = "clearing the verdict baseline on" if clear else f"stamping a verdict baseline on '{rel}' via"
+    if not plan_fm.public_repo_gate(slug, rel, cfg, flags.get("--confirm"), action):
+        return 0
+
+    if clear:
+        if not plan_fm.set_key(doc_path, "verdict_baseline", None):
+            print(f"✓ {rel} had no verdict baseline (nothing to clear).")
+            return 0
+        print(f"✓ cleared verdict baseline on {rel} (frontmatter only).")
+        return 0
+
+    # Compute the verdict authoritatively (same evaluator plan-status uses).
+    doc = doc_discovery.Doc(path=doc_path, rel=rel,
+                            kind=doc_discovery.classify_kind(rel))
+    cfg_stall = cfg.get("stall_days")
+    stall_days = cfg_stall if isinstance(cfg_stall, int) else verdict_mod.STALL_DAYS
+    row = evaluate_doc(doc, local, date.today(), verdict_mod.DEAD_DAYS, stall_days)
+    verdict = row["verdict"]
+
+    plan_fm.set_key(doc_path, "verdict_baseline", verdict)
+    print(f"✓ {rel} baseline stamped at '{verdict}' — wrote verdict_baseline to "
+          f"frontmatter only. plan-status will flag drift if the live verdict changes.")
+    return 0

package/skills/work-plan/commands/plan_confirm.py

@@ -0,0 +1,83 @@
+"""plan-confirm — write a human `verdict_override` into a plan/spec doc's YAML
+frontmatter (#286).
+
+This is the one viewer-driven write to a plan doc, and it is **frontmatter-only**
+by hard constraint: it touches the doc's YAML frontmatter and nothing else — never
+the prose body, the declared-file manifest, the checkboxes, or the status banner.
+A reviewer uses it to affirm a verdict the mechanical heuristic got wrong (e.g. a
+genuinely-shipped plan whose phase checkboxes were never ticked), which silences
+the "shipped but boxes unchecked" lie-gap on the next `plan-status` read.
+
+Usage:
+    work_plan.py plan-confirm --repo=<key> --verdict=shipped|partial|dead [--confirm=<token>] -- <rel>
+    work_plan.py plan-confirm --repo=<key> --clear [--confirm=<token>] -- <rel>
+
+`<rel>` is the repo-relative POSIX path of the plan doc (as emitted by
+`plan-status --json`). It is validated to resolve to a real file inside the repo,
+so a caller can't redirect the write outside the checkout.
+"""
+import sys
+
+from lib import config as config_mod
+from lib import plan_fm
+from lib.prompts import parse_flags
+
+VALID_VERDICTS = {"shipped", "partial", "dead"}
+KNOWN = {"--repo", "--verdict", "--clear", "--confirm"}
+
+
+def run(args: list) -> int:
+    flags, positional = parse_flags(args, KNOWN)
+
+    repo = flags.get("--repo")
+    if not repo or repo is True:
+        print("ERROR: --repo=<key> is required.", file=sys.stderr)
+        return 2
+    if not positional:
+        print("usage: work_plan.py plan-confirm --repo=<key> "
+              "--verdict=shipped|partial|dead [--clear] -- <rel>", file=sys.stderr)
+        return 2
+    rel = positional[0]
+
+    clear = bool(flags.get("--clear"))
+    verdict = flags.get("--verdict")
+    if not clear:
+        if not verdict or verdict is True or verdict not in VALID_VERDICTS:
+            print("ERROR: --verdict must be one of shipped|partial|dead "
+                  "(or pass --clear to remove the override).", file=sys.stderr)
+            return 2
+
+    try:
+        cfg = config_mod.load_config()
+    except config_mod.ConfigError as e:
+        print(f"ERROR: {e}", file=sys.stderr)
+        return 1
+
+    local = config_mod.resolve_local_path_for_folder(repo, cfg)
+    if not local or not local.exists():
+        print(f"repo '{repo}' has no resolvable local path in config", file=sys.stderr)
+        return 2
+
+    doc_path = plan_fm.resolve_doc_path(local, rel)
+    if doc_path is None:
+        print(f"ERROR: '{rel}' is not a file inside {local}", file=sys.stderr)
+        return 1
+
+    # Public-repo confirm gate (the extension surfaces this as a modal). The token
+    # is keyed on (slug, rel) — the same shape close/set use, so the viewer's
+    # existing executeWrite token flow drives it unchanged.
+    slug = config_mod.resolve_github_for_folder(repo, cfg)
+    action = "clearing the verdict override on" if clear else f"marking '{rel}' as {verdict} via"
+    if not plan_fm.public_repo_gate(slug, rel, cfg, flags.get("--confirm"), action):
+        return 0
+
+    if clear:
+        if not plan_fm.set_key(doc_path, "verdict_override", None):
+            print(f"✓ no verdict override on {rel} (nothing to clear).")
+            return 0
+        print(f"✓ cleared verdict override on {rel} (frontmatter only).")
+        return 0
+
+    plan_fm.set_key(doc_path, "verdict_override", verdict)
+    print(f"✓ {rel} confirmed {verdict} — wrote verdict_override to frontmatter only.")
+    return 0

package/skills/work-plan/commands/plan_status.py

@@ -11,6 +11,7 @@ from pathlib import Path
 
 from lib import config as config_mod
 from lib import doc_discovery, manifest, git_state, github_state
+from lib import frontmatter
 from lib import verdict as verdict_mod
 from lib import status_header
 from lib import llm_evidence
@@ -22,6 +23,42 @@ KNOWN = {"--repo", "--json", "--since-days", "--type", "--stamp", "--draft",
          "--llm", "--apply", "--archive", "--issues", "--stall-days"}
 _ORDER = ["shipped", "partial", "dead", "foreign", "manifest-less"]
 
+# Human verdict-override (#286): a reviewer affirms the verdict in the doc's
+# YAML frontmatter, so the mechanical heuristic (file score + checkbox %) stops
+# second-guessing it — and the "shipped but boxes unchecked" lie-gap goes quiet.
+_OVERRIDE_VERDICTS = {"shipped", "partial", "dead"}
+_OVERRIDE_GLYPH = {"shipped": "✅", "partial": "🟡", "dead": "💀"}
+
+
+def _read_fm_signals(path) -> tuple:
+    """Read the frontmatter signals plan-status honors (#286), in ONE parse:
+
+        (override, acknowledged, baseline)
+
+    `override` is the `verdict_override` value (case-insensitive shipped|partial|
+    dead, else None — a typo can't pin a bogus verdict). `acknowledged` is True
+    when the doc carries a truthy `acknowledged` (the durable ack plan-ack writes).
+    `baseline` is the `verdict_baseline` value (a verdict string, else None) that
+    plan-baseline stamps for drift detection. All frontmatter-only — never the
+    body/checkboxes. A doc with no frontmatter (most plans) parses to empty meta,
+    a clean (None, False, None) no-op."""
+    try:
+        meta, _ = frontmatter.parse_file(Path(path))
+    except Exception:
+        return (None, False, None)
+    if not isinstance(meta, dict):
+        return (None, False, None)
+    val = meta.get("verdict_override")
+    override = (val.strip().lower()
+                if isinstance(val, str) and val.strip().lower() in _OVERRIDE_VERDICTS
+                else None)
+    acknowledged = bool(meta.get("acknowledged"))
+    bval = meta.get("verdict_baseline")
+    baseline = (bval.strip().lower()
+                if isinstance(bval, str) and bval.strip().lower() in _OVERRIDE_VERDICTS
+                else None)
+    return (override, acknowledged, baseline)
+
 
 def _resolve_repo_root(flags) -> Path:
     repo = flags.get("--repo")
@@ -95,6 +132,14 @@ def _evaluate(doc, repo_root, today, dead_days, stall_days) -> dict:
     else:
         v = verdict_mod.classify(score, done, total_chk, last_d, today, dead_days)
 
+    # Frontmatter signals (#286): a `verdict_override` pins the verdict over the
+    # mechanical one (applied BEFORE the staleness clock + lie-gap so both key off
+    # the confirmed verdict), and `acknowledged` is the durable, shared ack.
+    override, acknowledged, baseline = _read_fm_signals(doc.path)
+    if override:
+        v = verdict_mod.Verdict(
+            override, _OVERRIDE_GLYPH[override], f"human-confirmed · {v.rationale}")
+
     # Staleness clock (#164): a partial plan whose declared manifest files have
     # gone cold = "started executing, then drifted off." Key off the manifest
     # files' commit date, NOT the plan doc's git date — plan docs are gitignored,
@@ -111,8 +156,14 @@ def _evaluate(doc, repo_root, today, dead_days, stall_days) -> dict:
                 stalled = (today - manifest_dt.date()).days >= stall_days
         # else: no declared files on disk yet -> brand-new, not stalled.
 
-    lie_gap = (v.label == "shipped" and total_chk > 0
+    # A human-confirmed verdict silences the lie-gap: the reviewer has affirmed
+    # the "shipped" claim despite unchecked boxes, so it's no longer a lie.
+    lie_gap = (not override and v.label == "shipped" and total_chk > 0
                and done / total_chk < 0.25)
+    # Drift (#286): a stamped `verdict_baseline` that no longer matches the live
+    # verdict — e.g. a once-shipped plan whose declared files were deleted. A
+    # human override owns the verdict, so it suppresses drift (same as lie-gap).
+    verdict_drift = bool(baseline) and not override and baseline != v.label
     return {
         "rel": doc.rel, "kind": doc.kind,
         "verdict": v.label, "glyph": v.glyph, "rationale": v.rationale,
@@ -122,11 +173,24 @@ def _evaluate(doc, repo_root, today, dead_days, stall_days) -> dict:
         "manifest_last_touched": manifest_dt.date().isoformat() if manifest_dt else None,
         "stalled": stalled,
         "lie_gap": lie_gap,
+        "override": override,
+        "acknowledged": acknowledged,
+        "verdict_baseline": baseline,
+        "verdict_drift": verdict_drift,
+        "offtree_paths": manifest.offtree_declared_paths(decls, repo_root),
         "unchecked_items": manifest.unchecked_checkbox_labels(text),
         "stall_days": stall_days,
     }
 
 
+# Public alias so other commands (e.g. `export`, which resolves a track's linked
+# plan badge for #285) reuse the SAME verdict/lie-gap/override evaluation instead
+# of reimplementing it and drifting. Kept at this module path so the existing
+# tests that patch `commands.plan_status.git_state.*` and call `_evaluate`
+# directly keep working unchanged.
+evaluate_doc = _evaluate
+
+
 def _render(rows, repo_root) -> None:
     print(f"# plan-status — {repo_root}\n")
     by = {}

package/skills/work-plan/commands/push_track.py

@@ -0,0 +1,156 @@
+"""push-track — promote a PRIVATE track to a repo's SHARED tier and publish it
+(#306).
+
+Tracks default to the private tier (`notes_root`, local-only, never pushed). The
+shared tier lives in a repo's `.work-plan/` on its canonical `plan_branch` (via a
+git worktree) and is how a track becomes visible to teammates. This verb moves a
+private track's `.md` into the shared `.work-plan/`, removes the private copy
+(so the track isn't duplicated), commits it to the plan branch, and pushes —
+unless `--no-push`.
+
+The tier is derived from WHERE the file lives, so promotion is a file move; no
+frontmatter edit. Pushing to a PUBLIC repo's plan branch makes the plan
+world-visible — the exposed state the viewer's visibility×tier badge warns about
+— so the push is confirm-token gated, like `plan-branch push`.
+
+Usage:
+    work_plan.py push-track <track | track@repo> [--repo=<key>] [--no-push] [--confirm=<token>]
+"""
+import json
+import sys
+from pathlib import Path
+
+from lib.config import load_config, ConfigError
+from lib.tracks import (
+    discover_tracks, find_track_by_name, parse_track_repo_arg, AmbiguousTrackError,
+)
+from lib.frontmatter import write_file
+from lib import plan_worktree as pw
+from lib.write_guard import needs_confirm, make_token, valid_token
+from lib.prompts import parse_flags
+
+KNOWN = {"--repo", "--no-push", "--confirm"}
+
+
+def run(args: list) -> int:
+    flags, positional = parse_flags(args, KNOWN)
+    if not positional:
+        print("usage: work_plan.py push-track <track> [--repo=<key>] [--no-push] "
+              "[--confirm=<token>]", file=sys.stderr)
+        return 2
+    name_from_arg, repo_from_arg = parse_track_repo_arg(positional[0])
+    repo_flag = flags.get("--repo") if flags.get("--repo") is not True else None
+    repo_qualifier = repo_from_arg or repo_flag
+    no_push = bool(flags.get("--no-push"))
+
+    try:
+        cfg = load_config()
+    except ConfigError as e:
+        print(f"ERROR: {e}", file=sys.stderr)
+        return 1
+
+    try:
+        track = find_track_by_name(name_from_arg, discover_tracks(cfg), repo=repo_qualifier)
+    except AmbiguousTrackError as e:
+        print(str(e), file=sys.stderr)
+        return 1
+    if not track:
+        print(f"No track matching '{name_from_arg}'.", file=sys.stderr)
+        return 1
+    if track.tier == "shared":
+        print(f"'{track.name}' is already in the shared tier — nothing to promote.",
+              file=sys.stderr)
+        return 1
+    if not track.folder:
+        print(f"'{track.name}' has no configured repo (folder) — can't resolve a "
+              "shared tier to promote into.", file=sys.stderr)
+        return 1
+
+    entry = (cfg.get("repos") or {}).get(track.folder) or {}
+    github = entry.get("github")
+    branch = entry.get("plan_branch")
+    local = entry.get("local")
+    if not local:
+        print(f"repo '{track.folder}' has no local clone path in config.", file=sys.stderr)
+        return 2
+    if not branch:
+        print(f"repo '{track.folder}' has no shared plan branch. Set one up first:\n"
+              f"  /work-plan plan-branch init {track.folder}", file=sys.stderr)
+        return 1
+
+    # Exposure gate (the push is what publishes). Fire BEFORE any mutation so the
+    # viewer's modal lands first; --no-push keeps it local, so no gate. Fails
+    # CLOSED on unknown visibility (same as plan-branch push).
+    if not no_push and needs_confirm(github, cfg):
+        confirm = flags.get("--confirm")
+        if not (isinstance(confirm, str) and valid_token(confirm, github, track.name)):
+            print(_needs_confirm_json(github, branch, track.name))
+            return 0
+
+    # Resolve (and ensure) the shared-tier worktree dir.
+    shared_dir = pw.shared_tier_dir(entry)
+    if shared_dir is None:
+        print(f"ERROR: could not open the shared plan branch '{branch}' for "
+              f"'{track.folder}'. Run `plan-branch init {track.folder}` first.",
+              file=sys.stderr)
+        return 1
+    dest = shared_dir / f"{track.name}.md"
+    if dest.exists():
+        print(f"ERROR: a shared track '{track.name}' already exists at {dest}.",
+              file=sys.stderr)
+        return 1
+
+    # Move: write into the shared tier (frontmatter preserved), then remove the
+    # private copy so discover_tracks shows the track once (shared), not twice.
+    write_file(dest, track.meta, track.body)
+    try:
+        track.path.unlink()
+    except OSError as e:
+        print(f"WARN: wrote the shared copy but could not remove the private "
+              f"file {track.path}: {e} — remove it by hand to avoid a duplicate.",
+              file=sys.stderr)
+
+    worktree = shared_dir.parent
+    sha = pw.commit_shared_tier(
+        worktree, f"work-plan: promote track '{track.name}' to shared tier",
+        [f".work-plan/{track.name}.md"],
+    )
+    if sha is None:
+        print(f"WARN: moved '{track.name}' into the shared tier but the commit "
+              "did not land — commit it by hand in the plan-branch worktree.",
+              file=sys.stderr)
+
+    if no_push:
+        print(f"✓ promoted '{track.name}' to the shared tier (local commit "
+              f"{sha or '—'}). Run `plan-branch push {track.folder}` to share it.")
+        return 0
+
+    proc = pw.push_plan_branch(Path(local).expanduser(), branch)
+    if proc is None or proc.returncode != 0:
+        err = (getattr(proc, "stderr", "") or "").strip()
+        if "protected" in err.lower() or "pull request" in err.lower():
+            print(f"ERROR: origin rejected the push — '{branch}' looks protected. "
+                  f"Exempt the plan branch from PR/branch-protection, or push it "
+                  "by hand once. The promotion is committed locally.", file=sys.stderr)
+        else:
+            print(f"ERROR: promoted + committed locally, but the push failed: "
+                  f"{err or 'unknown git error'}. Retry with `plan-branch push "
+                  f"{track.folder}`.", file=sys.stderr)
+        return 1
+    print(f"✓ promoted '{track.name}' to the shared tier and pushed '{branch}'. "
+          "Teammates can `plan-branch init` to see it.")
+    return 0
+
+
+def _needs_confirm_json(github, branch, name) -> str:
+    return json.dumps({
+        "needs_confirm": True,
+        "reason": (
+            f"{github} is PUBLIC (or its visibility is unknown). Promoting "
+            f"'{name}' to the shared tier and pushing '{branch}' makes that "
+            "track — its issue notes, priorities, and planning text — visible to "
+            "anyone on the internet, and it stays in public git history even if "
+            "later removed. Use --no-push to keep it local for now."
+        ),
+        "token": make_token(github, name),
+    })

package/skills/work-plan/commands/set_field.py

@@ -1,12 +1,13 @@
 """set subcommand — guarded edit of a track's frontmatter scalar/list fields."""
 import json
-from lib.config import load_config, ConfigError
+import sys
+from lib.config import load_config, ConfigError, resolve_local_path_for_folder
 from lib.tracks import discover_tracks, find_track_by_name, parse_track_repo_arg, AmbiguousTrackError
 from lib.frontmatter import write_file
 from lib.write_guard import needs_confirm, make_token, valid_token
 from lib.prompts import parse_flags
 
-ALLOWED = {"status", "launch_priority", "milestone_alignment", "blockers", "next_up", "depends_on"}
+ALLOWED = {"status", "launch_priority", "milestone_alignment", "blockers", "next_up", "depends_on", "plan"}
 LIST_FIELDS = {"blockers", "next_up"}
 STATUSES = {"active", "in-progress", "blocked", "parked", "shipped", "abandoned"}
 
@@ -39,6 +40,10 @@ def run(args: list[str]) -> int:
                 print(f"ERROR: {k} takes comma-separated integers (got {v!r})"); return 2
         elif k == "status" and v not in STATUSES:
             print(f"ERROR: status {v!r} invalid (allowed: {sorted(STATUSES)})"); return 2
+        elif k == "plan":
+            # Repo-relative path to the track's plan/spec doc (#285). Empty value
+            # clears the link. Stored as a scalar string; validated (advisory) below.
+            parsed[k] = v.strip()
         else:
             parsed[k] = v
     try:
@@ -58,7 +63,21 @@ def run(args: list[str]) -> int:
                           "reason": f"{track.repo} is PUBLIC (or visibility unknown); edit will be written there.",
                           "token": make_token(track.repo, track.name)}))
         return 0
+    # An empty `plan=` clears the link rather than writing `plan: ""` (#285).
+    if "plan" in parsed and parsed["plan"] == "":
+        parsed.pop("plan")
+        track.meta.pop("plan", None)
+    # Advisory validation: a non-empty plan path that doesn't resolve to a file in
+    # the track's repo checkout is saved anyway (the doc may not exist yet, or the
+    # repo may have no local clone) but flagged so a typo is caught early.
+    if parsed.get("plan") and track.folder:
+        local = resolve_local_path_for_folder(track.folder, cfg)
+        if local and local.exists() and not (local / parsed["plan"]).is_file():
+            print(f"WARN: plan path {parsed['plan']!r} does not resolve to a file "
+                  f"under {local} — link saved anyway.", file=sys.stderr)
+
     track.meta.update(parsed)
     write_file(track.path, track.meta, track.body)
-    print(f"✓ set {', '.join(parsed)} on {track.name}")
+    fields = ", ".join(parsed) if parsed else "plan (cleared)"
+    print(f"✓ set {fields} on {track.name}")
     return 0

package/skills/work-plan/commands/where_was_i.py

@@ -31,7 +31,9 @@ from lib.github_state import fetch_issues, short_milestone
 from lib.git_state import (
     parse_iso_timestamp,
     current_branch, uncommitted_file_count, commits_ahead,
+    hot_issue_numbers,
 )
+from lib.in_progress import issue_in_progress
 from lib.new_issues import build_slug_labels, find_new_issues_for_tracks
 
 
@@ -122,6 +124,8 @@ def _orient_track(track) -> int:
     titles_by_num: dict[int, str] = {}
     states_by_num: dict[int, str] = {}
     milestones_by_num: dict[int, str] = {}
+    inprog_by_num: dict = {}
+    blocked_by_num: dict = {}
     if track.repo and next_up:
         wanted = next_up[:4]
         fetched = fetch_issues(track.repo, wanted)
@@ -129,6 +133,18 @@ def _orient_track(track) -> int:
             titles_by_num[i["number"]] = i.get("title", "")
             states_by_num[i["number"]] = (i.get("state") or "").upper()
             milestones_by_num[i["number"]] = short_milestone(i.get("milestone"))
+        hot = hot_issue_numbers(track.local_path) if track.local_path else set()
+        manual_blockers = set(track.meta.get("blockers") or [])
+        for i in fetched:
+            inprog_by_num[i["number"]] = issue_in_progress(i, hot)
+            disp = []
+            for e in (i.get("blocked_by") or []):
+                same = e.get("repo") == track.repo
+                if same and e.get("number") in manual_blockers:
+                    continue
+                disp.append(f"#{e['number']}" if same else f"{e['repo']}#{e['number']}")
+            if disp:
+                blocked_by_num[i["number"]] = disp
 
     print(_top_rule(slug))
     print(f"Priority: {priority}  ·  Milestone: {milestone}  ·  Repo: {repo}")
@@ -150,7 +166,9 @@ def _orient_track(track) -> int:
         pick_title = titles_by_num.get(pick_num, "")
         pick_suffix = _state_suffix(states_by_num.get(pick_num))
         pick_ms = _milestone_prefix(milestones_by_num.get(pick_num))
-        print(f"Next pick: #{pick_num}  {pick_ms}{pick_title}{pick_suffix}".rstrip())
+        print(f"Next pick: #{pick_num}  {pick_ms}{pick_title}{pick_suffix}"
+              f"{_inprog_suffix(inprog_by_num.get(pick_num, False))}"
+              f"{_blocked_suffix(blocked_by_num.get(pick_num))}".rstrip())
         if _is_closed(states_by_num.get(pick_num)):
             print(f"  ⚠  next_up:[0] has shipped — run `/work-plan handoff {slug}` to rotate")
         rest = next_up[1:4]
@@ -161,7 +179,9 @@ def _orient_track(track) -> int:
                 title = titles_by_num.get(num, "")
                 suffix = _state_suffix(states_by_num.get(num))
                 ms = _milestone_prefix(milestones_by_num.get(num))
-                print(f"  #{num}  {ms}{title}{suffix}".rstrip())
+                print(f"  #{num}  {ms}{title}{suffix}"
+                      f"{_inprog_suffix(inprog_by_num.get(num, False))}"
+                      f"{_blocked_suffix(blocked_by_num.get(num))}".rstrip())
     else:
         print("Next pick: (none set — run `/work-plan handoff` to set one)")
 
@@ -235,6 +255,14 @@ def _state_suffix(state: Optional[str]) -> str:
     return "  (closed)" if _is_closed(state) else ""
 
 
+def _inprog_suffix(flag: bool) -> str:
+    return "  ▶ in-progress" if flag else ""
+
+
+def _blocked_suffix(disp: Optional[list]) -> str:
+    return ("  ⊘ blocked by " + ", ".join(disp)) if disp else ""
+
+
 def _milestone_prefix(ms: Optional[str]) -> str:
     return f"[{ms}] " if ms else ""
 

package/skills/work-plan/lib/export_model.py

@@ -52,10 +52,22 @@ def group_issues_by_milestone(issues, milestone_alignment=None):
     return groups
 
 
-def normalize_issue(i: dict) -> dict:
+def normalize_issue(i: dict, in_progress: bool = False,
+                    in_progress_label: bool = False,
+                    blocked_by=None, blocking=None) -> dict:
     """Reshape a raw gh issue row into the viewer's `Issue` shape
-    ({number,title,state,assignee,milestone}). Shared by the export and the
-    `list-open-issues` command (#282) so both emit an identical issue surface."""
+    ({number,title,state,assignee,milestone,in_progress,in_progress_label,
+    blocked_by,blocking}).
+    Shared by the export and the `list-open-issues` command (#282) so both
+    emit an identical issue surface.
+
+    `in_progress` is the UNION signal (hot branch OR label) — used by the
+    badge.  `in_progress_label` reflects LABEL presence only — used by the
+    toggle button so it accurately shows Mark/Clear for the label, not the
+    union.
+    `blocked_by` / `blocking` are lists of cross-issue dependency refs
+    (#257); default to [] when absent.
+    """
     state = (i.get("state") or "OPEN").lower()
     return {
         "number": i.get("number"),
@@ -63,14 +75,35 @@ def normalize_issue(i: dict) -> dict:
         "state": "closed" if state in ("closed", "merged") else "open",
         "assignee": (format_assignees(i) if i.get("assignees") else "—"),
         "milestone": short_milestone(i.get("milestone")) or None,
+        "in_progress": bool(in_progress),
+        "in_progress_label": bool(in_progress_label),
+        "blocked_by": list(blocked_by or []),
+        "blocking": list(blocking or []),
     }
 
 
 def build_export(tracks, issues_by_track, visibility, now: str,
-                 untracked_by_repo=None, config_repos=None) -> dict:
+                 untracked_by_repo=None, config_repos=None,
+                 plan_by_track=None, hot_by_track=None) -> dict:
+    plan_by_track = plan_by_track or {}
+    hot_by_track = hot_by_track or {}
     out = {"schema": SCHEMA, "generated_at": now, "tracks": []}
     for t in tracks:
-        issues = [normalize_issue(i) for i in issues_by_track.get(t.name, [])]
+        from lib.in_progress import issue_in_progress, IN_PROGRESS_LABEL
+        hot = hot_by_track.get((t.repo, t.name), set())
+        raw = issues_by_track.get((t.repo, t.name), [])
+        issues = [
+            normalize_issue(
+                i,
+                in_progress=issue_in_progress(i, hot),
+                in_progress_label=IN_PROGRESS_LABEL in {
+                    l.get("name") for l in (i.get("labels") or [])
+                },
+                blocked_by=i.get("blocked_by"),
+                blocking=i.get("blocking"),
+            )
+            for i in raw
+        ]
         milestone_alignment = t.meta.get("milestone_alignment")
         issues.sort(key=lambda i: milestone_sort_key(i, milestone_alignment))
         opened = sum(1 for i in issues if i["state"] == "open")
@@ -98,6 +131,10 @@ def build_export(tracks, issues_by_track, visibility, now: str,
             "depends_on": list(t.meta.get("depends_on") or []),
             "rollup": {"open": opened, "closed": len(issues) - opened},
             "issues": issues,
+            # The track's declared plan/spec doc + its execution badge (#285), or
+            # null when the track declares no `plan:`. `{rel, resolved:false}` when
+            # the link can't be resolved (no local clone / file absent).
+            "plan": plan_by_track.get(t.name),
         })
     out["untracked"] = [
         {"repo": repo, "issues": [normalize_issue(r) for r in rows]}