arctx-cli 0.3.1b2__tar.gz → 0.3.1b3__tar.gz

{arctx_cli-0.3.1b2 → arctx_cli-0.3.1b3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arctx-cli
-Version: 0.3.1b2
+Version: 0.3.1b3
 Summary: CLI for ARCTX — append-only DAG editing and refactoring
 Project-URL: Homepage, https://github.com/takumiecd/arctx
 Project-URL: Repository, https://github.com/takumiecd/arctx
@@ -17,7 +17,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Utilities
 Requires-Python: >=3.10
-Requires-Dist: arctx>=0.3.1b2
+Requires-Dist: arctx>=0.3.1b3
 Provides-Extra: dev
 Requires-Dist: black>=23.0; extra == 'dev'
 Requires-Dist: mypy>=1.0; extra == 'dev'

{arctx_cli-0.3.1b2 → arctx_cli-0.3.1b3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "arctx-cli"
-version = "0.3.1b2"
+version = "0.3.1b3"
 description = "CLI for ARCTX — append-only DAG editing and refactoring"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -25,7 +25,7 @@ classifiers = [
     "Topic :: Utilities",
 ]
 dependencies = [
-    "arctx>=0.3.1b2",
+    "arctx>=0.3.1b3",
 ]
 
 [project.optional-dependencies]

{arctx_cli-0.3.1b2 → arctx_cli-0.3.1b3}/src/arctx_cli/commands/add.py

@@ -14,6 +14,7 @@ from arctx_cli.context import (
     resolve_user_id_from_args,
     resolve_lane_id_from_args,
 )
+from arctx_cli.lane_gate import ensure_lane_open
 from arctx_cli.payload_builder import build_payload, parse_field_args, parse_json_object
 
 
@@ -36,6 +37,8 @@ def add_parser(subparsers) -> argparse.ArgumentParser:
     parser.add_argument("--store-dir", default=None)
     parser.add_argument("--user", default=None)
     parser.add_argument("--lane", default=None)
+    parser.add_argument("--force", action="store_true",
+                        help="Write even if the target lane is closed")
 
     return parser
 
@@ -52,11 +55,13 @@ def run_add_step_command(
     store_dir: str,
     user_id: str | None = None,
     lane_id: str | None = None,
+    force: bool = False,
 ) -> dict:
     store = resolve_store(store_dir)
     if not store.run_path(run_id).exists():
         raise KeyError(f"unknown run_id: {run_id}")
     handle = store.load_run(run_id)
+    ensure_lane_open(handle, lane_id, force=force)
     data = dict(json_data or {})
     data.update(field_data or {})
     if title is not None:
@@ -105,6 +110,7 @@ def cli_add(args) -> int:
             store_dir=args.store_dir,
             user_id=resolve_user_id_from_args(args),
             lane_id=resolve_lane_id_from_args(args),
+            force=args.force,
         )
         print(json.dumps(result["step"], ensure_ascii=False, indent=2))
         return 0

{arctx_cli-0.3.1b2 → arctx_cli-0.3.1b3}/src/arctx_cli/commands/asset.py

@@ -13,6 +13,7 @@ from arctx_cli.context import (
     resolve_user_id_from_args,
     resolve_lane_id_from_args,
 )
+from arctx_cli.lane_gate import ensure_lane_open
 
 
 def add_parser(subparsers) -> argparse.ArgumentParser:
@@ -27,6 +28,8 @@ def add_parser(subparsers) -> argparse.ArgumentParser:
     sp_attach.add_argument("--store-dir", default=None)
     sp_attach.add_argument("--user", default=None)
     sp_attach.add_argument("--lane", default=None)
+    sp_attach.add_argument("--force", action="store_true",
+                           help="Write even if the target lane is closed")
 
     sp_list = asset_sub.add_parser("list", help="List assets for a Node or Step")
     sp_list.add_argument("--target", required=True, dest="target_id", help="Node or Step ID")
@@ -72,6 +75,7 @@ def _cli_asset_attach(args) -> int:
         return 1
 
     try:
+        ensure_lane_open(handle, lane_id, force=args.force)
         before = graph_counts(handle)
         payload = handle.attach_asset(
             args.target_id,

{arctx_cli-0.3.1b2 → arctx_cli-0.3.1b3}/src/arctx_cli/commands/attach.py

@@ -15,6 +15,7 @@ from arctx_cli.context import (
     resolve_lane_id_from_args,
 )
 from arctx_cli.payload_builder import build_payload, parse_field_args, parse_json_object
+from arctx_cli.lane_gate import ensure_lane_open
 
 
 def add_parser(subparsers) -> argparse.ArgumentParser:
@@ -28,6 +29,8 @@ def add_parser(subparsers) -> argparse.ArgumentParser:
     parser.add_argument("--store-dir", default=None)
     parser.add_argument("--user", default=None)
     parser.add_argument("--lane", default=None)
+    parser.add_argument("--force", action="store_true",
+                        help="Write even if the target lane is closed")
     return parser
 
 
@@ -42,11 +45,13 @@ def run_attach_command(
     store_dir: str,
     user_id: str | None = None,
     lane_id: str | None = None,
+    force: bool = False,
 ) -> dict:
     store = resolve_store(store_dir)
     if not store.run_path(run_id).exists():
         raise KeyError(f"unknown run_id: {run_id}")
     handle = store.load_run(run_id)
+    ensure_lane_open(handle, lane_id, force=force)
     target_kind = resolve_target_kind(handle, target_id)
     if target_kind == "payload":
         raise ValueError("cannot attach a payload to another payload")
@@ -107,6 +112,7 @@ def cli_attach(args) -> int:
             store_dir=args.store_dir,
             user_id=resolve_user_id_from_args(args),
             lane_id=resolve_lane_id_from_args(args),
+            force=args.force,
         )
         print(json.dumps(result["payload"], ensure_ascii=False, indent=2))
         return 0

{arctx_cli-0.3.1b2 → arctx_cli-0.3.1b3}/src/arctx_cli/commands/guide.py

@@ -27,7 +27,7 @@ def cli_guide(args) -> int:
 1. **Understand Context**: Use `arctx dump` to view the graph. Check your **Current Lane** and **Active Frontiers** at the bottom of this guide to know where to resume work.
 2. **Isolate Approaches**: Use lanes to explore different solutions independently.
 3. **Record Everything**: Record your steps (e.g., via `arctx add` or `arctx git commit`). The graph should capture *how* you solved the problem, not just the final result.
-4. **Merge & Summarize**: Once you have explored multiple paths or completed a complex task, use `arctx lane join` to merge your active frontiers and attach a summary of your findings.
+4. **Close & Summarize**: When a lane's work is done, close it with `arctx lane close NAME --summary "..."`. This is the *close* action — use it even for a single linear chain, not only when several paths must be merged. The summary is **Markdown** (rendered as such in the web GUI) and becomes the closing node's payload, so **put your full synthesis there** (one leaf → it stamps that leaf; several leaves → it merges them into one node). Do **not** write a separate synthesis step and then close on top of it — the close *is* your synthesis-and-close. A closed lane refuses further writes; reopen it with `arctx lane open NAME` to resume.
 
 ## Essential Core Commands
 
@@ -35,7 +35,8 @@ def cli_guide(args) -> int:
 * `arctx dump --format outline --lane` : View the history of the current lane.
 * `arctx lane` : Show the currently active lane.
 * `arctx show <ID>` : Show details of a specific Node, Step, or Payload.
-* `arctx lane join <LANE> --summary "..."` : Merge frontier nodes in a lane and attach a summary.
+* `arctx lane close <LANE> --summary "<your synthesis>"` : Close a lane. Attaches the summary (**Markdown**) to its terminal (its one leaf, or a fresh node merging several leaves) and marks it closed; writes are then refused until reopened. Put your findings in `--summary` here — not in a separate preceding step. (`arctx lane join` is a deprecated alias.)
+* `arctx lane open <LANE>` : Reopen a closed lane to resume work.
 """
     # Try to load execution context dynamically
     try:

{arctx_cli-0.3.1b2 → arctx_cli-0.3.1b3}/src/arctx_cli/commands/lane.py

@@ -46,9 +46,12 @@ def add_parser(subparsers) -> argparse.ArgumentParser:
         "lane",
         help="Switch/show the active lane (solo or collaborative unit of work)",
         description=(
-            "`arctx lane create NAME` creates a lane. `arctx lane switch NAME` "
-            "switches to an existing lane and pins it for this checkout. "
-            "`arctx lane NAME` is switch shorthand and errors when NAME is absent."
+            "`arctx lane create NAME` creates a lane (status open). `arctx lane switch "
+            "NAME` switches to an existing lane and pins it for this checkout. "
+            "`arctx lane NAME` is switch shorthand and errors when NAME is absent. "
+            "`arctx lane close NAME --summary TEXT` closes a lane (attaching the summary "
+            "to its terminal); `arctx lane open NAME` reopens it. Writes to a closed lane "
+            "are refused until it is reopened."
         ),
     )
     parser.add_argument(
@@ -57,7 +60,7 @@ def add_parser(subparsers) -> argparse.ArgumentParser:
         metavar="COMMAND|NAME",
         help=(
             "No args = current lane. Commands: create NAME, switch NAME, "
-            "adopt NAME, validate, list, show LANE, summaries LANE."
+            "close NAME, open NAME, adopt NAME, validate, list, show LANE, summaries LANE."
         ),
     )
     parser.add_argument("--list", action="store_true", dest="list_lanes",
@@ -86,18 +89,19 @@ def add_parser(subparsers) -> argparse.ArgumentParser:
     parser.add_argument(
         "--reason",
         default=None,
-        help="Reason recorded on a lane adoption event",
+        help="Reason recorded on a lane adoption / close / open event",
     )
     parser.add_argument(
         "--summary",
         default=None,
-        help="Summary text to attach when joining a lane",
+        help="Closing summary (Markdown), attached to the lane's terminal node (lane close)",
     )
     parser.add_argument(
         "--node",
         action="append",
         default=None,
-        help="Specific node id to join (repeatable; if omitted, joins all leaf nodes of the lane)",
+        help="Specific leaf node id to summarise on close "
+             "(repeatable; if omitted, uses all active leaf nodes of the lane)",
     )
     parser.add_argument("--user", default=None, help="Actor (created_by) when creating")
     parser.add_argument("--run", default=None)
@@ -392,24 +396,76 @@ def validate_lane_run(*, run_id: str, store_dir: str | None) -> dict:
     }
 
 
-def run_lane_join_command(
+def _lane_active_leaves(handle, lane) -> list[str]:
+    """Active leaf nodes of a lane (nodes in the lane with no step extending them)."""
+    from arctx.core.cuts import is_active_node
+    from arctx.core.lanes import lane_membership
+
+    membership = lane_membership(handle.run_graph)
+    group = next((g for g in membership.groups if g.lane_id == lane.lane_id), None)
+    if not group:
+        return []
+    leaves = [
+        nid
+        for nid in group.node_ids
+        if is_active_node(handle.run_graph, nid)
+        and not handle.run_graph.steps_from_node(nid)
+    ]
+    return list(dict.fromkeys(leaves))
+
+
+def _attach_lane_summary(handle, *, lane, summary: str, node_ids, user_id: str):
+    """Stamp a lane's terminal with ``summary``. Returns (summary_node, leaves).
+
+    - 1 leaf  → attach the summary to that existing leaf (no extra node).
+    - ≥2 leaves → create one convergence (join) node and summarise that.
+    - 0 leaves → nothing to summarise (returns (None, [])).
+    """
+    from arctx.core.schema.payloads import JoinPayload, SummaryPayload
+
+    leaves = list(dict.fromkeys(node_ids)) if node_ids else _lane_active_leaves(handle, lane)
+    if not leaves:
+        return None, []
+
+    if len(leaves) == 1:
+        target = leaves[0]
+    else:
+        join_payload = JoinPayload(payload_id=handle._next_id("pl"), target_id="")
+        step = handle.add_step(
+            input_node_ids=leaves,
+            payload=join_payload,
+            user_id=user_id,
+            lane_id=lane.lane_id,
+        )
+        target = step.output_node_id
+
+    handle.attach(
+        target,
+        SummaryPayload(payload_id=handle._next_id("pl"), target_id=target, text=summary),
+        user_id=user_id,
+        lane_id=lane.lane_id,
+    )
+    return target, leaves
+
+
+def run_lane_close_command(
     *,
     name_or_id: str,
-    summary: str,
+    summary: str | None,
     node_ids: list[str] | None,
+    reason: str | None,
     run_id: str,
     user_id: str,
     store_dir: str | None,
 ) -> dict:
-    """Join multiple leaf nodes in a lane into a single output node with a summary.
-    
-    If node_ids is not provided, this automatically finds all active leaf nodes 
-    currently belonging to the lane.
-    """
-    from arctx.core.cuts import is_active_node
-    from arctx.core.lanes import lane_membership
-    from arctx.core.schema.payloads import JoinPayload, SummaryPayload
+    """Close a lane: attach the closing ``summary`` to its terminal, then mark it closed.
 
+    ``summary`` is **Markdown** (rendered as such in the web GUI), so put the full
+    closing write-up here. It lands on the lane's single leaf when there is one (no
+    redundant node), or on a fresh convergence node when several leaves must be
+    merged. Once closed, writes to the lane are refused until it is reopened with
+    ``lane open``.
+    """
     store = resolve_store(store_dir)
     if not store.run_path(run_id).exists():
         raise KeyError(f"unknown run_id: {run_id}")
@@ -418,64 +474,60 @@ def run_lane_join_command(
     lane = _find_lane(handle, name_or_id)
     if lane is None:
         raise KeyError(f"unknown lane: {name_or_id!r}")
+    if lane.status == "closed":
+        raise ValueError(
+            f"lane already closed: {name_or_id!r}; "
+            f"reopen it with `arctx lane open {name_or_id}`"
+        )
 
-    # Determine nodes to join
-    if not node_ids:
-        # Collect all leaf nodes currently assigned to this lane
-        membership = lane_membership(handle.run_graph)
-        group = next((g for g in membership.groups if g.lane_id == lane.lane_id), None)
-        if not group:
-            raise ValueError(f"lane has no nodes: {name_or_id!r}")
-        
-        candidates = []
-        for nid in group.node_ids:
-            if not is_active_node(handle.run_graph, nid):
-                continue
-            # Check if this node has no steps extending from it
-            if not handle.run_graph.steps_from_node(nid):
-                candidates.append(nid)
-        
-        node_ids = candidates
-    
-    if not node_ids:
-        raise ValueError(f"no active leaf nodes found in lane {name_or_id!r}")
-    
-    # Deduplicate while preserving order
-    node_ids = list(dict.fromkeys(node_ids))
-    
-    if len(node_ids) < 1:
-        raise ValueError("join requires at least one node")
-
-    # 1. Create Step with JoinPayload
-    join_payload = JoinPayload(
-        payload_id=handle._next_id("pl"),
-        target_id="",
-    )
-    step = handle.add_step(
-        input_node_ids=node_ids,
-        payload=join_payload,
-        user_id=user_id,
-        lane_id=lane.lane_id,
-    )
-    
-    # 2. Attach SummaryPayload to the new output node
-    summary_payload = SummaryPayload(
-        payload_id=handle._next_id("pl"),
-        target_id=step.output_node_id,
-        text=summary,
-    )
-    handle.attach(
-        step.output_node_id,
-        summary_payload,
-        user_id=user_id,
-        lane_id=lane.lane_id,
+    summary_node, leaves = (None, [])
+    if summary:
+        summary_node, leaves = _attach_lane_summary(
+            handle, lane=lane, summary=summary, node_ids=node_ids, user_id=user_id
+        )
+    event = handle.set_lane_status(
+        lane.lane_id, status="closed", user_id=user_id, reason=reason
     )
+    store.save_run(handle)
+    return {
+        "lane_id": lane.lane_id,
+        "name": lane.name,
+        "status": "closed",
+        "summary_node": summary_node,
+        "joined_nodes": leaves,
+        "event_id": event.event_id,
+    }
+
+
+def run_lane_open_command(
+    *,
+    name_or_id: str,
+    reason: str | None,
+    run_id: str,
+    user_id: str,
+    store_dir: str | None,
+) -> dict:
+    """Reopen a closed lane so work can resume. Symmetric to ``lane close``."""
+    store = resolve_store(store_dir)
+    if not store.run_path(run_id).exists():
+        raise KeyError(f"unknown run_id: {run_id}")
+    handle = store.load_run(run_id)
+
+    lane = _find_lane(handle, name_or_id)
+    if lane is None:
+        raise KeyError(f"unknown lane: {name_or_id!r}")
+    if lane.status != "closed":
+        raise ValueError(f"lane is already open: {name_or_id!r}")
 
+    event = handle.set_lane_status(
+        lane.lane_id, status="open", user_id=user_id, reason=reason
+    )
     store.save_run(handle)
     return {
-        "step_id": step.step_id,
-        "output_node_id": step.output_node_id,
-        "joined_nodes": node_ids,
+        "lane_id": lane.lane_id,
+        "name": lane.name,
+        "status": "open",
+        "event_id": event.event_id,
     }
 
 
@@ -533,15 +585,35 @@ def cli_lane(args) -> int:
             print(json.dumps(result, ensure_ascii=False, indent=2))
             return 0
 
-        if command == "join":
+        if command in ("close", "join"):
+            if command == "join":
+                print(
+                    "warning: `arctx lane join` is deprecated; use `arctx lane close` "
+                    "(it closes the lane and attaches the summary to its terminal).",
+                    file=sys.stderr,
+                )
             if len(argv) != 2:
-                raise ValueError("usage: arctx lane join NAME_OR_ID --summary TEXT [--node ID...]")
-            if not args.summary:
-                raise ValueError("--summary is required to join a lane")
-            result = run_lane_join_command(
+                raise ValueError(
+                    "usage: arctx lane close NAME_OR_ID --summary TEXT [--node ID...] [--reason TEXT]"
+                )
+            result = run_lane_close_command(
                 name_or_id=argv[1],
                 summary=args.summary,
                 node_ids=args.node,
+                reason=args.reason,
+                run_id=resolve_run_id_from_args(args),
+                user_id=resolve_user_id_from_args(args),
+                store_dir=args.store_dir,
+            )
+            print(json.dumps(result, ensure_ascii=False, indent=2))
+            return 0
+
+        if command == "open":
+            if len(argv) != 2:
+                raise ValueError("usage: arctx lane open NAME_OR_ID [--reason TEXT]")
+            result = run_lane_open_command(
+                name_or_id=argv[1],
+                reason=args.reason,
                 run_id=resolve_run_id_from_args(args),
                 user_id=resolve_user_id_from_args(args),
                 store_dir=args.store_dir,

{arctx_cli-0.3.1b2 → arctx_cli-0.3.1b3}/src/arctx_cli/ext/git/__init__.py

@@ -14,6 +14,7 @@ from arctx_cli.context import (
     resolve_user_id_from_args,
     resolve_lane_id_from_args,
 )
+from arctx_cli.lane_gate import ensure_lane_open
 
 # ---------------------------------------------------------------------------
 # Parser registration
@@ -60,6 +61,8 @@ def add_parser(subparsers) -> argparse.ArgumentParser:
     sp_add.add_argument("--store-dir", default=None)
     sp_add.add_argument("--user", default=None)
     sp_add.add_argument("--lane", default=None)
+    sp_add.add_argument("--force", action="store_true",
+                        help="Write even if the target lane is closed")
 
     sp_show = git_sub.add_parser("show", help="Show git_change payloads for a Step")
     sp_show.add_argument("--step", required=True, dest="step_id")
@@ -203,6 +206,7 @@ def _cli_git_attach(args) -> int:
     from arctx.ext.git.helpers.attach import attach_commits_to_step
 
     try:
+        ensure_lane_open(handle, lane_id, force=getattr(args, "force", False))
         before = graph_counts(handle)
         result = attach_commits_to_step(
             handle,

arctx_cli-0.3.1b3/src/arctx_cli/lane_gate.py

@@ -0,0 +1,25 @@
+"""Guard that refuses writes to a closed lane.
+
+A lane's lifecycle is open → closed → (reopen) open. "Closed" only means
+something if writes respect it: once a lane is closed, ``add`` / ``attach`` /
+``asset attach`` / ``git add`` and friends refuse to append to it until it is
+explicitly reopened with ``arctx lane open`` (or the caller passes ``--force``).
+"""
+
+from __future__ import annotations
+
+
+def ensure_lane_open(handle, lane_id: str | None, *, force: bool = False) -> None:
+    """Raise if *lane_id* names a closed lane, unless *force* is set.
+
+    No-op when *lane_id* is falsy (no lane context) or unknown — those are the
+    pre-existing default/lane-less write paths and are not this guard's business.
+    """
+    if not lane_id or force:
+        return
+    lane = handle.run_graph.lanes.get(lane_id)
+    if lane is not None and getattr(lane, "status", "open") == "closed":
+        raise ValueError(
+            f"lane is closed: {lane_id}; reopen it with "
+            f"`arctx lane open {lane_id}` (or pass --force to write anyway)"
+        )

arctx_cli-0.3.1b3/tests/cli/test_lane_lifecycle.py

@@ -0,0 +1,155 @@
+"""Tests for the lane open/close lifecycle and the closed-lane write gate."""
+
+from __future__ import annotations
+
+import tempfile
+from pathlib import Path
+
+import pytest
+
+from arctx_cli.commands.add import run_add_step_command
+from arctx_cli.commands.init import run_init_command
+from arctx_cli.commands.lane import (
+    list_lanes,
+    run_lane_close_command,
+    run_lane_create_command,
+    run_lane_open_command,
+)
+from arctx_cli.context import resolve_store
+
+
+def _store_dir(td: str) -> str:
+    return str(Path(td) / "runs")
+
+
+def _init(td: str) -> None:
+    run_init_command(
+        requirement_id="req",
+        target_type="task",
+        target_id="target",
+        run_id="run_lc",
+        store_dir=_store_dir(td),
+    )
+
+
+def _create_lane(sd: str) -> str:
+    res = run_lane_create_command(name="work", run_id="run_lc", user_id="alice", store_dir=sd)
+    return res["lane_id"]
+
+
+def _root(sd: str) -> str:
+    return resolve_store(sd).load_run("run_lc").root_node_id
+
+
+def _add(sd: str, from_node: str, lane_id: str, *, title: str, force: bool = False) -> str:
+    res = run_add_step_command(
+        run_id="run_lc",
+        input_node_ids=[from_node],
+        title=title,
+        payload_kind=None,
+        payload_type="step_payload",
+        field_data={},
+        json_data={},
+        store_dir=sd,
+        user_id="alice",
+        lane_id=lane_id,
+        force=force,
+    )
+    return res["step"]["output_node_id"]
+
+
+def _status(sd: str, lane_id: str) -> str:
+    return next(l["status"] for l in list_lanes(run_id="run_lc", store_dir=sd) if l["lane_id"] == lane_id)
+
+
+def test_close_single_leaf_stamps_existing_leaf_no_extra_node():
+    with tempfile.TemporaryDirectory() as td:
+        sd = _store_dir(td)
+        _init(td)
+        lane_id = _create_lane(sd)
+        leaf = _add(sd, _root(sd), lane_id, title="s1")
+
+        res = run_lane_close_command(
+            name_or_id="work", summary="findings", node_ids=None, reason="done",
+            run_id="run_lc", user_id="alice", store_dir=sd,
+        )
+        # The summary lands on the existing leaf — no convergence node is created.
+        assert res["status"] == "closed"
+        assert res["summary_node"] == leaf
+        assert res["joined_nodes"] == [leaf]
+        assert _status(sd, lane_id) == "closed"
+
+
+def test_status_persists_across_reload():
+    with tempfile.TemporaryDirectory() as td:
+        sd = _store_dir(td)
+        _init(td)
+        lane_id = _create_lane(sd)
+        _add(sd, _root(sd), lane_id, title="s1")
+        run_lane_close_command(
+            name_or_id="work", summary="x", node_ids=None, reason=None,
+            run_id="run_lc", user_id="alice", store_dir=sd,
+        )
+        # Fresh load → status is the projection of the lane_closed event.
+        assert _status(sd, lane_id) == "closed"
+
+
+def test_write_to_closed_lane_is_blocked_then_force_overrides():
+    with tempfile.TemporaryDirectory() as td:
+        sd = _store_dir(td)
+        _init(td)
+        lane_id = _create_lane(sd)
+        leaf = _add(sd, _root(sd), lane_id, title="s1")
+        run_lane_close_command(
+            name_or_id="work", summary="x", node_ids=None, reason=None,
+            run_id="run_lc", user_id="alice", store_dir=sd,
+        )
+        with pytest.raises(ValueError, match="closed"):
+            _add(sd, leaf, lane_id, title="s2")
+        # --force punches through.
+        forced = _add(sd, leaf, lane_id, title="s2", force=True)
+        assert forced
+
+
+def test_open_reopens_and_allows_writes():
+    with tempfile.TemporaryDirectory() as td:
+        sd = _store_dir(td)
+        _init(td)
+        lane_id = _create_lane(sd)
+        leaf = _add(sd, _root(sd), lane_id, title="s1")
+        run_lane_close_command(
+            name_or_id="work", summary="x", node_ids=None, reason=None,
+            run_id="run_lc", user_id="alice", store_dir=sd,
+        )
+        res = run_lane_open_command(
+            name_or_id="work", reason="resume", run_id="run_lc",
+            user_id="alice", store_dir=sd,
+        )
+        assert res["status"] == "open"
+        assert _status(sd, lane_id) == "open"
+        # Writing now succeeds without --force.
+        assert _add(sd, leaf, lane_id, title="s2")
+
+
+def test_open_when_open_and_close_when_closed_error():
+    with tempfile.TemporaryDirectory() as td:
+        sd = _store_dir(td)
+        _init(td)
+        _create_lane(sd)
+        # opening an already-open lane errors
+        with pytest.raises(ValueError, match="already open"):
+            run_lane_open_command(
+                name_or_id="work", reason=None, run_id="run_lc",
+                user_id="alice", store_dir=sd,
+            )
+        # close with no summary is allowed (closing an empty/dead-end lane)
+        run_lane_close_command(
+            name_or_id="work", summary=None, node_ids=None, reason=None,
+            run_id="run_lc", user_id="alice", store_dir=sd,
+        )
+        # closing an already-closed lane errors
+        with pytest.raises(ValueError, match="already closed"):
+            run_lane_close_command(
+                name_or_id="work", summary=None, node_ids=None, reason=None,
+                run_id="run_lc", user_id="alice", store_dir=sd,
+            )