@yahyahammad/venastine 0.3.18 → 0.3.19
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +27 -4
- package/core/commands.py +3 -2
- package/core/loop.py +66 -10
- package/core/reasoning/events.py +6 -0
- package/core/reasoning/json_retry.py +12 -1
- package/core/reasoning/orchestrator.py +562 -270
- package/core/reasoning/pipeline_storage.py +86 -5
- package/core/reasoning/resume.py +557 -0
- package/core/reasoning/source_corpus.py +25 -10
- package/main.py +108 -6
- package/package.json +1 -1
- package/pyproject.toml +1 -1
- package/storage.py +13 -0
- package/tui/app.py +114 -8
- package/tui/app.tcss +5 -1
- package/tui/screens.py +61 -0
package/main.py
CHANGED
|
@@ -71,6 +71,11 @@ from security import posture, protected_paths
|
|
|
71
71
|
|
|
72
72
|
logger = logging.getLogger(__name__)
|
|
73
73
|
|
|
74
|
+
#: ROADMAP_v3 §98. What a bare `--resume` parses to: list the runs that can be
|
|
75
|
+
#: resumed rather than resume one. A sentinel, not a string, so no run id can
|
|
76
|
+
#: collide with it -- GRANT_PICKER's shape, one flag over.
|
|
77
|
+
RESUME_LIST = object()
|
|
78
|
+
|
|
74
79
|
|
|
75
80
|
class _Visible:
|
|
76
81
|
"""Every untrusted string one prompt prints, and whether any of them
|
|
@@ -2168,6 +2173,39 @@ def run_memory_command(args) -> int:
|
|
|
2168
2173
|
return 0
|
|
2169
2174
|
|
|
2170
2175
|
|
|
2176
|
+
def run_resume_list() -> int:
|
|
2177
|
+
"""A bare `--resume` (ROADMAP_v3 §98): the runs that can be resumed,
|
|
2178
|
+
newest first, and how to resume one. The CLI's picker, since a line
|
|
2179
|
+
shell has nothing to pick with. The first eight characters of an id
|
|
2180
|
+
are shown because they are what `--resume` needs."""
|
|
2181
|
+
from core.reasoning.resume import resumable_runs
|
|
2182
|
+
for line in resume_list_lines(resumable_runs()):
|
|
2183
|
+
print(line)
|
|
2184
|
+
return 0
|
|
2185
|
+
|
|
2186
|
+
|
|
2187
|
+
def resume_list_lines(runs) -> list:
|
|
2188
|
+
"""The listing `run_resume_list` prints, as lines a test can read."""
|
|
2189
|
+
if not runs:
|
|
2190
|
+
return ["No failed or abandoned research run to resume."]
|
|
2191
|
+
lines = ["Research runs that can be resumed, newest first:"]
|
|
2192
|
+
for row in runs:
|
|
2193
|
+
status = ("stopped, or still running elsewhere"
|
|
2194
|
+
if row["status"] == "running" else row["status"])
|
|
2195
|
+
started = row["started_at"]
|
|
2196
|
+
when = (started.strftime("%Y-%m-%d %H:%M")
|
|
2197
|
+
if hasattr(started, "strftime") else str(started or ""))
|
|
2198
|
+
where = (f"cannot resume: {row['note']}" if row.get("note")
|
|
2199
|
+
else f"resumes {row['stage']}")
|
|
2200
|
+
query = ansi.for_display(str(row["user_query"]))
|
|
2201
|
+
if len(query) > 60:
|
|
2202
|
+
query = query[:59] + "…"
|
|
2203
|
+
lines.append(f" {str(row['id'])[:8]} {when} {status} {where}")
|
|
2204
|
+
lines.append(f" {query}")
|
|
2205
|
+
lines.append("Resume one with: venastine --resume <id>")
|
|
2206
|
+
return lines
|
|
2207
|
+
|
|
2208
|
+
|
|
2171
2209
|
def run_summary_command(args, provider_name: str, model: str) -> int:
|
|
2172
2210
|
"""`--summary [thread]`, ROADMAP_v2 §21c (M21).
|
|
2173
2211
|
|
|
@@ -2392,6 +2430,7 @@ def run_research(
|
|
|
2392
2430
|
review=None,
|
|
2393
2431
|
subagent_review=None,
|
|
2394
2432
|
effort: str | None = None,
|
|
2433
|
+
resume=None,
|
|
2395
2434
|
) -> None:
|
|
2396
2435
|
"""Run the full deep-research pipeline, write artifacts to disk,
|
|
2397
2436
|
and print the results. ensemble_mode/ensemble_n come from
|
|
@@ -2411,11 +2450,27 @@ def run_research(
|
|
|
2411
2450
|
§22: the pipeline is ITERATED, not called, so a run that takes many
|
|
2412
2451
|
minutes says what it is doing while it does it. The CLI is where that
|
|
2413
2452
|
matters most -- it is the shell an unattended run is usually launched
|
|
2414
|
-
from, and it had nothing at all to show until the run ended.
|
|
2453
|
+
from, and it had nothing at all to show until the run ended.
|
|
2454
|
+
|
|
2455
|
+
resume (ROADMAP_v3 §98) is a run id, or the start of one, to pick up
|
|
2456
|
+
instead of starting `query`. A run that fails, this time or that one,
|
|
2457
|
+
ends with the command that resumes it, because the id is otherwise
|
|
2458
|
+
printed only by a run that completed."""
|
|
2415
2459
|
from core.reasoning.orchestrator import stream_deep_research_pipeline
|
|
2416
2460
|
from core.reasoning.output_writer import write_run_artifacts
|
|
2461
|
+
from core.reasoning.resume import ResumeRefused, find_run
|
|
2417
2462
|
|
|
2418
|
-
|
|
2463
|
+
run_id = None
|
|
2464
|
+
if resume is not None:
|
|
2465
|
+
try:
|
|
2466
|
+
run_id = find_run(resume)
|
|
2467
|
+
except ResumeRefused as e:
|
|
2468
|
+
print(f"Cannot resume {ansi.for_display(resume)}: "
|
|
2469
|
+
f"{ansi.for_display(e)}.")
|
|
2470
|
+
raise SystemExit(1) from None
|
|
2471
|
+
print(f"Resuming research run {run_id}")
|
|
2472
|
+
else:
|
|
2473
|
+
print(f"Running deep-research pipeline on: {query!r}")
|
|
2419
2474
|
print(f"Provider: {provider_name} | Model: {model} | "
|
|
2420
2475
|
f"Effort: {effort or 'auto'}\n")
|
|
2421
2476
|
|
|
@@ -2426,6 +2481,7 @@ def run_research(
|
|
|
2426
2481
|
ensemble_mode=ensemble_mode, ensemble_n=ensemble_n,
|
|
2427
2482
|
authorization=authorization, review=review,
|
|
2428
2483
|
subagent_review=subagent_review, effort=effort,
|
|
2484
|
+
resume=run_id,
|
|
2429
2485
|
):
|
|
2430
2486
|
# §26: tool calls and code stages print here too. The CLI is
|
|
2431
2487
|
# the shell an unattended run is launched from, so a
|
|
@@ -2473,6 +2529,10 @@ def run_research(
|
|
|
2473
2529
|
print(f" .. {event.chars // 1000}k chars", flush=True)
|
|
2474
2530
|
elif event.kind == "trace_line":
|
|
2475
2531
|
print(f"- {ansi.for_display(event.text)}", flush=True)
|
|
2532
|
+
elif event.kind == "run_started":
|
|
2533
|
+
# §98. Kept, not printed: the id is what the failure line
|
|
2534
|
+
# below needs, and a completed run prints it at the end.
|
|
2535
|
+
run_id = event.text
|
|
2476
2536
|
elif event.kind == "run_complete":
|
|
2477
2537
|
run = event.run
|
|
2478
2538
|
if run is None:
|
|
@@ -2482,11 +2542,20 @@ def run_research(
|
|
|
2482
2542
|
raise RuntimeError(
|
|
2483
2543
|
"Pipeline generator completed without yielding a "
|
|
2484
2544
|
"run_complete event")
|
|
2545
|
+
except ResumeRefused as e:
|
|
2546
|
+
# §98. Refused before anything changed, so this is not a pipeline
|
|
2547
|
+
# failure and the run keeps the status it had.
|
|
2548
|
+
print(f"\nCannot resume run {run_id}: {ansi.for_display(e)}.")
|
|
2549
|
+
raise SystemExit(1) from None
|
|
2485
2550
|
except Exception as e:
|
|
2486
2551
|
logger.exception("Research pipeline failed")
|
|
2487
2552
|
print(f"\nPipeline failed: {ansi.for_display(e)}")
|
|
2488
|
-
|
|
2489
|
-
|
|
2553
|
+
if run_id:
|
|
2554
|
+
print(f"Completed passes are kept. Resume the run where it "
|
|
2555
|
+
f"stopped with: venastine --resume {run_id}")
|
|
2556
|
+
else:
|
|
2557
|
+
print("If any partial results were persisted, they can be "
|
|
2558
|
+
"inspected via the database.")
|
|
2490
2559
|
raise SystemExit(1)
|
|
2491
2560
|
|
|
2492
2561
|
output_dir = None
|
|
@@ -2661,6 +2730,21 @@ def build_parser() -> argparse.ArgumentParser:
|
|
|
2661
2730
|
help="Research mode: skip the post-pipeline review even if "
|
|
2662
2731
|
"settings.json or config.yaml turns it on.",
|
|
2663
2732
|
)
|
|
2733
|
+
# ROADMAP_v3 §98. An optional value, which is safe here where --grant
|
|
2734
|
+
# was not: a resumed run takes no query, so there is no next token for
|
|
2735
|
+
# it to swallow by mistake. Bare, it lists the runs it could take.
|
|
2736
|
+
parser.add_argument(
|
|
2737
|
+
"--resume",
|
|
2738
|
+
nargs="?",
|
|
2739
|
+
const=RESUME_LIST,
|
|
2740
|
+
default=None,
|
|
2741
|
+
metavar="RUN_ID",
|
|
2742
|
+
help="Research mode: pick a failed or abandoned run up where it "
|
|
2743
|
+
"stopped -- completed passes are not run again. Give the run "
|
|
2744
|
+
"id (its first eight characters are enough); with no id, list "
|
|
2745
|
+
"the runs that can be resumed. Implies --mode research and "
|
|
2746
|
+
"takes the usual --grant/--attended/--review flags.",
|
|
2747
|
+
)
|
|
2664
2748
|
parser.add_argument(
|
|
2665
2749
|
"--tui",
|
|
2666
2750
|
action="store_true",
|
|
@@ -3409,6 +3493,21 @@ def main(argv=None) -> int:
|
|
|
3409
3493
|
if args.summary is not None:
|
|
3410
3494
|
return run_summary_command(args, provider, model)
|
|
3411
3495
|
|
|
3496
|
+
# ROADMAP_v3 §98. --resume names a research run, so it implies the mode
|
|
3497
|
+
# rather than requiring it to be typed too. Checked here, ahead of the
|
|
3498
|
+
# validation below that wants a query for --mode research, because a
|
|
3499
|
+
# resumed run keeps its own query and must not be given another.
|
|
3500
|
+
if args.resume is not None:
|
|
3501
|
+
if args.tui:
|
|
3502
|
+
parser.error("--tui does not take --resume; use /research "
|
|
3503
|
+
"--resume inside the TUI.")
|
|
3504
|
+
if args.query:
|
|
3505
|
+
parser.error("--resume takes no query: a resumed run keeps the "
|
|
3506
|
+
"query it was started with.")
|
|
3507
|
+
args.mode = "research"
|
|
3508
|
+
if args.resume is RESUME_LIST:
|
|
3509
|
+
return run_resume_list()
|
|
3510
|
+
|
|
3412
3511
|
# §24. Beside the others, and AFTER load_project_config for a reason the
|
|
3413
3512
|
# rest do not share: the generator resolves its destination through
|
|
3414
3513
|
# config_loader.get_project_path(), and reads the trust state that
|
|
@@ -3432,8 +3531,10 @@ def main(argv=None) -> int:
|
|
|
3432
3531
|
# §16 ships the chat shell; research mode's coarse progress view
|
|
3433
3532
|
# is driven from inside the TUI, not from a launch flag.
|
|
3434
3533
|
parser.error("--tui does not take --mode research; use /research inside the TUI.")
|
|
3435
|
-
if args.mode == "research" and not args.tui and not args.query
|
|
3436
|
-
|
|
3534
|
+
if (args.mode == "research" and not args.tui and not args.query
|
|
3535
|
+
and args.resume is None):
|
|
3536
|
+
parser.error("--mode research requires a positional query argument "
|
|
3537
|
+
"(or --resume, to pick up a run that stopped).")
|
|
3437
3538
|
if args.tui and args.query:
|
|
3438
3539
|
# The parser help says a positional query is "sent as the first
|
|
3439
3540
|
# message", and tui.app.run() has no first-message parameter --
|
|
@@ -3574,6 +3675,7 @@ def main(argv=None) -> int:
|
|
|
3574
3675
|
subagent_review=review_on,
|
|
3575
3676
|
review=build_review_consent() if review_on else None,
|
|
3576
3677
|
effort=effort,
|
|
3678
|
+
resume=args.resume,
|
|
3577
3679
|
)
|
|
3578
3680
|
else:
|
|
3579
3681
|
thread_id = args.thread
|
package/package.json
CHANGED
package/pyproject.toml
CHANGED
|
@@ -18,7 +18,7 @@ build-backend = "setuptools.build_meta"
|
|
|
18
18
|
|
|
19
19
|
[project]
|
|
20
20
|
name = "venastine-research-harness"
|
|
21
|
-
version = "0.3.
|
|
21
|
+
version = "0.3.19"
|
|
22
22
|
description = "A from-scratch agentic harness: tool-using chat plus a ten-pass self-critiquing research pipeline."
|
|
23
23
|
readme = "README.md"
|
|
24
24
|
# The same words as package.json's `keywords`, in the same order: what a
|
package/storage.py
CHANGED
|
@@ -825,11 +825,24 @@ def _ordered_rows(thread_id: UUID) -> list[dict]:
|
|
|
825
825
|
# ROADMAP_v3 §81 (IM2). NULL for every row that attached no
|
|
826
826
|
# image; the compactor's size proxy reads it (IM8).
|
|
827
827
|
"images": m.images,
|
|
828
|
+
# ROADMAP_v3 §98 (RS6): when a tool result arrived, which a
|
|
829
|
+
# resumed run's rebuilt corpus keeps as the page's
|
|
830
|
+
# retrieved_at. The ordering above already reads it.
|
|
831
|
+
"created_at": m.created_at,
|
|
828
832
|
}
|
|
829
833
|
for m in session.exec(statement).all()
|
|
830
834
|
]
|
|
831
835
|
|
|
832
836
|
|
|
837
|
+
def tool_result_times(thread_id: UUID) -> dict:
|
|
838
|
+
"""When each tool result in a thread was written, by tool_call_id
|
|
839
|
+
(ROADMAP_v3 §98, RS6). Over `_ordered_rows`, so the suite's fake
|
|
840
|
+
storage answers it through the one read it already mirrors."""
|
|
841
|
+
return {row["tool_call_id"]: row.get("created_at")
|
|
842
|
+
for row in _ordered_rows(thread_id)
|
|
843
|
+
if row["role"] == "tool" and row["tool_call_id"]}
|
|
844
|
+
|
|
845
|
+
|
|
833
846
|
def _split_at(rows: list[dict], message_id: Optional[UUID]) -> int:
|
|
834
847
|
"""Index just past `message_id` in `rows`, or 0 when it isn't there.
|
|
835
848
|
|
package/tui/app.py
CHANGED
|
@@ -112,6 +112,7 @@ from tui.screens import (
|
|
|
112
112
|
PermissionScreen,
|
|
113
113
|
ProjectKindScreen,
|
|
114
114
|
QuestionScreen,
|
|
115
|
+
ResumeRunPickerScreen,
|
|
115
116
|
ReviewScreen,
|
|
116
117
|
SecretScreen,
|
|
117
118
|
SessionKillScreen,
|
|
@@ -5382,6 +5383,10 @@ class VenastineApp(App):
|
|
|
5382
5383
|
event.claim_id, {"id": event.claim_id})
|
|
5383
5384
|
claim["retry_count"] = event.attempt
|
|
5384
5385
|
panel.retried()
|
|
5386
|
+
elif event.kind == "run_started":
|
|
5387
|
+
# §98. Kept for _write_resume_hint, and not drawn: a completed
|
|
5388
|
+
# run prints its id at the end, and a failed one in the hint.
|
|
5389
|
+
self._research_run_id = event.text
|
|
5385
5390
|
|
|
5386
5391
|
def on_research_finished(self, message: ResearchFinished) -> None:
|
|
5387
5392
|
self._busy = False
|
|
@@ -5396,9 +5401,17 @@ class VenastineApp(App):
|
|
|
5396
5401
|
"[run abandoned — quit requested. Checkpoints so far are "
|
|
5397
5402
|
"kept; the run's record stays 'running' rather than "
|
|
5398
5403
|
"claiming completion.]")
|
|
5404
|
+
self._write_resume_hint()
|
|
5399
5405
|
return
|
|
5400
5406
|
if message.error is not None:
|
|
5407
|
+
from core.reasoning.resume import ResumeRefused
|
|
5408
|
+
if isinstance(message.error, ResumeRefused):
|
|
5409
|
+
# §98. Nothing ran, so this is not "pipeline failed".
|
|
5410
|
+
self._transcript.write_error(
|
|
5411
|
+
f"[cannot resume: {message.error}]")
|
|
5412
|
+
return
|
|
5401
5413
|
self._write_failure(message.error, "pipeline failed")
|
|
5414
|
+
self._write_resume_hint()
|
|
5402
5415
|
return
|
|
5403
5416
|
run = message.run
|
|
5404
5417
|
self._last_run = run
|
|
@@ -5426,6 +5439,16 @@ class VenastineApp(App):
|
|
|
5426
5439
|
if run.run_id:
|
|
5427
5440
|
self._transcript.write_system(f"[run id: {run.run_id}]")
|
|
5428
5441
|
|
|
5442
|
+
def _write_resume_hint(self) -> None:
|
|
5443
|
+
"""How to pick up a run that failed or was abandoned (ROADMAP_v3
|
|
5444
|
+
§98), once its id is known -- the run_started event carries it, and
|
|
5445
|
+
the exception that ended the run does not."""
|
|
5446
|
+
run_id = getattr(self, "_research_run_id", None)
|
|
5447
|
+
if run_id:
|
|
5448
|
+
self._transcript.write_system(
|
|
5449
|
+
f"Completed passes are kept. /research --resume "
|
|
5450
|
+
f"{str(run_id)[:8]} picks the run up where it stopped.")
|
|
5451
|
+
|
|
5429
5452
|
def on_worker_state_changed(self, event: Worker.StateChanged) -> None:
|
|
5430
5453
|
"""§16 AC3. Required alongside exit_on_error=False: without a handler the
|
|
5431
5454
|
exception is available on the worker and reported nowhere."""
|
|
@@ -5909,6 +5932,11 @@ def _cmd_research(app: VenastineApp, args: str) -> None:
|
|
|
5909
5932
|
§25: --grant [names] takes the same values as the CLI flag and goes
|
|
5910
5933
|
through the same parser, so the two shells cannot offer different
|
|
5911
5934
|
sets. Bare --grant opens the picker.
|
|
5935
|
+
|
|
5936
|
+
ROADMAP_v3 §98: `--resume [run-id]` in the query's place picks a failed
|
|
5937
|
+
or abandoned run up where it stopped; bare, it opens the picker. It
|
|
5938
|
+
comes LAST, after the other flags, which a resume takes too -- a grant
|
|
5939
|
+
is never stored (R12), so a resumed run is authorised afresh.
|
|
5912
5940
|
"""
|
|
5913
5941
|
from core.reasoning.authorization import (
|
|
5914
5942
|
GrantSpecError,
|
|
@@ -5917,6 +5945,7 @@ def _cmd_research(app: VenastineApp, args: str) -> None:
|
|
|
5917
5945
|
)
|
|
5918
5946
|
|
|
5919
5947
|
attended, review, grant_spec, query = _split_research_flags(args)
|
|
5948
|
+
resume = _split_resume(query)
|
|
5920
5949
|
if not attended:
|
|
5921
5950
|
attended = app._settings.get("research", {}).get(
|
|
5922
5951
|
"approval_mode") == "attended"
|
|
@@ -5929,10 +5958,26 @@ def _cmd_research(app: VenastineApp, args: str) -> None:
|
|
|
5929
5958
|
if not query:
|
|
5930
5959
|
app._transcript.write_error(
|
|
5931
5960
|
"Usage: /research [--attended] [--review|--no-review] "
|
|
5932
|
-
"[--grant[=a,b]] <query
|
|
5961
|
+
"[--grant[=a,b]] <query>|--resume [run-id]")
|
|
5933
5962
|
return
|
|
5934
5963
|
if app.refuse_if_occupied("start a research run"):
|
|
5935
5964
|
return
|
|
5965
|
+
if resume is not None and resume is not RESUME_PICKER:
|
|
5966
|
+
from core.reasoning.resume import ResumeRefused, find_run
|
|
5967
|
+
try:
|
|
5968
|
+
resume = find_run(resume)
|
|
5969
|
+
except ResumeRefused as e:
|
|
5970
|
+
app._transcript.write_error(f"/research --resume: {e}.")
|
|
5971
|
+
return
|
|
5972
|
+
|
|
5973
|
+
def launch(authorization) -> None:
|
|
5974
|
+
"""Start the run, or, for a bare --resume, ask which run first."""
|
|
5975
|
+
if resume is None:
|
|
5976
|
+
_start_research(app, query, authorization)
|
|
5977
|
+
elif resume is RESUME_PICKER:
|
|
5978
|
+
_pick_run_to_resume(app, authorization)
|
|
5979
|
+
else:
|
|
5980
|
+
_start_research(app, None, authorization, resume=resume)
|
|
5936
5981
|
|
|
5937
5982
|
offered = candidates()
|
|
5938
5983
|
if grant_spec is GRANT_PICKER:
|
|
@@ -5954,7 +5999,7 @@ def _cmd_research(app: VenastineApp, args: str) -> None:
|
|
|
5954
5999
|
# connects. What was config-dependent is now what happens on
|
|
5955
6000
|
# a fresh clone.
|
|
5956
6001
|
app._transcript.write_system(NOTHING_TO_GRANT)
|
|
5957
|
-
|
|
6002
|
+
launch(_authorization_for(app, set()))
|
|
5958
6003
|
return
|
|
5959
6004
|
|
|
5960
6005
|
def _picked(selected) -> None:
|
|
@@ -5963,7 +6008,7 @@ def _cmd_research(app: VenastineApp, args: str) -> None:
|
|
|
5963
6008
|
if selected is None:
|
|
5964
6009
|
app._transcript.write_system("Research cancelled.")
|
|
5965
6010
|
return
|
|
5966
|
-
|
|
6011
|
+
launch(_authorization_for(app, selected))
|
|
5967
6012
|
|
|
5968
6013
|
app.push_screen(GrantPickerScreen(offered), _picked)
|
|
5969
6014
|
return
|
|
@@ -5975,7 +6020,47 @@ def _cmd_research(app: VenastineApp, args: str) -> None:
|
|
|
5975
6020
|
except GrantSpecError as e:
|
|
5976
6021
|
app._transcript.write_error(f"/research --grant: {e}")
|
|
5977
6022
|
return
|
|
5978
|
-
|
|
6023
|
+
launch(_authorization_for(app, granted))
|
|
6024
|
+
|
|
6025
|
+
|
|
6026
|
+
#: ROADMAP_v3 §98. A bare `/research --resume`: open the picker rather than
|
|
6027
|
+
#: resume a named run. GRANT_PICKER's shape, for the same reason.
|
|
6028
|
+
RESUME_PICKER = object()
|
|
6029
|
+
|
|
6030
|
+
|
|
6031
|
+
def _split_resume(query: str):
|
|
6032
|
+
"""`--resume [run-id]` at the front of what is left once the leading
|
|
6033
|
+
flags are taken: None when the query is not a resume, RESUME_PICKER
|
|
6034
|
+
for a bare one, else the id as typed (ROADMAP_v3 §98). A separate step
|
|
6035
|
+
rather than a fifth value from _split_research_flags, whose four are
|
|
6036
|
+
unpacked by name at its call sites and in the suite."""
|
|
6037
|
+
head, _sep, rest = (query or "").strip().partition(" ")
|
|
6038
|
+
if head != "--resume":
|
|
6039
|
+
return None
|
|
6040
|
+
return rest.strip() or RESUME_PICKER
|
|
6041
|
+
|
|
6042
|
+
|
|
6043
|
+
def _pick_run_to_resume(app: VenastineApp, authorization) -> None:
|
|
6044
|
+
"""The picker behind a bare `/research --resume` (ROADMAP_v3 §98).
|
|
6045
|
+
|
|
6046
|
+
The read runs on the UI thread, in a command handler, so a failure is
|
|
6047
|
+
written rather than raised -- `action_pick_thread`'s rule (#104), and
|
|
6048
|
+
for its reason: app.db is shared with any CLI run, so `database is
|
|
6049
|
+
locked` needs nothing to be wrong."""
|
|
6050
|
+
from core.reasoning.resume import resumable_runs
|
|
6051
|
+
try:
|
|
6052
|
+
runs = resumable_runs()
|
|
6053
|
+
except Exception as e: # noqa: BLE001 -- see the docstring
|
|
6054
|
+
app._transcript.write_error(f"Could not list research runs: {e}")
|
|
6055
|
+
return
|
|
6056
|
+
|
|
6057
|
+
def chosen(run_id) -> None:
|
|
6058
|
+
if run_id is None:
|
|
6059
|
+
app._transcript.write_system("Resume cancelled.")
|
|
6060
|
+
return
|
|
6061
|
+
_start_research(app, None, authorization, resume=run_id)
|
|
6062
|
+
|
|
6063
|
+
app.push_screen(ResumeRunPickerScreen(runs), chosen)
|
|
5979
6064
|
|
|
5980
6065
|
|
|
5981
6066
|
def _authorization_for(app: VenastineApp, granted: set):
|
|
@@ -6093,12 +6178,25 @@ def _forwarding(app: "VenastineApp", events, outcome: dict):
|
|
|
6093
6178
|
yield event
|
|
6094
6179
|
|
|
6095
6180
|
|
|
6096
|
-
def _start_research(app: VenastineApp, query
|
|
6181
|
+
def _start_research(app: VenastineApp, query, authorization,
|
|
6182
|
+
resume=None) -> None:
|
|
6097
6183
|
"""Kick off the worker. Split from _cmd_research because the picker
|
|
6098
|
-
path resolves asynchronously and lands here from a callback.
|
|
6184
|
+
path resolves asynchronously and lands here from a callback.
|
|
6185
|
+
|
|
6186
|
+
`resume` (ROADMAP_v3 §98) is the id of a run to pick up instead of
|
|
6187
|
+
starting `query`, which is then None. The id is kept on the app from
|
|
6188
|
+
here, and from the run's run_started event, so a failure can say how
|
|
6189
|
+
to resume."""
|
|
6099
6190
|
app._busy = True
|
|
6100
|
-
app.
|
|
6101
|
-
|
|
6191
|
+
app._research_run_id = str(resume) if resume is not None else None
|
|
6192
|
+
if resume is not None:
|
|
6193
|
+
app._transcript.write_user(f"/research --resume {resume}")
|
|
6194
|
+
app._transcript.write_system(
|
|
6195
|
+
"Resuming the run where it stopped; completed passes are not "
|
|
6196
|
+
"run again.")
|
|
6197
|
+
else:
|
|
6198
|
+
app._transcript.write_user(f"/research {query}")
|
|
6199
|
+
app._transcript.write_system("Running the ten-pass pipeline. This takes a while.")
|
|
6102
6200
|
app._raven.state = ravens.THINKING
|
|
6103
6201
|
app._research_progress.start_run()
|
|
6104
6202
|
review_on = bool(getattr(app, "_research_review", False))
|
|
@@ -6110,6 +6208,7 @@ def _start_research(app: VenastineApp, query: str, authorization) -> None:
|
|
|
6110
6208
|
stream_deep_research_pipeline,
|
|
6111
6209
|
)
|
|
6112
6210
|
from core.reasoning.output_writer import write_run_artifacts
|
|
6211
|
+
from core.reasoning.resume import ResumeRefused
|
|
6113
6212
|
error = None
|
|
6114
6213
|
try:
|
|
6115
6214
|
# §22: ITERATED, not drained. A drainer would
|
|
@@ -6135,12 +6234,19 @@ def _start_research(app: VenastineApp, query: str, authorization) -> None:
|
|
|
6135
6234
|
# in the status bar -- captured HERE, so a mid-run /effort
|
|
6136
6235
|
# affects the next run, exactly like model/provider.
|
|
6137
6236
|
effort=app.effort,
|
|
6237
|
+
resume=resume,
|
|
6138
6238
|
)
|
|
6139
6239
|
outcome = {}
|
|
6140
6240
|
run = None
|
|
6141
6241
|
try:
|
|
6142
6242
|
run = run_pipeline_to_completion(
|
|
6143
6243
|
_forwarding(app, events, outcome))
|
|
6244
|
+
except ResumeRefused as refused:
|
|
6245
|
+
# §98. Refused before anything changed: reported as what it
|
|
6246
|
+
# is, and NOT re-raised -- it is an answer, not a worker
|
|
6247
|
+
# failure, and re-raising would log and toast it again.
|
|
6248
|
+
app.post_message(ResearchFinished(None, refused))
|
|
6249
|
+
return
|
|
6144
6250
|
except RuntimeError:
|
|
6145
6251
|
if not outcome.get("abandoned"):
|
|
6146
6252
|
raise
|
package/tui/app.tcss
CHANGED
|
@@ -460,7 +460,11 @@ Button:focus {
|
|
|
460
460
|
border-right: none;
|
|
461
461
|
}
|
|
462
462
|
|
|
463
|
-
|
|
463
|
+
/* ROADMAP_v3 §98's run picker shares the thread picker's dialog, so it
|
|
464
|
+
shares the rule that centres it -- the sweep in test_tui.py measured it
|
|
465
|
+
at the screen's left edge without. */
|
|
466
|
+
ThreadPickerScreen,
|
|
467
|
+
ResumeRunPickerScreen {
|
|
464
468
|
align: center middle;
|
|
465
469
|
}
|
|
466
470
|
|
package/tui/screens.py
CHANGED
|
@@ -1189,6 +1189,67 @@ class ThreadPickerScreen(ModalScreen[object]):
|
|
|
1189
1189
|
self.dismiss(None)
|
|
1190
1190
|
|
|
1191
1191
|
|
|
1192
|
+
def resume_run_row(run: dict) -> str:
|
|
1193
|
+
"""One research run in the resume picker (ROADMAP_v3 §98): the start of
|
|
1194
|
+
its id, when it started, what state it is in, where it would resume, and
|
|
1195
|
+
its query on the line below -- the query is what a person recognises.
|
|
1196
|
+
A run that is still 'running' may be live in another process sharing
|
|
1197
|
+
app.db, and nothing in the record can tell, so the row says both."""
|
|
1198
|
+
status = ("stopped, or still running elsewhere"
|
|
1199
|
+
if run.get("status") == "running" else str(run.get("status")))
|
|
1200
|
+
started = run.get("started_at")
|
|
1201
|
+
when = (started.strftime("%Y-%m-%d %H:%M")
|
|
1202
|
+
if hasattr(started, "strftime") else str(started or ""))
|
|
1203
|
+
where = (f"cannot resume: {run['note']}" if run.get("note")
|
|
1204
|
+
else f"resumes {run.get('stage')}")
|
|
1205
|
+
query = " ".join(str(run.get("user_query") or "").split())
|
|
1206
|
+
if len(query) > 70:
|
|
1207
|
+
query = query[:69] + "…"
|
|
1208
|
+
return f"{str(run.get('id'))[:8]} {when} {status} {where}\n {query}"
|
|
1209
|
+
|
|
1210
|
+
|
|
1211
|
+
class ResumeRunPickerScreen(ModalScreen[object]):
|
|
1212
|
+
"""Pick a failed or abandoned research run to resume (ROADMAP_v3 §98).
|
|
1213
|
+
Dismisses with the run's id, or None to cancel.
|
|
1214
|
+
|
|
1215
|
+
The thread picker's shape and its CSS, because it is the same decision
|
|
1216
|
+
one level up -- which earlier piece of work to carry on -- and a second
|
|
1217
|
+
look for it would be a second thing to keep styled. A run this build
|
|
1218
|
+
cannot resume is still listed, with the reason, so a person looking
|
|
1219
|
+
for it learns why rather than wondering where it went; choosing it gets
|
|
1220
|
+
the same reason as an error.
|
|
1221
|
+
"""
|
|
1222
|
+
|
|
1223
|
+
BINDINGS = [("escape", "cancel", "Cancel")]
|
|
1224
|
+
|
|
1225
|
+
def __init__(self, runs: list[dict], note: str = ""):
|
|
1226
|
+
super().__init__()
|
|
1227
|
+
self._runs = runs
|
|
1228
|
+
self._note = note
|
|
1229
|
+
|
|
1230
|
+
def compose(self) -> ComposeResult:
|
|
1231
|
+
items = [ListItem(Label(Text(resume_run_row(r)))) for r in self._runs]
|
|
1232
|
+
children = [Label("Resume which research run?", id="thread-title")]
|
|
1233
|
+
if self._note:
|
|
1234
|
+
children.append(Static(Text(self._note), id="thread-note"))
|
|
1235
|
+
if items:
|
|
1236
|
+
children.append(ListView(*items, id="thread-list"))
|
|
1237
|
+
else:
|
|
1238
|
+
children.append(Static("No failed or abandoned research run to "
|
|
1239
|
+
"resume.", id="thread-empty"))
|
|
1240
|
+
yield Vertical(*children, id="thread-dialog")
|
|
1241
|
+
|
|
1242
|
+
def on_list_view_selected(self, event: ListView.Selected) -> None:
|
|
1243
|
+
index = event.list_view.index
|
|
1244
|
+
if index is not None and 0 <= index < len(self._runs):
|
|
1245
|
+
self.dismiss(self._runs[index]["id"])
|
|
1246
|
+
else:
|
|
1247
|
+
self.dismiss(None)
|
|
1248
|
+
|
|
1249
|
+
def action_cancel(self) -> None:
|
|
1250
|
+
self.dismiss(None)
|
|
1251
|
+
|
|
1252
|
+
|
|
1192
1253
|
class SecretScreen(ModalScreen[object]):
|
|
1193
1254
|
"""Ask for one secret, masked (ROADMAP_v3 §49 slice 5a, SS59).
|
|
1194
1255
|
|