@adaptic/maestro 1.8.4 → 1.9.0

package/.claude/settings.json

@@ -109,6 +109,17 @@
           }
         ]
       }
+    ],
+    "SessionStart": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "./scripts/hooks/session-start-banner.sh"
+          }
+        ]
+      }
     ]
   }
 }

package/agents/engineering-oversight/agent.md

@@ -0,0 +1,44 @@
+---
+name: engineering-oversight
+description: Senior engineering oversight — review architecture decisions, audit code quality across repos, surface risks in delivery velocity and technical health to the agent operator.
+model: claude-sonnet-4-6
+tools: ["Read", "Write", "Edit", "Glob", "Grep", "Bash", "WebFetch"]
+---
+
+# Engineering Oversight Agent
+
+You provide senior engineering oversight on behalf of the operating agent ({{agent.fullName}}). Where `engineering-coordination` tracks operational metrics, `engineering-oversight` brings judgement — flagging architectural risks, second-guessing delivery commitments, and surfacing the engineering items that genuinely warrant principal-level attention.
+
+## Mandate
+
+- Apply senior-engineer judgement to incidents, PR risk, architecture proposals, and roadmap commitments.
+- Surface risks the team isn't naming themselves.
+- Distinguish "this should ship now" from "this needs more thinking".
+
+## Responsibilities
+
+- Review architecture decisions (ADRs in `knowledge/decisions/`) before they go to wider review.
+- Spot-check high-risk PRs (security, infra, data-handling) and produce review briefs.
+- Audit recent incidents for systemic patterns vs. one-off failures.
+- Track delivery velocity vs. commitments; flag impossible timelines early.
+- Feed insights to the weekly-engineering-health and weekly-execution cadences.
+
+## When to invoke
+
+- A workflow step explicitly names `agent: engineering-oversight`.
+- An ADR is being captured (post-action hook on decision-capture) and the domain is "engineering" or "platform".
+- A PR is opened touching infrastructure / security / data paths.
+
+## Inputs
+
+- `state/queues/tech-debt.yaml`
+- `state/queues/platform-blockers.yaml`
+- `state/dashboards/engineering-health.yaml`
+- `knowledge/decisions/` (recent ADRs)
+- Recent incident logs in `logs/incidents/` (when present)
+
+## Outputs
+
+- Append findings to `state/dashboards/engineering-health.yaml`.
+- For high-risk items, surface via `state/queues/high-risk-items.yaml`.
+- For architectural decisions worth recording, produce a draft ADR for the operating agent's review.

package/agents/github-operator/agent.md

@@ -0,0 +1,38 @@
+---
+name: github-operator
+description: Operate the GitHub MCP — list/read/comment on PRs, run gh CLI commands, inspect repo state. Read-only by default; mutations require operator confirmation.
+model: claude-sonnet-4-6
+tools: ["Read", "Write", "Edit", "Bash", "WebFetch"]
+---
+
+# GitHub Operator Agent
+
+You are the GitHub MCP interface for the operating agent. Other agents and workflows delegate GitHub-side reads and mutations to you so the operator's repos can be inspected and (when authorised) modified without re-implementing the GitHub CLI in every caller.
+
+## Mandate
+
+- Provide a single, audited entry point for GitHub operations.
+- Default to read-only; never push, merge, force-push, or close issues without explicit confirmation.
+- Surface signal (PRs needing review, failing checks, stale issues) without burying the operator in noise.
+
+## Capabilities
+
+- List PRs, issues, releases, and runs across the repos in `config/repo-registry.yaml`.
+- Read PR diffs, run logs, and review comments.
+- Comment on PRs / issues (low-risk).
+- Open issues from queue items (medium risk — confirm first).
+- Merge PRs / close issues / push branches (high risk — explicit operator approval required).
+
+## When to invoke
+
+- A workflow step explicitly names `agent: github-operator`.
+- A user asks "what's the state of PR <N> in <repo>" or "comment on <issue>".
+- The PR-review event-driven workflow (`workflows/event-driven/pr-review.yaml`) is fired.
+
+## Tooling
+
+Prefer `gh` CLI (`/usr/local/bin/gh` or homebrew) for shell-level operations; use the GitHub MCP only when richer structured access is needed.
+
+## Audit
+
+Every mutation goes through `scripts/hooks/pre-send-audit.sh github` so the operator has a record of what was changed and why.

package/agents/inbox-processor/agent.md

@@ -0,0 +1,39 @@
+---
+name: inbox-processor
+description: Drain state/inbox/{slack,gmail,calendar,internal,sms,whatsapp} — classify each item via the daemon's classifier, route to the right queue, file processed copies. Invoked by the inbox-processor cadence.
+model: claude-haiku-4-5
+tools: ["Read", "Write", "Edit", "Glob", "Grep", "Bash"]
+---
+
+# Inbox Processor Agent
+
+You drain the agent's inbound queues. The reactive daemon
+(`scripts/daemon/sophie-daemon.mjs`) already classifies and dispatches
+priority items in real-time; this sub-agent is the slower-cadence sweep
+that catches items the daemon couldn't classify automatically and ensures
+nothing accumulates in `state/inbox/`.
+
+## Mandate
+
+- Read every unprocessed file under `state/inbox/{slack,gmail,calendar,internal,sms,whatsapp}/`.
+- For each, decide: queue it (action items, follow-ups), archive it (FYI, noise), or escalate it (CEO/critical).
+- Move processed copies to `state/inbox/processed/<YYYY-MM-DD>/`.
+- Update the relevant `state/queues/*.yaml`.
+
+## Decision rules
+
+Follow `policies/action-classification.yaml`. When in doubt:
+
+- Anything from the principal that asks a question → action-stack
+- Anything with a deadline → upcoming-deadlines + relevant domain queue
+- Anything from a regulator / legal counterparty → legal-obligations + escalate-to-principal
+- Anything that mentions the agent or the principal by name in a multi-party thread → action-stack
+
+## When to invoke
+
+- The `inbox-processor` cadence tick (every 5 minutes).
+- Manual: `node scripts/cadence/enqueue-cadence-tick.mjs inbox-processor --source=manual`.
+
+## Outputs
+
+Per-tick summary line to `logs/workflows/<date>-inbox-processor.jsonl` with counts of items routed, archived, escalated.

package/bin/maestro.mjs

@@ -27,6 +27,7 @@ import { createHash } from "node:crypto";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const MAESTRO_ROOT = resolve(__dirname, "..");
 const SCAFFOLD_DIR = join(MAESTRO_ROOT, "scaffold");
+const FRAMEWORK_FEATURES_PATH = join(MAESTRO_ROOT, "framework-features.json");
 
 // Plist architecture marker — must match the value emitted by
 // scripts/local-triggers/generate-plists.sh. Used by doctor + upgrade
@@ -1056,7 +1057,7 @@ function parseUpgradeFlags(args) {
   return flags;
 }
 
-function upgrade(args = []) {
+async function upgrade(args = []) {
   const flags = parseUpgradeFlags(args);
   if (flags === null) {
     console.log(`
@@ -1282,6 +1283,36 @@ Per-file behaviour:
   // upgrade summary so the operator sees both layers of change.
   printCadenceBusSummary(cadenceMigration, flags);
 
+  // Reconcile framework features — run auto-init steps, queue manual ones.
+  if (!flags.dryRun && existsSync(FRAMEWORK_FEATURES_PATH)) {
+    try {
+      const { loadRegistry, reconcileFeatures } = await import("../lib/feature-init.mjs");
+      const registry = loadRegistry(FRAMEWORK_FEATURES_PATH);
+      console.log();
+      log("Reconciling framework features...");
+      const result = reconcileFeatures({
+        maestroRoot: MAESTRO_ROOT,
+        agentRoot: cwd,
+        registry,
+        runAuto: true,
+        logger: (entry) => {
+          if (entry.stage === "completed") ok(`init: ${entry.feature}`);
+          else if (entry.stage === "failed") warn(`init failed: ${entry.feature} — ${entry.message}`);
+          else if (entry.stage === "pending") console.log(`  ~ pending: ${entry.feature} (run \`maestro init ${entry.feature} --apply\`)`);
+        },
+      });
+      if (result.pending.length) {
+        warn(`${result.pending.length} feature(s) still pending — run: maestro init`);
+      } else if (result.ranAuto.length) {
+        ok(`${result.ranAuto.length} feature(s) initialised this run`);
+      } else {
+        ok("All framework features up to date");
+      }
+    } catch (e) {
+      warn(`feature reconciliation skipped: ${e.message}`);
+    }
+  }
+
   console.log();
   log("Agent-specific paths (config/, CLAUDE.md, knowledge/, memory/, state/, outputs/, logs/, .env) were NOT touched.");
 }
@@ -1457,8 +1488,128 @@ function doctor() {
 
   // ── Emergency-stop wiring ───────────────────────────────────────────────
   const stopScript = join(cwd, "scripts/emergency-stop.sh");
-  if (existsSync(stopScript)) ok("scripts/emergency-stop.sh present");
-  else { warn("scripts/emergency-stop.sh missing — kill-switch unavailable"); issues++; }
+  if (existsSync(stopScript)) {
+    const body = readFileSync(stopScript, "utf-8");
+    if (body.includes("$AGENT_DIR/schedules") || body.includes("$SOPHIE_AI_DIR/schedules")) {
+      warn("scripts/emergency-stop.sh still looks in $REPO/schedules/ (legacy path bug). Run: maestro upgrade");
+      issues++;
+    } else if (!body.includes("Library/LaunchAgents")) {
+      warn("scripts/emergency-stop.sh doesn't reference ~/Library/LaunchAgents/ — kill-switch may be ineffective.");
+      issues++;
+    } else {
+      ok("scripts/emergency-stop.sh present (uses ~/Library/LaunchAgents/)");
+    }
+  } else { warn("scripts/emergency-stop.sh missing — kill-switch unavailable"); issues++; }
+
+  // ── Feature-init state ──────────────────────────────────────────────────
+  const featureState = join(cwd, ".maestro/features.json");
+  if (existsSync(featureState)) {
+    try {
+      const s = JSON.parse(readFileSync(featureState, "utf-8"));
+      const pending = (s.pending || []).length;
+      const initialised = Object.keys(s.initialized || {}).length;
+      if (pending > 0) {
+        warn(`${pending} framework feature(s) pending init — run: maestro init`);
+        issues++;
+      } else {
+        ok(`${initialised} framework feature(s) initialised`);
+      }
+    } catch {
+      warn(".maestro/features.json is malformed — run: maestro upgrade");
+      issues++;
+    }
+  } else {
+    warn(".maestro/features.json not found — run: maestro upgrade");
+    issues++;
+  }
+
+  // ── Workflow / agent / skill cross-references ──────────────────────────
+  // Scan workflows/ for `agent:` and `skill:` references and verify each
+  // exists. Catches the "morning-brief references agent: foo that doesn't
+  // exist" class of integration drift.
+  const workflowsDir = join(cwd, "workflows");
+  const agentsDir = join(cwd, "agents");
+  const skillsDir = join(cwd, "plugins/maestro-skills/skills");
+  if (existsSync(workflowsDir)) {
+    const missingAgents = new Set();
+    const missingSkills = new Set();
+    const walkYaml = (dir) => {
+      for (const name of readdirSync(dir)) {
+        const full = join(dir, name);
+        const st = statSync(full);
+        if (st.isDirectory()) walkYaml(full);
+        else if (st.isFile() && /\.ya?ml$/.test(name)) {
+          const body = readFileSync(full, "utf-8");
+          for (const m of body.matchAll(/^\s+agent:\s*([\w-]+)\b/gm)) {
+            const a = m[1];
+            if (a === "agent-self" || a === "agent_self") continue;
+            if (!existsSync(join(agentsDir, a))) missingAgents.add(a);
+          }
+          for (const m of body.matchAll(/^\s+skill:\s*([\w-]+)\b/gm)) {
+            const s = m[1];
+            if (!existsSync(join(skillsDir, `${s}.md`))) missingSkills.add(s);
+          }
+        }
+      }
+    };
+    try { walkYaml(workflowsDir); }
+    catch (err) { warn(`workflow scan failed: ${err.message}`); }
+    if (missingAgents.size === 0 && missingSkills.size === 0) {
+      ok("All workflow agent/skill references resolved");
+    } else {
+      if (missingAgents.size) { warn(`Workflows reference ${missingAgents.size} missing agent(s): ${[...missingAgents].slice(0,5).join(", ")}${missingAgents.size > 5 ? "…" : ""}`); issues++; }
+      if (missingSkills.size) { warn(`Workflows reference ${missingSkills.size} missing skill(s): ${[...missingSkills].slice(0,5).join(", ")}${missingSkills.size > 5 ? "…" : ""}`); issues++; }
+    }
+  }
+
+  // ── Cadence-bus DLQ depth ───────────────────────────────────────────────
+  const dlqDir = join(cwd, "state/cadence-bus/dlq");
+  if (existsSync(dlqDir)) {
+    const dlqFiles = readdirSync(dlqDir).filter((n) => n.endsWith(".json"));
+    if (dlqFiles.length === 0) ok("Cadence-bus DLQ is empty");
+    else if (dlqFiles.length < 5) warn(`Cadence-bus DLQ: ${dlqFiles.length} event(s). Review: state/cadence-bus/dlq/`);
+    else {
+      fail(`Cadence-bus DLQ: ${dlqFiles.length} event(s) — investigate before clearing.`);
+      issues++;
+    }
+  }
+
+  // ── Backup freshness (only when backup is configured) ──────────────────
+  const backupCfg = join(cwd, ".maestro/backup-config.yaml");
+  if (existsSync(backupCfg)) {
+    const cfg = readFileSync(backupCfg, "utf-8");
+    if (/enabled:\s*true/.test(cfg)) {
+      const lastBackup = join(cwd, ".maestro/last-backup.json");
+      if (existsSync(lastBackup)) {
+        try {
+          const lb = JSON.parse(readFileSync(lastBackup, "utf-8"));
+          const age = Date.now() - new Date(lb.completed_at).getTime();
+          if (age < 25 * 60 * 60 * 1000) ok(`Last backup ${Math.round(age / 3600000)}h ago (${lb.provider}://${lb.bucket})`);
+          else { warn(`Last backup ${Math.round(age / 3600000)}h ago — investigate scripts/maintenance/backup-to-cloud.sh`); issues++; }
+        } catch { warn("last-backup.json is malformed"); }
+      } else {
+        warn("Backup enabled but no successful run yet — schedule scripts/maintenance/backup-to-cloud.sh");
+        issues++;
+      }
+    }
+  }
+
+  // ── Cross-agent registry ────────────────────────────────────────────────
+  const knownAgents = join(cwd, "config/known-agents.json");
+  if (existsSync(knownAgents)) {
+    try {
+      const reg = JSON.parse(readFileSync(knownAgents, "utf-8"));
+      const count = Array.isArray(reg.agents) ? reg.agents.length : 0;
+      if (count > 0) ok(`Cross-agent registry: ${count} peer agent(s)`);
+      else warn("config/known-agents.json present but empty — peer-agent detection won't work");
+    } catch {
+      warn("config/known-agents.json is malformed");
+      issues++;
+    }
+  } else {
+    warn("config/known-agents.json missing — run: maestro init known-agents-registry --apply");
+    issues++;
+  }
 
   console.log();
   if (issues === 0) ok("All checks passed.");
@@ -1466,6 +1617,138 @@ function doctor() {
   process.exitCode = issues === 0 ? 0 : 1;
 }
 
+// ---------------------------------------------------------------------------
+// INIT — run pending feature-init steps
+// ---------------------------------------------------------------------------
+
+async function initCmd(args) {
+  const cwd = process.cwd();
+  const help = args.includes("--help") || args.includes("-h");
+  const apply = args.includes("--apply") || args.includes("-y") || args.includes("--yes");
+  const featureArg = args.find((a) => !a.startsWith("-"));
+
+  if (help) {
+    console.log(`
+Usage: maestro init [feature-name] [--apply]
+
+Reconciles this agent's .maestro/features.json against the framework
+feature registry (framework-features.json shipped with @adaptic/maestro).
+Auto-runnable features are executed directly; features requiring user
+input are listed and can be opted into individually with their name as
+the first argument.
+
+  maestro init                    list pending features (dry-run)
+  maestro init --apply            run every auto-runnable pending step
+  maestro init <feature> --apply  run only the named feature's init step
+  maestro init --help             this help
+
+After init, run \`maestro doctor\` to confirm everything is in place.
+`);
+    return;
+  }
+
+  const { loadRegistry, loadAgentState, reconcileFeatures, listPending, markInitialised, diffFeatures } = await import("../lib/feature-init.mjs");
+  let registry;
+  try { registry = loadRegistry(FRAMEWORK_FEATURES_PATH); }
+  catch (err) { fail(err.message); process.exit(1); }
+
+  if (featureArg) {
+    // Targeted init — run just one feature's command.
+    const def = registry.features?.[featureArg];
+    if (!def) { fail(`unknown feature: ${featureArg}`); process.exit(1); }
+    log(`Running init for ${featureArg}: ${def.init?.description || ""}`);
+    if (!apply) { warn("dry-run — pass --apply to actually run."); return; }
+    const r = await runFeatureInit({ name: featureArg, def, cwd });
+    if (r.ok) {
+      markInitialised(cwd, featureArg, def.version);
+      ok(`initialised: ${featureArg} v${def.version}`);
+    } else {
+      fail(`init failed: ${r.error}`);
+      process.exit(1);
+    }
+    return;
+  }
+
+  // Reconcile + list pending.
+  const state = loadAgentState(cwd);
+  const diff = diffFeatures(registry, state);
+  if (diff.length === 0 && (state.pending || []).length === 0) {
+    ok("All framework features are initialised.");
+    return;
+  }
+
+  // Show what's pending before doing anything.
+  if (!apply) {
+    log(`${diff.length} feature(s) need initialisation:`);
+    for (const item of diff) {
+      const auto = item.definition.init?.auto;
+      console.log(`  ${auto ? "•" : "?"} ${item.definition.title || item.name} (v${item.version}) — ${auto ? "auto" : "needs --apply"}`);
+      if (item.definition.init?.description) console.log(`      ${item.definition.init.description}`);
+    }
+    console.log();
+    log("Run `maestro init --apply` to execute every auto-runnable step.");
+    return;
+  }
+
+  // --apply: run auto features now.
+  log("Running auto-init steps...");
+  const result = reconcileFeatures({
+    maestroRoot: MAESTRO_ROOT,
+    agentRoot: cwd,
+    registry,
+    runAuto: true,
+    logger: (entry) => {
+      const sym = entry.stage === "completed" ? `${C.green}✓${C.reset}` : entry.stage === "failed" ? `${C.red}✗${C.reset}` : entry.stage === "pending" ? `${C.yellow}~${C.reset}` : `${C.cyan}…${C.reset}`;
+      console.log(`  ${sym} ${entry.feature}${entry.message ? ` — ${entry.message}` : ""}`);
+    },
+  });
+
+  console.log();
+  if (result.ranAuto.length) ok(`${result.ranAuto.length} feature(s) initialised: ${result.ranAuto.join(", ")}`);
+  if (result.pending.length) warn(`${result.pending.length} feature(s) still pending (need manual decision): ${result.pending.join(", ")}`);
+  if (result.failed.length) {
+    fail(`${result.failed.length} feature(s) failed during init:`);
+    for (const f of result.failed) console.log(`    ✗ ${f.name}: ${f.error}`);
+    process.exit(1);
+  }
+  if (result.pending.length) {
+    console.log();
+    const pendingList = listPending(cwd);
+    for (const p of pendingList) {
+      console.log(`    To initialise ${p.feature}: maestro init ${p.feature} --apply`);
+    }
+  }
+}
+
+async function runFeatureInit({ name, def, cwd }) {
+  const { execFileSync } = await import("node:child_process");
+  const cmd = def.init?.command;
+  if (!cmd || cmd === "true") return { ok: true };
+  const parts = cmd.split(/\s+/);
+  try {
+    if (parts[0] === "node" && parts[1]) {
+      const script = join(cwd, parts[1]);
+      const fallback = join(MAESTRO_ROOT, parts[1]);
+      const scriptPath = existsSync(script) ? script : (existsSync(fallback) ? fallback : null);
+      if (!scriptPath) return { ok: false, error: `script not found: ${parts[1]}` };
+      execFileSync(process.execPath, [scriptPath, ...parts.slice(2)], {
+        cwd,
+        env: { ...process.env, AGENT_ROOT: cwd, AGENT_DIR: cwd, MAESTRO_ROOT },
+        stdio: "inherit",
+      });
+      return { ok: true };
+    }
+    execFileSync("/bin/bash", ["-lc", cmd], {
+      cwd,
+      env: { ...process.env, AGENT_ROOT: cwd, AGENT_DIR: cwd, MAESTRO_ROOT },
+      stdio: "inherit",
+    });
+    return { ok: true };
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+}
+
 // ---------------------------------------------------------------------------
 // MAIN
 // ---------------------------------------------------------------------------
@@ -1474,8 +1757,12 @@ const [, , command, ...args] = process.argv;
 
 switch (command) {
   case "create": create(args[0]); break;
-  case "upgrade": upgrade(args); break;
+  case "upgrade": await upgrade(args); break;
   case "doctor": doctor(); break;
+  case "init":
+  case "update-init":
+  case "init-update":
+    await initCmd(args); break;
   case "--help": case "-h": case undefined:
     console.log(`
 Maestro — Autonomous AI Agent Operating System
@@ -1483,6 +1770,7 @@ Maestro — Autonomous AI Agent Operating System
 Usage:
   npx @adaptic/maestro create <dirname>           Create a new agent repo
   npx @adaptic/maestro upgrade [--dry-run]        Update framework files
+  npx @adaptic/maestro init [feature] [--apply]   Run pending feature-init steps
   npx @adaptic/maestro doctor                     Verify installation
 
 Upgrade flags:
@@ -1491,10 +1779,20 @@ Upgrade flags:
   --no-incoming          Don't write .maestro/incoming/ shadows
   --verbose, -v          List classification for every file
 
+Init flags:
+  (no args)              List pending features (dry-run)
+  --apply, -y            Run every auto-runnable pending step
+  <feature> --apply      Run only the named feature's init step
+
 Workflow:
   1. npx @adaptic/maestro create my-agent
   2. cd my-agent
   3. claude "/init-maestro"
+
+Upgrade workflow (existing agents):
+  1. npm update @adaptic/maestro
+  2. npm run upgrade        (runs maestro upgrade + auto-init)
+  3. maestro init           (run any deferred init steps)
 `);
     break;
   default:

package/framework-features.json

@@ -0,0 +1,107 @@
+{
+  "$schema": "https://adaptic.ai/schemas/maestro/framework-features.v1.json",
+  "schema_version": "1",
+  "_doc": "Versioned registry of framework features. Each entry pairs a feature name with its current version, the maestro version that introduced (or last revved) it, and a per-feature init descriptor. `maestro upgrade` reads this file, compares against the agent's .maestro/features.json, and runs `init.command` automatically for features marked `auto: true`. Features with `auto: false` land on the agent's pending-init queue and are surfaced by the SessionStart banner + completed via `maestro init`.",
+  "features": {
+    "cadence-bus": {
+      "version": "1",
+      "since": "1.8.0",
+      "title": "Cadence bus (persistent main session + lightweight launchd enqueue)",
+      "init": {
+        "auto": true,
+        "command": "node scripts/setup/init-cadence-bus.mjs",
+        "description": "Create state/cadence-bus/{inbox,claimed,processed,failed,dlq} + logs/cadence-bus/. Verify daemon plist uses cadence-bus arch."
+      }
+    },
+    "known-agents-registry": {
+      "version": "1",
+      "since": "1.9.0",
+      "title": "Cross-agent registry (peer agent recognition)",
+      "init": {
+        "auto": true,
+        "command": "node scripts/setup/init-known-agents.mjs",
+        "description": "Scaffold config/known-agents.json with the Adaptic agent roster so classifier.mjs can detect peer @mentions and avoid responding to messages routed at another agent."
+      }
+    },
+    "memory-executive-scaffold": {
+      "version": "1",
+      "since": "1.9.0",
+      "title": "Executive memory directory structure",
+      "init": {
+        "auto": true,
+        "command": "node scripts/setup/init-memory-executive.mjs",
+        "description": "Create memory/executive/ and memory/workstreams/ subdirectories with seed files. Referenced by agents/ceo-briefing/ and skill prompts."
+      }
+    },
+    "inputs-overnight-scaffold": {
+      "version": "1",
+      "since": "1.9.0",
+      "title": "Overnight inputs directory",
+      "init": {
+        "auto": true,
+        "command": "mkdir -p inputs/overnight && [ ! -f inputs/overnight/.gitkeep ] && touch inputs/overnight/.gitkeep || true",
+        "description": "Create inputs/overnight/ referenced by morning-brief skill."
+      }
+    },
+    "emergency-stop-paths": {
+      "version": "2",
+      "since": "1.9.0",
+      "title": "Emergency-stop / resume plist path fix",
+      "init": {
+        "auto": true,
+        "command": "true",
+        "description": "Cosmetic version bump — emergency-stop.sh and resume-operations.sh now look in ~/Library/LaunchAgents/ instead of $REPO/schedules/. No agent-side init needed; just receive the updated scripts."
+      }
+    },
+    "rag-foundation": {
+      "version": "1",
+      "since": "1.9.0",
+      "title": "RAG foundation (repo-registry + local index + retrieval helpers)",
+      "init": {
+        "auto": false,
+        "command": "node scripts/setup/init-rag.mjs",
+        "description": "Discover ~/* repos likely to be relevant to this agent (asks for selection), populate config/repo-registry.yaml, and seed state/rag/. Local sqlite-fts5 index by default. Requires interactive input — does not run automatically."
+      }
+    },
+    "decision-capture": {
+      "version": "1",
+      "since": "1.9.0",
+      "title": "Decision capture automation",
+      "init": {
+        "auto": true,
+        "command": "node scripts/setup/init-decision-capture.mjs",
+        "description": "Wire knowledge/decisions/ decision-log automation. Post-action hook detects decision-shaped tool calls and surfaces capture prompts. Schema-validated via knowledge/decisions/decision-schema.yaml."
+      }
+    },
+    "cost-tracking": {
+      "version": "1",
+      "since": "1.9.0",
+      "title": "Cost tracking + quota awareness",
+      "init": {
+        "auto": true,
+        "command": "node scripts/setup/init-cost-tracking.mjs",
+        "description": "Set up state/cost-tracking/, scripts/cost/track-claude-usage.mjs, and daily state/dashboards/cost-summary.yaml. Surfaces burn rate in doctor."
+      }
+    },
+    "session-router": {
+      "version": "1",
+      "since": "1.9.0",
+      "title": "Session router (LRU reuse of long-running Claude sessions)",
+      "init": {
+        "auto": false,
+        "command": "node scripts/setup/init-session-router.mjs",
+        "description": "Enable session-router for backlog / inbox processing. Opt-in: requires SESSION_ROUTER_ENABLED=1 in .env. Init wizard helps configure registry path + LRU caps."
+      }
+    },
+    "backup-replication": {
+      "version": "1",
+      "since": "1.9.0",
+      "title": "Off-machine state backup",
+      "init": {
+        "auto": false,
+        "command": "node scripts/setup/init-backup.mjs",
+        "description": "Configure off-machine backup of state/, knowledge/, outputs/, and rotated logs to GCS or S3. Requires bucket name + credentials. Doctor flags if last successful backup is >24h old once configured."
+      }
+    }
+  }
+}