prodc 0.3.65__tar.gz → 0.3.72__tar.gz

{prodc-0.3.65 → prodc-0.3.72}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: prodc
-Version: 0.3.65
+Version: 0.3.72
 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.72/examples/quickstart/needs/jordan.yaml

@@ -0,0 +1,40 @@
+who: jordan
+label: "design partner"
+needs:
+  - id: N-1
+    text: "see which orders are past due at a glance"
+    must: true
+    sources:
+      - kind: primary
+        who: Jordan
+        date: 2026-09-20
+        quote: "I lose the past-due ones in the list"
+    proofs:
+      - "web:orders.feature#Past due orders are highlighted"
+
+  - id: N-2
+    text: "export the day's delivery run sheet"
+    sources:
+      - kind: secondary
+        locator: issues.md#N-2
+        date: 2026-09-21
+    proofs: []  # sourced HOLE: the need is evidenced, but no test proves it yet
+
+  - id: N-3
+    text: "implement a settings page"  # opinion (no source) + solution-in-disguise warning
+
+  # A product need is a hypothesis, same as a research question. Stating the `claim` (the warrant
+  # the bet would establish) silences the EARS/solution-verb lint — the honest act, not a mode.
+  # The experiment shipped and settled the question NO: DELIVERED + answer: no. It stays on the
+  # board and counts as a result — unlike `withdrawn`, which would hide that something was learned.
+  - id: N-4
+    text: "pin the daily summary to the top of the dashboard"
+    claim: "pinning the summary lifts next-day return visits"
+    sources:
+      - kind: primary
+        who: Jordan
+        date: 2026-09-22
+        quote: "I never scroll back up to the summary"
+    proofs:
+      - "ship:jordan@2026-10-05"  # the A/B experiment ran and concluded
+    answer: no  # return visits did not move — the bet is settled, and the answer is no

{prodc-0.3.65 → prodc-0.3.72}/examples/quickstart/prodc.toml

@@ -1,7 +1,8 @@
 # A minimal, runnable prodc project. From this directory:
 #   uv run prodc status
 # N-1 shows DELIVERED (a tagged scenario proves it), N-2 is a sourced HOLE
-# (evidence exists, no test yet), N-3 is an opinion with a solution-in-disguise warning.
+# (evidence exists, no test yet), N-3 is an opinion with a solution-in-disguise warning,
+# N-4 is a shipped hypothesis that settled NO (DELIVERED + answer: no — a result, not a gap).
 
 [prodc]
 needs = ["needs/*.yaml"]
@@ -11,3 +12,6 @@ kind = "gherkin"
 paths = ["features/*.feature"]
 delivered = ["@implemented"]
 pending = ["@pending"]
+
+[proofs.ship]
+kind = "accept"  # a human records that an experiment ran and concluded (declared)

{prodc-0.3.65 → prodc-0.3.72}/pyproject.toml

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

{prodc-0.3.65 → prodc-0.3.72}/src/prodc/adapters.py

@@ -40,6 +40,23 @@ def _steps_passed(steps: list[object]) -> bool:
     return True
 
 
+def _as_score(val: object) -> float | None:
+    """A numeric eval score from a results value: a bare number, or ``{"score": N}``.
+
+    ``bool`` is a subclass of ``int`` but is a pass/fail, not a score, so it is rejected — a
+    boolean result belongs to :class:`OutcomeAdapter`, not the gate.
+    """
+    if isinstance(val, bool):
+        return None
+    if isinstance(val, (int, float)):
+        return float(val)
+    if isinstance(val, dict):
+        inner = cast("dict[str, object]", val).get("score")
+        if isinstance(inner, (int, float)) and not isinstance(inner, bool):
+            return float(inner)
+    return None
+
+
 def _git_head(repo: Path) -> str | None:
     """Short git rev of a checked-out repo, read from .git/HEAD (no git binary needed)."""
     head = repo / ".git" / "HEAD"
@@ -486,6 +503,79 @@ class OutcomeAdapter:
         return ProofResult(ProofState.PENDING, False, f"outcome '{payload}' recorded failing")
 
 
+#: Comparators an evalgate locator may use, strongest-looking first so ``>=``/``<=`` match
+#: before the bare ``>``/``<`` when scanning the locator.
+_EVAL_OPS: dict[str, Callable[[float, float], bool]] = {
+    ">=": lambda s, t: s >= t,
+    "<=": lambda s, t: s <= t,
+    ">": lambda s, t: s > t,
+    "<": lambda s, t: s < t,
+}
+_EVAL_RE = re.compile(r"^(?P<key>.+?)(?P<op><=|>=|<|>)(?P<thr>[^<>=]+)$")
+
+
+class EvalGateAdapter:
+    """Resolves ``metric>=threshold`` against a recorded eval score (#75).
+
+    A scored sibling of :class:`OutcomeAdapter`: where that reads a pass/fail bool, this reads a
+    numeric score and gates it against a threshold carried in the locator (``accuracy>=0.9``), so
+    one adapter serves many metrics and cutoffs (``>=``, ``<=``, ``>``, ``<`` — ``<=`` for a loss
+    you want below a bound). The score is produced by an eval harness *outside* prodc and recorded
+    in a JSON file (``{"accuracy": {"score": 0.82}}`` or the bare ``{"accuracy": 0.82}``); prodc
+    only reads it — records-only, never runs the eval.
+
+    DELIVERED when the comparison holds; PENDING when the score is recorded but does not meet the
+    gate, or the metric is absent from a present file (recorded-below and not-yet-recorded are both
+    "not green", as in :class:`OutcomeAdapter`); BROKEN when the results file is absent or the
+    locator is malformed. The score, comparator and threshold go in the detail so the board shows
+    how far off it is.
+    """
+
+    def __init__(self, root: Path, results: str) -> None:
+        self._path = root / results
+        self._data: dict[str, float] | None = None
+        self._loaded = False
+
+    def _load(self) -> dict[str, float] | None:
+        if not self._loaded:
+            self._loaded = True
+            if self._path.exists():
+                out: dict[str, float] = {}
+                raw: object = json.loads(self._path.read_text(encoding="utf-8"))
+                if isinstance(raw, dict):
+                    for key, val in cast("dict[str, object]", raw).items():
+                        score = _as_score(val)
+                        if score is not None:
+                            out[key] = score
+                self._data = out
+        return self._data
+
+    def resolve(self, payload: str) -> ProofResult:
+        m = _EVAL_RE.match(payload.strip())
+        if not m:
+            return ProofResult(
+                ProofState.BROKEN, False, f"malformed evalgate '{payload}' (want metric>=threshold)"
+            )
+        key = m.group("key").strip()
+        op = m.group("op")
+        try:
+            threshold = float(m.group("thr").strip())
+        except ValueError:
+            return ProofResult(
+                ProofState.BROKEN, False, f"evalgate threshold not a number '{payload}'"
+            )
+        data = self._load()
+        if data is None:
+            return ProofResult(ProofState.BROKEN, False, f"no results file '{self._path.name}'")
+        if key not in data:
+            return ProofResult(ProofState.PENDING, False, f"metric '{key}' not in results")
+        score = data[key]
+        passed = _EVAL_OPS[op](score, threshold)
+        verdict = "pass" if passed else "below gate"
+        detail = f"{key} {score:g} {op} {threshold:g} ({verdict})"
+        return ProofResult(ProofState.DELIVERED if passed else ProofState.PENDING, False, detail)
+
+
 class CommandProof:
     """Resolves a locator by running a user-supplied command — a proof hook (#70).
 
@@ -549,6 +639,27 @@ class PrototypeAdapter:
         return ProofResult(ProofState.DELIVERED, True, detail)
 
 
+class CitationAdapter:
+    """Resolves ``ref@author@year`` to a cited published result — a declared DELIVERED (#75).
+
+    A research question can be settled by citing a result a human vouches for and prodc cannot
+    check (a published paper, a textbook theorem). Modelled on :class:`PrototypeAdapter`: a
+    *declared* DELIVERED (``*``), never BROKEN, because it is an assertion, like a tag. Kept
+    distinct from ``accept`` on purpose — ``accept`` records *who signed off*; a citation records
+    *what external result settles it*, and ``ref`` (the thing a reader follows to check the claim)
+    is the load-bearing payload ``accept`` has no slot for: ``accept:Smith2019@jorge@...`` would
+    read as "jorge accepted it", hiding that the truth is "Smith 2019 shows it".
+    """
+
+    def resolve(self, payload: str) -> ProofResult:
+        ref, _, rest = payload.partition("@")
+        author, _, year = rest.partition("@")
+        detail = "cites " + (ref or "?")
+        detail += f" by {author}" if author else ""
+        detail += f" ({year})" if year else ""
+        return ProofResult(ProofState.DELIVERED, True, detail)
+
+
 class External:
     """Wraps a proof adapter that resolves against a sibling repo checked out at ``repo``.
 

{prodc-0.3.65 → prodc-0.3.72}/src/prodc/agent.md

@@ -75,6 +75,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 |
 | 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.65 → prodc-0.3.72}/src/prodc/board.py

@@ -97,6 +97,12 @@ def need_payload(r: NeedResult, *, flavor: Literal["board", "html"] = "board") -
             "goal": need.goal,
             "release": need.release,
             "claim": need.claim,
+            "answer": need.answer.value if need.answer else None,
+            "withdrawn": (
+                {"reason": need.withdrawn.reason, "date": need.withdrawn.date}
+                if need.withdrawn
+                else None
+            ),
             "proofs": list(need.proofs),
             "detail": list(r.detail),
             "warnings": list(r.warnings),
@@ -138,6 +144,12 @@ def need_payload(r: NeedResult, *, flavor: Literal["board", "html"] = "board") -
         "release": need.release,
         "product": need.product,
         "draft": need.draft,
+        "answer": need.answer.value if need.answer else None,
+        "withdrawn": (
+            {"reason": need.withdrawn.reason, "date": need.withdrawn.date}
+            if need.withdrawn
+            else None
+        ),
         "importance": need.importance,
         "importance_set_at": need.importance_set_at,
         "claim": need.claim,

{prodc-0.3.65 → prodc-0.3.72}/src/prodc/cli/app.py

@@ -26,12 +26,14 @@ from .commands import (
     cmd_plan,
     cmd_portfolio,
     cmd_recurrence,
+    cmd_reinstate,
     cmd_report,
     cmd_set,
     cmd_show,
     cmd_status,
     cmd_suggest,
     cmd_sync,
+    cmd_withdraw,
 )
 
 
@@ -284,6 +286,44 @@ def main(argv: list[str] | None = None) -> int:
     )
     ac.set_defaults(func=cmd_accept)
 
+    wd = sub.add_parser(
+        "withdraw", help="record a decision against a need — withdrawn / won't-do (#74)"
+    )
+    wd.add_argument("need_id", help="the need id to withdraw")
+    wd.add_argument(
+        "--reason", required=True, help="why it was decided against (kept on the record)"
+    )
+    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")
+    wd.add_argument(
+        "--dry-run", action="store_true", help="validate and show the diff, don't write"
+    )
+    wd.add_argument(
+        "--expect-sha",
+        default=None,
+        metavar="SHA256",
+        help="refuse if the file's content hash differs (optimistic lock)",
+    )
+    wd.set_defaults(func=cmd_withdraw)
+
+    ri = sub.add_parser(
+        "reinstate", help="remove a need's withdrawal, putting it back on the board (#74)"
+    )
+    ri.add_argument("need_id", help="the need id to reinstate")
+    ri.add_argument("--config", default="prodc.toml", help="path to prodc.toml")
+    ri.add_argument("--json", action="store_true", help="machine-readable output")
+    ri.add_argument(
+        "--dry-run", action="store_true", help="validate and show the diff, don't write"
+    )
+    ri.add_argument(
+        "--expect-sha",
+        default=None,
+        metavar="SHA256",
+        help="refuse if the file's content hash differs (optimistic lock)",
+    )
+    ri.set_defaults(func=cmd_reinstate)
+
     pf = sub.add_parser("portfolio", help="roll up many repos into one scoreboard")
     pf.add_argument("configs", nargs="+", metavar="PRODC_TOML", help="one or more prodc.toml paths")
     pf.add_argument("--json", action="store_true", help="machine-readable output")

{prodc-0.3.65 → prodc-0.3.72}/src/prodc/cli/commands.py

@@ -51,8 +51,10 @@ from ..writer import (
     attest,
     capture_source,
     link_variant_group,
+    reinstate,
     set_field,
     set_importance,
+    withdraw,
 )
 from .common import RepoRow, emit_edit, exit_code, git_rev, load_or_report
 from .render import (
@@ -204,7 +206,8 @@ def cmd_status(args: argparse.Namespace) -> int:
     needs = list(model.needs)
     # Draft needs (#60) are staged: kept off the counted board (and coverage, recurrence,
     # orphans) until promoted with `set <id> draft=false`, unless --include-drafts is passed.
-    draft_count = sum(1 for n in needs if n.draft)
+    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)
     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.
@@ -259,6 +262,8 @@ def cmd_status(args: argparse.Namespace) -> int:
         print(summary_line(summary))
         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)")
         visible = [r for r in results if r.need.product]
         if args.only_must:
             visible = [r for r in visible if r.need.must]
@@ -476,6 +481,48 @@ def cmd_accept(args: argparse.Namespace) -> int:
     return emit_edit(edit, args.dry_run, args.json)
 
 
+def cmd_withdraw(args: argparse.Namespace) -> int:
+    """Record a decision against a need — withdrawn / won't-do (#74)."""
+    cfg_path = Path(args.config)
+    if not cfg_path.exists():
+        print(f"prodc: no config at {cfg_path}", file=sys.stderr)
+        return 2
+    try:
+        cfg = Config.load(cfg_path)
+        edit = withdraw(
+            cfg,
+            args.need_id,
+            reason=args.reason,
+            date=args.date or date.today().isoformat(),
+            expect_sha=args.expect_sha,
+            dry_run=args.dry_run,
+        )
+    except (ConfigError, WriteError) as exc:
+        print(f"prodc: {exc}", file=sys.stderr)
+        return 2
+    return emit_edit(edit, args.dry_run, args.json)
+
+
+def cmd_reinstate(args: argparse.Namespace) -> int:
+    """Remove a need's withdrawal, putting it back on the active board (#74)."""
+    cfg_path = Path(args.config)
+    if not cfg_path.exists():
+        print(f"prodc: no config at {cfg_path}", file=sys.stderr)
+        return 2
+    try:
+        cfg = Config.load(cfg_path)
+        edit = reinstate(
+            cfg,
+            args.need_id,
+            expect_sha=args.expect_sha,
+            dry_run=args.dry_run,
+        )
+    except (ConfigError, WriteError) as exc:
+        print(f"prodc: {exc}", file=sys.stderr)
+        return 2
+    return emit_edit(edit, args.dry_run, args.json)
+
+
 def cmd_capture(args: argparse.Namespace) -> int:
     """Append a Source to an existing need (capture evidence)."""
     cfg_path = Path(args.config)

{prodc-0.3.65 → prodc-0.3.72}/src/prodc/cli/render.py

@@ -273,6 +273,10 @@ def render_show(r: NeedResult, importance_label: str | None = None) -> str:
         f"  grounds: {_LABEL[r.state]}{nm}    warrant: {_warrant(need)}",
         f"  shape: {ears_shape(need.text).value}",
     ]
+    if need.answer:
+        lines.append(f"  answer: {need.answer.value}")
+    if need.withdrawn:
+        lines.append(f"  withdrawn: {need.withdrawn.reason} ({need.withdrawn.date})")
     if need.description:
         lines.append(f"  description: {need.description}")
     if need.importance is not None:

{prodc-0.3.65 → prodc-0.3.72}/src/prodc/config.py

@@ -10,9 +10,11 @@ from typing import cast
 from .adapters import (
     AcceptAdapter,
     Adapter,
+    CitationAdapter,
     CommandProof,
     CommandSource,
     CoverageAdapter,
+    EvalGateAdapter,
     External,
     FieldAdapter,
     FilesAdapter,
@@ -190,6 +192,8 @@ class Config:
                 inner = AcceptAdapter()
             elif kind == "prototype":
                 inner = PrototypeAdapter()
+            elif kind == "citation":
+                inner = CitationAdapter()
             elif kind == "coverage":
                 cat = tbl.get("catalog", "")
                 inner = CoverageAdapter(
@@ -202,13 +206,17 @@ class Config:
                 if not results_s:
                     raise ConfigError(f"[proofs.{name}]: external needs results = <json file>")
                 inner = OutcomeAdapter(root=proof_root, results=results_s)
+            elif kind == "evalgate":
+                if not results_s:
+                    raise ConfigError(f"[proofs.{name}]: evalgate needs results = <json file>")
+                inner = EvalGateAdapter(root=proof_root, results=results_s)
             elif kind == "command":
                 command, timeout = _hook_command(tbl, f"[proofs.{name}]")
                 inner = CommandProof(root=proof_root, command=command, timeout=timeout)
             else:
                 raise ConfigError(
                     f"[proofs.{name}]: unknown kind {kind!r} "
-                    "(gherkin|pytest|files|accept|prototype|coverage|field|external|command)"
+                    "(gherkin|pytest|files|accept|prototype|citation|coverage|field|external|evalgate|command)"
                 )
             adapters[name] = (
                 External(inner, root / repo_field) if isinstance(repo_field, str) else inner

{prodc-0.3.65 → prodc-0.3.72}/src/prodc/loader.py

@@ -17,6 +17,7 @@ import yaml
 
 from .config import Config
 from .model import (
+    Answer,
     ArgKind,
     ArgNode,
     Attestation,
@@ -28,6 +29,7 @@ from .model import (
     Role,
     Source,
     SourceKind,
+    Withdrawal,
 )
 
 
@@ -104,6 +106,45 @@ def _attestation(raw: object, where: str) -> Attestation | None:
     )
 
 
+def _answer(raw: object, where: str) -> Answer | None:
+    """Parse ``answer: yes|no|inconclusive`` into an :class:`Answer`, validated like other enums.
+
+    The direction a settled research question resolved; absent on a product need. Same
+    ``Enum(name) except ValueError`` pattern as ``SourceKind``/``ArgKind`` so an unknown value is
+    a :class:`LoaderError` the author owns, not silent junk.
+
+    YAML 1.1 reads a bare ``yes``/``no`` as a boolean, so ``answer: no`` arrives as ``False`` —
+    coerced back to the string here, the same way ``_opt_str`` accepts a bare ``date:`` that
+    parsed as a date. ``inconclusive`` is a plain string and needs no coercion.
+    """
+    if raw is None:
+        return None
+    if isinstance(raw, bool):
+        raw = "yes" if raw else "no"
+    name = _as_str(raw, where)
+    try:
+        return Answer(name)
+    except ValueError:
+        answers = "|".join(a.value for a in Answer)
+        raise LoaderError(f"{where}: unknown answer {name!r} ({answers})") from None
+
+
+def _withdrawal(raw: object, where: str) -> Withdrawal | None:
+    """Parse ``withdrawn: {reason, date}`` 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.
+    """
+    if raw is None:
+        return None
+    tbl = _as_mapping(raw, where)
+    reason = _opt_str(tbl.get("reason"), f"{where}.reason")
+    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)
+
+
 # Old source-kind names (pre-0.3.58) mapped to the primary/secondary/assumption ladder, so
 # existing need files keep loading. `interview` was live user contact (primary); `artifact` was a
 # cited document (secondary); `proxy`/`internal` were both unevidenced guesses (assumption).
@@ -160,6 +201,8 @@ def _need(
     release = _opt_str(tbl.get("release"), f"{where}.release")
     product = _as_bool(tbl["product"], f"{where}.product") if "product" in tbl else True
     draft = _as_bool(tbl["draft"], f"{where}.draft") if "draft" in tbl else False
+    withdrawn = _withdrawal(tbl.get("withdrawn"), f"{where}.withdrawn")
+    answer = _answer(tbl.get("answer"), f"{where}.answer")
 
     sources = tuple(
         _source(s, f"{where}.sources[{i}]")
@@ -217,6 +260,8 @@ def _need(
         not_variant_of=not_variant_of,
         importance_set_at=importance_set_at,
         draft=draft,
+        withdrawn=withdrawn,
+        answer=answer,
     )
 
 

{prodc-0.3.65 → prodc-0.3.72}/src/prodc/model.py

@@ -48,6 +48,26 @@ class NeedState(StrEnum):
     UNRESOLVED = "unresolved"  # a proof's source could not be read (e.g. sibling repo absent)
 
 
+class Answer(StrEnum):
+    """Which way a settled question resolved — the research board's direction axis.
+
+    A product need has one axis: is the outcome achieved? A research question has two: is it
+    *settled* (DELIVERED, the proof resolved green) and, if so, *which way*. DELIVERED means
+    settled; ``answer`` records the direction. A disproven hypothesis is therefore a settled
+    result that still counts toward coverage — DELIVERED with ``answer: no`` — not a gap.
+
+    Direction is always authored, never computed: an adapter can only map a proof to
+    delivered/pending/broken/unresolved, so no adapter can emit a settled-NO. The act of
+    concluding "this is the answer, and it is no" is the author's decision, so ``answer`` lives
+    on the :class:`Need` (authored lifecycle), not on a proof or need result (computed). A product
+    board never sets it and behaves exactly as before.
+    """
+
+    YES = "yes"  # the question settled affirmatively
+    NO = "no"  # the question settled negatively — a result, not a gap (e.g. a disproven hypothesis)
+    INCONCLUSIVE = "inconclusive"  # settled that the evidence cannot decide it either way
+
+
 @dataclass(frozen=True)
 class Source:
     """Where a need came from. Absence of any Source makes the need an opinion."""
@@ -140,6 +160,19 @@ class Attestation:
     comment: str | None = None  # the review's feedback / rationale, kept on the record
 
 
+@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.
+    """
+
+    reason: str
+    date: str
+
+
 @dataclass(frozen=True)
 class Need:
     """What a named person wants, with its provenance and its proofs."""
@@ -165,6 +198,10 @@ 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)
+    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
+    )
     not_duplicate_of: tuple[str, ...] = ()  # ids this need is confirmed NOT a duplicate of (#55)
     not_variant_of: tuple[str, ...] = ()  # ids this need is confirmed NOT a shared variant of (#56)
 
@@ -194,28 +231,37 @@ class Need:
         kinds = {s.kind for s in self.sources}
         return next((k for k in order if k in kinds), None)
 
+    @property
+    def is_withdrawn(self) -> bool:
+        """A decision has been recorded against this need — withdrawn / won't-do (#74)."""
+        return self.withdrawn is not None
+
     @property
     def counts_toward_coverage(self) -> bool:
         """Whether this need is a unit of product coverage — what :func:`~prodc.status.summarize`
         counts.
 
-        A leaf product need. A flow (a need with ``children``) is a roll-up of its leaves, so
-        counting it too would double-count (#43); a non-product need (infra/NFR/internal) is
-        excluded from product coverage (#48). Draft staging is a separate, upstream filter
-        (:func:`board_needs`), not part of this rule — so a draft still counts once promoted onto
-        the board (e.g. under ``--include-drafts``).
+        A leaf product need that has not been withdrawn. A flow (a need with ``children``) is a
+        roll-up of its leaves, so counting it too would double-count (#43); a non-product need
+        (infra/NFR/internal) is excluded from product coverage (#48); a withdrawn need is a
+        decision against, so it is out of coverage entirely (#74). Draft staging is a separate,
+        upstream filter (:func:`board_needs`), not part of this rule — so a draft still counts
+        once promoted onto the board (e.g. under ``--include-drafts``).
         """
-        return not self.children and self.product
+        return not self.children and self.product and not self.is_withdrawn
 
     @property
     def excluded_reason(self) -> str | None:
         """Why this need is off the counted board, or ``None`` when it is on it.
 
-        The single home for the lifecycle exclusions, so a new state lands here once: ``"draft"``
-        (staged, not yet promoted, #60) and ``"nonproduct"`` (infra/NFR/internal, #48). A flow is
-        not excluded — it is a roll-up row on the board — so ``children`` is not a reason here
-        (that axis is :attr:`counts_toward_coverage`).
+        The single home for the lifecycle exclusions, so a new state lands here once: ``"withdrawn"``
+        (a decision against, #74), ``"draft"`` (staged, not yet promoted, #60), and ``"nonproduct"``
+        (infra/NFR/internal, #48). Withdrawal is checked first — a decision against overrides
+        staging or scope. A flow is not excluded — it is a roll-up row on the board — so
+        ``children`` is not a reason here (that axis is :attr:`counts_toward_coverage`).
         """
+        if self.is_withdrawn:
+            return "withdrawn"
         if self.draft:
             return "draft"
         if not self.product:
@@ -224,12 +270,16 @@ class Need:
 
 
 def board_needs(needs: list[Need], *, include_drafts: bool) -> list[Need]:
-    """The needs on the counted board: a draft (#60) is staged off it until promoted.
+    """The needs on the active board: a withdrawn need (#74) is always off it, and a draft (#60)
+    is staged off until promoted.
 
-    ``include_drafts`` keeps them on (the ``--include-drafts`` flag). The one place the
-    draft-staging rule lives, shared by ``status`` and ``plan`` so the two never diverge.
+    A withdrawn need is a decision against, so it is dropped unconditionally — there is no
+    ``--include`` flag for it (its durable trace is the YAML record and ``prodc show``). Drafts
+    are kept when ``include_drafts`` (the ``--include-drafts`` flag). The one place the
+    board-membership rule lives, shared by ``status`` and ``plan`` so the two never diverge.
     """
-    return list(needs) if include_drafts else [n for n in needs if not n.draft]
+    kept = [n for n in needs if not n.is_withdrawn]
+    return kept if include_drafts else [n for n in kept if not n.draft]
 
 
 class ArgKind(StrEnum):

{prodc-0.3.65 → prodc-0.3.72}/src/prodc/report.py

@@ -75,10 +75,11 @@ def render_markdown(
         "proves yet — not a failure.",
     ]
 
-    # Needs grouped by who, like the board.
+    # Needs grouped by who, like the board. A withdrawn need (#74) is off the active board, so
+    # it is dropped here (its trace is the YAML record and `prodc show`), never shown as a gap.
     groups: dict[str, list[NeedResult]] = {}
     for r in results:
-        if not r.need.product:
+        if not r.need.product or r.need.is_withdrawn:
             continue
         groups.setdefault(r.need.who or "(unassigned)", []).append(r)
     if groups:
@@ -153,7 +154,11 @@ def render_markdown(
 
     # Open questions: the brief — opinions (no evidence) or HOLEs (no proof), must-haves first.
     open_ = [
-        r for r in results if r.need.product and (r.need.is_opinion or r.state is NeedState.HOLE)
+        r
+        for r in results
+        if r.need.product
+        and not r.need.is_withdrawn
+        and (r.need.is_opinion or r.state is NeedState.HOLE)
     ]
     open_.sort(key=lambda r: (not r.need.must, r.need.id))
     out += ["## Open questions", ""]