@bendyline/gilde 0.1.38 → 0.1.39

package/data/craftbook-templates/au/audio-highlight-reel/versions/1.0.2/craftbook.json

@@ -0,0 +1,135 @@
+{
+  "id": "audio-highlight-reel",
+  "name": "Audio Highlight Reel",
+  "description": "Cut a long recording (podcast, interview, talk, stream) down to a short highlight reel of its best moments, delivered as a single stitched audio clip plus a cue sheet of the segments used. Locks selection criteria and target length FIRST, selects the strongest timestamped segments against those criteria, then assembles them into one clean reel with smooth joins. Defining 'what makes a highlight' and the runtime budget before cutting is what keeps the reel tight and on-theme instead of a random montage.\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. Selection criteria (planner) — what counts as a highlight, target length, ordering → gated on artifact `{{workPath}}/criteria.md` (markdown-notes)\n2. Select segments (developer) — score candidates, pick segments with in/out timestamps → gated on artifact `{{workPath}}/segments.json` (json)\n3. Assemble the reel (developer) — cut + stitch segments into one audio file + cue sheet → gated on `reel.mp3` (audio-file)\n\nThe gates never advance with an unmet criterion, and loop back to the\nowning phase to fix named gaps.\n",
+  "entryStepId": "criteria",
+  "triggers": [
+    "highlight reel from audio",
+    "cut the best moments",
+    "make a teaser clip",
+    "shorten this recording to highlights",
+    "audio sizzle reel"
+  ],
+  "steps": [
+    {
+      "id": "criteria",
+      "name": "Selection criteria",
+      "description": "what counts as a highlight, target length, ordering",
+      "prompt": "Decide what to keep BEFORE cutting. Step 1: record the source (path, duration, transcript if available). Step 2: define the target reel length (e.g. 90-120s) and segment count/length bounds (e.g. 4-8 clips, each 8-25s). Step 3: write concrete selection criteria — what makes a moment a highlight here (a strong quote, a laugh, a key insight, an emotional beat, a clear answer) — so selection is judgeable, not vibes. Step 4: decide ordering (chronological, or hook-first) and whether to add short fades/gaps between clips. Step 5: decide intro/outro handling. Write an acceptance-criteria checklist (reel within ±15% of target length, N segments within bounds, each chosen segment matches a stated criterion, joins are clean with no mid-word cuts, a cue sheet lists each segment's source in/out) and decisions to `{{workPath}}/criteria.md` via write_task_note AND the produces path.\n\nThe deliverable `{{workPath}}/criteria.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}}/criteria.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "{{workPath}}/criteria.md",
+            "bytes": 120,
+            "artifact": true
+          },
+          {
+            "kind": "sniff",
+            "file": "{{workPath}}/criteria.md",
+            "sniff": "nonempty",
+            "artifact": true
+          }
+        ],
+        "onReject": "criteria",
+        "maxAttempts": 3
+      },
+      "next": "select"
+    },
+    {
+      "id": "select",
+      "name": "Select segments",
+      "description": "score candidates, pick segments with in/out timestamps",
+      "prompt": "Choose the segments against the criteria. Step 1: scan the transcript/audio and identify candidate moments, each with a precise in/out timestamp and the criterion it satisfies. Step 2: score/rank candidates and pick the set that fits the target length and segment bounds, trimming each in/out to natural pauses so no clip cuts a word in half. Step 3: order them per the scope (hook-first or chronological). Step 4: write the chosen segments to `{{workPath}}/segments.json` (each: source in, out, criterion, one-line why) via write_task_note AND the produces path. Do not exceed the segment count or length budget. On a loop-back, swap only the flagged segments.\n\nThe deliverable `{{workPath}}/segments.json` 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}}/segments.json",
+        "minBytes": 1,
+        "sniff": "json-valid",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "{{workPath}}/segments.json",
+            "bytes": 2,
+            "artifact": true
+          }
+        ],
+        "onReject": "select",
+        "maxAttempts": 3
+      },
+      "next": "assemble"
+    },
+    {
+      "id": "assemble",
+      "name": "Assemble the reel",
+      "description": "cut + stitch segments into one audio file + cue sheet",
+      "prompt": "Build the reel from the selected segments. Step 1: cut each segment from the source at its in/out, apply short fade-in/out at joins (and gaps if scoped) so transitions are smooth. Step 2: concatenate in the chosen order into one audio file `reel.mp3` (or the source format). Step 3: normalize loudness so clips don't jump in volume. Step 4: write a human-readable cue sheet `reel-cues.md` listing each segment: reel timecode, source in/out, and the highlight reason. Step 5: confirm the reel's total duration is within the target window. write_task_note the reel path, the cue sheet path, and the final duration. On a loop-back, re-cut only the flagged joins/segments.",
+      "suggestedRole": "developer",
+      "advanceWhen": {
+        "file": "reel.mp3",
+        "minBytes": 1,
+        "sniff": "nonempty"
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "reel.mp3",
+            "bytes": 1000
+          }
+        ],
+        "onReject": "assemble",
+        "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": "Listen to and measure the reel. Step 1: confirm `reel.mp3` exists, is non-silent, and its duration is within ±15% of the target (PASS/FAIL). Step 2: confirm the cue sheet lists each segment with reel timecode + source in/out + reason, and the count is within bounds. Step 3: sample-listen (if an audio capability exists) for clean joins — no mid-word cuts, no volume jumps. Step 4: confirm each kept segment maps to a stated highlight criterion. Step 5: confirm ordering matches the scope. Write PASS/FAIL per criterion.\n\nThen route — this is the whole point of the loop:\n\n- **Every criterion PASSES →** call `advance_task_step({ ref, stepId: \"evaluate\", next: \"finish\" })`.\n- **Any criterion FAILS →** write the specific gaps to notes, then call `advance_task_step({ ref, stepId: \"evaluate\", next: \"assemble\" })` 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": "reel.mp3"
+        }
+      ],
+      "next": "assemble"
+    },
+    {
+      "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/au/audio-highlight-reel/versions/1.0.2/test.json

@@ -0,0 +1,106 @@
+{
+  "schemaVersion": 1,
+  "title": "Audio Highlight Reel smoke eval",
+  "objective": "Self-contained smoke eval for the Audio Highlight Reel 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": "Audio Highlight Reel Eval",
+    "about": "Self-contained eval project for audio-highlight-reel. Seeded inputs are under workspace/source or workspace/fixtures; final deliverable is workspace/media-plan.json.",
+    "missionObjectives": "Use the Audio Highlight Reel 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": "# Audio Highlight Reel 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: audio-highlight-reel - Audio Highlight Reel.\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": "audio-highlight-reel-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/au/audiobook-master-pack/versions/1.0.4/craftbook.json

@@ -0,0 +1,222 @@
+{
+  "id": "audiobook-master-pack",
+  "name": "Master the Audiobook",
+  "description": "Assemble the finished chapters into a release: completeness swept against the manuscript first, the metadata manifest built and verified chapter by chapter, the master assembled through the project's media pipeline with a run log, and the listener-facing description written — the moment the folder of takes becomes a book. Locks the packaging rules FIRST (order, metadata fields, total duration), then the manifest, then the master, then the release copy. Use for mastering an audiobook, packaging the chapters, audiobook release prep, and 'all the chapters are rendered, now what'.\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. Sweep for completeness (producer) — chapters on disk checked against the manuscript, rules locked → gated on artifact `{{workPath}}/scope.md` (markdown-notes)\n2. Build the manifest (data-analyst) — master/manifest.json: chapter, file, duration, order → gated on `master/manifest.json` (json)\n3. Assemble the master (developer) — the chapters concatenated into the master with its log → gated on `master/book.m4b` (generic-file)\n4. Write the release copy (copywriter) — listener description and release notes for the finished book → gated on artifact `master/release-notes.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": [
+    "master the audiobook",
+    "package the chapters",
+    "assemble the book",
+    "audiobook release prep",
+    "finish the audiobook"
+  ],
+  "steps": [
+    {
+      "id": "scope",
+      "name": "Sweep for completeness",
+      "description": "chapters on disk checked against the manuscript, rules locked",
+      "prompt": "Establish that the book is actually finished before packaging it. Step 1: read the manuscript's table of contents under manuscript/ and list every chapter the book should have. Step 2: sweep the rendered audio under audio/ — each chapter's audio file and its run log — and check the two lists against each other; a missing or failed chapter stops the run here, reported plainly, because a master with a hole in it is not a master. Step 3: lock the packaging rules — the manifest at master/manifest.json records every chapter with its audio file, duration, and play order; order follows the manuscript; durations come from the chapters' run logs, never estimated; and the master is assembled through the project's pipeline script via the run_installed_script tool with a status-ok log. Step 4: write an acceptance-criteria checklist ('every manuscript chapter has rendered audio', 'manifest complete with file, duration, and order per chapter', 'no duplicate chapters', 'master assembled with a status-ok log', 'total duration equals the sum of the chapters', 'listener description written'). Call write_task_note with the chapter counts + 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": "producer",
+      "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": "manifest"
+    },
+    {
+      "id": "manifest",
+      "name": "Build the manifest",
+      "description": "master/manifest.json: chapter, file, duration, order",
+      "prompt": "Build the metadata manifest the master run and every player will trust. Step 1: write master/manifest.json as a JSON array, one record per chapter — the chapter title as the manuscript names it, the audio file path exactly as it exists under audio/, the duration taken from that chapter's run log, and the play order as a number following the manuscript. Step 2: verify as you go — every file path must point at a file that exists, no chapter appears twice, and the orders run without gaps. Step 3: total the durations and note the book's full running time for the release copy. Call write_task_note with the record count and the total duration.",
+      "suggestedRole": "data-analyst",
+      "advanceWhen": {
+        "file": "master/manifest.json",
+        "minBytes": 1,
+        "sniff": "json-valid"
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "master/manifest.json",
+            "bytes": 2
+          },
+          {
+            "kind": "recordSchema",
+            "file": "master/manifest.json",
+            "fields": [
+              {
+                "name": "chapter",
+                "type": "nonempty"
+              },
+              {
+                "name": "file",
+                "type": "nonempty"
+              },
+              {
+                "name": "duration"
+              },
+              {
+                "name": "order"
+              }
+            ],
+            "minRows": 3,
+            "uniqueBy": "chapter"
+          }
+        ],
+        "scripts": [
+          {
+            "name": "checkJsonValid",
+            "scope": "standard",
+            "inputs": {
+              "file": "master/manifest.json"
+            }
+          }
+        ],
+        "onReject": "manifest",
+        "maxAttempts": 3
+      },
+      "next": "assemble"
+    },
+    {
+      "id": "assemble",
+      "name": "Assemble the master",
+      "description": "the chapters concatenated into the master with its log",
+      "prompt": "Assemble the release master. Step 1: the mastering pipeline is a project script — call list_scripts to find it, then run it with run_installed_script({ name: \"<script name>\" }); never run it with run_nodejs_script and never reimplement it. It reads master/manifest.json, verifies every referenced audio file exists, joins the chapters in manifest order into master/book.m4b, and writes its run log to master/assembly-log.json with a status field, the chapter count, and the total duration it computed. Step 2: if run_installed_script reports an error, read the error text, fix what it names — usually a manifest path or order — and run it again; never write master/assembly-log.json yourself — the log is evidence the pipeline ran. Step 3: once it succeeds, read the log and confirm status ok, the chapter count matching the manifest, and the total duration matching the manifest's sum. Call write_task_note with the run outcome and the master's total duration.",
+      "suggestedRole": "developer",
+      "consumes": [
+        {
+          "file": "master/manifest.json"
+        }
+      ],
+      "advanceWhen": {
+        "file": "master/book.m4b",
+        "minBytes": 1,
+        "sniff": "nonempty"
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "master/book.m4b",
+            "bytes": 200
+          },
+          {
+            "kind": "sniff",
+            "file": "master/book.m4b",
+            "sniff": "nonempty"
+          },
+          {
+            "kind": "sniff",
+            "file": "master/assembly-log.json",
+            "sniff": "json-valid"
+          },
+          {
+            "kind": "jsonPathEquals",
+            "file": "master/assembly-log.json",
+            "path": "status",
+            "value": "ok",
+            "label": "the assembly log reports status ok"
+          }
+        ],
+        "onReject": "assemble",
+        "maxAttempts": 3
+      },
+      "next": "package"
+    },
+    {
+      "id": "package",
+      "name": "Write the release copy",
+      "description": "listener description and release notes for the finished book",
+      "prompt": "Write the words that travel with the book. Step 1: write the listener-facing description — what the book is about and who it is for, in the voice a listener browsing a store would actually read, without spoiling it. Step 2: add the release facts — the total running time from the master log, the chapter count, and the chapter list with per-chapter durations from the manifest. Step 3: add the release notes for the owner — what was assembled, anything flagged during the sweep, and the one-line confirmation that the master's numbers match the manifest. Write master/release-notes.md and call write_task_note with the path and the total running time.\n\nThe deliverable `master/release-notes.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": "copywriter",
+      "advanceWhen": {
+        "file": "master/release-notes.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "master/release-notes.md",
+            "bytes": 600,
+            "artifact": true
+          },
+          {
+            "kind": "contains",
+            "file": "master/release-notes.md",
+            "pattern": "(?:^|\\n)#{1,3}\\s+\\S",
+            "flags": "i",
+            "label": "at least one markdown heading",
+            "artifact": true
+          }
+        ],
+        "onReject": "package",
+        "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 master/release-notes.md, master/manifest.json, and master/assembly-log.json and verify every criterion from {{workPath}}/scope.md: every manuscript chapter appears in the manifest exactly once with file, duration, and order, the referenced audio files exist, the log reports status ok with a chapter count and total duration matching the manifest, the release copy states the total running time, and the listener description reads like store copy rather than an internal note. Write PASS/FAIL per criterion; on any failure, name the gap and loop back to package — or to manifest if the metadata is the problem.\n\nThe deliverable lives in the project's artifacts drawer — open `master/release-notes.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: \"package\" })` 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": "master/release-notes.md",
+          "artifact": true
+        }
+      ],
+      "next": "package"
+    },
+    {
+      "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.4",
+  "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"
+}