@bendyline/gilde 0.1.51 → 0.1.52

package/data/craftbook-templates/cl/cli-tool/versions/1.1.3/craftbook.json

@@ -0,0 +1,283 @@
+{
+  "id": "cli-tool",
+  "name": "Command-Line Tool",
+  "description": "Build a command-line tool with subcommands, flags, arguments, help text, and proper exit codes. Designs the CLI UX FIRST — the command surface, flags with defaults, positional args, help/usage output, and exit-code conventions — because a CLI's contract is its interface, then implements argument parsing and command logic, then writes tests for parsing, help, happy paths, and error exits. Covers argv parsing, subcommands, --flags and -short forms, --help, stdin/stdout/stderr conventions, and non-zero exit codes on error.\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. CLI UX scope (planner) — lock the command surface, flags, args, exit codes → gated on artifact `{{workPath}}/ux-scope.md` (markdown-notes)\n2. Build the CLI (developer) — implement parsing + command logic → gated on `src/cli.js` (code-module)\n3. Write CLI tests (developer) — test parsing, help, happy paths, error exits → gated on `src/cli.test.js` (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": "ux-scope",
+  "triggers": [
+    "build a cli tool",
+    "command line tool",
+    "make a terminal command",
+    "cli with subcommands",
+    "argv parser"
+  ],
+  "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": "ux-scope",
+      "name": "CLI UX scope",
+      "description": "lock the command surface, flags, args, exit codes",
+      "prompt": "Design the command-line interface before any logic — the interface IS the contract. Step 1: Enumerate the commands/subcommands and what each does. Step 2: For each, list the positional arguments (required vs optional) and the flags (`--long`, `-s` short form, type, default value, whether it takes a value). Step 3: Draft the exact `--help`/usage text the tool prints, including a one-line synopsis per command. Step 4: Define the IO and exit-code contract: what goes to stdout vs stderr, exit 0 on success, distinct non-zero codes for usage errors vs runtime errors. Step 5: Write a numbered acceptance-criteria checklist of 5-9 items (e.g. 'running with no args or --help prints usage and exits 0', 'an unknown flag prints an error to stderr and exits non-zero', 'the primary command produces the documented output'). `write_task_note` the command spec + checklist and write the same to the produces path. No implementation yet.\n\nThe deliverable `{{workPath}}/ux-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}}/ux-scope.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "{{workPath}}/ux-scope.md",
+            "bytes": 120,
+            "artifact": true
+          },
+          {
+            "kind": "sniff",
+            "file": "{{workPath}}/ux-scope.md",
+            "sniff": "nonempty",
+            "artifact": true
+          }
+        ],
+        "onReject": "ux-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 CLI",
+      "description": "implement parsing + command logic",
+      "prompt": "Implement the CLI in a single runnable source file with a real entry point. Step 1: Parse argv into commands, positional args, and flags exactly as scoped — support both long and short flag forms and apply defaults. Step 2: Implement each command's logic; write normal output to stdout and diagnostics/errors to stderr. Step 3: Wire `--help` (and bare invocation) to print the usage text and exit 0; on unknown command/flag or missing required arg, print a clear error to stderr and exit non-zero. Step 4: Ensure the process exits with the documented code in every path. On a loop-back, fix only the named gaps without regressing working commands. `write_task_note` the file path and which criteria now pass.",
+      "suggestedRole": "developer",
+      "advanceWhen": {
+        "file": "src/cli.js",
+        "minBytes": 1,
+        "sniff": "nonempty"
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "src/cli.js",
+            "bytes": 200
+          },
+          {
+            "kind": "sniff",
+            "file": "src/cli.js",
+            "sniff": "nonempty"
+          },
+          {
+            "kind": "esmImports",
+            "file": "src/cli.js"
+          },
+          {
+            "kind": "sourceParses",
+            "file": "src/cli.js"
+          }
+        ],
+        "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": "Write CLI tests",
+      "description": "test parsing, help, happy paths, error exits",
+      "prompt": "Write tests that invoke the CLI and inspect output + exit code. Step 1: Assert `--help` and bare invocation print usage and exit 0. Step 2: Assert each command's happy path produces the documented stdout and exits 0. Step 3: Assert error cases (unknown flag, missing required arg, bad value) print to stderr and exit non-zero with the right code. Step 4: Assert flag parsing handles long form, short form, and defaults. Capture stdout/stderr separately. `write_task_note` the test file path and pass/fail count.",
+      "suggestedRole": "developer",
+      "advanceWhen": {
+        "file": "src/cli.test.js",
+        "minBytes": 1,
+        "sniff": "nonempty"
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "src/cli.js",
+            "bytes": 200
+          },
+          {
+            "kind": "sniff",
+            "file": "src/cli.js",
+            "sniff": "nonempty"
+          },
+          {
+            "kind": "esmImports",
+            "file": "src/cli.js"
+          },
+          {
+            "kind": "sourceParses",
+            "file": "src/cli.js"
+          }
+        ],
+        "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": "Run the tests and invoke the CLI directly. For EACH acceptance criterion: confirm --help/usage works and exits 0, confirm each command's output matches the spec, confirm errors go to stderr with a non-zero exit, and confirm flag parsing (long, short, defaults) works. 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: \"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": "src/cli.js"
+        }
+      ],
+      "next": "build",
+      "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"
+      }
+    },
+    {
+      "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.1.3",
+  "releasedAt": "2026-09-01T20:00:00Z",
+  "minGezelVersion": "1.26233"
+}

package/data/craftbook-templates/cl/cli-tool/versions/1.1.3/test.json

@@ -0,0 +1,128 @@
+{
+  "schemaVersion": 1,
+  "title": "Small CSV summary CLI",
+  "objective": "Measure whether the cli-tool craftbook scopes command UX, writes a runnable Node CLI, and includes tests/examples.",
+  "tags": [
+    "html-page"
+  ],
+  "prompt": "In the `CLI Tool Eval` project, build a small dependency-free Node ESM CLI named `summarize-orders`. Write `src/cli.js` and `src/cli.test.js`. The CLI should accept `--input <csv>`, `--format table|json`, and `--min-total <number>`, parse order rows with customer,status,total fields, filter by minimum total, and print either a text table or JSON summary. The test file should use Node assert or a tiny test harness and cover JSON output, table output, and min-total filtering.",
+  "setup": {
+    "projectName": "CLI Tool Eval",
+    "about": "Self-contained eval project for cli-tool. Deliverables are workspace/src/cli.js and workspace/src/cli.test.js.",
+    "missionObjectives": "Produce a small dependency-free Node CLI with argument parsing, CSV parsing, JSON/table output, and tests.",
+    "files": [],
+    "worker": {
+      "name": "Koen",
+      "role": "Developer"
+    }
+  },
+  "mocks": [],
+  "success": {
+    "summary": "src/cli.js implements argument parsing/output modes and src/cli.test.js covers the core CLI behavior.",
+    "deliverables": [
+      {
+        "path": "src/cli.js",
+        "kind": "code-module",
+        "minBytes": 1600,
+        "checks": [
+          {
+            "kind": "contains",
+            "file": "src/cli.js",
+            "pattern": "process\\.argv|argv",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "src/cli.js",
+            "pattern": "--input",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "src/cli.js",
+            "pattern": "--format",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "src/cli.js",
+            "pattern": "--min-total",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "src/cli.js",
+            "pattern": "read_file|fs",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "src/cli.js",
+            "pattern": "JSON\\.stringify|console\\.log",
+            "flags": "i"
+          }
+        ]
+      },
+      {
+        "path": "src/cli.test.js",
+        "kind": "code-with-tests",
+        "minBytes": 900,
+        "checks": [
+          {
+            "kind": "contains",
+            "file": "src/cli.test.js",
+            "pattern": "assert|describe|it|test",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "src/cli.test.js",
+            "pattern": "json",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "src/cli.test.js",
+            "pattern": "table",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "src/cli.test.js",
+            "pattern": "min-total|filter",
+            "flags": "i"
+          }
+        ]
+      }
+    ]
+  },
+  "rubric": {
+    "artifact": {
+      "path": "src/cli.js",
+      "kind": "typescript"
+    },
+    "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": [
+    "CLI UX scope",
+    "argument parsing",
+    "test coverage"
+  ]
+}

package/data/craftbook-templates/co/code-review/versions/1.0.1/craftbook.json

@@ -0,0 +1,229 @@
+{
+  "id": "code-review",
+  "name": "Code Review",
+  "description": "Review one staged change set and deliver a gated report.\n\nThe change set is snapshotted ahead of time into the project artifacts drawer at `reviews/<reviewId>/`: `manifest.json` (kind, base/head, changed files, and — for branch reviews — the commit list) plus `changes.diff` (the unified diff). Three steps:\n\n1. **Scope** — read the snapshot, note the review kind and the themes to check\n2. **Report** — walk the diff and write `reviews/<reviewId>/report.md` (Summary, severity-ranked Findings table with file:line citations, Verdict)\n3. **Done** — stamp the verdict to task notes\n\nThe reviewer never modifies project source — the only deliverable is the report artifact. Reports must ground every finding in the actual diff; the completion gate checks structure, citations, and verdict consistency.",
+  "entryStepId": "scope",
+  "triggers": [
+    "review my uncommitted changes",
+    "review the working tree",
+    "review this branch against main",
+    "review the staged change set"
+  ],
+  "command": "code-review",
+  "requirements": [
+    {
+      "kind": "github"
+    }
+  ],
+  "paramSchema": {
+    "type": "object",
+    "properties": {
+      "reviewId": {
+        "type": "string",
+        "title": "Review id",
+        "description": "The staged snapshot folder under the project artifacts: reviews/<reviewId>/. Filled automatically when launched from the Review panel."
+      },
+      "focus": {
+        "type": "string",
+        "title": "Review focus",
+        "description": "Optional area to emphasize, e.g. security, performance, tests."
+      },
+      "intensity": {
+        "type": "string",
+        "title": "Intensity",
+        "enum": [
+          "low",
+          "medium",
+          "high"
+        ],
+        "default": "medium",
+        "squisq": {
+          "control": "segmented"
+        },
+        "description": "How deep to go on the diff walk."
+      }
+    }
+  },
+  "steps": [
+    {
+      "id": "scope",
+      "name": "Scope the change set",
+      "description": "Read the staged snapshot (manifest + diff) and write a scope note naming the review kind, the changed files, and the themes to check.",
+      "prompt": "**You are the reviewer for one snapshotted change set.** In this task you read code and write exactly ONE report artifact — never modify project source files.\n\n**Your first tool call this turn:** `read_artifact({ path: \"reviews/{{reviewId}}/manifest.json\" })`. If that path contains a literal `{{...}}` placeholder or is missing, call `list_artifacts({ path: \"reviews\" })` and use the newest review folder instead; if none exists, write a task note saying no review snapshot is staged and stop.\n\nThe manifest tells you the review kind (`commit` = unsaved work vs the last save; `pr` = this branch vs the default branch), the base/head, every changed file, and — for branch reviews — the commit list. Then read `reviews/{{reviewId}}/changes.diff` with `read_artifact` (use `head`/`lines` slices on a large diff; the manifest's `diffChars` tells you how big it is).\n\nWrite ONE scope note with `write_task_note`, starting with the line `## Scope`: the review kind, base and head from the manifest, each changed file with its change kind, and the 3-6 themes you will check — weighted by any focus and intensity named in your task description. Then call `advance_task_step`.",
+      "suggestedRole": "reviewer",
+      "gate": {
+        "at": "completion",
+        "scripts": [
+          {
+            "name": "checkTaskNoteContains",
+            "scope": "standard",
+            "inputs": {
+              "pattern": "##\\s*Scope"
+            }
+          }
+        ],
+        "onReject": "scope",
+        "maxAttempts": 3
+      },
+      "next": "report",
+      "toolPolicy": {
+        "disallowBuiltinToolsets": [
+          "ai-apps",
+          "archives",
+          "audio",
+          "browser-automation",
+          "code-execution",
+          "craftbooks",
+          "data-tables",
+          "entity-intel",
+          "image-intel",
+          "images",
+          "role-delegation",
+          "role-delegation-escalation",
+          "security-intel",
+          "team-management",
+          "videos",
+          "web",
+          "workspace-fs-write"
+        ],
+        "outputMedium": "task-note"
+      }
+    },
+    {
+      "id": "report",
+      "name": "Review and write the report",
+      "description": "Walk the diff hunk by hunk and write the complete review report artifact. Writing the report IS the advance — the completion gate checks structure, citations, and verdict consistency.",
+      "prompt": "Walk `reviews/{{reviewId}}/changes.diff` hunk by hunk and review for correctness, security, data-loss risk, error handling, tests, and clarity — weighted by the focus and intensity in your task description. Use `read_file` on workspace files when you need surrounding context. Only discuss files that appear in the change set. Cite every finding as `path:line` using paths exactly as they appear in the diff.\n\nThen write the complete report in ONE `write_artifact` call to `reviews/{{reviewId}}/report.md`, exactly this skeleton:\n\n```\n# Code Review — <one-line title>\nReview-ID: {{reviewId}}\n\n## Summary\n<2-6 sentences: what the change does, overall risk. If there are no findings, say \"No findings.\" here.>\n\n## Findings\n| # | Severity | File | Line | Finding | Recommendation |\n|---|----------|------|------|---------|----------------|\n<one row per finding; severities: critical, major, minor, nit. Keep the header row even when there are no findings.>\n\n## Verdict\nVerdict: approve\n<or> Verdict: request-changes\n<one sentence of rationale. Any critical or major finding means request-changes.>\n```\n\nDo not write any workspace file. If the gate rejects, fix exactly the gap it names and rewrite the whole artifact in one `write_artifact` call. When the report is written, call `advance_task_step` (writing the file may advance this step for you).",
+      "suggestedRole": "reviewer",
+      "advanceWhen": {
+        "file": "reviews/{{reviewId}}/report.md",
+        "minBytes": 400,
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "reviews/{{reviewId}}/report.md",
+            "bytes": 400,
+            "artifact": true
+          },
+          {
+            "kind": "contains",
+            "file": "reviews/{{reviewId}}/report.md",
+            "pattern": "##\\s+Summary",
+            "label": "Summary section",
+            "artifact": true
+          },
+          {
+            "kind": "contains",
+            "file": "reviews/{{reviewId}}/report.md",
+            "pattern": "##\\s+Findings",
+            "label": "Findings section",
+            "artifact": true
+          },
+          {
+            "kind": "contains",
+            "file": "reviews/{{reviewId}}/report.md",
+            "pattern": "\\|\\s*Severity\\s*\\|",
+            "label": "findings table header",
+            "artifact": true
+          },
+          {
+            "kind": "contains",
+            "file": "reviews/{{reviewId}}/report.md",
+            "pattern": "Verdict:\\s*(approve|request-changes)",
+            "label": "verdict line",
+            "artifact": true
+          },
+          {
+            "kind": "tableShape",
+            "file": "reviews/{{reviewId}}/report.md",
+            "requiredColumns": [
+              "Severity",
+              "File",
+              "Finding"
+            ],
+            "artifact": true
+          },
+          {
+            "kind": "judge",
+            "file": "reviews/{{reviewId}}/report.md",
+            "rubric": "Findings are grounded in the actual diff hunks (no invented code or files), severities are proportionate to real impact, and the verdict follows from the findings table.",
+            "sourceFiles": [
+              "reviews/{{reviewId}}/changes.diff"
+            ],
+            "advisory": true,
+            "artifact": true
+          }
+        ],
+        "scripts": [
+          {
+            "name": "checkReviewReport",
+            "scope": "standard"
+          }
+        ],
+        "onReject": "report",
+        "maxAttempts": 4
+      },
+      "next": "done",
+      "toolPolicy": {
+        "disallowBuiltinToolsets": [
+          "ai-apps",
+          "archives",
+          "audio",
+          "browser-automation",
+          "code-execution",
+          "craftbooks",
+          "data-tables",
+          "entity-intel",
+          "git",
+          "image-intel",
+          "images",
+          "role-delegation",
+          "role-delegation-escalation",
+          "team-management",
+          "videos",
+          "web",
+          "workspace-fs-write"
+        ],
+        "outputMedium": "artifact"
+      }
+    },
+    {
+      "id": "done",
+      "name": "Deliver the verdict",
+      "description": "The report passed its gate. Stamp the verdict to task notes and point the user at the report.",
+      "prompt": "The report is written and passed its gate. Write one final task note with `write_task_note`: `Verdict: <approve|request-changes> — N findings (a critical, b major, c minor, d nit)` plus a one-paragraph summary. Tell the user the full report is in the project artifacts at `reviews/{{reviewId}}/report.md` (the Review panel renders it). Then call `advance_task_step` to complete the task.",
+      "suggestedRole": "reviewer",
+      "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.1",
+  "releasedAt": "2026-09-01T20:00:00Z"
+}