prodc 0.3.76__tar.gz → 0.3.78__tar.gz

{prodc-0.3.76 → prodc-0.3.78}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: prodc
-Version: 0.3.76
+Version: 0.3.78
 Summary: Product management as code: roles, flows, and features traced to evidence.
 Project-URL: Homepage, https://gitlab.com/jorgeecardona/prodc
 Project-URL: Repository, https://gitlab.com/jorgeecardona/prodc

{prodc-0.3.76 → prodc-0.3.78}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "prodc"
-version = "0.3.76"
+version = "0.3.78"
 description = "Product management as code: roles, flows, and features traced to evidence."
 readme = "README.md"
 requires-python = ">=3.12"

{prodc-0.3.76 → prodc-0.3.78}/src/prodc/agent.md

@@ -79,7 +79,7 @@ Read first, then act, then check.
 | link a recurring want to a shared baseline | `prodc recurrence --suggest --apply --baseline-id <id> --file needs/<f>.yaml` |
 | record a human/AI review of the warrant | `prodc attest <id> --by <who> --date <ISO> [--ai]` |
 | record a human acceptance pass | `prodc accept <id> --who <person> --date <ISO>` |
-| decide against a need (won't-do) | `prodc withdraw <id> --reason "…"` — off the board + out of coverage; `prodc reinstate <id>` puts it back |
+| decide against a need (won't-do) | `prodc withdraw <id> --reason "…" [--kind out_of_scope\|duplicate]` — off the board + out of coverage (use `out_of_scope` for a real need that isn't this product); `prodc reinstate <id>` puts it back |
 | hand a human a readable status file | `prodc report -o status.md` (markdown; `--format html` for an interactive viewer; `--client ID` to scope) |
 | act on a need going green (notify a tracker, etc.) | `prodc sync` — runs the `[callbacks]` commands for needs whose state changed since the last sync (`--dry-run` to preview) |
 | gate in CI | `prodc lint --strict` |

{prodc-0.3.76 → prodc-0.3.78}/src/prodc/board.py

@@ -102,7 +102,11 @@ def need_payload(r: NeedResult, *, flavor: Literal["board", "html"] = "board") -
             "claim": need.claim,
             "answer": need.answer.value if need.answer else None,
             "withdrawn": (
-                {"reason": need.withdrawn.reason, "date": need.withdrawn.date}
+                {
+                    "reason": need.withdrawn.reason,
+                    "date": need.withdrawn.date,
+                    "kind": need.withdrawn.kind.value,
+                }
                 if need.withdrawn
                 else None
             ),
@@ -150,7 +154,11 @@ def need_payload(r: NeedResult, *, flavor: Literal["board", "html"] = "board") -
         "draft": need.draft,
         "answer": need.answer.value if need.answer else None,
         "withdrawn": (
-            {"reason": need.withdrawn.reason, "date": need.withdrawn.date}
+            {
+                "reason": need.withdrawn.reason,
+                "date": need.withdrawn.date,
+                "kind": need.withdrawn.kind.value,
+            }
             if need.withdrawn
             else None
         ),

{prodc-0.3.76 → prodc-0.3.78}/src/prodc/cli/app.py

@@ -133,6 +133,13 @@ def main(argv: list[str] | None = None) -> int:
     pl.add_argument(
         "--include-drafts", action="store_true", help="include draft (staged) needs (#60)"
     )
+    pl.add_argument(
+        "--revisit",
+        type=int,
+        default=None,
+        metavar="DAYS",
+        help="only needs whose importance is undated or set more than DAYS ago — a refresh pass (#59)",
+    )
     pl.set_defaults(func=cmd_plan)
 
     ar = sub.add_parser("argument", help="show the GSN assurance graph and its defects")
@@ -300,6 +307,13 @@ def main(argv: list[str] | None = None) -> int:
     wd.add_argument(
         "--reason", required=True, help="why it was decided against (kept on the record)"
     )
+    wd.add_argument(
+        "--kind",
+        choices=["wont_do", "out_of_scope", "duplicate"],
+        default="wont_do",
+        help="the decision's kind: wont_do (default), out_of_scope (real but not this product), "
+        "or duplicate (#74)",
+    )
     wd.add_argument("--date", default=None, help="when (ISO, e.g. 2026-10-10; default: today)")
     wd.add_argument("--config", default="prodc.toml", help="path to prodc.toml")
     wd.add_argument("--json", action="store_true", help="machine-readable output")

{prodc-0.3.76 → prodc-0.3.78}/src/prodc/cli/commands.py

@@ -37,6 +37,7 @@ from ..status import (
     applicable_needs,
     argument_defects,
     evidence_age_days,
+    importance_revisit_due,
     proof_suggestions,
     recurrence,
     relink_suggestions,
@@ -263,6 +264,14 @@ def cmd_status(args: argparse.Namespace) -> int:
     # orphans) until promoted with `set <id> draft=false`, unless --include-drafts is passed.
     draft_count = sum(1 for n in needs if n.draft and not n.is_withdrawn)
     withdrawn_count = sum(1 for n in needs if n.is_withdrawn)
+    # Break withdrawals down by kind (#74 follow-up), so "declined but valid" (out_of_scope) is
+    # legible on the board apart from plain won't-do; wont_do is the implicit default, not listed.
+    withdrawn_kinds: dict[str, int] = {}
+    for n in needs:
+        if n.withdrawn and n.withdrawn.kind.value != "wont_do":
+            withdrawn_kinds[n.withdrawn.kind.value] = (
+                withdrawn_kinds.get(n.withdrawn.kind.value, 0) + 1
+            )
     needs = board_needs(needs, include_drafts=args.include_drafts)
     # Scoped coverage (#49): restrict the board + coverage to a subset, so the number people
     # act on (this client, this goal) isn't diluted by the whole mixed board.
@@ -318,7 +327,9 @@ def cmd_status(args: argparse.Namespace) -> int:
         if draft_count and not args.include_drafts:
             print(f"drafts: {draft_count} staged (hidden — --include-drafts to show) (#60)")
         if withdrawn_count:
-            print(f"withdrawn: {withdrawn_count} (decided against) (#74)")
+            extra = ", ".join(f"{c} {k}" for k, c in sorted(withdrawn_kinds.items()))
+            suffix = f" — {extra}" if extra else ""
+            print(f"withdrawn: {withdrawn_count} (decided against){suffix} (#74)")
         visible = [r for r in results if r.need.product]
         if args.only_must:
             visible = [r for r in visible if r.need.must]
@@ -374,7 +385,20 @@ def cmd_brief(args: argparse.Namespace) -> int:
         return 2
     scoped = applicable_needs(needs, args.client)
     results = resolve(scoped, cfg.adapters, cfg.source_adapters)
-    print(brief_json(args.client, results) if args.json else render_brief(args.client, results))
+    # "Confirm still wanted" (#58): needs whose evidence is older than the stale threshold, to
+    # re-check with the client in the meeting. Only when [lint].stale_after_days is configured.
+    stale: list[tuple[NeedResult, int]] = []
+    if cfg.stale_after_days is not None:
+        today = date.today()
+        for r in results:
+            age = evidence_age_days(r.need, today)
+            if age is not None and age > cfg.stale_after_days:
+                stale.append((r, age))
+    print(
+        brief_json(args.client, results, stale)
+        if args.json
+        else render_brief(args.client, results, stale)
+    )
     return 0
 
 
@@ -387,10 +411,14 @@ def cmd_plan(args: argparse.Namespace) -> int:
     needs = board_needs(list(model.needs), include_drafts=args.include_drafts)  # drafts off (#60)
     results = resolve(needs, cfg.adapters, cfg.source_adapters)
     recurrence_counts = {rec.baseline.id: rec.count for rec in recurrence(needs)}
+    revisit = args.revisit is not None
+    if revisit:
+        today = date.today()
+        results = [r for r in results if importance_revisit_due(r.need, today, args.revisit)]
     print(
-        plan_json(results, recurrence_counts)
+        plan_json(results, recurrence_counts, revisit=revisit)
         if args.json
-        else render_plan(results, recurrence_counts)
+        else render_plan(results, recurrence_counts, revisit=revisit)
     )
     return 0
 
@@ -549,6 +577,7 @@ def cmd_withdraw(args: argparse.Namespace) -> int:
             args.need_id,
             reason=args.reason,
             date=args.date or date.today().isoformat(),
+            kind=args.kind,
             expect_sha=args.expect_sha,
             dry_run=args.dry_run,
         )
@@ -1079,7 +1108,9 @@ def _cmd_relink(cfg: Config, results: list[NeedResult], args: argparse.Namespace
                 print(f"{s.need.id}: {s.need.text}")
                 last = s.need.id
             print(f"    {s.score:.2f}  {s.broken} → {s.locator}")
-        print(f"suggest --relink: {len(suggestions)} candidate(s) at min-score {args.min_score:.2f}")
+        print(
+            f"suggest --relink: {len(suggestions)} candidate(s) at min-score {args.min_score:.2f}"
+        )
     return 0
 
 
@@ -1125,7 +1156,9 @@ def _apply_relinks(
     else:
         verb = "would relink" if args.dry_run else "relinked"
         for s, edit in applied:
-            print(f"{verb} {s.broken} → {s.locator} on {s.need.id} ({s.score:.2f}) in {edit.path.name}")
+            print(
+                f"{verb} {s.broken} → {s.locator} on {s.need.id} ({s.score:.2f}) in {edit.path.name}"
+            )
             print(edit.diff, end="")
         print(f"suggest --relink --apply: {verb} {len(applied)} locator(s)")
     return 0

{prodc-0.3.76 → prodc-0.3.78}/src/prodc/cli/render.py

@@ -276,7 +276,9 @@ def render_show(r: NeedResult, importance_label: str | None = None) -> str:
     if need.answer:
         lines.append(f"  answer: {need.answer.value}")
     if need.withdrawn:
-        lines.append(f"  withdrawn: {need.withdrawn.reason} ({need.withdrawn.date})")
+        w = need.withdrawn
+        tag = "" if w.kind.value == "wont_do" else f" [{w.kind.value}]"
+        lines.append(f"  withdrawn{tag}: {w.reason} ({w.date})")
     if need.description:
         lines.append(f"  description: {need.description}")
     if need.importance is not None:
@@ -329,7 +331,11 @@ def render_show(r: NeedResult, importance_label: str | None = None) -> str:
     return "\n".join(lines)
 
 
-def render_brief(client: str, results: list[NeedResult]) -> str:
+def render_brief(
+    client: str,
+    results: list[NeedResult],
+    stale: list[tuple[NeedResult, int]] | None = None,
+) -> str:
     open_ = brief_open(results)
     out = [f"brief — {client}: {len(open_)} open question{'s' if len(open_) != 1 else ''}"]
     if not open_:
@@ -345,6 +351,10 @@ def render_brief(client: str, results: list[NeedResult]) -> str:
             if g
         )
         out.append(f"  {bang} {r.need.id:<12} [{gaps}]  {r.need.text}")
+    if stale:
+        out.append(f"  confirm still wanted ({len(stale)} with evidence past the stale threshold):")
+        for r, age in sorted(stale, key=lambda t: (-t[1], t[0].need.id)):
+            out.append(f"    ~ {r.need.id:<12} {age}d old   {r.need.text}")
     return "\n".join(out)
 
 
@@ -357,9 +367,16 @@ def _importance_cell(need: Need) -> str:
     return f"imp={need.importance}{' (guess)' if weak else ''}"
 
 
-def render_plan(results: list[NeedResult], recurrence_counts: dict[str, int]) -> str:
+def render_plan(
+    results: list[NeedResult], recurrence_counts: dict[str, int], *, revisit: bool = False
+) -> str:
     ranked = rank(results, recurrence_counts)
-    out = ["plan — ranked backlog (must + state + evidence + recurrence, importance refines)"]
+    header = (
+        f"plan — revisit: {len(ranked)} need(s) with undated or stale importance (#59)"
+        if revisit
+        else "plan — ranked backlog (must + state + evidence + recurrence, importance refines)"
+    )
+    out = [header]
     for i, r in enumerate(ranked, 1):
         bang = "!!" if r.need.must else "  "
         imp = _importance_cell(r.need)

{prodc-0.3.76 → prodc-0.3.78}/src/prodc/cli/serialize.py

@@ -130,7 +130,11 @@ def show_json(r: NeedResult) -> str:
     return json.dumps(payload, indent=2)
 
 
-def brief_json(client: str, results: list[NeedResult]) -> str:
+def brief_json(
+    client: str,
+    results: list[NeedResult],
+    stale: list[tuple[NeedResult, int]] | None = None,
+) -> str:
     open_ = brief_open(results)
     return json.dumps(
         {
@@ -146,15 +150,22 @@ def brief_json(client: str, results: list[NeedResult]) -> str:
                 }
                 for r in open_
             ],
+            "confirm_still_wanted": [
+                {"id": r.need.id, "text": r.need.text, "evidence_age": age}
+                for r, age in sorted(stale or [], key=lambda t: (-t[1], t[0].need.id))
+            ],
         },
         indent=2,
     )
 
 
-def plan_json(results: list[NeedResult], recurrence_counts: dict[str, int]) -> str:
+def plan_json(
+    results: list[NeedResult], recurrence_counts: dict[str, int], *, revisit: bool = False
+) -> str:
     ranked = rank(results, recurrence_counts)
     return json.dumps(
         {
+            "revisit": revisit,
             "plan": [
                 {
                     "rank": i,
@@ -168,7 +179,7 @@ def plan_json(results: list[NeedResult], recurrence_counts: dict[str, int]) -> s
                     "importance_is_guess": (r.need.importance is not None and r.need.is_opinion),
                 }
                 for i, r in enumerate(ranked, 1)
-            ]
+            ],
         },
         indent=2,
     )

{prodc-0.3.76 → prodc-0.3.78}/src/prodc/config.py

@@ -272,7 +272,9 @@ class Config:
             raise ConfigError("[lint].importance_revisit_days must be a positive integer")
         draft_max_age = lint_tbl.get("draft_max_age_days")
         if draft_max_age is not None and (
-            not isinstance(draft_max_age, int) or isinstance(draft_max_age, bool) or draft_max_age < 1
+            not isinstance(draft_max_age, int)
+            or isinstance(draft_max_age, bool)
+            or draft_max_age < 1
         ):
             raise ConfigError("[lint].draft_max_age_days must be a positive integer")
 

{prodc-0.3.76 → prodc-0.3.78}/src/prodc/loader.py

@@ -30,6 +30,7 @@ from .model import (
     Source,
     SourceKind,
     Withdrawal,
+    WithdrawalKind,
 )
 
 
@@ -130,10 +131,12 @@ def _answer(raw: object, where: str) -> Answer | None:
 
 
 def _withdrawal(raw: object, where: str) -> Withdrawal | None:
-    """Parse ``withdrawn: {reason, date}`` into a :class:`Withdrawal` (#74).
+    """Parse ``withdrawn: {reason, date, kind?}`` into a :class:`Withdrawal` (#74).
 
-    Both fields are required when the key is present — a decision against a need must say why
-    and when, the same way an attestation needs who and when.
+    ``reason`` and ``date`` are required when the key is present — a decision against a need must
+    say why and when, the same way an attestation needs who and when. ``kind`` is optional and
+    defaults to ``wont_do``; it is validated with the same ``Enum(name) except ValueError`` pattern
+    as ``SourceKind``, so an unknown kind is a :class:`LoaderError` the author owns.
     """
     if raw is None:
         return None
@@ -142,7 +145,15 @@ def _withdrawal(raw: object, where: str) -> Withdrawal | None:
     date = _opt_str(tbl.get("date"), f"{where}.date")
     if not reason or not date:
         raise LoaderError(f"{where}: a withdrawal needs both 'reason' and 'date'")
-    return Withdrawal(reason=reason, date=date)
+    kind_name = _opt_str(tbl.get("kind"), f"{where}.kind") or WithdrawalKind.WONT_DO.value
+    try:
+        kind = WithdrawalKind(kind_name)
+    except ValueError:
+        kinds = "|".join(k.value for k in WithdrawalKind)
+        raise LoaderError(
+            f"{where}.kind: unknown withdrawal kind {kind_name!r} ({kinds})"
+        ) from None
+    return Withdrawal(reason=reason, date=date, kind=kind)
 
 
 # Old source-kind names (pre-0.3.58) mapped to the primary/secondary/assumption ladder, so

{prodc-0.3.76 → prodc-0.3.78}/src/prodc/model.py

@@ -74,7 +74,9 @@ class Source:
 
     kind: SourceKind
     who: str | None = None
-    role: str | None = None  # id of the Role the `who` spoke as — whose signal this is (#52 follow-up)
+    role: str | None = (
+        None  # id of the Role the `who` spoke as — whose signal this is (#52 follow-up)
+    )
     date: str | None = None
     quote: str | None = None
     locator: str | None = None
@@ -161,17 +163,33 @@ class Attestation:
     comment: str | None = None  # the review's feedback / rationale, kept on the record
 
 
+class WithdrawalKind(StrEnum):
+    """Why a need is off the board — the decision's *kind*, as data, not only free-text reason.
+
+    All three take the need off the active board and out of coverage identically; the kind records
+    *why* so the board can tell a validated-but-off-strategy need apart from one killed as not
+    worth doing. ``OUT_OF_SCOPE`` is the case a real, client-evidenced need is declined because it
+    is not the product being built — distinct from ``WONT_DO`` (decided against on its merits) and
+    ``DUPLICATE`` (the same want is tracked under another need).
+    """
+
+    WONT_DO = "wont_do"  # decided against on its merits — the default, #74's original meaning
+    OUT_OF_SCOPE = "out_of_scope"  # real and valid, but not this product
+    DUPLICATE = "duplicate"  # the same want is tracked elsewhere
+
+
 @dataclass(frozen=True)
 class Withdrawal:
     """A decision not to pursue a need — withdrawn / won't-do (#74).
 
     Unlike a draft (staged, not yet decided), a withdrawal is a decision *against*: the need is
-    taken off the active board and out of coverage, with its ``reason`` and ``date`` kept on the
-    record as the durable trace (``prodc show`` still renders it). Reinstate to put it back.
+    taken off the active board and out of coverage, with its ``reason``, ``date`` and ``kind`` kept
+    on the record as the durable trace (``prodc show`` still renders it). Reinstate to put it back.
     """
 
     reason: str
     date: str
+    kind: WithdrawalKind = WithdrawalKind.WONT_DO
 
 
 @dataclass(frozen=True)
@@ -199,7 +217,9 @@ class Need:
     release: str | None = None  # id of the Release slice this need ships in; None = unslotted
     product: bool = True  # False = infra/NFR/internal, excluded from product coverage (#48)
     draft: bool = False  # True = staged, not yet counted on the board until promoted (#60)
-    draft_added: str | None = None  # ISO date this need was staged (#60); lets a lint age-gate it later
+    draft_added: str | None = (
+        None  # ISO date this need was staged (#60); lets a lint age-gate it later
+    )
     withdrawn: Withdrawal | None = None  # a decision against this need — off the board (#74)
     answer: Answer | None = (
         None  # which way a settled need resolved (yes/no/inconclusive); None=open-ended

{prodc-0.3.76 → prodc-0.3.78}/src/prodc/status.py

@@ -78,6 +78,24 @@ def evidence_age_days(need: Need, today: date) -> int | None:
     return (today - max(dates)).days if dates else None
 
 
+def importance_revisit_due(need: Need, today: date, max_age_days: int) -> bool:
+    """Whether a need's importance should be revisited — for ``plan --revisit`` (#59).
+
+    Due when the need has an importance set but it is either never dated (no ``importance_set_at``)
+    or last set more than ``max_age_days`` ago. A need with no importance is never due — there is
+    nothing to revisit. A malformed date is treated as not-due (the lint warning owns that defect).
+    """
+    if need.importance is None:
+        return False
+    when = need.importance_set_at
+    if when is None:
+        return True
+    try:
+        return (today - date.fromisoformat(when)).days > max_age_days
+    except ValueError:
+        return False
+
+
 def _resolve_proof(locator: str, adapters: dict[str, Adapter]) -> ProofResult:
     name, sep, payload = locator.partition(":")
     adapter = adapters.get(name)

{prodc-0.3.76 → prodc-0.3.78}/src/prodc/writer.py

@@ -474,16 +474,21 @@ def withdraw(
     *,
     reason: str,
     date: str,
+    kind: str = "wont_do",
     expect_sha: str | None,
     dry_run: bool,
 ) -> Edit:
     """Record a decision against a need — withdrawn / won't-do (#74).
 
-    Writes a ``withdrawn: {reason, date}`` mapping onto the need, which takes it off the active
-    board and out of coverage; the record stays as its durable trace. Replaces any existing
-    withdrawal (re-withdrawing updates the reason/date). Reinstate with :func:`reinstate`.
+    Writes a ``withdrawn: {reason, date, kind?}`` mapping onto the need, which takes it off the
+    active board and out of coverage; the record stays as its durable trace. ``kind`` says *why*
+    (``wont_do`` default, ``out_of_scope``, ``duplicate``) and is written only when it is not the
+    default, to keep the common case clean. Replaces any existing withdrawal (re-withdrawing
+    updates it). Reinstate with :func:`reinstate`.
     """
     mark: dict[str, object] = {"reason": reason, "date": date}
+    if kind != "wont_do":
+        mark["kind"] = kind
     path, _ = _locate(config, need_id)
     doc, old_text = _read_doc(path)
     if expect_sha is not None and _sha256(old_text) != expect_sha:

{prodc-0.3.76 → prodc-0.3.78}/tests/test_importance.py

@@ -164,3 +164,52 @@ needs:
     payload = json.loads(capsys.readouterr().out)
     n1 = next(n for n in payload["needs"] if n["id"] == "N-1")
     assert n1["importance_set_at"] == "2026-10-01"
+
+
+# --- plan --revisit (#59 follow-up) -----------------------------------------
+
+
+def test_plan_revisit_filters_to_undated_and_stale(
+    tmp_path: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    from prodc.cli import main
+
+    old = (date.today() - timedelta(days=400)).isoformat()
+    recent = (date.today() - timedelta(days=5)).isoformat()
+    needs = f"""
+needs:
+  - id: UNDATED
+    text: importance set, never dated
+    importance: 2
+  - id: STALE
+    text: importance set long ago
+    importance: 3
+    importance_set_at: {old}
+  - id: FRESH
+    text: importance set recently
+    importance: 1
+    importance_set_at: {recent}
+  - id: NONE
+    text: no importance at all
+"""
+    main(["plan", "--revisit", "30", "--config", str(_project(tmp_path, _TOML, needs)), "--json"])
+    payload = json.loads(capsys.readouterr().out)
+    assert payload["revisit"] is True
+    assert {p["id"] for p in payload["plan"]} == {"UNDATED", "STALE"}
+
+
+def test_plan_without_revisit_lists_all(tmp_path: Path, capsys: pytest.CaptureFixture[str]) -> None:
+    from prodc.cli import main
+
+    needs = """
+needs:
+  - id: N-1
+    text: a thing
+    importance: 2
+  - id: N-2
+    text: another thing
+"""
+    main(["plan", "--config", str(_project(tmp_path, _TOML, needs)), "--json"])
+    payload = json.loads(capsys.readouterr().out)
+    assert payload["revisit"] is False
+    assert {p["id"] for p in payload["plan"]} == {"N-1", "N-2"}

{prodc-0.3.76 → prodc-0.3.78}/tests/test_relink.py

@@ -95,7 +95,7 @@ def test_relink_skips_when_adapter_absent(
 ) -> None:
     # A locator whose adapter does not exist is BROKEN but has no inventory to relink against.
     (tmp_path / "needs").mkdir(parents=True, exist_ok=True)
-    (tmp_path / "prodc.toml").write_text("[prodc]\nneeds = [\"needs/*.yaml\"]\n", encoding="utf-8")
+    (tmp_path / "prodc.toml").write_text('[prodc]\nneeds = ["needs/*.yaml"]\n', encoding="utf-8")
     (tmp_path / "needs" / "a.yaml").write_text(
         "needs:\n  - id: N-1\n    text: t\n    proofs: ['ghost:1']\n", encoding="utf-8"
     )

{prodc-0.3.76 → prodc-0.3.78}/tests/test_review.py

@@ -58,7 +58,9 @@ def test_review_list_carries_staged_date_and_dup(
     assert rows["D-2"]["duplicate"] is None
 
 
-def test_review_promote_sets_draft_false(tmp_path: Path, capsys: pytest.CaptureFixture[str]) -> None:
+def test_review_promote_sets_draft_false(
+    tmp_path: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
     cfg = _project(tmp_path)
     code = main(["review", "--promote", "D-1", "--config", str(cfg)])
     assert code == 0
@@ -113,7 +115,9 @@ def test_review_dry_run_writes_nothing(tmp_path: Path, capsys: pytest.CaptureFix
     assert "dry-run" in capsys.readouterr().out
 
 
-def test_review_preserves_header_comment(tmp_path: Path, capsys: pytest.CaptureFixture[str]) -> None:
+def test_review_preserves_header_comment(
+    tmp_path: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
     cfg = _project(tmp_path)
     main(["review", "--drop", "D-2", "--config", str(cfg)])
     capsys.readouterr()

{prodc-0.3.76 → prodc-0.3.78}/tests/test_source_role.py

@@ -13,7 +13,7 @@ from prodc.loader import LoaderError, load
 from prodc.model import Need, Source, SourceKind
 from prodc.writer import capture_source
 
-_TOML = "[prodc]\nneeds = [\"needs/*.yaml\"]\n"
+_TOML = '[prodc]\nneeds = ["needs/*.yaml"]\n'
 
 _NEEDS = """
 roles:

{prodc-0.3.76 → prodc-0.3.78}/tests/test_staleness.py

@@ -152,3 +152,51 @@ needs:
     assert code == 0
     written = (tmp_path / "needs" / "a.yaml").read_text(encoding="utf-8")
     assert "observed_at:" in written and "2026-10-05" in written
+
+
+# --- brief "confirm still wanted" (#58 follow-up) ---------------------------
+
+
+def _client_needs() -> str:
+    old = (date.today() - timedelta(days=400)).isoformat()
+    fresh = date.today().isoformat()
+    return f"""
+needs:
+  - id: OLD-1
+    text: acme wants the old thing
+    client: acme
+    sources:
+      - kind: primary
+        who: Ana
+        quote: "I need this"
+        observed_at: {old}
+  - id: FRESH-1
+    text: acme wants the fresh thing
+    client: acme
+    sources:
+      - kind: primary
+        who: Bob
+        quote: "me too"
+        observed_at: {fresh}
+"""
+
+
+def test_brief_confirm_still_wanted(tmp_path: Path, capsys: pytest.CaptureFixture[str]) -> None:
+    from prodc.cli import main
+
+    toml = _TOML + "\n[lint]\nstale_after_days = 180\n"
+    main(["brief", "acme", "--config", str(_project(tmp_path, toml, _client_needs())), "--json"])
+    payload = json.loads(capsys.readouterr().out)
+    stale = {s["id"] for s in payload["confirm_still_wanted"]}
+    assert stale == {"OLD-1"}  # only the >180d evidence is up for re-confirmation
+
+
+def test_brief_no_confirm_section_without_knob(
+    tmp_path: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    from prodc.cli import main
+
+    # no [lint].stale_after_days configured -> nothing to re-confirm
+    main(["brief", "acme", "--config", str(_project(tmp_path, _TOML, _client_needs())), "--json"])
+    payload = json.loads(capsys.readouterr().out)
+    assert payload["confirm_still_wanted"] == []

{prodc-0.3.76 → prodc-0.3.78}/tests/test_withdrawn.py

@@ -242,7 +242,11 @@ def test_show_json_carries_withdrawn(tmp_path: Path, capsys: pytest.CaptureFixtu
 
     main(["show", "W-1", "--config", str(_project(tmp_path)), "--json"])
     payload = json.loads(capsys.readouterr().out)
-    assert payload["withdrawn"] == {"reason": "superseded by N-1", "date": "2026-10-10"}
+    assert payload["withdrawn"] == {
+        "reason": "superseded by N-1",
+        "date": "2026-10-10",
+        "kind": "wont_do",  # default when the YAML omits kind
+    }
 
 
 def test_status_json_live_need_has_null_withdrawn(
@@ -254,3 +258,95 @@ def test_status_json_live_need_has_null_withdrawn(
     payload = json.loads(capsys.readouterr().out)
     n1 = next(n for n in payload["needs"] if n["id"] == "N-1")
     assert n1["withdrawn"] is None
+
+
+# --- withdrawal kind (#74 follow-up) ----------------------------------------
+
+_KIND_NEEDS = """
+needs:
+  - id: N-1
+    text: user can see a delivered thing
+    proofs: ["x:1"]
+  - id: OOS-1
+    text: a real but off-strategy need
+    withdrawn:
+      reason: not the product we build
+      date: 2026-10-10
+      kind: out_of_scope
+"""
+
+
+def test_loader_parses_withdrawal_kind(tmp_path: Path) -> None:
+    from prodc.model import WithdrawalKind
+
+    cfg = Config.load(_project(tmp_path, needs=_KIND_NEEDS))
+    by_id = {n.id: n for n in load(cfg).needs}
+    assert by_id["OOS-1"].withdrawn is not None
+    assert by_id["OOS-1"].withdrawn.kind is WithdrawalKind.OUT_OF_SCOPE
+
+
+def test_withdrawal_kind_defaults_wont_do(tmp_path: Path) -> None:
+    from prodc.model import WithdrawalKind
+
+    cfg = Config.load(_project(tmp_path))  # W-1 omits kind
+    by_id = {n.id: n for n in load(cfg).needs}
+    w = by_id["W-1"].withdrawn
+    assert w is not None and w.kind is WithdrawalKind.WONT_DO
+
+
+def test_unknown_withdrawal_kind_rejected(tmp_path: Path) -> None:
+    needs = _KIND_NEEDS.replace("kind: out_of_scope", "kind: bogus")
+    with pytest.raises(LoaderError, match="unknown withdrawal kind 'bogus'"):
+        load(Config.load(_project(tmp_path, needs=needs)))
+
+
+def test_withdraw_writes_non_default_kind(tmp_path: Path) -> None:
+    from prodc.cli import main
+    from prodc.model import WithdrawalKind
+
+    cfg = _project(tmp_path)
+    code = main(
+        [
+            "withdraw",
+            "N-1",
+            "--reason",
+            "off strategy",
+            "--kind",
+            "out_of_scope",
+            "--date",
+            "2026-10-15",
+            "--config",
+            str(cfg),
+        ]
+    )
+    assert code == 0
+    by_id = {n.id: n for n in load(Config.load(cfg)).needs}
+    w = by_id["N-1"].withdrawn
+    assert w is not None and w.kind is WithdrawalKind.OUT_OF_SCOPE
+
+
+def test_withdraw_omits_default_kind_in_yaml(tmp_path: Path) -> None:
+    from prodc.cli import main
+
+    cfg = _project(tmp_path)
+    main(["withdraw", "N-1", "--reason", "nope", "--date", "2026-10-15", "--config", str(cfg)])
+    text = (tmp_path / "needs" / "a.yaml").read_text(encoding="utf-8")
+    assert "kind:" not in text  # wont_do is the default; not written, keeps files clean
+
+
+def test_status_breaks_down_withdrawn_by_kind(
+    tmp_path: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    from prodc.cli import main
+
+    main(["status", "--config", str(_project(tmp_path, needs=_KIND_NEEDS))])
+    out = capsys.readouterr().out
+    assert "withdrawn: 1 (decided against) — 1 out_of_scope" in out
+
+
+def test_show_tags_non_default_kind(tmp_path: Path, capsys: pytest.CaptureFixture[str]) -> None:
+    from prodc.cli import main
+
+    main(["show", "OOS-1", "--config", str(_project(tmp_path, needs=_KIND_NEEDS))])
+    out = capsys.readouterr().out
+    assert "withdrawn [out_of_scope]: not the product we build (2026-10-10)" in out