skilldrop-cli 0.16.9 → 0.16.11

package/README.md

@@ -55,14 +55,14 @@ In Claude Code you can use the plugin marketplace instead: run `/plugin marketpl
 ## How it works
 
 - **A skill produces one file you own.** Each ships a quality bar, named anti-patterns and acceptance evals, so the output is an artifact, not a conversation. See [every skill, by category](guides/reference/skill-catalogue.md).
-- **Loops order skills, and a gate decides when work moves on.** Five loops cover the lifecycle (`discover`, `design`, `build`, `release`, `operate`), plus the `ship-a-draft` wrapper for any document and `apply` for a job application. Each gate is a script, a review panel or a person, chosen by how expensive the mistake is to undo. See [the loops, stage by stage](guides/reference/loops.md) and [why loops](guides/explanation/loops.md).
+- **Loops order skills, and a gate decides when work moves on.** Five loops cover the lifecycle (`discover`, `design`, `build`, `release`, `operate`), plus the `ship-a-draft` wrapper for any document and `apply` for a job application. Each gate is a script, a review panel or a person, chosen by how expensive the mistake is to undo. See [the operating model](guides/explanation/operating-model.md) for every stage and gate on one page, [the loops, stage by stage](guides/reference/loops.md), and [why loops](guides/explanation/loops.md).
 - **Measured, not asserted.** `run_bench.py` runs each acceptance eval with the skill and without it, in a sandbox, and reports the lift, a blind preference from two judges, and the cost per run. The results are published whether or not they flatter the skills. See [how skills are checked](https://sananthanarayan.github.io/skilldrop/evals/) and [RFC-0040](docs/rfcs/0040-skill-benchmark.md).
 - **Copy, never transform.** A skill is a plain `SKILL.md` folder in the [Agent Skills](https://agentskills.io) format, at `packs/<pack>/skills/<name>/`. What runs in your agent is byte-identical to what is reviewed here. There is no runtime, and the tooling has zero dependencies.
 - **Updates keep your edits.** `npx skilldrop-cli update` replaces files you haven't touched. For any file you changed, it leaves the new version beside it as `<file>.upstream`. See [upgrade installed skills](guides/how-to/upgrade-skills.md).
 
 ## Go deeper
 
-- **Use it:** [docs portal](https://sananthanarayan.github.io/skilldrop/docs/) · [a guide for every pack](guides/README.md#per-pack) · [install in any IDE](guides/how-to/install-per-ide.md) · [try skills in a repo you don't own](guides/how-to/install-per-ide.md#trying-skills-in-a-repo-you-dont-own) · [profiles](guides/how-to/profiles.md) · [hooks](guides/how-to/wire-a-hook.md)
+- **Use it:** [the operating model](guides/explanation/operating-model.md) · [docs portal](https://sananthanarayan.github.io/skilldrop/docs/) · [a guide for every pack](guides/README.md#per-pack) · [install in any IDE](guides/how-to/install-per-ide.md) · [try skills in a repo you don't own](guides/how-to/install-per-ide.md#try-skills-in-a-repo-you-dont-own) · [profiles](guides/how-to/profiles.md) · [hooks](guides/how-to/wire-a-hook.md)
 - **Run it in CI:** [a skill on every pull request](guides/how-to/run-a-skill-in-ci.md) · [how skills are checked](https://sananthanarayan.github.io/skilldrop/evals/) · [benchmark skills yourself](guides/how-to/benchmark-skills.md) · [measure your loops](guides/how-to/measure-your-loops.md)
 - **Roll it out:** [across your org, including an internal mirror](guides/how-to/enterprise-distribution.md) · [publish your own catalogue](guides/how-to/publish-a-catalogue.md) · [security and the OWASP Top 10s](guides/reference/owasp-mapping.md)
 - **Reviewers:** three subagents that push back on generated work: `devils-advocate`, `security-reviewer` and `code-quality`. See [`agents/`](agents/README.md).

package/bin/skilldrop.js

@@ -51,13 +51,13 @@ Usage:
                                           (--no-skills for the loop alone) (RFC-0028)
   skilldrop install --panel review        install the review panel — the 3 reviewer subagents +
                                           the pre-merge-review orchestrator that fires them (RFC-0020)
-  skilldrop update [--force] [--changed]  re-copy installed skills whose version changed; files
+  skilldrop update [--force] [--changed]  re-copy installed skills and loops whose version changed; files
                                           you edited are kept and the new copy lands beside them
                                           as <file>.upstream (--force overwrites) (RFC-0032).
                                           Files changed upstream under the same version are named,
                                           not taken, unless you add --changed (RFC-0039)
   skilldrop outdated                      show installed vs current versions, change nothing
-  skilldrop diff <skill> [--stat]         what differs between your installed copy and the catalog's —
+  skilldrop diff <name> [--stat]          what differs between your installed skill or loop and the catalog's —
                                           your edits, upstream changes, or both
   skilldrop doctor                        check a target against its ledger: missing folders, leftover
                                           .upstream files, stale wiring and hooks. Changes nothing.
@@ -1015,16 +1015,50 @@ function fileHashes(dir) {
   return out;
 }
 
+/* A loop installs as <name>/SKILL.md (its LOOP.md) plus <name>/loop.json. update, outdated,
+   diff and doctor treat a ledger row marked `loop` like a skill through these helpers: which
+   files it installs and where the catalog keeps each one, its hashes, metadata and check. */
+function loopFiles(cat, n) {
+  const d = loopDir(cat, n);
+  return { "SKILL.md": path.join(d, "LOOP.md"), "loop.json": path.join(d, "loop.json") };
+}
+function unitHashes(cat, s, isLoop) {
+  if (!isLoop) return fileHashes(skillDir(cat, s));
+  const out = {};
+  for (const [rel, p] of Object.entries(loopFiles(cat, s))) out[rel] = sha256(fs.readFileSync(p));
+  return out;
+}
+function unitSource(cat, s, isLoop, rel) {
+  return isLoop ? loopFiles(cat, s)[rel] : path.join(skillDir(cat, s), ...rel.split("/"));
+}
+function unitExists(cat, s, isLoop) { return isLoop ? loopsIn(cat).includes(s) : skillExists(cat, s); }
+function unitMeta(cat, s, isLoop) { return isLoop ? loopSpec(cat, s) : manifestOf(cat, s); }
+function unitCheck(cat, s, isLoop) { return isLoop ? checkLoop(cat, s) : checkSkill(cat, s); }
+function isLoopEntry(entry) { return !!(entry && typeof entry === "object" && entry.loop); }
+function unitLabel(r) { return r.loop ? `loop ${r.s}` : r.s; }
+
+function copyLoop(cat, n, dest, ide, l, notes) {
+  const sp = loopSpec(cat, n);
+  const out = path.join(dest, n);
+  fs.mkdirSync(out, { recursive: true });
+  for (const [rel, p] of Object.entries(loopFiles(cat, n))) fs.copyFileSync(p, path.join(out, rel));
+  const note = writeWiring(ide, dest, n, sp.description);
+  if (note && notes) notes.push(note);
+  l.data[n] = { version: sp.version || null, source: cat.source, loop: true, files: unitHashes(cat, n, true) };
+  if (cat.commit) l.data[n].commit = cat.commit;
+  return sp;
+}
+
 /* Update one skill file by file against the ledger baseline (RFC-0032):
      upstream unchanged            -> leave the local file alone, edited or not
      local untouched, or new file  -> take the new version
      local edited, upstream moved  -> keep the local file, write the new one as <file>.upstream
    A file the catalog dropped is removed only if the user never touched it. The new baseline is
    what the catalog ships now, so a kept edit stays "edited" until the user merges it. */
-function mergeOne(cat, s, dest, ide, l, notes, dry = false) {
-  const m = manifestOf(cat, s);
-  const src = skillDir(cat, s), dst = path.join(dest, s);
-  const base = l.data[s].files, next = fileHashes(src);
+function mergeOne(cat, s, dest, ide, l, notes, dry = false, isLoop = false) {
+  const m = unitMeta(cat, s, isLoop);
+  const dst = path.join(dest, s);
+  const base = l.data[s].files, next = unitHashes(cat, s, isLoop);
   const kept = [], orphaned = [];
   const at = (root, rel) => path.join(root, ...rel.split("/"));
   const localHash = (rel) => { try { return sha256(fs.readFileSync(at(dst, rel))); } catch (e) { return null; } };
@@ -1035,13 +1069,13 @@ function mergeOne(cat, s, dest, ide, l, notes, dry = false) {
     if (mine === null ? !(rel in base) : mine === base[rel]) {
       if (dry) continue;
       fs.mkdirSync(path.dirname(to), { recursive: true });
-      fs.copyFileSync(at(src, rel), to);
+      fs.copyFileSync(unitSource(cat, s, isLoop, rel), to);
       fs.rmSync(to + ".upstream", { force: true });
     } else {
       kept.push(rel);
       if (dry) continue;
       fs.mkdirSync(path.dirname(to), { recursive: true });
-      fs.copyFileSync(at(src, rel), to + ".upstream");
+      fs.copyFileSync(unitSource(cat, s, isLoop, rel), to + ".upstream");
     }
   }
   for (const rel of Object.keys(base)) {
@@ -1053,7 +1087,8 @@ function mergeOne(cat, s, dest, ide, l, notes, dry = false) {
   if (dry) return { m, kept, orphaned };
   const note = writeWiring(ide, dest, s, m.description);
   if (note && notes) notes.push(note);
-  l.data[s] = { version: m.version, source: cat.source, files: next };
+  l.data[s] = { version: m.version || null, source: cat.source, files: next };
+  if (isLoop) l.data[s].loop = true;
   if (cat.commit) l.data[s].commit = cat.commit;
   return { m, kept, orphaned };
 }
@@ -1252,20 +1287,21 @@ function installedRows(flags) {
     const src = lsrc(l.data[s]);
     let current = null, cat = null, changed = [];
     const entry = l.data[s];
+    const loop = isLoopEntry(entry);
     try {
       cat = resolveCatalog(src === BUNDLED ? undefined : src);
-      if (skillExists(cat, s)) {
-        current = manifestOf(cat, s).version;
+      if (unitExists(cat, s, loop)) {
+        current = unitMeta(cat, s, loop).version || null;
         // Same version, different files: the catalog changed the skill without bumping it.
         // The version check alone would never see that (OWASP AST07, update drift).
         if (current === lver(entry) && typeof entry === "object" && entry.files) {
-          const now = fileHashes(skillDir(cat, s));
+          const now = unitHashes(cat, s, loop);
           changed = [...new Set([...Object.keys(now), ...Object.keys(entry.files)])]
             .filter((f) => now[f] !== entry.files[f]).sort();
         }
       }
     } catch (e) { /* unreachable source: current stays null */ }
-    return { s, src, cat, installed: lver(entry), current, changed, pinned: isPinned(src) };
+    return { s, src, cat, loop, installed: lver(entry), current, changed, pinned: isPinned(src) };
   });
   return { dest, ide, l, rows };
 }
@@ -1289,18 +1325,20 @@ function update(args) {
   let n = 0, conflicts = 0;
   const silent = rows.filter((r) => r.current === r.installed && r.changed.length && !args.flags.changed);
   for (const r of rows) {
-    if (!r.current) { console.log(`skip ${r.s}: source '${r.src}' unreachable or skill gone from it`); continue; }
+    if (!r.current) { console.log(`skip ${unitLabel(r)}: source '${r.src}' unreachable, ${r.loop ? "loop" : "skill"} gone from it, or no version to compare`); continue; }
     if (!isDue(r)) continue;
-    const problems = checkSkill(r.cat, r.s);
-    if (problems.length) { console.log(`skip ${r.s}: fails structural check in '${r.src}' (${problems[0]})`); continue; }
-    // No baseline (installed before RFC-0032) or --force: overwrite as before, and record one.
+    const problems = unitCheck(r.cat, r.s, r.loop);
+    if (problems.length) { console.log(`skip ${unitLabel(r)}: fails structural check in '${r.src}' (${problems[0]})`); continue; }
+    // No baseline (installed before RFC-0032, or a loop installed before 0.16.11) or --force:
+    // overwrite as before, and record one.
     const entry = l.data[r.s];
     if (args.flags.force || typeof entry !== "object" || !entry.files) {
-      copyOne(r.cat, r.s, dest, ide, l);
-      console.log(`updated ${r.s} ${r.installed === r.current ? `${r.current} (same version, changed upstream)` : `${r.installed} -> ${r.current}`} (${r.src})`);
+      if (r.loop) copyLoop(r.cat, r.s, dest, ide, l);
+      else copyOne(r.cat, r.s, dest, ide, l);
+      console.log(`updated ${unitLabel(r)} ${r.installed === r.current ? `${r.current} (same version, changed upstream)` : `${r.installed} -> ${r.current}`} (${r.src})`);
     } else {
-      const { kept, orphaned } = mergeOne(r.cat, r.s, dest, ide, l);
-      console.log(`updated ${r.s} ${r.installed === r.current ? `${r.current} (same version, changed upstream)` : `${r.installed} -> ${r.current}`} (${r.src})`);
+      const { kept, orphaned } = mergeOne(r.cat, r.s, dest, ide, l, null, false, r.loop);
+      console.log(`updated ${unitLabel(r)} ${r.installed === r.current ? `${r.current} (same version, changed upstream)` : `${r.installed} -> ${r.current}`} (${r.src})`);
       for (const f of kept) console.log(`  kept your edits in ${f} — new version at ${f}.upstream`);
       for (const f of orphaned) console.log(`  kept ${f} — dropped upstream, but you edited it`);
       conflicts += kept.length;
@@ -1308,7 +1346,7 @@ function update(args) {
     n++;
   }
   saveLedger(l);
-  console.log(n ? `\n${n} skill(s) updated.` : (silent.length ? "no version changes." : "everything up to date."));
+  console.log(n ? `\n${n} skill(s) or loop(s) updated.` : (silent.length ? "no version changes." : "everything up to date."));
   if (silent.length)
     console.log(`\nNot taken: ${silent.map((r) => r.s).join(", ")} changed upstream without a version bump.` +
                 `\n  Read the change (skilldrop diff <skill>), then take it with: skilldrop update --changed`);
@@ -1333,28 +1371,28 @@ function planUpdate(dest, ide, l, rows, flags) {
   console.log(`dry run — nothing will be written. Target: ${dest} (${ide})\n`);
   let n = 0;
   for (const r of rows) {
-    if (!r.current) { console.log(`would skip ${r.s}: source '${r.src}' unreachable or skill gone from it`); continue; }
+    if (!r.current) { console.log(`would skip ${unitLabel(r)}: source '${r.src}' unreachable, ${r.loop ? "loop" : "skill"} gone from it, or no version to compare`); continue; }
     if (r.current === r.installed && !r.changed.length) continue;
     if (r.current === r.installed && !flags.changed) {
-      console.log(`would not take ${r.s}: ${r.changed.length} file(s) changed upstream without a version bump (add --changed to take them)`);
+      console.log(`would not take ${unitLabel(r)}: ${r.changed.length} file(s) changed upstream without a version bump (add --changed to take them)`);
       continue;
     }
-    const problems = checkSkill(r.cat, r.s);
-    if (problems.length) { console.log(`would skip ${r.s}: fails structural check (${problems[0]})`); continue; }
+    const problems = unitCheck(r.cat, r.s, r.loop);
+    if (problems.length) { console.log(`would skip ${unitLabel(r)}: fails structural check (${problems[0]})`); continue; }
     n++;
     const entry = l.data[r.s];
-    console.log(`would update ${r.s} ${r.installed} -> ${r.current} (${r.src})`);
+    console.log(`would update ${unitLabel(r)} ${r.installed} -> ${r.current} (${r.src})`);
     if (flags.force || typeof entry !== "object" || !entry.files) {
       const lost = editedFiles(dest, r.s, entry);
       if (lost.length) console.log(`  --force overwrites your edits in: ${lost.join(", ")}`);
       continue;
     }
-    const { kept, orphaned } = mergeOne(r.cat, r.s, dest, ide, l, null, true);
+    const { kept, orphaned } = mergeOne(r.cat, r.s, dest, ide, l, null, true, r.loop);
     for (const f of kept) console.log(`  would keep your edits in ${f} and write the new version to ${f}.upstream`);
     for (const f of orphaned) console.log(`  would keep ${f} — dropped upstream, but you edited it`);
   }
   const held = rows.filter((r) => r.current && r.current === r.installed && r.changed.length && !flags.changed).length;
-  console.log(n ? `\n${n} skill(s) would update. Rerun without --dry-run to apply.` : (held ? "no version changes." : "everything up to date."));
+  console.log(n ? `\n${n} skill(s) or loop(s) would update. Rerun without --dry-run to apply.` : (held ? "no version changes." : "everything up to date."));
 }
 
 function outdated(args) {
@@ -1368,15 +1406,15 @@ function outdated(args) {
       outdatedCount: stale.length,
       changedWithoutVersionCount: drift.length,
       skills: rows.map((r) => ({
-        name: r.s, installed: r.installed, current: r.current,
+        name: r.s, loop: r.loop, installed: r.installed, current: r.current,
         source: r.src, outdated: !!(r.current && r.current !== r.installed),
         changedWithoutVersion: r.changed || [], pinned: r.pinned,
       })),
     });
   if (!rows.length) return console.log(`nothing installed at ${dest}`);
-  for (const r of stale) console.log(`${r.s}: installed ${r.installed}, current ${r.current} (${r.src})`);
+  for (const r of stale) console.log(`${unitLabel(r)}: installed ${r.installed}, current ${r.current} (${r.src})`);
   for (const r of drift)
-    console.log(`${r.s}: ${r.changed.length} file(s) changed in '${r.src}' without a version bump (${r.changed.slice(0, 3).join(", ")}${r.changed.length > 3 ? ", …" : ""})`);
+    console.log(`${unitLabel(r)}: ${r.changed.length} file(s) changed in '${r.src}' without a version bump (${r.changed.slice(0, 3).join(", ")}${r.changed.length > 3 ? ", …" : ""})`);
   if (drift.length)
     console.log(`\n${drift.length} skill(s) changed upstream with the same version. Read the change first (skilldrop diff <skill>),` +
                 `\nthen take it with: skilldrop update --changed`);
@@ -1424,23 +1462,23 @@ function uninstall(args) {
    edits, an upstream change, or both. File-level always; line-level through git when it is on
    the PATH (git diff --no-index works outside any repo). */
 function diff(args) {
-  const s = args._[0] || die("pass an installed skill name: skilldrop diff <skill>");
+  const s = args._[0] || die("pass an installed skill or loop name: skilldrop diff <name>");
   const { dest } = target(args.flags);
   const l = ledger(dest);
   const entry = l.data[s];
   if (!entry && !fs.existsSync(path.join(dest, s))) die(`'${s}' is not installed at ${dest}`);
-  if (entry && entry.loop) die(`'${s}' is a loop — diff compares skills`);
+  const loop = isLoopEntry(entry);
   const src = args.flags.from || (entry ? lsrc(entry) : BUNDLED);
   const cat = resolveCatalog(src === BUNDLED ? undefined : src);
-  if (!skillExists(cat, s)) die(`'${s}' is no longer in catalog '${cat.source}'`);
-  const theirs = fileHashes(skillDir(cat, s)), mine = fileHashes(path.join(dest, s));
+  if (!unitExists(cat, s, loop)) die(`'${s}' is no longer in catalog '${cat.source}'`);
+  const theirs = unitHashes(cat, s, loop), mine = fileHashes(path.join(dest, s));
   const base = (entry && entry.files) || {};
   const changed = Object.keys(theirs).filter((f) => f in mine && mine[f] !== theirs[f]).sort();
   const onlyUp = Object.keys(theirs).filter((f) => !(f in mine)).sort();
   const onlyMine = Object.keys(mine).filter((f) => !(f in theirs)).sort();
   const why = (f) => !base[f] ? "" : mine[f] !== base[f] && theirs[f] !== base[f] ? "  (you edited it, and so did the catalog)"
     : mine[f] !== base[f] ? "  (your edit)" : "  (catalog changed it)";
-  const iv = entry ? lver(entry) : "?", cv = manifestOf(cat, s).version;
+  const iv = entry ? lver(entry) : "?", cv = unitMeta(cat, s, loop).version;
   console.log(`${s}: installed ${iv} at ${path.join(dest, s)}  vs  catalog '${cat.source}' ${cv}`);
   if (!changed.length && !onlyUp.length && !onlyMine.length) return console.log("identical.");
   for (const f of changed) console.log(`  M ${f}${why(f)}`);
@@ -1449,7 +1487,7 @@ function diff(args) {
   if (args.flags.stat) return;
   let git = true;
   for (const f of changed) {
-    const a = path.join(skillDir(cat, s), ...f.split("/")), b = path.join(dest, s, ...f.split("/"));
+    const a = unitSource(cat, s, loop, f), b = path.join(dest, s, ...f.split("/"));
     try {
       execFileSync("git", ["--no-pager", "diff", "--no-index", "--color=auto", "--src-prefix=catalog/", "--dst-prefix=installed/", a, b],
         { stdio: ["ignore", "inherit", "inherit"] });
@@ -1459,7 +1497,7 @@ function diff(args) {
     }
   }
   if (!git) console.log("\n(git not found — line-level diff needs git on the PATH; file list above)");
-  if (changed.length) console.log(`\nTake the catalog's version: skilldrop update --force, or install ${s} again.`);
+  if (changed.length) console.log(`\nTake the catalog's version: skilldrop update --force, or install ${loop ? "--loop " : ""}${s} again.`);
 }
 
 /* doctor: check an install target against its ledger and report what's out of step — skills
@@ -1477,10 +1515,13 @@ function doctor(args) {
   const names = Object.keys(data);
   for (const n of names) {
     if (!fs.existsSync(path.join(dest, n))) add("error", `${n} is in the ledger but its folder is gone`, `skilldrop install ${n} (or uninstall ${n} to drop the record)`);
-    else if (!data[n].loop && !data[n].file) {
+    else if (!data[n].file) {
+      const loop = isLoopEntry(data[n]);
       const e = editedFiles(dest, n, data[n]);
       if (e.length) add("info", `${n}: you edited ${e.join(", ")}`, `skilldrop diff ${n}`);
-      if (typeof data[n] === "string" || !data[n].files) add("warn", `${n} has no file baseline (installed before 0.13)`, `skilldrop install ${n} once; update will keep your edits after that`);
+      if (typeof data[n] === "string" || !data[n].files)
+        add("warn", `${loop ? "loop " : ""}${n} has no file baseline (installed before ${loop ? "0.16.11" : "0.13"})`,
+            `skilldrop install ${loop ? "--loop " : ""}${n} once; update will keep your edits after that`);
     }
   }
   if (fs.existsSync(dest)) {
@@ -1843,15 +1884,8 @@ function installLoops(args) {
   const l = ledger(dest);
   const notes = [];
   for (const n of names) {
-    const sp = loopSpec(cat, n);
-    const out = path.join(dest, n);
-    fs.mkdirSync(out, { recursive: true });
-    fs.copyFileSync(path.join(loopDir(cat, n), "LOOP.md"), path.join(out, "SKILL.md"));
-    fs.copyFileSync(path.join(loopDir(cat, n), "loop.json"), path.join(out, "loop.json"));
-    const note = writeWiring(ide, dest, n, sp.description);
-    if (note) notes.push(note);
-    l.data[n] = { version: sp.version || null, source: cat.source, loop: true };
-    console.log(`installed loop ${n} -> ${out}`);
+    copyLoop(cat, n, dest, ide, l, notes);
+    console.log(`installed loop ${n} -> ${path.join(dest, n)}`);
   }
   saveLedger(l);
   if (args.flags.local) addLocal(dest, ide, names);

package/contracts/guide.schema.json

@@ -13,6 +13,10 @@
       "enum": ["tutorial", "how-to", "reference", "explanation"],
       "description": "tutorial = learning by doing. how-to = a task with a goal. reference = look it up. explanation = why it is this way. A page that cannot pick one is doing two jobs and should be split."
     },
-    "status": { "enum": ["draft", "review", "stable", "deprecated"], "default": "stable" }
+    "status": { "enum": ["draft", "review", "stable", "deprecated"], "default": "stable" },
+    "stage": {
+      "enum": ["discover", "design", "build", "release", "operate"],
+      "description": "RFC-0044. The lifecycle stage a page belongs to, when it belongs to one. The docs sidebar groups staged pages under that stage, beside the stage's loop; a page that spans every stage, or none, leaves it out."
+    }
   }
 }

package/contracts/loop.schema.json

@@ -5,7 +5,7 @@
   "$comment": "RFC-0028. A loop sequences existing skills; it never contains one. Skills stay in their own packs/<pack>/skills/<name> folders and stay independently installable — a loop is a named order plus the gates between stages. Enforced by validate.py with hand-rolled stdlib checks: skilldrop ships zero runtime dependencies and this file must not become a reason to add `jsonschema`.",
   "type": "object",
   "additionalProperties": false,
-  "required": ["name", "description", "entrypoint", "kind", "stages"],
+  "required": ["name", "version", "description", "entrypoint", "kind", "stages"],
   "properties": {
     "$comment": { "type": "string" },
     "name": {
@@ -13,7 +13,7 @@
       "pattern": "^[a-z0-9][a-z0-9-]*$",
       "description": "Kebab-case. Must equal the folder name and the LOOP.md frontmatter name — the same triple-match skills are held to."
     },
-    "version": { "type": "string" },
+    "version": { "type": "string", "pattern": "^[0-9]+\\.[0-9]+\\.[0-9]+$", "description": "Bump it whenever LOOP.md or loop.json changes: `skilldrop update` compares it with the version a user installed." },
     "description": {
       "type": "string",
       "description": "Use-case-first. First half says what the loop delivers; second half states the trigger phrases an agent matches on."

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skilldrop-cli",
-  "version": "0.16.9",
+  "version": "0.16.11",
   "description": "Portable AI-agent skills, measured against the agent without them. ADRs, PRDs, runbooks, decks and reviews, installable into Claude Code, Cursor, Kiro, and any IDE that takes custom instructions. One command per skill or per role-based pack.",
   "author": {
     "name": "Sanjay Ananthanarayan",

package/packs/career/loops/apply/LOOP.md

@@ -14,18 +14,18 @@ can say what the resume shows, but only the candidate knows what is true and wha
 
 | # | Stage | Type | Skills | Gate |
 |---|---|---|---|---|
-| 1 | `fit` | gate | [`job-fit-analysis`](../../skills/job-fit-analysis/SKILL.md) | **G5** human |
+| 1 | `fit` | gate | [`job-fit-analysis`](../../skills/job-fit-analysis/SKILL.md) | **G6** human |
 | 2 | `tailor` | generate | [`resume-tailor`](../../skills/resume-tailor/SKILL.md) | — |
 | 3 | `letter` | generate | [`cover-letter`](../../skills/cover-letter/SKILL.md) | — |
 | 4 | `form` | generate | [`application-form-answers`](../../skills/application-form-answers/SKILL.md) | — |
-| 5 | `confirm` | verify | [`output-hygiene`](../../../core/skills/output-hygiene/SKILL.md) | **G6** human |
+| 5 | `confirm` | verify | [`output-hygiene`](../../../core/skills/output-hygiene/SKILL.md) | **G6.1** human |
 
 ## How to run this loop
 
 1. **Check the fit and stop.** Run `job-fit-analysis` on the posting, the resume and any
    other material of the candidate's: a LinkedIn summary, a portfolio, a project. Put its
    verdict, what could get the application rejected and its questions to the candidate,
-   including whether anything outside the resume covers a gap, then wait at G5.
+   including whether anything outside the resume covers a gap, then wait at G6.
    - `PROCEED`: they are applying. Go on.
    - `PROCEED WITH CONDITIONS`: they are applying and have answered the questions. Save
      their answers to `notes.md`; from here on those answers are source material alongside
@@ -41,7 +41,7 @@ can say what the resume shows, but only the candidate knows what is true and wha
    the documents, run `application-form-answers` with those questions and the tailored
    resume. Skip this stage when there is no form.
 5. **Clean the documents.** Run `output-hygiene` on the resume and the letter.
-6. **Confirm at G6.** Show the candidate the documents with four short lists: what the
+6. **Confirm at G6.1.** Show the candidate the documents with four short lists: what the
    posting asks for that the documents do not claim; every fact added from outside the
    resume and where it came from; every line cut from the resume; and the form questions
    that are theirs alone to answer. Ask them to confirm every line is true. `NOT READY` returns to `tailor` with their
@@ -49,8 +49,8 @@ can say what the resume shows, but only the candidate knows what is true and wha
 
 ## Verdicts
 
-Defined in [`contracts/terminals.json`](../../../../contracts/terminals.json). G5 emits
-`PROCEED`, `PROCEED WITH CONDITIONS`, `RECONSIDER` or `BLOCKED`. G6 emits `READY`,
+Defined in [`contracts/terminals.json`](../../../../contracts/terminals.json). G6 emits
+`PROCEED`, `PROCEED WITH CONDITIONS`, `RECONSIDER` or `BLOCKED`. G6.1 emits `READY`,
 `NOT READY` or `BLOCKED`. `RECONSIDER` leaves the loop: the candidate's time goes to a
 better posting.
 
@@ -64,7 +64,7 @@ produce documents carrying their name that they have not confirmed.
 
 Name the missing skill and skilldrop as its source, do the minimal inline version of that
 stage under the same rule (nothing the candidate didn't supply), and record that it ran
-degraded. Never skip G6.
+degraded. Never skip G6.1.
 
 ## Run log (opt-in)
 
@@ -73,7 +73,7 @@ gate's verdict, append one JSON line to that file. Nothing else is recorded, and
 sent anywhere. When the variable isn't set, or you can't read it, skip this section.
 
 ```bash
-printf '%s\n' '{"ts":"2026-10-05T14:03:00Z","loop":"apply","stage":"fit","gate":"G5","verdict":"PROCEED","round":1}' >> "$SKILLDROP_LOOP_LOG"
+printf '%s\n' '{"ts":"2026-10-05T14:03:00Z","loop":"apply","stage":"fit","gate":"G6","verdict":"PROCEED","round":1}' >> "$SKILLDROP_LOOP_LOG"
 ```
 
 Fields: `ts` (UTC), `loop`, `stage`, `gate` (`null` for a stage without one), `verdict` (the
@@ -83,9 +83,9 @@ The log holds verdicts only: never the posting, the resume or the candidate's na
 ## Quality bar
 
 - **The candidate decides to apply before anything is written.** A tailored resume for a job they would have skipped is wasted work.
-- **Every claim in both documents traces to the resume or to something the candidate said.** Answers given at G5 are written to `notes.md`, so the trace exists.
+- **Every claim in both documents traces to the resume or to something the candidate said.** Answers given at G6 are written to `notes.md`, so the trace exists.
 - **The resume, the letter and the form agree.** Same titles, dates and numbers in all three.
-- **The candidate confirms and sends.** G6 is their signature; the loop never submits an application.
+- **The candidate confirms and sends.** G6.1 is their signature; the loop never submits an application.
 
 ## Anti-patterns to avoid
 
@@ -93,5 +93,5 @@ The log holds verdicts only: never the posting, the resume or the candidate's na
 - ❌ **Treating a `Not shown` item as true** because the candidate proceeded. Only what they answered goes in.
 - ❌ **Writing the letter from the original resume.** The letter follows the tailored one, or the two will disagree.
 - ❌ **Answering a declaration on the form** for the candidate, or leaving out the list of what was added and cut.
-- ❌ **Self-confirming at G6.** A clean claim check says the words are in the source; it cannot say they are true.
+- ❌ **Self-confirming at G6.1.** A clean claim check says the words are in the source; it cannot say they are true.
 - ❌ **Submitting the application.** Sending is the candidate's act.

package/packs/career/loops/apply/evals/evals.json

@@ -7,7 +7,7 @@
       "assertions": [
         "Starts with job-fit-analysis and delivers its verdict before any resume or letter is written",
         "Names the unmet bachelor's degree as a screening requirement",
-        "Stops at G5 and asks the candidate whether to apply; does not tailor the resume in the same turn",
+        "Stops at G6 and asks the candidate whether to apply; does not tailor the resume in the same turn",
         "Does not advise claiming the degree or adding any keyword the resume does not support"
       ]
     },
@@ -19,7 +19,7 @@
         "The tailored resume includes Spanish and does not claim SAP",
         "The cover letter is written after the tailored resume and uses the same titles, dates and numbers",
         "Runs output-hygiene on both documents before the final gate",
-        "Stops at G6 and asks the candidate to confirm every line is true; does not submit or send anything",
+        "Stops at G6.1 and asks the candidate to confirm every line is true; does not submit or send anything",
         "Lists what the posting asks for that neither document claims"
       ]
     }

package/packs/career/loops/apply/loop.json

@@ -1,7 +1,7 @@
 {
   "$comment": "RFC-0042. One job application, start to send. The first gate exists because the cheapest application is the one not written; the last because the candidate, not the agent, signs what is sent.",
   "name": "apply",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Take one job posting and one resume to an application ready to send — an honest fit check, a tailored resume, a cover letter and the answers to the application form — with the candidate deciding whether to apply before any writing, and confirming every claim is true before anything is sent. Use when the user wants to apply for a job, says \"help me apply for this\", or wants a resume and cover letter prepared for one posting.",
   "entrypoint": "LOOP.md",
   "kind": "loop",
@@ -13,7 +13,7 @@
       "intent": "Say honestly where the candidate stands against the posting, then let them decide whether this application is worth writing.",
       "skills": ["job-fit-analysis"],
       "gate": {
-        "id": "G5",
+        "id": "G6",
         "kind": "human",
         "verdicts": ["PROCEED", "PROCEED WITH CONDITIONS", "RECONSIDER", "BLOCKED"]
       }
@@ -42,7 +42,7 @@
       "intent": "Strip what the machine left behind, then have the candidate confirm that every line in the documents is true and theirs, and that anything added from outside the resume is right.",
       "skills": ["output-hygiene"],
       "gate": {
-        "id": "G6",
+        "id": "G6.1",
         "kind": "human",
         "verdicts": ["READY", "NOT READY", "BLOCKED"],
         "revise_to": "tailor"

package/packs/core/loops/ship-a-draft/LOOP.md

@@ -16,7 +16,7 @@ check the argument and the surface after.
 |---|---|---|---|---|
 | 1 | `intake` | generate | [`brief-intake`](../../skills/brief-intake/SKILL.md) | — |
 | 2 | `draft` | generate | any generator (`*`) | — |
-| 3 | `critique` | verify | [`doc-critique`](../../skills/doc-critique/SKILL.md) | **G4** review |
+| 3 | `critique` | verify | [`doc-critique`](../../skills/doc-critique/SKILL.md) | **G5** review |
 | 4 | `polish` | verify | [`output-hygiene`](../../skills/output-hygiene/SKILL.md) | — |
 
 ## How to run this wrapper
@@ -29,7 +29,7 @@ check the argument and the surface after.
    chosen generator will refuse to start without. Resolve those before drafting.
 3. **Draft.** Run the chosen generator on the brief. It is a normal skilldrop skill with its
    own quality bar — this wrapper does not override it.
-4. **Critique at G4.** Run `doc-critique`, which dispatches to the same rubric the generator
+4. **Critique at G5.** Run `doc-critique`, which dispatches to the same rubric the generator
    was held to. `MAJOR REWRITE` returns to `intake` (not to `draft` — a rewrite usually means
    the input was wrong, not the prose). `WRONG ARTIFACT` leaves the wrapper entirely.
 5. **Polish last.** Run `output-hygiene` only once the argument is settled. It is a surface
@@ -37,14 +37,14 @@ check the argument and the surface after.
 
 ## Verdicts
 
-Defined in [`contracts/terminals.json`](../../../../contracts/terminals.json). G4 emits the critique
+Defined in [`contracts/terminals.json`](../../../../contracts/terminals.json). G5 emits the critique
 vocabulary. `SHIP WITH CHANGES` carries its changes forward to `polish`; it does not mean the
 changes are optional.
 
 ## When a stage's skill is not installed
 
 Name the missing skill and skilldrop as its source, do the minimal inline version of that
-stage, and say the stage ran degraded. Do not skip G4 — an unreviewed artifact is the failure
+stage, and say the stage ran degraded. Do not skip G5 — an unreviewed artifact is the failure
 mode this wrapper exists to prevent.
 
 ## Run log (opt-in)
@@ -54,7 +54,7 @@ gate's verdict, append one JSON line to that file. Nothing else is recorded, and
 sent anywhere. When the variable isn't set, or you can't read it, skip this section.
 
 ```bash
-printf '%s\n' '{"ts":"2026-10-01T14:03:00Z","loop":"ship-a-draft","stage":"critique","gate":"G4","verdict":"SHIP IT","round":1}' >> "$SKILLDROP_LOOP_LOG"
+printf '%s\n' '{"ts":"2026-10-01T14:03:00Z","loop":"ship-a-draft","stage":"critique","gate":"G5","verdict":"SHIP IT","round":1}' >> "$SKILLDROP_LOOP_LOG"
 ```
 
 Fields: `ts` (UTC), `loop`, `stage`, `gate` (`null` for a stage without one), `verdict` (the
@@ -71,7 +71,7 @@ which end in `BLOCKED`.
 
 ## Anti-patterns to avoid
 
-- ❌ **Running `polish` as the whole review.** Clean prose with a broken argument still fails; that is what G4 is for.
+- ❌ **Running `polish` as the whole review.** Clean prose with a broken argument still fails; that is what G5 is for.
 - ❌ **Skipping `intake` because the input "is already structured."** A Slack thread that looks organized is still untagged — nobody downstream can tell what was inferred.
 - ❌ **Looping `critique` → `draft` instead of `critique` → `intake`.** Re-drafting from the same incomplete brief reproduces the same gaps with new words.
 - ❌ **Treating `WRONG ARTIFACT` as a severe `MAJOR REWRITE`.** It is a redirect: the user wanted a different document, and revising this one cannot get there.

package/packs/core/loops/ship-a-draft/evals/evals.json

@@ -7,7 +7,7 @@
       "assertions": [
         "Chooses the target generator (exec-summary) BEFORE running intake, because the brief is shaped for a target",
         "Runs brief-intake and tags every field explicit / implied / inferred / missing",
-        "Runs doc-critique at G4 against the same rubric the generator was held to",
+        "Runs doc-critique at G5 against the same rubric the generator was held to",
         "Runs output-hygiene last, only once the argument is settled",
         "Reports what output-hygiene did not touch"
       ]
@@ -16,7 +16,7 @@
       "id": "major-rewrite-returns-to-intake",
       "prompt": "The critique on my draft came back MAJOR REWRITE. Continue the ship-a-draft wrapper.",
       "assertions": [
-        "Routes back to `intake`, not to `draft`, because G4's revise_to names intake",
+        "Routes back to `intake`, not to `draft`, because G5's revise_to names intake",
         "Explains that re-drafting from the same incomplete brief reproduces the same gaps",
         "Does not run output-hygiene on a draft that is about to be rewritten"
       ]

package/packs/core/loops/ship-a-draft/loop.json

@@ -1,7 +1,7 @@
 {
   "$comment": "RFC-0028. This wrapper is docs/knowledge-work-pipeline.mmd promoted from a hand-maintained diagram into the machine-readable source that diagram is now generated from. It is a wrapper, not a loop: the generator at its centre is chosen at run time from whichever artifact the user actually wants.",
   "name": "ship-a-draft",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Take raw mess to a stakeholder-ready artifact by wrapping any skilldrop generator in the two passes either side of it — structured intake before, critique and machine-residue scrub after. Use when the user has notes, a transcript, or a ticket and wants a finished document rather than a first draft.",
   "entrypoint": "LOOP.md",
   "kind": "wrapper",
@@ -25,7 +25,7 @@
       "intent": "Review the draft against the same rubric the generator was held to.",
       "skills": ["doc-critique"],
       "gate": {
-        "id": "G4",
+        "id": "G5",
         "kind": "review",
         "verdicts": ["SHIP IT", "SHIP WITH CHANGES", "MAJOR REWRITE", "WRONG ARTIFACT", "BLOCKED"],
         "revise_to": "intake"

package/packs/core/pack.json

@@ -37,7 +37,7 @@
         "skill": "doc-critique",
         "you_do": "Hand over the draft you wrote from the brief, by hand or with any generator skill.",
         "you_get": "A critique that opens with a verdict and lists findings as blocker, major, minor or nit, each pointing to the section and suggesting a fix.",
-        "decide": "Gate G4: SHIP IT or SHIP WITH CHANGES moves on; MAJOR REWRITE sends you back to the brief; WRONG ARTIFACT means you need a different kind of document."
+        "decide": "Gate G5: SHIP IT or SHIP WITH CHANGES moves on; MAJOR REWRITE sends you back to the brief; WRONG ARTIFACT means you need a different kind of document."
       },
       {
         "skill": "output-hygiene",

package/packs/dev-team/loops/release/LOOP.md

@@ -15,9 +15,9 @@ being folded into either neighbour.
 | # | Stage | Type | Skills | Gate |
 |---|---|---|---|---|
 | 1 | `plan` | generate | [`migration-plan`](../../skills/migration-plan/SKILL.md) | — |
-| 2 | `ready` | verify | [`launch-readiness`](../../skills/launch-readiness/SKILL.md) | **G2.5** review |
+| 2 | `ready` | verify | [`launch-readiness`](../../skills/launch-readiness/SKILL.md) | **G3** review |
 | 3 | `announce` | generate | [`release-notes`](../../skills/release-notes/SKILL.md) | — |
-| 4 | `go` | gate | [`council-review`](../../../core/skills/council-review/SKILL.md) | **G2.6** human |
+| 4 | `go` | gate | [`council-review`](../../../core/skills/council-review/SKILL.md) | **G3.1** human |
 
 ## How to run this loop
 
@@ -25,34 +25,34 @@ being folded into either neighbour.
    rollback for each one, and at most one named point of no return. For a code-only change
    behind a flag, the plan can be short: the flag, the stages and how to turn it off. It still
    has to exist.
-2. **Judge readiness at G2.5.** `launch-readiness` lists the change's own failure modes, then
+2. **Judge readiness at G3.** `launch-readiness` lists the change's own failure modes, then
    checks rollback, detection, response, measured targets, data and privacy, comms and
    exposure, each with evidence. `REVISE` returns to `plan`, and the report names which gap to
    close and which skill closes it. A missing rollback is `BLOCKED` on its own.
 3. **Announce only once it is ready.** `release-notes` drafts the customer-facing and
-   internal notes from the git range. Writing them before G2.5 risks announcing a launch that
+   internal notes from the git range. Writing them before G3 risks announcing a launch that
    then does not happen.
-4. **A human decides at G2.6.** The release owner decides whether to ship *now*, given
+4. **A human decides at G3.1.** The release owner decides whether to ship *now*, given
    timing, freeze windows and on-call coverage. When that decision is contested, use
    `council-review`. `RECONSIDER` means it is ready but this is the wrong time, and the work
    waits instead of going back to `plan`.
 
-After `PROCEED`, the change is live and the work moves to `operate`. Gaps that G2.5 sent to
+After `PROCEED`, the change is live and the work moves to `operate`. Gaps that G3 sent to
 `observability-plan` or `runbook-generator` are the first things `operate` picks up.
 
 ## Verdicts
 
-Defined in [`contracts/terminals.json`](../../../../contracts/terminals.json). G2.5 emits `PROCEED`,
-`PROCEED WITH CONDITIONS`, `REVISE` or `BLOCKED`. G2.6 adds `RECONSIDER`. `PROCEED WITH
-CONDITIONS` at G2.5 is allowed only when the open rows are comms or exposure. A detection or
+Defined in [`contracts/terminals.json`](../../../../contracts/terminals.json). G3 emits `PROCEED`,
+`PROCEED WITH CONDITIONS`, `REVISE` or `BLOCKED`. G3.1 adds `RECONSIDER`. `PROCEED WITH
+CONDITIONS` at G3 is allowed only when the open rows are comms or exposure. A detection or
 response gap is always `REVISE`.
 
 ## Non-interactive runs
 
 Never invent evidence such as rehearsal logs, load-test numbers, dashboards or sign-offs.
 When the change being released cannot be identified, emit `BLOCKED: need <the PR, tag, or
-feature name>`. G2.6 is a human gate. A headless run stops after `announce` and reports the
-G2.5 verdict for a person to act on.
+feature name>`. G3.1 is a human gate. A headless run stops after `announce` and reports the
+G3 verdict for a person to act on.
 
 ## When a stage's skill is not installed
 
@@ -68,7 +68,7 @@ gate's verdict, append one JSON line to that file. Nothing else is recorded, and
 sent anywhere. When the variable isn't set, or you can't read it, skip this section.
 
 ```bash
-printf '%s\n' '{"ts":"2026-10-01T14:03:00Z","loop":"release","stage":"ready","gate":"G2.5","verdict":"PROCEED","round":1}' >> "$SKILLDROP_LOOP_LOG"
+printf '%s\n' '{"ts":"2026-10-01T14:03:00Z","loop":"release","stage":"ready","gate":"G3","verdict":"PROCEED","round":1}' >> "$SKILLDROP_LOOP_LOG"
 ```
 
 Fields: `ts` (UTC), `loop`, `stage`, `gate` (`null` for a stage without one), `verdict` (the
@@ -80,12 +80,12 @@ which end in `BLOCKED`.
 
 - **Rollback exists before readiness is judged.** A plan with no way back is the one thing that cannot be fixed after launch.
 - **Readiness rests on evidence.** Every check links to something; "we're good" is `not met`.
-- **Can and should are separate gates.** G2.5 says whether it can ship; G2.6 says whether it should ship now.
+- **Can and should are separate gates.** G3 says whether it can ship; G3.1 says whether it should ship now.
 - **Detection gaps leave this loop as hand-offs.** `operate` picks them up first, rather than discovering them during the first incident.
 
 ## Anti-patterns to avoid
 
 - ❌ **Jumping from merge to "instrument a running service".** That skips this loop entirely, which is the gap it exists to close.
-- ❌ **Announcing before G2.5.** Customers hear about a launch that is then pulled.
+- ❌ **Announcing before G3.** Customers hear about a launch that is then pulled.
 - ❌ **Treating flag-off as a rollback without a data story.** If dual-write or a backfill has run, turning the flag off does not undo the data.
-- ❌ **Letting G2.6 overrule a G2.5 `BLOCKED`.** A human can delay a ready launch; they cannot make an unready one ready by deciding to go.
+- ❌ **Letting G3.1 overrule a G3 `BLOCKED`.** A human can delay a ready launch; they cannot make an unready one ready by deciding to go.

package/packs/dev-team/loops/release/loop.json

@@ -1,7 +1,7 @@
 {
-  "$comment": "RFC-0031. Covers the step between build (ends at merge, G2.1) and operate (starts at instrument). The gate ids sit between G2 and G3 to match where the loop sits in the lifecycle.",
+  "$comment": "RFC-0031. Covers the step between build (ends at merge, G2.1) and operate (starts at instrument). Its gates are G3 and G3.1: the whole number places the loop in the lifecycle (discover G0 through operate G4), and a decimal is a second gate inside the same loop (RFC-0044).",
   "name": "release",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Take merged code to live users through a planned, reversible rollout — plan the phases and the rollback, judge readiness on evidence, draft the release notes, then a human makes the go/no-go call. Use when the user has merged a change and asks how to roll it out, whether they are ready to launch, or for a go/no-go decision.",
   "entrypoint": "LOOP.md",
   "kind": "loop",
@@ -19,7 +19,7 @@
       "intent": "Judge on evidence whether the change can go live: rollback, detection, response, measured targets, data, comms, exposure.",
       "skills": ["launch-readiness"],
       "gate": {
-        "id": "G2.5",
+        "id": "G3",
         "kind": "review",
         "verdicts": ["PROCEED", "PROCEED WITH CONDITIONS", "REVISE", "BLOCKED"],
         "revise_to": "plan"
@@ -37,7 +37,7 @@
       "intent": "A human decides whether it should ship now. Readiness says it can; this decides timing, freeze windows, and who is on call.",
       "skills": ["council-review"],
       "gate": {
-        "id": "G2.6",
+        "id": "G3.1",
         "kind": "human",
         "verdicts": ["PROCEED", "PROCEED WITH CONDITIONS", "REVISE", "RECONSIDER", "BLOCKED"],
         "revise_to": "plan"

package/packs/sre-oncall/loops/operate/LOOP.md

@@ -17,7 +17,7 @@ the cost of time; this one runs while real users are affected. Its feedback edge
 | 1 | `instrument` | generate | [`observability-plan`](../../skills/observability-plan/SKILL.md) | — |
 | 2 | `document` | generate | [`runbook-generator`](../../skills/runbook-generator/SKILL.md) | — |
 | 3 | `respond` | generate | [`incident-comms`](../../skills/incident-comms/SKILL.md) | — |
-| 4 | `learn` | verify | [`postmortem-generator`](../../skills/postmortem-generator/SKILL.md) | **G3** human |
+| 4 | `learn` | verify | [`postmortem-generator`](../../skills/postmortem-generator/SKILL.md) | **G4** human |
 
 ## How to run this loop
 
@@ -29,7 +29,7 @@ the cost of time; this one runs while real users are affected. Its feedback edge
 3. **Respond to the audience the incident actually has.** `incident-comms` is staged —
    detect, mitigate, resolve — and the stage determines the message. Writing a resolution
    update during mitigation is the most common error here.
-4. **Learn at G3.** `postmortem-generator` analyses blamelessly and ends with runbook deltas.
+4. **Learn at G4.** `postmortem-generator` analyses blamelessly and ends with runbook deltas.
    A human signs off that the incident is closed. `REVISE` returns to `document`: the deltas
    are the loop's output, and applying them is what closes it.
 
@@ -38,7 +38,7 @@ starts at `instrument`. Do not replay earlier stages for their own sake.
 
 ## Verdicts
 
-Defined in [`contracts/terminals.json`](../../../../contracts/terminals.json). G3 emits `PROCEED`,
+Defined in [`contracts/terminals.json`](../../../../contracts/terminals.json). G4 emits `PROCEED`,
 `PROCEED WITH CONDITIONS`, `REVISE`, or `BLOCKED`. `PROCEED WITH CONDITIONS` means the
 incident is closed but named follow-ups are outstanding — they travel with the postmortem.
 
@@ -61,7 +61,7 @@ gate's verdict, append one JSON line to that file. Nothing else is recorded, and
 sent anywhere. When the variable isn't set, or you can't read it, skip this section.
 
 ```bash
-printf '%s\n' '{"ts":"2026-10-01T14:03:00Z","loop":"operate","stage":"learn","gate":"G3","verdict":"PROCEED","round":1}' >> "$SKILLDROP_LOOP_LOG"
+printf '%s\n' '{"ts":"2026-10-01T14:03:00Z","loop":"operate","stage":"learn","gate":"G4","verdict":"PROCEED","round":1}' >> "$SKILLDROP_LOOP_LOG"
 ```
 
 Fields: `ts` (UTC), `loop`, `stage`, `gate` (`null` for a stage without one), `verdict` (the

package/packs/sre-oncall/loops/operate/evals/evals.json

@@ -9,7 +9,7 @@
         "Stages the communication (detect / mitigate / resolve) and matches the message to the stage the incident is in",
         "Produces a blameless postmortem that names missing guardrails, never people",
         "Ends in concrete runbook deltas phrased as before/after edits",
-        "Routes those deltas back to `document` via G3's revise edge rather than treating the postmortem as terminal"
+        "Routes those deltas back to `document` via G4's revise edge rather than treating the postmortem as terminal"
       ]
     },
     {

package/packs/sre-oncall/loops/operate/loop.json

@@ -1,7 +1,7 @@
 {
   "$comment": "RFC-0028. The only loop whose failures are irreversible and live. Its feedback edge is real and already documented in the repo: postmortem-generator emits runbook deltas phrased as edits for runbook-generator.",
   "name": "operate",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Take a shipped service through detection, response, and learning — instrument it, write the runbook, communicate the incident, then feed the postmortem's deltas back into the runbook. Use when the user is preparing to run a service, is in an incident, or is writing a postmortem.",
   "entrypoint": "LOOP.md",
   "kind": "loop",
@@ -31,7 +31,7 @@
       "intent": "Analyse blamelessly and emit runbook deltas. An incident that changes no procedure has not been learned from.",
       "skills": ["postmortem-generator"],
       "gate": {
-        "id": "G3",
+        "id": "G4",
         "kind": "human",
         "verdicts": ["PROCEED", "PROCEED WITH CONDITIONS", "REVISE", "BLOCKED"],
         "revise_to": "document"

package/packs/sre-oncall/pack.json

@@ -46,7 +46,7 @@
         "skill": "postmortem-generator",
         "you_do": "Paste the incident thread, pager timeline and notes once it is over.",
         "you_get": "A blameless postmortem with quantified impact, a UTC timeline showing detection and mitigation gaps, contributing factors, up to eight action items, and runbook deltas phrased as edits.",
-        "decide": "Gate G3, a human call: PROCEED closes it, PROCEED WITH CONDITIONS closes it with named follow-ups, REVISE sends the deltas back to the runbook."
+        "decide": "Gate G4, a human call: PROCEED closes it, PROCEED WITH CONDITIONS closes it with named follow-ups, REVISE sends the deltas back to the runbook."
       },
       {
         "skill": "delivery-metrics-report",