@lovrozagar/grunt 0.5.0 → 0.6.0

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

@@ -1,10 +1,6 @@
 #!/usr/bin/env node
-/** 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
-| 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.
+/** PreToolUse fat-gate + persist rewrite. Stop writes session receipt. SubagentStop intercepts need: search|exec|slice|fetch.
+Fail-open: parse/crash → empty stdout, exit 0.
 */
 import fs from "node:fs";
 import path from "node:path";
@@ -17,33 +13,21 @@ import {
 import {
   denyResponse,
   fatHookOutput,
-  isWorkspaceGruntJob,
-  isParentOrchestrator,
   processFatTools,
   rewriteGruntScratchPath,
-  subagentTypeOf,
 } from "../../scripts/gate-fat-tools.mjs";
 import { persistPlan } from "../../scripts/persist-plan.mjs";
 import { persistHandoff } from "../../scripts/persist-handoff.mjs";
+import { persistImplementation, isFullImplementationBody, validateImplementation } from "../../scripts/persist-implementation.mjs";
+import { persistTmp } from "../../scripts/persist-tmp.mjs";
 import { parseNeed } from "../../scripts/parse-need.mjs";
 import { resolveJobCwd, runJob } from "../../scripts/grunt-job.mjs";
 
-export const 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.",
-];
+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 = "denied";
 const TRANSCRIPT_TAIL_BYTES = 512 * 1024;
-const PARENT_TOOLS = new Set([
-  "todowrite",
-  "getcommandorsubagentoutput",
-  "gettaskoutput",
-  "killcommandorsubagent",
-  "killtask",
-]);
 const SPAWN_TOOLS = new Set([
   "spawnsubagent",
   "task",
@@ -56,26 +40,16 @@ const WRITE_TOOLS = new Set([
   "searchreplace",
   "replacefilecontent",
 ]);
-const BASH_TOOLS = new Set(["bash", "runterminalcommand", "runcommand"]);
-const SKILL_TOOLS = new Set(["skill"]);
-const PARENT_SKILLS = new Set([
-  "parent",
-  "explain",
-  "solo",
-  "cascade",
-  "handoff",
-  "pickup",
-  "write-plan",
-  "implement-plan",
-]);
-const INTERCEPT_JOBS = new Set(["search", "exec"]);
-const MAX_STOP = 3;
+const INTERCEPT_JOBS = new Set(["search", "exec", "slice", "fetch"]);
 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 SOLO_STAMP = "grunt-off";
-
+const MAX_STOP = 3;
+const AUTO_RE = /^\s*\/auto\s*$/;
+const ASK_RE = /^\s*\/ask\s*$/;
+export const SESSION_GATE_STAMP = "session-gate";
+/** One-release dual-read of 0.5 leftover stamp. */
+export const AUTO_ASK_STAMP = "auto-ask";
+export const ASK_STOP_REASON = "ask after this step";
+const WAIT_GRUNT = "[orchestrator]: wait grunt";
 
 function main() {
   try {
@@ -86,7 +60,6 @@ function main() {
         "",
     );
     if (event === "pretooluse") return preToolUse(data || {});
-    if (event === "posttooluse") return postToolUse(data || {});
     if (event === "userpromptsubmit") return userPromptSubmit(data || {});
     if (event === "stop") return stop(data || {});
     if (event === "subagentstop") return interceptNeed(data || {}, "SubagentStop");
@@ -102,18 +75,6 @@ function preToolUse(data) {
   let toolInput = data.toolInput;
   if (toolInput == null) toolInput = data.tool_input;
 
-  const sub = subagentTypeOf(data);
-  if (sub || !isParentOrchestrator(data)) {
-    const code = emitFat(data);
-    return code == null ? 0 : code;
-  }
-  if (isSoloMode(data)) {
-    // Single-agent session: no parent-deny, no spawn rewrite. Fat gate still applies.
-    const fatCode = emitFat(data);
-    if (fatCode !== null) return fatCode;
-    emit({ decision: "allow" });
-    return 0;
-  }
   if (SPAWN_TOOLS.has(toolKey)) {
     const updated = rewriteSpawn(toolInput, data);
     if (updated && updated.__denied) return 0;
@@ -130,45 +91,15 @@ function preToolUse(data) {
     return 0;
   }
   if (WRITE_TOOLS.has(toolKey)) {
-    return parentWrite(data, toolInput);
-  }
-  if (PARENT_TOOLS.has(toolKey)) {
-    emit({ decision: "allow" });
-    return 0;
-  }
-  if (BASH_TOOLS.has(toolKey) && isAllowedParentGruntJob(bashCommandOf(toolInput), workspaceRootOf(data))) {
-    emit({ decision: "allow" });
-    return 0;
-  }
-  if (SKILL_TOOLS.has(toolKey) && isAllowedParentSkill(toolInput)) {
-    emit({ decision: "allow" });
-    return 0;
-  }
-  if (hasParentEscape(data)) {
-    const fatCode = emitFat(data);
-    if (fatCode !== null) return fatCode;
-    emit({ decision: "allow" });
-    return 0;
+    const persistCode = parentWrite(data, toolInput);
+    if (persistCode !== null) return persistCode;
   }
-  emit({ decision: "deny", reason: DENY_REASON });
+  const fatCode = emitFat(data);
+  if (fatCode !== null) return fatCode;
+  emit({ decision: "allow" });
   return 0;
 }
 
-/** Session flag, not one-turn. Fail-closed: an unreadable stamp keeps grunt on. */
-export function isSoloMode(data) {
-  try {
-    const p = soloStampPath(data);
-    return Boolean(p && fs.existsSync(p));
-  } catch {
-    return false;
-  }
-}
-
-function hasParentEscape(data) {
-  const p = stampPath(data, "parent-escape");
-  return Boolean(p && fs.existsSync(p));
-}
-
 function emitFat(data) {
   const fat = fatHookOutput(processFatTools(data));
   if (!fat) return null;
@@ -198,49 +129,35 @@ 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 function isAllowedParentGruntJob(command, workspaceRoot) {
-  return isWorkspaceGruntJob(command, workspaceRoot, ["search", "exec"]);
+export function isUnderImplementations(filePath, workspaceRoot) {
+  return isUnderDir(filePath, workspaceRoot, [".tmp", "grunt", "implementations"]);
 }
 
-function bashCommandOf(toolInput) {
-  if (!toolInput || typeof toolInput !== "object" || Array.isArray(toolInput)) {
-    return "";
-  }
-  return String(toolInput.command ?? toolInput.cmd ?? "");
-}
-
-function skillNameOf(toolInput) {
-  if (!toolInput || typeof toolInput !== "object" || Array.isArray(toolInput)) {
-    return "";
-  }
-  const raw =
-    toolInput.skill ??
-    toolInput.skill_name ??
-    toolInput.skillName ??
-    toolInput.name ??
-    "";
-  const s = String(raw).trim().toLowerCase().replace(/\\/g, "/");
-  const base = s.split("/").pop() || "";
-  return base.replace(/\.md$/, "").replace(/_/g, "-");
-}
-
-export function isAllowedParentSkill(toolInput) {
-  return PARENT_SKILLS.has(skillNameOf(toolInput));
-}
+export const TMP_RESERVED_DIRS = new Set([
+  "plans",
+  "handoffs",
+  "implementations",
+  "browser",
+  "orchestrator-logs",
+  "stash",
+  "sessions",
+]);
 
-function isHostStopBanner(prompt) {
-  const p = String(prompt || "");
-  if (/^\s*Stop hook feedback:/.test(p)) return true;
-  if (/Blocked by stop hook/.test(p)) return true;
-  if (/task[-_ ]?notification/i.test(p)) return true;
-  return false;
+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));
 }
 
 function parentWrite(data, toolInput) {
@@ -257,22 +174,59 @@ function parentWrite(data, toolInput) {
     "";
   const rewritten = rewriteGruntScratchPath(rawPath, ws);
   if (rewritten) rawPath = rewritten;
-  const handoff = isUnderHandoffs(rawPath, ws);
-  if (!handoff && !isUnderPlans(rawPath, ws)) {
-    if (hasParentEscape(data)) {
-      emit({ decision: "allow" });
+  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 (isUnderImplementations(rawPath, ws)) {
+    persist = persistImplementation;
+    invalid = "invalid implementation";
+    const abs = path.isAbsolute(rawPath)
+      ? path.resolve(rawPath)
+      : path.resolve(ws, rawPath);
+    const content = typeof toolInput.content === "string" ? toolInput.content : "";
+    const named = /^\s*IMPL_NAME:/m.test(content);
+    let exists = false;
+    try {
+      exists = fs.statSync(abs).isFile();
+    } catch {
+      exists = false;
+    }
+    if (!named && exists) {
+      if (!isFullImplementationBody(content)) return null;
+      const errors = validateImplementation(path.basename(abs), content);
+      if (errors.length) {
+        emit({ decision: "deny", reason: errors.join("; ") || invalid });
+        return 0;
+      }
+      const next = Object.assign({}, toolInput, {
+        file_path: abs,
+        content,
+      });
+      emit({
+        hookSpecificOutput: {
+          hookEventName: "PreToolUse",
+          updatedInput: next,
+        },
+      });
       return 0;
     }
-    emit({ decision: "deny", reason: DENY_REASON });
-    return 0;
+  } else if (isUnderTmp(rawPath, ws)) {
+    persist = persistTmp;
+    invalid = "invalid tmp";
+  } else {
+    return null;
   }
   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;
   }
@@ -290,7 +244,6 @@ function parentWrite(data, toolInput) {
 }
 
 function rewriteSpawn(toolInput, data) {
-  // Type default + intent-scrub in one updatedInput (last-wins with scrub-spawn).
   const updated = rewriteSpawnToolInput(toolInput, { defaultGrunt: true });
   const prompt =
     updated && typeof updated.prompt === "string"
@@ -305,69 +258,93 @@ function rewriteSpawn(toolInput, data) {
   return updated;
 }
 
-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");
-  return 0;
-}
-
 function userPromptOf(data) {
   if (!data || typeof data !== "object") return "";
   return String(data.prompt ?? data.userPrompt ?? data.user_prompt ?? data.content ?? "");
 }
 
-function isParentEscapePrompt(prompt) {
-  return /^\s*\/parent(?:\s|$)/.test(String(prompt || ""));
+function isHostStopBanner(prompt) {
+  const p = String(prompt || "");
+  if (/^\s*Stop hook feedback:/.test(p)) return true;
+  if (/Blocked by stop hook/.test(p)) return true;
+  if (/task[-_ ]?notification/i.test(p)) return true;
+  return false;
 }
 
-function userPromptSubmit(data) {
-  unlinkQuiet(stampPath(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");
-    }
-  } 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");
-    }
-  } else {
-    unlinkQuiet(stampPath(data, "parent-escape"));
+function countLines(file) {
+  try {
+    return fs
+      .readFileSync(file, "utf8")
+      .split("\n")
+      .map((l) => l.trim())
+      .filter(Boolean).length;
+  } catch {
+    return 0;
   }
-  return 0;
 }
 
-const RECAP_TAG_RE =
-  /^\[(?:orchestrator|grunt|implementer|thinker|handoff)\]:/;
-const WAIT_GRUNT = "[orchestrator]: wait grunt";
+function sessionReceiptContext(data) {
+  const sid = sessionIdOf(data);
+  if (!sid || sid === "default") return "";
+  const dir = path.join(
+    workspaceRootOf(data),
+    ".tmp",
+    "grunt",
+    "sessions",
+    sid,
+  );
+  if (!fs.existsSync(dir)) return "";
+  const wrote = countLines(path.join(dir, "wrote.txt"));
+  const read = countLines(path.join(dir, "read.txt"));
+  return `${wrote} wrote, ${read} read. session=.tmp/grunt/sessions/${sid}/`;
+}
 
-function firstNonEmptyStripped(msg) {
-  for (const line of String(msg || "").split("\n")) {
-    if (!line.trim()) continue;
-    return line.replace(/^[\s`*_>]+/, "");
+function writeSessionReceipt(data, msg) {
+  const sid = sessionIdOf(data);
+  if (!sid || sid === "default") return;
+  const dir = path.join(
+    workspaceRootOf(data),
+    ".tmp",
+    "grunt",
+    "sessions",
+    sid,
+  );
+  try {
+    fs.mkdirSync(dir, { recursive: true });
+  } catch {
+    return;
+  }
+  const wrote = countLines(path.join(dir, "wrote.txt"));
+  const read = countLines(path.join(dir, "read.txt"));
+  const first = firstNonEmptyStripped(msg).slice(0, 200);
+  const lines = [
+    first,
+    `${wrote} wrote, ${read} read.`,
+    `session=.tmp/grunt/sessions/${sid}/`,
+  ].filter(Boolean);
+  try {
+    fs.writeFileSync(path.join(dir, "receipt.txt"), lines.join("\n") + "\n");
+  } catch {
+    /* fail-open */
   }
-  return "";
 }
 
-export function isRecap(msg) {
-  return RECAP_TAG_RE.test(firstNonEmptyStripped(msg));
+function userPromptSubmit(data) {
+  const prompt = userPromptOf(data);
+  if (isHostStopBanner(prompt)) return 0;
+  unlinkStamp(data, "stop-block");
+  applySessionGateSlash(data, prompt);
+  const ctx = effectiveGruntContext(data);
+  if (!ctx) return 0;
+  emit({
+    hookSpecificOutput: {
+      hookEventName: "UserPromptSubmit",
+      additionalContext: ctx,
+    },
+  });
+  return 0;
 }
 
-/** Mid-turn wait must be exactly `[orchestrator]: wait grunt` (no leftover lines). */
 export function isWaitGruntExact(msg) {
   const nonempty = String(msg || "")
     .split("\n")
@@ -376,6 +353,23 @@ export function isWaitGruntExact(msg) {
   return nonempty[0].replace(/^[\s`*_>]+/, "") === WAIT_GRUNT;
 }
 
+export function hasStepAsk(msg) {
+  if (isWaitGruntExact(msg)) return true;
+  return String(msg || "")
+    .split("\n")
+    .map((l) => l.replace(/^[\s`*_>]+/, "").trim())
+    .filter(Boolean)
+    .some((l) => l.includes("?"));
+}
+
+function firstNonEmptyStripped(msg) {
+  for (const line of String(msg || "").split("\n")) {
+    if (!line.trim()) continue;
+    return line.replace(/^[\s`*_>]+/, "");
+  }
+  return "";
+}
+
 function payloadAssistantMessage(data) {
   if (!data || typeof data !== "object") return "";
   const camel = data.lastAssistantMessage;
@@ -463,44 +457,21 @@ function stop(data) {
   const reason = String(data.reason || "");
   if (reason && reason !== "end_turn") return 0;
 
-  // 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);
-    return 0;
-  }
-
   const payloadMsg = payloadAssistantMessage(data);
   let msg = payloadMsg;
   if (!msg) {
     const tp = data.transcript_path || data.transcriptPath || "";
     msg = lastAssistantFromTranscript(tp);
   }
-
-  const waitFirst = firstNonEmptyStripped(msg) === WAIT_GRUNT;
-  if (waitFirst && !isWaitGruntExact(msg)) {
-    // fall through to block — leftover lines not allowed on mid-turn wait
-  } else if (isRecap(msg)) {
-    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;
-  }
-  if (n >= MAX_STOP) {
+  writeSessionReceipt(data, msg);
+  if (isWaitGruntExact(msg)) return 0;
+  if (sessionGateOf(data) === "ask" && !hasStepAsk(msg)) {
+    let n = readStampInt(data, "stop-block");
+    if (n >= MAX_STOP) return 0;
+    writeStamp(data, "stop-block", String(n + 1));
+    emit({ decision: "block", reason: ASK_STOP_REASON });
     return 0;
   }
-  if (stopStamp) {
-    fs.mkdirSync(path.dirname(stopStamp), { recursive: true });
-    fs.writeFileSync(stopStamp, String(n + 1));
-  }
-  const reasonText = STOP_REASONS[Math.min(n, STOP_REASONS.length - 1)];
-  emit({ decision: "block", reason: reasonText });
   return 0;
 }
 
@@ -522,12 +493,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;
   }
@@ -547,6 +513,9 @@ function interceptNeed(data, hookEventName) {
           cwd: jobCwd || cwd,
           path: job.path,
           glob: job.glob,
+          stash: job.stash,
+          from: job.from,
+          to: job.to,
         });
       }
     } catch {
@@ -557,10 +526,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 +545,37 @@ 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 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 ||
@@ -587,21 +584,74 @@ function sessionIdOf(data) {
   );
 }
 
-/** Solo is a mode: never share a `default` stamp across sid-less sessions. */
-function soloStampPath(data) {
+function unlinkQuiet(p) {
+  if (!p) return;
+  try {
+    fs.unlinkSync(p);
+  } catch {
+    /* missing is fine */
+  }
+}
+
+function unlinkStamp(data, prefix) {
+  unlinkQuiet(stampPath(data, prefix));
+  unlinkQuiet(legacyStampPath(data, prefix));
+}
+
+function sessionGateStampPath(data, prefix) {
   const root = workspaceRootOf(data);
   const sid = sessionIdOf(data);
-  if (!root || !sid) return null;
-  return path.join(root, ORCHESTRATOR_LOGS_DIR, SOLO_STAMP + "-" + sid);
+  if (!root || !sid || sid === "default") return null;
+  return path.join(root, ORCHESTRATOR_LOGS_DIR, prefix + "-" + sid);
 }
 
-function unlinkQuiet(p) {
+function resolveSessionGateStamp(data) {
+  for (const prefix of [SESSION_GATE_STAMP, AUTO_ASK_STAMP]) {
+    const neu = sessionGateStampPath(data, prefix);
+    if (neu && fs.existsSync(neu)) return neu;
+    const old = path.join(
+      workspaceRootOf(data),
+      LEGACY_ORCHESTRATOR_LOGS_DIR,
+      prefix + "-" + sessionIdOf(data),
+    );
+    if (sessionIdOf(data) && fs.existsSync(old)) return old;
+  }
+  return null;
+}
+
+function applySessionGateSlash(data, prompt) {
+  let slash = "";
+  if (AUTO_RE.test(prompt)) slash = "auto";
+  else if (ASK_RE.test(prompt)) slash = "ask";
+  if (!slash) return;
+  const p = sessionGateStampPath(data, SESSION_GATE_STAMP);
   if (!p) return;
+  unlinkQuiet(sessionGateStampPath(data, AUTO_ASK_STAMP));
+  if (slash === "auto") {
+    unlinkQuiet(p);
+    return;
+  }
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+  fs.writeFileSync(p, slash);
+}
+
+export function sessionGateOf(data) {
   try {
-    fs.unlinkSync(p);
+    const p = resolveSessionGateStamp(data);
+    if (p) {
+      const body = fs.readFileSync(p, "utf8").trim();
+      if (body === "auto" || body === "ask") return body;
+    }
   } catch {
-    // missing is fine
+    /* fall through */
   }
+  return "auto";
+}
+
+export function effectiveGruntContext(data) {
+  const gate = sessionGateOf(data);
+  const receipt = sessionReceiptContext(data);
+  return receipt ? `sessionGate=${gate}. ${receipt}` : `sessionGate=${gate}`;
 }
 
 function eventKey(s) {