arctx-cli 0.2.0b3__tar.gz → 0.3.0b1__tar.gz

{arctx_cli-0.2.0b3 → arctx_cli-0.3.0b1}/.gitignore

@@ -5,6 +5,8 @@ __pycache__/
 .pytest_cache/
 .mypy_cache/
 .ruff_cache/
+.uv-cache/
+.venv/
 .coverage
 htmlcov/
 
@@ -27,4 +29,3 @@ dist/
 # IDE / Agent state directories
 .claude/
 .antigravitycli/
-

{arctx_cli-0.2.0b3 → arctx_cli-0.3.0b1}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: arctx-cli
-Version: 0.2.0b3
-Summary: CLI for ARCTX — append-only DAG for reasoning history and parallel agent work
+Version: 0.3.0b1
+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
 Author: Takumi Ishida
@@ -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.2.0b3
+Requires-Dist: arctx>=0.3.0b1
 Provides-Extra: dev
 Requires-Dist: black>=23.0; extra == 'dev'
 Requires-Dist: mypy>=1.0; extra == 'dev'

{arctx_cli-0.2.0b3 → arctx_cli-0.3.0b1}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "hatchling.build"
 
 [project]
 name = "arctx-cli"
-version = "0.2.0b3"
-description = "CLI for ARCTX — append-only DAG for reasoning history and parallel agent work"
+version = "0.3.0b1"
+description = "CLI for ARCTX — append-only DAG editing and refactoring"
 readme = "README.md"
 requires-python = ">=3.10"
 license = {text = "MIT"}
@@ -25,7 +25,7 @@ classifiers = [
     "Topic :: Utilities",
 ]
 dependencies = [
-    "arctx>=0.2.0b3",
+    "arctx>=0.3.0b1",
 ]
 
 [project.optional-dependencies]

{arctx_cli-0.2.0b3 → arctx_cli-0.3.0b1}/src/arctx_cli/append_batch.py

@@ -9,9 +9,8 @@ def graph_counts(handle) -> dict[str, set[str]]:
     """Capture graph record IDs before a mutation."""
     return {
         "nodes": set(handle.run_graph.nodes),
-        "transitions": set(handle.run_graph.transitions),
+        "steps": set(handle.run_graph.steps),
         "payloads": set(handle.run_graph.payloads),
-        "views": {view.view_id for view in handle.run_graph.views.values()},
         "work_events": {event.event_id for event in handle.run_graph.work_events},
     }
 
@@ -52,21 +51,14 @@ def build_append_batch(
         node = handle.run_graph.nodes[node_id]
         records.append(GraphRecordEnvelope("node", node.node_id, node))
 
-    for transition_id in _new_ids(handle.run_graph.transitions, before, "transitions"):
-        transition = handle.run_graph.transitions[transition_id]
-        records.append(GraphRecordEnvelope("transition", transition.transition_id, transition))
+    for step_id in _new_ids(handle.run_graph.steps, before, "steps"):
+        step = handle.run_graph.steps[step_id]
+        records.append(GraphRecordEnvelope("step", step.step_id, step))
 
     for payload_id in _new_ids(handle.run_graph.payloads, before, "payloads"):
         payload = handle.run_graph.payloads[payload_id]
         records.append(GraphRecordEnvelope("payload", payload.payload_id, payload))
 
-    before_view_ids = before.get("views", set())
-    new_views = [
-        view for view in handle.run_graph.views.values() if view.view_id not in before_view_ids
-    ]
-    for view in new_views:
-        records.append(GraphRecordEnvelope("view", view.view_id, view))
-
     new_events = [
         event
         for event in handle.run_graph.work_events

{arctx_cli-0.2.0b3 → arctx_cli-0.3.0b1}/src/arctx_cli/commands/__init__.py

@@ -7,10 +7,12 @@ from arctx.ext import CliCommand
 
 def core_cli_commands() -> list[CliCommand]:
     """Return the built-in, extension-independent CLI commands."""
+    from arctx_cli.commands.add import add_parser as add_add_parser
+    from arctx_cli.commands.add import cli_add
     from arctx_cli.commands.alias_cmd import add_parser as add_alias_parser
     from arctx_cli.commands.alias_cmd import cli_alias
-    from arctx_cli.commands.anchor import add_parser as add_anchor_parser
-    from arctx_cli.commands.anchor import cli_anchor
+    from arctx_cli.commands.attach import add_parser as add_attach_parser
+    from arctx_cli.commands.attach import cli_attach
     from arctx_cli.commands.current import add_parser as add_current_parser
     from arctx_cli.commands.current import cli_current
     from arctx_cli.commands.cut import add_parser as add_cut_parser
@@ -23,60 +25,37 @@ def core_cli_commands() -> list[CliCommand]:
     from arctx_cli.commands.ext import cli_ext
     from arctx_cli.commands.graph import add_parser as add_graph_parser
     from arctx_cli.commands.graph import cli_graph
-    from arctx_cli.commands.guide import add_parser as add_guide_parser
-    from arctx_cli.commands.guide import cli_guide
     from arctx_cli.commands.init import add_parser as add_init_parser
     from arctx_cli.commands.init import cli_init
     from arctx_cli.commands.list import add_parser as add_list_parser
     from arctx_cli.commands.list import cli_list
+    from arctx_cli.commands.log import add_parser as add_log_parser
+    from arctx_cli.commands.log import cli_log
     from arctx_cli.commands.migrate import add_parser as add_migrate_parser
     from arctx_cli.commands.migrate import cli_migrate
-    from arctx_cli.commands.node import add_parser as add_node_parser
-    from arctx_cli.commands.node import cli_node
-    from arctx_cli.commands.outcomes import add_parser as add_outcomes_parser
-    from arctx_cli.commands.outcomes import cli_outcomes
-    from arctx_cli.commands.payload import add_parser as add_payload_parser
-    from arctx_cli.commands.payload import cli_payload
-    from arctx_cli.commands.reachable import add_parser as add_reachable_parser
-    from arctx_cli.commands.reachable import cli_reachable
     from arctx_cli.commands.show import add_parser as add_show_parser
     from arctx_cli.commands.show import cli_show
-    from arctx_cli.commands.sync import add_parser as add_sync_parser
-    from arctx_cli.commands.sync import cli_sync
-    from arctx_cli.commands.trace import add_parser as add_trace_parser
-    from arctx_cli.commands.trace import cli_trace
-    from arctx_cli.commands.transition import add_parser as add_transition_parser
-    from arctx_cli.commands.transition import cli_transition
     from arctx_cli.commands.use import add_parser as add_use_parser
     from arctx_cli.commands.use import cli_use
-    from arctx_cli.commands.view import add_parser as add_view_parser
-    from arctx_cli.commands.view import cli_view
     from arctx_cli.commands.work_session import add_parser as add_work_session_parser
     from arctx_cli.commands.work_session import cli_work_session
 
     return [
+        CliCommand("add", add_add_parser, cli_add),
         CliCommand("alias", add_alias_parser, cli_alias),
-        CliCommand("anchor", add_anchor_parser, cli_anchor),
+        CliCommand("attach", add_attach_parser, cli_attach),
         CliCommand("current", add_current_parser, cli_current),
         CliCommand("ext", add_ext_parser, cli_ext),
         CliCommand("dump", add_dump_parser, cli_dump),
         CliCommand("export", add_export_parser, cli_export),
         CliCommand("graph", add_graph_parser, cli_graph),
-        CliCommand("guide", add_guide_parser, cli_guide),
         CliCommand("init", add_init_parser, cli_init),
         CliCommand("list", add_list_parser, cli_list),
+        CliCommand("log", add_log_parser, cli_log),
         CliCommand("migrate", add_migrate_parser, cli_migrate),
-        CliCommand("node", add_node_parser, cli_node),
-        CliCommand("outcomes", add_outcomes_parser, cli_outcomes),
-        CliCommand("payload", add_payload_parser, cli_payload),
-        CliCommand("reachable", add_reachable_parser, cli_reachable),
         CliCommand("cut", add_cut_parser, cli_cut),
         CliCommand("show", add_show_parser, cli_show),
-        CliCommand("sync", add_sync_parser, cli_sync),
-        CliCommand("trace", add_trace_parser, cli_trace),
-        CliCommand("transition", add_transition_parser, cli_transition),
         CliCommand("use", add_use_parser, cli_use),
-        CliCommand("view", add_view_parser, cli_view),
         CliCommand("work-session", add_work_session_parser, cli_work_session),
     ]
 

arctx_cli-0.3.0b1/src/arctx_cli/commands/_targets.py

@@ -0,0 +1,38 @@
+"""Helpers for resolving user-facing DAG record IDs."""
+
+from __future__ import annotations
+
+from typing import Literal
+
+
+TargetKind = Literal["node", "step", "payload"]
+
+
+def resolve_target_kind(handle, record_id: str) -> TargetKind:
+    """Resolve a record id to its internal target kind."""
+    graph = handle.run_graph
+    matches: list[TargetKind] = []
+    if record_id in graph.nodes:
+        matches.append("node")
+    if record_id in graph.steps:
+        matches.append("step")
+    if record_id in graph.payloads:
+        matches.append("payload")
+    if not matches:
+        raise KeyError(f"unknown record_id: {record_id}")
+    if len(matches) > 1:
+        raise ValueError(f"ambiguous record_id {record_id!r}: {matches}")
+    return matches[0]
+
+
+def step_view(step) -> dict:
+    """Return a user-facing Step view for an internal Step."""
+    return {
+        "kind": "step",
+        "id": step.step_id,
+        "step_id": step.step_id,
+        "step_id": step.step_id,
+        "input_node_ids": list(step.input_node_ids),
+        "output_node_id": step.output_node_id,
+        "metadata": dict(step.metadata),
+    }

arctx_cli-0.3.0b1/src/arctx_cli/commands/add.py

@@ -0,0 +1,203 @@
+"""User-facing arctx add commands."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+
+from arctx_cli.append_batch import graph_counts, maybe_append_or_save
+from arctx_cli.commands._targets import step_view
+from arctx_cli.context import (
+    resolve_run_id_from_args,
+    resolve_store,
+    resolve_user_id_from_args,
+    resolve_work_session_id_from_args,
+)
+from arctx_cli.payload_builder import build_payload, parse_field_args, parse_json_object
+
+
+def add_parser(subparsers) -> argparse.ArgumentParser:
+    parser = subparsers.add_parser("add", help="Add DAG nodes or steps")
+    add_sub = parser.add_subparsers(dest="add_command", required=True)
+
+    sp_node = add_sub.add_parser("node", help="Add a standalone Node")
+    sp_node.add_argument("--title", default=None)
+    sp_node.add_argument("--type", dest="payload_kind", default=None)
+    sp_node.add_argument("--payload-type", default="node_payload")
+    sp_node.add_argument("--field", action="append", default=None, help="Payload field as key=value")
+    sp_node.add_argument("--json", default=None, help="Payload fields as a JSON object")
+    sp_node.add_argument("--run", default=None)
+    sp_node.add_argument("--store-dir", default=None)
+    sp_node.add_argument("--user", default=None)
+    sp_node.add_argument("--work-session", default=None)
+
+    sp_step = add_sub.add_parser("step", help="Add a Step from input Nodes")
+    sp_step.add_argument(
+        "--from",
+        action="append",
+        required=True,
+        dest="input_nodes",
+        metavar="NODE_ID",
+        help="Input node (repeatable for multi-input steps)",
+    )
+    sp_step.add_argument("--title", default=None)
+    sp_step.add_argument("--type", dest="payload_kind", default=None)
+    sp_step.add_argument("--payload-type", default="step_payload")
+    sp_step.add_argument("--field", action="append", default=None, help="Payload field as key=value")
+    sp_step.add_argument("--json", default=None, help="Payload fields as a JSON object")
+    sp_step.add_argument("--run", default=None)
+    sp_step.add_argument("--store-dir", default=None)
+    sp_step.add_argument("--user", default=None)
+    sp_step.add_argument("--work-session", default=None)
+
+    return parser
+
+
+def run_add_node_command(
+    *,
+    run_id: str,
+    title: str | None,
+    payload_kind: str | None,
+    payload_type: str,
+    field_data: dict,
+    json_data: dict,
+    store_dir: str,
+    user_id: str | None = None,
+    work_session_id: str | None = None,
+) -> 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)
+    before = graph_counts(handle)
+    node = handle.add_node(user_id=user_id, work_session_id=work_session_id)
+
+    data = dict(json_data or {})
+    data.update(field_data or {})
+    if title is not None:
+        data.setdefault("title", title)
+        data.setdefault("text", title)
+    if payload_kind is not None:
+        data.setdefault("type", payload_kind)
+    elif data:
+        data.setdefault("type", "node")
+
+    payload = None
+    if data:
+        payload = build_payload(
+            payload_type=payload_type,
+            target_kind="node",
+            target_id=node.node_id,
+            payload_id=handle._next_id("pl"),
+            json_data={},
+            field_data=data,
+        )
+        attached = handle.attach(
+            node.node_id,
+            payload,
+            user_id=user_id,
+            work_session_id=work_session_id,
+        )
+        payload = attached
+
+    maybe_append_or_save(
+        store=store,
+        handle=handle,
+        user_id=user_id,
+        work_session_id=work_session_id,
+        before=before,
+    )
+    result = {"node": node.to_dict()}
+    if payload is not None:
+        result["payload"] = payload.to_dict()
+    return result
+
+
+def run_add_step_command(
+    *,
+    run_id: str,
+    input_node_ids: list[str],
+    title: str | None,
+    payload_kind: str | None,
+    payload_type: str,
+    field_data: dict,
+    json_data: dict,
+    store_dir: str,
+    user_id: str | None = None,
+    work_session_id: str | None = None,
+) -> 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)
+    data = dict(json_data or {})
+    data.update(field_data or {})
+    if title is not None:
+        data.setdefault("title", title)
+        data.setdefault("text", title)
+    if payload_kind is not None:
+        data.setdefault("type", payload_kind)
+    else:
+        data.setdefault("type", "step")
+
+    payload = build_payload(
+        payload_type=payload_type,
+        target_kind="step",
+        target_id="pending",
+        payload_id="pending",
+        json_data={},
+        field_data=data,
+    )
+    before = graph_counts(handle)
+    step = handle.add_step(
+        input_node_ids,
+        payload,
+        user_id=user_id,
+        work_session_id=work_session_id,
+    )
+    maybe_append_or_save(
+        store=store,
+        handle=handle,
+        user_id=user_id,
+        work_session_id=work_session_id,
+        before=before,
+    )
+    return {"step": step_view(step)}
+
+
+def cli_add(args) -> int:
+    try:
+        if args.add_command == "node":
+            result = run_add_node_command(
+                run_id=resolve_run_id_from_args(args),
+                title=args.title,
+                payload_kind=args.payload_kind,
+                payload_type=args.payload_type,
+                field_data=parse_field_args(args.field),
+                json_data=parse_json_object(args.json),
+                store_dir=args.store_dir,
+                user_id=resolve_user_id_from_args(args),
+                work_session_id=resolve_work_session_id_from_args(args),
+            )
+            print(json.dumps(result, ensure_ascii=False, indent=2))
+            return 0
+        if args.add_command == "step":
+            result = run_add_step_command(
+                run_id=resolve_run_id_from_args(args),
+                input_node_ids=args.input_nodes,
+                title=args.title,
+                payload_kind=args.payload_kind,
+                payload_type=args.payload_type,
+                field_data=parse_field_args(args.field),
+                json_data=parse_json_object(args.json),
+                store_dir=args.store_dir,
+                user_id=resolve_user_id_from_args(args),
+                work_session_id=resolve_work_session_id_from_args(args),
+            )
+            print(json.dumps(result["step"], ensure_ascii=False, indent=2))
+            return 0
+    except (KeyError, ValueError, json.JSONDecodeError) as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 1
+    return 1

arctx_cli-0.3.0b1/src/arctx_cli/commands/attach.py

@@ -0,0 +1,91 @@
+"""User-facing arctx attach command."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+
+from arctx_cli.commands._targets import resolve_target_kind
+from arctx_cli.commands.payload import run_payload_add_command
+from arctx_cli.context import (
+    resolve_run_id_from_args,
+    resolve_store,
+    resolve_user_id_from_args,
+    resolve_work_session_id_from_args,
+)
+from arctx_cli.payload_builder import parse_field_args, parse_json_object
+
+
+def add_parser(subparsers) -> argparse.ArgumentParser:
+    parser = subparsers.add_parser("attach", help="Attach a Payload to a Node or Step")
+    parser.add_argument("target_id")
+    parser.add_argument("--type", dest="payload_kind", default="payload")
+    parser.add_argument("--payload-type", default=None)
+    parser.add_argument("--field", action="append", default=None, help="Payload field as key=value")
+    parser.add_argument("--json", default=None, help="Payload fields as a JSON object")
+    parser.add_argument("--run", default=None)
+    parser.add_argument("--store-dir", default=None)
+    parser.add_argument("--user", default=None)
+    parser.add_argument("--work-session", default=None)
+    return parser
+
+
+def run_attach_command(
+    *,
+    run_id: str,
+    target_id: str,
+    payload_kind: str,
+    payload_type: str | None,
+    field_data: dict,
+    json_data: dict,
+    store_dir: str,
+    user_id: str | None = None,
+    work_session_id: str | None = None,
+) -> 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)
+    target_kind = resolve_target_kind(handle, target_id)
+    if target_kind == "payload":
+        raise ValueError("cannot attach a payload to another payload")
+
+    data = dict(json_data or {})
+    data.update(field_data or {})
+    data.setdefault("type", payload_kind)
+    internal_payload_type = payload_type or (
+        "node_payload" if target_kind == "node" else "step_payload"
+    )
+    result = run_payload_add_command(
+        run_id=run_id,
+        target_kind=target_kind,
+        target_id=target_id,
+        payload_type=internal_payload_type,
+        field_data=data,
+        json_data={},
+        store_dir=store_dir,
+        user_id=user_id,
+        work_session_id=work_session_id,
+    )
+    return result
+
+
+def cli_attach(args) -> int:
+    try:
+        result = run_attach_command(
+            run_id=resolve_run_id_from_args(args),
+            target_id=args.target_id,
+            payload_kind=args.payload_kind,
+            payload_type=args.payload_type,
+            field_data=parse_field_args(args.field),
+            json_data=parse_json_object(args.json),
+            store_dir=args.store_dir,
+            user_id=resolve_user_id_from_args(args),
+            work_session_id=resolve_work_session_id_from_args(args),
+        )
+        print(json.dumps(result["payload"], ensure_ascii=False, indent=2))
+        return 0
+    except (KeyError, ValueError, json.JSONDecodeError) as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 1

{arctx_cli-0.2.0b3 → arctx_cli-0.3.0b1}/src/arctx_cli/commands/cut.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import argparse
 import json
 
+from arctx_cli.commands._targets import resolve_target_kind
 from arctx_cli.context import (
     resolve_run_id_from_args,
     resolve_store,
@@ -15,12 +16,12 @@ from arctx_cli.append_batch import graph_counts, maybe_append_or_save
 
 
 def add_parser(subparsers) -> argparse.ArgumentParser:
-    parser = subparsers.add_parser("cut", help="Cut a Node or Transition")
-    parser.add_argument("kind", nargs="?", choices=["node", "transition"])
+    parser = subparsers.add_parser("cut", help="Cut a Node or Step")
+    parser.add_argument("kind", nargs="?")
     parser.add_argument("id", nargs="?")
     group = parser.add_mutually_exclusive_group(required=False)
     group.add_argument("--node", dest="node_id", metavar="NODE_ID")
-    group.add_argument("--transition", dest="transition_id", metavar="TRANSITION_ID")
+    group.add_argument("--step", dest="step_id", metavar="STEP_ID")
     parser.add_argument("--run", default=None)
     parser.add_argument("--reason", default=None)
     parser.add_argument("--store-dir", default=None)
@@ -62,22 +63,34 @@ def run_cut_command(
 
 
 def cli_cut(args) -> int:
-    if args.kind is not None:
-        if args.id is None:
-            raise ValueError("cut requires an id when using positional target")
-        target_id = args.id
-        target_kind = args.kind
-    elif args.node_id is not None:
+    run_id = resolve_run_id_from_args(args)
+    store_dir = args.store_dir
+    if args.node_id is not None:
         target_id = args.node_id
         target_kind = "node"
-    elif args.transition_id is not None:
-        target_id = args.transition_id
-        target_kind = "transition"
+    elif args.step_id is not None:
+        target_id = args.step_id
+        target_kind = "step"
+    elif args.kind is not None and args.id is not None:
+        if args.kind not in ("node", "step", "step"):
+            raise ValueError("cut target kind must be node, step, or step")
+        target_id = args.id
+        target_kind = "step" if args.kind == "step" else args.kind
+    elif args.kind is not None:
+        target_id = args.kind
+        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)
+        resolved = resolve_target_kind(handle, target_id)
+        if resolved == "payload":
+            raise ValueError("cannot cut a payload")
+        target_kind = resolved
     else:
-        raise ValueError("provide 'node <id>', 'transition <id>', --node, or --transition")
+        raise ValueError("provide '<id>', 'node <id>', 'step <id>', --node, or --step")
 
     result = run_cut_command(
-        run_id=resolve_run_id_from_args(args),
+        run_id=run_id,
         target_id=target_id,
         target_kind=target_kind,
         reason=args.reason,

{arctx_cli-0.2.0b3 → arctx_cli-0.3.0b1}/src/arctx_cli/commands/dump.py

@@ -25,9 +25,9 @@ def add_parser(subparsers) -> argparse.ArgumentParser:
     parser.add_argument("--depth", type=int, default=None,
                         help="Limit traversal depth")
     parser.add_argument("--observed-only", action="store_true",
-                        help="Hide predicted output transitions")
+                        help="Hide predicted output steps")
     parser.add_argument("--predicted-only", action="store_true",
-                        help="Hide observed (result) output transitions")
+                        help="Hide observed (result) output steps")
     parser.add_argument("--full-payloads", action="store_true",
                         help="Include full payload metrics / rationale")
     parser.add_argument("--run", default=None)

{arctx_cli-0.2.0b3 → arctx_cli-0.3.0b1}/src/arctx_cli/commands/export.py

@@ -32,7 +32,7 @@ def add_parser(subparsers) -> argparse.ArgumentParser:
     parser.add_argument("--full-payloads", action="store_true",
                         help="Include full payload content")
     parser.add_argument("--exclude-cut", action="store_true",
-                        help="Drop cut (inactive) nodes and transitions")
+                        help="Drop cut (inactive) nodes and steps")
     parser.add_argument("--include-local", action="store_true",
                         help="Keep repo local_path in the output (off by default)")
     parser.add_argument("--output", "-o", default=None,

{arctx_cli-0.2.0b3 → arctx_cli-0.3.0b1}/src/arctx_cli/commands/init.py

@@ -135,8 +135,9 @@ def run_init_command(
         repo_root = find_repo_root()
         write_arctx_id(repo_root, handle.run_id)
         written_arctx_id_path = str(arctx_id_path(repo_root))
-    except RuntimeError:
-        # Not inside a git repo — skip pointer creation silently.
+    except (OSError, RuntimeError):
+        # Not inside a git repo, or the gitdir is read-only in the current
+        # sandbox. The run itself is still valid without an active pointer.
         pass
 
     installed_hook_path: str | None = None