@lovrozagar/grunt 0.1.0

package/.grok/hooks/rtk-grok.js

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+/** Grok PreToolUse: rewrite Bash/run_terminal_command through `rtk rewrite`.
+
+Fail-open: parse error, missing rtk, timeout, no rewrite → empty stdout, exit 0.
+Keep the full toolInput (Grok needs `description`); only replace `command`.
+*/
+"use strict";
+
+const { spawnSync } = require("node:child_process");
+
+const RTK_TIMEOUT_MS = 3000;
+
+const ULTRA_SUBS = new Set([
+  "grep",
+  "rg",
+  "curl",
+  "wget",
+  "vitest",
+  "jest",
+  "pytest",
+  "test",
+  "lint",
+  "tsc",
+  "npm",
+  "npx",
+  "read",
+  "find",
+  "diff",
+  "json",
+  "log",
+  "playwright",
+  "cargo",
+  "ruff",
+  "prettier",
+  "format",
+]);
+
+function main() {
+  try {
+    const data = readJsonValue();
+    if (data === undefined) return 0;
+    if (!data || typeof data !== "object" || Array.isArray(data)) return 0;
+    let toolInput = data.toolInput;
+    if (toolInput == null) toolInput = data.tool_input;
+    if (!toolInput || typeof toolInput !== "object" || Array.isArray(toolInput)) return 0;
+    const cmdRaw = toolInput.command;
+    if (typeof cmdRaw !== "string") return 0;
+    const cmd = cmdRaw.trim();
+    if (!cmd) return 0;
+
+    const first = cmd.split(/\s+/, 1)[0] || "";
+    const already = first === "rtk" || first.endsWith("/rtk");
+    let rewritten;
+    if (already) {
+      rewritten = injectUltra(cmd);
+      if (rewritten === cmd) return 0;
+    } else {
+      rewritten = rewrite(cmd);
+      if (!rewritten) return 0;
+    }
+
+    const updated = Object.assign({}, toolInput, { command: rewritten });
+    process.stdout.write(
+      JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: "PreToolUse",
+          permissionDecisionReason: "RTK auto-rewrite",
+          updatedInput: updated,
+        },
+      }),
+    );
+    return 0;
+  } catch {
+    return 0;
+  }
+}
+
+function injectUltra(rewritten) {
+  if (rewritten.includes("--ultra-compact")) return rewritten;
+  const m = rewritten.match(/^(\S+)\s+(\S+)(?:\s+([\s\S]*))?$/);
+  if (!m || m[1] !== "rtk") return rewritten;
+  if (!ULTRA_SUBS.has(m[2])) return rewritten;
+  const rest = m[3] || "";
+  return "rtk " + m[2] + " --ultra-compact" + (rest ? " " + rest : "");
+}
+
+function whichRtk() {
+  const rtk = spawnSync("sh", ["-c", "command -v rtk"], { encoding: "utf8" });
+  const path = (rtk.stdout || "").trim();
+  return path || null;
+}
+
+function rewrite(cmd) {
+  const rtk = whichRtk();
+  if (!rtk) return null;
+  try {
+    const proc = spawnSync(rtk, ["rewrite", "--ultra-compact", cmd], {
+      encoding: "utf8",
+      timeout: RTK_TIMEOUT_MS,
+    });
+    const out = (proc.stdout || "").trim();
+    if (!out || out === cmd) return null;
+    return injectUltra(out);
+  } catch {
+    return null;
+  }
+}
+
+/** Read one JSON value (Python json.load): stop when parseable, do not wait for EOF. */
+function readJsonValue() {
+  const fs = require("node:fs");
+  let buf = Buffer.alloc(0);
+  const tmp = Buffer.alloc(8192);
+  for (;;) {
+    let n;
+    try {
+      n = fs.readSync(0, tmp, 0, tmp.length, null);
+    } catch {
+      break;
+    }
+    if (n === 0) break;
+    buf = Buffer.concat([buf, tmp.subarray(0, n)]);
+    try {
+      return JSON.parse(buf.toString("utf8"));
+    } catch {
+      // incomplete
+    }
+  }
+  if (!buf.length) return undefined;
+  try {
+    return JSON.parse(buf.toString("utf8"));
+  } catch {
+    return undefined;
+  }
+}
+
+process.exit(main());

package/.grok/hooks/rtk.json

@@ -0,0 +1,16 @@
+{
+  "hooks": {
+    "PreToolUse": [
+      {
+        "matcher": "Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"$GROK_WORKSPACE_ROOT/.grok/hooks/rtk-grok.js\"",
+            "timeout": 5
+          }
+        ]
+      }
+    ]
+  }
+}

package/.grok/hooks/rulesync.json

@@ -0,0 +1,3 @@
+{
+  "hooks": {}
+}

package/.grok/parent.md

@@ -0,0 +1 @@
+SSOT: `.grok/agents/orchestrator.md` (`[agent] name = "orchestrator"`).

package/.grok/roles/grunt.toml

@@ -0,0 +1,5 @@
+description = "Low reasoning role"
+default_capability_mode = "all"
+reasoning_effort = "low"
+model = "grok-4.5"
+default_fork_context = false

package/.grok/roles/implementer.toml

@@ -0,0 +1,5 @@
+description = "Medium reasoning role"
+default_capability_mode = "all"
+reasoning_effort = "medium"
+model = "grok-4.6"
+default_fork_context = false

package/.grok/roles/thinker.toml

@@ -0,0 +1,5 @@
+description = "Deep reasoner role"
+default_capability_mode = "read-only"
+reasoning_effort = "high"
+model = "grok-4.6"
+default_fork_context = false

package/.grok/skills/explain/SKILL.md

@@ -0,0 +1,15 @@
+---
+name: explain
+description: >
+  One-off human explanation. Use for /explain, "explain this", or a request
+  to explain for a human. Not a session mode. Escape superterse for this
+  reply only, then revert.
+---
+
+This reply only: explain for a human. Not a mode switch or session flag. After this reply, revert to maximal superterse automatically.
+
+Still concise. Complete sentences OK. Prioritize clarity over token compression. Do not dump, sprawl, or narrate process.
+
+en-US unless asked. Keep need:/verdict:/plan grammar when those apply.
+
+This skill is the only one-off escape from superterse.

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

@@ -0,0 +1,91 @@
+---
+name: implement-plan
+description: >
+  Implementer executes a local .tmp/plans checklist by serial, marks [x],
+  skips completed leaves. Use to implement/continue a written local plan
+  or /implement-plan. Not /implement review-loop, not /execute-plan PR DAG.
+when-to-use: >
+  Use when asked to "implement plan", "run plan N", "continue plan",
+  "execute the checklist", or "/implement-plan".
+argument-hint: "<plan_id_serial>"
+---
+
+# implement-plan
+
+Resolve serial (cheap-in-parent) → spawn implementer → parent verifies boxes. Format: `../shared/plan-format.md` — read it; do not paste.
+
+## Invocation
+
+`/implement-plan <serial>`
+
+Todos: `resolve` → `implement` → `verify`. One serial per run. Partial progress is ok; re-run continues.
+
+## Resolve serial (no spawn)
+
+Arg = `$ARGUMENTS` stripped.
+
+| input | action |
+|---|---|
+| empty | list `.tmp/plans/*.md` as `serial slug status` (read frontmatter `status` if cheap; else filename). Stop: `need serial. have: ...` |
+| int (`1`, `0001`) | files whose leading number == that int |
+| `{serial}-slug` or `*.md` or path | that file if under `.tmp/plans/` |
+| slug only (`add-auth`) | unique match `*-{slug}-*.md` or `*-{slug}.md` |
+| `.tmp/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 spawn** |
+
+Lookup: integer equality so `1` matches canonical `1-foo-20260826T143000Z.md` and legacy `1-foo.md`. `0001-foo.md` may still resolve if an old padded file exists. Normalize to abs path + int serial.
+
+Gather listed plan-leaf absolute paths plus prefetch `verdict:` blobs before the up-spawn (search|exec via parent grunt-job). Do not `resume_from` for dumps already listed in the plan leaves. Do not add a repo-wide explore. Then spawn.
+
+## Read format
+
+`read_file` `{repo}/.grok/skills/shared/plan-format.md`.
+
+## Spawn implementer
+
+`subagent_type: implementer`, `background: true`, omit `model`, `isolation: none`, `description: "implement plan {serial}"`.
+
+Prompt:
+
+```
+You are implementer subagent. Do not spawn.
+
+Read {abs}/.grok/skills/shared/plan-format.md and the plan at {abs_plan_path}.
+
+Implement remaining `[ ]` leaves in numeric order. Skip `[x]`.
+After each leaf: flip that line to `[x]` in the plan file (only the box).
+When a phase's children are all `[x]`, mark the phase `[x]`.
+Frontmatter status: in-progress at start; done when all boxes `[x]`; blocked if you cannot finish.
+Do not expand scope, add steps, or start a review loop.
+If blocked: leave remaining `[ ]`, status: blocked, report reason + leftover ids.
+Run Verify leaves. Report abs paths you changed.
+```
+
+Wait. Spawn fail → `[implementer]: failed: {err}` stop.
+
+## Parent verify (cheap 1-file)
+
+Grep plan for `\[ \]` vs `\[x\]` (and `[X]`).
+
+```
+[implementer]: serial={int} path=.tmp/plans/{file} status={status} done={x}/{total}
+files: {abs paths}
+{if leftover:}
+leftover:
+{up to 10 open leaf lines}
+{if blocked:} blocked: {reason}
+```
+
+## Rules
+
+- Skip `[x]`; only flip boxes; no renumber/rewrite leaf text.
+- No review-fix loop. Not bundled `/implement`.
+- 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.`
+- Child prompt = task + abs paths + verdicts only (no pasted transcripts).
+- Resume prompt = `You are implementer subagent.` + new verdicts only. Do not re-send the original task. Max 3 `resume_from` per child id; then report blocked/partial.
+- Tool-call first for spawn claims.
+- Do not re-plan. Partial = skill success (plan file is SoT).

package/.grok/skills/parent/SKILL.md

@@ -0,0 +1,12 @@
+---
+name: parent
+description: >
+  One-turn parent-orchestrator escape. Use for /parent when this turn
+  must complete in-parent. Not a session mode.
+---
+
+This turn only: parent may finish in-session. Not a mode. After this reply, Stop enforcement resumes.
+
+`/parent` writes `parent-escape-{sid}` (Stop consume+unlink once). Protocol: `.rulesync/reference/cascade.md`. Do not paste cascade here.
+
+Do not stay in-parent after this reply. Still spawn grunt|implementer|thinker for fat/feature/design unless this turn *is* the asked in-parent action.

package/.grok/skills/shared/plan-format.md

@@ -0,0 +1,158 @@
+# Plan format (SSOT)
+
+Local implementer checklist. Not a design doc, PR stack, or DAG.
+
+## Path
+
+`.tmp/plans/{serial}-{slug}-{YYYYMMDDTHHMMSSZ}.md`
+
+- **serial:** unpadded decimal int only (`1`, `12`, `10000`). **Never** `0001`, never quoted `"0001"` / `"1"`. Serial ≥ 1.
+- **filename:** unpadded serial, slug, UTC datetime stamp (`6-sync-global-settings-20260826T143000Z.md`, not `0001-slug.md`). Stamp is `created` with `-` and `:` dropped (keep `T` and `Z`).
+- **lookup:** integer equality on leading digits (`1` matches `1-foo-20260826T143000Z.md` and legacy `1-foo.md`; also `0001-foo.md` if an old padded file still exists).
+- **valid filename (new):** `^[0-9]+-[a-z0-9]+(-[a-z0-9]+)*-\d{8}T\d{6}Z\.md$`
+- **valid filename (legacy):** `^[0-9]+-[a-z0-9]+(-[a-z0-9]+)*\.md$` (no stamp; still accepted for existing files)
+- Frontmatter line must match `^serial: [1-9][0-9]*$`. Leading zeros are invalid (YAML octal / VS Code warning).
+- **New writes** always use the stamped filename. Collision: increment serial, rebuild filename, same stamp.
+
+## Slugify (`PLAN_NAME`)
+
+1. lower
+2. non `[a-z0-9]` → `-`
+3. collapse `-`, strip edges
+4. trim to 50 chars; if cut on `-`, strip trailing `-`
+5. empty → `unnamed`
+6. strip trailing `.lock` if any
+
+## Allocate next serial (grunt, bash)
+
+```bash
+mkdir -p .tmp/plans
+next=1
+for f in .tmp/plans/*; do
+  [ -f "$f" ] || continue
+  b=$(basename "$f")
+  case "$b" in
+    [0-9]*.md) n=${b%%-*}; n=$((10#$n)); [ "$n" -ge "$next" ] && next=$((n+1));;
+  esac
+done
+# filename prefix: unpadded decimal "$next" (1, 12, 10000)
+```
+
+Collision: if target path exists, increment and retry (max 5).
+
+## Frontmatter (required)
+
+```yaml
+---
+serial: 1
+name: add-auth
+status: ready          # ready | in-progress | done | blocked
+created: 2026-08-26T14:30:00Z    # UTC ISO-8601 seconds + Z; no milliseconds
+source: "<≤120 chars of user task>"
+---
+```
+
+`name` is the slug only (no datetime). `source` ≤120 chars.
+
+`created` for **new writes:** `new Date().toISOString()` with milliseconds stripped (`.\d{3}Z` → `Z`), e.g. `2026-08-26T14:30:00Z`. Existing files may still have `created: YYYY-MM-DD`.
+
+### Status machine
+
+`ready` → `in-progress` → `done` | `blocked`
+
+- Fresh write: `ready`
+- Implement start: `in-progress`
+- All boxes `[x]`: `done`
+- Cannot finish: `blocked` (leave remaining `[ ]`)
+
+## Body headings (this order only)
+
+`# {slug}`, `## Goal`, `## Context`, `## Constraints`, `## Watch-outs`, `## Steps`, `## Verify`
+
+No other `##` headings. No PR Plan, Key Decisions, or DAG.
+
+## Checkbox grammar
+
+- Open: `[ ]` (space in box required)
+- Done: `[x]` (accept `[X]`, write `[x]`)
+- Line: `^{id} [ ] {text}$` with optional 0–2 space indent
+- `{id}` = `N` / `N.M` / `N.M.K` (digits + dots). **Not** `1. [ ]`. **Not** GitHub `- [ ]`
+- Fresh plans: all `[ ]`, never `[x]`
+- Marking done: only flip the box. No renumber, delete, or rewrite leaf text
+- Depth 2 default (`N` phase + `N.M` leaf). 3rd level only if a leaf would itself be a mini-plan
+- Every phase `N` has ≥1 leaf `N.M`. Implementer **executes leaves**. Roll up: all children `[x]` ⇒ parent `[x]`
+- Verify = last numbered phase, same grammar
+- Done plan: every checkbox `[x]`, `status: done`
+
+## Prose vs steps
+
+| Section | Amount |
+|---|---|
+| Goal | 1–3 sentences. What “done” means. |
+| Context / Constraints / Watch-outs | bullets only. Watch-outs: non-obvious footguns; empty allowed (`(none)`). |
+| Steps | bulk of the file; each leaf = one coherent edit or one file-level action |
+| Verify | 1–5 runnable leaves (cmd or observable) |
+
+Thinker cites **absolute paths**. Leaves must be implementable without re-planning. Product fork → pick the narrowest default, state it under Constraints, still emit steps.
+
+## Validation checklist
+
+- filename matches new stamped regex or legacy unstamped; new writes unpadded + stamp (`1-foo-20260826T143000Z.md` not `0001-foo.md`); serial int equals leading digits; `name` equals slug after stripping optional trailing `-\d{8}T\d{6}Z`
+- frontmatter `serial` line matches `^serial: [1-9][0-9]*$` (unpadded decimal ≥ 1; reject `0001`, `"0001"`, `0`, `01`)
+- frontmatter keys: `serial`, `name`, `status`, `created`, `source`
+- `status` ∈ `ready` | `in-progress` | `done` | `blocked`; `created` `YYYY-MM-DDTHH:MM:SSZ` (new writes) or legacy `YYYY-MM-DD`; `source` ≤120
+- headings in order only; no extra `##`
+- ≥1 `N.M [ ]` leaf; every phase has ≥1 leaf; Verify is last numbered phase
+- checkbox grammar (`N [ ]` / `N.M [ ]` / `N.M.K [ ]`); no `- [ ]`; no `1. [ ]`
+- fresh write: zero `[x]` / `[X]`; Goal 1–3 sentences; Context/Constraints/Watch-outs bullets; Verify 1–5 leaves
+
+## Worked example
+
+File: `.tmp/plans/1-add-tmp-ignore-20260826T143000Z.md`
+
+```markdown
+---
+serial: 1
+name: add-tmp-ignore
+status: ready
+created: 2026-08-26T14:30:00Z
+source: "gitignore .tmp so local plans stay untracked"
+---
+
+# add-tmp-ignore
+
+## Goal
+Repo `.gitignore` ignores `.tmp/` so files under `.tmp/plans/` stay untracked. Existing ignore entries stay.
+
+## Context
+- `/home/ecomet/Development/example-app/.gitignore` may be missing or lack `.tmp/`
+- Plans live at `/home/ecomet/Development/example-app/.tmp/plans/`
+- No python helpers; bash only
+
+## Constraints
+- Do not clobber other `.gitignore` lines
+- Do not create sample plans under `.tmp/plans` for git
+- Do not edit `AGENTS.md`
+
+## Watch-outs
+- Duplicate `.tmp/` if append without grep
+- Use directory form `.tmp/`, not `.tmp`
+
+## Steps
+1 [ ] gitignore
+1.1 [ ] read `/home/ecomet/Development/example-app/.gitignore` if it exists
+1.2 [ ] create `/home/ecomet/Development/example-app/.gitignore` when missing, body `.tmp/`
+1.3 [ ] append `.tmp/` to `/home/ecomet/Development/example-app/.gitignore` if the line is absent
+2 [ ] plans dir
+2.1 [ ] mkdir -p `/home/ecomet/Development/example-app/.tmp/plans`
+2.2 [ ] confirm the dir exists; do not add a sample `*.md` under it
+3 [ ] sanity
+3.1 [ ] grep `^\.tmp/` in `/home/ecomet/Development/example-app/.gitignore`
+3.2 [ ] confirm no extra hunks in that file besides the ignore line
+3.3 [ ] `git check-ignore -v /home/ecomet/Development/example-app/.tmp/plans` from repo root
+
+## Verify
+4 [ ] Verify
+4.1 [ ] `git check-ignore -v .tmp/plans` reports ignored
+4.2 [ ] `git status --short -- .gitignore` shows only the ignore edit
+```

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

@@ -0,0 +1,84 @@
+---
+name: write-plan
+description: >
+  Thinker drafts a local implementer-ready checklist plan; parent Write
+  persists .tmp/plans/{serial}-{slug}-{YYYYMMDDTHHMMSSZ}.md. Use for a numbered local plan, checklist
+  for implementer, "write a plan", or /write-plan. Not a design doc or PR stack.
+when-to-use: >
+  Use when asked to "write a plan", "make a checklist plan",
+  "plan this for implementer", or "/write-plan".
+argument-hint: "<task or context>"
+---
+
+# write-plan
+
+Parent orchestrates thinker then persists via Write under `.tmp/plans/`. Parent does not author the plan body. Format: `../shared/plan-format.md` — read it; do not paste.
+
+## Invocation
+
+`/write-plan <task>`
+
+Optional todos: `think` → `write` → `report`. Always a new serial.
+
+## Cheap-in-parent (no spawn)
+
+Empty `$ARGUMENTS` **and** no task in conversation → `need task` and stop. Do not list the repo.
+
+## Read format
+
+`read_file` `{repo}/.grok/skills/shared/plan-format.md` (`dirname(SKILL.md)/../shared/plan-format.md`).
+
+Gather the listed plan-format/SSOT absolute paths before the up-spawn. Prefetch search|exec via parent `node scripts/grunt-job.mjs` (not LLM grunt spawn). Do not `need:` for paths already listed.
+
+## Step 1 — thinker
+
+Spawn `subagent_type: thinker`, `background: true`, omit `model`, `description: "write plan"`.
+
+Prompt:
+
+```
+You are thinker subagent. Read-only. Do not write files. Do not spawn.
+
+Read {abs}/.grok/skills/shared/plan-format.md. Produce a plan that matches it.
+
+Task:
+{full $ARGUMENTS + relevant conversation context}
+
+Cite absolute paths. Use only listed abs paths plus prefetch `verdict:` blobs. Do not explore the repo. Narrowest change that solves the task.
+
+Output rules:
+- Line 1: PLAN_NAME: <3-6 word name>
+- Then the plan body only: # heading, Goal, Context, Constraints, Watch-outs, Steps, Verify
+- All boxes [ ]
+- No preamble, no summary, no extra sections
+- Final message IS the plan (parent persists it verbatim)
+```
+
+Wait. Fail → `[thinker]: failed: {err}` stop.
+
+**Truncation:** if output lacks `PLAN_NAME:` or has no `N.M [ ]` leaf, resume once (`resume_from`). Resume prompt = `You are thinker subagent.` plus the new instruction only (do not re-send the original task). Still bad → stop, no write. Max 3 `resume_from` per child id.
+
+## Step 2 — persist (parent Write)
+
+No grunt spawn. Parent `write`s the thinker final message under `{repo}/.tmp/plans/` (any filename in that dir). `orchestrate-parent.js` runs `scripts/persist-plan.mjs`: serial/slug from `PLAN_NAME:` / heading, inject YAML, rewrite path+content. Deny invalid plans and any write outside `.tmp/plans/`.
+
+Report serial/path from the tool result (`updatedInput.file_path`). Fail/deny → `[write-plan]: failed: {err}` stop.
+
+## Report
+
+```
+[thinker]: {one-line goal}; {N} leaves
+[write-plan]: serial={int} path=.tmp/plans/{serial}-{slug}-{YYYYMMDDTHHMMSSZ}.md
+next: /implement-plan {int}
+```
+
+Do not dump the plan.
+
+## Rules
+
+- Omit `model`. `subagent_type` ∈ {grunt, implementer, thinker} only (thinker for draft).
+- First prompt sentence: `You are {agent} subagent.`
+- Child prompt = task + abs paths + verdicts only (no pasted transcripts).
+- Parent coordinates; parent Write under `.tmp/plans/` only; thinker never writes.
+- Not `/design`, not `/execute-plan`, not a design doc.
+- Tool-call first: emit `spawn_subagent` in the same turn as any spawn claim. Past tense after the tool result.

package/.mcp.json

@@ -0,0 +1,3 @@
+{
+  "mcpServers": {}
+}

package/.rulesync/global-settings/antigravity.json

@@ -0,0 +1 @@
+{}

package/.rulesync/global-settings/claude.json

@@ -0,0 +1 @@
+{}

package/.rulesync/global-settings/codex.toml

@@ -0,0 +1 @@
+# reserved: noop / project-only

package/.rulesync/global-settings/manifest.json

@@ -0,0 +1,37 @@
+{
+  "version": 1,
+  "skipKeyPattern": "^(secrets?|api[_-]?key|access[_-]?token|tokens?|passwords?|authorization|mcp(servers)?|hooks)$",
+  "hosts": [
+    {
+      "id": "grok",
+      "mode": "merge",
+      "format": "toml",
+      "payload": ".grok/global-settings.toml",
+      "dest": ".grok/config.toml"
+    },
+    {
+      "id": "claude",
+      "mode": "noop",
+      "scope": "project-only",
+      "format": "json",
+      "payload": ".rulesync/global-settings/claude.json",
+      "dest": null
+    },
+    {
+      "id": "codex",
+      "mode": "noop",
+      "scope": "project-only",
+      "format": "toml",
+      "payload": ".rulesync/global-settings/codex.toml",
+      "dest": null
+    },
+    {
+      "id": "antigravity",
+      "mode": "noop",
+      "scope": "project-only",
+      "format": "json",
+      "payload": ".rulesync/global-settings/antigravity.json",
+      "dest": null
+    }
+  ]
+}

package/.rulesync/hooks.jsonc

@@ -0,0 +1,22 @@
+{
+  "version": 1,
+  "hooks": {
+    // Claude / Codex / Antigravity only (generate -t omits grokcli for hooks).
+    // Grok spawn/fat SSOT is hand-placed .grok/hooks/orchestrate-parent.js + orchestrate-parent.json.
+    "preToolUse": [
+      {
+        "matcher": "spawn_subagent|Task|Agent|spawn_agent",
+        "type": "command",
+        "command": "node \"${GROK_WORKSPACE_ROOT:-${CLAUDE_PROJECT_DIR:-.}}/scripts/scrub-spawn-prompt.mjs\"",
+        "timeout": 5
+      },
+      {
+        // Fat Read/Grep/Glob/Bash: inject limits, path denylist, implementer dump deny.
+        "matcher": "Read|read_file|Grep|grep|Glob|list_dir|Bash|run_terminal_command",
+        "type": "command",
+        "command": "node \"${GROK_WORKSPACE_ROOT:-${CLAUDE_PROJECT_DIR:-.}}/scripts/gate-fat-tools.mjs\"",
+        "timeout": 5
+      }
+    ]
+  }
+}

package/.rulesync/mcp-policy.jsonc

@@ -0,0 +1,15 @@
+// MCP deny-default SSOT. Named allow is empty this pass; do not add cloudflare/docker.
+{
+  "default": "deny",
+  "allow": [],
+  "plugins": {
+    "denyDefault": true
+  },
+  "servers": {},
+  "agents": {
+    "orchestrator": { "inherit": false },
+    "implementer": { "inherit": false },
+    "thinker": { "inherit": false },
+    "grunt": { "inherit": false }
+  }
+}