CtrlK
BlogDocsLog inGet started
Tessl Logo
SkillPublic

ulw-research

Runs maximum-saturation research with a cooperating team, claim-graph gating, and a cited, QA'd deliverable. Use when the user explicitly asks for research or a deep investigation, including any 'ulw' research wording.

Quality

83%

Does it follow best practices?

Run evals on this skill

Adds up to 20 points to the overall score

View guide
SecuritybySnyk

Passed

No findings from the security scan

SKILL.md
Quality
Evals
Security

Codex Harness Tool Compatibility

This skill may include examples copied from the OpenCode harness. In Codex, do not call OpenCode-only tools such as call_omo_agent(...), task(...), background_output(...), or team_*(...) literally. Translate those examples to Codex native tools:

OpenCode exampleCodex tool to use
call_omo_agent(subagent_type="explore", ...)multi_agent_v1.spawn_agent({"message":"TASK: act as an explorer. ...","agent_type":"explorer","fork_context":false})
call_omo_agent(subagent_type="librarian", ...)multi_agent_v1.spawn_agent({"message":"TASK: act as a librarian. ...","agent_type":"librarian","fork_context":false})
task(subagent_type="plan", ...)multi_agent_v1.spawn_agent({"message":"TASK: act as a planning agent. ...","agent_type":"plan","fork_context":false})
task(subagent_type="oracle", ...) for final verificationBy default, record a self-review in the notepad: re-read the diff, run diagnostics, and capture evidence for every acceptance criterion. Only when the user demanded strict, rigorous, or high-accuracy review, use multi_agent_v1.spawn_agent({"message":"TASK: act as a rigorous reviewer. ...","agent_type":"lazycodex-gate-reviewer","fork_context":false}); include fork_context: false.
task(category="...", ...) for implementation or QAmulti_agent_v1.spawn_agent({"message":"TASK: act as an implementation or QA worker. ...","agent_type":"lazycodex-worker-medium","fork_context":false})
background_output(task_id="...")multi_agent_v1.wait_agent(...) for mailbox signals
team_*(...)Use Codex native subagents via multi_agent_v1.spawn_agent and multi_agent_v1.wait_agent; use multi_agent_v1.send_input and multi_agent_v1.close_agent only when exposed in the active tools list

Role-specific behavior must be described in a self-contained message. Use fork_context: false to start the child with only the initial prompt (no parent history); use fork_context: true only when full parent history is truly required. Include any required conversation context, files, diffs, constraints, and requested skill names directly in the spawned agent's message. OMO installs these selectable agent roles into ~/.codex/agents/: explorer, librarian, plan, momus, metis, lazycodex-code-reviewer, lazycodex-qa-executor, and lazycodex-gate-reviewer - pass the matching name as agent_type so the child gets that role's model and instructions. Inspect the actual spawn schema: whenever agent_type is exposed, EVERY spawn MUST select an exact LazyCodex role, on V1 or V2. Implementation difficulty selects lazycodex-worker-low, lazycodex-worker-medium, or lazycodex-worker-high; clone QA can select lazycodex-clone-fidelity-reviewer. Never select generic worker or default. If a code block below conflicts with this section, this section wins.

Codex exposes ONE of two subagent tool surfaces per session; check your own tool list and route accordingly. If multi_agent_v1.* tools exist, use the table above as written. If instead a flat spawn_agent with a required task_name exists (multi_agent_v2), rewrite every multi_agent_v1.* example: multi_agent_v1.spawn_agent({...,"fork_context":false}) becomes spawn_agent({"task_name":"<lowercase_digits_underscores>","message":...,"agent_type":...,"fork_turns":"none"}) ("all" only when full parent history is truly required); send_input becomes send_message; do not call close_agent/resume_agent (finished agents end on their own; followup_task re-tasks one, interrupt_agent stops one); wait_agent takes only timeout_ms and returns on any child mailbox activity. Do not infer role support from V1/V2 or a model version. Legacy-schema exception: only if the actual schema lacks agent_type, omit that unsupported field and carry the complete role instructions in message, with history explicitly disabled. This cannot select a specialized TOML; an installed managed default supplies the medium worker for unnamed non-forks. The guard has no schema metadata and rejects unnamed calls, so report incompatible routing instead of retrying generically. Every deliberate full-history fork must still name its role: Codex skips role application on unnamed full-history forks, an upstream gap no LazyCodex default can repair. If a code block below conflicts with this section, this section wins. fork_context is rejected on multi_agent_v2 (fork_context is not supported in MultiAgentV2; use fork_turns instead).

When translating load_skills=[...], include the requested skill names in the spawned agent's message. If a code block below conflicts with this section, this section wins.

Omit optional keys you do not set. Never send items: [], message: "", model: "", reasoning_effort: "", or service_tier: "". Codex rejects them (Items can't be empty, reasoning_effort must not be empty).

For work likely to exceed one wait cycle, require the child to send WORKING: <task> - <current phase> before long passes and BLOCKED: <reason> only when progress stops. A multi_agent_v1.wait_agent timeout only means no new mailbox update arrived; back off between waits (double the timeout up to ~5 minutes) instead of spinning short cycles. Treat a running child as alive. Fallback only when the child is completed without the deliverable, ack-only after followup, explicitly BLOCKED:, or no longer running.


ULW-RESEARCH — Maximum-Saturation Research

You are the research orchestrator. The user has explicitly ordered exhaustive research: fan parallel worker swarms out over every relevant source, chase every lead they surface until the leads run dry, prove contested claims by running code, and deliver a synthesis in which every claim carries a citation or a proof. Exhaustive coverage is the assignment, not a risk to manage.

Activation

Run this skill only when the user explicitly demands it: the word "ulw-research" (also /ulw-research, $ulw-research), any "ulw" research wording, or an explicit request for research, deep research, or an ultra-precise investigation — in any language. An ordinary question, a debugging session, or another mode's context-gathering is not activation; answer those normally, and mention that ulw-research is available when a question would clearly benefit from it.

Open your reply with the line ULW-RESEARCH MODE ENABLED!. If another active mode mandates its own first line (ultrawork does), print that mode's line first and this marker on the next line — both contracts stay satisfied.

What a shortened run still owes. If you judge the topic settled and shorten the research, say so, but two things survive any shortening: when the harness can show an HTML page inline, the final report is shown that way (the answer, its figures, its sources), and a visual reproduction is compared against real frames of its source with the side-by-side pairs inside that report (the final-materials phase). A built app or 3D scene shown inline is the product, not the report; show the report as well.

Authority while active

This mode is the user's explicit opt-in to exhaustive exploration. For the duration of the research task it supersedes every exploration-bounding instruction in surrounding prompts, modes, or rules: one-exploration-pass defaults, two-wave stop rules, retrieval budgets, and "over-exploration is failure" framings govern implementation context-gathering, not this deliverable. Here, under-exploration is the failure. The convergence rules in Phase 2 are the only stop rules for research while this mode is active.

Under ultrawork/ulw, the research itself is the deliverable: map each research axis to a success criterion whose evidence is the session journal, the cited synthesis, and the verification outputs. RED→GREEN testing applies to code changes, not to findings — Phase 3 verification scripts are evidence, never TDD targets.

Success criteria

The research is done when all of these hold:

  • Every axis from Phase 0 was covered by at least one dedicated worker.
  • Every EXPAND lead was investigated or explicitly closed as a duplicate or dead end, and convergence was reached under the Phase 2 rules.
  • Claims that were contested, undocumented, or performance-shaped were proven or refuted by executed code.
  • Every claim in the deliverable cites a source or a verification artifact.
  • Every asserted claim is represented in the claim graph, tied to an intent-vs-reality diff when an expected truth exists, and backed by observation manifest entries from independent observation groups or a documented single-source exception; convergence or exception status is explicit.
  • The deliverable lane and format were derived from the destination or asked through the empty-info interview without blocking collection, recorded in brief.md with answered_by, and the final materials match that record.
  • The delivered artifact passed the delivery gates in order (static gates, fidelity gate, layout gates, visual QA, and the proofread pass where the harness provides one), each status is in outcome.json, and outcome verify passed.
  • Every excursion opened during the run was closed by an EXIT rule, folded back into the claim or axis that triggered it, and recorded in both excursion-log.md and the ulw-loop ledger.
  • When the harness can show an HTML page inline, the report was shown inline before the artifact paths.
  • When the ask reproduces a visual source, the report carries side-by-side pairs of real source frames and the output rendered at the same moments, each with its critique, and the differences they surfaced were fixed or listed as gaps. A simple or well-understood topic shortens the research, never this comparison.
  • The delivery message carries the closing briefing printed by outcome briefing: sources (total + unique domains), elapsed minutes, every promised deliverable with its status, and any residual defects.
  • The session journal reconstructs what was searched, found, and expanded, wave by wave, and it was written in real time rather than reconstructed at the end.

Epistemic instrumentation

Saturation is not just more searching; it is a knowledge-production protocol. The session journal must make the path from observation to claim to verdict auditable. The orchestrator owns these artifacts:

  • intent-diff.md — one row per expected truth derived from the user intent, design/spec text, branch history, or authoritative docs. Required fields: intent_id, expected truth, observed reality, diff, violated invariant, intent source, supporting observations, status (true, violated, or unknown), and linked claim ids.
  • claim-graph.md — the single claim store; one node per claim. Required fields: claim_id, statement, claim type, risk tier, scope, intent ids, supporting observations, contradicting observations, independent observation groups, convergence status, counter-search result, primary source backing, dependencies, status (supported, partial, refuted, or unresolved), fact_ids (the ledger rows the claim rests on), and final synthesis location. High-risk non-code nodes that clear the Phase 3b gate are mirrored into a verified-claims digest section at the top of the file — the sole allowlist the synthesis draws non-code claims from.
  • observation-manifest.md — one row per observation. Required fields: observation_id, source path or URL, evidence layer, observer group, independence basis, observer, observed_at, valid_at or claim_valid_at, artifact path, quote or line anchor, and contamination notes.
  • verification-economics.md — one row per proof decision. Required fields: claim, risk, error cost, verification cost/time, chosen verification path, defer/verify decision, outcome, and residual risk.
  • cause-disappearance.md — one row per causal finding. Required fields: cause id, expected truth, previous observation, last_seen, disconfirming observation, replacement cause if any, current status, and whether the violation is no longer observed.

Observation candidates and claim candidates travel back from workers as message text. The orchestrator writes the instrumentation artifacts, links candidates into the intent diff and claim graph, and records where each observation entered the synthesis. A conclusion is not ready for final materials until its expected truth/reality diff is closed or marked unknown, its claim node exists, and its independent-observation convergence status is supported or explicitly excepted.

Run the swarm as a cooperating team

Saturation research defaults to teammode, not isolated fire-and-forget workers: a lead one worker surfaces almost always reshapes what another should search next. When your harness gives you real cooperating members — Codex: the teammode skill when it is listed (MultiAgentV2 agents, or codex_app threads as its fallback); 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.
  • Always the maximum roster. The team is not sized by taste: fill every member slot your harness allows (OpenCode team_mode caps members at 8; Codex teammode has its own ceiling) on every run. If you can only name five axes, split the broadest one — by source territory, by time window, by perspective — until the roster is full. A half-empty team is a half-covered topic.
  • Compose deliberately across everything you can spawn. Before writing the roster, enumerate what this session actually has — every delegation tier the harness or config defines and every spawnable role — and give each slot the cheapest tier that can do ITS job: broad recon on fast tiers, contested analysis on deep tiers, attack lanes on the strongest reasoning tier. Mixed tiers by design, never one tier across the whole board.
  • Routing words from the user are literal. "quick", "fast", "deep", "all quick", "max parallel" — in any language — are hard instructions, not mood. Route exactly as asked and journal requested tier -> spawned worker -> fallback reason for every slot. Silently promoting a "quick" roster to a heavier tier is a defect, and so is dropping to a cheaper one without saying why.
  • Debate members are mandatory for ultradebate/hyperdebate, default otherwise. At least one skeptic or red-team perspective attacks claims, evidence quality, source independence, synthesis structure, and report choices before they reach the deliverable. When the user says ultradebate or hyperdebate, run at least two attacking perspectives and give every contested claim a full round.

One team, or a sequence — decided by scale and precision. One team is the floor, not the ceiling. When the brief shows 6+ axes, several source territories, or a long final document — or a wrong claim is expensive (legal, medical, financial, procurement, public-facing) — run the research team to convergence, disband it, and stand up a REFINEMENT team from your strongest reasoning tiers whose only job is to attack and sharpen the synthesis before the document is written. A fresh premium team reading a finished journal reasons better than the same researchers grading their own homework. Build each team from a written brief and disband it before the next one starts; never leave two research teams live at once.

  • 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, web, repo-dive) differ by harness, but assume:

  • Read-only. Most research workers cannot write files. Never ask a worker to write the journal or any session file — every journal write is yours.
  • No recursion — workers AND members. Workers cannot spawn their own subagents, and team members must not re-orchestrate: a member researches its axis and reports; it never stands up its own team, loads this skill, or fans out a research swarm of its own. Depth comes from YOUR expansion waves. Say so in every spawn message — a member that starts its own research protocol burns the run's budget on duplicated orchestration and returns nothing you can cite.
  • Built-in brakes. Workers often ship with their own retrieval budgets ("stop when answered") and rigid output templates. Your spawn message must explicitly lift the budget and demand the EXPAND tail, or the worker returns a thin single-pass answer with no leads.
  • Capability routing. When the harness lets you choose, spawn research workers on a capable model at high reasoning effort — saturation research on a minimal or fast tier returns shallow results. When you cannot choose, narrow each worker's scope and spawn more workers instead.

The spawn-message contract

Every research spawn message contains, in order:

  1. TASK: — one imperative line naming the role and the axis.
  2. The budget lift: "This is an explicit exhaustive-research assignment. Your default retrieval budget and stop-when-answered rules do not apply — run the full protocol below and report every lead."
  3. Scope — the axis, the sources to hit, and what a complete answer contains.
  4. The role protocol (Phase 1).
  5. The reply tail. EXPAND markers, observation candidates, and claim candidates travel back as message text, never as files. Every worker ends the reply with:
## EXPAND
- LEAD: <discovery not yet investigated> — WHY: <why it matters> — ANGLE: <suggested search>
- DEAD END: <lead explored to exhaustion>

A worker with nothing to expand writes ## EXPAND followed by none — <one-line reason>. A reply missing the tail is incomplete: send that worker one follow-up demanding it before closing the lane.

Execution references

Read research-collection.md before scoping or collecting sources, then research-delivery.md before verification, synthesis, and delivery. These references continue this skill in phase order; their requirements remain binding.

source snapshot --html and --url probe their own conversion and print the numbers it altered (a footnote digit glued onto a value, a merged table cell); fact add then refuses those numbers with conversion_altered_number, so write a verified text of that source and replace the snapshot with source snapshot --id S<n> --text <verified.txt> --replace (refused while an active row cites the id: retract those rows first or use a new id), then add the fact from it. When you convert a document yourself, run node "$SKILL_DIR/scripts/report-tools.mjs" source probe-conversion <raw-file> <converted-file> and snapshot a verified --text instead before adding any number it lists as altered; lost is a warning only.

Phase 5 — Final materials

The promised formats recorded in brief.md and outcome.json are binding; pdf + docx is the default pair only when a document was asked for with no format word and no destination:

TargetHow
PDF (default)Author the report as one self-contained HTML file, then print it headless: chrome --headless --disable-gpu --no-pdf-header-footer --print-to-pdf=<out.pdf> file://<report.html>. Embed the design-spec.md fonts as real webfonts (CJK included) instead of trusting system fallbacks. uv run --with weasyprint python is the fallback renderer.
DOCX (default)pandoc <report.md> -o <out.docx>, adding --reference-doc=<template.docx> when the user has a house style; uv run --with python-docx python when pandoc is unavailable. Charts and Mermaid renders go in as images.
Slides / deckuv run --with python-pptx python — one claim per slide, a chart or diagram per claim.
Standalone HTML / MarkdownThe authored source itself.

Every reader-facing edition is filled and verified. The main report, the inline edition, LaTeX sections, and slide sources are all filled by fact fill from the same placeholder source, and each is verified on its own by fact verify; PDF and DOCX are renders of a verified source (pandoc <report.html> -o <out.docx> when the DOCX comes from the filled HTML). Fill and verify HTML or Markdown sources (fact verify --format html|md, with a fill map for Markdown); verify LaTeX through its Markdown source, since direct --format tex verification exits 2. Record a delivered edition with outcome set <format> delivered --path <file> --verified-by <record>, where <record> is the fact verify output whose artifact_sha256 equals the sha256 of the delivered source; a PDF or DOCX adds --rendered-from <source> and is matched against that source. outcome verify refuses a delivered row without a matching record (edition_unverified).

Write design-spec.md the moment the deliverable is recorded — before any asset worker spawns. When a document was pointed at, extract it instead of retyping its stylesheet: node "$SKILL_DIR/scripts/report-tools.mjs" format-extract <reference> --out "$SESSION_DIR/design-spec.md" (--from-url for a URL), then fill every TODO: ask from the interview answers, never by guessing. It is the one design contract every asset and assembly worker receives: template family (absent a reference, the clean analyst-report register — one accent over neutral tones, generous margins, styled section headings, no emoji, no clipart), palette tokens, body/heading fonts (a real gothic CJK webfont — Pretendard, Noto Sans KR — when the report language needs one, with word-break: keep-all for Korean), responsive breakpoints and HTML/CSS charts for web deliverables, the figure standard below, and the lineage mode on its own line: Lineage: inline (analyst default: every unit-bearing number tagged MEASURED / ASSUMED / DERIVED or cited in the same element) or Lineage: section (web and blog register: every section cited, lineage in the figure captions). The reference's section 6 lists the full defaults. One font family and one palette govern prose, charts, Mermaid, and generated images alike; a diagram rendering in a random default font inside a styled report is a defect, not a style choice.

The figure standard — binding for every image, chart, and diagram. Each figure sits in a fixed-size container styled from the spec (border, background, caption); the image scales to fit entirely inside it with its original aspect ratio preserved — object-fit: contain semantics — never stretched, never cropped, never spilling out. Every chart carries a title, axis labels, units, and value labels in the report's language; a bare number the reader cannot name is a defect.

Asset workers (background, parallel, each fed design-spec.md) — visuals are the DEFAULT deliverable of this phase, not garnish the user must ask for; a delivered report without figures is an incomplete run:

  • Charts for every quantitative finding, computed from real data. Pull the numbers into an actual table first (CSV/JSON under $SESSION_DIR), then plot from that table, never from prose. Follow the data-scientist tool doctrine — numpy for numeric work beyond SQL/DataFrame aggregation, Polars for filtering/sorting/transforms, DuckDB for joins/aggregations/window functions, never pandas — and load the data-scientist skill when this session has it: uv run --with numpy --with polars --with duckdb --with pyarrow --with matplotlib python. Keep pyarrow in that set — the DuckDB-to-Polars handoff (.pl()) fails without it, and .df() fails without pandas, so hand data across through .pl(), never .df(). Save to $SESSION_DIR/assets/. Plot ONLY from the ledger: export the rows with node "$SKILL_DIR/scripts/report-tools.mjs" fact export --csv --out "$SESSION_DIR/assets/<chart>.csv" --session-dir "$SESSION_DIR" and draw from that CSV; every chart figure carries data-chart-source="assets/<chart>.csv", and its axis tick labels sit inside a <g class="ticks" data-tick-step=".." data-tick-min=".." data-tick-max=".."> group, so the fidelity gate can check every plotted value and tick (the deliverable reference's section 6 tick rule).
  • Mermaid graphs for process, architecture, argument, timeline, and evidence-flow structure, themed to the spec's fonts and palette. Render each to SVG and confirm the file exists before the document references it.
  • Generated visuals through the imagegen skill whenever the session has it: a cover plus a concept illustration per major theme, prompted from the spec's style, palette, and mood — document-styled illustration, never generic stock art dropped into a designed page.
  • Full-page screenshots of the top 5-10 sources, saved by the web workers while reading, as provenance you can show.

Every final report is visual — binding. It carries at least one data visualization of the run's own findings (a chart drawn from the data table, next to the claim it supports), a diagram wherever structure matters, and the topic's own screenshots and video, embedded or linked with attribution; every figure is captioned, sourced, and given alt text. Mermaid for flows, timelines, and relations; generated charts for numbers; image generation only where an illustration genuinely helps; PlotNeuralNet for paper-format reports that describe model architectures. Every asset lane reads references/report-visualization.md first: which tool fits which finding, the render commands, the quality bar, and the checklist the gates apply. A light-tier post still carries one visual when it reports numbers or structure.

Visual reproductions are compared against the source — binding. When the ask is to recreate, reproduce, or rebuild something visual (a clip in 3D, an interface from a screenshot, a figure), real frames or captures from the source are the reference: extract them at the moments that define the source, render the output at the same moments and viewpoints, compose side-by-side pairs, critique every pair by looking at it, fix the largest differences, and compare again within the repair bound. The final pairs, and the first-round pairs in the correction log, go into the report. Procedure: references/report-visualization.md, section 3, Reference compare. A reproduction checked only against itself is unverified.

Verify the asset manifest before rendering. List every asset the document references, assert each file exists and is non-empty on disk, and re-render whatever is missing. A document that renders with three broken diagrams is a document you will publish twice.

Assembly worker — task(category="deep-low", load_skills=["frontend", "visual-qa", "data-scientist"], run_in_background=true, ...); when the session lists the imagegen skill or the ulw-loop skill, add each one it lists to load_skills. Before writing, read every available design and visualization skill and apply it — the report is a designed artifact, not a text dump; the worker's prompt carries design-spec.md. Use the template the user approved; absent a stronger house style the default skeleton is executive summary → key findings by theme → detailed analysis (quotes under 20 words with attribution, charts, Mermaid graphs, generated visuals, SHA-pinned permalinks, verification results) → comparative analysis when options compete → numbered sources with access dates → methodology appendix (workers, waves, searches, verifications, debate rounds) → correction log naming what verification overturned. Write it long and specific: every claim cites [Source N], and the sources section lists every source the run actually used rather than a curated few. The assembly worker writes report.src.html with placeholders, never typed values; the orchestrator runs node "$SKILL_DIR/scripts/report-tools.mjs" fact fill "$SESSION_DIR/report.src.html" --out "$SESSION_DIR/report.html" --session-dir "$SESSION_DIR" and gates the filled file. The inline edition for a PDF, DOCX, or oversized HTML deliverable comes from the same source (fact fill "$SESSION_DIR/report.src.html" --inline --out "$SESSION_DIR/report.inline.html", which inlines local stylesheets and makes image paths absolute on the filled output), never from a hand copy.

The delivery gates — every gate for the QA tier must PASS, in order

Nothing reaches the user until the gates pass. Record each result with node "$SKILL_DIR/scripts/report-tools.mjs" outcome gate <static|fidelity|layout|visual|proofread> <pass|fail|not_run> --session-dir "$SESSION_DIR"; a gate this harness does not provide is recorded not_run --reason "<why>" (fidelity not_run refuses without the reason). A chat or post answer (light tier) runs the static gates and one render; every paginated or web deliverable runs them all (the reference's sections 3 and 7).

  1. Static gates (always, before anyone looks at pixels). node "$SKILL_DIR/scripts/report-tools.mjs" check "$SESSION_DIR/report.html" --design-spec "$SESSION_DIR/design-spec.md" > "$SESSION_DIR/defects.json": keep-all, palette tokens, emoji, em dashes, heading length, unsourced numbers, figure containers, chart text, a report with no visual, images without alt text, gothic-only fonts, citations, the closing and sources sections, broken assets. Codes and fixes: references/report-gates.md.
  2. Fidelity gate. node "$SKILL_DIR/scripts/report-tools.mjs" fact verify "$SESSION_DIR/report.html" --session-dir "$SESSION_DIR" checks every number, quote, chart value, and sentence binding against the ledger, the snapshots, claims.json, and the locked ## Fidelity block of brief.md, and writes $SESSION_DIR/fidelity-defects.json with the verified file's artifact_sha256. Exit 1 on any blocker or major defect: record outcome gate fidelity fail and repair; minors alone exit 0 and are listed. Verify every other edition the same way into its own record (--out "$SESSION_DIR/fidelity-inline.json"). Codes and fixes: references/report-gates.md; grammar: references/deliverable-phase.md, Fidelity gate.

Meaning verifier (a separate session reads every sentence against its source). When the brief's meaning check is on, run it after the fidelity gate passes; when it is off, fact pairs writes {"skipped": true} and the step ends there. node "$SKILL_DIR/scripts/report-tools.mjs" fact pairs "$SESSION_DIR/report.html" --session-dir "$SESSION_DIR" writes $SESSION_DIR/pairs.json: one pair per distinct source quote a findings sentence cites, per sentence bound only by data-claim (against the claim's statement), and per data-translates span, with force_strong set where the lexicon or the hedge position says a strong reader must look. Then spawn one reader worker on the cheapest category, task(category="quick", ...), whose prompt carries ONLY the path of pairs.json and the verdict schema, in exactly this text:

TASK: meaning reader, <cheap|strong> tier. Read ONLY the pair file <SESSION_DIR>/<pairs.json or pairs-strong.json> and the verdict schema in this prompt. Do not open, search, or fetch any other file, page, or tool output: not the report, the ledger, the sources, or the claim graph.
For each pair, compare `sentence` with `quote` (with `statement` for a claim pair) and decide whether the sentence says something its source does not.
Write <SESSION_DIR>/meaning-<cheap|strong>.json as {"model_tier": "<cheap|strong>", "verdicts": [...]} with one verdict per pair_id: {"pair_id": "P<n>", "verdict": "ok" or "drift", "drift_kind": ..., "fragment": ..., "source_fragment": ..., "explanation": "<one sentence>"}.
drift_kind is exactly one of: subject_changed, scope_widened, hedge_dropped, certainty_added, causality_added, direction_flipped, population_changed, evidence_grade_raised, other.
fragment is copied verbatim from the sentence and source_fragment verbatim from the quote or statement: the shortest exact substrings that show the drift, never paraphrased, never empty. A verdict whose fragments are not found word for word is discarded.
A sentence that shortens, summarizes, or translates its source without changing subject, scope, certainty, causality, direction, population, or evidence grade is ok. Do not rewrite anything; return verdicts only.

Next, write $SESSION_DIR/pairs-strong.json (the same file, keeping only the pairs the cheap reader flagged plus every force_strong pair) and spawn one reader on the strong category, task(category="ultrabrain", ...), with the same prompt for the strong tier. Then node "$SKILL_DIR/scripts/report-tools.mjs" fact meaning-check --pairs "$SESSION_DIR/pairs.json" --verdicts "$SESSION_DIR/meaning-cheap.json" --verdicts "$SESSION_DIR/meaning-strong.json" --edition html --session-dir "$SESSION_DIR" writes $SESSION_DIR/fidelity-meaning-defects.html.json, the meaning record of that edition (repeat fact pairs and the readers with --edition <format> for every other delivered edition whose source bytes differ): both tiers naming the same drift_kind (never other) is meaning_drift_confirmed (major, exit 1); one tier alone is meaning_drift_warn (minor); a verdict whose fragments are not in the pair is dropped and counted. Repair every confirmed drift by rewriting the sentence from its quote, re-fill, re-verify, and re-read only the changed sentences (fact pairs ... --changed-since <the new fill map>); or, when the sentence is right, dispute it with --dispute P<n> --reason "<why>", which keeps the defect for this run and logs the dispute. Pass the record to repair decide as one more --defects file and list the warnings in the closing briefing. Each flagged pair adds one line to $SESSION_DIR/fidelity-calibration.jsonl, whose header records the promotion criterion: meaning_drift_confirmed moves from major to an integrity code only after at least 20 runs with disputed-to-confirmed below 10 percent and no more than 2 report-level false blocks in the last 20 runs. These are starting values, changed only with evidence; the scripts never call a model.

  1. Layout gates. Print the probe with node "$SKILL_DIR/scripts/report-tools.mjs" layout-probe --json, evaluate its source in the rendered page through the browser skill's owned headless engine, save the result as $SESSION_DIR/boxes.json, and re-run check with --layout "$SESSION_DIR/boxes.json" (overflow, clipped text, distorted images, overlapping siblings).
  2. Visual QA. Render the produced artifact back to images — PDF pages to PNG, the HTML through the browser skill at desktop and phone widths — and look at them: missing or broken figures, images stretched or spilling their containers, diagram or chart text rendered off the spec's font or palette, clipped tables, overflowing CJK text, blank pages, unlabeled chart values, wrong page breaks. Reading the source markup is not visual QA; inspect the pixels.

Repair is bounded. After every gate run that found defects, ask node "$SKILL_DIR/scripts/report-tools.mjs" repair decide --state "$SESSION_DIR/repair-state.json" --defects "$SESSION_DIR/defects.json" --defects "$SESSION_DIR/fidelity-defects.json" --artifact-bytes <bytes> --renders <pages> --session-dir "$SESSION_DIR" and obey it: repair means fix and re-run; deliver means stop and ship with the residual defects the manifest now lists; block means a content-integrity defect remains (or there is no usable artifact), so do not deliver: tell the user what blocks it and record the row as failed with the reason. Never repair past a stop decision (3 attempts, a 2-attempt plateau, an oscillation, or 15 minutes; the reference's section 8). Fidelity defects ride the same loop (--defects "$SESSION_DIR/defects.json" --defects "$SESSION_DIR/fidelity-defects.json"), but a deliver decision does not release them: while fidelity-defects.json lists untraceable_number, value_mismatch, unit_mismatch, quote_not_verbatim, quote_unbound, unbound_sentence, or chart_value_untraceable, outcome verify fails with fidelity_unresolved and outcome finish refuses, even with the repair budget spent. The only ways out are a ledger row, an assumed row with its rationale, or removing the sentence.

Then resolve every manifest row (outcome set <format> delivered --path <file> --verified-by <record> (plus --rendered-from <source> for a PDF or DOCX) or blocked_capability / skipped / failed with --reason) and deliver. Show the report inline first when the harness can. When this session has a tool that shows an HTML page inline in the conversation (show_html_page, html_render), the requester's first view of the result is the report itself: the gated report.html when it fits the tool, otherwise an inline edition built from the same synthesis and assets, with the reference-compare pairs when the run has them (references/deliverable-phase.md, section 9, Showing the report inline). Then give the artifact paths and a compact chat-readable summary of what the report says — the answer in a few sentences, the numbers that matter, and what to look at first. This holds on every tier, a chat answer included, and when the thing built is itself a page (an app, a 3D scene), showing it does not replace the report page. Without an inline page tool, deliver the artifact paths plus that summary. The document is the deliverable; the summary is what gets it read.

The closing briefing — every run ends with it

The last thing the user reads states, in one compact block, what the answer is made of:

  • The printed block. node "$SKILL_DIR/scripts/report-tools.mjs" outcome verify --session-dir "$SESSION_DIR" && node "$SKILL_DIR/scripts/report-tools.mjs" outcome finish --session-dir "$SESSION_DIR" && node "$SKILL_DIR/scripts/report-tools.mjs" outcome briefing --session-dir "$SESSION_DIR": sources and distinct domains counted from sources-ledger.md, elapsed minutes from the session directory's own timestamp, every promised deliverable with its status, the gate results, the residual defects, and the repair summary. A failing verify means the run is not done.
  • Effort. Workers, waves, excursions, and verifications — the same counters as the SYNTHESIS.md header — plus how many sources were primary and how many claims went to the unresolved/refuted annex. fact export also prints a coverage line (N of M sources snapshotted, by extractor: ...); paste it into the briefing's effort line.

Never ship the artifact without this block, and never fill it from memory — paste the printed block and read the rest off the journal.

Record the format choice. After delivery, when the harness exposes a memory tool and the run qualifies (the user declared a preference, or made the same unsolicited choice on 2+ runs), append one episode line to reference/human-report-style.md in the grammar of the reference's section 5, and update the system/human/report-style.md pointer when a generalization changed. If you stood up a team, disband it and confirm every worker is terminal before the final answer.

Snapshot and locator contract

  • sources/ and fact-ledger.json — one directory per source snapshot and the ledger built from them. The snapshot and locator contract (raw bytes, converted-only sources, byte locators, source refresh) is defined once, in fact-ledger.md; every number and quotation reaches the report through a ledger placeholder.
Repository

code-yeongyu/lazycodex

Path

plugins/omo/skills/ulw-research/SKILL.md

Last updated
First committed

Is this your skill?

If you maintain this skill, you can claim it as your own. Once claimed, you can manage eval scenarios, bundle related skills, attach documentation or rules, and ensure cross-agent compatibility.