prodc 0.4.1__tar.gz → 0.4.3__tar.gz

{prodc-0.4.1 → prodc-0.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: prodc
-Version: 0.4.1
+Version: 0.4.3
 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.4.1 → prodc-0.4.3}/pyproject.toml

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

{prodc-0.4.1 → prodc-0.4.3}/src/prodc/cli/render.py

@@ -7,6 +7,7 @@ formatting: it reads the resolved model and returns strings, never loads or writ
 
 from __future__ import annotations
 
+import datetime
 import shutil
 from collections.abc import Callable
 
@@ -27,6 +28,7 @@ from ..status import (
     PrincipleReport,
     Recurrence,
     Summary,
+    group_state,
     orphaned_decisions,
     rank,
     state_priority,
@@ -209,12 +211,21 @@ def render_out_of_scope(results: list[NeedResult]) -> str:
 
 
 def render_goals(goal_cov: list[tuple[Goal, Summary]], ungoaled: list[NeedResult]) -> str:
-    """Per-goal coverage, plus the needs that serve no objective (#27)."""
+    """Per-goal coverage with a derived state and target, plus the needs that serve no objective (#27, #80)."""
+    today = datetime.date.today().isoformat()
     out = ["\ngoals (objectives needs trace up to):"]
     for goal, gsum in goal_cov:
+        state = group_state(gsum)
         metric = f"  [{goal.metric}]" if goal.metric else ""
         pct = round(gsum.coverage * 100)
-        out.append(f"  {goal.id:<12} {gsum.delivered}/{gsum.total} ({pct}%){metric}  {goal.text}")
+        overdue = goal.target is not None and goal.target < today and state is not NeedState.DELIVERED
+        target = ""
+        if goal.target:
+            target = f"  ⚠ overdue {goal.target}" if overdue else f"  target {goal.target}"
+        out.append(
+            f"  {goal.id:<12} {_LABEL[state]:<10} {gsum.delivered}/{gsum.total} ({pct}%)"
+            f"{metric}{target}  {goal.text}"
+        )
     if ungoaled:
         ids = ", ".join(r.need.id for r in ungoaled)
         out.append(f"  ⚠ {len(ungoaled)} need(s) serve no goal: {ids}")
@@ -382,7 +393,10 @@ def render_show(
     else:
         lines.append("  sources: (none — opinion)")
     if need.children:
-        lines.append(f"  children: {', '.join(need.children)}")
+        rendered = ", ".join(
+            c.id if c.step is None else f"{c.id}@{c.step}" for c in need.children
+        )
+        lines.append(f"  children: {rendered}")
     if need.contradicts:
         lines.append(f"  contradicts: {', '.join(need.contradicts)}")
     if need.seam:

{prodc-0.4.1 → prodc-0.4.3}/src/prodc/cli/serialize.py

@@ -13,7 +13,7 @@ from ..board import need_payload
 from ..board import warrant as _warrant
 from ..dedup import DupPair, VariantGroup
 from ..model import Decision, Goal, NeedResult, NeedState, Release, Role
-from ..status import Handoff, PrincipleReport, Recurrence, Summary, rank
+from ..status import Handoff, PrincipleReport, Recurrence, Summary, group_state, rank
 from .common import brief_open
 
 
@@ -119,6 +119,9 @@ def to_json(
                 "id": goal.id,
                 "text": goal.text,
                 "metric": goal.metric,
+                "description": goal.description,
+                "target": goal.target,
+                "state": group_state(gsum).value,
                 "coverage": round(gsum.coverage, 4),
                 "delivered": gsum.delivered,
                 "total": gsum.total,
@@ -160,7 +163,7 @@ def show_json(r: NeedResult, decisions: list[Decision] | None = None) -> str:
                 for s in need.sources
             ],
             "proofs": list(need.proofs),
-            "children": list(need.children),
+            "children": [{"id": c.id, "step": c.step} for c in need.children],
             "seam": list(need.seam),
         }
     )

{prodc-0.4.1 → prodc-0.4.3}/src/prodc/loader.py

@@ -21,6 +21,7 @@ from .model import (
     Answer,
     Attestation,
     AttestationKind,
+    Child,
     Decision,
     Goal,
     Model,
@@ -203,6 +204,21 @@ def _source(raw: object, where: str) -> Source:
     )
 
 
+def _child(raw: object, where: str) -> Child:
+    """Parse one flow edge: a bare id string, or a ``{id, step}`` mapping (#90).
+
+    A bare ``US-050`` stays valid (``Child("US-050")`` with no step), so existing flows load
+    unchanged; a mapping adds the optional ``step`` the edge plays in the journey.
+    """
+    if isinstance(raw, str):
+        return Child(id=raw)
+    tbl = _as_mapping(raw, where)
+    return Child(
+        id=_as_str(tbl.get("id"), f"{where}.id"),
+        step=_opt_str(tbl.get("step"), f"{where}.step"),
+    )
+
+
 def _need(
     raw: object,
     where: str,
@@ -243,7 +259,7 @@ def _need(
         for i, p in enumerate(_as_list(tbl.get("proofs"), f"{where}.proofs"))
     )
     children = tuple(
-        _as_str(c, f"{where}.children[{i}]")
+        _child(c, f"{where}.children[{i}]")
         for i, c in enumerate(_as_list(tbl.get("children"), f"{where}.children"))
     )
     seam = tuple(
@@ -306,6 +322,8 @@ def _goal(raw: object, where: str) -> Goal:
         id=_as_str(tbl.get("id"), f"{where}.id"),
         text=_as_str(tbl.get("text"), f"{where}.text"),
         metric=_opt_str(tbl.get("metric"), f"{where}.metric"),
+        description=_opt_str(tbl.get("description"), f"{where}.description"),
+        target=_opt_str(tbl.get("target"), f"{where}.target"),
     )
 
 
@@ -564,9 +582,9 @@ def _check_children(needs: list[Need]) -> None:
     """Every id in a need's ``children`` must name a known need."""
     known = {n.id for n in needs}
     for need in needs:
-        for cid in need.children:
-            if cid not in known:
-                raise LoaderError(f"need {need.id!r}: child {cid!r} is not a known need id")
+        for c in need.children:
+            if c.id not in known:
+                raise LoaderError(f"need {need.id!r}: child {c.id!r} is not a known need id")
 
 
 def _check_withdrawal_of(needs: list[Need]) -> None:

{prodc-0.4.1 → prodc-0.4.3}/src/prodc/model.py

@@ -102,11 +102,20 @@ class Goal:
 
     A need with no ``goal`` is flagged the way an unsourced need is flagged an opinion — it
     lets the board answer "are we moving the objective", not only "is this need delivered".
+
+    A goal is also the home for the long-lived container other trackers call an *initiative* or
+    *epic* (#80): a ``description`` and an optional ``target`` window give it a title, a blurb and a
+    deadline, and its state is *derived* from the needs that cite it (:func:`~prodc.status.group_state`),
+    never hand-set — so an "is this big piece of work done" rolls up from the proofs, not a status
+    field that drifts. No separate ``initiative`` noun: an output bundle that is neither an outcome
+    (goal) nor a ship slice (release) is engineering tracking, not product.
     """
 
     id: str
     text: str
     metric: str | None = None  # how the objective is measured, e.g. "churn < 5%"
+    description: str | None = None  # optional longer blurb — the initiative's prose (#80)
+    target: str | None = None  # optional ISO date the objective is aimed at; past + not DELIVERED warns
 
 
 @dataclass(frozen=True)
@@ -257,6 +266,21 @@ class Withdrawal:
     of: str | None = None  # id of the need this one duplicates (required when kind is duplicate)
 
 
+@dataclass(frozen=True)
+class Child:
+    """One edge of a flow: the sub-need and, optionally, the ``step`` it plays in the journey (#90).
+
+    A flow's ``children`` are ordered, and a use case ("job") is just a flow with a ``role`` set and
+    a ``step`` on each edge (locate / execute / conclude). The step annotates the *edge*, not the
+    sub-need — the same need can be the ``execute`` step of one flow and the ``locate`` of another —
+    so it lives here, not on :class:`Need`. A bare ``US-050`` in YAML loads as ``Child("US-050")``
+    with no step, so every existing flow keeps working unchanged.
+    """
+
+    id: str
+    step: str | None = None
+
+
 @dataclass(frozen=True)
 class Need:
     """What a named person wants, with its provenance and its proofs."""
@@ -269,7 +293,7 @@ class Need:
     must: bool = False
     sources: tuple[Source, ...] = ()
     proofs: tuple[str, ...] = ()  # locators, "<adapter>:<payload>" (leaf needs)
-    children: tuple[str, ...] = ()  # ids of sub-needs (a flow is a Need with children)
+    children: tuple[Child, ...] = ()  # ordered sub-need edges (a flow is a Need with children)
     seam: tuple[str, ...] = ()  # end-to-end proof locators for a flow's between-steps behaviour
     client: str | None = None  # which client this instance is for; None = shared baseline
     variant_of: str | None = None  # id of the baseline need this specialises; None = standalone

{prodc-0.4.1 → prodc-0.4.3}/src/prodc/report.py

@@ -14,7 +14,7 @@ from datetime import date
 from .board import gather
 from .config import Config
 from .model import Model, NeedResult, NeedState
-from .status import active_decisions, principle_report, state_priority
+from .status import active_decisions, group_state, principle_report, state_priority
 
 _LABEL = {
     NeedState.DELIVERED: "DELIVERED",
@@ -97,11 +97,12 @@ def render_markdown(
             out.append("")
 
     if model.goals:
-        out += ["## Goals", "", "| goal | delivered | goal |", "|---|---|---|"]
+        out += ["## Goals", "", "| goal | state | delivered | target | goal |", "|---|---|---|---|---|"]
         for goal, gsum in goal_cov:
             out.append(
-                f"| {goal.id} | {gsum.delivered}/{gsum.total} ({round(gsum.coverage * 100)}%) "
-                f"| {goal.text} |"
+                f"| {goal.id} | {_LABEL[group_state(gsum)]} "
+                f"| {gsum.delivered}/{gsum.total} ({round(gsum.coverage * 100)}%) "
+                f"| {goal.target or ''} | {goal.text} |"
             )
         if ungoaled:
             out.append("")

{prodc-0.4.1 → prodc-0.4.3}/src/prodc/report_html.py

@@ -15,7 +15,7 @@ from datetime import date
 from .board import gather, need_payload
 from .config import Config
 from .model import Model
-from .status import active_decisions, principle_report
+from .status import active_decisions, group_state, principle_report
 
 
 def board_payload(
@@ -55,7 +55,16 @@ def board_payload(
             for r in results
             if r.need.product and not r.need.is_withdrawn
         ],
-        "goals": [{"id": g.id, "text": g.text, **_cov(s.delivered, s.total)} for g, s in goal_cov],
+        "goals": [
+            {
+                "id": g.id,
+                "text": g.text,
+                "target": g.target,
+                "state": group_state(s).value,
+                **_cov(s.delivered, s.total),
+            }
+            for g, s in goal_cov
+        ],
         "ungoaled": [r.need.id for r in ungoaled],
         "releases": [
             {"id": rel.id, "text": rel.text, **_cov(s.delivered, s.total)} for rel, s in rel_cov

{prodc-0.4.1 → prodc-0.4.3}/src/prodc/status.py

@@ -293,11 +293,11 @@ class Resolver:
         warnings: list[str] = []
         child_states: list[NeedState] = []
         declared = False
-        for cid in need.children:
-            if cid not in self._by_id:
-                warnings.append(f"unknown child id '{cid}'")
+        for c in need.children:
+            if c.id not in self._by_id:
+                warnings.append(f"unknown child id '{c.id}'")
                 continue
-            cr = self.resolve(cid)
+            cr = self.resolve(c.id)
             child_states.append(cr.state)
             declared = declared or cr.declared
         delivered = sum(1 for s in child_states if s is NeedState.DELIVERED)
@@ -385,6 +385,26 @@ def summarize(results: list[NeedResult]) -> Summary:
     )
 
 
+def group_state(s: Summary) -> NeedState:
+    """The derived state of an FK group (goal, release, role) — the roll-up of its members (#80).
+
+    One function behind every group's state, so a goal/initiative, a release slice and a role all
+    read the same way and none carries a hand-set status that can drift from its needs: BROKEN if
+    any member proof is broken, UNRESOLVED if any source couldn't be read, DELIVERED only when every
+    member is, HOLE when nothing is covered yet, else PENDING (in progress). An empty group is a
+    HOLE (nothing delivered, nothing pending).
+    """
+    if s.broken:
+        return NeedState.BROKEN
+    if s.unresolved:
+        return NeedState.UNRESOLVED
+    if s.total and s.delivered == s.total:
+        return NeedState.DELIVERED
+    if s.delivered == 0 and s.pending == 0:
+        return NeedState.HOLE
+    return NeedState.PENDING
+
+
 @dataclass(frozen=True)
 class Recurrence:
     """A baseline need and the clients that carry a variant of it (#32)."""
@@ -806,7 +826,7 @@ def handoffs(needs: list[Need]) -> list[Handoff]:
     for flow in needs:
         if not flow.children:
             continue
-        steps = [by_id[c] for c in flow.children if c in by_id]
+        steps = [by_id[c.id] for c in flow.children if c.id in by_id]
         for a, b in pairwise(steps):
             if a.role and b.role and a.role != b.role:
                 out.append(Handoff(flow, a, b, a.role, b.role))
@@ -844,7 +864,7 @@ def flow_orphan_warnings(needs: list[Need]) -> set[str]:
         return set()
     in_a_flow: set[str] = set()
     for flow in flows:
-        in_a_flow.update(flow.children)
+        in_a_flow.update(c.id for c in flow.children)
     return {n.id for n in needs if not n.children and n.id not in in_a_flow}
 
 

{prodc-0.4.1 → prodc-0.4.3}/src/prodc/writer.py

@@ -365,6 +365,19 @@ def _coerce(value: str) -> object:
         return value
 
 
+def _child_item(raw: str) -> object:
+    """Parse a ``children+=`` value into a flow edge: ``id`` stays a bare string, ``id@step`` a map.
+
+    Mirrors the loader's dual shape (#90): ``children+=US-050`` appends the bare id (unstepped),
+    ``children+=US-052@execute`` appends ``{id: US-052, step: execute}``. A bare id keeps the file's
+    existing plain-string style; the ``@`` suffix mirrors the ``need:A@yes`` proof-locator idiom.
+    """
+    head, sep, step = raw.partition("@")
+    if not sep:
+        return raw
+    return {"id": head.strip(), "step": step.strip()}
+
+
 def _apply_assignment(need: dict[str, object], assignment: str, path: Path) -> None:
     if "+=" in assignment:
         key, _, raw = assignment.partition("+=")
@@ -377,7 +390,7 @@ def _apply_assignment(need: dict[str, object], assignment: str, path: Path) -> N
         if not isinstance(current, list):
             raise WriteError(f"{path.name}: {key!r} is not a list")
         items = cast("list[object]", current)
-        items.append(raw.strip())
+        items.append(_child_item(raw.strip()) if key == "children" else raw.strip())
         need[key] = items
         return
     key, sep, raw = assignment.partition("=")

{prodc-0.4.1 → prodc-0.4.3}/tests/test_loader.py

@@ -109,6 +109,26 @@ def test_flow_with_proofs_raises(tmp_path: Path) -> None:
         load_needs(cfg)
 
 
+def test_children_load_as_bare_id_or_stepped_mapping(tmp_path: Path) -> None:
+    # #90: a flow's children take either a bare id (unstepped) or a {id, step} mapping, mixed.
+    cfg = _config(
+        tmp_path,
+        (
+            "a.yaml",
+            "needs:\n"
+            "  - id: F-1\n"
+            "    text: a flow\n"
+            "    children:\n"
+            "      - C-1\n"
+            "      - {id: C-2, step: execute}\n"
+            "  - id: C-1\n    text: one\n"
+            "  - id: C-2\n    text: two\n",
+        ),
+    )
+    flow = next(n for n in load_needs(cfg) if n.id == "F-1")
+    assert [(c.id, c.step) for c in flow.children] == [("C-1", None), ("C-2", "execute")]
+
+
 def test_variant_scope_shared_baseline_across_clients(tmp_path: Path) -> None:
     cfg = _config(
         tmp_path,
@@ -242,6 +262,26 @@ def test_goals_loaded_and_need_traces_up(tmp_path: Path) -> None:
     assert model.needs[0].goal == "G-1"
 
 
+def test_goal_loads_description_and_target(tmp_path: Path) -> None:
+    # #80: a goal is the home for the initiative — a description and an optional target window.
+    from prodc.loader import load
+
+    cfg = _config(
+        tmp_path,
+        (
+            "goals.yaml",
+            "goals:\n"
+            "  - id: INIT-SEARCH\n"
+            "    text: Second-generation search\n"
+            "    description: the long blurb\n"
+            "    target: 2026-12-15\n",
+        ),
+    )
+    goal = load(cfg).goals[0]
+    assert goal.description == "the long blurb"
+    assert goal.target == "2026-12-15"
+
+
 def test_need_goal_unknown_raises(tmp_path: Path) -> None:
     cfg = _config(tmp_path, ("a.yaml", "needs:\n  - id: N-1\n    text: t\n    goal: NOPE\n"))
     with pytest.raises(LoaderError, match="goal 'NOPE' is not a known goal id"):

{prodc-0.4.1 → prodc-0.4.3}/tests/test_models.py

@@ -14,7 +14,7 @@ from dataclasses import dataclass, replace
 from musil import Action, Model, check, explore, reaches
 
 from prodc.adapters import Adapter, ProofResult
-from prodc.model import Decision, Need, NeedState, ProofState, Withdrawal, board_needs
+from prodc.model import Child, Decision, Need, NeedState, ProofState, Withdrawal, board_needs
 from prodc.status import Resolver, active_decisions
 
 
@@ -141,7 +141,7 @@ def flow_state(f: Flow) -> NeedState:
     """The NeedState prodc's real aggregate gives this set of children + seam."""
     children = [_child_need(f"c{i}", s) for i, s in enumerate(f.children)]
     seam = tuple(f"stub:{s}" for s in f.seam if s != "none")
-    flow = Need(id="flow", text="f", children=tuple(c.id for c in children), seam=seam)
+    flow = Need(id="flow", text="f", children=tuple(Child(c.id) for c in children), seam=seam)
     return Resolver([flow, *children], _ADAPTERS).resolve("flow").state
 
 

{prodc-0.4.1 → prodc-0.4.3}/tests/test_status.py

@@ -6,8 +6,24 @@ from dataclasses import dataclass
 from pathlib import Path
 
 from prodc.adapters import FrontmatterAdapter, ProofResult, SourceAdapter
-from prodc.model import Need, NeedState, ProofState, Source, SourceKind
-from prodc.status import resolve
+from prodc.model import Child, Need, NeedState, ProofState, Source, SourceKind
+from prodc.status import Summary, group_state, resolve
+
+
+def _summary(**kw: int) -> Summary:
+    base = dict(total=0, delivered=0, pending=0, hole=0, must_hole=0, broken=0, unresolved=0, opinion=0)
+    base.update(kw)
+    return Summary(**base)
+
+
+def test_group_state_rolls_up_members() -> None:
+    # #80: a goal/release/role state is derived from its members, never hand-set.
+    assert group_state(_summary()) is NeedState.HOLE  # empty group
+    assert group_state(_summary(total=2, hole=2)) is NeedState.HOLE  # nothing started
+    assert group_state(_summary(total=2, delivered=2)) is NeedState.DELIVERED
+    assert group_state(_summary(total=2, delivered=1, pending=1)) is NeedState.PENDING
+    assert group_state(_summary(total=2, delivered=1, broken=1)) is NeedState.BROKEN  # broken wins
+    assert group_state(_summary(total=2, delivered=1, unresolved=1)) is NeedState.UNRESOLVED
 
 
 @dataclass(frozen=True)
@@ -52,7 +68,7 @@ def test_flow_aggregates_two_of_three() -> None:
         Need(id="C-2", text="two", proofs=("web:2",)),
         Need(id="C-3", text="three", proofs=()),  # a HOLE
     )
-    flow = Need(id="F-1", text="a flow", children=("C-1", "C-2", "C-3"))
+    flow = Need(id="F-1", text="a flow", children=(Child("C-1"), Child("C-2"), Child("C-3")))
     results = {r.need.id: r for r in resolve([flow, *children], {"web": _delivered()})}
     flow_result = results["F-1"]
     assert flow_result.state is NeedState.PENDING  # not all delivered → pending
@@ -234,7 +250,7 @@ def test_coverage_counts_leaves_not_flow_parents() -> None:
     from prodc.status import summarize
 
     needs = [
-        Need(id="F-1", text="roast day flow", children=("L-1", "L-2")),
+        Need(id="F-1", text="roast day flow", children=(Child("L-1"), Child("L-2"))),
         Need(id="L-1", text="step one", proofs=("x:1",)),
         Need(id="L-2", text="step two", proofs=("x:1",)),
     ]
@@ -296,7 +312,7 @@ def test_flow_orphan_warning() -> None:
     from prodc.status import flow_orphan_warnings
 
     needs = [
-        Need(id="F-1", text="a flow", children=("L-1",)),
+        Need(id="F-1", text="a flow", children=(Child("L-1"),)),
         Need(id="L-1", text="in the flow"),
         Need(id="L-2", text="in no flow"),
     ]
@@ -354,7 +370,7 @@ def test_flow_seam_proof_gates_delivered() -> None:
     # all children delivered but the seam proof pending → flow is PENDING, not DELIVERED (#44)
     from prodc.adapters import Adapter
 
-    flow = Need(id="F-1", text="roast day", children=("L-1", "L-2"), seam=("web:seam#E2E",))
+    flow = Need(id="F-1", text="roast day", children=(Child("L-1"), Child("L-2")), seam=("web:seam#E2E",))
     children = [
         Need(id="L-1", text="a", proofs=("x:1",)),
         Need(id="L-2", text="b", proofs=("x:1",)),
@@ -368,14 +384,14 @@ def test_flow_seam_proof_gates_delivered() -> None:
 
 
 def test_flow_seam_green_delivers() -> None:
-    flow = Need(id="F-1", text="roast day", children=("L-1",), seam=("web:seam#E2E",))
+    flow = Need(id="F-1", text="roast day", children=(Child("L-1"),), seam=("web:seam#E2E",))
     child = Need(id="L-1", text="a", proofs=("x:1",))
     by_id = {r.need.id: r for r in resolve([flow, child], {"x": _delivered(), "web": _delivered()})}
     assert by_id["F-1"].state is NeedState.DELIVERED
 
 
 def test_flow_seam_broken_breaks_flow() -> None:
-    flow = Need(id="F-1", text="roast day", children=("L-1",), seam=("nope:x",))
+    flow = Need(id="F-1", text="roast day", children=(Child("L-1"),), seam=("nope:x",))
     child = Need(id="L-1", text="a", proofs=("x:1",))
     by_id = {r.need.id: r for r in resolve([flow, child], {"x": _delivered()})}
     assert by_id["F-1"].state is NeedState.BROKEN  # no 'nope' adapter → seam BROKEN

{prodc-0.4.1 → prodc-0.4.3}/tests/test_writer.py

@@ -275,6 +275,33 @@ def test_delete_need_removes_the_block_keeping_others(tmp_path: Path) -> None:
     assert "# keep me" in text  # header comment survives the splice
 
 
+def test_children_append_stepped_edge(tmp_path: Path) -> None:
+    # #90: `children+=id@step` appends a {id, step} edge; a bare id stays a plain string.
+    body = (
+        "needs:\n"
+        "  - id: F-1\n    text: a flow\n    children: [N-2]\n"
+        "  - id: N-2\n    text: step two\n    proofs: ['x:1']\n"
+        "  - id: N-3\n    text: step three\n    proofs: ['x:2']\n"
+    )
+    cfg = _proj(tmp_path, body)
+    set_field(cfg, "F-1", "children+=N-3@conclude", expect_sha=None, dry_run=False)
+    flow = next(n for n in load(cfg).needs if n.id == "F-1")
+    assert [(c.id, c.step) for c in flow.children] == [("N-2", None), ("N-3", "conclude")]
+
+
+def test_children_append_bare_id(tmp_path: Path) -> None:
+    body = (
+        "needs:\n"
+        "  - id: F-1\n    text: a flow\n    children: [N-2]\n"
+        "  - id: N-2\n    text: step two\n    proofs: ['x:1']\n"
+        "  - id: N-3\n    text: step three\n    proofs: ['x:2']\n"
+    )
+    cfg = _proj(tmp_path, body)
+    set_field(cfg, "F-1", "children+=N-3", expect_sha=None, dry_run=False)
+    flow = next(n for n in load(cfg).needs if n.id == "F-1")
+    assert [(c.id, c.step) for c in flow.children] == [("N-2", None), ("N-3", None)]
+
+
 def test_delete_need_unknown_id_rejected(tmp_path: Path) -> None:
     cfg = _proj(tmp_path, "needs:\n  - id: N-1\n    text: t\n")
     with pytest.raises(WriteError, match="no need 'N-9'"):