fusion-cli 1.1.0__py3-none-any.whl

fusion/__init__.py

@@ -0,0 +1,3 @@
+"""fusion — the reference CLI of the Fusion Convention."""
+
+__version__ = "1.0.0"

fusion/_skills/fusion-analyst/SKILL.md

@@ -0,0 +1,50 @@
+---
+name: fusion-analyst
+description: "The Fusion analyst — deliverables out of the bucket. Four gears: report (multi-section analysis from library + activities — the default), assess (scored assessment with explicit criteria and scale), compare (side-by-side matrix with deltas and red flags), export (CSV/JSON/XLSX data extracts). Everything lands in output/ as a summary-first document, cites every source path in data_sources, and ships signed in the ledger. Use for 'report on', 'analyze and write up', 'brief', 'assess', 'evaluate', 'score', 'compare X and Y', 'export as csv/excel'. For searching without producing a deliverable use fusion-librarian's query; for new documents of record use fusion-librarian's create. Applies only inside a Fusion bucket — a directory tree with BUCKET.md and LEDGER.md at its root; if there is no such bucket in play, this skill does not apply."
+license: MIT
+compatibility: "Requires the fusion CLI on PATH; uv for the export script (PEP 723: openpyxl)."
+---
+
+# fusion-analyst — the output
+
+Deliverables leave the bucket; their evidence never does. Every analyst
+document cites the exact paths it was built from, and ships with a
+`shipped` ledger entry.
+
+Read `references/fusion-conventions.md` once per session; read
+`BUCKET.md ## Conventions` before acting. No `BUCKET.md` up the tree and
+none named? Stop — this is not a Fusion bucket, and no Fusion skill
+applies (`fusion hub` lists the real ones).
+
+## Pick the gear
+
+| Signal | Gear | Load |
+|---|---|---|
+| report / analyze / write up / brief (default) | report | references/report.md |
+| assess / evaluate / score / rate | assess | references/assess.md |
+| compare / versus / side by side | compare | references/compare.md |
+| export / as csv / as excel / as json | export | references/export.md |
+
+## The output contract (all four gears)
+
+- Deliverables are documents in `output/` — frontmatter `title`, `type`,
+  `aurora` (usually `library` for reference-grade output, `commitments`
+  when it answers a promise), `created`, and **`data_sources`: the YAML
+  list of every bucket path the deliverable was built from.** No
+  uncited claims: if it isn't in a listed source, it is labelled as the
+  analyst's own inference.
+- Drafts live in `workbench/` while the human iterates; the finished
+  piece moves to `output/` (that move is the librarian's promote gear if
+  the human asks for the full ceremony, or written directly to `output/`
+  when the ask was a deliverable from the start).
+- Sign every deliverable:
+  `fusion log shipped "output/<path>" --bucket <root> --as <you>` ·
+  `fusion index <root>` · `fusion check <root>` green.
+
+## Never
+
+- Never invent data — the bucket is the evidence, `data_sources` is the
+  warrant.
+- Never overwrite an existing deliverable silently; new version, new
+  name, or an explicit yes.
+- Never hand-edit the registers.

fusion/_skills/fusion-analyst/references/assess.md

@@ -0,0 +1,12 @@
+# assess — scored, scaled, evidenced
+
+1. Subject + criteria + scale. No scale given → 1–5 integers
+   (1 very poor … 5 excellent) and SAY SO at the top of the document.
+2. Evidence per criterion from the bucket (paths kept for data_sources).
+   A criterion without evidence scores nothing — mark it "no evidence
+   in bucket" instead of guessing.
+3. Write `output/assessments/<slug>.md`: summary + `---` + scores table
+   (criterion · score · evidence path) + per-criterion rationale +
+   `## Sources`.
+4. `fusion log shipped … --bucket <root> --as <you>` · `fusion index <root>`
+   · `fusion check <root>`.

fusion/_skills/fusion-analyst/references/compare.md

@@ -0,0 +1,12 @@
+# compare — the matrix that shows its work
+
+1. Items + criteria (ask for criteria only if the obvious set is
+   ambiguous). Normalize units and scales before comparing; say when a
+   normalization changes a number's face.
+2. Matrix: criterion · item A · item B · delta. Below it: strengths,
+   weaknesses, and red flags (crippling conditions get named, not
+   averaged away).
+3. Inline answer for a quick question; `output/reports/<slug>.md` with
+   the full contract when it is a deliverable.
+4. Deliverable path: `fusion log shipped … --bucket <root> --as <you>` ·
+   `fusion index <root>` · `fusion check <root>`.

fusion/_skills/fusion-analyst/references/export.md

@@ -0,0 +1,18 @@
+# export — data that leaves as data
+
+1. Scope the rows: which documents, which frontmatter fields / table
+   columns. Collect into JSON: `{"headers": […], "rows": [[…], …]}`.
+2. Pipe through the script:
+
+   ```bash
+   echo '<json>' | uv run <skill>/scripts/export.py --format xlsx \
+     --output output/exports/<slug>.xlsx
+   ```
+
+   Formats: csv (default), json, xlsx.
+3. Write the companion document `output/exports/<slug>.md` — summary of
+   what the export contains + `resource:` naming the binary +
+   `data_sources` listing every source path. The binary is data; the
+   document is its passport.
+4. `fusion log shipped "output/exports/<slug>.xlsx" --bucket <root>
+   --as <you>` · `fusion index <root>` · `fusion check <root>`.

fusion/_skills/fusion-analyst/references/fusion-conventions.md

@@ -0,0 +1,149 @@
+# The Fusion Conventions — operator's card
+
+> Carried byte-identical by all four Fusion skills. SPEC.md in the Fusion
+> repository is normative; this card is the working summary. When they
+> disagree, SPEC.md wins and this card has a bug.
+
+**The contract:** the human judges, the AI operates, the files remember.
+
+**Liberal reader, strict writer.** Never refuse to read a bucket because
+something is missing or unknown. Never write into `library/`, `activities/`,
+`output/`, or a register without satisfying every rule below first.
+
+## The bucket
+
+```
+<bucket>/
+├── BUCKET.md        # identity card + learned conventions
+├── LEDGER.md        # append-only collaboration record
+├── inbox/           # drop zone — things arrive, nothing lives here
+├── sources/         # immutable originals + MANIFEST.md
+├── library/         # settled knowledge — documents
+├── activities/      # live work — documents + status
+├── workbench/       # ephemeral human+AI space — NO format rules
+└── output/          # finished deliverables — documents
+```
+
+- `sources/` is immutable: never modify, rename, or delete a registered file.
+- `workbench/` has no rules; leaving it (promotion) is a deliberate,
+  ledger-logged act.
+- Fusion holds knowledge and work, never media or code — documents point
+  (`resource:`) at big things, they never swallow them.
+- `output/` may also hold non-markdown deliverable files (exports); their
+  names are still lowercase-hyphen slugs with a lowercase extension.
+
+## Before acting — always
+
+1. Read `BUCKET.md`: the identity card, then `## Conventions` — `### Rules`
+   are how this bucket works; `### Delegations` are your standing autonomy
+   grants. They bind you.
+2. Triage through `library/INDEX.md` and `activities/INDEX.md` plus document
+   summaries before opening bodies.
+
+## The document format
+
+Every `.md` in `library/`, `activities/`, `output/` (except INDEX.md):
+
+```markdown
+---
+title: Human-readable name
+type: what-it-is        # open vocabulary, curated per bucket
+aurora: library         # one of the eight — closed set
+---
+
+## Summary
+
+Two or three lines a human or agent reads in two seconds.
+
+---
+
+Full body. Cross-links are plain relative markdown links.
+```
+
+- Required: `title`, `type`, `aurora` — exactly three.
+- Optional: `tags`, `created`/`updated` (ISO dates), `due` (ISO date the
+  thing falls due — `fusion agenda` surfaces it), `source` (path into
+  `sources/`), `resource` (URI or bucket path of the thing this document
+  describes), `status` (`active`|`done`|`dormant`, activities only),
+  `data_sources` (paths list, output only).
+- Body MUST be summary-first: `## Summary`, the lines, a `---` separator,
+  then everything else.
+- Filenames: lowercase, hyphen-separated, `.md`, stem ≤60 chars.
+- Preserve frontmatter keys you don't recognize.
+
+## Aurora — the eight (closed)
+
+| Aurora | Meaning |
+|---|---|
+| `commitments` | Obligations, promises, deadlines |
+| `focus` | Deep work, what deserves full attention |
+| `ops` | Operations, process, the recurring |
+| `collab` | Shared work, other people involved |
+| `life` | Personal, wellbeing, the non-work |
+| `explore` | Curiosity, research, the not-yet-settled |
+| `archive` | Done, kept, out of the way |
+| `library` | Reference, the settled knowledge |
+
+Aurora says what a document means for the human's attention — never invent
+a ninth value.
+
+## Archive
+
+No archive zone: archived items move to an `archive/` subfolder inside their
+zone AND take `aurora: archive`. Path is the truth, aurora is the signal —
+both, always.
+
+## The registers — single writers, no exceptions
+
+| File | Only writer | Your move |
+|---|---|---|
+| `LEDGER.md` | `fusion log` | `fusion log <verb> "<object>" [--note "…"] --as <you>` |
+| `library/INDEX.md`, `activities/INDEX.md` | `fusion index` | run it after any add/move/edit that changes titles or summaries |
+| `sources/MANIFEST.md` | fusion-intake's `scripts/convert.py` | everything enters `sources/` through the intake gate |
+
+Never edit these three files by hand — not with an editor tool, not with
+shell. The ledger verbs (closed set of eleven): `created`, `converted`,
+`classified`, `indexed`, `moved`, `promoted`, `archived`, `restructured`,
+`shipped`, `reflected`, `noted`. Sign with your agent name (`--as claude`,
+or set `FUSION_ACTOR`).
+
+## The CLI crib
+
+| Command | What it does |
+|---|---|
+| `fusion new <path>` | scaffold a conformant bucket |
+| `fusion hub [add\|remove]` | list / register / retire buckets |
+| `fusion log <verb> <object>` | append a signed ledger entry |
+| `fusion index` | regenerate INDEX files (logs `indexed` when changed) |
+| `fusion check [path]` | conformance: errors, warnings, honest exit codes |
+| `fusion status [--since …]` | one bucket at a glance |
+| `fusion today` | the composed morning across all hub buckets |
+| `fusion agenda` | dated + active items across buckets |
+| `fusion setup` | install/refresh the skills into detected agents |
+
+All take `--json`. `--since last-reflection` scopes to the current
+reflection window. **Exit gate for every skill scenario: `fusion check`
+green before you call the work done.**
+
+## When you're blocked
+
+- `fusion` not on PATH: stop and tell the human — the install is
+  `uv tool install ./fusion/cli` from a clone of the Fusion repository.
+  Never imitate the notary by hand: no register writes while the CLI is
+  missing.
+- `fusion check` red and you cannot fix it: stop, show the findings
+  verbatim, leave the bucket as it stands, and sign nothing that claims
+  the work is done. A bucket is a git repo — nothing is unrecoverable.
+- The human rejects a proposal: that is a result, not a failure. Record
+  it if the gear's protocol says to (`noted`), and move on.
+
+## The four accountabilities
+
+| Skill | Owns |
+|---|---|
+| fusion-intake | The gate. Everything that enters, enters through it. |
+| fusion-librarian | The order. Placement, curation, restructuring, reflection. |
+| fusion-planner | The horizon. Activities, agendas, what today looks like. |
+| fusion-analyst | The output. Deliverables that cite their sources. |
+
+One skill, one accountability — the ledger says which hat was worn.

fusion/_skills/fusion-analyst/references/report.md

@@ -0,0 +1,13 @@
+# report — from bucket to briefing
+
+1. Scope: topic, audience, depth. A "brief" is a report whose audience
+   is management: two pages, headline numbers first, no methodology.
+2. Gather: INDEX triage → grep → read the relevant documents. Keep the
+   list of every path you actually used — that IS `data_sources`.
+3. Write to `output/reports/<slug>.md` (or workbench first if the human
+   is iterating):
+   `## Summary` (the 2–3-line triage), `---`, then: Key findings
+   (numbers verbatim from sources) · Analysis · Recommendations ·
+   `## Sources` (path · contribution — mirrors data_sources).
+4. Close: `fusion log shipped "output/reports/<slug>.md" --bucket <root>
+   --as <you>` · `fusion index <root>` · `fusion check <root>`.

fusion/_skills/fusion-analyst/scripts/export.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python3
+# /// script
+# requires-python = ">=3.11"
+# dependencies = ["openpyxl>=3.1.0"]
+# ///
+"""fusion-analyst export: stdin JSON {"headers": [...], "rows": [[...]]}
+-> csv / json / xlsx on disk. Deterministic; the judgment (what to export)
+happened before the pipe."""
+import argparse
+import csv
+import json
+import sys
+from pathlib import Path
+
+
+def main(argv=None) -> int:
+    ap = argparse.ArgumentParser(description="fusion-analyst data export")
+    ap.add_argument("--format", "-f", choices=("csv", "json", "xlsx"),
+                    default="csv")
+    ap.add_argument("--output", "-o", required=True)
+    args = ap.parse_args(argv)
+
+    payload = json.load(sys.stdin)
+    headers = payload.get("headers") or []
+    rows = payload.get("rows") or []
+
+    if headers:
+        bad = [i for i, r in enumerate(rows) if len(r) != len(headers)]
+        if bad:
+            print(f"export: row(s) {bad} have wrong length vs headers", file=sys.stderr)
+            return 1
+
+    out = Path(args.output)
+    out.parent.mkdir(parents=True, exist_ok=True)
+
+    if args.format == "csv":
+        with open(out, "w", encoding="utf-8", newline="") as fh:
+            w = csv.writer(fh)
+            if headers:
+                w.writerow(headers)
+            w.writerows(rows)
+    elif args.format == "json":
+        records = ([dict(zip(headers, r)) for r in rows]
+                   if headers else rows)
+        out.write_text(json.dumps(records, indent=2, ensure_ascii=False),
+                       encoding="utf-8", newline="\n")
+    else:
+        import openpyxl
+        wb = openpyxl.Workbook()
+        ws = wb.active
+        ws.title = "export"
+        if headers:
+            ws.append(headers)
+        for r in rows:
+            ws.append(r)
+        wb.save(out)
+
+    print(json.dumps({"written": str(out), "rows": len(rows),
+                      "format": args.format}))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

fusion/_skills/fusion-intake/SKILL.md

@@ -0,0 +1,128 @@
+---
+name: fusion-intake
+description: "The Fusion intake gate — everything that enters a bucket enters through it, losslessly. Classify what landed in inbox/ (new, updated, duplicate, conflicting), preserve the original in sources/ with its sha256 in the MANIFEST, convert to a faithful summary-first document (xlsx, csv, docx, pptx, pdf, html, images, .eml mail, markdown/text exports), propose type and aurora, sign the ledger, clear the inbox. Use when the user says 'process the inbox', 'intake', 'ingest', 'convert this file', or drops files into a Fusion bucket's inbox/. For placement, curation, or restructuring of what is already inside, use fusion-librarian; for deliverables out of the bucket, use fusion-analyst. Applies only inside a Fusion bucket — a directory tree with BUCKET.md and LEDGER.md at its root; if there is no such bucket in play, this skill does not apply."
+license: MIT
+compatibility: "Requires the fusion CLI on PATH and uv. LibreOffice (soffice on PATH) required for docx/pptx/legacy office/html formats — fails fast when missing, never silently degrades. Script deps via PEP 723 (openpyxl, PyYAML, pymupdf)."
+---
+
+# fusion-intake — the gate
+
+Nothing enters the library except through the gate. The gate preserves
+originals forever, converts losslessly, and asks before it acts on anything
+that isn't clean and new.
+
+Read `references/fusion-conventions.md` once per session. Then, before
+touching anything: read the bucket's `BUCKET.md` — `## Conventions` may
+contain filing rules and standing delegations that bind this whole run.
+No `BUCKET.md` up the tree and none named? Stop — this is not a Fusion
+bucket, and no Fusion skill applies (`fusion hub` lists the real ones).
+
+## The pipeline
+
+```
+inbox/ ─► STAGE 1 gate (scripts/gate.py)      deterministic: hash, similarity
+              │        six buckets → gate-<runid>.json
+              ▼
+          STAGE 2 gate (references/gate.md)   judgment: final class + intake report
+              │        new → auto-proceed · exact dup → auto-skip
+              │        near-dup / updated / conflicting → ASK FIRST
+              ▼
+          ADMIT + CONVERT (scripts/convert.py) original → sources/ + MANIFEST row
+              │        xlsx/csv finish here; everything else stages pages
+              ▼
+          STAGE 2 convert (references/convert.md)  vision reconstruction,
+              │        fidelity checklist, summary, type + aurora
+              ▼
+          CLOSE       link MANIFEST → fusion log → fusion index → fusion check
+                      admit already moved the original into sources/ —
+                      close just needs the register trail green
+```
+
+## Running it
+
+`admit`, `prepare`, `link`, `unpack`, and `gate.py` take the bucket root as
+`--bucket`; `cleanup` takes only `--run-dir` — resolve it against the
+bucket root before calling (the manifest's `run_dir` is bucket-relative).
+`<skill>` is this skill's directory.
+
+A delivery — a container or folder holding dozens to hundreds of files
+arriving together — walks this same pipeline, but its mechanical halves
+(admit, link) run once each as a single validated batch instead of one
+call per file: `convert.py batch --bucket <root> --ops <ops.json>`. Read
+`references/delivery.md` for the full protocol (dedupe, per-folder
+categories on basename collision, batch schema) before working a
+delivery.
+
+Containers (`.zip`, `.athena`) are delivery vehicles, not originals:
+`uv run <skill>/scripts/convert.py unpack --bucket <root> --file <name>`
+extracts one beside the container (`inbox/<stem>/` for top-level drops)
+and deletes the container — the members become the originals, signed
+`noted` in the ledger — then gate the contents normally (step 1).
+
+1. **Classify:** `uv run <skill>/scripts/gate.py --bucket <root>`
+   → read the printed manifest path, then load `references/gate.md` and
+   follow it to the intake report. Stop for confirmation where it says stop.
+2. **Admit** each approved file:
+   `uv run <skill>/scripts/convert.py admit --bucket <root> --file <name> --category <cat> --actor <you>`
+   Category follows the bucket's filing rules (BUCKET.md), else a short
+   plural noun (`reports`, `mails`, `gear`). The MANIFEST row is the
+   script's job — never edit MANIFEST.md yourself.
+3. **Prepare:**
+   `uv run <skill>/scripts/convert.py prepare --bucket <root> --source <cat>/<name> [--dest …] [--slug …] [--type …] [--aurora …] [--reconcile]`
+   Extractive files (`done: true`) are already conformant documents.
+   Everything else returns a work-dir manifest — load
+   `references/convert.md` and reconstruct. `--reconcile` (with the
+   existing doc's `--dest`/`--slug`) is the confirmed-update path —
+   prepare refuses an existing destination without it.
+4. **Close** (per file): refine the document summary if it's the
+   deterministic placeholder, then — admit already moved the original into
+   `sources/`, so closing is just the register trail:
+   `uv run <skill>/scripts/convert.py link --bucket <root> --source <cat>/<name> --doc <zone-rel-doc>`
+   `fusion log converted "sources/<cat>/<name> → <doc>" --bucket <root> --as <you>`
+   `fusion index <root>` · `fusion check <root>` — green, then
+   `cleanup --run-dir <dir>`. Nothing remains in inbox for this file.
+
+## The four classes (locked)
+
+| Class | Meaning | Action |
+|---|---|---|
+| new | nothing matches | auto-proceed |
+| duplicate — exact | byte-identical to a source | auto-skip, recorded |
+| duplicate — near | re-export / trivial edit | ASK: skip / update / new |
+| updated | newer version of an existing source | ASK, then supersede |
+| conflicting | claims contradict the library | ASK — the gate never picks a winner |
+
+Four classes — `duplicate` splits into exact (auto-skip) and near (ask).
+
+The four classes cover matches against `sources/`; the same bytes dropped
+twice within one inbox batch are reported separately as `inbox_dups` and
+cleaned per the bucket's rules (`references/gate.md`).
+
+**Supersede, the Fusion way:** `sources/` is immutable — a confirmed update
+ADMITS THE NEW FILE as its own source (rename it first if the name
+collides) and RECONCILES the existing library document in place
+(`prepare --reconcile`): same path, content updated, `updated:` bumped,
+`source:` repointed to the new original. One document, no `-v2` twin.
+The old original stays in `sources/` and the MANIFEST, superseded but
+never erased.
+
+## The fidelity contract (lossless, non-negotiable)
+
+- The original lands in `sources/` byte-identical, full sha256 in MANIFEST.
+- Every page is accounted for (`page_count == len(pages)`); a page the
+  text layer can't cover is flagged `needs_vision` and YOU read its image.
+- Tables: every row, every column. Numbers verbatim — never rounded,
+  never paraphrased. Figures get a one-line caption.
+- Doubtful fidelity (blurry scan, unreadable region)? If caught BEFORE
+  admit, the file simply stays in inbox. If caught AFTER admit, the
+  original is already safe in `sources/` — withhold the document instead
+  (or flag the gap loudly inside it) and leave the MANIFEST row unlinked
+  (`—`) until the human decides. A lossy conversion is a failed conversion.
+- Close only after MANIFEST link + ledger + green `fusion check`.
+
+## Never
+
+- Never modify, rename, or delete anything in `sources/`.
+- Never hand-edit `MANIFEST.md`, `LEDGER.md`, or any `INDEX.md`.
+- Never convert a near-dup, update, or conflict without a yes.
+- Never leave a converted file's ledger entry unsigned.

fusion/_skills/fusion-intake/references/convert.md

@@ -0,0 +1,104 @@
+# Conversion — Stage 2 (reconstruction)
+
+`prepare` returned `done: false` and a work-dir manifest. You are the
+vision half of the engine: reconstruct the document faithfully, then close
+the loop. All paths below are bucket-relative.
+
+## Reconstruct
+
+Read `manifest.json` (`run_dir`, `pages`, `images`, `front_matter_seed`,
+`output_file`, `attachments`).
+
+Walk `pages` in order:
+- `needs_vision: false` → use the page's `text` verbatim. Do not
+  paraphrase; do not "clean up" numbers.
+- `needs_vision: true` → Read the corresponding `page-NNN.png` (or the
+  staged image) and transcribe what you see: headings, paragraphs, FULL
+  tables — every column, every row, no cap — and figures as a one-line
+  caption (`*Figure: monthly deliveries trending up since March.*`).
+
+Format-specific notes:
+- **mail** (`path: mail`): the page text carries headers + body. Body
+  becomes the document; headers land in the summary and frontmatter
+  (`created:` from the Date header). An html-only body is converted to
+  text with entities decoded and script/style dropped whole; attachment
+  names that collide are de-collided (`name-2.ext`) so neither is lost.
+  Attachments were extracted into the work dir — tell the user, and
+  offer to move them to `inbox/` so each goes through the gate itself.
+- **text** (`path: text`): the content is already prose. Normalize it
+  into the document body; if it carried frontmatter, preserve unknown
+  keys (liberal reader) and merge the required three.
+- **image**: transcribe or describe honestly — a photo gets a faithful
+  description, a screenshot of text gets the text.
+- **html** (`path: libreoffice`): an LLM-artifact-style page — headings,
+  prose, real tables — routed through LibreOffice like docx/pptx/legacy
+  office formats. Read it exactly as any other rendered page below.
+
+## Write the document
+
+To `output_file`, exactly this shape:
+
+```markdown
+---
+title: <refined from content — the seed title is just the filename>
+type: <seed, or better from content>
+aurora: <see the guidance below>
+source: <seed verbatim>
+created: <seed verbatim, or the mail Date>
+---
+
+## Summary
+
+<2–3 lines a human reads in two seconds to decide whether to open the rest.
+Write it from the content — never "converted from X.">
+
+---
+
+<the reconstructed body>
+```
+
+Aurora guidance — seven of the eight; `archive` is deliberately absent
+(nothing enters a bucket already archived — archiving is the librarian's
+act, moving path and aurora together per SPEC §9):
+| Content | Aurora |
+|---|---|
+| Settled reference: manuals, records, data, mail worth keeping | `library` |
+| Something to act on with a deadline or promise | `commitments` |
+| Material for current deep work | `focus` |
+| Recurring process, ops docs | `ops` |
+| Shared work, other people's input | `collab` |
+| Personal, non-work | `life` |
+| Unvetted research, curiosity | `explore` |
+
+When unsure between two: propose one, note the alternative in the intake
+report. The bucket's own Rules (BUCKET.md) override this table.
+
+## The fidelity checklist (run it before closing)
+
+1. Document is non-empty and summary-first.
+2. Every manifest page is represented in the body (count them).
+3. Every table's row and column counts match the source page (spot-check
+   against the image). Merged ranges are unfolded to their anchor value
+   before pruning, so a spanned column is never mistaken for empty.
+4. All three required frontmatter fields present; aurora is one of the
+   eight; `source:` points at the admitted original.
+5. Anything you could not read faithfully is flagged in your report to
+   the human — and the inbox file stays put.
+
+## Close the loop (per file, in this order)
+
+admit already moved the original into `sources/` — closing is just the
+register trail; nothing remains in inbox for this file.
+
+```bash
+uv run <skill>/scripts/convert.py link --bucket <root> --source <cat>/<file> --doc <output_file>
+fusion log converted "sources/<cat>/<file> → <output_file>" --bucket <root> --as <you>
+fusion index <root>
+fusion check <root>
+```
+
+Green check → `uv run <skill>/scripts/convert.py cleanup --run-dir <run_dir>`.
+Extractive files (`done: true`) skip reconstruction but get the same
+close: refine their placeholder summary and title from the tables first
+(Edit the document — that is a content change, so bump nothing else),
+then link → log → index → check.