@lovrozagar/grunt 0.5.0 → 0.5.2

package/.grok/hooks/orchestrate-parent.js

@@ -2,7 +2,7 @@
 /** PreToolUse parent-deny on Claude+Grok+Antigravity; Stop = first-non-empty-line recap; stop-block survives host banners; SubagentStop is single-registration intercept.
 Parent Read/Grep/Glob/Bash/Web denied unless parent-escape (fat-gate still).
 SubagentStop intercepts need: search|exec with grunt-job verdicts.
-Stop: first-non-empty-line [orchestrator]:/[grunt]:/[implementer]:/[thinker]:/[handoff]: recap
+Stop: first-non-empty-line [orchestrator]:/[grunt]:/[implementer]:/[thinker]:/[handoff]:/[tmp]: recap
 | parent-escape once; else block. MAX_STOP=3. No isCheap/trivia.
 Empty lastAssistantMessage → transcript_path tail-scan. Fail-open: parse/crash → empty stdout, exit 0.
 */
@@ -25,16 +25,20 @@ import {
 } from "../../scripts/gate-fat-tools.mjs";
 import { persistPlan } from "../../scripts/persist-plan.mjs";
 import { persistHandoff } from "../../scripts/persist-handoff.mjs";
+import { persistTmp } from "../../scripts/persist-tmp.mjs";
 import { parseNeed } from "../../scripts/parse-need.mjs";
 import { resolveJobCwd, runJob } from "../../scripts/grunt-job.mjs";
+import { loadLeftoverGate, loadSpawnMode } from "../../scripts/grunt-config.mjs";
 
-export const ORCHESTRATOR_LOGS_DIR = ".tmp/orchestrator-logs";
+export const ORCHESTRATOR_LOGS_DIR = ".tmp/grunt/orchestrator-logs";
+/** One-release dual-read; drop next release. */
+export const LEGACY_ORCHESTRATOR_LOGS_DIR = ".tmp/orchestrator-logs";
 export const DENY_REASON =
   "First action=spawn implementer|grunt|thinker. Deny expected. Only /solo this session escapes.";
 export const STOP_REASONS = [
-  "Spawn: ⚠/validate/sim findings or writes remain after Implement pick/`/implement-plan`/explicit implement or parent just tried to Write → spawn implementer. Else facts → grunt. Else no spec/not small/simple → thinker then recap-stop. Else small/simple/defined → implementer. Thinker recap ≠ spec-ready. `ok`/`yes` ≠ implement. Else recap `[orchestrator]:` one recap line; advise leftover 1./2. each on own line after.",
-  "Still spawn: ⚠/validate/sim findings or writes remain after Implement pick/`/implement-plan`/explicit implement or parent just tried to Write → spawn implementer. Else facts → grunt. Else no spec/not small/simple → thinker then recap-stop. Else small/simple/defined → implementer. Thinker recap ≠ spec-ready. `ok`/`yes` ≠ implement. Else recap `[orchestrator]:` one recap line; advise leftover 1./2. each on own line after.",
-  "Last spawn: ⚠/validate/sim findings or writes remain after Implement pick/`/implement-plan`/explicit implement or parent just tried to Write → spawn implementer. Else facts → grunt. Else no spec/not small/simple → thinker then recap-stop. Else small/simple/defined → implementer. Thinker recap ≠ spec-ready. `ok`/`yes` ≠ implement. Else recap `[orchestrator]:` one recap line; advise leftover 1./2. each on own line after.",
+  "Spawn: ⚠/validate/sim findings or writes remain after Implement pick/`/implement-plan`/explicit implement or parent just tried to Write → spawn implementer. Else facts → grunt. Else no spec/not small/simple → thinker then recap-stop. Else small/simple/defined → implementer. Thinker recap ≠ spec-ready. `ok`/`yes` ≠ implement. Else recap `[orchestrator]:` one recap line; advise leftover numbered pick each on own line after (echo printed leftover; always-print typed triple).",
+  "Still spawn: ⚠/validate/sim findings or writes remain after Implement pick/`/implement-plan`/explicit implement or parent just tried to Write → spawn implementer. Else facts → grunt. Else no spec/not small/simple → thinker then recap-stop. Else small/simple/defined → implementer. Thinker recap ≠ spec-ready. `ok`/`yes` ≠ implement. Else recap `[orchestrator]:` one recap line; advise leftover numbered pick each on own line after (echo printed leftover; always-print typed triple).",
+  "Last spawn: ⚠/validate/sim findings or writes remain after Implement pick/`/implement-plan`/explicit implement or parent just tried to Write → spawn implementer. Else facts → grunt. Else no spec/not small/simple → thinker then recap-stop. Else small/simple/defined → implementer. Thinker recap ≠ spec-ready. `ok`/`yes` ≠ implement. Else recap `[orchestrator]:` one recap line; advise leftover numbered pick each on own line after (echo printed leftover; always-print typed triple).",
 ];
 const TRANSCRIPT_TAIL_BYTES = 512 * 1024;
 const PARENT_TOOLS = new Set([
@@ -58,12 +62,15 @@ const WRITE_TOOLS = new Set([
 ]);
 const BASH_TOOLS = new Set(["bash", "runterminalcommand", "runcommand"]);
 const SKILL_TOOLS = new Set(["skill"]);
-const PARENT_SKILLS = new Set([
+export const PARENT_SKILLS = new Set([
   "parent",
   "explain",
   "solo",
   "cascade",
+  "auto",
+  "ask",
   "handoff",
+  "tmp",
   "pickup",
   "write-plan",
   "implement-plan",
@@ -74,7 +81,11 @@ const MAX_INTERCEPT = 3;
 /** `/solo` enters single-agent mode; `/cascade` restores the orchestrator. */
 const SOLO_RE = /^\s*\/solo\s*$/;
 const CASCADE_RE = /^\s*\/cascade\s*$/;
+const AUTO_RE = /^\s*\/auto\s*$/;
+const ASK_RE = /^\s*\/ask\s*$/;
 const SOLO_STAMP = "grunt-off";
+export const AUTO_ASK_STAMP = "auto-ask";
+export const SPAWN_MODE_STAMP = "spawn-mode";
 
 
 function main() {
@@ -154,19 +165,17 @@ function preToolUse(data) {
   return 0;
 }
 
-/** Session flag, not one-turn. Fail-closed: an unreadable stamp keeps grunt on. */
+/** Session flag, not one-turn. Fail-closed: unreadable spawn-mode stamp is not solo. */
 export function isSoloMode(data) {
   try {
-    const p = soloStampPath(data);
-    return Boolean(p && fs.existsSync(p));
+    return spawnModeOf(data) === "solo";
   } catch {
     return false;
   }
 }
 
 function hasParentEscape(data) {
-  const p = stampPath(data, "parent-escape");
-  return Boolean(p && fs.existsSync(p));
+  return Boolean(resolveStamp(data, "parent-escape"));
 }
 
 function emitFat(data) {
@@ -198,13 +207,30 @@ function isUnderDir(filePath, workspaceRoot, segments) {
 }
 
 export function isUnderPlans(filePath, workspaceRoot) {
-  return isUnderDir(filePath, workspaceRoot, [".tmp", "plans"]);
+  return isUnderDir(filePath, workspaceRoot, [".tmp", "grunt", "plans"]);
 }
 
 export function isUnderHandoffs(filePath, workspaceRoot) {
   return isUnderDir(filePath, workspaceRoot, [".tmp", "grunt", "handoffs"]);
 }
 
+export const TMP_RESERVED_DIRS = new Set([
+  "plans",
+  "handoffs",
+  "browser",
+  "orchestrator-logs",
+]);
+
+export function isUnderTmp(filePath, workspaceRoot) {
+  if (!filePath || !workspaceRoot) return false;
+  const abs = path.isAbsolute(filePath)
+    ? path.resolve(filePath)
+    : path.resolve(workspaceRoot, filePath);
+  const root = path.resolve(workspaceRoot, ".tmp", "grunt");
+  if (path.dirname(abs) !== root) return false;
+  return !TMP_RESERVED_DIRS.has(path.basename(abs));
+}
+
 export function isAllowedParentGruntJob(command, workspaceRoot) {
   return isWorkspaceGruntJob(command, workspaceRoot, ["search", "exec"]);
 }
@@ -257,8 +283,18 @@ function parentWrite(data, toolInput) {
     "";
   const rewritten = rewriteGruntScratchPath(rawPath, ws);
   if (rewritten) rawPath = rewritten;
-  const handoff = isUnderHandoffs(rawPath, ws);
-  if (!handoff && !isUnderPlans(rawPath, ws)) {
+  let persist;
+  let invalid = "invalid plan";
+  if (isUnderPlans(rawPath, ws)) {
+    persist = persistPlan;
+    invalid = "invalid plan";
+  } else if (isUnderHandoffs(rawPath, ws)) {
+    persist = persistHandoff;
+    invalid = "invalid handoff";
+  } else if (isUnderTmp(rawPath, ws)) {
+    persist = persistTmp;
+    invalid = "invalid tmp";
+  } else {
     if (hasParentEscape(data)) {
       emit({ decision: "allow" });
       return 0;
@@ -267,12 +303,11 @@ function parentWrite(data, toolInput) {
     return 0;
   }
   const content = typeof toolInput.content === "string" ? toolInput.content : "";
-  const persist = handoff ? persistHandoff : persistPlan;
   const result = persist({ workspaceRoot: ws, content });
   if (!result.ok) {
     emit({
       decision: "deny",
-      reason: result.error || (handoff ? "invalid handoff" : "invalid plan"),
+      reason: result.error || invalid,
     });
     return 0;
   }
@@ -307,10 +342,7 @@ function rewriteSpawn(toolInput, data) {
 
 function postToolUse(data) {
   if (data.subagentType || data.subagent_type) return 0;
-  const stamp = stampPath(data, "tools-used");
-  if (!stamp) return 0;
-  fs.mkdirSync(path.dirname(stamp), { recursive: true });
-  fs.writeFileSync(stamp, "1");
+  writeStamp(data, "tools-used", "1");
   return 0;
 }
 
@@ -324,35 +356,41 @@ function isParentEscapePrompt(prompt) {
 }
 
 function userPromptSubmit(data) {
-  unlinkQuiet(stampPath(data, "tools-used"));
+  unlinkStamp(data, "tools-used");
   const prompt = userPromptOf(data);
   if (!isHostStopBanner(prompt)) {
-    unlinkQuiet(stampPath(data, "stop-block"));
-  }
-  // Sticky: only /solo and /cascade move it. Every other prompt leaves it alone.
-  if (SOLO_RE.test(prompt)) {
-    const solo = soloStampPath(data);
-    if (solo) {
-      fs.mkdirSync(path.dirname(solo), { recursive: true });
-      fs.writeFileSync(solo, "1");
+    unlinkStamp(data, "stop-block");
+  }
+  // Sticky: only exact /solo and /cascade move spawn-mode. Always unlink grunt-off.
+  if (SOLO_RE.test(prompt) || CASCADE_RE.test(prompt)) {
+    const token = SOLO_RE.test(prompt) ? "solo" : "cascade";
+    const cfg = loadSpawnMode(workspaceRootOf(data));
+    if (token === cfg) {
+      unlinkSpawnModeStamp(data);
+    } else {
+      writeSpawnModeStamp(data, token);
+    }
+    unlinkSoloStamp(data);
+  }
+  if (AUTO_RE.test(prompt) || ASK_RE.test(prompt)) {
+    const token = AUTO_RE.test(prompt) ? "auto" : "ask";
+    const cfg = loadLeftoverGate(workspaceRootOf(data));
+    if (token === cfg) {
+      unlinkAutoAskStamp(data);
+    } else {
+      writeAutoAskStamp(data, token);
     }
-  } else if (CASCADE_RE.test(prompt)) {
-    unlinkQuiet(soloStampPath(data));
   }
   if (isParentEscapePrompt(prompt)) {
-    const p = stampPath(data, "parent-escape");
-    if (p) {
-      fs.mkdirSync(path.dirname(p), { recursive: true });
-      fs.writeFileSync(p, "1");
-    }
+    writeStamp(data, "parent-escape", "1");
   } else {
-    unlinkQuiet(stampPath(data, "parent-escape"));
+    unlinkStamp(data, "parent-escape");
   }
   return 0;
 }
 
 const RECAP_TAG_RE =
-  /^\[(?:orchestrator|grunt|implementer|thinker|handoff)\]:/;
+  /^\[(?:orchestrator|grunt|implementer|thinker|handoff|tmp)\]:/;
 const WAIT_GRUNT = "[orchestrator]: wait grunt";
 
 function firstNonEmptyStripped(msg) {
@@ -376,6 +414,38 @@ export function isWaitGruntExact(msg) {
   return nonempty[0].replace(/^[\s`*_>]+/, "") === WAIT_GRUNT;
 }
 
+function nonemptyLines(msg) {
+  return String(msg || "")
+    .split("\n")
+    .filter((l) => l.trim());
+}
+
+/** Format-only leftover triple. No leftover-number → skill map. */
+export function hasLeftoverTriple(msg) {
+  const lines = String(msg || "")
+    .split("\n")
+    .map((l) => l.replace(/^[\s`*_>]+/, "").trim());
+  const hit = (re) => lines.some((l) => re.test(l));
+  const tweak = hit(/^3\.\s+Tweak$/);
+  const impl =
+    hit(/^1\.\s+Implement with verbal plan$/) &&
+    hit(/^2\.\s+Implement with file plan$/);
+  const write =
+    hit(/^1\.\s+Write with verbal plan$/) &&
+    hit(/^2\.\s+Write with file plan$/);
+  return Boolean(tweak && (impl || write));
+}
+
+/** Ask leftover-required: any `[thinker]:`; `[orchestrator]:` iff >1 nonempty line (except exact wait-grunt); `[grunt]|[implementer]|[handoff]|[tmp]:` exempt. Auto waives in Stop. */
+export function leftoverRequiredAsk(msg) {
+  if (isWaitGruntExact(msg)) return false;
+  const first = firstNonEmptyStripped(msg);
+  if (/^\[(?:grunt|implementer|handoff|tmp)\]:/.test(first)) return false;
+  if (/^\[thinker\]:/.test(first)) return true;
+  if (/^\[orchestrator\]:/.test(first)) return nonemptyLines(msg).length > 1;
+  return false;
+}
+
 function payloadAssistantMessage(data) {
   if (!data || typeof data !== "object") return "";
   const camel = data.lastAssistantMessage;
@@ -466,9 +536,8 @@ function stop(data) {
   // Before the parent-escape consume: solo must never burn the one-turn stamp.
   if (isSoloMode(data)) return 0;
 
-  const escapeStamp = stampPath(data, "parent-escape");
-  if (escapeStamp && fs.existsSync(escapeStamp)) {
-    unlinkQuiet(escapeStamp);
+  if (resolveStamp(data, "parent-escape")) {
+    unlinkStamp(data, "parent-escape");
     return 0;
   }
 
@@ -483,22 +552,22 @@ function stop(data) {
   if (waitFirst && !isWaitGruntExact(msg)) {
     // fall through to block — leftover lines not allowed on mid-turn wait
   } else if (isRecap(msg)) {
-    return 0;
+    if (
+      leftoverGateOf(data) !== "auto" &&
+      leftoverRequiredAsk(msg) &&
+      !hasLeftoverTriple(msg)
+    ) {
+      // fall through to block — leftover-required under ask
+    } else {
+      return 0;
+    }
   }
 
-  const stopStamp = stampPath(data, "stop-block");
-  let n = 0;
-  if (stopStamp && fs.existsSync(stopStamp)) {
-    n = parseInt(fs.readFileSync(stopStamp, "utf8"), 10);
-    if (!Number.isFinite(n) || n < 0) n = 0;
-  }
+  let n = readStampInt(data, "stop-block");
   if (n >= MAX_STOP) {
     return 0;
   }
-  if (stopStamp) {
-    fs.mkdirSync(path.dirname(stopStamp), { recursive: true });
-    fs.writeFileSync(stopStamp, String(n + 1));
-  }
+  writeStamp(data, "stop-block", String(n + 1));
   const reasonText = STOP_REASONS[Math.min(n, STOP_REASONS.length - 1)];
   emit({ decision: "block", reason: reasonText });
   return 0;
@@ -522,12 +591,7 @@ function interceptNeed(data, hookEventName) {
     return 0;
   }
 
-  const interceptStamp = stampPath(data, "need-intercept");
-  let n = 0;
-  if (interceptStamp && fs.existsSync(interceptStamp)) {
-    n = parseInt(fs.readFileSync(interceptStamp, "utf8"), 10);
-    if (!Number.isFinite(n) || n < 0) n = 0;
-  }
+  let n = readStampInt(data, "need-intercept");
   if (n >= MAX_INTERCEPT) {
     return 0;
   }
@@ -557,10 +621,7 @@ function interceptNeed(data, hookEventName) {
     }
     parts.push(String(result.text || "").trimEnd());
   }
-  if (interceptStamp) {
-    fs.mkdirSync(path.dirname(interceptStamp), { recursive: true });
-    fs.writeFileSync(interceptStamp, String(n + 1));
-  }
+  writeStamp(data, "need-intercept", String(n + 1));
   const reason = parts.join("\n");
   emit({
     decision: "block",
@@ -579,6 +640,42 @@ function stampPath(data, prefix) {
   return path.join(root, ORCHESTRATOR_LOGS_DIR, prefix + "-" + sid);
 }
 
+function legacyStampPath(data, prefix) {
+  const root = workspaceRootOf(data);
+  const sid = sessionIdOf(data) || "default";
+  if (!root) return null;
+  return path.join(root, LEGACY_ORCHESTRATOR_LOGS_DIR, prefix + "-" + sid);
+}
+
+function resolveStamp(data, prefix) {
+  const neu = stampPath(data, prefix);
+  if (neu && fs.existsSync(neu)) return neu;
+  const old = legacyStampPath(data, prefix);
+  if (old && fs.existsSync(old)) return old;
+  return null;
+}
+
+function writeStamp(data, prefix, body) {
+  const p = stampPath(data, prefix);
+  if (!p) return null;
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+  fs.writeFileSync(p, body);
+  return p;
+}
+
+function unlinkStamp(data, prefix) {
+  unlinkQuiet(stampPath(data, prefix));
+  unlinkQuiet(legacyStampPath(data, prefix));
+}
+
+function readStampInt(data, prefix) {
+  const p = resolveStamp(data, prefix);
+  if (!p) return 0;
+  const n = parseInt(fs.readFileSync(p, "utf8"), 10);
+  if (!Number.isFinite(n) || n < 0) return 0;
+  return n;
+}
+
 function sessionIdOf(data) {
   return String(
     process.env.GROK_SESSION_ID ||
@@ -595,6 +692,127 @@ function soloStampPath(data) {
   return path.join(root, ORCHESTRATOR_LOGS_DIR, SOLO_STAMP + "-" + sid);
 }
 
+function legacySoloStampPath(data) {
+  const root = workspaceRootOf(data);
+  const sid = sessionIdOf(data);
+  if (!root || !sid) return null;
+  return path.join(root, LEGACY_ORCHESTRATOR_LOGS_DIR, SOLO_STAMP + "-" + sid);
+}
+
+function resolveSoloStamp(data) {
+  const neu = soloStampPath(data);
+  if (neu && fs.existsSync(neu)) return neu;
+  const old = legacySoloStampPath(data);
+  if (old && fs.existsSync(old)) return old;
+  return null;
+}
+
+function unlinkSoloStamp(data) {
+  unlinkQuiet(soloStampPath(data));
+  unlinkQuiet(legacySoloStampPath(data));
+}
+
+/** Spawn-mode stamp: never share a `default` stamp across sid-less sessions. */
+export function spawnModeStampPath(data) {
+  const root = workspaceRootOf(data);
+  const sid = sessionIdOf(data);
+  if (!root || !sid) return null;
+  return path.join(root, ORCHESTRATOR_LOGS_DIR, SPAWN_MODE_STAMP + "-" + sid);
+}
+
+function legacySpawnModeStampPath(data) {
+  const root = workspaceRootOf(data);
+  const sid = sessionIdOf(data);
+  if (!root || !sid) return null;
+  return path.join(root, LEGACY_ORCHESTRATOR_LOGS_DIR, SPAWN_MODE_STAMP + "-" + sid);
+}
+
+function resolveSpawnModeStamp(data) {
+  const neu = spawnModeStampPath(data);
+  if (neu && fs.existsSync(neu)) return neu;
+  const old = legacySpawnModeStampPath(data);
+  if (old && fs.existsSync(old)) return old;
+  return null;
+}
+
+function writeSpawnModeStamp(data, body) {
+  const p = spawnModeStampPath(data);
+  if (!p) return null;
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+  fs.writeFileSync(p, body);
+  return p;
+}
+
+function unlinkSpawnModeStamp(data) {
+  unlinkQuiet(spawnModeStampPath(data));
+  unlinkQuiet(legacySpawnModeStampPath(data));
+}
+
+/** Valid stamp solo|cascade wins; else grunt-off presence as solo; else config. Unreadable/bad body ignored. */
+export function spawnModeOf(data) {
+  try {
+    const p = resolveSpawnModeStamp(data);
+    if (p) {
+      const body = fs.readFileSync(p, "utf8").trim();
+      if (body === "solo" || body === "cascade") return body;
+    }
+  } catch {
+    // unreadable stamp → fall through
+  }
+  if (resolveSoloStamp(data)) return "solo";
+  return loadSpawnMode(workspaceRootOf(data));
+}
+
+/** Leftover-gate stamp: never share a `default` stamp across sid-less sessions. */
+export function autoAskStampPath(data) {
+  const root = workspaceRootOf(data);
+  const sid = sessionIdOf(data);
+  if (!root || !sid) return null;
+  return path.join(root, ORCHESTRATOR_LOGS_DIR, AUTO_ASK_STAMP + "-" + sid);
+}
+
+function legacyAutoAskStampPath(data) {
+  const root = workspaceRootOf(data);
+  const sid = sessionIdOf(data);
+  if (!root || !sid) return null;
+  return path.join(root, LEGACY_ORCHESTRATOR_LOGS_DIR, AUTO_ASK_STAMP + "-" + sid);
+}
+
+function resolveAutoAskStamp(data) {
+  const neu = autoAskStampPath(data);
+  if (neu && fs.existsSync(neu)) return neu;
+  const old = legacyAutoAskStampPath(data);
+  if (old && fs.existsSync(old)) return old;
+  return null;
+}
+
+function writeAutoAskStamp(data, body) {
+  const p = autoAskStampPath(data);
+  if (!p) return null;
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+  fs.writeFileSync(p, body);
+  return p;
+}
+
+function unlinkAutoAskStamp(data) {
+  unlinkQuiet(autoAskStampPath(data));
+  unlinkQuiet(legacyAutoAskStampPath(data));
+}
+
+/** Stamp body auto|ask wins; else config; else ask. Bad stamp body ignored. */
+export function leftoverGateOf(data) {
+  try {
+    const p = resolveAutoAskStamp(data);
+    if (p) {
+      const body = fs.readFileSync(p, "utf8").trim();
+      if (body === "auto" || body === "ask") return body;
+    }
+  } catch {
+    // unreadable stamp → fall through
+  }
+  return loadLeftoverGate(workspaceRootOf(data));
+}
+
 function unlinkQuiet(p) {
   if (!p) return;
   try {

package/.grok/skills/ask/SKILL.md

@@ -0,0 +1,18 @@
+---
+name: ask
+description: >
+  Session leftover-gate. /ask sets leftover-gate ask for this session — leftover
+  triple wait on advise-class recaps. Not leftover y/n. Not pick 3 Tweak. Not
+  spawn-escape. /auto sets auto.
+---
+Session leftover-gate, not spawn-escape. Not leftover y/n. Not pick 3 Tweak.
+
+Whole-prompt `/ask` only (`/ask foo` no-op). Persists until `/auto` or session end.
+
+Effective leftover-gate: stamp body `auto`|`ask` > `.rulesync/grunt.config.jsonc` `leftoverGate` > `ask`. Fail-closed `ask`.
+
+Claude/Codex/Grok: `/ask` via submit hook. If slash token equals committed config `leftoverGate`, unlink `.tmp/grunt/orchestrator-logs/auto-ask-{sid}`; else write stamp body `ask`. Requires real sid (never `default`). Agents/Antigravity: instruction-only (this skill body); cannot create stamp via `/ask`; Stop still honors a pre-existing stamp if present. Session-scoped, never global.
+
+Ask: always-print typed leftover triple on advise-class final recap. Write-typed leftover never spawns implementer. Not leftover pick 3.
+
+Not `/solo`. Spawn-first still. Recap tags still.

package/.grok/skills/auto/SKILL.md

@@ -0,0 +1,18 @@
+---
+name: auto
+description: >
+  Session leftover-gate. /auto sets leftover-gate auto for this session —
+  Implement-typed pick2 chains write-plan persist then implement-plan {n} and
+  skips leftover wait. Not autofix. Not spawn-escape. /ask restores ask.
+---
+Session leftover-gate, not spawn-escape. Not autofix. Not leftover y/n.
+
+Whole-prompt `/auto` only (`/auto foo` no-op). Persists until `/ask` or session end.
+
+Effective leftover-gate: stamp body `auto`|`ask` > `.rulesync/grunt.config.jsonc` `leftoverGate` > `ask`. Fail-closed `ask`.
+
+Claude/Codex/Grok: `/auto` via submit hook. If slash token equals committed config `leftoverGate`, unlink `.tmp/grunt/orchestrator-logs/auto-ask-{sid}`; else write stamp body `auto`. Requires real sid (never `default`). Agents/Antigravity: instruction-only (this skill body); cannot create stamp via `/auto`; Stop still honors a pre-existing stamp if present. Session-scoped, never global.
+
+effective=auto + Implement-typed: write-plan persist then implement-plan `{n}`; skip leftover triple wait. Write-typed under auto still leftover wait; never spawn implementer.
+
+Not `/solo`. Spawn-first still. Recap tags still.

package/.grok/skills/browser/SKILL.md

@@ -1,9 +1,10 @@
 ---
 name: browser
 description: >
-  Session browser rail. /browser or browse a URL. Call node scripts/browser.mjs
-  nav|snap|click|fill|shot|pdf|stop. Lightpanda default; snap is the default
-  read. Windows → Chromium. Never MCP. Never env knobs. Never raw Playwright.
+  Live URL/interact → this; not websearch. /browser or browse a URL. Call node
+  scripts/browser.mjs nav|snap|click|fill|shot|pdf|stop. Lightpanda default;
+  snap is the default read. Windows → Chromium. Never MCP. Never env knobs.
+  Never raw Playwright.
 ---
 Zero-config. `node scripts/browser.mjs <verb>`.
 

package/.grok/skills/cascade/SKILL.md

@@ -13,14 +13,16 @@ Session mode, not one-turn. Persists until `/solo` or session end.
 This session: cascade restored. You are the parent orchestrator.
 
 - Spawn grunt|implementer|thinker.
-- Recap tags. Recap `[orchestrator]:` `[grunt]:` `[implementer]:` `[thinker]:` `[handoff]:`.
+- Recap tags. Recap `[orchestrator]:` `[grunt]:` `[implementer]:` `[thinker]:` `[handoff]:` `[tmp]:`.
 - Spawn-first rule. `need:`/`verdict:` grammar.
 - Voice unchanged: `.rulesync/reference/output.md`. `/explain` is still the voice escape.
 
 Fat-tool caps stay on — token guards, not cascade.
 
-Claude/Codex/Grok: `/cascade` via submit hook unlinks `.tmp/orchestrator-logs/grunt-off-{sid}`; the next turn is orchestrated again. Already orchestrated: no-op. Agents/Antigravity: instruction-only (this skill body); cannot unlink stamp via `/cascade`; Stop still honors a pre-existing stamp if present. Session-scoped, never global.
+Effective spawn: stamp body `solo`|`cascade` > one-release `grunt-off-{sid}` presence as solo > `.rulesync/grunt.config.jsonc` `spawnMode` > `cascade`. Fail-closed `cascade`. Unreadable/bad stamp body ignored (dual-read grunt-off else config). Never fail-closed solo.
+
+Claude/Codex/Grok: `/cascade` via submit hook. If slash token equals committed config `spawnMode`, unlink `.tmp/grunt/orchestrator-logs/spawn-mode-{sid}`; else write stamp body `cascade`. Always unlink `grunt-off-{sid}` (new+legacy). Requires real sid (never `default`). Already matching config with no leftover grunt-off: no-op. Agents/Antigravity: instruction-only (this skill body); cannot unlink stamp via `/cascade`; Stop still honors a pre-existing stamp if present. Session-scoped, never global.
 
 `/explain` is voice-only not spawn-escape. After unlink first token = spawn.
 
-After `/solo`, or when spawn/recap/need|verdict must resume.
+After `/solo`, or when spawn/recap/need|verdict must resume. Leftover-gate `/auto`/`/ask` is not spawn-escape.

package/.grok/skills/handoff/SKILL.md

@@ -80,6 +80,6 @@ Do not dump the handoff body.
 
 - No spawn. One write. `/handoff` is not a mode.
 - Never parent Read/Bash. Write handoffs dir only.
-- Handoff ≠ plan: no Steps/Verify phases, no `.tmp/plans/` write.
+- Handoff ≠ plan: no Steps/Verify phases, no `.tmp/grunt/plans/` write.
 - Never rewrite or renumber an existing handoff; new session = new serial.
 - Protocol: `.rulesync/reference/cascade.md`. Do not paste it here.

package/.grok/skills/implement-plan/SKILL.md

@@ -1,15 +1,15 @@
 ---
 name: implement-plan
 description: >
-  Implementer executes a local .tmp/plans checklist: continue, resume, or pick
-  among plans. Empty /implement-plan resumes a unique in-progress or starts a
-  unique ready plan; else lists and needs serial. Marks [x], skips completed
+  Implementer executes a local .tmp/grunt/plans checklist: continue, resume, or
+  pick among plans. Empty /implement-plan resumes a unique in-progress or starts
+  a unique ready plan; else lists and needs serial. Marks [x], skips completed
   leaves. Not /implement review-loop, not /execute-plan PR DAG, not /pickup, not
   /run-plan.
 ---
 # implement-plan
 
-Parent: spawn grunt to list/validate `.tmp/plans/` when the target is unknown or empty-arg; then spawn implementer with abs plan path + `{repo}/.rulesync/reference/plan-format.md` + first open leaf. Recap from implementer output only. No parent Read/Grep/Bash. Agent-agnostic (grunt then implementer). Not `/pickup` (handoffs only). Not `/run-plan`. Not `/execute-plan` (PR DAG).
+Parent: spawn grunt to list/validate `.tmp/grunt/plans/` when the target is unknown or empty-arg; then spawn implementer with abs plan path + `{repo}/.rulesync/reference/plan-format.md` + first open leaf. Recap from implementer output only. No parent Read/Grep/Bash. Agent-agnostic (grunt then implementer). Not `/pickup` (handoffs only). Not `/run-plan`. Not `/execute-plan` (PR DAG).
 
 Format SSOT: `.rulesync/reference/plan-format.md`.
 
@@ -22,7 +22,7 @@ Todos: `resolve` → `implement` → `verify`. One serial per run. Partial progr
 
 ## Resolve
 
-Arg = `$ARGUMENTS` stripped. Listing/validate: spawn grunt (`job:search|exec`) on `.tmp/plans/`. Do not parent Read/Grep/Bash.
+Arg = `$ARGUMENTS` stripped. Listing/validate: spawn grunt (`job:search|exec`) on `.tmp/grunt/plans/`. Do not parent Read/Grep/Bash.
 
 Eligible auto = valid plan-format checkbox grammar (`N [ ]` / `N.M [ ]`; not `- [ ]`; not `1. [ ]`). Invalid grammar: exclude from auto. Drop `done` (all `[x]` or FM `status: done`) from auto. Never silent latest. Never auto-pick among many.
 
@@ -34,7 +34,7 @@ Eligible auto = valid plan-format checkbox grammar (`N [ ]` / `N.M [ ]`; not `-
 
 ### Empty arg (`/implement-plan`)
 
-Grunt lists/validates `.tmp/plans/*.md`. Then:
+Grunt lists/validates `.tmp/grunt/plans/*.md`. Then:
 
 | condition | action |
 |---|---|
@@ -54,9 +54,9 @@ That file only; skip `[x]`; remaining leaves. Write-plan remainder stays `/imple
 | input | action |
 |---|---|
 | int (`1`, `0001`) | files whose leading number == that int |
-| `{serial}-slug` or `*.md` or path | that file if under `.tmp/plans/` |
+| `{serial}-slug` or `*.md` or path | that file if under `.tmp/grunt/plans/` |
 | slug only (`add-auth`) | unique match `*-{slug}-*.md` or `*-{slug}.md` |
-| `.tmp/plans` missing / no files | `no plans. /write-plan first` stop |
+| `.tmp/grunt/plans` missing / no files | `no plans. /write-plan first` stop |
 | 0 matches | `no plan serial={n}. have: {list}` stop |
 | >1 matches | `ambiguous: {paths}` stop |
 | all boxes already `[x]` / `status: done` | `[implementer]: already done path=...` **no implementer spawn** |
@@ -93,7 +93,7 @@ Wait. Spawn fail → `[implementer]: failed: {err}` stop.
 Recap from implementer output only. No parent Read/Grep/Bash.
 
 ```
-[implementer]: serial={int} path=.tmp/plans/{file} status={status} done={x}/{total}
+[implementer]: serial={int} path=.tmp/grunt/plans/{file} status={status} done={x}/{total}
 files: {abs paths}
 {if leftover:}
 leftover:
@@ -104,8 +104,9 @@ leftover:
 ## Rules
 
 - Skip `[x]`; only flip boxes; no renumber/rewrite leaf text.
-- No review-fix loop. Not bundled `/implement`. Leftover pick 1 (verbal plan) ≠ this skill (no `.tmp/plans`; no write-plan; no implement-plan). Bare `implement`/`implementer` → pick1, not this skill.
-- Slash `/implement-plan {n}` = disk/file run. Empty `/implement-plan` = unique-resume / unique-start / else list. Leftover pick 2 may invoke this sequencing without user slash (after write-plan persist; `plan=/abs/...` only). Always-do leftover match; leftover `2` ≠ Skill-name. Verbal leftover ≠ implement-plan.
+- No review-fix loop. Not bundled `/implement`. Implement leftover pick 1 (`Implement with verbal plan`) ≠ this skill (no `.tmp/grunt/plans`; no write-plan; no implement-plan). Bare `implement`/`implementer` → pick1 iff Implement-typed, not this skill; else recap “no implementer this remainder”.
+- Slash `/implement-plan {n}` = disk/file run. Empty `/implement-plan` = unique-resume / unique-start / else list. Implement leftover pick 2 may invoke this sequencing without user slash (after write-plan persist; `plan=/abs/...` only). Write leftover pick 2 does not spawn implementer this turn. Always-do leftover match; leftover `2` ≠ Skill-name. Verbal leftover ≠ implement-plan.
+- effective=auto + Implement-typed may chain this sequencing without user slash after write-plan persist (`plan=/abs/...`). Write-typed under auto: no implementer this turn; leftover wait.
 - No auto `/write-plan` chain. Escalation → tell user to `/write-plan` a follow-up.
 - Omit `model`. `subagent_type: implementer` only for this skill.
 - First prompt sentence: `You are implementer subagent.`