@bendyline/gilde 0.1.51 → 0.1.52

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

@@ -0,0 +1,242 @@
+{
+  "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.",
+  "entryStepId": "triage",
+  "triggers": [
+    "sweep the open findings",
+    "nightly fixes",
+    "draft fixes for the open issues",
+    "fix the boekwachter findings"
+  ],
+  "runModes": {
+    "nightShift": "recommended"
+  },
+  "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",
+      "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.",
+      "suggestedRole": "developer",
+      "capabilityFloor": "medium",
+      "advanceWhen": {
+        "file": "{{workPath}}/clusters.json",
+        "minBytes": 2,
+        "sniff": "json-valid",
+        "artifact": true
+      },
+      "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",
+      "toolPolicy": {
+        "disallowBuiltinToolsets": [
+          "ai-apps",
+          "archives",
+          "audio",
+          "browser-automation",
+          "craftbooks",
+          "data-tables",
+          "entity-intel",
+          "git",
+          "image-intel",
+          "images",
+          "role-delegation",
+          "role-delegation-escalation",
+          "security-intel",
+          "team-management",
+          "videos",
+          "web",
+          "workspace-fs-write"
+        ],
+        "outputMedium": "artifact",
+        "additionalOutputMedia": [
+          "task-note"
+        ]
+      }
+    },
+    {
+      "id": "fanout",
+      "name": "Draft the proposals",
+      "prompt": "Your clusters are being drafted, one proposal per cluster. Wait for the shards to finish, then call `advance_task_step`.",
+      "next": "collect",
+      "spawnFanout": true,
+      "toolPolicy": {
+        "disallowBuiltinToolsets": [
+          "ai-apps",
+          "archives",
+          "artifacts",
+          "audio",
+          "browser-automation",
+          "code-execution",
+          "craftbooks",
+          "data-tables",
+          "entity-intel",
+          "git",
+          "image-intel",
+          "images",
+          "role-delegation",
+          "role-delegation-escalation",
+          "security-intel",
+          "team-management",
+          "videos",
+          "web",
+          "workspace-fs-write"
+        ],
+        "outputMedium": "none"
+      }
+    },
+    {
+      "id": "collect",
+      "name": "Hand over",
+      "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.",
+      "terminal": true,
+      "toolPolicy": {
+        "disallowBuiltinToolsets": [
+          "ai-apps",
+          "archives",
+          "artifacts",
+          "audio",
+          "browser-automation",
+          "code-execution",
+          "craftbooks",
+          "data-tables",
+          "entity-intel",
+          "git",
+          "image-intel",
+          "images",
+          "role-delegation",
+          "role-delegation-escalation",
+          "security-intel",
+          "team-management",
+          "videos",
+          "web",
+          "workspace-fs-write"
+        ],
+        "outputMedium": "task-note"
+      }
+    }
+  ],
+  "spawn": {
+    "overFile": "{{workPath}}/clusters.json",
+    "overArtifact": true,
+    "entryStepId": "draft",
+    "steps": [
+      {
+        "id": "draft",
+        "name": "Draft the change",
+        "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`.",
+        "suggestedRole": "developer",
+        "capabilityFloor": "small",
+        "advanceWhen": {
+          "file": "{{diffpack.dir}}/notes.md",
+          "minBytes": 200,
+          "artifact": true
+        },
+        "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,
+        "toolPolicy": {
+          "disallowBuiltinToolsets": [
+            "ai-apps",
+            "archives",
+            "audio",
+            "browser-automation",
+            "code-execution",
+            "craftbooks",
+            "data-tables",
+            "entity-intel",
+            "git",
+            "image-intel",
+            "images",
+            "role-delegation",
+            "role-delegation-escalation",
+            "security-intel",
+            "team-management",
+            "videos",
+            "web"
+          ],
+          "outputMedium": "artifact",
+          "additionalOutputMedia": [
+            "workspace"
+          ]
+        }
+      }
+    ]
+  },
+  "diffpackCapable": true,
+  "capabilityFloor": "small",
+  "version": "1.0.1",
+  "releasedAt": "2026-09-01T20:00:00Z",
+  "minGezelVersion": "1.26236"
+}

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

@@ -0,0 +1,120 @@
+{
+  "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": {
+      "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": "{{task.dir}}/clusters.json",
+        "kind": "json",
+        "artifact": true,
+        "minBytes": 2,
+        "checks": [
+          {
+            "kind": "recordSchema",
+            "file": "{{task.dir}}/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": "{{task.dir}}/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/no/notification-router/versions/1.0.3/craftbook.json

@@ -0,0 +1,293 @@
+{
+  "id": "notification-router",
+  "name": "Notification Router",
+  "description": "Build an event-to-channel notification router: a small module that takes incoming events and routes each to the right destination (Slack channel, email, PagerDuty, webhook) based on type, severity, and quiet-hours rules — with dedupe, throttling, and a fallback channel. Scopes the routing matrix and policy FIRST (event taxonomy, channel map, severity→destination rules, dedupe key, rate limits, fallback), then a developer implements the router module to that matrix, then writes tests covering each routing branch. Scoping the matrix before coding is what guarantees every event type has a defined destination and that critical events can never be silently dropped. Use for notification routing, alert fan-out, event dispatch, webhook routing, and on-call/Slack notification systems.\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 router (planner) — lock the routing matrix, dedupe, throttle, and fallback → gated on artifact `{{workPath}}/scope.md` (markdown-notes)\n2. Build the router (developer) — implement the router module to the matrix → gated on `router.ts` (code-module)\n3. Test the router (developer) — cover every routing branch with assertions → gated on `router.test.ts` (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": [
+    "notification router",
+    "route events to channels",
+    "alert fan-out",
+    "event dispatch",
+    "send notifications to slack"
+  ],
+  "paramSchema": {
+    "type": "object",
+    "properties": {
+      "workPath": {
+        "type": "string",
+        "title": "Working folder",
+        "description": "Per-task working folder in the artifacts drawer. Defaults to this task's own folder so runs never collide; override with a stable name when you deliberately want runs to share files.",
+        "default": "{{task.dir}}"
+      }
+    }
+  },
+  "steps": [
+    {
+      "id": "scope",
+      "name": "Scope the router",
+      "description": "lock the routing matrix, dedupe, throttle, and fallback",
+      "prompt": "Define the routing contract before coding. (1) Enumerate the event taxonomy (the event types/shapes the router accepts) and the available destination channels. (2) Build the routing matrix: for each (event type × severity) pair, the destination channel(s) — make it total so no input is undefined. (3) Define the dedupe key (which fields identify a duplicate within a window) and the suppression window. (4) Set per-channel rate limits/throttling and a quiet-hours rule (and which severities override quiet hours). (5) Define a fallback channel for events that match no rule, so nothing is dropped silently, and the behavior on a destination send failure (retry/fallback). (6) Pick the language and the function signature, e.g. route(event) -> Destination[]. Write an acceptance-criteria checklist ('every (type,severity) maps to a destination', 'unmatched events hit the fallback, never dropped', 'duplicates within the window are suppressed', 'rate limits enforced', 'critical severity overrides quiet hours', 'pure routing logic is unit-testable without live channels') plus the matrix to {{workPath}}/scope.md via write_task_note AND the produces path.\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",
+      "toolPolicy": {
+        "disallowBuiltinToolsets": [
+          "ai-apps",
+          "archives",
+          "audio",
+          "browser-automation",
+          "code-execution",
+          "craftbooks",
+          "data-tables",
+          "entity-intel",
+          "git",
+          "image-intel",
+          "images",
+          "role-delegation",
+          "role-delegation-escalation",
+          "security-intel",
+          "team-management",
+          "videos",
+          "web",
+          "workspace-fs-write"
+        ],
+        "outputMedium": "artifact",
+        "additionalOutputMedia": [
+          "task-note"
+        ]
+      }
+    },
+    {
+      "id": "build",
+      "name": "Build the router",
+      "description": "implement the router module to the matrix",
+      "prompt": "Implement the router as a single module (e.g. router.ts/router.py) realizing the locked matrix. Separate PURE routing logic — route(event) returning the destination list — from any side-effecting send, so routing is testable in isolation. Implement: matrix lookup with the fallback for unmatched events, dedupe via the locked key + window (an in-memory recent-key set is fine), per-channel throttling, and the quiet-hours rule with the critical-severity override. Validate/normalize inbound events and reject malformed ones explicitly. Never let an event with no matching rule vanish — it goes to fallback. Add brief doc comments mapping code back to matrix rows. On a loop-back fix only the flagged behavior. Write the module path and the implemented signature to notes via write_task_note.",
+      "suggestedRole": "developer",
+      "advanceWhen": {
+        "file": "router.ts",
+        "minBytes": 1,
+        "sniff": "nonempty"
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "router.ts",
+            "bytes": 200
+          },
+          {
+            "kind": "sniff",
+            "file": "router.ts",
+            "sniff": "nonempty"
+          },
+          {
+            "kind": "esmImports",
+            "file": "router.ts"
+          },
+          {
+            "kind": "sourceParses",
+            "file": "router.ts"
+          }
+        ],
+        "onReject": "build",
+        "maxAttempts": 3
+      },
+      "next": "test",
+      "toolPolicy": {
+        "disallowBuiltinToolsets": [
+          "ai-apps",
+          "archives",
+          "artifacts",
+          "audio",
+          "browser-automation",
+          "craftbooks",
+          "data-tables",
+          "entity-intel",
+          "git",
+          "image-intel",
+          "images",
+          "role-delegation",
+          "role-delegation-escalation",
+          "security-intel",
+          "team-management",
+          "videos",
+          "web"
+        ],
+        "outputMedium": "workspace",
+        "additionalOutputMedia": [
+          "task-note"
+        ]
+      }
+    },
+    {
+      "id": "test",
+      "name": "Test the router",
+      "description": "cover every routing branch with assertions",
+      "prompt": "Write router.test.ts exercising the router's pure logic. Cover, with explicit assertions: (1) a representative event for each (type,severity) row resolves to the matrix's destination; (2) an unmatched event routes to the fallback and is NOT dropped; (3) a duplicate within the window is suppressed and the same key after the window is allowed; (4) throttling blocks the N+1th send to a channel in the window; (5) a critical event during quiet hours still routes, a non-critical one is held; (6) a malformed event is rejected. Use the test runner's describe/it/expect (or equivalent assert). Tests must run without live channels. On a loop-back add the missing cases. Write the test path and the branch-coverage list to notes via write_task_note.",
+      "suggestedRole": "developer",
+      "advanceWhen": {
+        "file": "router.test.ts",
+        "minBytes": 1,
+        "sniff": "nonempty"
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "router.test.ts",
+            "bytes": 300
+          },
+          {
+            "kind": "sniff",
+            "file": "router.test.ts",
+            "sniff": "nonempty"
+          },
+          {
+            "kind": "esmImports",
+            "file": "router.test.ts"
+          },
+          {
+            "kind": "sourceParses",
+            "file": "router.test.ts"
+          }
+        ],
+        "scripts": [
+          {
+            "name": "checkContains",
+            "scope": "standard",
+            "inputs": {
+              "file": "router.test.ts",
+              "pattern": "\\b(test|describe|it|assert|expect)\\b",
+              "flags": "i"
+            }
+          }
+        ],
+        "onReject": "test",
+        "maxAttempts": 4
+      },
+      "next": "evaluate",
+      "toolPolicy": {
+        "disallowBuiltinToolsets": [
+          "ai-apps",
+          "archives",
+          "artifacts",
+          "audio",
+          "browser-automation",
+          "craftbooks",
+          "data-tables",
+          "entity-intel",
+          "git",
+          "image-intel",
+          "images",
+          "role-delegation",
+          "role-delegation-escalation",
+          "security-intel",
+          "team-management",
+          "videos",
+          "web"
+        ],
+        "outputMedium": "workspace",
+        "additionalOutputMedia": [
+          "task-note"
+        ]
+      }
+    },
+    {
+      "id": "evaluate",
+      "name": "Evaluate",
+      "description": "Grade the deliverable against every acceptance criterion. All pass → finish; any fail → loop back and fix the gap.",
+      "prompt": "QA the router against the locked criteria. (1) Run the test suite (or trace it) — every test must pass; a failing/empty suite is FAIL. (2) Confirm tests exist for each matrix row, the fallback path, dedupe (hit and post-window allow), throttling, the quiet-hours + critical-override behavior, and malformed-event rejection. (3) Read router.ts: is routing pure and side-effect-free, is the matrix total, can an unmatched event ever be silently dropped (must be NO)? (4) Spot-check 2 matrix rows in code against {{workPath}}/scope.md. Write PASS/FAIL per criterion with the gaps.\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": "router.test.ts"
+        }
+      ],
+      "next": "build",
+      "toolPolicy": {
+        "disallowBuiltinToolsets": [
+          "ai-apps",
+          "archives",
+          "artifacts",
+          "audio",
+          "browser-automation",
+          "craftbooks",
+          "data-tables",
+          "entity-intel",
+          "git",
+          "image-intel",
+          "images",
+          "role-delegation",
+          "role-delegation-escalation",
+          "security-intel",
+          "team-management",
+          "videos",
+          "web",
+          "workspace-fs-write"
+        ],
+        "outputMedium": "task-note"
+      }
+    },
+    {
+      "id": "finish",
+      "name": "Finish",
+      "description": "All acceptance criteria met. Stamp a short summary and report DONE.",
+      "prompt": "Every acceptance criterion passed. Write a one-paragraph DONE summary to task notes via `write_task_note`: what was built, the deliverable path(s), and a one-line confirmation that each criterion is met. Then report DONE.",
+      "suggestedRole": "developer",
+      "terminal": true,
+      "toolPolicy": {
+        "disallowBuiltinToolsets": [
+          "ai-apps",
+          "archives",
+          "artifacts",
+          "audio",
+          "browser-automation",
+          "code-execution",
+          "craftbooks",
+          "data-tables",
+          "entity-intel",
+          "git",
+          "image-intel",
+          "images",
+          "role-delegation",
+          "role-delegation-escalation",
+          "security-intel",
+          "team-management",
+          "videos",
+          "web",
+          "workspace-fs-write"
+        ],
+        "outputMedium": "task-note"
+      }
+    }
+  ],
+  "version": "1.0.3",
+  "releasedAt": "2026-09-01T20:00:00Z",
+  "minGezelVersion": "1.26233"
+}