@bongos/core 1.19.818 → 1.19.819

package/.bongos-core.json

@@ -2,22 +2,22 @@
   "artifact": "bongos-core",
   "manifest_schema": 1,
   "generator": "scripts/gds/package-core.js",
-  "core_version": "1.19.818",
-  "core_contract": "1.19.818",
-  "source_commit": "7f98428f5e6532100482d729716d92638bee2eb5",
+  "core_version": "1.19.819",
+  "core_contract": "1.19.819",
+  "source_commit": "b56f301dfa5e889c7f8e46624eb564de4bed3510",
   "source_ref": "HEAD",
-  "built_at": "2026-09-17T08:43:53.963Z",
+  "built_at": "2026-09-17T09:33:00.702Z",
   "redaction": {
     "model": "docs-redacted+functional-verbatim",
     "docs_redacted": 490,
     "agent_docs_stubbed": 26,
-    "functional_verbatim": 2217,
+    "functional_verbatim": 2220,
     "rules": 3,
     "gate_literals": 3,
     "gate": "passed"
   },
-  "file_count": 2733,
-  "tree_sha256": "35b8712820d4287686e4a01a9a497c386fd32f24a5109b691a39892d4aeaa964",
+  "file_count": 2736,
+  "tree_sha256": "235bf7bed8d6ad67aa73deddbbb1dc9a87fa6a697935f24b52bf2cdf5c299139",
   "files": [
     {
       "path": ".claude/skills/ask-for-help/SKILL.md",
@@ -247,7 +247,7 @@
     {
       "path": ".claude/skills/strand-fix/SKILL.md",
       "mode": "0000644",
-      "sha256": "42284146c4420b768afaba6edf89975aa2e0bf837d5465bbe86a1f1ad3e2cb75"
+      "sha256": "938a3a8ee5bfb25036f03519fc27de795ba88bd7ed8b33a7f6e31639023b4304"
     },
     {
       "path": ".claude/skills/worktree-clean/SKILL.md",
@@ -302,7 +302,7 @@
     {
       "path": ".gitattributes",
       "mode": "0000644",
-      "sha256": "38bf33dd14a7bff6545f961c4f30172ac850f6a0578900a3c10295c4fc0f27e9"
+      "sha256": "2d993829478b5f8931e5a8248818b70279055d1af643e51f07de6161eab593aa"
     },
     {
       "path": "CLAUDE.md",
@@ -2547,7 +2547,7 @@
     {
       "path": "docs/module-api-changelog.md",
       "mode": "0000644",
-      "sha256": "0b561d6587c66805edf357a97265aa313ab4cf1610e23c63efbb30fc0f1fdf78"
+      "sha256": "671ac9949acbb7120d9a6b3acf43082dba90d2c5119afb61b7cd215fbbec2fdc"
     },
     {
       "path": "docs/modules-contract.md",
@@ -2692,7 +2692,7 @@
     {
       "path": "docs/recipes/gds-db-backup.md",
       "mode": "0000644",
-      "sha256": "0f2dfdeca8d49a07a0da043eaa9f2b16669228c358cb56a7786c6c59e5e29808"
+      "sha256": "b3d6a3e3a400bf593b0f2d671f35cb1a60279f495c8763d311f8cdb68a6d603a"
     },
     {
       "path": "docs/recipes/instance-deploy.md",
@@ -4142,7 +4142,7 @@
     {
       "path": "modules/discord/bug-attachments.js",
       "mode": "0000644",
-      "sha256": "c9ee5215e1856173fd4855e31abc656147171c4a8fea2daf066563a758bd2bf5"
+      "sha256": "b773430f5abe8a742e35dc59335805c531821d0701a50f2090ed599f3c66dafe"
     },
     {
       "path": "modules/discord/db.js",
@@ -7802,12 +7802,12 @@
     {
       "path": "package-lock.json",
       "mode": "0000644",
-      "sha256": "c314948249345b2ef9e9c43e7dc32287f3901882cbc0c4d51a475d568ed0fb76"
+      "sha256": "80eb7e1ecf3c324277a00d732da45ff1e094ac64e4ba176777395fc5c4cb33e4"
     },
     {
       "path": "package.json",
       "mode": "0000644",
-      "sha256": "8be1abd0cb53633278698edda8b8b78edf57224e89eb3b08806ede49014dab6d"
+      "sha256": "30a0133ce3cc21770d6915e5d7bd65d7c8a3a8e0494d0eb0e3230586f66f0876"
     },
     {
       "path": "public-docs/index.html",
@@ -8044,6 +8044,11 @@
       "mode": "0000644",
       "sha256": "bf2f9c0ccbdaaa615bcd4020402dac32466a5a3ace6a1fb5cb543baa905a2ecd"
     },
+    {
+      "path": "scripts/gds/bug-attachment-audit.js",
+      "mode": "0000644",
+      "sha256": "959e349e988146d7be1eb872cf80eb0d25d3d4daf95bdcf1b077a0d81c0c598f"
+    },
     {
       "path": "scripts/gds/bug-triage.js",
       "mode": "0000644",
@@ -8067,7 +8072,7 @@
     {
       "path": "scripts/gds/capture.js",
       "mode": "0000644",
-      "sha256": "7320809dacf61454d114d5c55c244e7eac3314f36302eab879950355540573f6"
+      "sha256": "9edb2127b0712ec052c7c9946246665773e552c95f1e276c1991854fe9feb12f"
     },
     {
       "path": "scripts/gds/category-advisory-guard.js",
@@ -8177,7 +8182,7 @@
     {
       "path": "scripts/gds/db-backup-nightly.sh",
       "mode": "0000644",
-      "sha256": "93f0b743b90a0cfdc91806ecb10da20456b98c0fac0f2b8eb3d690bccf79e532"
+      "sha256": "5e8b7ebfe0b82a426e229a256daf231cb597d8e1df2b908c528a0ed0a67066a5"
     },
     {
       "path": "scripts/gds/db-backup-offsite.sh",
@@ -9142,7 +9147,7 @@
     {
       "path": "scripts/gds/skill-preflight.js",
       "mode": "0000644",
-      "sha256": "2c8297314642a459adb31d4253540fac4a8b3b32a4b79dddd9f0e6cdb87b51fc"
+      "sha256": "913e8b89d3023375462a0308480ddebddbc8536a0312961297a12382f5b40e70"
     },
     {
       "path": "scripts/gds/smoke-batch-claim.sh",
@@ -9697,7 +9702,7 @@
     {
       "path": "src/module-api.js",
       "mode": "0000644",
-      "sha256": "d26e3a559beac4c6431a5cf5476c7a0976798ec8b9174814c06f7d64fd1f6f91"
+      "sha256": "37b1b65e9b2e4136ec74c3d22f13da1a58740de5f1a6e4ddd29dd46cc544eb1f"
     },
     {
       "path": "src/module-loader/catalog.js",
@@ -10279,6 +10284,11 @@
       "mode": "0000644",
       "sha256": "a8fe5a479c38703217de2cb9357ac3a77b28d928feba125e97929bb31c669496"
     },
+    {
+      "path": "tests/bug_attachment_audit.mjs",
+      "mode": "0000644",
+      "sha256": "995bc60d7c4d51c18c90dfe5e3e220ec884c793267f9d0403c299e7c2ecb96fa"
+    },
     {
       "path": "tests/bug_attachments.mjs",
       "mode": "0000644",
@@ -10432,7 +10442,7 @@
     {
       "path": "tests/cli_surface.mjs",
       "mode": "0000644",
-      "sha256": "5a8cc9320d66980280965ee34fbb5fc4bbcc30c8ffa860324a99ce0ce4e4d61f"
+      "sha256": "1475bff8f7e51244f451401f92ac647ddf859eacecf277a8b3f9990a23b84059"
     },
     {
       "path": "tests/cli_token_reissue.mjs",
@@ -12042,7 +12052,7 @@
     {
       "path": "tests/module_api_lazy.mjs",
       "mode": "0000644",
-      "sha256": "40c396fda3a618bf9fa2d2ae3d8d30b50e62c4210199d70b5e29cb82a046d037"
+      "sha256": "9183d78e4d195428afbee8c71746e12db2455f8529ac1223d690a7b8f7ded538"
     },
     {
       "path": "tests/module_asset_subdomain.mjs",
@@ -12794,6 +12804,11 @@
       "mode": "0000644",
       "sha256": "b56a6945713e738542d612f6d43dd9bd00ce1a370b3d7b3e130f4e59a056ee15"
     },
+    {
+      "path": "tests/routine_capture_kind.mjs",
+      "mode": "0000644",
+      "sha256": "0d45c19886939b8a068df438d2e03e749efb3a84258764ed0a345ce96128827d"
+    },
     {
       "path": "tests/routine_schedule.mjs",
       "mode": "0000644",
@@ -13192,7 +13207,7 @@
     {
       "path": "tests/skill_preflight.mjs",
       "mode": "0000644",
-      "sha256": "df2c86d02d560b242a341c905b9ee5fbb25c6479c506736807947749e0a033fa"
+      "sha256": "fe5f29a252d709d417e07f41e9ff2537980e5c42245821fbc966b6b2ba9d9e1e"
     },
     {
       "path": "tests/skill_prefs.mjs",

package/.claude/skills/strand-fix/SKILL.md

@@ -32,10 +32,19 @@ node scripts/gds/skill-preflight.js strand-fix   # exits 1 naming what is MISSIN
    git log origin/main --oneline --grep="N" | head
    gh pr list --search "N" --state all --json number,state,mergeable,url
    ```
-2. **Pick the ONE matching case.**
+2. **Pick the ONE matching case.** (Nothing here moves **main** by hand: landing is server-mediated (ADR 0031 §6 / ADR 0055), so the step that lands is always `ship.js`. `git fetch` always works.)
    - **A. A main commit carries `(task N` and the post-merge `unit` + `main-audit` on main are green** (`gh run list --branch main --limit 4`): the land happened; only the proof failed. The proof is the claim's recorded tip (`claims.published_head_sha`, task 1547) being an ancestor of main — and a `no_branch_no_tip` claim has none (the work rode in on another branch, e.g. a cloud-agent batch, or a `--here` claim). **Record the tip first**: the owner (Archon) sets that column on the task's latest claim to the full 40-char SHA of the main commit — a direct DB write on the box as the DB owner, so it runs under this task's own ledger with the SQL in the ship note (`UPDATE claims SET published_head_sha = '<sha>' WHERE id = (SELECT id FROM claims WHERE task_id = N ORDER BY claimed_at DESC, id DESC LIMIT 1)`). Then the reconciler proves it within ≤5 min, or flip it yourself: `node scripts/gds/api.js POST /api/bongos/tasks/N/ship --body '{}'`. Never `no_artifact: true` here — the artifact exists, and the ledger would record a falsehood. Credits land on the flip (ADR 0120). (Before task 1003434 the manual POST refused even with a tip when the claim had no branch; the reconciler path always worked.)
    - **B. A local branch exists with commits ahead of `origin/main` and no PR**: the ship never pushed. From that worktree: `git push -u origin <branch>` then `gh pr create --base main --head <branch> --fill`. Green `unit` → server auto-merge → the reconciler flips it within ~5 min. If it merges but does not flip, do **A**.
-   - **C. A PR exists but is `CONFLICTING`**: the branch owner brings it up to date — `git merge origin/main`, resolve, push — not this skill, and never `--force`. **Merge, never rebase** (task 1002788): the branch is already published and the server's publish is append-only, so rewriting its history makes every later push non-fast-forward and the task un-landable while the claim gate keeps the owner's queue shut. Report the PR URL and stop.
+   - **C. A PR exists but is `CONFLICTING`**: only the **branch owner** can resolve this, and **never with `--force`**. **Merge, never rebase** (task 1002788): the branch is already published and the server's publish is append-only, so rewriting its history makes every later push non-fast-forward and the task un-landable while the claim gate keeps the owner's queue shut.
+     - **If you ARE the branch owner** (the usual case — it is your own strand), from that worktree:
+       ```bash
+       git fetch -q origin
+       git merge origin/main      # resolve the conflicts, commit
+       node scripts/gds/ship.js <task-id>
+       ```
+       **`ship.js` is the landing step, not `git push`.** Landing is **server-mediated** (ADR 0031 §6 / ADR 0055): `/builder-ship` uploads a bundle and the SERVER moves main. A push from your machine does not land the task even where it succeeds, and on the documented default machine a push to main has no credential at all. So "resolve and push" is not an exit — it leaves the task at `confirmed`, unpaid, with nothing named to do next. That is what stranded task 1003529.
+       **The resume does NOT re-grade.** `ship.js` sees `confirmed` + "you last held the claim", prints `resuming the merge + deploy (no re-claim needed)`, and lands it. The standing caution about re-running `ship.js` on graded work is about `--regrade`, which pays for a second panel; a bare resume from `confirmed` does not. Verified end to end on task 1003529 → PR #745 merged as `e827063f`.
+     - **If it is SOMEONE ELSE'S strand**: report the PR URL and stop. That exit is still correct — only the owner can resolve a real content conflict, and this skill does not resolve conflicts for them.
    - **D. Nothing anywhere** — no branch, no PR, no commit: a codeless confirm. Ask what the task delivered. Work done outside this repo (on the box's instance checkout, a DB-only change captured in the ship note) is legitimately artifact-free → **A** with the reason in the ship body: `--body '{"note":"codeless: <where the work lives>"}'`. If the work was never done, release it instead so it returns to `ready`: `node scripts/gds/release.js N --reason "stranded codeless confirm; nothing delivered"`.
 3. **Verify**: `node scripts/gds/api.js GET /api/bongos/tasks/N` → `"status": "shipped"` (or `ready` after a release). Re-run `strand-watch.js --line` — the task must be gone from it. If the claim gate was the symptom, `claim.js` now succeeds.
 

package/.gitattributes

@@ -28,6 +28,15 @@
 *.py           text eol=lf
 *.json         text eol=lf
 
+# SQL: pinned for the same reason the .md above is, not for tidiness (task 1003945).
+# Unpinned, *.sql fell through `* text=auto`, so a Windows clone with the common
+# core.autocrlf=true got CRLF in the worktree for all 232 of them while the repo
+# content stayed LF. Anything that reads a migration AS TEXT — a column-scanning
+# helper, a doc generator, a checksum — then trips over a \r that CI on Linux never
+# sees. That is how task 1003759's bug sat in the local failure baseline for weeks,
+# read as environmental noise.
+*.sql          text eol=lf
+
 # Future Windows-only wrappers (none today) must be CRLF — cmd.exe/PowerShell
 # expect it. Declared up front so a later setup-builder.cmd lands correct.
 *.bat          text eol=crlf

package/docs/module-api-changelog.md

@@ -2110,5 +2110,7 @@ is load-bearing: the script throws rather than guess if it is missing, and
         landed since 1.19.816 with no explicit bump. run 35200401779. (task 1002620)
   1.19.818 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
         landed since 1.19.817 with no explicit bump. run 35201213516. (task 1002620)
+  1.19.819 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
+        landed since 1.19.818 with no explicit bump. run 35205615659. (task 1002620)
 ---------------------------------------------------------------------------
 ```

package/docs/recipes/gds-db-backup.md

@@ -242,6 +242,52 @@ curl -s https://example.com/api/gds/healthz
 curl -s https://example.com/api/gds/public/progress | jq '.progress[0]'
 ```
 
+## Bug attachments — the state that is not in the database (task 1003918)
+
+The nightly dump is not the whole of this instance. Re-hosted `#bugs` screenshots
+live on disk under `var/bug-attachments`, outside Postgres and outside git, and they
+are the one artefact here that **cannot be regenerated**: the Discord CDN URL each was
+copied from is signed and expires in about a day, so our copy *is* the image.
+
+Nothing backed them up until this task. All five this instance had ever stored were
+lost in the 2026-07-05 droplet move (ADR 0126) — `pg_dump` carried the database and
+nothing carried `var/` — and the loss surfaced two months later, when somebody opened
+an old bug task and saw a broken image.
+
+Two things changed, and one thing is still on you:
+
+1. **The nightly job archives them.** `db-backup-nightly.sh` now writes
+   `<db>-attachments-<TS>.tar.gz` beside the dump, same timestamp and same retention,
+   so a restore drill that picks a date gets the database and the images that go with
+   it. Best-effort: a missing or empty attachments dir is the ordinary case on a fresh
+   instance and never fails a night of database backup.
+
+2. **The default store follows the instance, not the package.** It resolves against the
+   instance root, so an instance running a vendored core no longer keeps these files
+   inside `node_modules/@bongos/core/var`, where every core reinstall would wipe them.
+
+3. **On a box where the instance root is itself impermanent, set `BUG_ATTACHMENTS_DIR`**
+   to a persistent path (e.g. `/srv/<instance>/bug-attachments`) in the service
+   environment, and make sure that path is on the volume your backups actually cover.
+   The override wins over everything above.
+
+### Checking
+
+```bash
+node scripts/gds/bug-attachment-audit.js
+```
+
+Reads every bug task's description, extracts the attachment links it promises a reader,
+and asks the disk whether it can keep them. Exits 1 when any are missing and names the
+task each broken image sits in. `--json` for a machine, `--line` for a one-line probe
+that never blocks a session.
+
+A missing file cannot be re-fetched. Restore it from an attachments archive:
+
+```bash
+tar -xzf /var/backups/gds/<db>-attachments-<TS>.tar.gz -C "$BUG_ATTACHMENTS_DIR"
+```
+
 ## Limits — what this recipe does NOT cover
 
 1. **Whole-droplet loss window is ~1 week, not zero.** The weekly offsite copy ([#415](https://example.com/builders#/task/415), above) closes the catastrophic-loss gap, but it runs weekly — so in the worst case (droplet dies right before the weekly run) you lose up to ~7 days of writes that made it into the local daily dumps but not yet offsite. Acceptable for the Bongos DB's shape; tighten the offsite cadence to daily if that ever stops being true.

package/modules/discord/bug-attachments.js

@@ -50,8 +50,43 @@ const NAME_RE = /^bug-[a-z0-9]{1,40}-[0-9a-f]{16}\.(png|jpg|gif|webp)$/;
 // Where re-hosted images live. Outside the git tree (a `var/` dir) so a deploy's
 // `git reset --hard` / pull never wipes them; gitignored. Env override for tests
 // / non-default layouts.
+//
+// RESOLVED AGAINST THE INSTANCE ROOT, not this file (task 1003918). The default
+// used to be __dirname/../../var, which is the repo root in a single checkout and
+// `node_modules/@bongos/core/var` on an instance running a vendored core — where
+// every core reinstall wipes it. That is the task 1002237 shape, and these files
+// are the one thing here that cannot be regenerated: a Discord CDN URL expires in
+// about a day, so our copy IS the image. All five attachments this instance ever
+// stored are already gone (the 2026-07-05 droplet move carried the database and
+// not var/), which is what this default is meant to stop happening again.
+//
+// BUG_ATTACHMENTS_DIR still wins, and on a box where the instance root is itself
+// impermanent that override is the answer — the standup recipe says so.
+// The instance root is resolved ONCE. resolveInstanceRoot() reads an optional
+// bongos.config.json on every call, and this runs per served attachment — a sync
+// file read per image request, where the old code did a path.join. The root cannot
+// move under a running process, so caching it costs nothing and keeps the serve
+// path as cheap as it was. The env override is still read every call, so a test
+// (or an operator) can still change it without restarting.
+let instanceRootCache;
+function attachmentsRoot() {
+  if (instanceRootCache === undefined) {
+    try {
+      // Through the published doorway (ADR 0083), like every other core read here.
+      instanceRootCache = require('../../src/module-api').resolveInstanceRoot();
+    } catch (e) {
+      // Never let a storage-path lookup take down the bot: fall back to the historical
+      // location, which is correct in a single checkout and is where any existing
+      // files already are.
+      instanceRootCache = path.join(__dirname, '..', '..');
+    }
+  }
+  return instanceRootCache;
+}
+
 function attachmentsDir() {
-  return process.env.BUG_ATTACHMENTS_DIR || path.join(__dirname, '..', '..', 'var', 'bug-attachments');
+  if (process.env.BUG_ATTACHMENTS_DIR) return process.env.BUG_ATTACHMENTS_DIR;
+  return path.join(attachmentsRoot(), 'var', 'bug-attachments');
 }
 
 // PURE — is this a well-formed, bot-generated attachment name?

package/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@bongos/core",
-  "version": "1.19.818",
+  "version": "1.19.819",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@bongos/core",
-      "version": "1.19.818",
+      "version": "1.19.819",
       "license": "AGPL-3.0-or-later",
       "dependencies": {
         "express": "^4.21.2",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.19.818",
+  "version": "1.19.819",
   "description": "Cloud Bongos — the AI-first build platform core (GDS + platform surfaces + module system), installed as a versioned dependency (ADR 0108).",
   "license": "AGPL-3.0-or-later",
   "main": "src/platform-server.js",

package/scripts/gds/bug-attachment-audit.js

@@ -0,0 +1,143 @@
+#!/usr/bin/env node
+// scripts/gds/bug-attachment-audit.js — do the images our task descriptions
+// promise actually exist? (task 1003918)
+//
+// WHY THIS EXISTS. A re-hosted #bugs screenshot is the one artefact in this
+// system that cannot be regenerated: the Discord CDN URL it was copied from is
+// signed and expires in about a day, so our copy IS the image. They live on disk
+// under var/bug-attachments — outside Postgres, outside git — and nothing
+// noticed when all five this instance had ever stored disappeared in the
+// 2026-07-05 droplet move. The loss surfaced on 2026-09-14, two months later,
+// because somebody happened to open an old bug task and saw a broken image.
+//
+// So: read the descriptions, extract every attachment link they promise, and ask
+// the disk whether it can keep that promise. A count of broken promises is the
+// thing that should have been non-zero and visible in July.
+//
+// Usage:
+//   node scripts/gds/bug-attachment-audit.js          # human report; exit 1 if any are missing
+//   node scripts/gds/bug-attachment-audit.js --json   # { described, present, missing: [...] }
+//   node scripts/gds/bug-attachment-audit.js --line   # one line, or nothing; always exit 0
+//
+// Read-only. It never writes, never deletes, and never touches Discord.
+
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+// The link shape the bot embeds in a description. Deliberately matched against
+// the SERVE ROUTE's path rather than any filename found on disk: what matters is
+// what a reader will click, and a file nothing links to is not a broken promise.
+const LINK_RE = /\/api\/(?:gds|bongos)\/bug-attachments\/(bug-[a-z0-9]{1,40}-[0-9a-f]{16}\.(?:png|jpg|gif|webp))/gi;
+
+// PURE — every attachment name a body of text promises, deduped, in first-seen
+// order. Exported so the extraction is testable without a database or a disk.
+function describedAttachments(text) {
+  const out = [];
+  const seen = new Set();
+  for (const m of String(text || '').matchAll(LINK_RE)) {
+    const name = m[1];
+    if (!seen.has(name)) { seen.add(name); out.push(name); }
+  }
+  return out;
+}
+
+// PURE — split the promised names into kept and broken, given an existence test.
+// `rows` are { id, title, description }; the result names the TASK for each
+// missing file, because "three files are gone" is not actionable and "the image
+// in task N is gone" is.
+function auditRows(rows, exists) {
+  const described = [];
+  const missing = [];
+  for (const row of rows || []) {
+    for (const name of describedAttachments(row && row.description)) {
+      described.push({ name, taskId: row.id });
+      if (!exists(name)) missing.push({ name, taskId: row.id, title: row.title || '' });
+    }
+  }
+  return { described, missing, present: described.length - missing.length };
+}
+
+// EVERY status, explicitly, and paged. Two ways to get a comfortable zero here,
+// both of which I hit while building this:
+//
+//   - GET /tasks omits abandoned rows unless you ask for them. The five files this
+//     audit exists for are described in tasks that are now abandoned or shipped, so
+//     the obvious query returned '0 linked, 0 missing' — indistinguishable from
+//     'nothing is broken'.
+//   - the route clamps `limit`, so one page is not the table.
+//
+// A probe whose failure mode is a clean bill of health is worse than no probe, so
+// the status list is spelled out rather than defaulted.
+// 'claimed' is not one — claimTask sets status='active' (db-claims.js). Listing it
+// only bought a no-op query, and a comment promising EVERY status should be right.
+const TASK_STATUSES = ['backlog', 'ready', 'active', 'completed', 'confirmed', 'shipped', 'abandoned'];
+
+async function fetchRows() {
+  const { cliClient } = require('./cli-lib');
+  const { TASK_LIST_MAX_LIMIT, buildTaskPageQuery } = require('../../modules/lifecycle/task-list-limits.js');
+  const api = await cliClient();
+  const byId = new Map();
+  for (const status of TASK_STATUSES) {
+    let offset = 0;
+    for (let page = 0; page < 100; page++) {
+      const q = buildTaskPageQuery({ kind: 'bug', status, limit: TASK_LIST_MAX_LIMIT, offset });
+      const r = await api.tasks.getTasks({ query: q });
+      if (!r || !r.ok) throw new Error(`could not list ${status} tasks (${r && r.status})`);
+      const rows = (r.data && r.data.tasks) || [];
+      for (const t of rows) byId.set(String(t.id), t);
+      // A short page is the end. Compare against the limit the route HONOURED.
+      if (rows.length < q.limit) break;
+      offset += q.limit;
+    }
+  }
+  return [...byId.values()];
+}
+
+async function main() {
+  const argv = process.argv.slice(2);
+  const dir = require('../../modules/discord/bug-attachments.js').attachmentsDir();
+  let rows;
+  try {
+    rows = await fetchRows();
+  } catch (e) {
+    if (argv.includes('--line')) process.exit(0); // a probe never blocks a session
+    console.error(`bug-attachment-audit: undetermined — ${e.message || e}`);
+    process.exit(2);
+  }
+  // Through the serve route's OWN resolver, not a bare path.join. The name pattern
+  // already excludes slashes and dots, and a test pins that '../../etc/passwd' is
+  // never extracted — but the route that actually opens these files defends itself
+  // with a resolved-path prefix check, and a probe that reads the same store should
+  // not hold itself to a weaker rule than the thing it audits.
+  const { resolveSafe } = require('../../modules/discord/bug-attachments.js');
+  const r = auditRows(rows, (name) => {
+    const p = resolveSafe(name);
+    return Boolean(p) && fs.existsSync(p);
+  });
+
+  if (argv.includes('--json')) {
+    console.log(JSON.stringify({ dir, described: r.described.length, present: r.present, missing: r.missing }, null, 2));
+    return;
+  }
+  if (argv.includes('--line')) {
+    if (r.missing.length) {
+      console.log(`Bug attachments: ${r.missing.length} of ${r.described.length} linked screenshot(s) are MISSING from ${dir} `
+        + '— every task describing one renders a broken image. These cannot be re-fetched (the Discord URL has expired).');
+    }
+    return;
+  }
+  console.log(`  Bug attachments: ${r.described.length} linked, ${r.present} present, ${r.missing.length} missing`);
+  console.log(`  Store: ${dir}`);
+  for (const m of r.missing) console.log(`    missing  ${m.name}  (task ${m.taskId})`);
+  if (r.missing.length) {
+    console.log('  These cannot be re-fetched — the Discord CDN URL they were copied from has expired.');
+    console.log('  Restore from a nightly attachments archive: /var/backups/gds/<db>-attachments-*.tar.gz');
+    process.exit(1);
+  }
+}
+
+if (require.main === module) main();
+
+module.exports = { describedAttachments, auditRows, LINK_RE };

package/scripts/gds/capture.js

@@ -282,6 +282,25 @@ async function main() {
   const noPrompt = hasFlag('--no-prompt', args);
   const goalArg = arg('--goal', args);
 
+  // A BAD --kind used to reach the server and come back a 400 (task 1003694).
+  // That is not merely late, it is invisible where it matters: a SCHEDULED routine
+  // filing its findings gets the 400 into a log nobody reads, the audit work still
+  // runs, and only the step that turns a finding into a durable row fails — so no
+  // queue accumulates to make the absence noticeable. dep-audit-nightly filed with
+  // `--kind security`, which is not a kind, and had therefore NEVER filed anything.
+  //
+  // Refusing here makes the same typo surface at authoring time, on the machine of
+  // whoever wrote the command, with the valid list in the message.
+  if (kindFromArg !== null) {
+    const { VALID_KINDS } = require('../../modules/ideas/inbox.js');
+    if (!VALID_KINDS.includes(kindFromArg)) {
+      console.error(`--kind "${kindFromArg}" is not a valid kind. The server would refuse this with a 400.`);
+      console.error(`Valid kinds: ${VALID_KINDS.join(', ')}`);
+      console.error('Adding a new kind is a schema change (the idea_inbox CHECK constraint) and needs its own migration + ADR.');
+      process.exit(2);
+    }
+  }
+
   if (parseGoalArg(goalArg).kind === 'invalid') {
     console.error(`--goal must be a positive goal id, or the literal "none" to file homeless (got "${goalArg}").`);
     process.exit(2);

package/scripts/gds/db-backup-nightly.sh

@@ -170,6 +170,42 @@ if [ "$BYTES" -gt "$WARN_BYTES" ]; then
   echo "[$(date -u +%FT%TZ)] gds-db-backup: WARN latest dump is ${BYTES} bytes (> ${WARN_BYTES} threshold) — review what grew; is it a regenerable table excludable like search_chunks?" >&2
 fi
 
+# ---- bug attachments (task 1003918) -----------------------------------------
+
+# The DB dump above is not the whole state. Re-hosted #bugs screenshots live on
+# disk under var/bug-attachments, outside Postgres and outside git, and they are
+# the one artefact here that CANNOT be regenerated: the Discord CDN URL they were
+# copied from is signed and expires in about a day, so our copy IS the image.
+#
+# Nothing backed them up. All five this instance ever stored are gone — the
+# 2026-07-05 droplet move carried the database and not var/ — and every task
+# description embedding one now renders a broken image in the hall.
+#
+# Tarred beside the dump, same timestamp, same retention, so a restore drill that
+# picks a date gets the database and the images that go with it. Best-effort by
+# design: a missing or empty attachments dir is the ordinary case on a fresh
+# instance and must never fail a night of database backup.
+ATTACH_DIR="${BUG_ATTACHMENTS_DIR:-$REPO_ROOT/var/bug-attachments}"
+ATTACH_OUT="${BACKUP_DIR}/${DB_NAME}-attachments-${TS}.tar.gz"
+ATTACH_GLOB="${DB_NAME}-attachments-${D}${D}${D}${D}-${D}${D}-${D}${D}T${D}${D}${D}${D}${D}${D}Z.tar.gz"
+
+if [ -d "$ATTACH_DIR" ]; then
+  ATTACH_COUNT=$(find "$ATTACH_DIR" -maxdepth 1 -type f | wc -l)
+  if [ "$ATTACH_COUNT" -gt 0 ]; then
+    if tar -czf "$ATTACH_OUT.partial" -C "$ATTACH_DIR" . 2>/dev/null; then
+      mv "$ATTACH_OUT.partial" "$ATTACH_OUT"
+      echo "[$(date -u +%FT%TZ)] gds-db-backup: wrote ${ATTACH_OUT} (${ATTACH_COUNT} attachment(s))"
+    else
+      rm -f "$ATTACH_OUT.partial"
+      echo "[$(date -u +%FT%TZ)] gds-db-backup: WARN could not archive ${ATTACH_DIR} — database dump is unaffected" >&2
+    fi
+  else
+    echo "[$(date -u +%FT%TZ)] gds-db-backup: no bug attachments to archive"
+  fi
+else
+  echo "[$(date -u +%FT%TZ)] gds-db-backup: no bug-attachment dir at ${ATTACH_DIR} — nothing to archive"
+fi
+
 # ---- retention prune --------------------------------------------------------
 
 # Delete dumps older than RETENTION_DAYS. -mtime +N means strictly older
@@ -177,7 +213,7 @@ fi
 # Done AFTER the new dump lands so a streak of failed runs can't erase
 # everything: we never delete on a day we didn't successfully dump.
 PRUNED=$(find "$BACKUP_DIR" -maxdepth 1 -type f \
-    -name "$DUMP_GLOB" \
+    \( -name "$DUMP_GLOB" -o -name "$ATTACH_GLOB" \) \
     -mtime +"${RETENTION_DAYS}" \
     -print -delete | wc -l)
 

package/scripts/gds/skill-preflight.js

@@ -120,13 +120,36 @@ const CAPABILITIES = {
   },
 };
 
+// EVERY read of a SKILL.md goes through here (task 1003754).
+//
+// These files are CRLF in a Windows checkout — .gitattributes pins *.js, *.json,
+// *.sh and *.sql, but Markdown falls through `* text=auto`. Every regex below is
+// anchored on \n, starting with the frontmatter fence /^---\n/, so on Windows the
+// frontmatter simply did not match and parseRequires returned `declared: false`
+// for EVERY skill.
+//
+// That is worse than one red test. Fitness check G03 compares what a skill's fenced
+// commands imply against what it declares — and with nothing parsed as declared, the
+// check reported '53 skill(s) scanned; 0 declare a machine contract' and had nothing
+// to compare. The guard against a skill's ops commands outrunning its declaration
+// was inert on any Windows box.
+//
+// Normalising once at the boundary is deliberately not 'make each regex CRLF-aware':
+// there are six of them and the next one added would forget.
+function readSkillMd(p) {
+  return String(fs.readFileSync(p, 'utf8')).replace(/\r\n/g, '\n');
+}
+
 // ---- the declaration ------------------------------------------------------
 // Read `requires:` out of a skill's YAML frontmatter. Accepts the inline form
 // (`requires: [gh, main-checkout]`) and the dash-list form. Returns
 // { requires, declared, error }: `declared` distinguishes "declared nothing"
 // from "declared an empty list", which the fitness check needs to tell apart.
 function parseRequires(md) {
-  const m = /^---\n([\s\S]*?)\n---/.exec(String(md || ''));
+  // Normalised here too, not only in readSkillMd: this is exported and a caller may
+  // hand it raw file text (the fitness check's injected `read` does exactly that).
+  const src = String(md || '').replace(/\r\n/g, '\n');
+  const m = /^---\n([\s\S]*?)\n---/.exec(src);
   if (!m) return { requires: [], declared: false, error: null };
   const fm = m[1];
   const inline = /^requires:[ \t]*\[(.*?)\][ \t]*$/m.exec(fm);
@@ -176,7 +199,8 @@ function fencedCode(md) {
 }
 
 function inferRequired(md) {
-  const code = fencedCode(md);
+  // Same reason as parseRequires: the SIGNALS below are ^-anchored per line.
+  const code = fencedCode(String(md || '').replace(/\r\n/g, '\n'));
   const out = new Set();
   for (const [rx, cap] of SIGNALS) if (rx.test(code)) out.add(cap);
   return [...out].sort();
@@ -224,7 +248,7 @@ function preflightSkill(name, caps = CAPABILITIES) {
     return { ok: false, requires: [], missing: [{ name: 'skill', why: `"${name}" is not a skill name — it must be a single directory name under .claude/skills/.` }], unknown: [], checked: [] };
   }
   let md;
-  try { md = fs.readFileSync(p, 'utf8'); } catch {
+  try { md = readSkillMd(p); } catch {
     return { ok: false, missing: [{ name: 'skill', why: `no skill named "${name}" at .claude/skills/${name}/SKILL.md` }], unknown: [], checked: [] };
   }
   const { requires, error } = parseRequires(md);
@@ -263,7 +287,7 @@ function checkOpsSkillsDeclareMachine({ dir = SKILLS_DIR, read = null, names: in
     };
   }
   const readOne = read || ((n) => {
-    try { return fs.readFileSync(path.join(dir, n, 'SKILL.md'), 'utf8'); } catch { return null; }
+    try { return readSkillMd(path.join(dir, n, 'SKILL.md')); } catch { return null; }
   });
 
   let declaring = 0;

package/src/module-api.js

@@ -71,7 +71,7 @@ const { responsibilityFor, ROLE_RESPONSIBILITIES } = require('./role-responsibil
 // there. scripts/gds/bump-version.js still rewrites the literal below; it appends
 // the entry to that file. Look for a version's history there, not here.
 // ---------------------------------------------------------------------------
-const CORE_VERSION = '1.19.818'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.19.819'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
 
 // A namespaced logger so a module's log lines are attributable + consistent.
 // Usage: const log = api.logger('dev-box'); log.info('mounted');

package/tests/bug_attachment_audit.mjs

@@ -0,0 +1,122 @@
+// tests/bug_attachment_audit.mjs — the described-but-missing probe (task 1003918).
+//
+// WHY THIS FILE EXISTS. Five re-hosted #bugs screenshots — every one this instance
+// ever stored — disappeared in the 2026-07-05 droplet move, and nobody noticed for
+// two months. They cannot be re-fetched: the Discord CDN URL they were copied from
+// is signed and expires in about a day, so our copy IS the image. The probe is what
+// should have said so in July.
+//
+// A probe like this fails by finding nothing, and a clean bill of health looks
+// identical to working — which is exactly what happened while building it: the
+// first cut queried GET /tasks without naming a status, the route omits abandoned
+// rows by default, and every task describing these files is now abandoned or
+// shipped. It printed "0 linked, 0 missing". So the cases below lean on the ways
+// the extraction can go quietly empty.
+//
+// Run:  node tests/bug_attachment_audit.mjs
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const { describedAttachments, auditRows } = require('../scripts/gds/bug-attachment-audit.js');
+const { attachmentsDir } = require('../modules/discord/bug-attachments.js');
+const path = require('node:path');
+
+// The real link shape, taken verbatim from task 1003718's description.
+const REAL = '/api/gds/bug-attachments/bug-1523688670492627115-8bb16de1f5b4c20e.png';
+
+test('extracts the attachment name from a real embedded link', () => {
+  const got = describedAttachments(`![screenshot](https://cloudbongos.com${REAL})`);
+  assert.deepEqual(got, ['bug-1523688670492627115-8bb16de1f5b4c20e.png']);
+});
+
+test('the 19-digit Discord message id is not too long for the name pattern', () => {
+  // The id in every real filename here is 19 characters. A pattern sized for
+  // something shorter would match nothing and report a clean board.
+  assert.equal(describedAttachments(REAL).length, 1);
+});
+
+test('both /gds/ and /bongos/ spellings of the route are recognised', () => {
+  const a = describedAttachments('/api/gds/bug-attachments/bug-1-0123456789abcdef.png');
+  const b = describedAttachments('/api/bongos/bug-attachments/bug-1-0123456789abcdef.png');
+  assert.deepEqual(a, b, 'the route was renamed; a description can carry either');
+  assert.equal(a.length, 1);
+});
+
+test('the same file linked twice in one description is counted once', () => {
+  const text = `![a](${REAL}) and again ![a](${REAL})`;
+  assert.equal(describedAttachments(text).length, 1);
+});
+
+test('a description with no attachment yields nothing — and that is not an error', () => {
+  assert.deepEqual(describedAttachments('a bug about the hall sidebar'), []);
+  assert.deepEqual(describedAttachments(null), []);
+  assert.deepEqual(describedAttachments(undefined), []);
+});
+
+test('a malformed name is NOT extracted — the pattern is the traversal defence too', () => {
+  assert.deepEqual(describedAttachments('/api/gds/bug-attachments/../../etc/passwd'), []);
+  assert.deepEqual(describedAttachments('/api/gds/bug-attachments/bug-1-short.png'), []);
+  assert.deepEqual(describedAttachments('/api/gds/bug-attachments/bug-1-0123456789abcdef.exe'), []);
+});
+
+test('auditRows names the TASK for each missing file, not just the file', () => {
+  const rows = [
+    { id: '1003718', title: 'a re-filed bug', description: `![x](${REAL})` },
+    { id: '1003719', title: 'no images here', description: 'plain prose' },
+  ];
+  const r = auditRows(rows, () => false);
+  assert.equal(r.described.length, 1);
+  assert.equal(r.missing.length, 1);
+  assert.equal(r.missing[0].taskId, '1003718', '"a file is gone" is not actionable; "the image in task N is gone" is');
+  assert.equal(r.present, 0);
+});
+
+test('a present file is not reported missing', () => {
+  const rows = [{ id: '1', title: 't', description: `![x](${REAL})` }];
+  const r = auditRows(rows, () => true);
+  assert.deepEqual(r.missing, []);
+  assert.equal(r.present, 1);
+});
+
+test('the same file described by two tasks is reported for BOTH', () => {
+  // task 1002076 was re-filed as 1003718 and both descriptions carry the links;
+  // each renders a broken image, so each is worth naming.
+  const rows = [
+    { id: '1002076', title: 'original', description: `![x](${REAL})` },
+    { id: '1003718', title: 're-file', description: `![x](${REAL})` },
+  ];
+  const r = auditRows(rows, () => false);
+  assert.equal(r.missing.length, 2);
+});
+
+test('the store resolves against the INSTANCE root, not the core package (task 1003918)', () => {
+  // The old default was __dirname/../../var, which on a vendored core is
+  // node_modules/@bongos/core/var — wiped by every reinstall, and these files
+  // cannot be regenerated.
+  const prev = process.env.BUG_ATTACHMENTS_DIR;
+  delete process.env.BUG_ATTACHMENTS_DIR;
+  try {
+    const dir = attachmentsDir();
+    assert.ok(!dir.includes('node_modules'), `the store must not live inside an installed package: ${dir}`);
+    assert.equal(path.basename(dir), 'bug-attachments');
+    assert.equal(path.basename(path.dirname(dir)), 'var');
+  } finally {
+    if (prev === undefined) delete process.env.BUG_ATTACHMENTS_DIR;
+    else process.env.BUG_ATTACHMENTS_DIR = prev;
+  }
+});
+
+test('BUG_ATTACHMENTS_DIR still wins outright', () => {
+  const prev = process.env.BUG_ATTACHMENTS_DIR;
+  process.env.BUG_ATTACHMENTS_DIR = '/srv/persistent/bug-attachments';
+  try {
+    assert.equal(attachmentsDir(), '/srv/persistent/bug-attachments',
+      'on a box whose instance root is impermanent, the override is the answer');
+  } finally {
+    if (prev === undefined) delete process.env.BUG_ATTACHMENTS_DIR;
+    else process.env.BUG_ATTACHMENTS_DIR = prev;
+  }
+});

package/tests/cli_surface.mjs

@@ -169,18 +169,47 @@ function runGuidance(fn, env) {
   const code =
     `const l=require(${JSON.stringify(path.join(REPO_ROOT, 'scripts', 'gds', 'cli-lib.js'))});` +
     `Promise.resolve(l[${JSON.stringify(fn)}]()).catch(()=>{});`;
+  // HOME ALONE IS NOT ISOLATION ON WINDOWS (task 1003941). cli-lib resolves the
+  // session through os.homedir(), which on win32 reads USERPROFILE and ignores
+  // HOME entirely — so the child found the DEVELOPER'S REAL session, requireSession
+  // succeeded, and the guidance these tests exist to read was never printed. That
+  // failed on any Windows box whose builder happened to be signed in, and went
+  // green again once their CLI session expired, which made it read as a flake.
+  //
+  // HOMEDRIVE/HOMEPATH are os.homedir()'s second win32 source, so all four go.
+  const HOMELESS = path.join(REPO_ROOT, 'no-such-home-for-tests');
   const r = spawnSync(process.execPath, ['-e', code], {
     encoding: 'utf8',
-    env: { ...process.env, ...env, HOME: path.join(REPO_ROOT, 'no-such-home-for-tests') },
+    env: {
+      ...process.env,
+      ...env,
+      HOME: HOMELESS,
+      USERPROFILE: HOMELESS,
+      HOMEDRIVE: '',
+      HOMEPATH: HOMELESS,
+    },
   });
   return `${r.stdout || ''}${r.stderr || ''}`;
 }
 
+// The isolation above either worked or it did not, and the difference is visible:
+// a child with no session PRINTS guidance, and a child that found one prints
+// nothing. Every assertion below that looks for something ABSENT is satisfied for
+// free by that silence, so the silence is checked for first (task 1003941).
+function guidanceOutput(fn, env) {
+  const out = runGuidance(fn, env);
+  assert.ok(out.trim().length > 0,
+    `${fn} printed NOTHING. That means the child found a real CLI session instead of `
+    + 'the blanked home, so this test is reading an unisolated environment and every '
+    + '"must not contain" assertion here is vacuous (task 1003941).');
+  return out;
+}
+
 const GUIDANCE = ['printUnauthGuidanceAndExit', 'printBoxScopeGuidanceAndExit', 'requireSession'];
 
 test('no guidance path speaks slash commands to a terminal reader', () => {
   for (const fn of GUIDANCE) {
-    const out = runGuidance(fn, { BONGOS_SURFACE: 'terminal' });
+    const out = guidanceOutput(fn, { BONGOS_SURFACE: 'terminal' });
     const leaks = [...out.matchAll(/\/builder-[a-z-]+/g)].map((m) => m[0]);
     assert.deepEqual(leaks, [], `${fn} leaked to a terminal reader: ${leaks.join(', ')}\n${out}`);
     assert.ok(!/node scripts\/gds\//.test(out), `${fn} told a terminal reader to run a repo script:\n${out}`);

package/tests/module_api_lazy.mjs

@@ -35,8 +35,13 @@ function loadedAfter(spec, read = null) {
     const ROOT = ${JSON.stringify(ROOT)};
     const m = require(path.join(ROOT, ${JSON.stringify(spec)}));
     ${read ? `void m[${JSON.stringify(read)}];` : ''}
+    // POSIX-normalised before filtering (task 1003941). path.relative returns
+    // backslashes on win32, so 'src/bongos/' matched NOTHING and every list came
+    // back empty — which made the two laziness assertions below pass VACUOUSLY on
+    // Windows: they assert that a filtered-empty list is empty. An eager require
+    // reintroduced at the doorway would have shipped green.
     const files = Object.keys(require.cache)
-      .map((f) => path.relative(ROOT, f))
+      .map((f) => path.relative(ROOT, f).split(path.sep).join('/'))
       .filter((f) => f.startsWith('src/bongos/'));
     process.stdout.write(JSON.stringify(files));
   `;
@@ -50,6 +55,32 @@ function loadedAfter(spec, read = null) {
   return JSON.parse(out);
 }
 
+// CALIBRATION — can the instrument see anything at all? (task 1003941)
+//
+// Every other assertion in this file has the shape "nothing heavy is in this
+// list", which an EMPTY list satisfies for free. So an empty list is not evidence
+// of laziness; it is evidence of nothing, and the two tests that guard the ADR
+// 0083 doorway invariant cannot tell the difference.
+//
+// That is not hypothetical. loadedAfter filtered on a 'src/bongos/' prefix after
+// path.relative, which returns BACKSLASHES on win32 — so on Windows the filter
+// matched nothing, every list was empty, and both doorway tests passed vacuously.
+// An eager require reintroduced at the doorway would have shipped green.
+//
+// The fix normalises separators, but a normalisation can break again silently, and
+// asserting the doorway's own list is non-empty would be wrong — loading NOTHING
+// from src/bongos/ is precisely what the doorway is supposed to do. So the probe
+// is calibrated against a module that certainly does load one. If this test fails,
+// every emptiness assertion below is meaningless and should be read as untested.
+test('CALIBRATION: the probe can see a src/bongos/ require at all', () => {
+  const files = loadedAfter('src/bongos/pool.js');
+  assert.ok(files.includes('src/bongos/pool.js'),
+    'requiring src/bongos/pool.js must show up in the probe\'s own list. It does not, so '
+    + 'the list is empty for reasons unrelated to laziness — check the path normalisation '
+    + 'in loadedAfter (task 1003941). Until this passes, every "loads nothing" assertion '
+    + `in this file is vacuous. Saw: ${JSON.stringify(files.slice(0, 5))}`);
+});
+
 test('importing the doorway loads no server: no pool, no auth, no routes', () => {
   const files = loadedAfter('src/module-api.js');
   const heavy = files.filter((f) => HEAVY.test(f));

package/tests/routine_capture_kind.mjs

@@ -0,0 +1,147 @@
+// tests/routine_capture_kind.mjs — a routine that files its findings must name a
+// kind the server accepts (task 1003694).
+//
+// THE FAILURE THIS PINS. .claude/scheduled-tasks/dep-audit-nightly/SKILL.md filed
+// with `--kind security`. That is not one of the kinds — captureIdea throws BAD_KIND
+// and the route 400s — so the capture step of that nightly routine had NEVER filed
+// anything.
+//
+// It is quiet in the worst way. The routine still runs, still does the audit, and
+// only the step that turns a finding into a durable row fails. There is no
+// accumulating queue whose emptiness would look wrong, so nothing ever looked wrong.
+// A scheduled routine cannot notice its own silence, which is exactly why this is a
+// test and not a runtime check.
+//
+// Run:  node tests/routine_capture_kind.mjs
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync, readdirSync, existsSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const { VALID_KINDS } = require('../modules/ideas/inbox.js');
+
+const REPO_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+
+// Every SKILL.md that could carry a capture command: the scheduled routines and the
+// skills. A routine is the dangerous case (nobody reads its output), but a skill with
+// a bad kind wastes a builder's time the same way.
+function skillFiles() {
+  const out = [];
+  const roots = [
+    path.join(REPO_ROOT, '.claude', 'scheduled-tasks'),
+    path.join(REPO_ROOT, '.claude', 'skills'),
+  ];
+  for (const root of roots) {
+    if (!existsSync(root)) continue;
+    for (const d of readdirSync(root, { withFileTypes: true })) {
+      if (!d.isDirectory()) continue;
+      const p = path.join(root, d.name, 'SKILL.md');
+      if (existsSync(p)) out.push(p);
+    }
+  }
+  return out;
+}
+
+// `--kind foo` — a LITERAL kind, on a CAPTURE command only.
+//
+// Both narrowings are load-bearing, and I got each wrong first:
+//
+//   - CAPTURE ONLY. `--kind` is not unique to capture.js. recall.js takes its own
+//     `--kind doc|db`, and a matcher that reads every `--kind` in the tree reports
+//     three recall invocations as broken. A guard whose first run is mostly noise
+//     is a guard people learn to suppress.
+//   - LITERAL ONLY. A placeholder (`--kind <bug|cleanup>`, `--kind cleanup|refactor`)
+//     documents a CHOICE rather than passing a value; overnight-code-review and
+//     repo-simplify-sweep both use that form deliberately.
+const CAPTURE_LINE_RE = /capture\.js/;
+const KIND_RE = /--kind\s+([a-z][a-z0-9-]*)(?=[\s`'"]|$)/g;
+
+// A capture command can wrap across lines with a trailing backslash, so the unit of
+// inspection is the command, not the line: a run of lines joined while the previous
+// one ends in `\`.
+function captureCommands(text) {
+  const lines = String(text || '').split('\n');
+  const out = [];
+  let buf = null;
+  for (const line of lines) {
+    const continues = /\\\s*$/.test(line);
+    if (buf !== null) {
+      buf += ' ' + line;
+      if (!continues) { out.push(buf); buf = null; }
+    } else if (CAPTURE_LINE_RE.test(line)) {
+      if (continues) buf = line;
+      else out.push(line);
+    }
+  }
+  if (buf !== null) out.push(buf);
+  return out;
+}
+
+function literalKinds(text) {
+  const out = [];
+  for (const cmd of captureCommands(text)) {
+    for (const m of cmd.matchAll(KIND_RE)) {
+      const after = cmd.slice(m.index + m[0].length, m.index + m[0].length + 1);
+      if (after === '|') continue; // `--kind cleanup|refactor` — a menu, not a value
+      out.push(m[1]);
+    }
+  }
+  return out;
+}
+
+test('every literal --kind in a routine or skill is a kind the server accepts', () => {
+  const files = skillFiles();
+  // The scan must not pass by finding nothing: these files exist, and at least one of
+  // them documents a capture command.
+  assert.ok(files.length > 0, 'found no SKILL.md files at all — the scan is broken, not clean');
+
+  const bad = [];
+  let seen = 0;
+  for (const f of files) {
+    for (const kind of literalKinds(readFileSync(f, 'utf8'))) {
+      seen += 1;
+      if (!VALID_KINDS.includes(kind)) bad.push(`${path.relative(REPO_ROOT, f)}: --kind ${kind}`);
+    }
+  }
+  assert.ok(seen > 0, 'no literal --kind found anywhere — the pattern has drifted, and this test would pass an empty repo');
+  assert.deepEqual(bad, [],
+    `these file a kind the server rejects with a 400 — for a SCHEDULED routine that means its findings are silently never filed:\n  ${bad.join('\n  ')}\n`
+    + `Valid kinds: ${VALID_KINDS.join(', ')}`);
+});
+
+test('the matcher reads a literal kind on a capture command', () => {
+  assert.deepEqual(literalKinds('node scripts/gds/capture.js "t" --kind infra --body-file x'), ['infra']);
+  assert.deepEqual(literalKinds('node scripts/gds/capture.js "t" --kind security'), ['security'],
+    'the real bug is still caught');
+});
+
+test('a DIFFERENT tool\'s --kind is not this guard\'s business', () => {
+  // recall.js takes --kind doc|db. Reading every --kind in the tree reported three
+  // recall invocations as broken on the first run of this guard.
+  assert.deepEqual(literalKinds('node scripts/gds/recall.js nightly backup --kind doc'), []);
+  assert.deepEqual(literalKinds('add `--kind doc` for ADRs/recipes'), []);
+});
+
+test('a documented menu is not a value', () => {
+  assert.deepEqual(literalKinds('node scripts/gds/capture.js --kind <bug|cleanup|refactor>'), []);
+  assert.deepEqual(literalKinds('node scripts/gds/capture.js --kind cleanup|refactor \\'), []);
+});
+
+test('a capture command wrapped over lines is still read', () => {
+  const text = ['node scripts/gds/capture.js "t" \\', '  --kind security \\', '  --body-file /tmp/x'].join('\n');
+  assert.deepEqual(literalKinds(text), ['security'],
+    'dep-audit-nightly writes exactly this shape — a line-at-a-time matcher misses it');
+});
+
+test('dep-audit-nightly specifically now files with an accepted kind (task 1003694)', () => {
+  const p = path.join(REPO_ROOT, '.claude', 'scheduled-tasks', 'dep-audit-nightly', 'SKILL.md');
+  const src = readFileSync(p, 'utf8');
+  assert.ok(!/--kind\s+security\b/.test(src), 'security is not a kind and never was');
+  const kinds = literalKinds(src);
+  assert.ok(kinds.length > 0, 'the routine must still file something');
+  for (const k of kinds) assert.ok(VALID_KINDS.includes(k), `${k} is not a valid kind`);
+});

package/tests/skill_preflight.mjs

@@ -140,6 +140,51 @@ test('the live tree passes the declare-check', () => {
   assert.equal(r.hardFail, false, `unexpected:\n  ${r.violations.join('\n  ')}`);
 });
 
+// ---- CRLF (task 1003754) --------------------------------------------------
+//
+// Every regex in skill-preflight is anchored on \n, starting with the frontmatter
+// fence /^---\n/. SKILL.md files are CRLF in a Windows checkout — .gitattributes
+// pins *.js, *.json, *.sh and *.sql, but Markdown falls through `* text=auto` — so
+// the frontmatter never matched and parseRequires reported `declared: false` for
+// EVERY skill.
+//
+// The visible symptom was one red test below. The real damage was quieter: fitness
+// check G03 compares a skill's fenced commands against its declaration, and with
+// nothing parsed as declared it had nothing to compare — '0 declare a machine
+// contract'. The guard against a skill's ops commands outrunning its declaration was
+// INERT on Windows, which is a false green, not a false red.
+
+test('parseRequires reads a CRLF frontmatter identically to an LF one (task 1003754)', () => {
+  const lf = '---\nname: x\nrequires: [gh, main-checkout]\n---\nbody\n';
+  const crlf = lf.replace(/\n/g, '\r\n');
+  assert.deepEqual(sp.parseRequires(crlf), sp.parseRequires(lf),
+    'a checkout\'s line endings must not change what a skill is understood to require');
+  assert.deepEqual(sp.parseRequires(crlf).requires, ['gh', 'main-checkout']);
+  assert.equal(sp.parseRequires(crlf).declared, true);
+});
+
+test('the dash-list form survives CRLF too', () => {
+  const crlf = '---\r\nname: x\r\nrequires:\r\n  - gh\r\n  - droplet-ssh\r\n---\r\nbody\r\n';
+  assert.deepEqual(sp.parseRequires(crlf).requires, ['gh', 'droplet-ssh']);
+});
+
+test('inferRequired reads CRLF fenced commands (task 1003754)', () => {
+  // The half that would silently stop CATCHING an undeclared ops command.
+  const crlf = '---\r\nname: x\r\n---\r\n```bash\r\ngit push origin main\r\n```\r\n';
+  assert.ok(sp.inferRequired(crlf).includes('push-credential'),
+    'a main-push in a CRLF skill must still imply a push credential, or G03 cannot catch it');
+});
+
+test('the live corpus is NOT empty — G03 has something to compare (task 1003754)', () => {
+  // The check\'s own note read "0 declare a machine contract" on Windows. A guard
+  // with an empty corpus passes whatever the skills do.
+  const r = sp.checkOpsSkillsDeclareMachine();
+  const n = Number(/(\d+) declare a machine contract/.exec(r.note || '')?.[1] ?? 0);
+  assert.ok(n > 0,
+    `no skill parsed as declaring a machine contract, so check G03 has nothing to compare and `
+    + `cannot fail. Note was: ${r.note}`);
+});
+
 test('merge-mode really declares the machine it needs', () => {
   // The skill at the centre of the incident.
   const r = sp.preflightSkill('merge-mode', caps);