@bendyline/gilde 0.1.55 → 0.1.57

package/data/craftbook-templates/do/doc-rewrite/versions/1.0.3/test.json

@@ -1,110 +1,174 @@
 {
   "schemaVersion": 1,
-  "title": "Documentation Rewrite smoke eval",
-  "objective": "Self-contained smoke eval for the Documentation Rewrite craftbook using the external generic harness.",
+  "title": "Documentation Rewrite — confusing ops doc made usable",
+  "objective": "Measure whether the rewrite makes a genuinely confusing procedure usable WITHOUT losing any technical fact, which is the craftbook's own critical criterion.",
   "tags": [
-    "corpus"
+    "writing",
+    "documentation"
   ],
-  "prompt": "Theres a fake service set up for this so nothing real gets touched — details are in fixtures/fake-service.md. Can you work out the automation and write up how it woudl run in automation.md?",
+  "prompt": "Use the Documentation Rewrite craftbook on `docs/backup-restore.md`. It is the doc our on-call engineers complain about most. Produce the rewritten version at `rewritten-doc.md`. Do not edit the original.",
   "setup": {
-    "projectName": "Documentation Rewrite Eval",
-    "about": "Self-contained eval project for doc-rewrite. Seeded inputs are under workspace/source or workspace/fixtures; final deliverable is workspace/automation.md.",
-    "missionObjectives": "Use the Documentation Rewrite craftbook/template, read the seeded local fixtures, and write automation.md without network calls, real credentials, or live services.",
+    "projectName": "Doc Rewrite Eval",
+    "about": "A single confusing operations document is the only input. Everything needed is in the workspace; no network access and no live services.",
+    "missionObjectives": "Rewrite docs/backup-restore.md into rewritten-doc.md so an on-call engineer can follow it under pressure: prerequisites up front, numbered imperative steps in execution order, jargon defined on first use. Every technical fact in the original must survive the rewrite — dropping one is the failure mode this task exists to catch. Leave the original file unchanged.",
     "files": [
       {
-        "path": "source/brief.md",
-        "content": "# Documentation Rewrite Eval Brief\n\nClient: Boreal Desk, a home-office accessories company.\nAudience: operations leads who need an artifact they can use this week.\n\nFixed source facts for grounding:\n- The returns desk pilot covered 18 SKUs.\n- Median first response improved from 18 hours to 6 hours.\n- Preventable refund leakage fell from 14.2% to 8.9%.\n- The top unresolved complaint is status silence after photo submission.\n- Required next actions are automated status emails, barcode-exception training, and a weekly Finance exception export.\n\nUse these facts when the task asks for prose, analysis, copy, UI content, or test data. Do not use live web services, real credentials, or current outside data.\n\nCraftbook under test: doc-rewrite - Documentation Rewrite.\n"
-      },
-      {
-        "path": "fixtures/fake-service.md",
-        "content": "# Fake Service Fixture\n\nThis eval must stay in dry-run mode.\n\nAvailable fake endpoints and commands:\n- GET /api/bookings/open returns BKG-1001, BKG-1002, BKG-1003.\n- POST /api/bookings/dry-run records a simulated submission and returns DRY_RUN_OK.\n- fake-ci status returns pending twice and success on the third poll.\n- fake-github pr create returns https://example.invalid/pull/42.\n\nThe deliverable must reference these fixture names instead of real services or credentials.\n"
+        "path": "docs/backup-restore.md",
+        "content": "# Backup and Restore\n\nBackups are taken by the platform automatically. The RPO for the tier-1 stores is 15 minutes,\nand it should be noted that snapshots older than 14 days are garbage-collected and cannot be\nrestored from, so restores must be initiated within that window.\n\nRestoring is done by running the restore tool. Before this can be done it is necessary that the\noperator has been granted the ops-admin role, otherwise the command will be rejected. The\nsnapshot id can be found by listing snapshots. The verification flag should always be passed so\nthat the restored copy is checked against the manifest; skipping it has caused silent corruption\nto be shipped in the past.\n\nThe command is `gezel-restore --snapshot <id> --verify`. It is also worth mentioning that the\nservice must be drained first, which is done from the ops console, and that the restore will\nfail if the target volume has less than 2x the snapshot size free.\n\nAfter the restore has completed the service can be undrained. Post-restore the integrity report\nis written to /var/log/gezel/restore-report.json and this should be reviewed before undraining.\n"
       }
     ],
     "worker": {
-      "name": "Jules",
-      "role": "Developer"
+      "name": "Wieke",
+      "role": "Copywriter"
+    },
+    "craftbookParams": {
+      "workPath": "tasks/eval"
     }
   },
   "mocks": [],
   "success": {
-    "summary": "automation.md is a dry-run external-automation artifact grounded in fake service fixtures.",
+    "summary": "rewritten-doc.md is a usable procedure that preserves every fact from the original, and the audit that drove it is on record.",
     "deliverables": [
       {
-        "path": "automation.md",
+        "path": "tasks/eval/audit.md",
+        "kind": "markdown-notes",
+        "artifact": true,
+        "minBytes": 250,
+        "checks": [
+          {
+            "kind": "contains",
+            "file": "tasks/eval/audit.md",
+            "pattern": "RPO|jargon|acronym",
+            "flags": "i",
+            "label": "names the undefined jargon",
+            "artifact": true
+          },
+          {
+            "kind": "contains",
+            "file": "tasks/eval/audit.md",
+            "pattern": "prerequisit|ops-admin|up front",
+            "flags": "i",
+            "label": "names the buried prerequisite",
+            "artifact": true
+          }
+        ]
+      },
+      {
+        "path": "rewritten-doc.md",
         "kind": "markdown-report",
         "minBytes": 900,
         "checks": [
           {
             "kind": "contains",
-            "file": "automation.md",
-            "pattern": "(?:^|\\n)#{1,3}\\s+\\S",
-            "flags": "i"
+            "file": "rewritten-doc.md",
+            "pattern": "14[\\s-]?day|14 days",
+            "flags": "i",
+            "label": "preserves the 14-day restore window"
+          },
+          {
+            "kind": "contains",
+            "file": "rewritten-doc.md",
+            "pattern": "gezel-restore --snapshot",
+            "flags": "i",
+            "label": "preserves the exact command"
+          },
+          {
+            "kind": "contains",
+            "file": "rewritten-doc.md",
+            "pattern": "--verify",
+            "flags": "i",
+            "label": "preserves the verification flag"
+          },
+          {
+            "kind": "contains",
+            "file": "rewritten-doc.md",
+            "pattern": "ops-admin",
+            "flags": "i",
+            "label": "preserves the required role"
+          },
+          {
+            "kind": "contains",
+            "file": "rewritten-doc.md",
+            "pattern": "2x|twice the snapshot|two times the snapshot",
+            "flags": "i",
+            "label": "preserves the free-space requirement"
+          },
+          {
+            "kind": "contains",
+            "file": "rewritten-doc.md",
+            "pattern": "restore-report\\.json",
+            "flags": "i",
+            "label": "preserves the integrity-report path"
           },
           {
             "kind": "contains",
-            "file": "automation.md",
-            "pattern": "DRY_RUN_OK|dry-run|dry run",
-            "flags": "i"
+            "file": "rewritten-doc.md",
+            "pattern": "recovery[\\s-]point[\\s-]objective",
+            "flags": "i",
+            "label": "defines RPO on first use"
           },
           {
             "kind": "contains",
-            "file": "automation.md",
-            "pattern": "fake-ci|fake-github|/api/bookings",
-            "flags": "i"
+            "file": "rewritten-doc.md",
+            "pattern": "(?:^|\\n)#{1,3}\\s*[^\\n]*(prerequisit|before you (begin|start)|requirements)",
+            "flags": "i",
+            "label": "prerequisites are a section, not buried prose"
           },
           {
             "kind": "contains",
-            "file": "automation.md",
-            "pattern": "no real|credentials|safety|guard",
-            "flags": "i"
+            "file": "rewritten-doc.md",
+            "pattern": "(?:^|\\n)\\s*1\\.\\s+\\S",
+            "flags": "",
+            "label": "numbered procedure"
           },
           {
             "kind": "contains",
-            "file": "automation.md",
-            "pattern": "success|failure|retry|abort",
-            "flags": "i"
+            "file": "rewritten-doc.md",
+            "pattern": "(?:^|\\n)\\s*2\\.\\s+\\S",
+            "flags": "",
+            "label": "more than one numbered step"
+          },
+          {
+            "kind": "contains",
+            "file": "rewritten-doc.md",
+            "pattern": "drain",
+            "flags": "i",
+            "label": "preserves the drain-before-restore step"
           }
         ]
       }
+    ],
+    "unchangedFixtures": [
+      "docs/backup-restore.md"
     ]
   },
   "rubric": {
     "artifact": {
-      "path": "automation.md",
+      "path": "rewritten-doc.md",
       "kind": "markdown"
     },
     "axes": [
       {
-        "name": "safety",
-        "description": "Dry-run posture is explicit: no real credentials, clear stop-before-side-effect boundary."
+        "name": "fact-preservation",
+        "description": "Every technical fact, value, path, flag and constraint in the original survives the rewrite."
       },
       {
-        "name": "mapping",
-        "description": "Fake endpoints/commands are mapped completely to the workflow steps."
+        "name": "structure",
+        "description": "Prerequisites come first and the procedure is ordered, numbered steps in execution order."
       },
       {
-        "name": "signals",
-        "description": "Success, failure, retry, and abort conditions are all defined."
+        "name": "clarity",
+        "description": "Jargon is defined on first use and instructions are imperative and unambiguous."
       },
       {
-        "name": "containment",
-        "description": "The plan cannot accidentally reach a real service from a mock context."
+        "name": "usability",
+        "description": "An on-call engineer could follow this under pressure without consulting the original."
       }
     ]
   },
   "qualityFocus": [
-    "dry-run safety",
-    "fake tool mapping",
-    "side-effect containment"
-  ],
-  "extensions": {
-    "legacySimulators": [
-      {
-        "id": "doc-rewrite-fake-service-fixture",
-        "kind": "data-source",
-        "status": "implemented",
-        "description": "Seeded local fake service contract replacing live CLIs, HTTP APIs, credentials, and side effects."
-      }
-    ]
-  }
+    "fact preservation",
+    "procedure structure",
+    "defined jargon"
+  ]
 }

package/data/craftbook-templates/do/dockerize-app/versions/1.0.4/craftbook.json

@@ -0,0 +1,285 @@
+{
+  "id": "dockerize-app",
+  "name": "Containerize a Service",
+  "description": "Containerize an application with a production-grade Dockerfile — small, secure, reproducible, and buildable — plus the supporting files to run it. Scopes the container contract FIRST — base image, build vs runtime stages, dependencies, exposed port, entrypoint, env config, and the size/security bar — then writes the Dockerfile + .dockerignore + compose, then a reviewer confirms it builds, runs, and meets the bar. Covers multi-stage builds, slim base images, layer caching, non-root user, .dockerignore, healthchecks, EXPOSE/ENTRYPOINT, and reproducible image builds.\n\nA gallery craftbook generated from an archetype spec. It runs\n`phase → (per-phase gate) → … → evaluate → (loop) → finish`. Each build\nphase that produces a checkable artifact is followed by a **runtime\ngate-checkpoint** — the runtime verifies the artifact and routes with no\nmodel turn, looping back to redo the phase on a miss. The final `evaluate`\nstep holds a static deliverable gate plus a reviewer QA pass. What it adds\nover the generic `build-loop`: a specialist role per phase, a\ndomain-correct ordering, and a concrete per-phase quality bar.\n\nDeliverables marked \"artifact\" land in the project's artifacts drawer (`write_artifact` / `read_artifact`), not the shipped workspace — review output is not product source.\n\nPhases:\n\n1. Scope the container (planner) — lock base image, stages, port, entrypoint, bar → gated on artifact `{{workPath}}/scope.md` (markdown-notes)\n2. Write the Dockerfile (developer) — implement the multi-stage Dockerfile + support files → gated on `Dockerfile` (code-module)\n3. Verify the image (reviewer) — confirm it builds, runs, and meets the bar → gated on artifact `{{workPath}}/verify.md` (markdown-notes)\n\nThe gates never advance with an unmet criterion, and loop back to the\nowning phase to fix named gaps.\n",
+  "entryStepId": "scope",
+  "triggers": [
+    "dockerize this app",
+    "write a dockerfile",
+    "containerize a service",
+    "create a docker image",
+    "docker compose setup"
+  ],
+  "paramSchema": {
+    "type": "object",
+    "properties": {
+      "workPath": {
+        "type": "string",
+        "title": "Working folder",
+        "description": "Per-task working folder in the artifacts drawer. Defaults to this task's own folder so runs never collide; override with a stable name when you deliberately want runs to share files.",
+        "default": "{{task.dir}}"
+      }
+    }
+  },
+  "steps": [
+    {
+      "id": "scope",
+      "name": "Scope the container",
+      "description": "lock base image, stages, port, entrypoint, bar",
+      "prompt": "Scope the container before writing the Dockerfile. Step 1: Identify the runtime (language/version) and pick a slim, pinned base image. Step 2: Decide the build strategy: a multi-stage build (build deps in one stage, copy only artifacts to a slim runtime stage) and what gets copied forward. Step 3: List the dependencies to install, the port to EXPOSE, the ENTRYPOINT/CMD, and the env vars the app needs at runtime. Step 4: Set the bar: run as a non-root user, a .dockerignore that excludes junk, a healthcheck, and a rough image-size target. Step 5: Write a numbered acceptance-criteria checklist of 5-9 items (e.g. 'docker build succeeds from a clean context', 'the container starts and serves on the exposed port', 'runs as non-root', 'final image uses a multi-stage slim base'). `write_task_note` the scope + checklist and write the same to the produces path.\n\nThe deliverable `{{workPath}}/scope.md` lands in the project's artifacts drawer — write it with `write_artifact` and read it back with `read_artifact`; the shipped workspace stays untouched.",
+      "suggestedRole": "planner",
+      "toolPolicy": {
+        "disallowBuiltinToolsets": [
+          "ai-apps",
+          "archives",
+          "audio",
+          "browser-automation",
+          "code-execution",
+          "craftbooks",
+          "data-tables",
+          "entity-intel",
+          "git",
+          "image-intel",
+          "images",
+          "role-delegation",
+          "role-delegation-escalation",
+          "security-intel",
+          "team-management",
+          "videos",
+          "web",
+          "workspace-fs-write"
+        ],
+        "outputMedium": "artifact",
+        "additionalOutputMedia": [
+          "task-note"
+        ]
+      },
+      "advanceWhen": {
+        "file": "{{workPath}}/scope.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "{{workPath}}/scope.md",
+            "bytes": 120,
+            "artifact": true
+          },
+          {
+            "kind": "sniff",
+            "file": "{{workPath}}/scope.md",
+            "sniff": "nonempty",
+            "artifact": true
+          }
+        ],
+        "onReject": "scope",
+        "maxAttempts": 3
+      },
+      "next": "build"
+    },
+    {
+      "id": "build",
+      "name": "Write the Dockerfile",
+      "description": "implement the multi-stage Dockerfile + support files",
+      "prompt": "Author the containerization files to the scope. Step 1: Write a multi-stage `Dockerfile` — a build stage that installs deps and builds, then a slim runtime stage that copies only the needed artifacts. Step 2: Order layers for cache efficiency (copy manifest + install deps BEFORE copying source), pin the base image, set a non-root USER, EXPOSE the port, and define ENTRYPOINT/CMD and a HEALTHCHECK. Step 3: Write a `.dockerignore` that excludes node_modules, .git, build output, and secrets. Step 4: If a service needs orchestration, add a minimal compose/run file. Step 5: Build the image and confirm it succeeds and the container starts. Write the Dockerfile to the produces path. On a loop-back, fix only the named gaps. `write_task_note` the file paths and which criteria now pass.",
+      "suggestedRole": "developer",
+      "toolPolicy": {
+        "disallowBuiltinToolsets": [
+          "ai-apps",
+          "archives",
+          "artifacts",
+          "audio",
+          "browser-automation",
+          "code-execution",
+          "craftbooks",
+          "data-tables",
+          "entity-intel",
+          "image-intel",
+          "images",
+          "role-delegation",
+          "role-delegation-escalation",
+          "security-intel",
+          "team-management",
+          "videos",
+          "web"
+        ],
+        "outputMedium": "workspace",
+        "additionalOutputMedia": [
+          "task-note"
+        ]
+      },
+      "advanceWhen": {
+        "file": "Dockerfile",
+        "minBytes": 1,
+        "sniff": "nonempty"
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "Dockerfile",
+            "bytes": 200
+          },
+          {
+            "kind": "sniff",
+            "file": "Dockerfile",
+            "sniff": "nonempty"
+          },
+          {
+            "kind": "esmImports",
+            "file": "Dockerfile"
+          },
+          {
+            "kind": "sourceParses",
+            "file": "Dockerfile"
+          }
+        ],
+        "onReject": "build",
+        "maxAttempts": 3
+      },
+      "next": "verify"
+    },
+    {
+      "id": "verify",
+      "name": "Verify the image",
+      "description": "confirm it builds, runs, and meets the bar",
+      "prompt": "Verify the container build. Step 1: Build the image from a clean context and confirm the build succeeds. Step 2: Run the container and confirm it starts and serves on the exposed port (hit the healthcheck/endpoint). Step 3: Confirm the bar: multi-stage slim base, non-root user, a real .dockerignore, pinned base image, and a sane final size. Step 4: Confirm no secrets or junk were baked into the image layers. Write a verification note with the build result, run check, and size to the produces path.\n\nThe deliverable `{{workPath}}/verify.md` lands in the project's artifacts drawer — write it with `write_artifact` and read it back with `read_artifact`; the shipped workspace stays untouched.",
+      "suggestedRole": "reviewer",
+      "toolPolicy": {
+        "disallowBuiltinToolsets": [
+          "ai-apps",
+          "archives",
+          "audio",
+          "browser-automation",
+          "code-execution",
+          "craftbooks",
+          "data-tables",
+          "entity-intel",
+          "git",
+          "image-intel",
+          "images",
+          "role-delegation",
+          "role-delegation-escalation",
+          "security-intel",
+          "team-management",
+          "videos",
+          "web",
+          "workspace-fs-write"
+        ],
+        "outputMedium": "artifact",
+        "additionalOutputMedia": [
+          "task-note"
+        ]
+      },
+      "advanceWhen": {
+        "file": "{{workPath}}/verify.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "Dockerfile",
+            "bytes": 200
+          },
+          {
+            "kind": "sniff",
+            "file": "Dockerfile",
+            "sniff": "nonempty"
+          },
+          {
+            "kind": "esmImports",
+            "file": "Dockerfile"
+          },
+          {
+            "kind": "sourceParses",
+            "file": "Dockerfile"
+          }
+        ],
+        "onReject": "verify",
+        "maxAttempts": 4
+      },
+      "next": "evaluate"
+    },
+    {
+      "id": "evaluate",
+      "name": "Evaluate",
+      "description": "Grade the deliverable against every acceptance criterion. All pass → finish; any fail → loop back and fix the gap.",
+      "prompt": "Build and run the image. For EACH acceptance criterion: confirm `docker build` succeeds from a clean context, confirm the container starts and serves on the exposed port, confirm it runs as non-root with a multi-stage slim base and a .dockerignore, and confirm no secrets/junk were baked in. Write PASS/FAIL per criterion.\n\nThen route — this is the whole point of the loop:\n\n- **Every criterion PASSES →** call `advance_task_step({ ref, stepId: \"evaluate\", next: \"finish\" })`.\n- **Any criterion FAILS →** write the specific gaps to notes, then call `advance_task_step({ ref, stepId: \"evaluate\", next: \"build\" })` to loop back. The builder fixes exactly those gaps.\n\nNever route to `finish` while any criterion is unmet. The build phase's completion gate already blocked a grossly-incomplete deliverable; your job is the judgment an automated check cannot make (does it actually work, read well, look right). After ~3 unproductive loops, stop and report DONE_WITH_CONCERNS so the user can step in.",
+      "suggestedRole": "reviewer",
+      "toolPolicy": {
+        "disallowBuiltinToolsets": [
+          "ai-apps",
+          "archives",
+          "artifacts",
+          "audio",
+          "browser-automation",
+          "code-execution",
+          "craftbooks",
+          "data-tables",
+          "entity-intel",
+          "git",
+          "image-intel",
+          "images",
+          "role-delegation",
+          "role-delegation-escalation",
+          "security-intel",
+          "team-management",
+          "videos",
+          "web",
+          "workspace-fs-write"
+        ],
+        "outputMedium": "task-note"
+      },
+      "consumes": [
+        {
+          "file": "Dockerfile"
+        }
+      ],
+      "next": "build"
+    },
+    {
+      "id": "finish",
+      "name": "Finish",
+      "description": "All acceptance criteria met. Stamp a short summary and report DONE.",
+      "prompt": "Every acceptance criterion passed. Write a one-paragraph DONE summary to task notes via `write_task_note`: what was built, the deliverable path(s), and a one-line confirmation that each criterion is met. Then report DONE.",
+      "suggestedRole": "developer",
+      "toolPolicy": {
+        "disallowBuiltinToolsets": [
+          "ai-apps",
+          "archives",
+          "artifacts",
+          "audio",
+          "browser-automation",
+          "code-execution",
+          "craftbooks",
+          "data-tables",
+          "entity-intel",
+          "git",
+          "image-intel",
+          "images",
+          "role-delegation",
+          "role-delegation-escalation",
+          "security-intel",
+          "team-management",
+          "videos",
+          "web",
+          "workspace-fs-write"
+        ],
+        "outputMedium": "task-note"
+      },
+      "terminal": true
+    }
+  ],
+  "version": "1.0.4",
+  "releasedAt": "2026-09-05T03:30:00Z",
+  "minGezelVersion": "1.26233"
+}

package/data/craftbook-templates/do/dockerize-app/versions/1.0.4/test.json

@@ -0,0 +1,92 @@
+{
+  "schemaVersion": 1,
+  "title": "Containerize a Service smoke eval",
+  "objective": "Self-contained smoke eval for the Containerize a Service craftbook using the code generic harness.",
+  "tags": [
+    "code"
+  ],
+  "prompt": "We need a small Node helper for this — the requirments are in source/requirements.md. Put it in src/solution.mjs.",
+  "setup": {
+    "projectName": "Containerize a Service Eval",
+    "about": "Self-contained eval project for dockerize-app. Seeded inputs are under workspace/source or workspace/fixtures; final deliverable is workspace/src/solution.mjs.",
+    "missionObjectives": "Use the Containerize a Service craftbook/template, read the seeded local fixtures, and write src/solution.mjs without network calls, real credentials, or live services.",
+    "files": [
+      {
+        "path": "source/brief.md",
+        "content": "# Containerize a Service Eval Brief\n\nClient: Boreal Desk, a home-office accessories company.\nAudience: operations leads who need an artifact they can use this week.\n\nFixed source facts for grounding:\n- The returns desk pilot covered 18 SKUs.\n- Median first response improved from 18 hours to 6 hours.\n- Preventable refund leakage fell from 14.2% to 8.9%.\n- The top unresolved complaint is status silence after photo submission.\n- Required next actions are automated status emails, barcode-exception training, and a weekly Finance exception export.\n\nUse these facts when the task asks for prose, analysis, copy, UI content, or test data. Do not use live web services, real credentials, or current outside data.\n\nCraftbook under test: dockerize-app - Containerize a Service.\n"
+      },
+      {
+        "path": "source/requirements.md",
+        "content": "# Runner Requirements\n\nBuild a dependency-free Node ESM helper for Boreal Desk support operations. Export at least one function. Include a tiny self-test section using node:assert or an equivalent assertion helper. Use fixture values for 18 -> 6 hour response time and 14.2 -> 8.9 refund leakage.\n"
+      }
+    ],
+    "worker": {
+      "name": "Jules",
+      "role": "Developer"
+    }
+  },
+  "mocks": [],
+  "success": {
+    "summary": "src/solution.mjs is a local ESM module with basic self-test scaffolding.",
+    "deliverables": [
+      {
+        "path": "src/solution.mjs",
+        "kind": "code-with-tests",
+        "minBytes": 1500,
+        "checks": [
+          {
+            "kind": "esmImports",
+            "file": "src/solution.mjs"
+          },
+          {
+            "kind": "contains",
+            "file": "src/solution.mjs",
+            "pattern": "export\\s+(function|const|class)|export\\s*\\{",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "src/solution.mjs",
+            "pattern": "assert|test|describe|it|expect",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "src/solution.mjs",
+            "pattern": "18|6|14\\.2|8\\.9|Boreal",
+            "flags": "i"
+          }
+        ]
+      }
+    ]
+  },
+  "rubric": {
+    "artifact": {
+      "path": "src/solution.mjs",
+      "kind": "typescript"
+    },
+    "axes": [
+      {
+        "name": "correctness",
+        "description": "The module does what the requirements ask, with sensible edge handling."
+      },
+      {
+        "name": "verification",
+        "description": "Self-tests exercise real behavior, not trivial truths."
+      },
+      {
+        "name": "clarity",
+        "description": "Exports, naming, and structure make the module usable without reading every line."
+      },
+      {
+        "name": "robustness",
+        "description": "Invalid input and boundary cases fail loudly rather than silently."
+      }
+    ]
+  },
+  "qualityFocus": [
+    "runnable ESM",
+    "test scaffolding",
+    "local fixtures"
+  ]
+}