13 Commits

Author	SHA1	Message	Date
drew	eb01eb0172	feat(controller): dual-mode launcher (fork/prod) + DB-mode validator ... Adds the operator surface for switching the controller pipeline between the personal fork (drew/cleveragents-core) and the canonical repo (cleveragents/cleveragents-core) via a MODE env + --prod CLI flag, backed by safety primitives that make a wrong-mode launch loud rather than silent. run-controller-state-machine-pipeline.sh: --prod flag and MODE env (primary home: .devcontainer/.env) select fork vs prod. After resolving MODE, the launcher auto-sources the matching overlay file (.devcontainer/.env.{fork,prod}) and asserts MODE didn't drift during the source step. The drift assertion uses a readonly snapshot under an obscure variable name so a stray ``MODE=fork`` in .env.prod aborts the launch with a clear bash error rather than silently demoting the run. CONTROLLER_RUN_DIR_ROOT now overrides the trial /tmp path so prod can use a persistent /var/lib/cleveragents/run dir. tools/launch_prod.sh (new): sibling to launch_fork.sh with the opposite safety primitive — affirmative GET /repos/{owner}/{repo} that asserts the target is non-fork, exists, isn't archived, and the bot has push. On any failure, no env is exported. Honors HAL_* aliases for parity with launch_fork.sh and prints a hard-to-miss PROD-MODE banner. tools/controller/deploy/validate_db_mode.py (new): stamps a _mode_marker table on each SQLite db (controller DB + telemetry cache) on first use, asserts a match on every subsequent launch, and moves mismatched files aside as <name>.<prior-mode>.bak.<ts> — never deletes. The --adopt flag lets an operator grandfather in already-good pre-marker data without losing history. Wired into the launcher's startup sequence before OpenCode and the master start. tools/_cache_path.py (new): single source of truth for the per-(owner, repo) Forgejo cache file convention. .opencode/telemetry/server.py and the launcher both delegate here so the dual-source-truth drift risk is eliminated. tools/_pipeline_cache.py and tools/controller/db/models.py documented as not owning the _mode_marker table so future migrations leave it alone. .opencode/telemetry/server.py: hosts the llm_activity scraper as a background subprocess thread (60s cadence, --since-hours 1 in steady state, full backfill on first tick). Re-homes the cost-telemetry data path after the pr_state_warmer was retired by the controller migration — without this the Cost tab freezes when the warmer's loop is gone. Subprocess (not in-process) for isolation; failures swallowed. opencode.json: local-claude provider's baseURL now reads {env:LOCAL_PROXY_URL} instead of the literal http://127.0.0.1:3456/v1, matching the apiKey pattern already in use. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-05-24 08:25:24 -04:00
drew	6178be3aa7	feat(models): single-source model registry via models.yaml + sync_models.py ... .opencode/models/models.yaml is now the ONE file humans edit to assign a model to an agent. tools/sync_models.py regenerates every derived surface — the .opencode/models/*.txt files, opencode.json's `agent` block, and each non-tier agent's .md `model:` frontmatter — so an assignment cannot drift across surfaces. `--check` verifies with no writes and is enforced in CI by test_model_registry_in_sync_with_manifest. Hardened after adversarial review: - Deletes orphan <agent>.txt files left behind when an override is dropped from the manifest. The dispatcher's resolver reads <agent>.txt before default.txt, so a stale file would silently pin the old model. Tier .txt files are left to sync_tier_models.py. - Rejects a manifest key that does not name a real agent (no matching .opencode/agents/<name>.md) instead of silently appending a bogus opencode.json entry and leaving the real agent on the default model. - Validates the regenerated opencode.json BEFORE writing it, so a bad render aborts cleanly instead of corrupting the file on disk. Tier-ladder agents (task-implementor-tier-*) remain governed separately by tiers.yaml + sync_tier_models.py and are passed through untouched. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-05-22 07:33:18 -04:00
drew	a6986008ee	feat(controller): trial-5 batch — dispute path, merge pipeline split, conflict-resolver hardening ... T5-1 reviewer feedback rendered full-body to the implementer T5-4/9 implementer dispute path — dispute-at-any-tier with per-tier cap, OPERATOR_ATTENTION state on stalemate, pr-review-worker-dispute agent T5-5 reviewer BLOCKING ISSUE EVIDENCE RULE + 5-step validation T5-7 merge step split into a singleton process — impl/review masters write APPROVED and stop; merge_drive owns APPROVED -> MERGING -> MERGED T5-10 merge process is fully deterministic; base conflicts bounce to the controller's CONFLICT_RESOLVING (LLM); conflict_drive sidecar retired T5-11 implementer fast success path — verified-clean outcome so a no-op after conflict resolution doesn't force busywork T5-12 conflict-resolver permissions fixed across all paths (/tmp/** glob) T5-13 conflict-resolver PR-intent prehydration (title/body/comments) Adds tools/_controller_db_bridge.py so merge_drive reads the controller DB directly (Option B), plus APPROVED + OPERATOR_ATTENTION states, the dispute/verified-clean events, and the V1 contract fields backing them. Reviewer model: baseline -> sonnet, dispute -> opus. Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>	2026-05-19 17:54:07 -04:00
drew	85c3440bb5	fix(opencode): inline tier-implementor model assignments (Option B follow-up) ... The repo-root opencode.json agent block had 4 entries pointing at {file:./.opencode/models/task-implementor-tier-N.txt} — files that batch Q's Option B fix removed because OpenCode ignored the dispatcher's POST /session model pass-through anyway. Result: OpenCode failed startup with ConfigInvalidError ("bad file reference"). The trial couldn't launch. Fix: replace the 4 {file:...} refs with literal model strings, matching tiers.yaml exactly: - tier-min: local-claude/claude-haiku-4-5 - tier-0: local-claude/claude-haiku-4-5 - tier-1: local-claude/claude-sonnet-4-6 - tier-2: local-claude/claude-opus-4-6 Verified empirically: probing task-implementor-tier-1 now returns 'claude-sonnet-4-6' (vs the pre-fix 'openai/gpt-5.3-chat-latest' fallback that masked the missing per-tier model). The tier-escalation ladder now actually swaps models — pre-batch-Q it was cosmetic. Follow-up: sync_tier_models.py should keep these in sync when tiers.yaml changes (currently the script regenerates .md frontmatter + removes stale .txt; the opencode.json block is hand-maintained). Deferred to keep this fix tightly scoped. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-05-18 20:20:36 -04:00
drew	80d61de942	feat(auto-agents): R3 wrapper-chain retirement — direct task-implementor variants ... Eliminates the remaining LLM wrapper chain (``tier-dispatcher`` + ``tier-{min,0,1,2}`` selectors) between the Python dispatcher and the ``task-implementor`` worker. Follows the R2 implementation-worker retirement (6e63073ad, 2026-05-16); both wrappers were pure routing agents with no per-cycle judgment that could not be moved to Python. Architecture ------------ Before (R2 baseline): dispatch_implementer.py → tier-dispatcher (LLM) → estimator-implementation (LLM, judgment) → tier-N selector (LLM, pure pass-through) → task-implementor (LLM, the actual work, via `task` hop) After (R3): dispatch_implementer.py → estimator-implementation (LLM, judgment — invoked top-level) → task-implementor-tier-N (LLM, the actual work, NO `task` hops) Two LLM hops eliminated per cycle. The ``task`` tool hop between the tier-N selector and task-implementor is gone too, so the dispatcher's prefetched ``## Pre-fetched …`` sections survive intact in the worker's prompt — closing the structural cause of the ~30-80 per-session ``implementer_pr_context.py read --pr N`` round-trips the worker burned to recover summarised-away context. Cost savings (4-day measurement window, $-figures based on local-claude pricing with caching): - Eliminating tier-dispatcher sessions (32/day): ~$5-15/day - Eliminating tier-N selector sessions (15/day): ~$2-5/day - Eliminating prefetch round-trips (229/4d → expected near 0): ~$20-40/day Aggregate at current traffic: roughly $30-60/day, $900-1,800/month. What changed ------------ 1. **New ``sync_tier_models.py`` scope** — generates per-tier ``task-implementor-{slot}.md`` + matching ``.opencode/models/task-implementor-{slot}.txt`` files from ``task-implementor.md`` (the byte source). Dropped: the bare ``tier-N.txt`` model files (no consumer) and the tier-dispatcher.md mapping-table generation (no file). 2. **New ``_call_python_estimator``** in dispatch_implementer.py invokes ``estimator-implementation`` as a top-level OpenCode session, parses ``{is_confident, recommended_tier}``, returns the tier integer or None. Includes a heartbeat-refresh on_poll so a 30-180 s estimator call cannot trigger the launcher's hung- process watchdog. Estimator switched from ``mode: subagent`` to ``mode: all`` so the dispatcher can spawn it directly. 3. **New ``_resolve_task_implementor_for_tier(tier)`` helper** maps manifest tier integers to the matching ``task-implementor-{slot}`` variant. Used by both the initial dispatch (in the prompt factory) and the in-cycle escalation respawn. 4. **WorkGroup contract extended** with ``requires_worker_agent_override: bool`` (default False, opt-in per group). The implementer's three WorkGroups set True; ``_resolve_effective_worker_agent`` raises a clear RuntimeError if the prompt_factory failed to populate the override (a code bug that would otherwise silently run every cycle at the static fallback tier). 5. **``_implementation_prompt_dispatch`` refactored** to: - Resolve the tier in Python (label-driven hint → estimator → default 0), honouring both the in-cycle escalation flag and the estimator-enabled flag. - Stash the resolved ``task-implementor-tier-<slot>`` agent name on the item context under ``WORKER_AGENT_OVERRIDE_ITEM_KEY`` (single source of truth in ``_dispatch_runtime``; imported into the higher layer). - Emit the worker body with ``escalation_tier: \`N\``` directly — no more ``escalation_tier_hint``, ``task_prompt:`` fence, or ``task_agent:``/``estimator_agent:`` outer parameters (all consumed by the retired tier-dispatcher). - Skip the estimator call on ``--dry-run`` so the operator- visible no-I/O contract holds. 6. **Retired agent files DELETED**: - ``.opencode/agents/tier-dispatcher.md`` - ``.opencode/agents/tier-{min,0,1,2}.md`` - ``.opencode/models/tier-{min,0,1,2}.txt`` - Matching entries in ``opencode.json``'s agent block. 7. **Prose updates** to ``task-implementor.md`` (the byte-source for variants), ``estimator-implementation.md``, and production docstrings (``_block_store.py``, ``_pr_context_sentinel.py``, ``implementer_workspace.py``, ``_review_post.py``, ``_review_finalize.py``) reflecting the post-R3 chain. The filesystem handoff scripts (``implementer_pr_context.py``, ``implementer_workspace.py``) remain in place as the canonical read path — defensive against any future regression that re- introduces summarisation. Tests ----- 2262 auto_agents passing (was 2268 pre-R3; net -6 from removing tests pinning the retired wrapper-chain contract, offset by +14 new tests pinning the post-R3 contract): - ``TestEstimatorEnabledFlag`` rewritten to assert ``escalation_tier`` + agent-override semantics. - New ``TestEstimatorPromptShape`` (5 tests) pins the body shape the Python estimator helper passes to the agent and the call shape into ``run_session_blocking``. - New ``TestResolveEffectiveWorkerAgent`` (8 tests) directly covers the override priority chain — override present, empty, whitespace, non-string, whitespace-stripped, required-but-missing (loud fail), required-and-present. - ``test_dry_run_never_calls_estimator`` pins the dry-run no-I/O contract via an exploding-stub guard on the estimator helper. - ``TestDirectTierDispatch`` replaces the retired ``TestTierDispatcherShortCircuit`` suite in ``test_worker_permissions.py``. - ``TestTaskImplementorVariantsAreByteIdentical`` ensures the four per-tier variants never hand-diverge from each other. - ``test_no_legacy_tier_agents_in_opencode_agent_block`` fails loudly if any of the retired tier-* entries are re-introduced to ``opencode.json``. Operator notes -------------- - The C3 footgun (model swaps need OpenCode restart) still applies to the generated variants — edit ``tiers.yaml``, re-run ``python3 tools/sync_tier_models.py``, then restart OpenCode. - The estimator now runs as a top-level OpenCode session; an operator grepping the session archive will see ``[AUTO-IMP-PR-N-estimator] estimator-implementation`` entries alongside the worker sessions. - Roll-back: revert this commit + the R3 prep commit (b8c1e4903). Both wrappers + the static-fallback ``worker_agent`` come back; no schema migration needed. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-05-17 15:03:30 -04:00
drew	b8c1e49032	feat(auto-agents): R3 prep — generate per-tier task-implementor variants ... Prep step for retiring the tier-dispatcher + tier-N wrapper chain (R3, follow-up to R2's implementation-worker retirement at 6e63073ad). The cutover commit will swap the dispatcher to invoke these variants directly; this commit adds the variants without behavior change. What changed: 1. **sync_tier_models.py extended** to generate ``task-implementor-tier-{slot}.md`` + matching ``.opencode/models/task-implementor-tier-{slot}.txt`` for every tier in ``tiers.yaml``. The ``.md`` body is a byte copy of ``task-implementor.md`` (the source of truth) prefixed with an HTML-comment generation header. The ``.txt`` carries the slot's model, identical to the matching tier-N selector's ``.txt``. 2. **opencode.json agent block** gets four new entries (one per variant) wiring each ``task-implementor-tier-{slot}`` to its ``.opencode/models/<name>.txt`` via the same ``{file:...}`` interpolation the existing tier-N selectors use. This is the one-time refactor edit the generator's docstring already documents — operators add/remove ``opencode.json`` agent block entries when tiers are added or removed. 3. **Drift-detection tests** in test_tier_model_registry.py for the new variants: existence (md + txt), byte-copy invariant against the source, model match against the manifest, and opencode.json wiring. The per-tier variants exist because OpenCode resolves a session's model from ``agent.<name>.model`` at startup — there is no per-session model override (documented C3 footgun at 1635229828). Each tier needs a distinct agent name to hit a distinct model slot; the variants give the dispatcher that handle without going through a tier-N pass-through agent. Tests: 2268 auto_agents passing (was 2268 before; +5 new variant drift tests offset by no regressions). The variants are not yet invoked by any code path — that's the cutover commit. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-05-17 13:34:59 -04:00
drew	1eac4ea233	refactor(auto-agents): manifest-driven tier-model registry, slot-based naming ... Replace the scattered per-agent .txt-file mapping (whose names embedded model-family identity like tier-qwen-med and tier-kimi and went stale the moment a model was swapped) with a single source-of-truth manifest at .opencode/models/tiers.yaml. The four tier slots get model-agnostic slot-based names (tier-min, tier-0, tier-1, tier-2); the model in each slot is configured ONLY in the manifest. Derived artifacts (per-agent .txt files and the mapping table block in tier-dispatcher.md) are now generated by tools/sync_tier_models.py. A drift-detection test in tests/auto_agents/test_tier_model_registry.py fails CI if any derived file diverges from the manifest, if an agent referenced by the manifest lacks an agent file, if the manifest cites a provider not declared in opencode.json, or if opencode.json carries a stale tier-* entry. To swap a model in a slot: edit tiers.yaml -> run python3 tools/sync_tier_models.py -> commit. The runtime dispatcher re-reads the .txt files per cycle (no restart); the static OpenCode config path needs a server restart. Tier rename mapping (escalation_tier integers UNCHANGED): tier-qwen-small -> tier-min (slot -1) tier-qwen-med -> tier-0 (slot 0, default first attempt) tier-qwen-large -> tier-1 (slot 1) tier-kimi -> tier-2 (slot 2) Vestigial tier-* agents removed (declared but never in the active mapping): tier-haiku, tier-sonnet, tier-opus, tier-codex, tier-gpt5-mini, tier-gpt5-nano, tier-o4-mini. estimator-implementation.md now reasons in capability descriptors (cheapest / default / advanced / complex) instead of model-family labels (qwen-small / qwen-med / qwen-large / kimi), so the estimator stays correct across model swaps. The stale "default tier = gpt-5-mini" docstring claim (already drifted to claude-haiku-4-5) is removed. Companion prose updates across every consumer of tier names: - Agent prompts: tier-dispatcher.md, implementation-worker.md, estimator-implementation.md - Skills: implementer-pr-context, implementer-workspace - Python: dispatch_implementer.py, _opencode_worker.py, _pr_context_sentinel.py, implementer_workspace.py, setup_auto_labels.py, _attempt_history.py - Tests: test_worker_permissions.py (parametrize list + byte-identity test now covers 4 slot files instead of 3 family-named files), test_opencode_worker_models.py (synthetic-fixture names updated) - Docs: .opencode/models/README.md, docs/development/models.md, docs/development/agent-system-specification.md, docs/development/auto-agents-tier-2-3-plan.md, docs/development/implementer-in-cycle-escalation-plan.md, docs/development/final-working-harvest-plan.md Validation: 1625 tests pass (+6 net new from the tier-registry test file), 3 skipped. python3 tools/sync_tier_models.py --check exits 0. local_ci_gate.sh --gate lint PASS. Files: 9 added, 22 deleted, 18 modified. The drift-detection test ran green on every step of the refactor, catching one out-of-sync .txt file before commit. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-05-15 12:49:31 -04:00
drew	706178d54b	fix(auto-agents): tier-selector pass-through lockdown + local-claude provider ... Three coupled fixes from the run-3/4/5 forensic sequence, plus the local-claude model routing they depend on. PROVIDER (validated in run-5): * opencode.json: local-claude provider uses @ai-sdk/anthropic (was @ai-sdk/openai-compatible). The OpenAI-compat adapter dropped streaming tool-call args on ~58% of responses — OpenCode saw bash({}) schema-errors. The native Anthropic SDK parses the proxy's input_json_delta stream correctly. Run-5 confirmed: tool args now flow intact (full {command,description} fields observed). * apiKey reads {env:LOCAL_ANTHROPIC_API_KEY} (not ANTHROPIC_API_KEY) so a shell with a real Anthropic key set cannot leak it to the local proxy. * .opencode/models/tier-{qwen-med,qwen-large,kimi}.txt point at local-claude/claude-{haiku,sonnet,opus}-4-x. These REQUIRE the provider block above — committed together to avoid a non-bootable intermediate state. TIER-SELECTOR LOCKDOWN (applied, unvalidated — see below): * tier-{qwen-med,qwen-large,kimi}.md: every tool except `task` is now denied at the permission-engine level. Run-5 showed an agentic model (claude-haiku-4-5) given Read/Grep/Edit/Bash will do the implementer work *inside the tier selector*, bypassing task-implementor and thrashing against the selector's restrictive perms (20+ denials in one Tier 0 cycle; task-implementor never spawned). gpt-5-mini honoured the "pure pass-through" prompt; Claude-family models do not. The fix makes pass-through structural, not prompt-dependent. The 60-line alphabet-kludge edit block is also gone. TASK-IMPLEMENTOR PERMISSION ORDERING (applied, unvalidated): * task-implementor.md: edit/write/external_directory rules reordered so specific allows precede `*: deny` — the OpenCode permission engine evaluates path-perms first-match-wins (confirmed empirically from run-4's denial dump; no OpenCode docs exist for this). Path globs widened /tmp/* -> /tmp/** since the worktree path is multi-segment under /tmp/. This is what was blocking edit/write on the dispatcher's pre-cloned worktree. VALIDATION STATUS: the provider swap is confirmed by run-5 observation. The two permission changes are UNVALIDATED — run-5 never reached task-implementor because the tier selector consumed the whole cycle. The tier-selector lockdown is precisely what unblocks reaching task-implementor, so the next run validates both at once. TEST: tests/auto_agents/test_worker_permissions.py gains TestTierSelectorPassThroughPermissions — 10 tests pinning that all work-tools are denied, only `task: task-*` is allowed, the bash block has zero allow rules, and the three selector files stay byte-identical (they are maintained as a unit; copy-paste drift is the failure mode). Full suite: 25/25 in test_worker_permissions.py, 1499 passing in tests/auto_agents/ (3 pre-existing failures in test_pr_comments_cache.py are a date-rollover time-bomb unrelated to this change). Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-05-14 00:57:11 -04:00
drew	132a5a2269	feat(auto-agents): centralise model registry under .opencode/models with session-create model stamp ... Every agent's model assignment now lives in a single-line text file at .opencode/models/<name>.txt; default.txt is the 27-agent catch-all. opencode.json's agent.<name>.model uses {file:./.opencode/models/<name>.txt} interpolation, and tools/_opencode_worker.py reads the same files at session-create to stamp the resolved model on the session record (observability + drift sentinel; OpenCode does NOT propagate session-level model to prompt_async — schema for that is undocumented and deferred to Stage 2). 39 .md frontmatter `model:` lines stripped; the two intentional inheritors (task-implementor, agent-evolution-pool-supervisor) keep their model-less frontmatter. Operator workflow for swapping a model is now: edit .opencode/models/<role>.txt, restart OpenCode so opencode.json's {file:...} re-resolves, run the dispatcher. Live-swap without restart was attempted (override on prompt_async); OpenCode 0.x silently dropped those requests (200 OK, no assistant message) and the prompt_async override was reverted. The session-create override remains for observability + drift detection. End-to-end validation (2026-05-10): dispatch_review.py on PR #25 with default.txt=openai/gpt-5-mini produced a clean REQUEST_CHANGES review in 26 s for ~$0.016; dispatch_implementer.py on PR #30 with tier-qwen-* files remapped to openai/{gpt-5-nano, gpt-5-mini, gpt-5-codex} ran the full implementation-worker → tier-dispatcher → estimator-implementation → tier-qwen-med → task-implementor → git-isolator-util chain in 16 min with model=gpt-5-mini end-to-end. Also documents the printenv VAR form as the only allowed env-read in implementation-worker.md and task-implementor.md (live testing showed the worker burning 2–4 turns on permission-denied trial-and-error trying printf and echo variants). Tests: 21 in tests/auto_agents/test_opencode_worker_models.py (resolver semantics with caplog assertions on every malformed-input path; session-create body shape; prompt_async body never carries model; three repo-level invariants — every {file:...} reference resolves, every .md is wired or in the inheritor allowlist, no .md has a model: frontmatter). 1027 auto_agents tests pass / 3 skipped. Note: .opencode/models/default.txt and the three tier-qwen-*.txt files are committed with their OpenAI swaps in place (gpt-5-mini, gpt-5-nano, gpt-5-mini, gpt-5-codex respectively) because the CleverThis HuggingFace endpoints are paused. Revert with `git diff HEAD~1 -- .opencode/models/*.txt | git apply -R` if/when they come back. Co-authored-by: Cursor <cursoragent@cursor.com>	2026-05-10 17:23:06 -04:00
drew	2cbe62a70c	fix(auto-agents): F1+F2+F3 telemetry liveness, reviewer perf (A+C), bash rules ... Bundles a long-overdue set of fixes that surfaced while watching the single-PR pipeline test against PR #30 the morning of 2026-05-07. # F1 — long-worker liveness contract The dispatcher heartbeat was only refreshed *between* worker sessions. On a 30-minute review the heartbeat file went stale, and any heartbeat-watchdog (dispatchers-launcher.sh / cleveragents-dispatchers.service) would SIGTERM a perfectly-healthy worker mid-cycle, orphaning the OpenCode session and the auto/claimed-* lock. ``_opencode_worker.run_session_blocking`` now accepts an ``on_poll`` callback fired once per status-poll iteration; ``_dispatch_runtime.dispatch_one`` and ``conflict_drive.py`` wire it to ``write_heartbeat(cfg.heartbeat_path)``. Callback exceptions are logged and swallowed so a transient EROFS on the heartbeat path can never mask a successful worker completion. # F2 — in-flight cycle visibility (schema v5) The ``dispatch_*_cycles`` tables previously only recorded a row at cycle *end*. While a worker was running, the operator's only signal was the heartbeat file — and even that became stale (see F1). Schema bumped to v5: ``ended_at`` is now nullable and ``cycle_id`` carries a UNIQUE index. ``begin_cycle`` writes the in-flight row at start; ``finish_cycle`` updates it at end. ``run_one_cycle``'s try/finally guarantees ``finish_cycle`` runs even when ``collect_candidates`` / ``dispatch_one`` raises, so an orphan ``ended_at IS NULL`` can no longer be stuck forever after a crash. The v4→v5 migration is now defined in ONE place — a set of helpers in ``_forgejo_cache.py`` (``DISPATCH_CYCLE_TABLES``, ``_dispatch_cycle_create_sql``, ``_dispatch_cycle_index_sqls``, ``migrate_dispatch_cycle_table_to_v5``, ``ensure_dispatch_cycle_schema``). Both ``ForgejoCache._migrate_to_v5_in_flight_rows`` and ``_dispatch_runtime.ensure_cycle_table`` import from there, eliminating the drift risk of the previous duplicated DDL. Pre-existing rows are preserved verbatim across the migration. # F3 — telemetry surface for the new state ``/api/health`` now returns ``in_flight_cycle: {cycle_id, started_at, session_id, candidates_count, elapsed_s}`` per dispatcher daemon and a ``running_long_worker: bool`` flag (heartbeat older than 600s AND a matching pid alive — should never fire under healthy F1 operation, so when it does it points at a real bug). The Drivers and Overview tabs in ``.opencode/telemetry/{index.html,app.js,style.css}`` render in-flight rows with a tinted background + "in flight" pill, daemon tiles get a dashed border for the long-worker state, and each tile shows the running cycle's id + elapsed time inline. # Fix A — reasoningEffort high → medium for pr-review-worker On its own that change alone would not have been enough, but combined with Fix C below it dropped a representative cycle from "timed out at 30:00" to a target ~2-3min. Pure config change in ``.opencode/agents/pr-review-worker.md``; no code path touched. # Fix C — pre-fetch PR diff in dispatch_review and embed in prompt The reviewer used to spawn a ``git-isolator-util`` subagent, which shelled out to ``git clone``, ``git fetch``, and ``git diff master...HEAD``. That subagent burned 90+ seconds and several token budgets per cycle. ``dispatch_review.py`` now fetches the unified diff via the Forgejo ``/pulls/{n}.diff`` endpoint and embeds it into the worker prompt under an ``UNTRUSTED CONTENT`` fence with explicit BEGIN_PR_DIFF / END_PR_DIFF markers, head_sha pinning, character-count metadata, and END marker redaction to defeat patch-text injection. The worker is instructed to use the embedded diff and skip the isolator subagent entirely when it is present. Falls back to the old path on fetch failure or via the ``REVIEW_DISPATCHER_EMBED_DIFF=0`` env switch. # Cross-cutting bash rules The ``pr-review-worker``'s shell tool calls kept hitting ``permission denied`` because OpenCode's permission engine matches the *raw, unexpanded* command string against allow-globs. Chained commands (``&&``, ``||``, ``;``, ``|``), command substitution (``$(...)``), bare variable assignments, multi-line continuations (``\\\n``), heredocs, and inline ``python3 -c "..."`` strings all contain characters the permission glob cannot span, and were silently denied. Added ``.opencode/instructions/bash-commands.md`` (wired into ``opencode.json`` via the ``instructions`` array so it appends to EVERY agent's system prompt globally), with hard rules + recovery recipes (``printf > /tmp/file`` instead of heredocs; ``printf > /tmp/script.py`` + ``python3 /tmp/script.py`` instead of ``python3 -c``; ``curl -d @/tmp/body.json`` instead of multi-line ``-d '{...}'``). # Pre-commit polish (architect/dev/test review) Surfaced during a chief-architect / principal-developer / senior-test-engineer code review of the uncommitted change: - Schema DDL deduplication (described above under F2). - ``finish_cycle`` INSERT-fallback now preserves ``started_at`` / ``driver_name`` when caller provides them; otherwise stamps a ``synthetic_started_at: true`` flag in the raw blob so cycle-time analytics can exclude rows whose duration was synthesised. - ``bytes=`` → ``chars=`` in the embedded-diff header. The value is ``len(diff_text)`` after ``decode("utf-8")`` — a UTF-8 character count, not a byte count. Off-by-multibyte for non-ASCII patches. - ``scripts/opencode-builder.sh`` mode 644 → 755. - ``.gitignore`` entries for ``.parked-prs.json`` (runtime state for ``tools/park_other_prs.py --restore``) and ``.dispatcher-logs/`` (append-only local pipeline log directory). # Tests (381 passed, 1 skipped) - ``test_opencode_worker.py``: 3 new tests for ``on_poll`` cadence, error swallowing, and backwards-compatible default. - ``test_dispatch_runtime.py``: 7 new tests for ``begin_cycle`` / ``finish_cycle`` semantics, the v4→v5 migration with row preservation, the crash-safe try/finally path, the ``dispatch_one`` → ``run_session_blocking`` ``on_poll`` wiring, and the new ``started_at`` / ``driver_name`` plumbing through the INSERT-fallback branch. - ``test_telemetry_server.py``: 4 new tests for ``in_flight_cycle`` in ``/api/health``, the elapsed-seconds computation, and the ``running_long_worker`` flag. - ``test_telemetry_schema.py``: assertion bumped from v4 → v5 and a new test confirming the cycle tables now allow ``ended_at IS NULL``. - ``test_dispatch_review.py`` (new file): 14 tests for diff fetch (happy path, truncation, HTTP/URL errors, END_PR_DIFF redaction, Forgejo auth scheme), ``_build_diff_section`` (dry-run, env toggle, embedding, fallback), and end-to-end prompt embedding. Co-authored-by: Cursor <cursoragent@cursor.com>	2026-05-07 07:12:45 -04:00
drew	e247c10219	chore(opencode): reconcile providers and agents with agents/final-working ... Imports the source-of-truth tier selector shape (tier-qwen-small/med/ large, tier-kimi) and the explicit-only variable-propagation contract from agents/final-working, while preserving this branch's deterministic merge_drive.py / conflict_drive.py ownership model and the implementer/reviewer claim-release behavior so LLM workers do not race the host drivers. Rebuilds root opencode.json so host-launched OpenCode sees the same live HF endpoints as the devcontainer, and corrects pipeline-agent model pins to the live default CleverThis-15/Qwen3-6-35B-A3B-GGUF-UD-Q3-K-XL after CleverThis-8 was decommissioned. Drops the stale single tier-qwen selector. Telemetry pricing keys are updated to match the new model pin. Scope is intentionally limited to provider/model routing and agent- definition reconciliation; the Tier 2 deterministic dispatchers and their telemetry land in a separate commit. Co-authored-by: Cursor <cursoragent@cursor.com>	2026-05-06 22:41:41 -04:00
brent.edwards	50458d1c9f	ci(opencode.json): change based on Luis's comments	2026-03-05 23:39:16 +00:00
brent.edwards	d4acd05dbf	ci(opencode.json): add file from Luis's suggestions ... https://matrix.to/#/!ZuWYQzDEGWoZeNbfFB:qoto.org/$sLRMR8jNmeXw6FGpwqwG_Kp9PVus4SwlApmCtboYetk?via=qoto.org&via=matrix.org	2026-03-05 23:18:08 +00:00