@bendyline/gilde 0.1.38 → 0.1.39

package/data/craftbook-templates/mo/mod-scaffold/versions/1.0.2/craftbook.json

@@ -0,0 +1,168 @@
+{
+  "id": "mod-scaffold",
+  "name": "Scaffold a Mod",
+  "description": "Start the mod right: a correctly-shaped Minecraft datapack — pack.mcmeta carrying the right format number for the target game version, namespaced folders laid out properly, and one working example of the mod's core idea — plus install steps a twelve-year-old can follow. Locks the idea and the version's structure rules FIRST, then scaffolds the tree, then writes the README. Use for starting a datapack, scaffolding a mod, 'my kid wants a mod that…', datapack setup, and first-mod projects.\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 mod (modmaker) — the idea, the target version, the structure rules locked → gated on artifact `{{workPath}}/scope.md` (markdown-notes)\n2. Scaffold the datapack (developer) — pack.mcmeta plus the namespaced tree with one working example → gated on `pack.mcmeta` (json)\n3. Write the README (copywriter) — install and test steps a twelve-year-old can follow → gated on `README.md` (markdown-doc)\n\nThe gates never advance with an unmet criterion, and loop back to the\nowning phase to fix named gaps.\n",
+  "entryStepId": "scope",
+  "triggers": [
+    "scaffold a mod",
+    "start a datapack",
+    "make a minecraft mod",
+    "set up the datapack",
+    "my kid wants a mod"
+  ],
+  "steps": [
+    {
+      "id": "scope",
+      "name": "Scope the mod",
+      "description": "the idea, the target version, the structure rules locked",
+      "prompt": "Define the mod before creating a single file. Step 1: state the mod's core idea in one sentence — the thing that should happen in the game — and the target game version it must run on. Step 2: lock the structure rules for that version — the pack_format number pack.mcmeta must carry for the target version (from the project's version notes when present, stated explicitly either way), the namespace for this mod (short, lowercase, no spaces), and the folder layout the version expects under data/ for the mechanics the idea needs (functions, recipes, advancements, tags). Step 3: decide the one working example that proves the core idea end to end — the smallest set of files that makes the thing actually happen in-game. Step 4: write an acceptance-criteria checklist ('pack.mcmeta is valid JSON with the right pack_format for the target version', 'all content lives under the namespaced folders', 'the working example is complete — every file it needs exists', 'README has install steps and a test step a kid can follow'). Call write_task_note with the idea + version + pack_format + checklist and write {{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": "modmaker",
+      "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": "scaffold"
+    },
+    {
+      "id": "scaffold",
+      "name": "Scaffold the datapack",
+      "description": "pack.mcmeta plus the namespaced tree with one working example",
+      "prompt": "Build the datapack tree against the locked rules. Step 1: write pack.mcmeta at the workspace root — valid JSON with the pack object carrying the pack_format number locked in scope and a one-line description of the mod. Step 2: lay out the namespaced tree under data/ exactly as the target version expects, and build the working example — every function, recipe, advancement, or tag file the core idea needs, each in its right folder with its right name; a scaffold whose example is missing a file teaches a kid that mods do not work. Step 3: use the version's correct folder names and identifier syntax throughout — one renamed folder between versions is the classic silent break, so double-check against the structure rules from scope. Step 4: re-read every JSON file for validity and every function file for command syntax. Call write_task_note with the file count and the namespace.",
+      "suggestedRole": "developer",
+      "advanceWhen": {
+        "file": "pack.mcmeta",
+        "minBytes": 1,
+        "sniff": "json-valid"
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "pack.mcmeta",
+            "bytes": 2
+          },
+          {
+            "kind": "contains",
+            "file": "pack.mcmeta",
+            "pattern": "pack_format",
+            "label": "pack.mcmeta declares its pack_format"
+          },
+          {
+            "kind": "fileCount",
+            "ext": [
+              "json",
+              "mcfunction"
+            ],
+            "min": 3,
+            "dir": "data"
+          }
+        ],
+        "scripts": [
+          {
+            "name": "checkJsonValid",
+            "scope": "standard",
+            "inputs": {
+              "file": "pack.mcmeta"
+            }
+          }
+        ],
+        "onReject": "scaffold",
+        "maxAttempts": 3
+      },
+      "next": "docs"
+    },
+    {
+      "id": "docs",
+      "name": "Write the README",
+      "description": "install and test steps a twelve-year-old can follow",
+      "prompt": "Write the README that gets the mod into the game. Step 1: open with what the mod does, in one line a kid would repeat to a friend. Step 2: write the install steps — where the datapack folder goes for the target version, written concretely for the platform, one action per step, no step assuming knowledge the last step did not give. Step 3: write the test step — exactly what to do in-game to see the mod work, and exactly what should happen when it does. Step 4: add the version note — which game version this pack targets and the one-line warning that other versions may need a different format number. Write README.md and call write_task_note with the README path and the test step in one line.",
+      "suggestedRole": "copywriter",
+      "advanceWhen": {
+        "file": "README.md",
+        "minBytes": 1,
+        "sniff": "nonempty"
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "README.md",
+            "bytes": 600
+          }
+        ],
+        "scripts": [
+          {
+            "name": "checkContains",
+            "scope": "standard",
+            "inputs": {
+              "file": "README.md",
+              "pattern": "(?:^|\\n)#{1,3}\\s+\\S",
+              "flags": "i"
+            }
+          }
+        ],
+        "onReject": "docs",
+        "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 pack.mcmeta, walk the tree under data/, and read README.md against every criterion from {{workPath}}/scope.md: pack.mcmeta is valid JSON carrying the pack_format locked for the target version, all content sits under the namespaced folders with the version's correct folder names, the working example is complete — trace the core idea file by file and confirm every reference resolves — and the README's install and test steps are concrete enough for a twelve-year-old to follow without help. Write PASS/FAIL per criterion; on any failure, name the missing or misplaced file and loop back to scaffold.\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: \"scaffold\" })` 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": "README.md"
+        }
+      ],
+      "next": "scaffold"
+    },
+    {
+      "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/mo/mod-scaffold/versions/1.0.2/test.json

@@ -0,0 +1,136 @@
+{
+  "schemaVersion": 1,
+  "title": "Scaffold a Mod smoke eval",
+  "objective": "Task-specific eval for the Scaffold a Mod craftbook: a craft-a-boat-get-a-diamond datapack for Minecraft 1.21 — pack.mcmeta with the format number from the house version notes, singular 1.21 folder names under a namespace, one working example, and a README a kid can follow.",
+  "tags": [
+    "corpus"
+  ],
+  "prompt": "my kid wants a datapack that gives you a diamond when you craft a boat — can you scafold it for 1.21?",
+  "setup": {
+    "projectName": "Mod Workshop — Datapack Scaffold Eval",
+    "about": "Self-contained eval project for mod-scaffold. The target is a Minecraft 1.21 datapack; the house version notes at tasks/eval/format-versions.md carry the pack_format table (1.21 uses 48) and the 1.21 singular folder-name rule. pack.mcmeta goes at the workspace root, the namespaced content under data/, and the install guide in README.md.",
+    "missionObjectives": "Use the Scaffold a Mod craftbook/template, lock the 1.21 structure rules from the version notes, build the datapack tree with one working example of the boat-diamond idea, and write README.md with install and test steps. No game launches or external tools — the scaffold and docs are the deliverable.",
+    "files": [
+      {
+        "path": "tasks/eval/format-versions.md",
+        "content": "# Datapack format numbers (house notes)\n\n| Game version | pack_format |\n| --- | --- |\n| 1.20 | 15 |\n| 1.20.6 | 41 |\n| 1.21 | 48 |\n| 1.21.5 | 71 |\n\nFolder names: since 1.21 the data folder names are singular - function,\nrecipe, advancement, loot_table, and tags/function. Before 1.21 they were\nplural - functions, recipes, advancements, loot_tables, tags/functions.\nA pack using the old plural names loads on 1.21+ but its content silently\nnever fires.\n"
+      }
+    ],
+    "worker": {
+      "name": "Milan",
+      "role": "Developer"
+    },
+    "craftbookParams": {
+      "workPath": "tasks/eval"
+    }
+  },
+  "mocks": [],
+  "success": {
+    "summary": "pack.mcmeta declares pack_format 48 per the version notes, the namespaced tree under data/ carries a working boat-diamond example in at least three content files, and README.md gives concrete install and test steps naming 1.21.",
+    "deliverables": [
+      {
+        "path": "pack.mcmeta",
+        "kind": "json",
+        "checks": [
+          {
+            "kind": "jsonPathEquals",
+            "file": "pack.mcmeta",
+            "path": "pack.pack_format",
+            "value": 48,
+            "label": "pack_format matches the 1.21 value from the version notes"
+          }
+        ]
+      },
+      {
+        "path": "README.md",
+        "kind": "markdown-doc",
+        "minBytes": 500,
+        "checks": [
+          {
+            "kind": "contains",
+            "file": "README.md",
+            "pattern": "(?:^|\\n)#{1,3}\\s+\\S",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "README.md",
+            "pattern": "install",
+            "flags": "i",
+            "label": "install steps are present"
+          },
+          {
+            "kind": "contains",
+            "file": "README.md",
+            "pattern": "1\\.21",
+            "label": "the target version is named"
+          },
+          {
+            "kind": "contains",
+            "file": "README.md",
+            "pattern": "boat",
+            "flags": "i",
+            "label": "the test step exercises the mod idea"
+          }
+        ]
+      }
+    ],
+    "checks": [
+      {
+        "kind": "fileCount",
+        "ext": [
+          "json",
+          "mcfunction"
+        ],
+        "min": 3,
+        "dir": "data"
+      },
+      {
+        "kind": "fileCount",
+        "ext": [
+          "mcfunction"
+        ],
+        "min": 1,
+        "dir": "data"
+      },
+      {
+        "kind": "judge",
+        "file": "README.md",
+        "rubric": "The install steps are concrete enough for a twelve-year-old (where the folder goes, one action per step) and the test step says exactly what to do in-game and what should happen. The version note warns that other versions may need a different format number.",
+        "sourceFiles": [
+          "tasks/eval/format-versions.md"
+        ],
+        "label": "kid-followable docs"
+      }
+    ]
+  },
+  "rubric": {
+    "artifact": {
+      "path": "README.md",
+      "kind": "markdown"
+    },
+    "axes": [
+      {
+        "name": "structure-correctness",
+        "description": "The tree uses the 1.21 singular folder names under a proper namespace; every file the example needs exists."
+      },
+      {
+        "name": "version-awareness",
+        "description": "pack_format and folder layout come from the version notes, not memory."
+      },
+      {
+        "name": "docs-clarity",
+        "description": "Install and test steps work for a kid with no prior modding."
+      },
+      {
+        "name": "idea-fit",
+        "description": "The working example actually implements craft-a-boat-get-a-diamond."
+      }
+    ]
+  },
+  "qualityFocus": [
+    "version-correct structure",
+    "complete working example",
+    "kid-followable docs"
+  ]
+}

package/data/craftbook-templates/mo/monitor-and-alert/versions/1.0.2/craftbook.json

@@ -0,0 +1,170 @@
+{
+  "id": "monitor-and-alert",
+  "name": "Watch a Page or API and Alert",
+  "description": "Build a watcher that polls a web page or API endpoint on a schedule, detects a meaningful change or threshold breach, and fires an alert (and only alerts on real changes, not noise). Scopes the watched target, the exact change/threshold condition, and the dedup/cooldown policy FIRST, then builds the poll-diff-notify loop with persisted state, then tests it against simulated change and no-change inputs so it neither misses a real change nor spams on every poll. Condition-and-cooldown-before-build is the wisdom that separates a useful monitor from an alert-fatigue generator.\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 monitor (planner) — target, change condition, dedup + cooldown policy → gated on artifact `{{workPath}}/scope.md` (markdown-notes)\n2. Build the watcher (developer) — poll, extract, diff vs state, alert on real change → gated on `monitor.py` (code-module)\n3. Test the watcher (developer) — assert it alerts on change, stays silent otherwise → gated on `monitor_test.py` (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": "scope",
+  "triggers": [
+    "watch a page for changes",
+    "alert me when this changes",
+    "monitor an API",
+    "notify on a price drop",
+    "uptime watcher"
+  ],
+  "steps": [
+    {
+      "id": "scope",
+      "name": "Scope the monitor",
+      "description": "target, change condition, dedup + cooldown policy",
+      "prompt": "Define what to watch and what counts as alert-worthy before building. Step 1: name the target (URL or API endpoint), the poll interval, and exactly which value to extract (a price, a status code, a count, a specific text region) — not the whole page. Step 2: define the change condition precisely — equality change, threshold crossing (>=, <=), or appearance/disappearance of a substring. Step 3: define the dedup/cooldown policy so you alert once per distinct change, not every poll (persist last-seen value + last-alert time; require a cooldown window). Step 4: define the alert channel and message template (what the alert says, including old→new value). Step 5: write an acceptance-criteria checklist ('extracts only the target value', 'fires exactly once on a real change', 'silent when nothing changed', 'respects the cooldown', 'persists state across runs'). Call write_task_note with the condition + policy + checklist and write it to {{workPath}}/scope.md. No code yet.\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 watcher",
+      "description": "poll, extract, diff vs state, alert on real change",
+      "prompt": "Implement the watcher to the locked condition and policy. Step 1: load persisted state (last-seen value, last-alert timestamp) or initialize on first run. Step 2: fetch the target and extract only the scoped value, with error handling so a transient fetch failure does not crash or false-alert. Step 3: evaluate the change condition against the last-seen value; if met AND the cooldown has elapsed, format and send the alert with old→new. Step 4: always persist the new last-seen value (and last-alert time when alerting) so the next run diffs correctly. Step 5: make it runnable on the chosen interval (a script suitable for cron) and write it to a code module. Call write_task_note with the module path and how state is persisted.",
+      "suggestedRole": "developer",
+      "advanceWhen": {
+        "file": "monitor.py",
+        "minBytes": 1,
+        "sniff": "nonempty"
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "monitor.py",
+            "bytes": 200
+          },
+          {
+            "kind": "sniff",
+            "file": "monitor.py",
+            "sniff": "nonempty"
+          },
+          {
+            "kind": "esmImports",
+            "file": "monitor.py"
+          },
+          {
+            "kind": "sourceParses",
+            "file": "monitor.py"
+          }
+        ],
+        "onReject": "build",
+        "maxAttempts": 3
+      },
+      "next": "test"
+    },
+    {
+      "id": "test",
+      "name": "Test the watcher",
+      "description": "assert it alerts on change, stays silent otherwise",
+      "prompt": "Prove the watcher behaves on every case before trusting it. Step 1: write tests that feed a fixed last-seen state plus a new reading. Step 2: assert the no-change case sends NO alert. Step 3: assert a real change (or threshold crossing) sends EXACTLY ONE alert with the correct old→new values. Step 4: assert that a second identical change within the cooldown window does NOT re-alert, and that it does alert again after the window. Step 5: assert a fetch failure is handled (no crash, no false alert) and that state is persisted after each run. Put the watcher and these tests in a single code-with-tests file; run them and confirm green. Call write_task_note with the test file path and the pass count.",
+      "suggestedRole": "developer",
+      "advanceWhen": {
+        "file": "monitor_test.py",
+        "minBytes": 1,
+        "sniff": "nonempty"
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "monitor_test.py",
+            "bytes": 300
+          },
+          {
+            "kind": "sniff",
+            "file": "monitor_test.py",
+            "sniff": "nonempty"
+          },
+          {
+            "kind": "esmImports",
+            "file": "monitor_test.py"
+          },
+          {
+            "kind": "sourceParses",
+            "file": "monitor_test.py"
+          }
+        ],
+        "scripts": [
+          {
+            "name": "checkContains",
+            "scope": "standard",
+            "inputs": {
+              "file": "monitor_test.py",
+              "pattern": "\\b(test|describe|it|assert|expect)\\b",
+              "flags": "i"
+            }
+          }
+        ],
+        "onReject": "test",
+        "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": "Run the tests in monitor_test.py (or trace them) and verify every criterion from {{workPath}}/scope.md: only the target value is extracted, a real change fires exactly one alert with old→new, no-change polls are silent, the cooldown suppresses duplicate alerts and releases after the window, fetch failures do not false-alert, and state persists across runs. Write PASS/FAIL per criterion; on any failure, name it and loop back to test.\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: \"test\" })` 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": "monitor_test.py"
+        }
+      ],
+      "next": "test"
+    },
+    {
+      "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"
+}