@bendyline/gilde 0.1.51 → 0.1.52

package/data/craftbook-templates/ru/runbook/versions/1.0.3/craftbook.json

@@ -0,0 +1,282 @@
+{
+  "id": "runbook",
+  "name": "Ops Runbook",
+  "description": "Write an operational runbook or playbook a tired on-call engineer can follow at 3am without thinking — covering when to use it, prerequisites, numbered step-by-step procedures, verification, rollback, and escalation. Scopes the exact scenarios and prerequisites FIRST, writes unambiguous copy-pasteable steps with expected output and verification at each stage, then has a reviewer pressure-test it for gaps and dangerous ambiguity. Use for incident response, deploy/rollback procedures, and recurring ops tasks.\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 runbook (planner) — trigger scenarios, prerequisites, success/rollback definition → gated on artifact `{{workPath}}/scope.md` (markdown-notes)\n2. Write the runbook (copywriter) — numbered, copy-pasteable steps with expected output + verification → gated on `runbook.md` (markdown-doc)\n3. Review for gaps (reviewer) — pressure-test the runbook for ambiguity and missing safety rails → gated on artifact `{{workPath}}/review.md` (markdown-notes)\n\nThe gates never advance with an unmet criterion, and loop back to the\nowning phase to fix named gaps.\n",
+  "entryStepId": "scope",
+  "triggers": [
+    "write a runbook",
+    "ops playbook",
+    "incident runbook",
+    "on call procedure",
+    "operational procedure doc",
+    "deploy runbook"
+  ],
+  "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 runbook",
+      "description": "trigger scenarios, prerequisites, success/rollback definition",
+      "prompt": "Define what the runbook covers before writing steps. Step 1: state the exact scenario(s) this runbook handles and, just as importantly, when NOT to use it. Step 2: list prerequisites — access/permissions, tools, environment, and any 'before you start' safety checks. Step 3: define what SUCCESS looks like (the verification signal that the procedure worked) and the conditions that should trigger a rollback or escalation. Step 4: outline the procedure as named stages in order (e.g. assess -> mitigate -> verify -> communicate), each to be expanded into numbered steps. Step 5: identify the destructive/irreversible steps that need an explicit warning. Step 6: write an acceptance-criteria checklist ('states when to use AND when not to', 'prerequisites + access listed', 'every stage has a verification step', 'a rollback procedure exists', 'escalation path with who/when', 'destructive steps carry a warning'). Write the scope + checklist via write_task_note AND to {{workPath}}/scope.md. No detailed steps 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": "write",
+      "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": "write",
+      "name": "Write the runbook",
+      "description": "numbered, copy-pasteable steps with expected output + verification",
+      "prompt": "Write the runbook as runbook.md so a stressed on-call engineer can follow it literally. Step 1: open with a header block — purpose, when to use / when not to use, severity, and an at-a-glance summary. Step 2: write the prerequisites and a pre-flight checklist. Step 3: write each stage as explicitly NUMBERED steps; commands go in fenced code blocks ready to copy-paste, with placeholders clearly marked (e.g. <SERVICE_NAME>), and EACH step states the expected output and how to verify it before moving on. Step 4: add bold warning callouts before any destructive/irreversible step. Step 5: write a dedicated Rollback section (numbered, also verified) and an Escalation section naming who to contact, when, and how. Step 6: end with a 'how to confirm fully resolved' checklist. Keep sentences short and imperative; no ambiguity about which step to run when. On a loop-back, fix ONLY the named gaps. Write the path + stage/step counts via write_task_note.",
+      "suggestedRole": "copywriter",
+      "advanceWhen": {
+        "file": "runbook.md",
+        "minBytes": 1,
+        "sniff": "nonempty"
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "runbook.md",
+            "bytes": 500
+          }
+        ],
+        "scripts": [
+          {
+            "name": "checkContains",
+            "scope": "standard",
+            "inputs": {
+              "file": "runbook.md",
+              "pattern": "(?:^|\\n)#{1,3}\\s+\\S",
+              "flags": "i"
+            }
+          }
+        ],
+        "onReject": "write",
+        "maxAttempts": 3
+      },
+      "next": "review",
+      "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"
+        ],
+        "outputMedium": "workspace",
+        "additionalOutputMedia": [
+          "task-note"
+        ]
+      }
+    },
+    {
+      "id": "review",
+      "name": "Review for gaps",
+      "description": "pressure-test the runbook for ambiguity and missing safety rails",
+      "prompt": "Pressure-test the runbook as if you must execute it half-asleep. Step 1: read every step and flag any that is ambiguous, assumes unstated context, or could be run out of order. Step 2: verify every destructive step has a warning and every stage has a verification signal. Step 3: confirm the rollback and escalation sections are actionable (real commands/contacts, not placeholders like 'contact the team'). Step 4: list concrete gaps with the exact step number and the fix needed. Step 5: write a review-findings note recording each gap as PASS/FAIL against the scope checklist. Write the findings via write_task_note AND to {{workPath}}/review.md. If gaps remain, they must be fixed in the write phase before this passes.\n\nThe deliverable `{{workPath}}/review.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": "reviewer",
+      "advanceWhen": {
+        "file": "{{workPath}}/review.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "runbook.md",
+            "bytes": 500
+          }
+        ],
+        "scripts": [
+          {
+            "name": "checkContains",
+            "scope": "standard",
+            "inputs": {
+              "file": "runbook.md",
+              "pattern": "(?:^|\\n)#{1,3}\\s+\\S",
+              "flags": "i"
+            }
+          }
+        ],
+        "onReject": "review",
+        "maxAttempts": 4
+      },
+      "next": "evaluate",
+      "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": "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 runbook against the locked criteria. Step 1: read runbook.md and simulate following it step by step for the primary scenario. Step 2: check EACH acceptance criterion: states when to use and when not to, prerequisites + access listed, every stage has numbered steps with expected output and a verification, destructive steps carry warnings, a working rollback section exists, and an escalation path names who/when/how. Step 3: confirm there are no ambiguous steps or unresolved placeholders in the rollback/escalation sections. Step 4: incorporate the review findings from {{workPath}}/review.md. Write PASS/FAIL per criterion with the offending step number on any FAIL.\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: \"write\" })` 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": "runbook.md"
+        }
+      ],
+      "next": "write",
+      "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.0.3",
+  "releasedAt": "2026-09-01T20:00:00Z",
+  "minGezelVersion": "1.26233"
+}

package/data/craftbook-templates/ru/runbook/versions/1.0.3/test.json

@@ -0,0 +1,118 @@
+{
+  "schemaVersion": 1,
+  "title": "On-call runbook for webhook backlog",
+  "objective": "Measure whether the runbook craftbook produces a literal, safe, verified operational procedure with rollback and escalation.",
+  "tags": [
+    "external"
+  ],
+  "prompt": "In the `Runbook Eval` project, read `source/incident-brief.md` and write `runbook.md`: an on-call procedure for clearing a webhook retry backlog. Include when to use and when not to use it, prerequisites, pre-flight checks, numbered mitigation steps with expected output and verification, rollback, escalation, warnings for risky actions, and a final resolved checklist.",
+  "setup": {
+    "projectName": "Runbook Eval",
+    "about": "Self-contained eval project for runbook. The operational scenario is seeded in workspace/source/incident-brief.md.",
+    "missionObjectives": "Write a copy-pasteable on-call runbook with safety rails, verification after each stage, rollback, escalation, and no unresolved placeholders.",
+    "files": [
+      {
+        "path": "source/incident-brief.md",
+        "content": "# Webhook retry backlog runbook brief\n\nScenario: use this when the `webhook_retry_backlog` queue exceeds 5,000 jobs for more than 10 minutes and customer invoice webhooks are delayed. Do not use it during an active database outage or while Stripe status is degraded.\nPrerequisites: production Kubernetes access, PagerDuty incident role, `kubectl` context `prod-us`, Datadog dashboard access, and permission to scale worker deployment `webhook-worker`.\nSafe commands: `kubectl -n payments get deploy webhook-worker`, `kubectl -n payments scale deploy webhook-worker --replicas=12`, `kubectl -n payments logs deploy/webhook-worker --tail=200`, `kubectl -n payments scale deploy webhook-worker --replicas=4`.\nSuccess: backlog below 500 jobs, p95 webhook delay below 2 minutes, error rate below 1% for 15 minutes.\nRollback: scale workers back to 4 replicas and pause retries if error rate rises above 3%.\nEscalation: page Payments Primary after 20 minutes without improvement; page Database On-call if DB CPU exceeds 85%.\nRisk: scaling workers too high can overload the database.\n"
+      }
+    ],
+    "worker": {
+      "name": "Sanne",
+      "role": "SRE Writer"
+    }
+  },
+  "mocks": [],
+  "success": {
+    "summary": "workspace/runbook.md has clear use/not-use criteria, prerequisites, numbered verified steps, warnings, rollback, escalation, commands, and no unresolved placeholders.",
+    "deliverables": [
+      {
+        "path": "runbook.md",
+        "kind": "markdown-doc",
+        "minBytes": 2400,
+        "checks": [
+          {
+            "kind": "contains",
+            "file": "runbook.md",
+            "pattern": "when to use|when not to use|prerequisites|pre-flight|rollback|escalation|resolved",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "runbook.md",
+            "pattern": "kubectl|webhook-worker|replicas=12|replicas=4|webhook_retry_backlog",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "runbook.md",
+            "pattern": "expected output|verify|verification|success signal",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "runbook.md",
+            "pattern": "warning|risk|database|overload",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "runbook.md",
+            "pattern": "Payments Primary|Database On-call|20 minutes|85%",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "runbook.md",
+            "pattern": "^\\s*1\\.",
+            "flags": "m"
+          },
+          {
+            "kind": "notContains",
+            "file": "runbook.md",
+            "pattern": "TBD|TODO|contact the team",
+            "flags": "i"
+          }
+        ]
+      }
+    ]
+  },
+  "rubric": {
+    "artifact": {
+      "path": "runbook.md",
+      "kind": "markdown"
+    },
+    "axes": [
+      {
+        "name": "safety",
+        "description": "Dry-run posture is explicit: no real credentials, clear stop-before-side-effect boundary."
+      },
+      {
+        "name": "mapping",
+        "description": "Fake endpoints/commands are mapped completely to the workflow steps."
+      },
+      {
+        "name": "signals",
+        "description": "Success, failure, retry, and abort conditions are all defined."
+      },
+      {
+        "name": "containment",
+        "description": "The plan cannot accidentally reach a real service from a mock context."
+      }
+    ]
+  },
+  "qualityFocus": [
+    "literal steps",
+    "verification after actions",
+    "rollback and escalation"
+  ],
+  "extensions": {
+    "legacySimulators": [
+      {
+        "id": "runbook-fake-service-fixture",
+        "kind": "data-source",
+        "status": "implemented",
+        "description": "Seeded local fake service contract replacing live CLIs, HTTP APIs, credentials, and side effects."
+      }
+    ]
+  }
+}