oh-my-opencode 4.12.0 → 4.13.0

package/packages/omo-codex/plugin/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/packages/omo-codex/plugin/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/packages/omo-codex/plugin/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/packages/omo-codex/plugin/skills/ultraresearch/SKILL.md

@@ -49,6 +49,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:
@@ -104,7 +112,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:
 
@@ -120,7 +128,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):
@@ -135,7 +143,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.
@@ -169,6 +177,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`:
@@ -181,13 +208,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)
 
@@ -219,6 +246,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/packages/omo-codex/plugin/skills/ulw-loop/references/full-workflow.md

@@ -26,7 +26,7 @@ Run each criterion's real-surface proof yourself through the channel that faithf
 Auxiliary surfaces (CLI stdout / DB state diff / parsed config dump) are first-class evidence for CLI- or data-shaped criteria; use a channel scenario when the behavior is user-facing. `--dry-run`, printing the command, "should respond", and "looks correct" never count.
 
 ## Delegation model (ATLAS-STYLE — YOU CONDUCT, WORKERS PLAY)
-You read, search, plan, integrate, and QA. You DELEGATE every code edit, test write, bug fix, and QA execution to a right-sized `multi_agent_v1.spawn_agent` worker, then verify what comes back. Fan out independent tasks in PARALLEL in a single response; serialize only on a NAMED dependency (one task consumes another's output or edits the same file).
+You read, search, plan, integrate, and QA. You DELEGATE every code edit, test write, bug fix, and QA execution to a right-sized `multi_agent_v1.spawn_agent` worker, then verify what comes back. Fan out independent tasks in PARALLEL in one response; serialize only on a NAMED dependency (one task consumes another's output or edits the same file).
 
 Size each worker to the task. Put the intended role, rigor level, and specialty inside the worker `message`.
 
@@ -42,7 +42,7 @@ Size each worker to the task. Put the intended role, rigor level, and specialty
 
 For reviewer work, use a self-contained reviewer assignment, tight scope, and explicit verification in `message`. Never spawn a context-only child for review.
 
-Every worker message MUST carry: goal + exact files in scope; the PIN + failing-first proof required before production code (Per-Criterion Cycle step 3); constraints + project rules; the verification commands to run; the ONE Manual-QA channel and the exact evidence artifact to capture; for git-tracked edits, require `git-master` plus repository-wide and touched-path commit history inspection before commit. Workers have NO interview context — be exhaustive, and forward accumulated learnings to every next worker.
+Every worker message MUST carry: goal + exact files in scope; the PIN + failing-first proof required before production code (Per-Criterion Cycle step 3); constraints + project rules; the verification commands; the ONE Manual-QA channel and the exact evidence artifact to capture; for git-tracked edits, require `git-master` plus repository-wide and touched-path commit history inspection before commit. Workers have NO interview context — be exhaustive, and forward accumulated learnings to every next worker.
 
 Codex subagent reliability:
 - Start every `multi_agent_v1.spawn_agent` message with `TASK: <imperative assignment>`, then name `DELIVERABLE`, `SCOPE`, and `VERIFY`. State that it is an executable assignment, not a context handoff.
@@ -58,14 +58,14 @@ Codex subagent reliability:
 - `.omo/ulw-loop/goals.json`: goals with embedded `successCriteria` per goal.
 - `.omo/ulw-loop/ledger.jsonl`: append-only audit trail.
 - Read artifacts before resuming, steering, or checkpointing.
-- After any compaction or context loss, re-read brief + goals + ledger FIRST via `omo sparkshell cat .omo/ulw-loop/ledger.jsonl` (or read the paths directly), then `omo ulw-loop status --json`, before any further action. Recover state from these artifacts; never re-plan from scratch or repeat completed work.
+- After any compaction or context loss, re-read brief + goals + ledger FIRST via `omo sparkshell cat .omo/ulw-loop/ledger.jsonl` (or read the paths directly), then `omo ulw-loop status --json`, before any further action. Recover state from these artifacts; never re-plan from scratch or repeat completed work (re-hypothesizing inside a research goal is not a re-plan).
 - Never invent state outside `.omo/ulw-loop` artifacts or `omo ulw-loop status --json`.
 
 ## Bootstrap
 Do all three steps before execution. No edits, goal tools, or checkpointing before bootstrap completes.
 
 ### 1. Create goals from the brief
-Resolve the CLI before the first command. If `omo` is absent from PATH or does not support `ulw-loop`, use the stable local installer bin or cached Codex component CLI. This is the same ulw-loop CLI, so PATH absence is not a blocker. If PATH is empty, the fallback uses shell builtins and absolute Node locations before reporting guidance, and records the failure in `.omo/ulw-loop/bootstrap-notepad.md`.
+Resolve the CLI before the first command. If `omo` is absent from PATH or lacks `ulw-loop`, use the stable local installer bin or cached Codex component CLI — same CLI, so PATH absence is not a blocker. If PATH is empty, the fallback uses shell builtins and absolute Node locations before reporting guidance, recording the failure in `.omo/ulw-loop/bootstrap-notepad.md`.
 ```sh
 CODEX_HOME="${CODEX_HOME:-$HOME/.codex}"
 ULW_LOOP_NODE="$(command -v node 2>/dev/null || true)"
@@ -117,10 +117,11 @@ Write state through the CLI path. Do not hand-edit state files.
 
 ### 2. Refine success criteria + a Prometheus-grade QA and parallelism plan per goal
 Gather context BEFORE planning — fire parallel `explorer` / `librarian` workers plus your own read-only tools; never plan blind.
-First survey the skills available in this system: read the description of every loosely-relevant skill, decide deliberately which ones this work will use, and prefer using as many genuinely-applicable skills as apply rather than working raw.
-Then run tier triage per goal and record it with an `annotate_ledger` steering entry. Default is LIGHT — a narrow change inside existing layers. Take HEAVY only on a fact you can point to: a new module / abstraction / domain model; auth, security, or session; an external integration; a DB schema or migration; concurrency, transaction boundaries, or cache invalidation; a cross-domain refactor; or the user signaled care or demanded review. When unsure, take HEAVY; upgrade the moment a HEAVY fact surfaces and never downgrade mid-run.
+First survey available skills: read every loosely-relevant skill's description, deliberately choose which this work uses, and prefer applying genuinely-relevant skills over working raw.
+Then run tier triage per goal — rigor (LIGHT/HEAVY below) and shape (`delivery` default, or `research` when the deliverable is a cited answer, not an artifact) — and record both in an `annotate_ledger` steering entry. Default is LIGHT — a narrow change inside existing layers. Take HEAVY only on a fact you can point to: a new module / abstraction / domain model; auth, security, or session; an external integration; a DB schema or migration; concurrency, transaction boundaries, or cache invalidation; a cross-domain refactor; or the user signaled care or demanded review. When unsure, take HEAVY; upgrade the moment a HEAVY fact surfaces, never downgrade mid-run.
 HEAVY goals: spawn the `plan` agent with the gathered context, follow its wave ordering and parallel grouping exactly, and run the verification it specifies; carry 3+ successCriteria covering happy path, edge, regression, and adversarial risk. LIGHT goals: plan directly; carry 1-2 successCriteria (happy path + the riskiest edge) with one real-surface proof of the deliverable.
-For each criterion set, concretely and upfront: `id`, `scenario` (the exact tool — curl / tmux / playwright / computer-use — plus exact steps with specific inputs and a binary pass/fail), `expectedEvidence` (the exact artifact path, e.g. `.omo/ulw-loop/evidence/<goal>-<criterion>.<ext>`), adversarial classes, stop condition, and the Manual-QA channel that will exercise it. Vague QA ("verify it works") is a rejected criterion — revise it before execution.
+Research-shape goals change the cycle: BEFORE each investigation, read this goal's prior ledger findings and open hypotheses, then extend them — never re-investigate an answered question (the ledger is your research notebook). Record findings via `annotate_ledger` with their source (`file:line`, command output, doc URL) as `--evidence`. Track hypotheses as `HYPOTHESIS[id]: <claim> | status: open`, flipped to `confirmed`/`refuted` only on an observed source. A research criterion passes on a cited answer — skip QA-channel, cleanup, and commit, but keep source-observability (never "looks correct"). Keep hypotheses inside the user's stated question; a scope-widening one is an `add_subgoal` proposal you surface, never silent creep. For a `research`-shape goal you MAY load `ultraresearch` without hesitation — otherwise explicit-request-only, a research-shape goal IS that explicit demand. Research-only: never for a `delivery` goal. It composes with the librarian routing above — `ultraresearch` for saturation (many parallel sources, recursive expansion), a single `librarian` for one lookup.
+For each criterion set, concretely and upfront: `id`, `scenario` (the exact tool — curl / tmux / playwright / computer-use — plus steps with specific inputs and a binary pass/fail), `expectedEvidence` (the artifact path, e.g. `.omo/ulw-loop/evidence/<goal>-<criterion>.<ext>`), adversarial classes, stop condition, and the Manual-QA channel that exercises it. Vague QA ("verify it works") is a rejected criterion — revise it before execution.
 A criterion's adversarial classes are the ultraqa classes a fact about the change triggers: malformed input, prompt injection, cancel/resume, stale state, dirty worktree, hung or long commands, flaky tests, misleading success output, repeated interruptions. Record untriggered classes as not-applicable in one line.
 Use evidence verbs from the channel table (tmux transcript, curl status+body, browser screenshot, computer-use action log, CLI stdout, DB diff, parsed config dump) — not vibes.
 

package/packages/omo-codex/plugin/test/aggregate-build.test.mjs

@@ -17,9 +17,10 @@ test("#given aggregate plugin build script #when inspected #then generated asset
 	// then
 	assert.equal(
 		buildScript,
-		"node scripts/sync-version.mjs && node scripts/sync-hook-status-messages.mjs && node scripts/build-bundled-mcp-runtimes.mjs && node scripts/sync-skills.mjs && node scripts/build-components.mjs",
+		"node scripts/sync-version.mjs && node scripts/sync-hook-status-messages.mjs && node scripts/build-bundled-mcp-runtimes.mjs && node scripts/materialize-shared-upstreams.mjs --strict && node scripts/sync-skills.mjs && node scripts/build-components.mjs",
 	);
 	assert.match(buildScript, /^node scripts\/sync-version\.mjs &&/);
+	assert.match(buildScript, /materialize-shared-upstreams\.mjs --strict && node scripts\/sync-skills\.mjs/);
 	assert.equal(testScript, "node --test test/*.test.mjs");
 	assert(packageJson.workspaces.includes("components/ultrawork"));
 	assert.doesNotMatch(packageText, /\bpython3?\b|ultrawork-detector\.py/);

package/packages/omo-codex/plugin/test/aggregate-hooks.test.mjs

@@ -30,9 +30,11 @@ test("#given isolated components #when hooks are inspected #then commands stay i
 	const componentMarkers = [
 		"components/comment-checker/dist/cli.js",
 		"components/lsp/dist/cli.js",
+		"components/codegraph/dist/cli.js",
 		"components/rules/dist/cli.js",
 		"components/start-work-continuation/dist/cli.js",
 		"components/telemetry/dist/cli.js",
+		"components/teammode/dist/cli.js",
 		"components/ulw-loop/dist/cli.js",
 		"components/ultrawork/dist/cli.js",
 		"scripts/auto-update.mjs",
@@ -179,6 +181,40 @@ test("#given aggregate SessionStart hooks #when inspected #then LazyCodex auto-u
 	assert(sessionStartCommands.some((command) => command.includes("scripts/auto-update.mjs")));
 });
 
+test("#given aggregate PostToolUse hooks #when inspected #then CodeGraph init guidance is registered for CodeGraph tools", async () => {
+	// given
+	const commandHooks = await readAggregateCommandHooks();
+
+	// when
+	const codegraphPostToolUseHooks = commandHooks.filter(
+		(hook) =>
+			hook.eventName === "PostToolUse" &&
+			hook.handler.command === 'node "${PLUGIN_ROOT}/components/codegraph/dist/cli.js" hook post-tool-use',
+	);
+
+	// then
+	assert.equal(codegraphPostToolUseHooks.length, 1);
+	assert.equal(codegraphPostToolUseHooks[0]?.matcher, "^(codegraph[._].*|mcp__codegraph__.*)$");
+	assert.equal(codegraphPostToolUseHooks[0]?.handler.statusMessage, "(OmO) Checking CodeGraph Init Guidance");
+});
+
+test("#given aggregate PostToolUse hooks #when inspected #then thread title hygiene is registered for created Codex threads", async () => {
+	// given
+	const commandHooks = await readAggregateCommandHooks();
+
+	// when
+	const threadTitleHooks = commandHooks.filter(
+		(hook) =>
+			hook.eventName === "PostToolUse" &&
+			hook.handler.command === 'node "${PLUGIN_ROOT}/components/teammode/dist/cli.js" hook post-tool-use',
+	);
+
+	// then
+	assert.equal(threadTitleHooks.length, 1);
+	assert.equal(threadTitleHooks[0]?.matcher, "^(create_thread|codex_app\\.create_thread)$");
+	assert.equal(threadTitleHooks[0]?.handler.statusMessage, "(OmO) Checking Thread Title Hygiene");
+});
+
 test("#given aggregate plugin packaging #when inspected #then hooks and compatibility sentinels stay Python-free", async () => {
 	// given
 	const hooksText = (await Promise.all((await readAggregateHookManifests()).map(({ source }) => readFile(join(root, source), "utf8")))).join("\n");

package/packages/omo-codex/plugin/test/aggregate-manifest.test.mjs

@@ -17,7 +17,7 @@ test("#given aggregate plugin manifest #when inspected #then it owns the omo nam
 	// then
 	assert.equal(manifest.name, "omo");
 	assert(Array.isArray(hookPaths));
-	assert.equal(hookPaths.length, 19);
+	assert.equal(hookPaths.length, 21);
 	assert(hookPaths.every((hookPath) => typeof hookPath === "string" && hookPath.startsWith("./hooks/")));
 	assert(!hookPaths.includes("./hooks/hooks.json"));
 	assert.equal(skillsPath, "./skills/");
@@ -60,6 +60,7 @@ test("#given component directories #when scanned #then only intentional resource
 		"lsp",
 		"rules",
 		"start-work-continuation",
+		"teammode",
 		"telemetry",
 		"ultrawork",
 		"ulw-loop",