@bendyline/gilde 0.1.51 → 0.1.53

package/data/craftbook-templates/re/refactor-module/versions/2.0.1/test.json

@@ -0,0 +1,241 @@
+{
+  "schemaVersion": 1,
+  "title": "Behavior-preserving extraction of duplicated logic",
+  "objective": "The craftbook drives a disciplined refactor of copy-pasted name-normalization logic: a green baseline recorded before anything moves, reversible stages with the suite green throughout, a re-measured duplication target, and an enforced review — verified mechanically via a reference matrix across both call sites, a duplication count across src/, and a green-suite run.",
+  "tags": [
+    "code",
+    "refactor",
+    "tactical-fleet"
+  ],
+  "prompt": "Use the Behavior-Preserving Refactor craftbook for this: the same name-normalization logic is copy-pasted in src/format-name.js and src/report.js, and the copies have drifted once already. The brief is in source/refactor-brief.md. Extract the shared logic into a new src/normalize-name.js used by both files, without changing behavior.",
+  "setup": {
+    "projectName": "Crewlog",
+    "about": "A tiny crew-hours logging module. Tests run with `npm run test` (node --test).",
+    "files": [
+      {
+        "path": "package.json",
+        "content": "{\n  \"name\": \"crewlog\",\n  \"private\": true,\n  \"version\": \"1.0.0\",\n  \"type\": \"module\",\n  \"scripts\": {\n    \"test\": \"node --test\"\n  }\n}\n"
+      },
+      {
+        "path": "src/format-name.js",
+        "content": "export function formatName(raw) {\n  const words = String(raw).trim().split(/\\s+/);\n  const fixed = [];\n  for (const word of words) {\n    fixed.push(word.charAt(0).toUpperCase() + word.slice(1).toLowerCase());\n  }\n  return fixed.join(' ');\n}\n"
+      },
+      {
+        "path": "src/report.js",
+        "content": "function titleCaseName(raw) {\n  const words = String(raw).trim().split(/\\s+/);\n  const fixed = [];\n  for (const word of words) {\n    fixed.push(word.charAt(0).toUpperCase() + word.slice(1).toLowerCase());\n  }\n  return fixed.join(' ');\n}\n\nexport function reportLine(entry) {\n  return titleCaseName(entry.name) + ': ' + entry.hours + 'h';\n}\n\nexport function reportSummary(entries) {\n  return entries.map((entry) => reportLine(entry)).join('\\n');\n}\n"
+      },
+      {
+        "path": "tests/format.test.mjs",
+        "content": "import assert from 'node:assert/strict';\nimport { test } from 'node:test';\nimport { formatName } from '../src/format-name.js';\n\ntest('formats a messy name', () => {\n  assert.equal(formatName('  ada   lovelace '), 'Ada Lovelace');\n});\n"
+      },
+      {
+        "path": "tests/report.test.mjs",
+        "content": "import assert from 'node:assert/strict';\nimport { test } from 'node:test';\nimport { reportLine } from '../src/report.js';\n\ntest('report line normalizes the name', () => {\n  assert.equal(reportLine({ name: 'grace hopper', hours: 2 }), 'Grace Hopper: 2h');\n});\n"
+      },
+      {
+        "path": "source/refactor-brief.md",
+        "content": "# Refactor brief\n\nThe same name-normalization logic (trim, collapse inner whitespace, title-case each word) is copy-pasted in two places:\n\n- src/format-name.js - `formatName`, used by the profile screens\n- src/report.js - a private `titleCaseName` helper feeding `reportLine`\n\nThe copies drifted once before and had to be manually re-synced. Extract the shared logic into a NEW `src/normalize-name.js` module used by both files, WITHOUT changing behavior. Every output must stay byte-for-byte identical, including edge cases: extra inner spaces, ALL-CAPS input, single letters, and the empty string. Public exports must survive unchanged: `formatName`, `reportLine`, and `reportSummary` keep their names and signatures.\n"
+      },
+      {
+        "path": "tests/verify-refactor.mjs",
+        "content": "import assert from 'node:assert/strict';\nimport { execFileSync } from 'node:child_process';\nimport { readFileSync, readdirSync } from 'node:fs';\nimport { join } from 'node:path';\nimport { formatName } from '../src/format-name.js';\nimport { reportLine, reportSummary } from '../src/report.js';\n\n// 1) Behavior: a reference matrix across BOTH call sites, quirks included.\nconst matrix = [\n  ['  ada   lovelace ', 'Ada Lovelace'],\n  ['GRACE HOPPER', 'Grace Hopper'],\n  ['katherine  g.  johnson', 'Katherine G. Johnson'],\n  ['a', 'A'],\n  ['', ''],\n];\nfor (const [input, expected] of matrix) {\n  assert.equal(formatName(input), expected, 'formatName(' + JSON.stringify(input) + ')');\n}\nassert.equal(reportLine({ name: '  grace   HOPPER ', hours: 4 }), 'Grace Hopper: 4h');\nassert.equal(reportLine({ name: 'ada lovelace', hours: 2 }), 'Ada Lovelace: 2h');\nassert.equal(\n  reportSummary([\n    { name: 'ADA   LOVELACE', hours: 1 },\n    { name: ' mary jackson ', hours: 3 },\n  ]),\n  'Ada Lovelace: 1h\\nMary Jackson: 3h',\n);\nconsole.log('REFACTOR_MODULE_ORACLE behavior ok');\n\n// 2) Deduplication: the title-case implementation exists at most once\n// across src/ - two surviving copies mean the extraction did not happen.\nconst root = process.cwd();\nfunction countMarker(relDir) {\n  let count = 0;\n  for (const entry of readdirSync(join(root, relDir), { withFileTypes: true })) {\n    const relPath = relDir + '/' + entry.name;\n    if (entry.isDirectory()) {\n      count += countMarker(relPath);\n    } else if (/\\.(js|mjs|cjs|ts)$/.test(entry.name)) {\n      const text = readFileSync(join(root, relPath), 'utf8');\n      count += (text.match(/toUpperCase/g) ?? []).length;\n    }\n  }\n  return count;\n}\nconst occurrences = countMarker('src');\nassert.ok(\n  occurrences <= 1,\n  'the title-case implementation appears ' + occurrences + ' times across src/ - the duplication was not extracted to one shared place',\n);\nconsole.log('REFACTOR_MODULE_ORACLE dedupe ok');\n\n// 3) The whole suite is green on the refactored tree (real run).\nfunction runSuite(cwd) {\n  try {\n    execFileSync(process.execPath, ['--test'], { cwd, stdio: 'pipe', timeout: 30000 });\n    return 0;\n  } catch (err) {\n    return typeof err.status === 'number' ? err.status : 1;\n  }\n}\nassert.equal(runSuite(root), 0, 'the suite must be green on the refactored tree');\nconsole.log('REFACTOR_MODULE_ORACLE suite green');\nconsole.log('REFACTOR_MODULE_ORACLE done');\n",
+        "surface": "harness"
+      }
+    ],
+    "craftbookParams": {
+      "scope": "Extract the duplicated name normalization in src/format-name.js and src/report.js into a shared src/normalize-name.js used by both, without changing behavior; see source/refactor-brief.md."
+    }
+  },
+  "mocks": [],
+  "success": {
+    "summary": "The duplicated normalization lives in exactly one place, both call sites behave byte-for-byte as before (reference matrix), the suite is green on a real run, and every fleet artifact exists with honest citations.",
+    "deliverables": [
+      {
+        "path": "{{task.dir}}/baseline.md",
+        "kind": "markdown-notes",
+        "artifact": true,
+        "minBytes": 500,
+        "checks": [
+          {
+            "kind": "contains",
+            "file": "{{task.dir}}/baseline.md",
+            "pattern": "^##\\s+Current behavior[\\s\\S]*^##\\s+Measurements[\\s\\S]*^##\\s+Guardrail",
+            "flags": "im",
+            "label": "baseline sections in order"
+          },
+          {
+            "kind": "citationsResolve",
+            "file": "{{task.dir}}/baseline.md",
+            "minCitations": 2,
+            "artifact": true
+          }
+        ]
+      },
+      {
+        "path": "{{task.dir}}/plan.md",
+        "kind": "markdown-notes",
+        "artifact": true,
+        "minBytes": 500,
+        "checks": [
+          {
+            "kind": "contains",
+            "file": "{{task.dir}}/plan.md",
+            "pattern": "^##\\s+Target[\\s\\S]*^##\\s+Stages[\\s\\S]*^##\\s+Acceptance criteria",
+            "flags": "im",
+            "label": "plan sections in order"
+          },
+          {
+            "kind": "citationsResolve",
+            "file": "{{task.dir}}/plan.md",
+            "minCitations": 2,
+            "artifact": true
+          }
+        ]
+      },
+      {
+        "path": "{{task.dir}}/change-notes.md",
+        "kind": "markdown-notes",
+        "artifact": true,
+        "minBytes": 600,
+        "checks": [
+          {
+            "kind": "contains",
+            "file": "{{task.dir}}/change-notes.md",
+            "pattern": "^##\\s+Stages executed[\\s\\S]*^##\\s+Files touched[\\s\\S]*^##\\s+Deviations from plan",
+            "flags": "im",
+            "label": "change-notes sections in order"
+          },
+          {
+            "kind": "citationsResolve",
+            "file": "{{task.dir}}/change-notes.md",
+            "minCitations": 2,
+            "artifact": true
+          }
+        ]
+      },
+      {
+        "path": "{{task.dir}}/verification.md",
+        "kind": "markdown-notes",
+        "artifact": true,
+        "minBytes": 400,
+        "checks": [
+          {
+            "kind": "contains",
+            "file": "{{task.dir}}/verification.md",
+            "pattern": "^##\\s+Before\\s*/\\s*after[\\s\\S]*^##\\s+Suite[\\s\\S]*^##\\s+Result",
+            "flags": "im",
+            "label": "verification sections in order"
+          },
+          {
+            "kind": "contains",
+            "file": "{{task.dir}}/verification.md",
+            "pattern": "^##\\s+Before\\s*/\\s*after[\\s\\S]*\\d",
+            "flags": "im",
+            "label": "before/after figures quoted"
+          }
+        ]
+      },
+      {
+        "path": "{{task.dir}}/review.md",
+        "kind": "markdown-report",
+        "artifact": true,
+        "minBytes": 400,
+        "checks": [
+          {
+            "kind": "contains",
+            "file": "{{task.dir}}/review.md",
+            "pattern": "Verdict:\\s*(?:PASS|REVISE)",
+            "flags": "i",
+            "label": "explicit reviewer verdict"
+          }
+        ]
+      }
+    ],
+    "checks": [
+      {
+        "kind": "notContains",
+        "file": "src/format-name.js",
+        "pattern": "toUpperCase",
+        "label": "format-name.js no longer carries its own title-case copy"
+      },
+      {
+        "kind": "notContains",
+        "file": "src/report.js",
+        "pattern": "toUpperCase",
+        "label": "report.js no longer carries its own title-case copy"
+      },
+      {
+        "kind": "sourceParses",
+        "file": "src/format-name.js"
+      },
+      {
+        "kind": "sourceParses",
+        "file": "src/report.js"
+      },
+      {
+        "kind": "nodeScriptPasses",
+        "script": "tests/verify-refactor.mjs",
+        "timeoutMs": 60000,
+        "requiredOutput": [
+          {
+            "pattern": "REFACTOR_MODULE_ORACLE behavior ok",
+            "label": "both call sites match the reference matrix"
+          },
+          {
+            "pattern": "REFACTOR_MODULE_ORACLE dedupe ok",
+            "label": "the implementation exists at most once across src/"
+          },
+          {
+            "pattern": "REFACTOR_MODULE_ORACLE suite green",
+            "label": "suite green on the refactored tree"
+          }
+        ]
+      }
+    ],
+    "taskNotes": {
+      "minBytes": 120,
+      "checks": [
+        {
+          "kind": "contains",
+          "file": "task-notes.md",
+          "pattern": "\\bDONE\\b[\\s\\S]*(npm\\s+run\\s+test|node\\s+--test)",
+          "flags": "i",
+          "label": "DONE note names the real test command"
+        }
+      ]
+    },
+    "taskGraph": {
+      "requireCraftbookTask": true,
+      "requireTerminalStep": true
+    },
+    "unchangedFixtures": [
+      "source/refactor-brief.md",
+      "package.json"
+    ]
+  },
+  "rubric": {
+    "artifact": {
+      "path": "{{task.dir}}/change-notes.md",
+      "kind": "markdown"
+    },
+    "axes": [
+      {
+        "name": "Guardrail-first discipline",
+        "description": "The suite was genuinely run and recorded green before any restructuring, characterization coverage was considered honestly, and the baseline counted the duplication with a stated method."
+      },
+      {
+        "name": "Reversible-stage execution",
+        "description": "The restructure happened in small planned stages at the real sites, with the suite kept green between stages and deviations recorded honestly rather than papered over."
+      },
+      {
+        "name": "Genuine deduplication",
+        "description": "One shared implementation remains, both call sites use it, public exports survived unchanged, and no behavior change was smuggled in under cover of the refactor."
+      }
+    ]
+  },
+  "qualityFocus": [
+    "green-before/green-after receipts",
+    "same-method re-measurement",
+    "enforced review loop"
+  ]
+}

package/data/craftbook-templates/re/regex-builder/versions/1.0.3/craftbook.json

@@ -0,0 +1,283 @@
+{
+  "id": "regex-builder",
+  "name": "Build + Test a Tricky Regex",
+  "description": "Build a regular expression that matches exactly the right strings and rejects the wrong ones — specified with concrete should-match and should-NOT-match cases before a single character is written. Specs the cases FIRST — the positive examples, the tricky negative examples, edge cases, and the anchoring/flags — then builds the regex incrementally against those cases, then tests the full matrix including catastrophic-backtracking safety. Covers character classes, quantifiers, anchors, groups/captures, lookahead/behind, escaping, flags, and ReDoS-safe patterns validated by a should-match / should-not-match table.\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. Spec the cases (planner) — lock should-match / should-NOT-match examples → gated on artifact `{{workPath}}/spec.md` (markdown-notes)\n2. Build the regex (developer) — construct the pattern against the cases → gated on `src/regex.js` (code-module)\n3. Test the matrix (developer) — test every match/no-match case + ReDoS safety → gated on `src/regex.test.js` (code-with-tests)\n\nThe gates never advance with an unmet criterion, and loop back to the\nowning phase to fix named gaps.\n",
+  "entryStepId": "spec",
+  "triggers": [
+    "build a regex",
+    "write a regular expression",
+    "match a pattern",
+    "validate with regex",
+    "tricky regex"
+  ],
+  "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": "spec",
+      "name": "Spec the cases",
+      "description": "lock should-match / should-NOT-match examples",
+      "prompt": "Specify the regex by examples before writing it — a regex is only correct relative to its cases. Step 1: Describe in words exactly what should match and what should not. Step 2: Write a SHOULD-MATCH list of concrete example strings, including edge cases (boundaries, minimum/maximum, unusual-but-valid forms). Step 3: Write a SHOULD-NOT-MATCH list of tricky near-misses that a naive pattern would wrongly accept (this is where most regexes fail). Step 4: Decide anchoring (full-string vs substring), case sensitivity, and any other flags, plus whether captures are needed. Step 5: Write a numbered acceptance-criteria checklist (e.g. 'every should-match string matches', 'every should-NOT-match string is rejected', 'the pattern is anchored as specified', 'no catastrophic backtracking on adversarial input'). `write_task_note` the two case lists + flags + checklist and write the same to the produces path.\n\nThe deliverable `{{workPath}}/spec.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",
+      "advanceWhen": {
+        "file": "{{workPath}}/spec.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "{{workPath}}/spec.md",
+            "bytes": 120,
+            "artifact": true
+          },
+          {
+            "kind": "sniff",
+            "file": "{{workPath}}/spec.md",
+            "sniff": "nonempty",
+            "artifact": true
+          }
+        ],
+        "onReject": "spec",
+        "maxAttempts": 3
+      },
+      "next": "build",
+      "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"
+        ]
+      }
+    },
+    {
+      "id": "build",
+      "name": "Build the regex",
+      "description": "construct the pattern against the cases",
+      "prompt": "Construct the regex incrementally against the spec. Step 1: Build the pattern piece by piece (character classes, quantifiers, groups), checking it against the should-match and should-not-match lists as you go rather than writing one big pattern blind. Step 2: Apply the specified anchors and flags, and add capture groups only where needed. Step 3: Escape special characters correctly and prefer specific classes over greedy `.*` to keep it precise. Step 4: Avoid nested/ambiguous quantifiers that cause catastrophic backtracking (ReDoS); prefer atomic/possessive or restructure if the engine supports it. Step 5: Deliver the final pattern plus a brief annotation of what each part does, written to the produces path as a small module exporting the regex and a `test(input)` helper. On a loop-back, fix only the failing cases. `write_task_note` the pattern and which criteria now pass.",
+      "suggestedRole": "developer",
+      "advanceWhen": {
+        "file": "src/regex.js",
+        "minBytes": 1,
+        "sniff": "nonempty"
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "src/regex.js",
+            "bytes": 200
+          },
+          {
+            "kind": "sniff",
+            "file": "src/regex.js",
+            "sniff": "nonempty"
+          },
+          {
+            "kind": "esmImports",
+            "file": "src/regex.js"
+          },
+          {
+            "kind": "sourceParses",
+            "file": "src/regex.js"
+          }
+        ],
+        "onReject": "build",
+        "maxAttempts": 3
+      },
+      "next": "test",
+      "toolPolicy": {
+        "disallowBuiltinToolsets": [
+          "ai-apps",
+          "archives",
+          "artifacts",
+          "audio",
+          "browser-automation",
+          "craftbooks",
+          "data-tables",
+          "entity-intel",
+          "git",
+          "image-intel",
+          "images",
+          "role-delegation",
+          "role-delegation-escalation",
+          "security-intel",
+          "team-management",
+          "videos",
+          "web"
+        ],
+        "outputMedium": "workspace",
+        "additionalOutputMedia": [
+          "task-note"
+        ]
+      }
+    },
+    {
+      "id": "test",
+      "name": "Test the matrix",
+      "description": "test every match/no-match case + ReDoS safety",
+      "prompt": "Write tests covering the full case matrix. Step 1: For every should-match string, assert the regex matches. Step 2: For every should-NOT-match string, assert the regex does NOT match — this is the part that catches over-eager patterns. Step 3: Assert anchoring behaves (e.g. a valid substring inside junk is rejected if full-string anchoring was specified). Step 4: Add a ReDoS-safety check: feed an adversarial input (long repeated prefix) and assert matching completes quickly rather than hanging. `write_task_note` the test file path and pass/fail count.",
+      "suggestedRole": "developer",
+      "advanceWhen": {
+        "file": "src/regex.test.js",
+        "minBytes": 1,
+        "sniff": "nonempty"
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "src/regex.js",
+            "bytes": 200
+          },
+          {
+            "kind": "sniff",
+            "file": "src/regex.js",
+            "sniff": "nonempty"
+          },
+          {
+            "kind": "esmImports",
+            "file": "src/regex.js"
+          },
+          {
+            "kind": "sourceParses",
+            "file": "src/regex.js"
+          }
+        ],
+        "onReject": "test",
+        "maxAttempts": 4
+      },
+      "next": "evaluate",
+      "toolPolicy": {
+        "disallowBuiltinToolsets": [
+          "ai-apps",
+          "archives",
+          "artifacts",
+          "audio",
+          "browser-automation",
+          "craftbooks",
+          "data-tables",
+          "entity-intel",
+          "git",
+          "image-intel",
+          "images",
+          "role-delegation",
+          "role-delegation-escalation",
+          "security-intel",
+          "team-management",
+          "videos",
+          "web"
+        ],
+        "outputMedium": "workspace",
+        "additionalOutputMedia": [
+          "task-note"
+        ]
+      }
+    },
+    {
+      "id": "evaluate",
+      "name": "Evaluate",
+      "description": "Grade the deliverable against every acceptance criterion. All pass → finish; any fail → loop back and fix the gap.",
+      "prompt": "Run the tests against the full case matrix. For EACH acceptance criterion: confirm every should-match string matches, confirm every should-NOT-match string is rejected, confirm anchoring/flags behave as specified, and confirm no catastrophic backtracking on adversarial input. Write PASS/FAIL per criterion; a single wrongly-accepted should-not-match string is a FAIL.\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",
+      "consumes": [
+        {
+          "file": "src/regex.js"
+        }
+      ],
+      "next": "build",
+      "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"
+      }
+    },
+    {
+      "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",
+      "terminal": true,
+      "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"
+      }
+    }
+  ],
+  "version": "1.0.3",
+  "releasedAt": "2026-09-01T20:00:00Z",
+  "minGezelVersion": "1.26233"
+}

package/data/craftbook-templates/re/regex-builder/versions/1.0.3/test.json

@@ -0,0 +1,92 @@
+{
+  "schemaVersion": 1,
+  "title": "Build + Test a Tricky Regex smoke eval",
+  "objective": "Self-contained smoke eval for the Build + Test a Tricky Regex 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": "Build + Test a Tricky Regex Eval",
+    "about": "Self-contained eval project for regex-builder. Seeded inputs are under workspace/source or workspace/fixtures; final deliverable is workspace/src/solution.mjs.",
+    "missionObjectives": "Use the Build + Test a Tricky Regex 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": "# Build + Test a Tricky Regex 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: regex-builder - Build + Test a Tricky Regex.\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"
+  ]
+}