oh-my-opencode 4.12.0 → 4.13.0

package/dist/skills/ultimate-browsing/scripts/tests/test_cookie_domain_filter.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import shutil
+import sqlite3
+import sys
+import tempfile
+import unittest
+from collections.abc import Callable
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from extract_cookies import extract_cookies  # noqa: E402
+
+
+def _make_chromium_db(path: Path, rows: list[tuple[str, bytes, str]]) -> None:
+    conn = sqlite3.connect(str(path))
+    conn.execute(
+        "CREATE TABLE cookies (name TEXT, encrypted_value BLOB, host_key TEXT, path TEXT, "
+        "expires_utc INTEGER, is_secure INTEGER, is_httponly INTEGER, samesite INTEGER)"
+    )
+    conn.executemany(
+        "INSERT INTO cookies VALUES (?,?,?,?,?,?,?,?)",
+        [
+            (name, value, host, "/", 13_300_000_000_000_000, 1, 1, 1)
+            for name, value, host in rows
+        ],
+    )
+    conn.commit()
+    conn.close()
+
+
+def _make_firefox_db(path: Path, rows: list[tuple[str, str, str]]) -> None:
+    conn = sqlite3.connect(str(path))
+    conn.execute(
+        "CREATE TABLE moz_cookies (name TEXT, value TEXT, host TEXT, path TEXT, "
+        "expiry INTEGER, isSecure INTEGER, isHttpOnly INTEGER, sameSite INTEGER)"
+    )
+    conn.executemany(
+        "INSERT INTO moz_cookies VALUES (?,?,?,?,?,?,?,?)",
+        [
+            (name, value, host, "/", 9999999999, 1, 1, 1)
+            for name, value, host in rows
+        ],
+    )
+    conn.commit()
+    conn.close()
+
+
+class DomainFilter(unittest.TestCase):
+    def _base_with_db(self, rel: str, make: Callable[[Path], None]) -> Path:
+        base = Path(tempfile.mkdtemp())
+        self.addCleanup(lambda: shutil.rmtree(str(base), ignore_errors=True))
+        db = base / rel
+        db.parent.mkdir(parents=True)
+        make(db)
+        return base
+
+    def test_chromium_does_not_overmatch_suffix_text(self) -> None:
+        base = self._base_with_db(
+            "Google/Chrome/User Data/Default/Cookies",
+            lambda p: _make_chromium_db(
+                p,
+                [
+                    ("exact", b"exact-value", "example.com"),
+                    ("sub", b"sub-value", ".login.example.com"),
+                    ("near", b"near-value", ".example.com"),
+                ],
+            ),
+        )
+
+        near = extract_cookies(
+            "chrome", ["ample.com"], platform="win32",
+            keyring_reader=lambda _s: b"k" * 32, base_override=base,
+        )
+        exact = extract_cookies(
+            "chrome", ["example.com"], platform="win32",
+            keyring_reader=lambda _s: b"k" * 32, base_override=base,
+        )
+
+        self.assertEqual(near, [])
+        self.assertEqual({cookie["name"] for cookie in exact}, {"exact", "near", "sub"})
+
+    def test_firefox_does_not_overmatch_suffix_text(self) -> None:
+        base = self._base_with_db(
+            "Firefox/Profiles/abc.default/cookies.sqlite",
+            lambda p: _make_firefox_db(
+                p,
+                [
+                    ("exact", "exact-value", "example.com"),
+                    ("sub", "sub-value", ".login.example.com"),
+                    ("near", "near-value", ".example.com"),
+                ],
+            ),
+        )
+
+        near = extract_cookies(
+            "firefox", ["ample.com"], platform="darwin", base_override=base,
+        )
+        exact = extract_cookies(
+            "firefox", ["example.com"], platform="darwin", base_override=base,
+        )
+
+        self.assertEqual(near, [])
+        self.assertEqual({cookie["name"] for cookie in exact}, {"exact", "near", "sub"})
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)

package/dist/skills/ultimate-browsing/scripts/tests/test_extract_cookies.py

@@ -0,0 +1,245 @@
+#!/usr/bin/env python3
+"""Synthetic-fixture tests for cross-platform cookie extraction (no live browser)."""
+from __future__ import annotations
+
+import shutil
+import sqlite3
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+from typing import Callable
+from unittest.mock import patch
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from cookie_crypto import decrypt_chromium_value, derive_key  # noqa: E402
+from cookie_paths import UnsupportedPlatform, resolve_cookie_db  # noqa: E402
+from extract_cookies import extract_cookies, inject_cookies, write_cookie_file  # noqa: E402
+
+
+def _make_chromium_db(path: Path, name: str, encrypted_value: bytes, host: str) -> None:
+    conn = sqlite3.connect(str(path))
+    conn.execute(
+        "CREATE TABLE cookies (name TEXT, encrypted_value BLOB, host_key TEXT, path TEXT, "
+        "expires_utc INTEGER, is_secure INTEGER, is_httponly INTEGER, samesite INTEGER)"
+    )
+    conn.execute(
+        "INSERT INTO cookies VALUES (?,?,?,?,?,?,?,?)",
+        (name, encrypted_value, host, "/", 13_300_000_000_000_000, 1, 1, 1),
+    )
+    conn.commit()
+    conn.close()
+
+
+def _make_firefox_db(path: Path, name: str, value: str, host: str) -> None:
+    conn = sqlite3.connect(str(path))
+    conn.execute(
+        "CREATE TABLE moz_cookies (name TEXT, value TEXT, host TEXT, path TEXT, "
+        "expiry INTEGER, isSecure INTEGER, isHttpOnly INTEGER, sameSite INTEGER)"
+    )
+    conn.execute("INSERT INTO moz_cookies VALUES (?,?,?,?,?,?,?,?)", (name, value, host, "/", 9999999999, 1, 1, 1))
+    conn.commit()
+    conn.close()
+
+
+def _encrypt_cbc_v10(key: bytes, plaintext: str) -> bytes:
+    from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
+
+    data = plaintext.encode()
+    pad = 16 - (len(data) % 16)
+    padded = data + bytes([pad]) * pad
+    encryptor = Cipher(algorithms.AES128(key), modes.CBC(b" " * 16)).encryptor()
+    return b"v10" + encryptor.update(padded) + encryptor.finalize()
+
+
+def _encrypt_gcm_v10(key: bytes, plaintext: str) -> bytes:
+    from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
+
+    nonce = b"n" * 12
+    encryptor = Cipher(algorithms.AES(key), modes.GCM(nonce)).encryptor()
+    ciphertext = encryptor.update(plaintext.encode()) + encryptor.finalize()
+    return b"v10" + nonce + ciphertext + encryptor.tag
+
+
+class PathResolution(unittest.TestCase):
+    def test_macos_chromium_path(self) -> None:
+        base = Path(self.tmp())
+        target = base / "Google/Chrome/Default/Cookies"
+        target.parent.mkdir(parents=True)
+        target.write_bytes(b"")
+        self.assertEqual(resolve_cookie_db("chrome", "darwin", base_override=base), target)
+
+    def test_linux_chromium_network_path(self) -> None:
+        base = Path(self.tmp())
+        target = base / "google-chrome/Default/Network/Cookies"
+        target.parent.mkdir(parents=True)
+        target.write_bytes(b"")
+        self.assertEqual(resolve_cookie_db("chrome", "linux", base_override=base), target)
+
+    def test_windows_chromium_path(self) -> None:
+        base = Path(self.tmp())
+        target = base / "Google/Chrome/User Data/Default/Cookies"
+        target.parent.mkdir(parents=True)
+        target.write_bytes(b"")
+        self.assertEqual(resolve_cookie_db("chrome", "win32", base_override=base), target)
+
+    def test_unsupported_platform_raises(self) -> None:
+        with self.assertRaises(UnsupportedPlatform):
+            resolve_cookie_db("chrome", "sunos")
+
+    def test_unsupported_browser_raises(self) -> None:
+        with self.assertRaises(UnsupportedPlatform):
+            resolve_cookie_db("nonexistent", "darwin")
+
+    def tmp(self) -> str:
+        import tempfile
+
+        d = tempfile.mkdtemp()
+        self.addCleanup(lambda: __import__("shutil").rmtree(d, ignore_errors=True))
+        return d
+
+
+class KeyDerivation(unittest.TestCase):
+    def test_macos_iters_differ_from_linux(self) -> None:
+        secret = b"some-keychain-secret"
+        self.assertNotEqual(derive_key("darwin", secret), derive_key("linux", secret))
+        self.assertEqual(len(derive_key("darwin", secret)), 16)
+
+    def test_windows_passthrough_32_bytes(self) -> None:
+        key = b"k" * 32
+        self.assertEqual(derive_key("win32", key), key)
+
+    def test_windows_rejects_wrong_length(self) -> None:
+        with self.assertRaises(ValueError):
+            derive_key("win32", b"short")
+
+    def test_unsupported_platform_raises(self) -> None:
+        with self.assertRaises(UnsupportedPlatform):
+            derive_key("sunos", b"x")
+
+
+class Decryption(unittest.TestCase):
+    def test_macos_cbc_roundtrip(self) -> None:
+        key = derive_key("darwin", b"secret")
+        blob = _encrypt_cbc_v10(key, "session-token-123")
+        self.assertEqual(decrypt_chromium_value("darwin", key, blob), "session-token-123")
+
+    def test_windows_gcm_roundtrip(self) -> None:
+        key = b"k" * 32
+        blob = _encrypt_gcm_v10(key, "win-token-xyz")
+        self.assertEqual(decrypt_chromium_value("win32", key, blob), "win-token-xyz")
+
+
+class EndToEnd(unittest.TestCase):
+    def _base_with_db(self, rel: str, make: Callable[[Path], None]) -> Path:
+        base = Path(tempfile.mkdtemp())
+        self.addCleanup(lambda: shutil.rmtree(str(base), ignore_errors=True))
+        db = base / rel
+        db.parent.mkdir(parents=True)
+        make(db)
+        return base
+
+    def test_chromium_extract_with_injected_keyring(self) -> None:
+        key = derive_key("darwin", b"secret")
+        blob = _encrypt_cbc_v10(key, "logged-in")
+        base = self._base_with_db(
+            "Google/Chrome/Default/Cookies",
+            lambda p: _make_chromium_db(p, "SID", blob, ".youtube.com"),
+        )
+        cookies = extract_cookies(
+            "chrome", ["youtube.com"], platform="darwin",
+            keyring_reader=lambda _s: b"secret", base_override=base,
+        )
+        self.assertEqual(len(cookies), 1)
+        self.assertEqual(cookies[0]["value"], "logged-in")
+        self.assertEqual(cookies[0]["name"], "SID")
+
+    def test_firefox_extract_unencrypted(self) -> None:
+        base = self._base_with_db(
+            "Firefox/Profiles/abc.default/cookies.sqlite",
+            lambda p: _make_firefox_db(p, "auth", "plain-value", ".example.com"),
+        )
+        cookies = extract_cookies("firefox", ["example.com"], platform="darwin", base_override=base)
+        self.assertEqual(len(cookies), 1)
+        self.assertEqual(cookies[0]["value"], "plain-value")
+
+
+class SecretHandling(unittest.TestCase):
+    def test_cookie_output_file_is_owner_only(self) -> None:
+        base = Path(tempfile.mkdtemp())
+        self.addCleanup(lambda: shutil.rmtree(str(base), ignore_errors=True))
+        output = base / "cookies.json"
+
+        write_cookie_file(output, [{"name": "SID", "value": "secret"}])
+
+        self.assertEqual(output.stat().st_mode & 0o777, 0o600)
+        self.assertIn("secret", output.read_text())
+
+    def test_cookie_output_replaces_existing_file_only_after_private_temp_write(self) -> None:
+        base = Path(tempfile.mkdtemp())
+        self.addCleanup(lambda: shutil.rmtree(str(base), ignore_errors=True))
+        output = base / "cookies.json"
+        output.write_text("old\n")
+        output.chmod(0o644)
+
+        def _dump(_cookies, f, indent: int) -> None:
+            self.assertEqual(output.read_text(), "old\n")
+            self.assertEqual(output.stat().st_mode & 0o777, 0o644)
+            temp_files = list(base.glob(".cookies.json.*.tmp"))
+            self.assertEqual(len(temp_files), 1)
+            self.assertEqual(temp_files[0].stat().st_mode & 0o777, 0o600)
+            f.write('[{"name": "SID", "value": "secret"}]')
+
+        with patch("extract_cookies.json.dump", side_effect=_dump):
+            write_cookie_file(output, [{"name": "SID", "value": "secret"}])
+
+        self.assertEqual(output.stat().st_mode & 0o777, 0o600)
+        self.assertIn("secret", output.read_text())
+
+    def test_cookie_output_refuses_symlinks(self) -> None:
+        base = Path(tempfile.mkdtemp())
+        self.addCleanup(lambda: shutil.rmtree(str(base), ignore_errors=True))
+        target = base / "target.json"
+        target.write_text("{}")
+        link = base / "cookies.json"
+        link.symlink_to(target)
+
+        with self.assertRaises(ValueError):
+            write_cookie_file(link, [{"name": "SID", "value": "secret"}])
+
+    def test_cookie_output_refuses_dangling_symlinks(self) -> None:
+        base = Path(tempfile.mkdtemp())
+        self.addCleanup(lambda: shutil.rmtree(str(base), ignore_errors=True))
+        link = base / "cookies.json"
+        link.symlink_to(base / "missing.json")
+
+        with self.assertRaises(ValueError):
+            write_cookie_file(link, [{"name": "SID", "value": "secret"}])
+
+    def test_inject_cookies_sends_values_over_stdin_not_argv(self) -> None:
+        cookie = {
+            "name": "SID",
+            "value": "secret-token",
+            "domain": ".youtube.com",
+            "path": "/",
+            "expires": 9999999999,
+            "secure": True,
+            "httpOnly": True,
+            "sameSite": "Lax",
+        }
+
+        with patch("extract_cookies.subprocess.run") as run:
+            run.return_value.returncode = 0
+            run.return_value.stdout = "1"
+            run.return_value.stderr = ""
+
+            inject_cookies([cookie], 9242)
+
+        command = run.call_args.args[0]
+        self.assertNotIn("secret-token", command)
+        self.assertIn("secret-token", run.call_args.kwargs["input"])
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)

package/dist/skills/ultraresearch/ATTRIBUTION.md

@@ -0,0 +1,49 @@
+# ATTRIBUTION / NOTICE
+
+This skill (`ultraresearch`, part of `@oh-my-opencode/shared-skills`) is authored by
+the oh-my-openagent project. One design idea is adapted from a third-party project,
+credited below. No third-party source is vendored here — only the verification idea
+is adapted into this skill's prompt contract.
+
+---
+
+## 1. insane-research (fivetaku) — inspiration for the claim-ledger verification gate
+
+The non-code claim-ledger verification gate (Phase 3b: a data-flow-lock where the
+synthesis may assert a high-risk non-code claim only after it clears `>= 2 independent
+source domains + 1 counter-search + a primary source`, otherwise it is abstained to an
+unresolved/refuted annex) is inspired by the data-flow-lock verification design in
+**insane-research** by fivetaku.
+
+- Source: https://github.com/fivetaku/insane-research
+- License: MIT (declared in the project's `README.md`).
+- **What is adapted:** the IDEA only — a verification gate whose output is the sole
+  allowlist the synthesis draws from, so skipping verification leaves nothing to
+  synthesize. No insane-research code is copied or redistributed. The upstream gate is
+  a Python checker (`validate_ledger.py`); this skill translates the concept into a
+  runtime-agnostic prompt + message-text contract, because the Codex Light edition has
+  no guaranteed Python.
+
+```
+MIT License
+
+Copyright (c) 2026 fivetaku
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+```

package/dist/skills/ultraresearch/SKILL.md

@@ -51,6 +51,14 @@ The research is done when all of these hold:
 - Every claim in the deliverable cites a source or a verification artifact.
 - The session journal reconstructs what was searched, found, and expanded, wave by wave.
 
+## Run the swarm as a cooperating team
+
+Saturation research is the textbook case for a cooperating team, not isolated fire-and-forget workers: a lead one worker surfaces almost always reshapes what another should search next. So when your harness gives you real cooperating members — Codex: the `teammode` skill (`codex_app` threads); OpenCode: `team_mode` — run this swarm as a team. Fall back to the background-worker swarm below only when team mode is unavailable, or the axes are genuinely independent with no cross-pollination expected.
+
+- **One member per axis — by part, ownership, or perspective, never a job title.** Each Phase 0 axis is one member owning one concrete slice: a codebase part, a source territory, or a question lens. No two members share an angle. "Backend researcher" or "the web person" gives no real boundary and invites overlap — name what the member owns.
+- **The raise law — broadcast every lead the instant it surfaces.** Members over-communicate relentlessly: every new lead, finding, contradiction, and dead end is raised to you the moment it surfaces, never hoarded for a final dump. Through long passes they send `WORKING: <axis> - <phase>`, and `BLOCKED: <reason>` the moment progress stops, so you always know a member is alive. Too many small updates is correct here; going quiet is the only failure.
+- **You lead; expand on each raised lead.** Members raise via message text, never write session files. Journal each lead and spawn its expansion the instant it lands (Phase 2), not only when a member's final reply arrives.
+
 ## Worker ground rules
 
 Research workers (explore, librarian, browsing) differ by harness, but assume:
@@ -106,7 +114,7 @@ Append each digest the moment its worker returns, not in a batch at the end —
 
 ## Phase 1 — Saturation wave
 
-Launch every first-wave worker in a single turn, all in background. Sequential launches and "start with one and see" defeat the mode.
+Launch the entire first wave in one turn — every axis at once, as team members if you formed a team, else as background workers. Sequential launches and "start with one and see" defeat the mode.
 
 Scaling floor — more angles always justify more workers:
 
@@ -122,7 +130,7 @@ Role protocols — embed the relevant one in each spawn message; every worker ge
 
 - **Codebase (explore), 2-4 workers.** Grep with 3+ keyword variations; structural/AST search; LSP definitions and references; file-name globs; `git log --all -S '<keyword>'` and `--grep` for history including deleted code. Cross-validate hits across tools. Report absolute file paths, patterns with `file:line`, and how findings connect.
 - **Web (librarian), 3-6 workers.** At least 10 distinct websearch queries per worker, each with a different operator or angle (see Search craft); fetch the full page for every result that matters — snippets lie. Context7 with 3+ queries per known library. grep.app and `gh search code|repos|issues` for real-world usage. Official docs via sitemap discovery (`<base>/sitemap.xml`), then targeted pages.
-- **Browsing, 0-3 workers.** Pages plain fetch cannot read (WAF, dynamic rendering, login): use the browsing skill; capture screenshots when visual context matters.
+- **Browsing, 0-3 workers.** Pages plain fetch cannot read (WAF, 403, Cloudflare, dynamic rendering, login): the worker loads the `ultimate-browsing` skill and escalates through its tiers — Tier-1 insane-search engine first, then Tier-2 Chrome stealth — rather than abandoning the source. Capture screenshots when visual context matters. When one blocked territory hides many leads, fan out more browsing subagents in parallel for breadth instead of serializing one worker through them.
 - **Repo deep-dive (librarian), 0-2 workers.** Shallow-clone the most relevant repos to `${TMPDIR:-/tmp}`, pin the HEAD SHA, read core modules, follow call chains, return SHA-pinned permalinks.
 
 Example spawn (codebase axis; librarian, browsing, and repo-dive follow the same contract with their own protocol):
@@ -137,7 +145,7 @@ End your reply with the ## EXPAND tail: '- LEAD: <discovery> — WHY: <why> —
 
 ## Phase 2 — Expand until convergence
 
-This loop is what makes the mode research rather than search. Collect workers as they finish — never wait for the full wave:
+This loop is what makes the mode research rather than search. Collect returns as they land — and in team mode, act on each lead the moment a member raises it, never waiting for the full wave or a member's final reply:
 
 1. Journal the return: digest plus verbatim EXPAND markers into `wave-<N>-<kind>-<axis>.md`.
 2. Deduplicate new markers against `expansion-log.md` — every lead ever seen, not just confirmed ones, or rejected leads resurface each wave.
@@ -171,6 +179,25 @@ Reply with: the exact code, the full output, environment (OS, runtime, dependenc
 
 Journal each verdict to `verify-<slug>.md`.
 
+## Phase 3b — Lock non-code claims through a claim ledger
+
+Code settles code-shaped claims (Phase 3). Numeric, market-share, legal, dated, causal, and financial claims cannot be run — so they pass through a data-flow-lock instead (the verification idea adapted from fivetaku/insane-research): the synthesis may assert a high-risk non-code claim **only** if it cleared this gate, and the gate's output is the sole allowlist the synthesis draws from. Skip the gate and there is nothing to synthesize — the lock is self-enforcing.
+
+The claim ledger is orchestrator-owned. Workers only return verified-claim markers as message text, the same channel as EXPAND markers — never a file. As leads resolve, you record one ledger entry per asserted claim and compute its status; workers report claim candidates in their replies, and you decide.
+
+A high-risk claim clears the gate to `verified-claims` only when all hold:
+
+- **>= 2 independent source domains** corroborate it (two pages on the same domain count once).
+- **One counter-search** actively looked for a refutation and did not find a stronger one.
+- **A primary source** (the standard, filing, dataset, or first-party doc) backs it, not only secondary commentary.
+
+Anything that fails goes to an `Unresolved` (insufficient evidence) or `Refuted` (counter-search won) annex — abstention is a correct outcome, not a gap to paper over. Maintain `claim-ledger.md` with one row per claim — `claim | risk | domains | counter-search | primary? | status (verified/unresolved/refuted)` — and write the cleared rows into a `verified-claims` digest. Worker reply marker (message text, same channel as EXPAND):
+
+```
+## CLAIMS
+- CLAIM: <non-code assertion> — RISK: high|normal — SOURCES: <domain1, domain2> — COUNTER: <refutation search result> — PRIMARY: <primary source or none>
+```
+
 ## Phase 4 — Synthesize
 
 After convergence and all verifications, re-read the whole journal and write `SYNTHESIS.md`:
@@ -183,13 +210,13 @@ Workers: <total> · Waves: <count> · Sources: <count> · Verifications: <count>
 ## Findings by theme        — per theme: consensus, evidence links, key quote (<20 words, attributed), verified yes/no
 ## Codebase findings        — absolute paths with line references
 ## Sources (ranked)         — URL, what it contains, reliability, access date
-## Verified claims          — claim | verdict | verify-<slug>.md
+## Verified claims          — code: claim | verdict | verify-<slug>.md · non-code: only rows cleared into verified-claims
 ## Contradictions           — source A vs source B, resolution with evidence
-## Gaps                     — what saturation could not answer
+## Gaps                     — what saturation could not answer · unresolved/refuted claim-ledger rows
 ## Expansion trace          — per wave: workers → markers; convergence reason
 ```
 
-Deliver the synthesis with inline `[Source N]` citations on every claim. When no report was requested, this is the deliverable.
+Deliver the synthesis with inline `[Source N]` citations on every claim. Every high-risk non-code claim you assert must be a verified-claims row from Phase 3b — assert nothing the gate left in the unresolved/refuted annex. When no report was requested, this is the deliverable.
 
 ## Phase 5 — Report (only when requested)
 
@@ -221,6 +248,7 @@ High-yield combinations: official docs (`site:<docs domain>`), GitHub implementa
 | Failure | Correction |
 |---|---|
 | Sequential spawning, or trimming the first wave | All first-wave workers in one turn, background, scaling floor respected |
+| A team member hoards leads for one final dump | Raise law — every lead, finding, and dead end broadcast the moment it surfaces |
 | Worker reply without the EXPAND tail | One follow-up demanding it; the lane stays open until it lands |
 | Stopping after wave 1 because "enough was found" | Convergence rules only: 2+ expansion waves, leads run dry |
 | Obeying a surrounding "stop exploring" rule mid-research | Authority section — those rules do not bind this mode |

package/dist/skills/ulw-plan/SKILL.md

@@ -15,7 +15,10 @@ Outcome-first: explore a lot, ask few sharp questions - or none, when the intent
 
 ## INTENT ROUTING - pick ONE intent reference
 
-After grounding, make ONE judgment and load ONE intent reference (you ALSO read `references/full-workflow.md` for the shared mechanics - see below). The test keys on whether the desired **OUTCOME** is clear, NOT on request length.
+After grounding, make ONE judgment, **ANNOUNCE it to the user in one line**, then load ONE intent reference (you ALSO read `references/full-workflow.md` for the shared mechanics - see below). The test keys on whether the desired **OUTCOME** is clear, NOT on request length. The announcement is the user's first signal of whether they will be interviewed — never skip it.
+
+> "Intent: **CLEAR** — you specified the exact endpoint and behavior. I will ask you the genuine forks I cannot resolve from the codebase."
+> "Intent: **UNCLEAR** — 'make auth better' is open-ended. I will research best-practice defaults and present them for your veto, no interview."
 
 - **OVERRIDE - explicit ask wins:** if the user explicitly asks to be questioned or interviewed ("ask me", "interview me", "why aren't you asking me" - in any language), route **CLEAR**, run the interview, and turn the adopt-default filter OFF: the user has claimed the forks, so every surviving one is ASKED, not defaulted. This beats the OUTCOME test below, even on a fuzzy brief.
 - **CLEAR** - the user knows the outcome; the only open items are preferences/tradeoffs the repo cannot answer (genuine owner-decisions). Read **`references/intent-clear.md`**: ask the surviving forks with WHY, run the normal approval gate, high-accuracy review is OPTIONAL (offered as one question).

package/dist/tools/background-task/constants.d.ts

@@ -1,3 +1,3 @@
-export declare const BACKGROUND_TASK_DESCRIPTION = "Run agent task in background. Returns a background task ID (`bg_...`) immediately; notifies on completion.\n\nUse `background_output` to get results. Prompts MUST be in English.";
+export declare const BACKGROUND_TASK_DESCRIPTION = "Run agent task in background. Returns a background task ID (`bg_...`) immediately and notifies on completion.\n\nDo NOT poll for results. The system delivers a <system-reminder> when the task finishes.\n\nPrompts MUST be in English.";
 export declare const BACKGROUND_OUTPUT_DESCRIPTION = "Get output from background task. Use full_session=true to fetch session messages with filters. System notifies on completion, so block=true rarely needed. - Timeout values are in milliseconds (ms), NOT seconds.\n\nIMPORTANT: ONLY call this tool AFTER receiving a <system-reminder> notification for the task. Do NOT call immediately after launching a background task - wait for the notification first.";
 export declare const BACKGROUND_CANCEL_DESCRIPTION = "Cancel running background task(s). Use all=true to cancel ALL before final answer.";

package/dist/tools/delegate-task/sync-task-deps.d.ts

@@ -1,11 +1,13 @@
+import { isProviderExhaustionFallbackEligible } from "@oh-my-opencode/model-core";
 import { createSyncSession } from "./sync-session-creator";
 import { sendSyncPrompt } from "./sync-prompt-sender";
 import { pollSyncSession } from "./sync-session-poller";
 import { fetchSyncResult } from "./sync-result-fetcher";
-export declare const syncTaskDeps: {
-    createSyncSession: typeof createSyncSession;
-    sendSyncPrompt: typeof sendSyncPrompt;
-    pollSyncSession: typeof pollSyncSession;
-    fetchSyncResult: typeof fetchSyncResult;
+export type SyncTaskDeps = {
+    readonly createSyncSession: typeof createSyncSession;
+    readonly sendSyncPrompt: typeof sendSyncPrompt;
+    readonly pollSyncSession: typeof pollSyncSession;
+    readonly fetchSyncResult: typeof fetchSyncResult;
+    readonly isProviderExhaustionFallbackEligible?: typeof isProviderExhaustionFallbackEligible;
 };
-export type SyncTaskDeps = typeof syncTaskDeps;
+export declare const syncTaskDeps: SyncTaskDeps;

package/dist/tools/skill-mcp/tools.d.ts

@@ -3,7 +3,7 @@ import type { SkillMcpManager } from "../../features/skill-mcp-manager";
 import type { LoadedSkill } from "../../features/opencode-skill-loader/types";
 interface SkillMcpToolOptions {
     manager: SkillMcpManager;
-    getLoadedSkills: () => LoadedSkill[];
+    getLoadedSkills: () => LoadedSkill[] | Promise<LoadedSkill[]>;
     getSessionID?: () => string | undefined;
 }
 export declare function applyGrepFilter(output: string, pattern: string | undefined): string;

package/dist/tui.js

@@ -4163,6 +4163,14 @@ var init_ast_grep = __esm(() => {
 
 // packages/utils/src/codegraph/env.ts
 var init_env = () => {};
+
+// packages/utils/src/codegraph/workspace.ts
+var init_workspace = () => {};
+
+// packages/utils/src/codegraph/guidance.ts
+var init_guidance = __esm(() => {
+  init_workspace();
+});
 // packages/utils/src/codegraph/manifest.ts
 var init_manifest = () => {};
 
@@ -4183,12 +4191,10 @@ var init_resolve2 = __esm(() => {
   requireFromHere = createRequire(import.meta.url);
 });
 
-// packages/utils/src/codegraph/workspace.ts
-var init_workspace = () => {};
-
 // packages/utils/src/codegraph/index.ts
 var init_codegraph = __esm(() => {
   init_env();
+  init_guidance();
   init_provision();
   init_resolve2();
   init_workspace();
@@ -20062,6 +20068,7 @@ var CodegraphConfigSchema;
 var init_codegraph2 = __esm(() => {
   init_zod();
   CodegraphConfigSchema = exports_external.object({
+    auto_init: exports_external.boolean().default(true),
     auto_provision: exports_external.boolean().default(true),
     enabled: exports_external.boolean().default(true),
     install_dir: exports_external.string().optional(),
@@ -20392,7 +20399,8 @@ var init_runtime_fallback = __esm(() => {
     max_fallback_attempts: exports_external.number().min(1).max(20).optional(),
     cooldown_seconds: exports_external.number().min(0).optional(),
     timeout_seconds: exports_external.number().min(0).optional(),
-    notify_on_fallback: exports_external.boolean().optional()
+    notify_on_fallback: exports_external.boolean().optional(),
+    restore_primary_after_cooldown: exports_external.boolean().optional()
   });
 });
 
@@ -21462,6 +21470,11 @@ var init_runtime_fallback_error_classifier = __esm(() => {
   init_runtime_fallback_error_shape();
 });
 
+// packages/model-core/src/provider-exhaustion-fallback-policy.ts
+var init_provider_exhaustion_fallback_policy = __esm(() => {
+  init_runtime_fallback_error_classifier();
+});
+
 // packages/model-core/src/runtime-fallback-model.ts
 var init_runtime_fallback_model = __esm(() => {
   init_model_string_parser();
@@ -21890,6 +21903,7 @@ var init_src3 = __esm(() => {
   init_runtime_fallback_auto_retry_signal();
   init_runtime_fallback_error_classifier();
   init_runtime_fallback_error_shape();
+  init_provider_exhaustion_fallback_policy();
   init_runtime_fallback_model();
   init_model_capabilities2();
   init_context_limit_resolver();