@bendyline/gilde 0.1.38 → 0.1.39

package/data/craftbook-templates/im/image-dedup-cluster/versions/1.0.2/craftbook.json

@@ -0,0 +1,152 @@
+{
+  "id": "image-dedup-cluster",
+  "name": "Image Dedup & Cluster",
+  "description": "Find and group near-duplicate images across a folder — exact dupes, resized/re-encoded copies, and visually similar shots from the same burst — using perceptual hashing or visual similarity, then report clusters with a recommended keeper per group. Lock the similarity definition and thresholds FIRST (what counts as a duplicate vs merely similar) because the whole result hinges on that line; then analyze pairwise, cluster, and produce a human-reviewable report. Covers deduplication, near-duplicate detection, perceptual hashing, image clustering, burst grouping, and library cleanup.\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 dedup (planner) — define similarity, thresholds, and the keeper rule → gated on artifact `{{workPath}}/scope.md` (markdown-notes)\n2. Analyze similarity (developer) — hash, compare, and cluster the images → gated on artifact `{{workPath}}/analyze.md` (markdown-notes)\n3. Write the report (developer) — produce the reviewable dedup report → gated on artifact `{{workPath}}/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": [
+    "find duplicate images",
+    "cluster similar photos",
+    "dedupe my image folder",
+    "near-duplicate detection",
+    "group similar images"
+  ],
+  "steps": [
+    {
+      "id": "scope",
+      "name": "Scope the dedup",
+      "description": "define similarity, thresholds, and the keeper rule",
+      "prompt": "1) List the folder and count the images. 2) Define the similarity method: exact-bytes hash for true dupes PLUS a perceptual hash (aHash/pHash/dHash) or embedding distance for near-dupes, and set the THRESHOLD (e.g. Hamming distance <= N) that separates 'duplicate' from 'merely similar'. 3) Define the KEEPER rule for a cluster (e.g. highest resolution, largest file, earliest timestamp). 4) Decide the report shape: clusters with member filenames, the chosen keeper, and the would-free byte savings. 5) Write an acceptance-criteria checklist: 'every image appears in exactly one cluster (singletons allowed)', 'the threshold is stated and applied consistently', 'each multi-member cluster names a keeper', 'reported savings are computed from real file sizes', 'no false-merge of clearly different images'. 6) Record method + thresholds + checklist via write_task_note AND to {{workPath}}/scope.md.\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",
+      "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": "analyze"
+    },
+    {
+      "id": "analyze",
+      "name": "Analyze similarity",
+      "description": "hash, compare, and cluster the images",
+      "prompt": "1) Read scope.md. 2) Compute the exact and perceptual hashes for every image (prefer a small rerunnable script; fall back to visual comparison via the vision capability for small sets). 3) Compare pairwise and group images whose distance is within the threshold into clusters (transitively — if A~B and B~C, they share a cluster). 4) Apply the keeper rule to each multi-member cluster. 5) Spot-verify a couple of clusters by actually looking at the images to catch false merges. 6) Stage the cluster assignments and per-image metadata (hash, size, dimensions) to a working note. write_task_note the cluster count, duplicate count, and any uncertain merges. Good looks like: tight clusters where members truly are the same shot.\n\nThe deliverable `{{workPath}}/analyze.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}}/analyze.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "{{workPath}}/analyze.md",
+            "bytes": 120,
+            "artifact": true
+          },
+          {
+            "kind": "sniff",
+            "file": "{{workPath}}/analyze.md",
+            "sniff": "nonempty",
+            "artifact": true
+          }
+        ],
+        "onReject": "analyze",
+        "maxAttempts": 3
+      },
+      "next": "report"
+    },
+    {
+      "id": "report",
+      "name": "Write the report",
+      "description": "produce the reviewable dedup report",
+      "prompt": "1) Read the cluster assignments. 2) Write {{workPath}}/report.md: a summary (total images, N clusters, M duplicates found, estimated bytes freed), then one section per multi-member cluster listing its members (filename, dimensions, size), the recommended KEEPER (and why), and the ones to remove. 3) Include a short methodology line (method + threshold used) so the result is auditable. 4) List singletons compactly at the end. 5) Be explicit about any low-confidence clusters the human should eyeball. 6) On a loop-back, fix only the named issues (a bad merge, a wrong keeper). 7) write_task_note the report path. The gated deliverable is {{workPath}}/report.md.\n\nThe deliverable `{{workPath}}/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": "developer",
+      "advanceWhen": {
+        "file": "{{workPath}}/report.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "{{workPath}}/report.md",
+            "bytes": 1500,
+            "artifact": true
+          },
+          {
+            "kind": "contains",
+            "file": "{{workPath}}/report.md",
+            "pattern": "(?:^|\\n)#{1,3}\\s+\\S",
+            "flags": "i",
+            "label": "at least one markdown heading",
+            "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": "1) Open {{workPath}}/report.md and confirm it states the method + threshold and a summary with cluster/duplicate counts (PASS/FAIL). 2) Verify every image is accounted for in exactly one cluster or as a singleton (PASS/FAIL). 3) Open 2-3 reported clusters' member images — are they genuinely the same/near-same shot (no false merges) and is the keeper choice sensible (PASS/FAIL)? 4) Confirm byte-savings are computed from real sizes. 5) Write PASS/FAIL per criterion. False merges or unaccounted images → loop back to report (or analyze if clustering is wrong).\n\nThe deliverable lives in the project's artifacts drawer — open `{{workPath}}/report.md` with `read_artifact`, not `read_file`.\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: \"report\" })` 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": "{{workPath}}/report.md",
+          "artifact": true
+        }
+      ],
+      "next": "report"
+    },
+    {
+      "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.0.2",
+  "releasedAt": "2026-08-21T00:00:00Z",
+  "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.26233"
+}

package/data/craftbook-templates/im/image-dedup-cluster/versions/1.0.2/test.json

@@ -0,0 +1,106 @@
+{
+  "schemaVersion": 1,
+  "title": "Image Dedup & Cluster smoke eval",
+  "objective": "Self-contained smoke eval for the Image Dedup & Cluster craftbook using the media generic harness.",
+  "tags": [
+    "media"
+  ],
+  "prompt": "Our media files are all listd in source/media-index.csv. Can you put together the production plan for them as media-plan.json?",
+  "setup": {
+    "projectName": "Image Dedup & Cluster Eval",
+    "about": "Self-contained eval project for image-dedup-cluster. Seeded inputs are under workspace/source or workspace/fixtures; final deliverable is workspace/media-plan.json.",
+    "missionObjectives": "Use the Image Dedup & Cluster craftbook/template, read the seeded local fixtures, and write media-plan.json without network calls, real credentials, or live services.",
+    "files": [
+      {
+        "path": "source/brief.md",
+        "content": "# Image Dedup & Cluster 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: image-dedup-cluster - Image Dedup & Cluster.\n"
+      },
+      {
+        "path": "source/media-index.csv",
+        "content": "filename,type,duration_or_size,notes\npilot-interview.wav,audio,00:02:15,mentions response time and status silence\nreturns-desk.png,image,1600x900,shows intake form and photo evidence step\nlaunch-clip.mp4,video,00:01:05,shows barcode exception handling\n"
+      }
+    ],
+    "worker": {
+      "name": "Jules",
+      "role": "Producer"
+    },
+    "craftbookParams": {
+      "workPath": "tasks/eval"
+    }
+  },
+  "mocks": [],
+  "success": {
+    "summary": "media-plan.json is a valid JSON media-production manifest grounded in seeded fixture metadata.",
+    "deliverables": [
+      {
+        "path": "media-plan.json",
+        "kind": "json",
+        "minBytes": 700,
+        "checks": [
+          {
+            "kind": "sniff",
+            "file": "media-plan.json",
+            "sniff": "json-valid"
+          },
+          {
+            "kind": "contains",
+            "file": "media-plan.json",
+            "pattern": "pilot-interview\\.wav|returns-desk\\.png|launch-clip\\.mp4",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "media-plan.json",
+            "pattern": "outputs|assets|steps|cues|verification",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "media-plan.json",
+            "pattern": "accessibility|alt|caption|transcript|metadata",
+            "flags": "i"
+          }
+        ]
+      }
+    ]
+  },
+  "rubric": {
+    "artifact": {
+      "path": "media-plan.json",
+      "kind": "json"
+    },
+    "axes": [
+      {
+        "name": "completeness",
+        "description": "The manifest covers sources, outputs, and processing steps end to end."
+      },
+      {
+        "name": "grounding",
+        "description": "Only seeded media fixtures are referenced, with faithful metadata."
+      },
+      {
+        "name": "accessibility",
+        "description": "Alt text, captions, or transcripts are planned wherever the class requires."
+      },
+      {
+        "name": "precision",
+        "description": "Timestamps, crops, and cues are specific enough to execute."
+      }
+    ]
+  },
+  "qualityFocus": [
+    "media fixture handling",
+    "structured manifest",
+    "verification metadata"
+  ],
+  "extensions": {
+    "legacySimulators": [
+      {
+        "id": "image-dedup-cluster-media-fixtures",
+        "kind": "data-source",
+        "status": "implemented",
+        "description": "Seeded local media index replacing real audio, video, image generation, and external media metadata services."
+      }
+    ]
+  }
+}

package/data/craftbook-templates/im/image-palette-extract/versions/1.0.2/craftbook.json

@@ -0,0 +1,121 @@
+{
+  "id": "image-palette-extract",
+  "name": "Image Palette Extraction",
+  "description": "Extract a usable color palette from an image or a set of images — the dominant and accent colors as hex/RGB with proportions — and emit it as design tokens (CSS variables / JSON) plus a swatch preview, so a brand or theme can be built from a reference photo. Lock FIRST how many colors, the color space and clustering method, and accessibility constraints (e.g. text/background pairs must meet a contrast ratio) because a raw dominant-color dump is rarely directly usable as a theme; then extract, name, and present the palette. Covers color extraction, palette generation, design tokens, theme-from-image, dominant colors, and brand color sampling.\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 palette (planner) — lock count, method, token format, and contrast rules → gated on artifact `{{workPath}}/scope.md` (markdown-notes)\n2. Build the palette (developer) — extract, name, token-ize, and preview the palette → gated on `index.html` (html-page)\n\nThe gates never advance with an unmet criterion, and loop back to the\nowning phase to fix named gaps.\n",
+  "entryStepId": "scope",
+  "triggers": [
+    "extract colors from an image",
+    "make a palette from a photo",
+    "get dominant colors",
+    "generate a color theme from an image",
+    "image to design tokens"
+  ],
+  "steps": [
+    {
+      "id": "scope",
+      "name": "Scope the palette",
+      "description": "lock count, method, token format, and contrast rules",
+      "prompt": "1) Identify the source image(s) and the intended use (web theme, brand palette, chart colors). 2) Lock the palette SIZE (e.g. 5-6 swatches: a primary, 2-3 supports, a neutral, an accent) and the extraction method (k-means/median-cut clustering in a perceptual space) plus how to report proportions. 3) Decide the OUTPUT token format: CSS custom properties and/or a JSON tokens file with named roles (--color-primary, etc.). 4) Lock accessibility constraints: at least one text-on-background pair must meet WCAG AA contrast (4.5:1); if the raw extraction misses it, derive a tweaked tint/shade and note it. 5) Write an acceptance-criteria checklist: 'N named swatches with valid hex', 'proportions reported', 'tokens parse (valid CSS/JSON)', 'at least one AA-contrasting text/bg pair', 'colors are sampled from the actual image'. 6) Record scope + checklist via write_task_note AND to {{workPath}}/scope.md.\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",
+      "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": "Build the palette",
+      "description": "extract, name, token-ize, and preview the palette",
+      "prompt": "1) Read scope.md. 2) Sample the actual image pixels (prefer a script doing real clustering; otherwise read the image via the vision capability and estimate the dominant colors honestly) to derive the N colors with their approximate proportions. 3) Assign semantic ROLES and names (primary, secondary, accent, neutral, surface) and convert each to hex and RGB. 4) Check the chosen text/background pair for AA contrast; if it fails, derive an adjusted shade and record both the raw and adjusted value. 5) Emit the tokens: a tokens.json (and CSS variables) at the agreed path, AND build a single index.html swatch preview showing each color block with its name, hex, proportion, and a live text-on-color contrast demo. 6) Validate JSON/CSS parse. 7) On a loop-back, fix only named gaps. 8) write_task_note the token + preview paths. The gated deliverable is index.html.",
+      "suggestedRole": "developer",
+      "advanceWhen": {
+        "file": "index.html",
+        "minBytes": 1,
+        "sniff": "html-complete"
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "index.html",
+            "bytes": 800
+          },
+          {
+            "kind": "htmlLint",
+            "file": "index.html"
+          }
+        ],
+        "scripts": [
+          {
+            "name": "checkHtmlComplete",
+            "scope": "standard",
+            "inputs": {
+              "file": "index.html"
+            }
+          }
+        ],
+        "onReject": "build",
+        "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": "1) Open index.html and confirm it renders N named swatches each with a valid hex and proportion (PASS/FAIL). 2) Confirm the tokens file parses (valid JSON/CSS) and roles are named (PASS/FAIL). 3) Open the source image next to the palette — are the colors genuinely sampled from it, not arbitrary (PASS/FAIL)? 4) Check the contrast demo: at least one text/background pair meets AA 4.5:1 (PASS/FAIL). 5) Write PASS/FAIL per criterion. Off-image colors, failing contrast, or unparseable tokens → loop back to build.\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": "index.html"
+        }
+      ],
+      "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",
+      "terminal": true
+    }
+  ],
+  "version": "1.0.2",
+  "releasedAt": "2026-08-21T00:00:00Z",
+  "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.26233"
+}

package/data/craftbook-templates/im/image-palette-extract/versions/1.0.2/test.json

@@ -0,0 +1,100 @@
+{
+  "schemaVersion": 1,
+  "title": "Image Palette Extraction smoke eval",
+  "objective": "Self-contained smoke eval for the Image Palette Extraction craftbook using the html-page generic harness.",
+  "tags": [
+    "html-page"
+  ],
+  "prompt": "Can you biuld us a little page for this? The content notes are in source/page-content.md. Save it as index.html — one file, nothing fancy needed on our end.",
+  "setup": {
+    "projectName": "Image Palette Extraction Eval",
+    "about": "Self-contained eval project for image-palette-extract. Seeded inputs are under workspace/source or workspace/fixtures; final deliverable is workspace/index.html.",
+    "missionObjectives": "Use the Image Palette Extraction craftbook/template, read the seeded local fixtures, and write index.html without network calls, real credentials, or live services.",
+    "files": [
+      {
+        "path": "source/brief.md",
+        "content": "# Image Palette Extraction 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: image-palette-extract - Image Palette Extraction.\n"
+      },
+      {
+        "path": "source/page-content.md",
+        "content": "# Boreal Desk Support Board\n\nBuild content around a support operations board. Required labels: Open issues, Status silence, Response time, Refund leakage, Next action. Required metric text: 18 hours to 6 hours and 14.2% to 8.9%.\n"
+      }
+    ],
+    "worker": {
+      "name": "Jules",
+      "role": "Developer"
+    },
+    "craftbookParams": {
+      "workPath": "tasks/eval"
+    }
+  },
+  "mocks": [],
+  "success": {
+    "summary": "index.html is a source-grounded self-contained HTML page/tool.",
+    "deliverables": [
+      {
+        "path": "index.html",
+        "kind": "html-page",
+        "minBytes": 3000,
+        "checks": [
+          {
+            "kind": "cssMinBytes",
+            "bytes": 650,
+            "file": "index.html"
+          },
+          {
+            "kind": "jsParses",
+            "file": "index.html"
+          },
+          {
+            "kind": "contains",
+            "file": "index.html",
+            "pattern": "Boreal|Support Board|returns",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "index.html",
+            "pattern": "18\\s*hours|6\\s*hours|14\\.2%|8\\.9%",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "index.html",
+            "pattern": "button|input|filter|tab|card|section|nav",
+            "flags": "i"
+          }
+        ]
+      }
+    ]
+  },
+  "rubric": {
+    "artifact": {
+      "path": "index.html",
+      "kind": "html"
+    },
+    "axes": [
+      {
+        "name": "structure",
+        "description": "Layout and hierarchy fit the content; sections are scannable and coherent."
+      },
+      {
+        "name": "grounding",
+        "description": "Seeded source content is used faithfully — no invented facts or dropped requirements."
+      },
+      {
+        "name": "interactivity",
+        "description": "Controls and states the page claims to offer actually work."
+      },
+      {
+        "name": "polish",
+        "description": "Styling is intentional and responsive rather than unstyled or broken."
+      }
+    ]
+  },
+  "qualityFocus": [
+    "self-contained UI",
+    "source grounding",
+    "responsive structure"
+  ]
+}

package/data/craftbook-templates/im/image-seo-rename/versions/1.0.2/craftbook.json

@@ -0,0 +1,117 @@
+{
+  "id": "image-seo-rename",
+  "name": "Image SEO Rename & Tag",
+  "description": "Rename and tag a folder of images for SEO and findability — descriptive, hyphenated, keyword-rich filenames plus consistent metadata (title, caption, keyword tags) — driven by what each image actually depicts, while preserving a mapping back to the originals so links don't break silently. Scope FIRST the naming convention, keyword strategy, and collision/mapping rules, because bulk-renaming without a plan creates duplicate-name clashes and broken references; then process the folder and emit the rename map. Covers image SEO, filename optimization, descriptive renaming, alt/metadata tagging, and asset findability.\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 rename (planner) — lock naming convention, keywords, and collision/mapping rules → gated on artifact `{{workPath}}/scope.md` (markdown-notes)\n2. Process the folder (developer) — derive names from content, rename, and emit the map → gated on `rename-map.json` (json)\n\nThe gates never advance with an unmet criterion, and loop back to the\nowning phase to fix named gaps.\n",
+  "entryStepId": "scope",
+  "triggers": [
+    "rename images for seo",
+    "make descriptive image filenames",
+    "tag images for search",
+    "seo image filenames",
+    "optimize image names"
+  ],
+  "steps": [
+    {
+      "id": "scope",
+      "name": "Scope the rename",
+      "description": "lock naming convention, keywords, and collision/mapping rules",
+      "prompt": "1) List the folder and inventory current filenames and formats. 2) Lock the naming CONVENTION: lowercase, hyphen-separated, descriptive, keyword-first, no spaces/underscores/special chars, max length, and whether to keep a stable id suffix to guarantee uniqueness (e.g. red-running-shoe-side-01.jpg). 3) Define the keyword strategy (primary subject + 1-2 descriptive modifiers) and the metadata to attach (title, caption, keyword tags). 4) Lock collision handling (append -01/-02) and require a complete OLD→NEW mapping so references can be updated and nothing is lost. 5) Write an acceptance-criteria checklist: 'every new name is lowercase-hyphenated and describes the image', 'names are unique (no collisions)', 'a complete old→new map exists', 'metadata fields are populated from the image content', 'file extensions are preserved'. 6) Record convention + checklist via write_task_note AND to {{workPath}}/scope.md.\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",
+      "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": "process"
+    },
+    {
+      "id": "process",
+      "name": "Process the folder",
+      "description": "derive names from content, rename, and emit the map",
+      "prompt": "1) Read scope.md. 2) For each image, LOOK at it via the vision capability to derive an accurate descriptive name (primary subject + modifiers) and the metadata (title, caption, keyword tags) — never base the name on a meaningless original name. 3) Apply the naming convention exactly (lowercase, hyphens, keyword-first, extension preserved) and resolve collisions with the agreed suffix scheme. 4) Perform the renames (or stage to an out/ folder if non-destructive is requested) and write a complete OLD→NEW mapping to rename-map.json including the per-image metadata. 5) Validate the JSON parses and that no two new names collide and every original is represented. 6) write_task_note the map path and the count renamed. The gated deliverable is rename-map.json.",
+      "suggestedRole": "developer",
+      "advanceWhen": {
+        "file": "rename-map.json",
+        "minBytes": 1,
+        "sniff": "json-valid"
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "rename-map.json",
+            "bytes": 2
+          }
+        ],
+        "scripts": [
+          {
+            "name": "checkJsonValid",
+            "scope": "standard",
+            "inputs": {
+              "file": "rename-map.json"
+            }
+          }
+        ],
+        "onReject": "process",
+        "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": "1) Open rename-map.json and confirm it parses as valid JSON (PASS/FAIL). 2) Confirm every original file has an entry and the count matches the folder (PASS/FAIL). 3) Check new names against scope.md: lowercase-hyphenated, keyword-first, no collisions, extensions preserved (PASS/FAIL). 4) Spot-check 3-4 entries by opening the images — does the name actually describe the image and are metadata fields populated (PASS/FAIL)? 5) Write PASS/FAIL per criterion. Collisions, generic names, or missing entries → loop back to process.\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: \"process\" })` 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": "rename-map.json"
+        }
+      ],
+      "next": "process"
+    },
+    {
+      "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.0.2",
+  "releasedAt": "2026-08-21T00:00:00Z",
+  "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.26233"
+}