@troylar/flightdeck 1.22.0 → 2.0.1

package/CHANGELOG.md

@@ -2,6 +2,58 @@
 
 <!-- Generated by build.py from src/releases.json. Edit that file, not this one. -->
 
+## 2.0.1 · Oct 22, 2026
+
+Each run counts once, and a sign-off or correction counts only from the exact person who made it.
+
+### Fixed
+
+- **A copy of a run in another run folder no longer counts twice** (Runs). A run.json counts only in its own folder (runs/<process>/<run ID>/). A copy anywhere else is listed with the files that can't be read, with where it belongs, and is never counted or opened. Nothing is removed: move or delete the copy yourself. *Where:* Folder health and Refresh list the copy. Evidence packs include such a folder as it is and say so
+- **Sign-offs count only from the owner's exact ID** (Skills). The ID on a sign-off, and the process and version it names, are compared exactly. The same goes for who wrote a correction, so only its author can withdraw or revise it. A run that names someone by an ID over 80 characters opens read-only. *Where:* A process page, Ready for a skill?
+- **Only runs read now count toward a sign-off** (Skills). Such a run stays on screen, with any change you haven't saved, but isn't counted toward a sign-off until its file reads again. *Where:* A process page, Ready for a skill?, and Home
+
+## 2.0.0 · Oct 21, 2026
+
+Typed values, exact versions and reports from tools, in a lighter Flightdeck. Move every computer to 1.21 or later first.
+
+### New
+
+- **Numbers, yes/no, dates, choices and links** (Checklists). A run detail can be a number, yes/no, date, choice or link (context: rows:number, due:date), and a step can ask for a number, yes/no or date as evidence. Each gets the right box and is checked as it's typed. Text from a plan or a parent run converts only when that's certain; anything else waits for a person, and nothing that uses it goes ahead. A checklist without typed values works as before. *Where:* The start form, the run's Details, evidence boxes and the step-type editor
+- **Contract 2 reads Flightdeck 2.0 runs and versions** (Reading for other apps). flightdeck run, runs and process with --contract 2 read 2.0 versions and runs, with each value's kind, its stored text, a typed value and any conversion record. --contract 1 prints exactly what it did before.
+- **Notes and screenshots on phases and gates** (Checklists). A phase can have a note and screenshots right under its heading, and a gate can have screenshots under its note. Runs show them in the phase header and the gate's panel. *Where:* The checklist editor and the run screen
+- **Suggest a change to a phase's note or a gate's** (Corrections). Anyone viewing a run can suggest new wording for a phase's note or a gate's. It is decided and applied to the draft like a step's correction. Teammates on Flightdeck 1.13 to 1.22 see it as a described problem.
+- **Run an exact version of another checklist** (Checklists). A {run.process} step can say version: N to run exactly that version. A run of a version that uses something new in 2.0 also keeps every other linked checklist on the version that was latest when it started, even after a newer one is published. If a pinned version can't be used, the step says why instead of starting another one. Other runs start linked runs on the latest, as before. *Where:* Checklists and the run screen
+- **Continue an older run with Flightdeck 2.0** (Runs). When a run made before 2.0 reaches a step whose linked checklist needs Flightdeck 2.0, it offers Start it as a Flightdeck 2.0 run. The old step is marked Continued in run <key>, which teammates on older copies read too.
+- **Plans that start on an exact version** (Plans). A plan for a version that uses something new in 2.0 starts on that version and nothing else. If it can't be used, the plan asks, and Start on vN instead switches it on purpose. Other plans work as before.
+- **Register skills with flightdeck skill register** (Skills). flightdeck skill register writes the skill's registration for a version made with Flightdeck 2.0, and a {run.skill} step can say skillVersion: to expect one. Checking the step records which registration was current, with a warning if it isn't the expected one.
+- **See reports from tools on each step, and accept or decline them** (Runs). A tool or script that did a step's work can write a report with flightdeck report write. The step shows what the report says, what a person decided, and whether its inputs match the run. The recorder can accept a passing report, which checks the step with exactly its evidence, or decline it with a reason. *Where:* The selected step in a run, and Reports beside Follow-ups
+
+### Improved
+
+- **Before anyone uses 2.0 features, move every computer to 1.21 or later** (Updating). Put Flightdeck 1.21 or later on every computer that opens the team folder, then Flightdeck 2.0, before anyone uses a 2.0 feature. Copies from 1.11.1 on never change a 2.0 file, but they can't run a 2.0 version or record on a 2.0 run. Copies before 1.11.1 can't tell a 2.0 file at all. A checklist that uses nothing new publishes as before, and every teammate runs it. *Where:* Folder health names older copies it saw in the last 7 days. Steps: Updating Flightdeck, Moving a team to Flightdeck 2.0
+- **Gate notes now show in runs** (Runs). A gate's note shows above Pass the gate, for every version, including versions published before 2.0.
+- **The publish panel says when a version needs Flightdeck 2.0** (Publishing). When a checklist uses something new in 2.0, the publish panel names it and says what that means: teammates on Flightdeck 1.22 or earlier see the version but can't run it. A checklist that uses nothing new publishes as before, and every teammate runs it.
+- **Evidence checks pins and the published payload** (Evidence). Evidence for a run made with Flightdeck 2.0 checks that its version's pins and payload match what was published, and step fingerprints include the version each step runs.
+- **Receipts and Evidence show which reports were accepted** (Receipt). The receipt names the report a step was accepted from, with its hash, and lists every report on the run. Evidence export packs the run's reports and the decisions on them.
+- **A process page shows its owner's panels only to its owner** (Processes). Corrections, Ready for a skill? and Skills are one closed line each for everyone but the checklist's owner and backup owner, saying what they hold ("Corrections · 2 open"). Open one to see it all, as before. A warning in Corrections is never folded. Versions shows the newest, with the rest under Earlier versions, and Recent runs shows 3, with All runs of this process. *Where:* A process page
+- **Home lists only what's yours** (Home). A draft with unpublished changes, and skills that need attention, show on the Home of the checklist's owner and backup owner. A checklist that names nobody still shows them to everyone. Drafts stay marked on Processes. At a glance shows running and processes.
+- **Four sections in the top bar** (Navigation). Home, Runs, Processes, Settings. Skills and Step types open from the Processes page, from Settings (Library) and from search, and their links still work. The first-run welcome shows only its three choices.
+- **A run says each thing once** (Runs). The keyboard hint shows once, in Next up; More → Keyboard shortcuts and ? still list every key. No start notice repeats the status strip, and the revision is in Details. A must-do step is marked with a red ! named "Must do". Timing shows only on a step the checklist times; otherwise Start is under More for this step. Correct this step explains itself on hover. *Where:* A run
+- **Plain words for phase modes, details and outcomes** (Checklists). Phases say "Read, then do" and "Do, then confirm". A run detail in a step or gate shows as its name, like approves deploy of commit to environment. Runs that were canceled say Canceled. Only the words on screen changed: checklist files still say READ-DO and DO-CONFIRM, and run files and receipt text keep the outcome exactly as stored. *Where:* Process pages, runs, the builder, Finish, receipts and Insights
+- **A flatter Processes list** (Processes). Tags fold into Filter by tag (N), which stays open once you open it. A group whose only child is a group shows as one heading ("Operations / Incidents"), and counts of 1 aren't drawn. Each row says its version and when it last ran. Tags are still on the process page, in search and in the filter.
+- **New process asks for a title** (New process). Type a title and the file name is made from it, shown under it ("Saved as onboard-a-new-hire.md") and editable under More options with the group, tags, run details, roles, owner and "Usually run by one person". A taken or invalid name is refused as before, and the options open to show why. Start from Code check-in or Weekly review and publish v1 as it is, or copy a prompt for your AI assistant.
+- **The builder says the save step** (Builder). A new draft says to fill in the steps, choose Save draft, then Done to publish it, and unsaved edits say "Unsaved: Save draft before you publish". Checks counts problems and warnings only; tips are still listed. The first version's change note starts as "First version". Done and saving work exactly as before.
+- **The parts box starts with Phase, Gate, Step and Must-do** (Builder). The builder's parts box shows Phase, Gate, Step and Must-do, with every other part under All parts (N). A search still shows every match, and a step type that can't be used is never folded away.
+- **Fill in opens itself** (Runs). Checking a Jira step that needs an issue type or status only Fill in holds opens that step's Fill in, puts the reason beside the box and focuses it, the way required evidence already does.
+- **Finish shows only what has something in it** (Finish). With no follow-ups, the form is one Add a follow-up line that opens it; with no corrections, one line says No corrections. The three End buttons are unchanged.
+- **Lighter Runs, Step types and Settings pages** (Runs). Runs shows the 8 newest finished runs with the rest under Earlier finished runs, Export evidence is in a More menu (still on each run's too), and cards don't repeat the version. Step types folds the built-in types, with each type's ID inside What it asks for. Settings puts Jira workflows and Keyboard under More settings, except that a Jira workflow problem keeps Jira workflows outside the fold.
+- **Folder health folds what passed** (Folder health). The checks that passed fold into one line, All clear · N checks passed. Problems are never folded.
+
+### Fixed
+
+- **Publish waits for edits that aren't saved** (Publishing). After Done with edits not saved yet, Publish is off and says to save or discard them first, so a version always has what you see.
+- **A run you record shows once on Home** (Home). You're recording, with a separate line when reports wait for review.
+
 ## 1.22.0 · Oct 20, 2026
 
 Back and Forward work inside Flightdeck.

package/README.md

@@ -80,7 +80,7 @@ To update later, run `flightdeck install` again: it updates what's still a Fligh
 
 ## A tour
 
-`flightdeck open` starts on a team folder with a month of history in it. Choose **Casey Nguyen** in the top right and follow along. Six sections sit in the top bar: **Home, Runs, Processes, Skills, Step types, Settings**.
+`flightdeck open` starts on a team folder with a month of history in it. Choose **Casey Nguyen** in the top right and follow along. Four sections sit in the top bar: **Home, Runs, Processes, Settings**. **Skills** and **Step types** open from the Processes page, from Settings and from search.
 
 <table>
 <tr>
@@ -318,7 +318,7 @@ Beside the checklist: whether it's ready for a skill, its skills, its versions a
 
 Saving is careful. A save only goes through if the draft is still exactly what you opened. If a teammate or your AI assistant changed it meanwhile, nothing is saved: you see their version and choose to keep yours or take theirs. One limit: a shared folder can't lock a file, so a change that lands in the instant between that check and the write can still be replaced. Edit a draft with one person (or one AI assistant) at a time. Saving never publishes; publishing is a separate, logged step.
 
-**New process** on the Processes page asks for an ID, title, group, tags, run details, roles and owner, starts the draft, and opens it in the editor.
+**New process** on the Processes page asks for a title; the file name is made from it and shown before you create it. The group, tags, run details, roles, owner and file name are under **More options**. Start blank, from Code check-in or Weekly review (publish v1 as it is, or open it in the editor), or copy a prompt for your AI assistant.
 
 <br>
 
@@ -402,6 +402,7 @@ The same rules are in the `flightdeck-skill-brief` skill for your AI assistant,
 | `flightdeck next <folder> <process>/<run id> --json` | What's waiting in a run and on whom; `--person <id>` adds that person's own next step |
 | `flightdeck followups <folder> --json` | Every follow-up and what became of it (`--status open` for the open ones) |
 | `flightdeck plan request <folder> <request.json \| -> --key <key>` | For other apps: ask for a run. Writes one planned run to `proposals/`, once, for a person to review and start in the app. The same key and request again writes nothing. `--dry-run` shows what it would write; `--json` prints the result as JSON |
+| `flightdeck report targets \| check \| write` | For other apps: report work a tool did on a step. `targets` lists running runs' steps and the evidence each records; `check` checks a report; `write` writes it once to `reports/`. A report never checks a step: the run's recorder accepts or declines it in the app |
 | `flightdeck path` | Prints where the app file is |
 | `flightdeck version` | Prints the version |
 
@@ -416,6 +417,8 @@ The same rules are in the `flightdeck-skill-brief` skill for your AI assistant,
 
 The JSON commands let other apps read a team folder the way a teammate would: a script beside the monthly backup check, a reminder bot for an access review, an onboarding tracker, a deploy script. They only read, never through a link, and never change a file in the team folder. Every result says which contract it follows (`flightdeck-read/1`) and names, file by file, anything it couldn't read. Exit code 0: complete; 4: partial (the data is still printed, with each problem listed); 1: no data; 5: no such process, version or run. People-directory email fields are omitted. See [Using Flightdeck from other apps](docs/apps.md).
 
+`flightdeck report write` lets a tool say it did a step's work, in a report the step shows beside what a person decided and whether its inputs match the run. Accepting a passing report checks the step with exactly its evidence; the receipt and Evidence name the report and its hash. See *Reporting work* in [docs/apps.md](docs/apps.md).
+
 `flightdeck plan request` lets another app ask for a run, the way a teammate would put one on the calendar. A monthly script asks for the backup check with `--key 2026-11`; asking again with the same key and the same request changes nothing, and the same key with other details is refused. The request shows under **Runs** as a planned run, "requested by" the tool, by its own account: the name is what the file says, not proof of who wrote it. Nothing starts by itself; a person starts it, changes it or declines it. It never writes `run.json`, writes only in `proposals/`, never through a link, and reads the way the JSON commands read (exit 0, 4 when something it depends on couldn't be read and nothing was written, 1 when it's refused, 5 when there's no such process or version).
 
 Install and skills sort every `AGENTS.md` and skill file the same way. A file that's still a Flightdeck default (this version's or an earlier one) is updated. A file your team changed is left alone. If this version changed that file's default too, the new default goes to `.flightdeck/updates/<version>/`, with a `README.md` holding a prompt for your AI assistant to merge it. In `AGENTS.md` only the part between the `flightdeck:begin` and `flightdeck:end` markers is Flightdeck's; Team notes, below it, are never touched. `.flightdeck/installed.json` records which defaults the folder is based on; it can make install more careful, never less. Every file install replaces is first copied to `.flightdeck/updates/<version>/replaced/`. A file that changes while install runs is left alone and install exits with 1. Nothing is written through a link or outside the folder (see [Updating Flightdeck](docs/updating.md) for the limits).

package/bin/flightdeck.js

@@ -765,16 +765,19 @@ async function readData(eng, adapter, req) {
      folder above what it reads included, are never its problems. */
   let relevant = () => true;
   const ledger = () => { take(adapterProblems(adapter)); return L.problems().filter((p) => relevant(p.path)); };
-  const err = (code, kind, why) => ({ code, json: A.failure(app, kind, why, ledger()) });
+  const two = +req.contract === 2;
+  const err = (code, kind, why) => ({ code, json: A.failure(app, kind, why, ledger(), two ? 2 : 1) });
   const notFound = (why) => err(EXIT.notFound, 'not-found', why);
-  if (req.contract != null && A.VERSIONS.indexOf(+req.contract) < 0) return err(EXIT.error, 'contract', 'This copy of Flightdeck reads contract ' + A.VERSIONS.join(', ') + ' only (' + A.CONTRACT + '). Ask for one of those, or update Flightdeck.');
-  const done = (keep, data, readAt) => { const e = A.envelope(app, readAt || new Date().toISOString(), keep(ledger()), data); return { code: e.complete ? 0 : EXIT.partial, json: e }; };
+  if (req.contract != null && A.VERSIONS.indexOf(+req.contract) < 0) return err(EXIT.error, 'contract', 'This copy of Flightdeck reads contract ' + A.VERSIONS.join(', ') + ' only (' + A.VERSIONS.map(A.CONTRACT_OF).join(', ') + '). Ask for one of those, or update Flightdeck.');
+  const done = (keep, data, readAt) => { const e = A.envelope(app, readAt || new Date().toISOString(), keep(ledger()), data, two ? 2 : 1); return { code: e.complete ? 0 : EXIT.partial, json: e }; };
   try {
     if (req.cmd === 'run' || req.cmd === 'next') {
       const m = RUN_KEY.exec(req.key || '');
       relevant = runCovers(m[1], m[2], null);
       const one = await repo.readRunOnly(L.fs, m[1], m[2]);
       if (!one.found) return notFound('There\'s no run ' + req.key + ' in the team folder.');
+      /* Contract 1 shows what Flightdeck 1.x reads: a run/3 and a 2.0 version are named as newer. Contract 2 reads them. */
+      if (!two) { one.run = A.v1Run(one.run); one.pub = A.v1Pub(one.pub); }
       const r = one.run, key = m[1] + '/' + m[2];
       if (one.nofile) L.note('runs/' + key + '/run.json', 'nofile', 'The run folder has no run.json.');
       take(one.bad.map((b) => ({ path: b.path, kind: b.kind || 'unreadable', why: fileWhy(b.why) })));
@@ -787,13 +790,28 @@ async function readData(eng, adapter, req) {
       const usable = !!r && !newerRun(PF, r);
       /* run and next read only what they depend on (readRunOnly), so every problem met counts. */
       const keep = (list) => list, nameOf = A.names(one.people);
-      if (req.cmd === 'run') return done(keep, usable ? A.run(r, F.list([r], one.fuDecisions), nameOf) : { run: null });
+      /* Contract 2 lists a run/3's migration records, current and archived (history-*.jsonl): a failed read is a problem. */
+      if (two && usable && r.format === PF.run.FORMAT3) {
+        const h = await repo.loadHistory(L.fs, r).catch((e) => { L.note('runs/' + key + '/', 'unreadable', fileWhy(e && e.message || String(e))); return []; });
+        take((h.refused || []).map((x) => ({ path: x.path, kind: x.kind === 'newer' ? 'newer' : 'malformed', why: x.why })));
+        [...new Set(h.malformed || [])].forEach((p) => L.note(p, 'malformed', 'This file has lines that aren\'t archived records, so some of the run\'s history may be missing.'));
+        /* An archived record is read only in its exact frozen shape (kind, av, then a migration record); any other is named. */
+        const rmap = PF.run.mapOf(r), MK = ['path', 'at', 'from', 'source', 'verdict', 'result', 'resolved'];
+        r._archivedMigrations = [];
+        h.filter((x) => x.kind === 'migration').forEach((x) => {
+          const m = {}; Object.keys(x).filter((k) => k !== 'kind' && k !== 'av').forEach((k) => { m[k] = x[k]; });
+          if (Object.keys(x).slice(0, 2).join() === 'kind,av' && Object.keys(m).join() === MK.join() && PF.run.migrationOk(m, rmap, r)) r._archivedMigrations.push(m);
+          else L.note(x._file || 'runs/' + key + '/', 'malformed', 'An archived migration record isn\'t one Flightdeck can read, so some of the run\'s history may be missing.');
+        });
+      }
+      if (req.cmd === 'run') return done(keep, usable ? (two ? A.run2 : A.run)(r, F.list([r], one.fuDecisions), nameOf) : { run: null });
       return done(keep, usable ? A.next(r, nameOf, req.person || null) : { run: key, person: req.person ? nameOf(req.person) : null, next: null, mine: null });
     }
     /* Each command reads only what its output depends on (needs()), so every problem the ledger holds is one that output
        depends on, and all of them are reported: there's no scope to fall behind what's read. */
     relevant = covers(needs(req));
-    const d = await repo.loadAll(dependsOn(L.fs, needs(req)), { readOnly: true, explain: true, deep: true });
+    const d = await repo.loadAll(dependsOn(L.fs, needs(req)), { readOnly: true, explain: true, deep: true, contract2: two });
+    if (!two) { d.processes = A.v1Processes(d.processes); d.runs = d.runs.map(A.v1Run).filter(Boolean); }
     take(folderProblems(PF, d));
     /* Every run judged as run judges it, against its own version (runs reads the versions; followups doesn't need them). */
     const pubOf = (r) => { const proc = d.processes.filter((x) => x.process === r.process)[0], p = proc && proc.pubs.filter((x) => x.folder === r.folder)[0]; return p || missingVersion(PF, r); };
@@ -811,7 +829,7 @@ async function readData(eng, adapter, req) {
       else if (req.version != null) pub = proc.pubs.filter((p) => vOf(p) === +req.version).sort((a, b) => (b.ok ? 1 : 0) - (a.ok ? 1 : 0) || (a.folder < b.folder ? -1 : 1))[0];
       else pub = proc.index.latest || proc.pubs.slice().sort((a, b) => (vOf(b) || 0) - (vOf(a) || 0))[0];
       if (!pub) return notFound('There\'s no version ' + (req.folder || req.version) + ' of ' + req.proc + ' in the team folder.');
-      return done(all, A.process(proc, pub), d.readAt);
+      return done(all, (two ? A.process2 : A.process)(proc, pub), d.readAt);
     }
     if (req.cmd === 'runs') {
       const st = req.status || 'all', mine = (p) => !req.proc || p === req.proc;
@@ -820,7 +838,7 @@ async function readData(eng, adapter, req) {
       /* Which version a plan starts on is unknown (null), not missing, when any of its process's versions couldn't be read or
          verified: only problems with the versions themselves count (a run that doesn't match its version is named at the run). */
       const probs = ledger(), unsure = (proc) => probs.some((x) => ['', 'publications', 'publications/'].indexOf(x.path) >= 0 || x.path === 'publications/' + proc || x.path.indexOf('publications/' + proc + '/') === 0);
-      return done(all, A.runs(list, plans, nameOf, d.processes, unsure), d.readAt);
+      return done(all, (two ? A.runs2 : A.runs)(list, plans, nameOf, d.processes, unsure), d.readAt);
     }
     /* followups: every run's follow-ups come from its run.json, so any run that couldn't be read may hide some. */
     const items = F.list(runs.filter((r) => !req.proc || r.process === req.proc), d.fuDecisions).filter((x) => req.status !== 'open' || F.isOpen(x));
@@ -879,7 +897,12 @@ function failureJson(eng, kind, why) { return eng ? eng.PF.appjson.failure(eng.v
    replacing a file here; it can't stop two computers that aren't syncing from both writing (OneDrive then keeps both). */
 function writeRequest(dir, name, text, hooks) {
   if (!/^req-[a-z0-9-]{1,60}\.json$/.test(name)) fail('refusing an unexpected request name: ' + name);
-  const home = folders(dir, ['proposals'], true), target = path.join(home, name), data = Buffer.from(text, 'utf8');
+  return writeOnce(dir, ['proposals'], name, text, hooks);
+}
+/* The same, for any one folder of the team folder (parts): a report in reports/<process>/ too. */
+function writeOnce(dir, parts, name, text, hooks) {
+  const rel = parts.join('/') + '/';
+  const home = folders(dir, parts, true), target = path.join(home, name), data = Buffer.from(text, 'utf8');
   const tmp = path.join(home, '.' + name + '.' + process.pid + '.' + crypto.randomBytes(6).toString('hex') + '.tmp');
   const put = (fd) => { for (let off = 0; off < data.length;) { const n = fs.writeSync(fd, data, off, data.length - off); if (!(n > 0)) throw new Error('the disk accepted no more bytes'); off += n; } fs.fsyncSync(fd); };
   const EXCL = fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL | (fs.constants.O_NOFOLLOW || 0);
@@ -889,7 +912,7 @@ function writeRequest(dir, name, text, hooks) {
     mine = fs.fstatSync(fd);
     put(fd);
     fs.closeSync(fd); fd = null;
-    folders(dir, ['proposals'], false);
+    folders(dir, parts, false);
     const now = lstatOrNull(tmp);
     if (!now || now.isSymbolicLink() || now.ino !== mine.ino || now.dev !== mine.dev) fail('refusing to write through a link: ' + home);
     if (hooks && hooks.beforeLink) hooks.beforeLink();
@@ -907,14 +930,14 @@ function writeRequest(dir, name, text, hooks) {
         throw e3;
       } finally { fs.closeSync(f2); }
     }
-    folders(dir, ['proposals'], false);
+    folders(dir, parts, false);
     const st = lstatOrNull(target);
     if (!st || st.isSymbolicLink() || !st.isFile()) fail('refusing to write through a link: ' + target);
-    if (!fs.readFileSync(target).equals(data)) fail('proposals/' + name + ' didn\'t read back the same after it was written. Check the team folder before asking again.');
+    if (!fs.readFileSync(target).equals(data)) fail(rel + name + ' didn\'t read back the same after it was written. Check the team folder before trying again.');
     return 'written';
   } catch (e) {
     if (e instanceof Refused) throw e;
-    fail('couldn\'t write proposals/' + name + ': ' + e.message);
+    fail('couldn\'t write ' + rel + name + ': ' + e.message);
   } finally {
     if (fd !== null) try { fs.closeSync(fd); } catch (e) { /* already failing */ }
     /* The temporary file goes, if it's still the one this process made (the final name, once linked, keeps the bytes). */
@@ -1090,11 +1113,247 @@ async function requestMain(argv) {
   return out(r.json, r.code);
 }
 
+/* ---------- Reports from other apps: flightdeck report targets | check | write (docs/apps.md, contract flightdeck-read/2)
+   A tool that did a step's work writes a report: a claim a person accepts or declines in Flightdeck. These commands never
+   write run.json and never decide; write puts one new file in reports/<process>/, once, and reads it back. They read the
+   way the --json commands read (a problem ledger over a read-only view) and print READ's envelope under flightdeck-read/2. */
+function randomReportId() { const a = 'abcdefghijklmnopqrstuvwxyz0123456789', b = crypto.randomBytes(12); let o = ''; for (let i = 0; i < 12; i++) o += a[b[i] % 36]; return o; }
+/* req: { cmd: 'check' | 'write' | 'targets', buf (the report's bytes), folder (false: check alone, no team folder), dryRun,
+   strict, unmatchedOk, now, proc, key }. adapter: the team folder, or null for check alone. write(parts, name, text): writes
+   reports/<process>/<name> once (writeOnce), resolving 'written' or 'exists'. Resolves to { code, json }. */
+async function reportData(eng, adapter, req, write) {
+  const PF = eng.PF, A = PF.appjson, X = PF.reports, repo = PF.repo, app = eng.version || '', C2 = A.CONTRACT2;
+  const L = adapter ? repo.ledger(repo.readOnly(adapter, 'Checking a report')) : null;
+  const take = (list) => list.forEach((p) => L.note(p.path, p.kind, p.why));
+  let relevant = () => true;
+  const ledger = () => { if (!L) return []; take(adapterProblems(adapter)); return L.problems().filter((p) => relevant(p.path)); };
+  const err = (code, kind, why) => ({ code, json: A.failure(app, kind, why, ledger(), C2) });
+  const done = (data) => { const e = A.envelope(app, new Date().toISOString(), ledger(), data, C2); return { code: e.complete ? 0 : EXIT.partial, json: e }; };
+  try {
+    if (req.cmd === 'targets') {
+      const scope = ['runs' + (req.proc ? '/' + req.proc : ''), 'publications' + (req.proc ? '/' + req.proc : ''), 'people.json'];
+      relevant = covers(scope);
+      const d = await repo.loadAll(dependsOn(L.fs, scope), { readOnly: true, explain: true, deep: true });
+      take(folderProblems(PF, d));
+      const pubOf = (r) => { const proc = d.processes.filter((x) => x.process === r.process)[0], p = proc && proc.pubs.filter((x) => x.folder === r.folder)[0]; return p || missingVersion(PF, r); };
+      d.runs.forEach((r) => take(judgeRun(PF, r, pubOf(r))));
+      let runs = d.runs.filter((r) => !r._unrunnable && !r.ended && r.state === 'running' && (!req.proc || r.process === req.proc));
+      if (req.key) {
+        runs = runs.filter((r) => r.process + '/' + r.id === req.key);
+        if (!runs.length) return err(EXIT.notFound, 'not-found', 'There\'s no running run ' + req.key + ' in the team folder.');
+      }
+      return done(A.targets(runs, A.names(d.people)));
+    }
+    if (req.buf.length > X.LIMITS.bytes) return err(EXIT.error, 'invalid', 'A report is at most 64 KB; this one is more.');
+    const snap = X.snapshot(new Uint8Array(req.buf));
+    if (snap.text === null) return err(EXIT.error, 'invalid', 'The report isn\'t UTF-8 text.');
+    if (X.holdsKey(snap.text)) return err(EXIT.error, 'invalid', 'The report holds a private key. A report never needs one; nothing was written.');
+    let o;
+    try { o = JSON.parse(snap.text); } catch (e) { return err(EXIT.error, 'invalid', 'The report isn\'t complete JSON: ' + e.message); }
+    /* id and created are filled when they're left out (check says so; write writes them). */
+    let text = snap.text, filled = [];
+    if (o && typeof o === 'object' && !Array.isArray(o)) {
+      if (!Object.prototype.hasOwnProperty.call(o, 'id')) { o.id = randomReportId(); filled.push('id'); }
+      if (!Object.prototype.hasOwnProperty.call(o, 'created')) { o.created = req.now || new Date().toISOString(); filled.push('created'); }
+      if (filled.length) text = X.text(o);
+    }
+    const pre = req.cmd === 'check' && filled.length ? ['No ' + filled.map((k) => '"' + k + '"').join(' or ') + ': report write fills ' + (filled.length === 1 ? 'it' : 'them') + ' in, so the file name and SHA-256 here are examples.'] : [];
+    const withPre = (t) => (t ? Object.assign({}, t, { warnings: pre.concat(t.warnings) }) : { applies: null, warnings: pre });
+    const rm = o && typeof o.run === 'string' ? /^([a-z0-9][a-z0-9-]{0,59})\/([a-z0-9-]{1,40})$/.exec(o.run) : null;
+    const prod = o && o.producer && typeof o.producer === 'object' ? o.producer.name : null;
+    const name = rm && typeof o.step === 'string' && typeof prod === 'string' && typeof o.id === 'string' ? X.fileName({ run: rm[2], step: o.step, producer: prod, id: o.id }) : null;
+    const c = X.clean(text, rm ? rm[1] : null, name && X.parseName(name) ? name : null);
+    if (!c.ok) return err(EXIT.error, 'invalid', (c.kind === 'newer' ? 'This report ' + c.why : 'This isn\'t a report Flightdeck can use: ' + c.errors.join('; ') + '.') + (req.cmd === 'write' ? ' Nothing was written.' : ''));
+    const rep = c.report, file = X.DIR + '/' + rep.process + '/' + X.fileName({ run: rep.run, step: rep.step, producer: rep.producer.name, id: rep.id });
+    /* The hash is always of the bytes written (a byte-order mark in the input isn't), so it's the one the app logs. */
+    const bytes = Buffer.from(text, 'utf8'), sha = PF.sha256.hex(new Uint8Array(bytes));
+    if (bytes.length > X.LIMITS.bytes) return err(EXIT.error, 'invalid', 'With id and created filled in, the report is more than 64 KB, so it couldn\'t be read. Nothing was written.');
+    if (!adapter) return done(A.reportOut(file, sha, 'valid', rep, withPre(null)));
+
+    /* Against the folder: the run, read alone (its folder, its version, people.json), as run --json reads it. */
+    relevant = runCovers(rep.process, rep.run, null);
+    const one = await repo.readRunOnly(L.fs, rep.process, rep.run);
+    let t = null;
+    if (!one.found) {
+      /* Not listed isn't proof it's absent: with a problem met on the way (a link, a folder that can't be read), --unmatched-ok
+         holds and nothing is written. */
+      if (req.cmd === 'write' && req.unmatchedOk && ledger().length) return done(A.reportOut(file, null, 'held', rep, { applies: 'unknown', warnings: [] }));
+      if (!(req.cmd === 'write' && req.unmatchedOk)) return err(EXIT.notFound, 'not-found', 'There\'s no run ' + rep.process + '/' + rep.run + ' in the team folder.' + (req.cmd === 'write' ? ' Nothing was written. If it hasn\'t synced here yet, add --unmatched-ok.' : ''));
+      t = { errors: [], warnings: ['Run ' + rep.process + '/' + rep.run + ' isn\'t in the team folder yet; nobody can accept this report until it is.'], applies: 'unknown' };
+    } else {
+      const r = one.run;
+      if (one.nofile) L.note('runs/' + rep.process + '/' + rep.run + '/run.json', 'nofile', 'The run folder has no run.json.');
+      take(one.bad.map((b) => ({ path: b.path, kind: b.kind || 'unreadable', why: fileWhy(b.why) })));
+      if (r) { relevant = runCovers(rep.process, rep.run, r); take(judgeRun(PF, r, one.pub)); }
+      if (!r || r._unrunnable || ledger().length) {
+        if (!ledger().length) L.note('runs/' + rep.process + '/' + rep.run + '/run.json', 'unreadable', 'This run can\'t be read here' + (r && r._unrunnable ? ': ' + r._unrunnable : '.'));
+        return done(A.reportOut(file, null, 'held', rep, { applies: 'unknown', warnings: [] }));
+      }
+      t = X.target(rep, r, PF.run.mapOf(r));
+      if (t.errors.length) return err(EXIT.error, 'invalid', t.errors.join(' ') + (req.cmd === 'write' ? ' Nothing was written.' : ''));
+    }
+    if (req.strict && t.warnings.length) return err(EXIT.error, 'invalid', 'With --strict, warnings refuse the report: ' + t.warnings.join(' ') + ' Nothing was written.');
+    if (req.cmd === 'check') return done(A.reportOut(file, sha, 'valid', rep, withPre(t)));
+
+    /* write: a report is written once. The same bytes already there are this report (a retry); anything else under its name
+       is another report, and nothing is written. */
+    relevant = (p) => runCovers(rep.process, rep.run, one.run)(p) || p === X.DIR || p === X.DIR + '/' + rep.process || p === file;
+    const there = async () => {
+      let f;
+      try { f = await L.fs.blob(file, { maxBytes: X.LIMITS.bytes }); } catch (e) { L.note(file, e && e.skipped ? 'skipped' : 'unreadable', fileWhy(e && e.message)); return 'held'; }
+      if (!f) return null;
+      const got = Buffer.from(await f.arrayBuffer());
+      return got.equals(bytes) ? 'same' : 'other';
+    };
+    const before = await there();
+    if (before === 'held') return done(A.reportOut(file, null, 'held', rep, t));
+    if (before === 'same') return done(A.reportOut(file, sha, 'already', rep, t));
+    if (before === 'other') return err(EXIT.error, 'id-taken', file + ' is already in the team folder with other contents. Reports are written once: give this one another id. Nothing was written.');
+    if (req.dryRun || !write) return done(A.reportOut(file, sha, 'would-write', rep, t));
+    let res;
+    try { res = await write([X.DIR, rep.process], file.split('/').pop(), text); } catch (e) { return err(EXIT.error, 'failed', e && e.message || String(e)); }
+    if (res === 'written') return done(A.reportOut(file, sha, 'written', rep, t));
+    const after = await there();
+    if (after === 'same') return done(A.reportOut(file, sha, 'already', rep, t));
+    if (after === 'held') return done(A.reportOut(file, null, 'held', rep, t));
+    return err(EXIT.error, 'id-taken', file + ' was written by someone else first, with other contents. Give this report another id. Nothing was written.');
+  } catch (e) {
+    return err(EXIT.error, 'failed', 'The team folder couldn\'t be read: ' + (e && e.message || String(e)));
+  }
+}
+/* The words for report check, write and targets without --json. */
+function reportWords(json) {
+  if (json.error) return 'flightdeck: ' + json.error.why + json.problems.map((x) => '\n  ' + x.path + ': ' + x.why).join('');
+  const lines = [];
+  if (json.data.runs) {
+    if (!json.data.runs.length) lines.push('No running runs.');
+    json.data.runs.forEach((r) => { lines.push(r.key + '  ' + r.title + ' (' + r.folder + ')'); r.steps.forEach((st) => lines.push('  ' + st.id + '  ' + st.text + (st.evidence.length ? '  evidence: ' + st.evidence.map((e) => e.name + (e.required ? '*' : '')).join(', ') : '') + (st.accepts ? '' : '  (' + st.why + ')'))); });
+  } else {
+    const r = json.data.report, say = { valid: 'Valid', written: 'Wrote', already: 'Already in the folder, nothing written:', 'would-write': 'Would write (--dry-run), nothing written:', held: 'Nothing was written, because part of what this report depends on couldn\'t be read:' };
+    lines.push(say[r.status] + ' ' + r.file + (r.sha256 ? ' (sha256 ' + r.sha256 + ')' : ''));
+    if (r.applies) lines.push('Applies to the run now: ' + r.applies + '.');
+    r.warnings.forEach((w) => lines.push('Warning: ' + w));
+  }
+  json.problems.forEach((x) => lines.push('  ' + x.path + ': ' + x.why));
+  return lines.join('\n');
+}
+async function reportMain(argv) {
+  const asJson = argv.includes('--json'), VAL = ['--folder', '--process', '--run'], val = {};
+  const args = argv.filter((a, i) => (!a.startsWith('--') || a === '-') && !(i > 0 && VAL.indexOf(argv[i - 1]) >= 0));
+  let eng = null;
+  const out = (json, code) => ({ out: asJson ? JSON.stringify(json, null, 2) : reportWords(json), code });
+  const fj = (kind, why) => (eng ? eng.PF.appjson.failure(eng.version, kind, why, [], eng.PF.appjson.CONTRACT2) : { contract: 'flightdeck-read/2', app: versionOf(app()) || '', error: { kind, why }, problems: [] });
+  const usage = (why) => out(fj('usage', why), EXIT.error);
+  for (const f of VAL) { const i = argv.indexOf(f); if (i >= 0) { if (!argv[i + 1] || argv[i + 1].startsWith('--')) return usage('say what goes after ' + f + '.'); val[f] = argv[i + 1]; } }
+  try { eng = loadEngine(); } catch (e) { return out(fj('failed', e.message), EXIT.error); }
+  const sub = args[1], X = eng.PF.reports;
+  const allowed = { targets: ['--json', '--process', '--run'], check: ['--json', '--folder'], write: ['--json', '--dry-run', '--strict', '--unmatched-ok'] };
+  if (!allowed[sub]) return usage('say what to do: flightdeck report targets <team folder>, report check <report.json | -> [--folder <team folder>], or report write <team folder> <report.json | ->');
+  const unknown = argv.filter((a) => a.startsWith('--') && allowed[sub].indexOf(a) < 0);
+  if (unknown.length) return usage('report ' + sub + ' doesn\'t take ' + unknown.join(', ') + '.');
+  if (sub === 'targets') {
+    if (!args[2] || args[3]) return usage('say the team folder: flightdeck report targets <team folder> [--process <process>] [--run <process>/<run id>]');
+    if (val['--process'] && !PROC_ID.test(val['--process'])) return usage('a process ID is lowercase letters, numbers and dashes.');
+    if (val['--run'] && !/^[a-z0-9][a-z0-9-]{0,59}\/[a-z0-9-]{1,40}$/.test(val['--run'])) return usage('--run is a run key, <process>/<run id>, like release/k3m9p2q8.');
+    let dir;
+    try { dir = folderArg(args[2], 'report targets'); } catch (e) { return out(fj('failed', e.message), EXIT.error); }
+    const r = await reportData(eng, readAdapter(dir, { maxBytes: READ_MAX }), { cmd: 'targets', proc: val['--process'] || null, key: val['--run'] || null });
+    return out(r.json, r.code);
+  }
+  const fileArg = sub === 'check' ? args[2] : args[3], folderIn = sub === 'check' ? val['--folder'] : args[2];
+  if (!fileArg || (sub === 'check' ? args[3] : !args[2] || args[4])) return usage(sub === 'check' ? 'say the report file, or - for standard input: flightdeck report check <report.json | -> [--folder <team folder>]' : 'say the team folder and the report file, or - for standard input: flightdeck report write <team folder> <report.json | ->');
+  let dir = null;
+  if (folderIn) { try { dir = folderArg(folderIn, 'report ' + sub); } catch (e) { return out(fj('failed', e.message), EXIT.error); } }
+  let input;
+  try { input = await readRequestInput(fileArg, X.LIMITS.bytes); } catch (e) { return usage('couldn\'t read the report ' + (fileArg === '-' ? 'from standard input' : fileArg) + ': ' + e.message); }
+  if (input.tooBig) return out(fj('invalid', 'A report is at most 64 KB; this one is more.'), EXIT.error);
+  const r = await reportData(eng, dir ? readAdapter(dir, { maxBytes: READ_MAX }) : null, { cmd: sub, buf: input.buf, dryRun: argv.includes('--dry-run'), strict: argv.includes('--strict'), unmatchedOk: argv.includes('--unmatched-ok') },
+    (parts, name, t) => writeOnce(dir, parts, name, t));
+  return out(r.json, r.code);
+}
+
 /* ---------- Writing drafts for AI assistants: flightdeck draft read | save | propose (contract flightdeck-draft/1) ----------
    These commands change the team folder, and only ever write maps/drafts/<process>.md (a direct save), one new
    proposed/<process>/<operation>.json and one new history/drafts/<process>/agent-<operation>.jsonl, all through folders()
    (never through a link, never outside the folder). A draft open in an editor this computer can see is never written: the
    change becomes a proposal a person applies in Flightdeck. docs/apps.md, docs/design.md section 27. */
+/* ---------- Registering a skill: flightdeck skill register <team folder> --from <file | -> [--json] (contract flightdeck-skill/1)
+   The only writer of skill-registrations/ (2.0): a new revision file for the exact version a skill was built from, created
+   once and read back; then the skill's legacy skills/<name>.json, if any, becomes a tombstone every older copy refuses to
+   match. A version that can't be matched exactly (missing, another folder with the same number, a clash, damaged) is
+   refused and nothing is written. docs/apps.md. */
+const SKILL_CONTRACT = 'flightdeck-skill/1';
+async function skillMain(argv) {
+  const asJson = argv.includes('--json'), fi = argv.indexOf('--from'), from = fi >= 0 ? argv[fi + 1] : null;
+  const args = argv.filter((a, i) => !a.startsWith('--') && !(i > 0 && argv[i - 1] === '--from'));
+  let eng = null;
+  const out = (o, code) => {
+    const json = Object.assign({ contract: SKILL_CONTRACT, app: eng ? eng.version : versionOf(app()) || '' }, o);
+    return { out: asJson ? JSON.stringify(json, null, 2) : o.error ? 'flightdeck: ' + o.error.why : 'Registered ' + o.registered.name + ' ' + o.registered.version + ' (revision ' + o.registered.rev + ') at ' + o.registered.path + (o.tombstone ? '\nReplaced ' + o.tombstone + ' with a pointer to it.' : ''), code };
+  };
+  const refuse = (kind, why) => out({ error: { kind, why } }, EXIT.error);
+  if (args[1] !== 'register') return refuse('usage', 'say what to do: flightdeck skill register <team folder> --from <registration.json | -> --json');
+  if (!args[2] || args[3]) return refuse('usage', 'say the team folder: flightdeck skill register <team folder> --from <registration.json | -> --json');
+  if (fi < 0 || !from || (from.startsWith('--') && from !== '-')) return refuse('usage', 'say which file with --from, or --from - for standard input.');
+  const unknown = argv.filter((a) => a.startsWith('--') && ['--json', '--from'].indexOf(a) < 0);
+  if (unknown.length) return refuse('usage', 'skill register doesn\'t take ' + unknown.join(', ') + '.');
+  try { eng = loadEngine(); } catch (e) { return refuse('failed', e.message); }
+  const PF = eng.PF;
+  let dir;
+  try { dir = folderArg(args[2], 'skill register'); } catch (e) { return refuse('failed', e.message); }
+  let input;
+  try { input = await readRequestInput(from, 65536); } catch (e) { return refuse('usage', 'couldn\'t read ' + (from === '-' ? 'standard input' : from) + ': ' + e.message); }
+  if (input.tooBig) return refuse('invalid', 'A registration is at most 64 KB; this one is more.');
+  let o;
+  try { o = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(input.buf)); } catch (e) { return refuse('invalid', 'The registration isn\'t JSON in UTF-8.'); }
+  const rfs = readAdapter(dir, { maxBytes: READ_MAX }), name = o && typeof o.name === 'string' ? o.name : '';
+  const proc = o && o.implements && typeof o.implements.process === 'string' ? await PF.repo.readProcess(rfs, o.implements.process) : null;
+  const okName = /^[a-z0-9][a-z0-9._-]{0,79}$/i.test(name), lfile = 'skills/' + name + '.json';
+  const regs = okName ? await PF.repo.loadRegistrations(rfs) : [];
+  /* The skill's legacy file, read as the app reads it: missing is absent; one that can't be read (an I/O error) is
+     unreadable, never absent. */
+  let legacyText = null, legacy = null;
+  if (okName) {
+    try { legacyText = readInside(dir, ['skills', name + '.json']); }
+    catch (e) { legacy = { skill: null, errors: [lfile + ': couldn\'t be read (' + (e.code || e.message) + ')'], file: name + '.json', unreadable: true }; }
+    if (legacyText != null) {
+      let checked = null;
+      try { checked = PF.skills.check(JSON.parse(legacyText), lfile); } catch (e) { checked = null; }
+      legacy = checked ? Object.assign(checked, { file: name + '.json' }) : { skill: null, errors: [lfile + ': isn\'t valid JSON'], file: name + '.json' };
+    }
+  }
+  /* The one verdict for the name (PF.skills.resolve), from that file and every revision filed under the name, readable or
+     not: anything it can't read, or two revisions at one rev, is refused before anything is written. */
+  /* What the listings couldn't show for the name holds it, as in the app (PF.skills.held): skills/ that can't be listed, or
+     whose file for the name is past the files a copy reads, stands in for the file read here. */
+  const listed = okName ? await PF.repo.loadLegacySkills(rfs).then(null, (e) => Object.assign([], { unlisted: 'skills/ couldn\'t be listed (' + (e && (e.code || e.message)) + ').' })) : [];
+  const held = okName ? PF.skills.held(listed, regs, name) : { legacy: [], revs: [] };
+  /* Every file that speaks for the name, as the app groups them (PF.skills.legacyFor, revisionsFor): its own file, and any
+     that records it under another file name. The file read above is in that list, so one recording another name holds it. */
+  const others = PF.skills.legacyFor(listed, name).filter((x) => (x.file || '').toLowerCase() !== (name + '.json').toLowerCase());
+  const legacyIn = held.legacy.length ? held.legacy : others.concat(legacy ? [legacy] : []);
+  const verdict = okName ? PF.skills.resolve(name, legacyIn, PF.skills.revisionsFor(regs, name).concat(held.revs)) : null;
+  const said = verdict ? { name: verdict.name, status: verdict.status, source: verdict.source, rev: verdict.rev, kinds: verdict.kinds, blocks: verdict.blocks } : null;
+  const no = (kind, why) => out({ verdict: said, error: { kind, why } }, EXIT.error);
+  if (verdict && verdict.blocks) return no('invalid', 'Can\'t register ' + name + ': ' + verdict.reasons.join(' ') + ' Nothing was written.');
+  const got = PF.skills.registration(o, proc, verdict && verdict.top ? { skill: verdict.top.skill } : null, { app: eng.version, now: new Date().toISOString(), by: 'flightdeck skill register', window: 'cli-' + crypto.randomBytes(4).toString('hex'), rand: crypto.randomBytes(8).toString('hex').replace(/[^a-z0-9]/g, '') });
+  if (got.why) return no('invalid', got.why);
+  const was = legacy;
+  const text = JSON.stringify(got.rec, null, 2) + '\n';
+  try { writeNew(dir, got.path.split('/'), text); } catch (e) { return no('failed', e.message); }
+  /* Read it back through the same reader the app uses: what's there must be this registration, exactly. */
+  const back = (await PF.repo.loadRegistrations(readAdapter(dir, { maxBytes: READ_MAX }), { name: got.rec.name })).filter((x) => x.file === got.path)[0];
+  const sha = crypto.createHash('sha256').update(Buffer.from(text, 'utf8')).digest('hex');
+  if (!back || !back.skill || back.skill.sha !== sha) return no('failed', got.path + ' didn\'t read back as written' + (back && back.errors.length ? ': ' + back.errors.join('; ') : '') + '.');
+  let tomb = null;
+  if (legacyText != null) {
+    if (!(was.tombstone && was.id === got.rec.id)) {
+      try { safeWrite(dir, ['skills', name + '.json'], JSON.stringify(PF.skills.tombstone(got.rec), null, 2) + '\n', legacyText); tomb = 'skills/' + name + '.json'; }
+      catch (e) { return out({ verdict: said, registered: { path: got.path, name: got.rec.name, version: got.rec.version, id: got.rec.id, rev: got.rec.rev, implements: got.rec.implements, sha }, tombstone: null, error: { kind: 'failed', why: 'Registered at ' + got.path + ', but skills/' + name + '.json changed or couldn\'t be replaced (' + e.message + '). Run the command again to replace it with a pointer.' } }, EXIT.error); }
+    }
+  }
+  return out({ verdict: said, registered: { path: got.path, name: got.rec.name, version: got.rec.version, id: got.rec.id, rev: got.rec.rev, implements: got.rec.implements, sha }, tombstone: tomb }, 0);
+}
 const DRAFT_CONTRACT = 'flightdeck-draft/1';
 /* Test hooks around the final compare of a direct save (test/cli.test.js injects a write there). */
 const _hooks = {};
@@ -1313,6 +1572,13 @@ const HELP = `flightdeck: team process checklists, in one HTML file
   flightdeck plan request <team folder> <request.json | -> --key <key> [--json] [--dry-run]
                                       for other apps: ask for a run. Writes a planned run to proposals/ once, for a
                                       person to start in Flightdeck; the same key and request again writes nothing
+  flightdeck report targets <team folder> [--process <process>] [--run <process>/<run id>] [--json]
+                                      for other apps: running runs and the steps a report can be written for
+  flightdeck report check <report.json | -> [--folder <team folder>] [--json]
+                                      check a report (with --folder, against its run too); writes nothing
+  flightdeck report write <team folder> <report.json | -> [--json] [--dry-run] [--strict] [--unmatched-ok]
+                                      say a step's work is done: writes the report to reports/ once, for a person
+                                      to accept or decline in Flightdeck. It never checks a step by itself
   flightdeck draft read <team folder> <process> [--session <id>] [--or-latest] --json
                                       for AI assistants: the draft's exact text and rev, who has it open,
                                       this session's proposals and the text to continue from
@@ -1322,6 +1588,9 @@ const HELP = `flightdeck: team process checklists, in one HTML file
                                       read; otherwise write a proposal a person applies in Flightdeck
   flightdeck draft propose <same as save>
                                       always write a proposal
+  flightdeck skill register <team folder> --from <file|-> [--json]
+                                      for AI assistants: register a skill against the exact version it was built
+                                      from (Flightdeck 2.0). The only writer of skill-registrations/
   flightdeck path                     print where the app file is
   flightdeck version                  print this version
 
@@ -1358,6 +1627,8 @@ function main(argv) {
   if (READS.indexOf(first) >= 0 && !argv.includes('--help')) return readMain(argv);
   if (first === 'draft' && !argv.includes('--help')) return draftMain(argv);
   if (first === 'plan' && !argv.includes('--help')) return requestMain(argv);
+  if (first === 'skill' && !argv.includes('--help')) return skillMain(argv);
+  if (first === 'report' && !argv.includes('--help')) return reportMain(argv);
   const ti = argv.indexOf('--to'), to = ti >= 0 ? argv[ti + 1] : null;
   if (ti >= 0 && (!to || to.startsWith('--'))) fail('say which folder after --to, for example: flightdeck skills --to ~/skills');
   /* Flags that take a value: the value is never read as a command or a folder. */
@@ -1475,4 +1746,4 @@ if (require.main === module) {
     if (r && typeof r.then === 'function') r.then(done, failed); else done(r);
   } catch (e) { failed(e); }
 }
-module.exports = { _hooks, main, installedNewer, versionOf, cmp, skillFiles, norm, region, managed, merged, hash, baselineKey, examples, readAdapter, loadEngine, readData, requestData, writeRequest, EXIT };
+module.exports = { _hooks, main, installedNewer, versionOf, cmp, skillFiles, norm, region, managed, merged, hash, baselineKey, examples, readAdapter, loadEngine, readData, requestData, writeRequest, reportData, writeOnce, EXIT };