## Summary An on-call agent submits a job, arms a wake and ends its turn saying so; the wake runs a later turn on the session on its own clock. Over ACP that turn's `end_turn` read as "finished" to the caller: a DAG judging its node spent every continuation on "still watching, wake at 13:13" while the job ran fine (ar-r4, 2026-09-08), and the main agent re-dispatched the work by hand. ACP has no stop reason for "waiting". Replaces the closed !573: **no DAG code changes**, no new node status. The node is `running` because a turn is genuinely in flight. - **The signal.** The loop-hooks paper gains one key the ACP layer reads for itself: `acp_meta["raven.holdTurn"]` (`{"untilMs", "why"}`). oncall-flow files it at the send fire when the window's campaign is claimed, not concluded, and has one pending wake -- read the same way the owner's answer pulls that wake forward. No campaign, a wake that stood down, or a concluded campaign files nothing and the turn ends as before. - **The hold** (`raven/acp/methods.py`). A turn that ended `end_turn` with the key filed is not answered. One `tool_call` stands for the wait (its title names the campaign and the next look), with a `tool_call_update` heartbeat every `HOLD_HEARTBEAT_S` (60 s) so a client that clocks liveness by frames sees the agent alive while its model sleeps. The turn slot is reopened with no id to correlate on, so whichever turn ends next on the session -- the wake's, a steer's -- settles it, and the handler decides again from that turn's stash. A wake that arms again keeps the hold; a turn ending with nothing pending answers `end_turn`; a cancel answers `cancelled` as before. The key itself is not passed to the client. - **Steer.** `_raven/session/steer` is served and advertised under `agentCapabilities._meta` as `raven.steer` (the names raven's own client already uses). Accepted while a prompt is open on the session, held or running: the text is shown on the wire as the person's own line, then sent with `turn.send`'s new `busy: "inject"`. Answers `injected` / `no_turn`. - **Wire.** `turn.send` gains the optional `busy` param (`const "inject"`): an ordinary send on an idle lane, `BusyPolicy.INJECT` into the running turn otherwise -- the merge a channel's mid-turn message already gets (`gateway_commands.py`). No slot is bound for an injected message; the running turn keeps the lane's. `openrpc.json` and both generated clients moved together. What raven's client side already does, unchanged: the DAG stall watcher resets on any frame (the heartbeat keeps it quiet, and a stopped heartbeat raises the existing stall notice after ten minutes); a sub-agent process that dies fails the request and the node takes its ordinary path; the pool's `_responsive` treats a prompt in flight as busy. ## Review round 1 (2026-09-09, on !600, superseded by this MR) - **`busy: inject` reads the scheduler's lane state too.** `is_turn_active` knows only the turns `turn.send` started; an armed wake is submitted to the scheduler directly (`make_on_session_wake`) and never binds that map, so a steer during a running wake queued a second turn and answered `injected`. `turn.send` now asks `Scheduler.has_inflight(lane)` as well, and merges (`BusyPolicy.INJECT`) when either record says the lane is running. Pinned: `test_busy_inject_merges_into_a_wake_the_real_scheduler_is_running` -- the reviewer's reproduction on the real `Scheduler`, a turn submitted the way `make_on_session_wake` submits one; with the lane check bypassed it reads `pending=1, inject_mailbox=0`, with it `(1, 0)` in the mailbox and the running turn drains the text. - Branch renamed to snake_case and both commits carry the `Co-authored-by: Claude (<model-id>)` trailer, per AGENTS.md §2–3; that is why this MR replaces !600 rather than continuing it. ## Review round 2 (2026-09-10) - **A wake re-armed during its own run survives the writeback.** `CronService._writeback_locked` reloaded the store after the run and, for a one-shot with `delete_after_run`, overwrote the id with the finished run's state and removed it -- but the turn the wake ran had just called `schedule_wake` under the same key, so the id now named the *next* look. It vanished, and the held prompt had nothing left to settle it. A stored job under the fired id whose `at` schedule the run never had is treated as the new wake it is: claim cleared, run recorded, schedule kept, not deleted. Pinned on the real service: `test_a_wake_re_armed_during_its_own_run_survives_the_writeback` (reads `[]` without the fix, the reviewer's state) and the unchanged one-shot deletion beside it. Cron, proactive, sentinel and on-call suites: 968 passed. ## Review round 3 (2026-09-10) - **An undrained inject stays visible and cancellable.** `busy: inject` dropped the scheduler's handle; when the host turn ended past its last drain, the spine's fallback ran the text as a turn nothing owned -- `turn.cancel` a no-op, no `message.start`. The handle is now kept per lane under an id minted for the text; `turn.cancel` / `session.interrupt` reach it when the active slot is empty (mailbox, queued fallback, or running); and when the fallback turn starts, the RPC sink (`on_turn_start`, wired from bootstrap) binds the lane to it and opens it on the wire with the person's words. `turn.send` answers the inject's own id. Pinned through `build_rpc_spine` with the reviewer's shape (a loop that drains once, an inject after it): `test_an_undrained_inject_runs_as_a_turn_the_surface_can_see_and_cancel` and `test_a_pending_inject_can_be_cancelled_before_it_merges_or_falls_back`; both read the reviewer's state (`turn_ids` empty, cancel finding nothing) with the fix bypassed. - **Line ceiling.** The contract comment is five lines; `raven/contracts` is 2,519 against 2,520, one line of headroom on the current `main` (2,514). - Non-blocking items taken: `SchedulerDrainingError` on the inject path exits as `turn_failed`; the title is announced before the hold; the steer constants sit below the cancel constant's docstring; three edges pinned (a held prompt settled by a wake turn's uncorrelated ending through `send_frame`, the hold key never in the client's `_meta`, `raven.toolName` on the wait row). - Focused suite (reviewer's list plus the touched files): 948 passed on Python 3.12. ## Review round 4 (2026-09-10) - **Every pending inject is kept, per lane and per id.** One replaceable record per lane kept only the newest steer; two steers after the host's last drain fall back in turn, and the first started unowned while a cancel took out the second. The record is now `lane -> {inject id: (handle, text)}` in arrival order: each fallback promotes its own handle, and a cancel with no active turn reaches the oldest pending one -- the one the spine runs next. Pinned: `test_two_undrained_injects_each_get_their_own_turn_promoted_and_cancelled` (both promoted with their own ids and `message.start`, cancelled one after the other; runner saw all three turns). Focused suite: 949 passed. ## Type - [ ] Fix - [x] Feature - [ ] Docs - [ ] CI / tooling - [ ] Refactor - [ ] Other ## Verification ``` uv run pytest tests/test_acp_methods.py tests/test_acp_protocol.py tests/test_rpc_turn_send.py \ tests/test_rpc_schema_match.py tests/test_acp_updates.py tests/test_acp_server.py -q # 766 passed uv run pytest tests/test_agents_oncall_flow_hooks.py tests/test_agents_oncall_flow_actions.py \ tests/test_agents_oncall_flow_budget.py tests/test_agents_oncall_flow_readings.py \ tests/test_agents_oncall_flow_escalation_tools.py -q # 99 passed uv run ruff check raven tests agents && uv run ruff format --check raven tests agents # clean uv run lint-imports # 9 kept, 0 broken cd ui-tui && npm run lint:rpc && npx tsc --noEmit; cd ui-web && npm run gen:check && npx tsc --noEmit # in sync, clean ``` New tests: `TestHeldTurn` (held across an armed wake, held again on a re-arm, heartbeat on the wait call, cancel while held, a non-`end_turn` stop is not held; every frame validated against the ACP schema), `TestSteer` (advertised, `no_turn` when idle, a held prompt takes the words as a turn with `busy: inject`, refusals), `busy: inject` on a busy and an idle lane in `test_rpc_turn_send.py`, and the plugin's hold stamping through the real `CronService` grant (filed with a pending wake; not filed without one, after the wake stands down, or once the campaign concluded). Not done: no end-to-end run of a real on-call wake through a held prompt yet -- unit tests only. - [x] Relevant tests pass locally - [x] Relevant lint / type checks pass locally - [ ] User-facing docs or screenshots are updated when needed (the hold is invisible to a person except as a "waiting for ..." tool row) ## Risk - [x] Backward compatibility considered: a turn that files no `raven.holdTurn` is answered exactly as before; `busy` is optional and absent from every existing caller; the steer method and capability are additive. - [x] Rollback path is clear: revert the two commits. A held prompt holds one `max_concurrent_subagents` slot (default 8) for the wait's duration on the caller's side; raised in config if it bites. ## Related Replaces !573 (closed). Follows !518 (stall notice) and !520 (unprompted-turn route; a wake that runs under a held prompt no longer takes it for DAG nodes).
305 lines
13 KiB
Python
305 lines
13 KiB
Python
"""Repository instructions enter system through the product hook without rewriting the query."""
|
|
|
|
import os
|
|
import sys
|
|
from copy import deepcopy
|
|
from pathlib import Path
|
|
from types import SimpleNamespace
|
|
|
|
import pytest
|
|
|
|
from raven.agent import workdir
|
|
from raven.contracts.loop_hooks import AgentHookContext
|
|
from raven.plugins.context import PluginContext, ServiceLocator
|
|
from raven.providers.binding import ModelBinding, use_binding
|
|
from raven.providers.prompt_cache import STABLE_PREFIX_KEY
|
|
from raven.utils.tokens import estimate_prompt_tokens
|
|
|
|
REPO = Path(__file__).resolve().parent.parent
|
|
PLUGIN_DIR = REPO / "agents" / "raven-code" / "plugins" / "code-flow"
|
|
sys.path.insert(0, str(PLUGIN_DIR))
|
|
|
|
from code_flow.flow import ( # noqa: E402
|
|
PROJECT_FILE_MAX_CHARS,
|
|
PROJECT_FILES,
|
|
PROJECT_INSTRUCTIONS_HEAD,
|
|
CodeFlowHook,
|
|
make_flow_hook,
|
|
project_instructions,
|
|
)
|
|
from code_flow.sessions import SessionLedger # noqa: E402
|
|
|
|
TASK = "fix the failing test in tests/test_units.py"
|
|
|
|
|
|
def _hook(names=PROJECT_FILES) -> CodeFlowHook:
|
|
return CodeFlowHook(SessionLedger(), project_files=list(names))
|
|
|
|
|
|
async def _system(hook: CodeFlowHook, cwd: Path | None, text: str = TASK, key: str = "s1") -> str:
|
|
inbound = AgentHookContext(session_key=key, inbound_content=text)
|
|
ctx = AgentHookContext(
|
|
session_key=key,
|
|
messages=[{"role": "system", "content": ""}, {"role": "user", "content": text}],
|
|
context_window_tokens=8192,
|
|
)
|
|
|
|
async def build():
|
|
assert (await hook.before_user_inbound(inbound)).modified_content is None
|
|
assert inbound.inbound_content == text
|
|
decision = await hook.before_iteration(ctx)
|
|
assert decision.short_circuit_result is None
|
|
assert ctx.messages[-1] == {"role": "user", "content": text}
|
|
return ctx.messages[0]["content"]
|
|
|
|
if cwd is None:
|
|
return await build()
|
|
with workdir.bind(cwd):
|
|
return await build()
|
|
|
|
|
|
def _checkout(tmp_path: Path, **files: str) -> Path:
|
|
root = tmp_path / "checkout"
|
|
root.mkdir()
|
|
for name, text in files.items():
|
|
(root / name).write_text(text, encoding="utf-8")
|
|
return root
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_the_named_files_enter_system_in_the_slices_order(tmp_path):
|
|
root = _checkout(tmp_path, **{"AGENTS.md": "run the tests with make test", "CLAUDE.md": "the build needs node 20"})
|
|
text = await _system(_hook(), root)
|
|
assert text
|
|
assert text.startswith(PROJECT_INSTRUCTIONS_HEAD)
|
|
assert text.index("## AGENTS.md") < text.index("make test") < text.index("## CLAUDE.md") < text.index("node 20")
|
|
assert TASK not in text, "the query is not part of system instructions"
|
|
assert "## CONTEXT.md" not in text, "a missing name leaves no empty heading"
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_nothing_bound_reads_nothing(tmp_path):
|
|
"""Unbound, these names would resolve against the agent's own home."""
|
|
text = await _system(_hook(), None)
|
|
assert text == ""
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_an_empty_list_reads_nothing(tmp_path):
|
|
root = _checkout(tmp_path, **{"AGENTS.md": "run the tests with make test"})
|
|
text = await _system(_hook([]), root)
|
|
assert text == ""
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_a_checkout_without_the_files_passes_the_task_through(tmp_path):
|
|
root = _checkout(tmp_path, **{"README.md": "hello"})
|
|
text = await _system(_hook(), root)
|
|
assert text == ""
|
|
|
|
|
|
def test_a_file_is_capped_and_says_so(tmp_path):
|
|
root = _checkout(tmp_path, **{"AGENTS.md": "x" * (PROJECT_FILE_MAX_CHARS + 5_000)})
|
|
text = project_instructions(root, ["AGENTS.md"])
|
|
assert len(text) < PROJECT_FILE_MAX_CHARS + len(PROJECT_INSTRUCTIONS_HEAD) + 200
|
|
assert "truncated" in text
|
|
|
|
|
|
def test_a_directory_or_a_broken_link_at_the_name_is_skipped(tmp_path):
|
|
root = tmp_path / "checkout"
|
|
(root / "AGENTS.md").mkdir(parents=True)
|
|
os.symlink(str(tmp_path / "nowhere"), str(root / "CLAUDE.md"))
|
|
(root / "CONTEXT.md").write_text("the terms of art", encoding="utf-8")
|
|
text = project_instructions(root, PROJECT_FILES)
|
|
assert "## CONTEXT.md" in text
|
|
assert "## AGENTS.md" not in text
|
|
assert "## CLAUDE.md" not in text
|
|
|
|
|
|
def test_the_files_are_not_fenced_as_untrusted(tmp_path):
|
|
"""A data fence would tell the model to ignore what it is handed to follow."""
|
|
root = _checkout(tmp_path, **{"AGENTS.md": "run the tests with make test"})
|
|
assert "UNTRUSTED" not in project_instructions(root, ["AGENTS.md"])
|
|
|
|
|
|
@pytest.mark.parametrize("escape", ["absolute", "parent", "symlink", "directory_symlink"])
|
|
def test_instruction_paths_cannot_read_outside_the_bound_directory(tmp_path, escape):
|
|
root = _checkout(tmp_path, **{"AGENTS.md": "LOCAL_RULE"})
|
|
outside = tmp_path / "host.md"
|
|
outside.write_text("HOST_FILE_MUST_NOT_REACH_THE_MODEL")
|
|
if escape == "absolute":
|
|
name = str(outside)
|
|
elif escape == "parent":
|
|
name = "../host.md"
|
|
elif escape == "symlink":
|
|
(root / "CLAUDE.md").symlink_to(outside)
|
|
name = "CLAUDE.md"
|
|
else:
|
|
(root / "linked").symlink_to(tmp_path, target_is_directory=True)
|
|
name = "linked/host.md"
|
|
text = project_instructions(root, [name, "AGENTS.md"])
|
|
assert "HOST_FILE_MUST_NOT_REACH_THE_MODEL" not in text
|
|
assert "LOCAL_RULE" in text
|
|
|
|
|
|
def test_contained_aliases_and_a_symlinked_working_directory_are_supported(tmp_path):
|
|
root = _checkout(tmp_path, **{"AGENTS.md": "LOCAL_RULE"})
|
|
(root / "CLAUDE.md").symlink_to("AGENTS.md")
|
|
(root / "nested").mkdir()
|
|
alias = tmp_path / "bound"
|
|
alias.symlink_to(root, target_is_directory=True)
|
|
text = project_instructions(alias, ["nested/../AGENTS.md", "CLAUDE.md", str(root / "AGENTS.md")])
|
|
assert text.count("LOCAL_RULE") == 1
|
|
|
|
|
|
def test_a_symlink_loop_does_not_prevent_reading_other_instruction_files(tmp_path):
|
|
root = _checkout(tmp_path, **{"AGENTS.md": "LOCAL_RULE"})
|
|
(root / "CLAUDE.md").symlink_to("CLAUDE.md")
|
|
assert "LOCAL_RULE" in project_instructions(root, ["CLAUDE.md", "AGENTS.md"])
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_repository_instructions_and_concurrency_enter_system_together(tmp_path):
|
|
root = _checkout(tmp_path, **{"AGENTS.md": "run the tests with make test"})
|
|
ledger = SessionLedger()
|
|
first = CodeFlowHook(ledger, project_files=PROJECT_FILES)
|
|
second = CodeFlowHook(ledger, project_files=PROJECT_FILES)
|
|
await _system(first, root, key="s1")
|
|
text = await _system(second, root, key="s2")
|
|
assert text is not None
|
|
assert text.index(PROJECT_INSTRUCTIONS_HEAD) < text.index("# Workspace concurrency")
|
|
assert TASK not in text
|
|
|
|
|
|
def _ctx(tmp_path: Path, config: dict) -> PluginContext:
|
|
return PluginContext(
|
|
config=config,
|
|
services=ServiceLocator(workspace=tmp_path / "home", user_id="u", agent_id="a"),
|
|
)
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_the_factory_reads_the_names_from_the_slice(tmp_path):
|
|
root = _checkout(tmp_path, **{"AGENTS.md": "run the tests with make test"})
|
|
named = make_flow_hook(_ctx(tmp_path, {"enabled": True, "projectFiles": ["AGENTS.md"]}))
|
|
unnamed = make_flow_hook(_ctx(tmp_path, {"enabled": True}))
|
|
assert "make test" in (await _system(named, root))
|
|
assert (await _system(unnamed, root)) == ""
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_flow_disabled_contributes_no_system_sections(tmp_path):
|
|
root = _checkout(tmp_path, **{"AGENTS.md": "run tests"})
|
|
hook = CodeFlowHook(SessionLedger(), project_files=PROJECT_FILES, flow_enabled=False)
|
|
assert await _system(hook, root) == ""
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
@pytest.mark.parametrize("blocks", [False, True])
|
|
async def test_iteration_hook_preserves_the_host_prefix_and_never_duplicates_its_addition(tmp_path, blocks):
|
|
root = _checkout(tmp_path, **{"AGENTS.md": "REPOSITORY_RULE"})
|
|
base = [{"type": "text", "text": "HOST_PREFIX"}] if blocks else "HOST_PREFIX"
|
|
ctx = AgentHookContext(
|
|
session_key="s1",
|
|
messages=[{"role": "system", "content": base, STABLE_PREFIX_KEY: 4}, {"role": "user", "content": TASK}],
|
|
)
|
|
hook = _hook()
|
|
with workdir.bind(root):
|
|
for _ in range(3):
|
|
assert (await hook.before_iteration(ctx)).short_circuit_result is None
|
|
assert str(ctx.messages[0]["content"]).count("REPOSITORY_RULE") == 1
|
|
assert ctx.messages[0][STABLE_PREFIX_KEY] == 4
|
|
assert ctx.messages[1:] == [{"role": "user", "content": TASK}]
|
|
ctx.messages = deepcopy(ctx.messages)
|
|
ctx.messages[0]["content"] = deepcopy(base)
|
|
assert (await hook.before_iteration(ctx)).short_circuit_result is None
|
|
assert str(ctx.messages[0]["content"]).count("REPOSITORY_RULE") == 1
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_hook_truncates_only_its_addition_and_reserves_tools_and_the_actual_reply_ceiling(tmp_path):
|
|
root = _checkout(tmp_path, **{"AGENTS.md": "repository rule " * 6000})
|
|
provider = SimpleNamespace(generation=SimpleNamespace(max_tokens=512))
|
|
ctx = AgentHookContext(
|
|
session_key="s1",
|
|
messages=[{"role": "system", "content": "HOST_PREFIX"}, {"role": "user", "content": "history " * 400}],
|
|
tools=[{"type": "function", "function": {"name": "test", "description": "tool schema " * 150}}],
|
|
context_window_tokens=100_000,
|
|
)
|
|
original_history = deepcopy(ctx.messages[1:])
|
|
hook = _hook()
|
|
with workdir.bind(root), use_binding(ModelBinding(provider, "test-model", configured_window=2048)):
|
|
decision = await hook.before_iteration(ctx)
|
|
assert decision.short_circuit_result is None
|
|
assert "Repository instructions truncated" in ctx.messages[0]["content"]
|
|
assert ctx.messages[0]["content"].startswith("HOST_PREFIX")
|
|
assert ctx.messages[1:] == original_history
|
|
assert estimate_prompt_tokens(ctx.messages, ctx.tools) + 512 <= 2048
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_hook_reports_when_even_the_instruction_notice_cannot_fit(tmp_path):
|
|
root = _checkout(tmp_path, **{"AGENTS.md": "repository rule"})
|
|
provider = SimpleNamespace(generation=SimpleNamespace(max_tokens=512))
|
|
ctx = AgentHookContext(
|
|
session_key="s1",
|
|
messages=[{"role": "system", "content": "HOST_PREFIX"}, {"role": "user", "content": "history " * 2000}],
|
|
)
|
|
original = deepcopy(ctx.messages)
|
|
with workdir.bind(root), use_binding(ModelBinding(provider, "test-model", configured_window=1024)):
|
|
decision = await _hook().before_iteration(ctx)
|
|
assert "could not fit repository instructions" in decision.short_circuit_result
|
|
assert ctx.messages == original
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_repeated_injection_does_not_remove_matching_text_from_the_host_prefix(tmp_path):
|
|
root = _checkout(tmp_path, **{"AGENTS.md": "REPOSITORY_RULE"})
|
|
base = "HOST_PREFIX\n\n" + project_instructions(root, PROJECT_FILES) + "\nHOST_SUFFIX"
|
|
ctx = AgentHookContext(
|
|
session_key="s1", messages=[{"role": "system", "content": base}, {"role": "user", "content": TASK}]
|
|
)
|
|
hook = _hook()
|
|
with workdir.bind(root):
|
|
for _ in range(2):
|
|
await hook.before_iteration(ctx)
|
|
assert ctx.messages[0]["content"].startswith(base)
|
|
assert ctx.messages[0]["content"].count("REPOSITORY_RULE") == 2
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_pending_checklist_restore_is_counted_before_sizing_repository_instructions(tmp_path):
|
|
from code_flow.tools.todo import TodoStore, normalize_todos
|
|
|
|
root = _checkout(tmp_path, **{"AGENTS.md": "repository rule " * 6000})
|
|
store = TodoStore(tmp_path / "home")
|
|
store.bind("s1", root)
|
|
store.replace(normalize_todos([{"content": "work item " * 200, "status": "pending"}]))
|
|
provider = SimpleNamespace(generation=SimpleNamespace(max_tokens=512))
|
|
ctx = AgentHookContext(
|
|
session_key="s1", messages=[{"role": "system", "content": "HOST_PREFIX"}, {"role": "user", "content": TASK}]
|
|
)
|
|
hook = CodeFlowHook(SessionLedger(), project_files=PROJECT_FILES, todos=store)
|
|
with workdir.bind(root), use_binding(ModelBinding(provider, "test-model", configured_window=2048)):
|
|
decision = await hook.before_iteration(ctx)
|
|
assert decision.short_circuit_result is None
|
|
assert decision.append_note
|
|
assert "truncated" in ctx.messages[0]["content"]
|
|
ctx.messages[-1]["content"] += "\n\n" + decision.append_note
|
|
assert estimate_prompt_tokens(ctx.messages, ctx.tools) + 512 <= 2048
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_a_checklist_binding_failure_does_not_suppress_repository_instructions(tmp_path, monkeypatch):
|
|
from code_flow.tools.todo import TodoStore
|
|
|
|
root = _checkout(tmp_path, **{"AGENTS.md": "REPOSITORY_RULE"})
|
|
store = TodoStore(tmp_path / "home")
|
|
|
|
def fail(*args):
|
|
raise OSError("checklist unavailable")
|
|
|
|
monkeypatch.setattr(store, "bind", fail)
|
|
hook = CodeFlowHook(SessionLedger(), project_files=PROJECT_FILES, todos=store)
|
|
assert "REPOSITORY_RULE" in await _system(hook, root)
|