@bendyline/gilde 0.1.40 → 0.1.41

package/data/craftbook-templates/li/live-browser-qa/manifest.json

@@ -19,6 +19,10 @@
   },
   "logo": "logo.webp",
   "license": "MIT",
-  "yankedVersions": [],
+  "yankedVersions": [
+    "1.0.0",
+    "1.0.1",
+    "1.0.2"
+  ],
   "workflow": "build-loop"
 }

package/data/craftbook-templates/ni/nightly-fix-sweep/art.json

@@ -0,0 +1,12 @@
+{
+  "schemaVersion": 1,
+  "promptVersion": "workshop-mark-1910-v2",
+  "periodCue": "circa-1910-subtle",
+  "family": "build-repair",
+  "accents": [
+    "deep indigo",
+    "brass"
+  ],
+  "sourceSummary": "Overnight triage of open code findings into clustered, reviewable change proposals; the tree itself is never touched.",
+  "styleReference": "bug-fix-tdd"
+}

package/data/craftbook-templates/ni/nightly-fix-sweep/manifest.json

@@ -0,0 +1,23 @@
+{
+  "schemaVersion": 1,
+  "kind": "craftbook-template",
+  "id": "nightly-fix-sweep",
+  "role": "maintenance-review",
+  "category": "code-quality",
+  "name": "Nightly Fix Sweep",
+  "description": "Turn a night's open code findings into reviewable change proposals: triage the leads, cluster what belongs together, and draft one focused proposal per cluster for the user to read and apply in the morning. The project's files are never touched.",
+  "tags": [
+    "bug-fix",
+    "night-shift",
+    "boekwachter",
+    "proposals",
+    "quality",
+    "batch"
+  ],
+  "maintainer": {
+    "name": "Gezel"
+  },
+  "license": "MIT",
+  "yankedVersions": [],
+  "logo": "logo.webp"
+}

package/data/craftbook-templates/ni/nightly-fix-sweep/versions/1.0.0/craftbook.json

@@ -0,0 +1,145 @@
+{
+  "schemaVersion": 1,
+  "id": "nightly-fix-sweep",
+  "name": "Nightly Fix Sweep",
+  "description": "Turn a batch of open code findings into reviewable change proposals. The host triages the leads against the current code — a lead that no longer matches the file, or that needs a judgement only the owner can make, is legitimately left out — then clusters what belongs together as ONE change (a fix that spans a file and its caller is one cluster, not two) and fans out one drafting shard per cluster. Each shard makes the smallest correct change for its leads and explains it under Problem, Change, Risk, and How to verify. Built for unattended night runs: proposals are what the user reviews and applies in the morning, and the project's files are never touched by the sweep itself.",
+  "version": "1.0.0",
+  "releasedAt": "2026-08-24T00:00:00.000Z",
+  "minGezelVersion": "1.26236",
+  "entryStepId": "triage",
+  "triggers": [
+    "sweep the open findings",
+    "nightly fixes",
+    "draft fixes for the open issues",
+    "fix the boekwachter findings"
+  ],
+  "runModes": {
+    "nightShift": "recommended"
+  },
+  "diffpackCapable": true,
+  "capabilityFloor": "small",
+  "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}}"
+      },
+      "leads": {
+        "type": "string",
+        "title": "Leads",
+        "description": "Comma-separated finding refs to sweep (e.g. BW-3,BW-8). Leave empty when the task description carries the leads.",
+        "default": ""
+      }
+    }
+  },
+  "steps": [
+    {
+      "id": "triage",
+      "name": "Triage the leads into clusters",
+      "suggestedRole": "developer",
+      "capabilityFloor": "medium",
+      "prompt": "You have been handed open findings to sweep: {{leads}}. The task description may carry more detail per lead.\n\nRead the affected files and judge each lead against the CURRENT code: real, already fixed, stale, or a judgement only the owner can make. Leaving a lead out is legitimate — say why rather than forcing a change to satisfy a stale review.\n\nCluster what belongs together as ONE change: a fix that spans a file and its caller is one cluster, not two — splitting it would hand the user two half-changes neither of which stands alone. At most 8 clusters; prefer fewer, focused ones.\n\nWrite ONE `write_task_note` starting with the line `## Triage`: per lead, whether you will fix it and which cluster it belongs to, with reasons for anything left out.\n\nThen write the cluster list to the artifact `{{workPath}}/clusters.json` with ONE `write_artifact` call: a JSON array where each entry is an object with exactly these string fields — `slug` (short kebab-case name for the cluster, e.g. \"auth-null-guard\"), `issueRefs` (the refs in that cluster, comma-separated), and `focus` (one sentence on what that cluster should change). If nothing is worth fixing, write an empty array `[]` and say why in your note.",
+      "advanceWhen": {
+        "file": "{{workPath}}/clusters.json",
+        "artifact": true,
+        "minBytes": 2,
+        "sniff": "json-valid"
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "sniff",
+            "file": "{{workPath}}/clusters.json",
+            "sniff": "json-valid",
+            "artifact": true
+          }
+        ],
+        "scripts": [
+          {
+            "name": "checkTaskNoteContains",
+            "scope": "standard",
+            "inputs": {
+              "taskRef": "{{task.ref}}",
+              "pattern": "##\\s*Triage"
+            }
+          }
+        ],
+        "onReject": "triage",
+        "maxAttempts": 3
+      },
+      "next": "fanout"
+    },
+    {
+      "id": "fanout",
+      "name": "Draft the proposals",
+      "spawnFanout": true,
+      "prompt": "Your clusters are being drafted, one proposal per cluster. Wait for the shards to finish, then call `advance_task_step`.",
+      "next": "collect"
+    },
+    {
+      "id": "collect",
+      "name": "Hand over",
+      "terminal": true,
+      "prompt": "The sweep is done. Write one short `write_task_note` naming the proposals your crew drafted (by cluster) and any leads deliberately left alone with their reasons, then call `advance_task_step`. Never claim anything was fixed or applied — these are proposals for the user to review."
+    }
+  ],
+  "spawn": {
+    "overFile": "{{workPath}}/clusters.json",
+    "overArtifact": true,
+    "entryStepId": "draft",
+    "steps": [
+      {
+        "id": "draft",
+        "name": "Draft the change",
+        "suggestedRole": "developer",
+        "capabilityFloor": "small",
+        "prompt": "Your cluster is {{issueRefs}} ({{slug}}). What it should change: {{focus}}\n\nRead the affected files first, then make the smallest correct change for those leads and nothing else. Use `read_file`, `write_file`, and `replace_in_file` exactly as you always do. Keep it focused — a change a reviewer can read in a minute gets applied; a sprawling one gets dismissed. If a lead turns out to be wrong once you are in the code, leave it alone and say so.\n\nThen write your explanation to the artifact `{{diffpack.dir}}/notes.md` in ONE `write_artifact` call, with exactly these four headings:\n\n## Problem\n## Change\n## Risk\n## How to verify\n\nUnder Change, describe what you altered and why, naming the refs. Under Risk, be honest about what you could not verify without running the code. Then call `advance_task_step`.",
+        "advanceWhen": {
+          "file": "{{diffpack.dir}}/notes.md",
+          "artifact": true,
+          "minBytes": 200
+        },
+        "gate": {
+          "at": "completion",
+          "checks": [
+            {
+              "kind": "contains",
+              "file": "{{diffpack.dir}}/notes.md",
+              "pattern": "##\\s+Problem",
+              "label": "Problem section",
+              "artifact": true
+            },
+            {
+              "kind": "contains",
+              "file": "{{diffpack.dir}}/notes.md",
+              "pattern": "##\\s+Change",
+              "label": "Change section",
+              "artifact": true
+            },
+            {
+              "kind": "contains",
+              "file": "{{diffpack.dir}}/notes.md",
+              "pattern": "##\\s+Risk",
+              "label": "Risk section",
+              "artifact": true
+            },
+            {
+              "kind": "contains",
+              "file": "{{diffpack.dir}}/notes.md",
+              "pattern": "##\\s+How to verify",
+              "label": "How to verify section",
+              "artifact": true
+            }
+          ],
+          "onReject": "draft",
+          "maxAttempts": 3
+        },
+        "terminal": true
+      }
+    ]
+  }
+}

package/data/craftbook-templates/ni/nightly-fix-sweep/versions/1.0.0/test.json

@@ -0,0 +1,121 @@
+{
+  "schemaVersion": 1,
+  "title": "Nightly sweep drafts sealed proposals without touching the tree",
+  "objective": "The host triages two seeded findings into clusters and fans out drafting shards; each shard's edits land in a change proposal that seals on completion, the four-heading notes contract holds, and the workspace files stay byte-identical.",
+  "tags": [
+    "code",
+    "night-shift",
+    "proposals",
+    "fanout",
+    "tactical-fleet"
+  ],
+  "prompt": "Run the Nightly Fix Sweep for the two open findings described in the task. LEAD-1: src/greet.js builds the greeting with a stray double space when no title is given. LEAD-2: src/farewell.js says 'Godbye' instead of 'Goodbye'. Draft the fixes as proposals.",
+  "setup": {
+    "projectName": "Sweep Fixture",
+    "about": "A tiny greeting library with two known low-risk defects, used to exercise the nightly proposal sweep.",
+    "managedWorkspaceWritePolicy": "deny",
+    "files": [
+      {
+        "path": "src/greet.js",
+        "content": "export function greet(name, title) {\n  const prefix = title ? `${title} ` : ' ';\n  return `Hello, ${prefix}${name}!`;\n}\n"
+      },
+      {
+        "path": "src/farewell.js",
+        "content": "export function farewell(name) {\n  return `Godbye, ${name}.`;\n}\n"
+      },
+      {
+        "path": "source/findings.md",
+        "content": "# Open findings\n\n- LEAD-1 (minor, src/greet.js): greeting has a leading double space when no title is passed - `greet('Ada')` returns `Hello,  Ada!`. The no-title prefix should be empty.\n- LEAD-2 (minor, src/farewell.js): the farewell text misspells Goodbye as 'Godbye'.\n"
+      }
+    ],
+    "craftbookParams": {
+      "workPath": "tasks/eval",
+      "leads": "LEAD-1,LEAD-2"
+    }
+  },
+  "success": {
+    "summary": "Clusters were published, shards drafted, at least one proposal sealed with the four-heading notes, and the workspace was never modified.",
+    "deliverables": [
+      {
+        "path": "tasks/eval/clusters.json",
+        "kind": "json",
+        "artifact": true,
+        "minBytes": 2,
+        "checks": [
+          {
+            "kind": "recordSchema",
+            "file": "tasks/eval/clusters.json",
+            "artifact": true,
+            "minRows": 1,
+            "fields": [
+              {
+                "name": "slug",
+                "rule": "nonempty"
+              },
+              {
+                "name": "issueRefs",
+                "rule": "nonempty"
+              },
+              {
+                "name": "focus",
+                "rule": "nonempty"
+              }
+            ]
+          }
+        ]
+      }
+    ],
+    "taskNotes": {
+      "minBytes": 120,
+      "requireCraftbookTask": true,
+      "checks": [
+        {
+          "kind": "contains",
+          "file": "task-notes.md",
+          "pattern": "##\\s*Triage",
+          "label": "triage note present"
+        }
+      ]
+    },
+    "taskGraph": {
+      "requireCraftbookTask": true,
+      "requireTerminalStep": true
+    },
+    "history": [
+      {
+        "kind": "project.diffpack.sealed",
+        "minEntries": 1
+      }
+    ],
+    "unchangedFixtures": [
+      "src/greet.js",
+      "src/farewell.js",
+      "source/findings.md"
+    ]
+  },
+  "rubric": {
+    "artifact": {
+      "path": "tasks/eval/clusters.json",
+      "kind": "json"
+    },
+    "axes": [
+      {
+        "name": "Triage judgement",
+        "description": "Leads were judged against the current code and clustered sensibly; anything left out has an honest reason."
+      },
+      {
+        "name": "Proposal focus",
+        "description": "Each drafted proposal is the smallest correct change for its cluster, explained under Problem, Change, Risk, and How to verify."
+      },
+      {
+        "name": "Honesty about mode",
+        "description": "Notes never claim anything was fixed or applied; risk sections admit what could not be verified without running the code."
+      }
+    ]
+  },
+  "qualityFocus": [
+    "proposal discipline",
+    "cluster judgement",
+    "untouched workspace"
+  ]
+}

package/data/craftbook-templates/pe/perf-audit/versions/1.1.0/craftbook.json

@@ -0,0 +1,195 @@
+{
+  "id": "perf-audit",
+  "name": "Performance Audit",
+  "description": "Audit an application or page for performance problems with measurements, then produce a report of the highest-impact optimizations. First scopes the workloads and locks a performance budget and checklist (load time and Core Web Vitals, bundle/asset weight, render and main-thread cost, network waterfall and request count, server/query latency, memory and re-render churn), then MEASURES each against a baseline using real profiling rather than guessing, then writes a report that ranks bottlenecks by impact-vs-effort with a specific fix and the expected gain for each. Use this for a performance audit, speed optimization, finding bottlenecks, a Lighthouse-style review, reducing load time, or profiling slowness — it grounds every recommendation in a measured number and an estimated payoff, not 'it feels slow'.\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 perf budget (reviewer) — lock workloads, a budget, and a metrics checklist → gated on artifact `{{workPath}}/scope.md` (markdown-notes)\n2. Measure the baseline (developer) — profile each workload, locate the real bottlenecks → gated on artifact `{{workPath}}/measure.md` (markdown-notes)\n3. Write the perf report (reviewer) — rank optimizations by impact vs effort → gated on artifact `{{workPath}}/perf-report.md` (markdown-report)\n\nThe gates never advance with an unmet criterion, and loop back to the\nowning phase to fix named gaps.\n",
+  "entryStepId": "scope",
+  "triggers": [
+    "performance audit",
+    "why is this slow",
+    "find the bottleneck",
+    "optimize load time",
+    "speed this up",
+    "profile the app"
+  ],
+  "steps": [
+    {
+      "id": "scope",
+      "name": "Scope the perf budget",
+      "description": "lock workloads, a budget, and a metrics checklist",
+      "prompt": "Step 1: Identify the workloads to audit (the slow page/route/endpoint/operation and its typical usage). Step 2: Write a performance acceptance-criteria checklist with concrete budgets, drawn from the relevant metrics: page load and Core Web Vitals (LCP < 2.5s, CLS < 0.1, INP < 200ms), total JS/CSS/image transfer weight, time-to-interactive and main-thread blocking, request count and waterfall serialization, server response and DB query latency (and N+1 detection), and memory growth / excessive re-renders for SPAs. Step 3: For each metric, set the target/budget for THIS app and note the current pain. Step 4: Decide the measurement method and environment (Lighthouse/devtools/profiler/timing logs if available; otherwise read the code and reason about asymptotic and I/O costs). Write the workloads + budgeted checklist + method to `write_task_note` AND `{{workPath}}/scope.md`. No optimizing yet — define 'fast enough' first.\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": "reviewer",
+      "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": "measure"
+    },
+    {
+      "id": "measure",
+      "name": "Measure the baseline",
+      "description": "profile each workload, locate the real bottlenecks",
+      "prompt": "Step 1: Establish a baseline by MEASURING each metric in the checklist (run Lighthouse/devtools/a profiler, time the endpoint, inspect the network waterfall and bundle, log query times). If no live env, statically analyze: bundle composition, algorithmic complexity of hot paths, query patterns, and render triggers. Step 2: For each metric over budget, drill into WHY — which asset is heaviest, which function dominates the flame chart, which query is slow or repeated, which component re-renders needlessly. Step 3: Record the actual numbers (e.g. 'LCP 4.1s; main.js is 480KB, 60% is moment.js+lodash'; 'GET /feed: 1.2s, runs 1+N queries, N≈40'). Step 4: For each bottleneck, identify the fix and ESTIMATE the expected gain and the effort. Step 5: Separate confirmed bottlenecks from suspicions you could not measure. Good looks like: every claim has a number behind it. Stage measurements to `write_task_note`. Do not write the report yet.\n\nThe deliverable `{{workPath}}/measure.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": "developer",
+      "advanceWhen": {
+        "file": "{{workPath}}/measure.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "{{workPath}}/measure.md",
+            "bytes": 120,
+            "artifact": true
+          },
+          {
+            "kind": "sniff",
+            "file": "{{workPath}}/measure.md",
+            "sniff": "nonempty",
+            "artifact": true
+          }
+        ],
+        "onReject": "measure",
+        "maxAttempts": 3
+      },
+      "next": "report"
+    },
+    {
+      "id": "report",
+      "name": "Write the perf report",
+      "description": "rank optimizations by impact vs effort",
+      "prompt": "Step 1: Open `{{workPath}}/perf-report.md` and write a '## Summary' table of each metric: budget vs measured vs PASS/FAIL. Step 2: Add a '## Recommendations' section ranked by impact-vs-effort; each entry: the bottleneck (with its measured number), the specific fix (e.g. 'code-split the editor route and lazy-load it', 'replace the 1+N with a single JOIN/batch', 'serve images as WebP at 2x and add width/height'), the ESTIMATED gain, and the effort. Step 3: Add a '## Quick wins' callout for the high-impact/low-effort items to do first. Step 4: Add a '## Needs measurement' section for suspicions not yet confirmed. Every recommendation must cite a measured number and an expected payoff — no generic 'optimize images'. On a loop-back, fix only the named gaps. `write_task_note` the report path and the count of failing metrics.\n\nThe deliverable `{{workPath}}/perf-report.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",
+      "advanceWhen": {
+        "file": "{{workPath}}/perf-report.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true,
+        "requireChange": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "{{workPath}}/perf-report.md",
+            "bytes": 1500,
+            "artifact": true
+          },
+          {
+            "kind": "contains",
+            "file": "{{workPath}}/perf-report.md",
+            "pattern": "(?:^|\\n)#{1,3}\\s+\\S",
+            "flags": "i",
+            "label": "at least one markdown heading",
+            "artifact": true
+          },
+          {
+            "kind": "citationsResolve",
+            "file": "{{workPath}}/perf-report.md",
+            "minCitations": 2,
+            "artifact": true
+          }
+        ],
+        "onReject": "report",
+        "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": "Open `{{workPath}}/perf-report.md` with `read_artifact` first, then review it against the original scope: every claim cites a real path, the severities and priorities are defensible, and nothing important in scope was skipped. Open the underlying files for at least the top findings; do not grade from the report's own summary. If a finding cannot be verified, say so explicitly.\n\nWrite your review to the artifact `{{workPath}}/review.md` with one `write_artifact` call: what you checked, what held, what did not (as a findings table with columns `| Severity | File | Line | Problem | Fix |` when anything needs fixing), ending with exactly `Verdict: PASS` or `Verdict: REVISE`. The gate enforces the verdict: a well-formed REVISE is routed back to the `report` step automatically with your findings. On PASS, `advance_task_step` to `finish`.",
+      "suggestedRole": "reviewer",
+      "consumes": [
+        {
+          "file": "{{workPath}}/perf-report.md",
+          "artifact": true
+        }
+      ],
+      "next": "finish",
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "{{workPath}}/review.md",
+            "bytes": 300,
+            "artifact": true
+          },
+          {
+            "kind": "contains",
+            "file": "{{workPath}}/review.md",
+            "pattern": "Verdict:\\s*(?:PASS|REVISE)",
+            "flags": "i",
+            "label": "explicit PASS or REVISE verdict",
+            "artifact": true
+          }
+        ],
+        "scripts": [
+          {
+            "name": "checkFixReview",
+            "scope": "standard",
+            "inputs": {
+              "taskRef": "{{task.ref}}",
+              "reviewPath": "{{workPath}}/review.md",
+              "fixStepId": "report"
+            }
+          }
+        ],
+        "onReject": "evaluate",
+        "maxAttempts": 4
+      }
+    },
+    {
+      "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
+    }
+  ],
+  "version": "1.1.0",
+  "releasedAt": "2026-08-24T00:00:00.000Z",
+  "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}}"
+      }
+    }
+  },
+  "minGezelVersion": "1.26236",
+  "runModes": {
+    "nightShift": "supported"
+  }
+}