@adaptic/maestro 1.8.3 → 1.9.0

package/scripts/resume-operations.sh

@@ -1,40 +1,77 @@
 #!/bin/bash
-# Resume Operations — Restarts Maestro agent after an emergency stop
+# Resume Operations — Restarts Maestro agent after an emergency stop.
 # Usage: ./scripts/resume-operations.sh
+#
+# Reverses emergency-stop.sh:
+#   1. Verifies health check passes.
+#   2. Removes the .emergency-stop flag.
+#   3. Reloads every installed `ai.adaptic.<agent>-*` launchd job.
+#
+# Agent first-name slug resolved from config/agent.json (SOT).
 
 set -e
 
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-SOPHIE_AI_DIR="$(dirname "$SCRIPT_DIR")"
-LOG_FILE="$SOPHIE_AI_DIR/logs/operations.log"
+AGENT_DIR="$(dirname "$SCRIPT_DIR")"
+LOG_FILE="$AGENT_DIR/logs/operations.log"
 TIMESTAMP=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+mkdir -p "$(dirname "$LOG_FILE")" 2>/dev/null || true
 
-# Check if stop flag exists
-if [ ! -f "$SOPHIE_AI_DIR/.emergency-stop" ]; then
-    echo "No emergency stop flag found. System may already be running."
+# Resolve agent first-name slug.
+AGENT_FIRST=""
+if [ -f "$AGENT_DIR/config/agent.json" ]; then
+    if command -v jq >/dev/null 2>&1; then
+        AGENT_FIRST=$(jq -r '.firstName // empty' "$AGENT_DIR/config/agent.json" | tr '[:upper:]' '[:lower:]')
+    else
+        AGENT_FIRST=$(awk -F'"' '/"firstName"[[:space:]]*:/ { print tolower($4); exit }' "$AGENT_DIR/config/agent.json")
+    fi
+fi
+[ -z "$AGENT_FIRST" ] && AGENT_FIRST=$(basename "$AGENT_DIR" | sed 's/-ai$//')
+
+LAUNCH_AGENTS_DIR="$HOME/Library/LaunchAgents"
+PLIST_GLOB="$LAUNCH_AGENTS_DIR/ai.adaptic.${AGENT_FIRST}-*.plist"
+
+# Check if stop flag exists.
+if [ ! -f "$AGENT_DIR/.emergency-stop" ]; then
+    echo "No emergency stop flag found — system is already running."
+    # Still verify launchd jobs are loaded; if not, load them.
+    loaded=0
+    for plist in $PLIST_GLOB; do
+        [ -f "$plist" ] || continue
+        label=$(basename "$plist" .plist)
+        if ! launchctl list | grep -q "$label"; then
+            launchctl load "$plist" 2>/dev/null && loaded=$((loaded + 1))
+        fi
+    done
+    [ "$loaded" -gt 0 ] && echo "Loaded $loaded missing launchd job(s)"
     exit 0
 fi
 
-echo "[$TIMESTAMP] RESUMING OPERATIONS" | tee -a "$LOG_FILE"
+echo "[$TIMESTAMP] RESUMING OPERATIONS (agent=$AGENT_FIRST)" | tee -a "$LOG_FILE"
 
-# 1. Run health check first
+# 1. Run health check first.
 echo "Running health check..."
 if ! "$SCRIPT_DIR/healthcheck.sh"; then
     echo "ERROR: Health check failed. Fix issues before resuming."
     exit 1
 fi
 
-# 2. Remove stop flag
-rm "$SOPHIE_AI_DIR/.emergency-stop"
+# 2. Remove stop flag.
+rm "$AGENT_DIR/.emergency-stop"
 echo "[$TIMESTAMP] Stop flag removed" >> "$LOG_FILE"
 
-# 3. Reload scheduled workflows
-echo "Reloading scheduled workflows..."
-for plist in "$SOPHIE_AI_DIR"/schedules/*.plist; do
+# 3. Reload installed launchd jobs.
+echo "Reloading installed launchd jobs ($PLIST_GLOB)..."
+loaded=0
+for plist in $PLIST_GLOB; do
     if [ -f "$plist" ]; then
+        # Unload first in case it was left in a half-loaded state.
+        launchctl unload "$plist" 2>/dev/null || true
         launchctl load "$plist" 2>/dev/null || true
         echo "[$TIMESTAMP] Loaded: $(basename "$plist")" >> "$LOG_FILE"
+        loaded=$((loaded + 1))
     fi
 done
+echo "[$TIMESTAMP] Loaded $loaded launchd job(s)" >> "$LOG_FILE"
 
 echo "[$TIMESTAMP] OPERATIONS RESUMED" | tee -a "$LOG_FILE"

package/scripts/setup/init-backup.mjs

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+/**
+ * init-backup.mjs — Off-machine state backup wizard.
+ *
+ * Configures `.maestro/backup-config.yaml` with bucket details and seeds
+ * a daily launchd plist that runs scripts/maintenance/backup-to-cloud.sh.
+ * Requires interactive input — does NOT auto-run.
+ */
+import { existsSync, writeFileSync, mkdirSync } from "node:fs";
+import { join, resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const AGENT_DIR = process.env.AGENT_ROOT || process.env.AGENT_DIR || resolve(__dirname, "..", "..");
+
+const ok = (m) => process.stdout.write(`[init-backup]  ✓ ${m}\n`);
+const warn = (m) => process.stdout.write(`[init-backup]  ⚠ ${m}\n`);
+
+mkdirSync(join(AGENT_DIR, ".maestro"), { recursive: true });
+const cfg = join(AGENT_DIR, ".maestro/backup-config.yaml");
+if (existsSync(cfg)) {
+  ok("backup-config.yaml already present");
+  process.exit(0);
+}
+
+writeFileSync(cfg, `# Off-machine state backup configuration
+# Fill in the bucket details, then run:
+#   maestro init backup-replication --apply
+#
+# Backups cover (configurable below):
+#   - state/   (queues, dashboards, inboxes — minus state/tmp/)
+#   - knowledge/
+#   - outputs/
+#   - logs/ (rotated archives only — current-day logs excluded)
+#   - config/agent.json (identity SOT)
+
+enabled: false
+provider: gcs            # gcs | s3 | rsync
+bucket: ""               # e.g. adaptic-maestro-backups
+prefix: agent-name-here  # e.g. ravi-ai (typically the repoSlug)
+schedule: "0 3 * * *"    # daily 03:00 local (overrides via launchd plist)
+include:
+  - state
+  - knowledge
+  - outputs
+  - logs
+  - config/agent.json
+exclude:
+  - state/tmp
+  - state/rag/index/*.bin
+retention_days: 30
+`);
+ok(`wrote ${cfg}`);
+warn("Backup is configured but NOT enabled. Edit .maestro/backup-config.yaml + set enabled: true, then re-run init.");

package/scripts/setup/init-cadence-bus.mjs

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+/**
+ * init-cadence-bus.mjs — Idempotent init step for the cadence-bus feature.
+ *
+ * Called by `maestro init` / `maestro upgrade` (via the feature-init
+ * tracker). Safe to run repeatedly. Verifies state/cadence-bus/{inbox,
+ * claimed,processed,failed,dlq} exist + logs/cadence-bus/ exists +
+ * generated launchd plists are on the cadence-bus arch.
+ */
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const AGENT_DIR = process.env.AGENT_ROOT || process.env.AGENT_DIR || resolve(__dirname, "..", "..");
+
+const ok = (m) => process.stdout.write(`[init-cadence-bus]  ✓ ${m}\n`);
+const warn = (m) => process.stdout.write(`[init-cadence-bus]  ⚠ ${m}\n`);
+
+// Directory tree (mirror of cadence-bus.mjs's bootstrap).
+for (const d of [
+  "state/cadence-bus/inbox",
+  "state/cadence-bus/claimed",
+  "state/cadence-bus/processed",
+  "state/cadence-bus/failed",
+  "state/cadence-bus/dlq",
+  "logs/cadence-bus",
+]) {
+  const full = join(AGENT_DIR, d);
+  if (!existsSync(full)) {
+    mkdirSync(full, { recursive: true });
+    ok(`created ${d}`);
+  }
+}
+
+// Version marker file.
+const versionFile = join(AGENT_DIR, "state/cadence-bus/VERSION");
+if (!existsSync(versionFile)) {
+  writeFileSync(versionFile, "1\n");
+  ok("seeded state/cadence-bus/VERSION");
+}
+
+// Plist arch verification — flag (don't fix here, that's upgrade's job).
+const plistDir = join(AGENT_DIR, "scripts/local-triggers/plists");
+if (existsSync(plistDir)) {
+  let legacy = 0;
+  for (const name of readdirSync(plistDir)) {
+    if (!name.endsWith(".plist")) continue;
+    const body = readFileSync(join(plistDir, name), "utf-8");
+    if (body.includes("run-trigger.sh")) legacy++;
+  }
+  if (legacy > 0) {
+    warn(`${legacy} generated plist(s) still use the legacy spawn-per-tick pattern.`);
+    warn("  Run: npx @adaptic/maestro upgrade  (will back up + regenerate)");
+  } else {
+    ok("plist arch verified");
+  }
+}
+
+ok("done");

package/scripts/setup/init-cost-tracking.mjs

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+/**
+ * init-cost-tracking.mjs — Set up local cost tracking ledger + dashboard.
+ *
+ * State:
+ *   state/cost-tracking/<date>.jsonl    — per-day token ledger
+ *   state/dashboards/cost-summary.yaml  — rollup
+ *
+ * The actual tracker is scripts/cost/track-claude-usage.mjs (shipped by the
+ * framework) which is wired into the cadence-consumer's session-spawn path.
+ */
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join, resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const AGENT_DIR = process.env.AGENT_ROOT || process.env.AGENT_DIR || resolve(__dirname, "..", "..");
+
+const ok = (m) => process.stdout.write(`[init-cost-tracking]  ✓ ${m}\n`);
+
+for (const d of ["state/cost-tracking", "state/dashboards"]) {
+  const full = join(AGENT_DIR, d);
+  if (!existsSync(full)) {
+    mkdirSync(full, { recursive: true });
+    ok(`created ${d}`);
+  }
+}
+
+const summary = join(AGENT_DIR, "state/dashboards/cost-summary.yaml");
+if (!existsSync(summary)) {
+  writeFileSync(summary, `# Cost summary — auto-regenerated by scripts/cost/track-claude-usage.mjs
+generated: null
+window_days: 7
+totals:
+  sessions: 0
+  input_tokens: 0
+  output_tokens: 0
+  estimated_usd: 0
+by_model: {}
+by_cadence: {}
+`);
+  ok("seeded cost-summary.yaml");
+}
+
+ok("done");

package/scripts/setup/init-decision-capture.mjs

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+/**
+ * init-decision-capture.mjs — Wire decision-capture automation.
+ *
+ * Ensures knowledge/decisions/{decision-schema,index}.yaml exist and
+ * creates scripts/decisions/capture-decision.mjs locally (the helper
+ * that the agent invokes when recording a decision).
+ */
+import { existsSync, mkdirSync, writeFileSync, copyFileSync } from "node:fs";
+import { join, resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const AGENT_DIR = process.env.AGENT_ROOT || process.env.AGENT_DIR || resolve(__dirname, "..", "..");
+const MAESTRO_ROOT = process.env.MAESTRO_ROOT || resolve(__dirname, "..", "..");
+
+const ok = (m) => process.stdout.write(`[init-decision-capture]  ✓ ${m}\n`);
+
+for (const d of ["knowledge/decisions", "knowledge/decisions/archive", "scripts/decisions"]) {
+  const full = join(AGENT_DIR, d);
+  if (!existsSync(full)) {
+    mkdirSync(full, { recursive: true });
+    ok(`created ${d}`);
+  }
+}
+
+// Copy the framework's capture-decision helper if present.
+const src = join(MAESTRO_ROOT, "scripts/decisions/capture-decision.mjs");
+const dst = join(AGENT_DIR, "scripts/decisions/capture-decision.mjs");
+if (existsSync(src) && !existsSync(dst)) {
+  copyFileSync(src, dst);
+  ok(`copied capture-decision.mjs`);
+}
+
+// Seed index.yaml + schema if missing.
+const schemaPath = join(AGENT_DIR, "knowledge/decisions/decision-schema.yaml");
+if (!existsSync(schemaPath)) {
+  writeFileSync(schemaPath, `# Decision Record Schema (Maestro decision-capture v1)
+# Each decision is a YAML doc named DEC-YYYY-MM-DD-NNN.yaml under knowledge/decisions/.
+
+schema:
+  version: "1"
+  fields:
+    id:               { type: string, format: "DEC-YYYY-MM-DD-NNN", required: true }
+    date:             { type: date,   format: "YYYY-MM-DD",         required: true }
+    title:            { type: string, required: true }
+    domain:           { type: string, required: true }
+    decision_maker:   { type: string, required: true }
+    decision_text:    { type: string, required: true }
+    context:          { type: string, required: true }
+    rationale:        { type: string, required: true }
+    alternatives:     { type: array,  required: false }
+    stakeholders:     { type: array,  required: false }
+    expires_at:       { type: date,   required: false }
+    status:           { type: string, enum: [active, superseded, reversed, completed], default: active }
+`);
+  ok("seeded decision-schema.yaml");
+}
+
+const indexPath = join(AGENT_DIR, "knowledge/decisions/index.yaml");
+if (!existsSync(indexPath)) {
+  writeFileSync(indexPath, "# Decision Index — auto-maintained by capture-decision.mjs\ndecisions: []\n");
+  ok("seeded decision index");
+}
+
+ok("done");

package/scripts/setup/init-known-agents.mjs

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+/**
+ * init-known-agents.mjs — Scaffold config/known-agents.json
+ *
+ * The Adaptic agent roster is shipped as a starter; agents that have
+ * already populated their own known-agents.json keep theirs (this init
+ * step is idempotent and never overwrites).
+ *
+ * classifier.mjs reads this file at runtime to detect peer @mentions in
+ * Slack/Gmail so an agent doesn't respond to messages routed at another
+ * agent.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join, dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const AGENT_DIR = process.env.AGENT_ROOT || process.env.AGENT_DIR || resolve(__dirname, "..", "..");
+
+const ok = (m) => process.stdout.write(`[init-known-agents]  ✓ ${m}\n`);
+
+const TARGET = join(AGENT_DIR, "config", "known-agents.json");
+const MAESTRO_ROOT = process.env.MAESTRO_ROOT || resolve(__dirname, "..", "..");
+const SCAFFOLD = join(MAESTRO_ROOT, "scaffold", "config", "known-agents.json");
+
+mkdirSync(dirname(TARGET), { recursive: true });
+
+if (existsSync(TARGET)) {
+  // Already present — verify shape and exit. We don't merge upstream
+  // additions into existing files to avoid surprising the operator.
+  try {
+    const current = JSON.parse(readFileSync(TARGET, "utf-8"));
+    const count = Array.isArray(current.agents) ? current.agents.length : 0;
+    ok(`already present (${count} agents)`);
+    process.exit(0);
+  } catch (err) {
+    process.stderr.write(`[init-known-agents] existing file is invalid JSON: ${err.message}\n`);
+    process.exit(1);
+  }
+}
+
+// Copy from scaffold (the framework's canonical roster); fall back to a
+// minimal stub if the scaffold is missing.
+let payload;
+if (existsSync(SCAFFOLD)) {
+  payload = readFileSync(SCAFFOLD, "utf-8");
+  ok(`copied from ${SCAFFOLD}`);
+} else {
+  payload = JSON.stringify({
+    schema_version: "1",
+    agents: [],
+  }, null, 2) + "\n";
+  ok("scaffold not found — wrote empty roster");
+}
+
+writeFileSync(TARGET, payload);
+ok(`wrote ${TARGET}`);

package/scripts/setup/init-memory-executive.mjs

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+/**
+ * init-memory-executive.mjs — Create memory/executive/ + memory/workstreams/
+ * Referenced by agents/ceo-briefing/agent.md and several skill prompts.
+ *
+ * Seeds priorities.md and open-loops.md so morning-brief / evening-wrap
+ * don't fail on a missing file.
+ */
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join, resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const AGENT_DIR = process.env.AGENT_ROOT || process.env.AGENT_DIR || resolve(__dirname, "..", "..");
+
+const ok = (m) => process.stdout.write(`[init-memory-executive]  ✓ ${m}\n`);
+
+const DIRS = [
+  "memory/executive",
+  "memory/workstreams",
+];
+
+for (const d of DIRS) {
+  const full = join(AGENT_DIR, d);
+  if (!existsSync(full)) {
+    mkdirSync(full, { recursive: true });
+    ok(`created ${d}`);
+  }
+}
+
+const seeds = {
+  "memory/executive/priorities.md": "# Executive Priorities\n\nCurrent strategic priorities maintained by the agent. Updated weekly.\n\n_Populate via /init-maestro or by the weekly-priorities cadence._\n",
+  "memory/executive/open-loops.md": "# Open Loops\n\nOutstanding commitments awaiting closure. Updated by inbox-processor and evening-wrap cadences.\n\n_Format: each loop has owner, deadline, blocker, last-touched._\n",
+  "memory/workstreams/README.md": "# Workstreams\n\nOne markdown file per active workstream. Updated by the relevant cadence (weekly-execution, weekly-engineering-health, etc.) to reflect current status, blockers, and next milestones.\n",
+};
+
+for (const [path, body] of Object.entries(seeds)) {
+  const full = join(AGENT_DIR, path);
+  if (!existsSync(full)) {
+    writeFileSync(full, body);
+    ok(`seeded ${path}`);
+  }
+}
+
+ok("done");

package/scripts/setup/init-rag.mjs

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+/**
+ * init-rag.mjs — Bootstrap the local RAG index.
+ *
+ * Auto-discovers candidate repos under ~/ and writes them to
+ * config/repo-registry.yaml. By default this script is *not* auto-run
+ * because picking the right repos requires operator judgement. When run
+ * interactively, it lists candidates and asks for confirmation; when run
+ * with --yes it picks all ~/{repo}-ai siblings + adapticai/* clones.
+ */
+import { existsSync, mkdirSync, readdirSync, statSync, writeFileSync, readFileSync } from "node:fs";
+import { join, resolve, dirname } from "node:path";
+import { homedir } from "node:os";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const AGENT_DIR = process.env.AGENT_ROOT || process.env.AGENT_DIR || resolve(__dirname, "..", "..");
+
+const ok = (m) => process.stdout.write(`[init-rag]  ✓ ${m}\n`);
+const warn = (m) => process.stdout.write(`[init-rag]  ⚠ ${m}\n`);
+
+const args = new Set(process.argv.slice(2));
+const autoYes = args.has("--yes") || args.has("-y");
+
+for (const d of ["state/rag", "state/rag/index", "scripts/rag"]) {
+  const full = join(AGENT_DIR, d);
+  if (!existsSync(full)) {
+    mkdirSync(full, { recursive: true });
+    ok(`created ${d}`);
+  }
+}
+
+// Discover candidate repos under $HOME.
+function discoverRepos() {
+  const home = homedir();
+  const candidates = [];
+  for (const name of readdirSync(home)) {
+    if (name.startsWith(".") || name === "ravi-ai" || name === "Library" || name === "Applications") continue;
+    const full = join(home, name);
+    try {
+      const st = statSync(full);
+      if (!st.isDirectory()) continue;
+      // Heuristic: looks like a code repo (.git or package.json or pyproject.toml).
+      const isRepo =
+        existsSync(join(full, ".git")) ||
+        existsSync(join(full, "package.json")) ||
+        existsSync(join(full, "pyproject.toml")) ||
+        existsSync(join(full, "go.mod")) ||
+        existsSync(join(full, "Cargo.toml"));
+      if (isRepo) {
+        candidates.push({ name, path: full });
+      }
+    } catch { /* ignore */ }
+  }
+  return candidates;
+}
+
+const candidates = discoverRepos();
+ok(`discovered ${candidates.length} candidate repo(s) under ${homedir()}`);
+
+const registryPath = join(AGENT_DIR, "config/repo-registry.yaml");
+let registry = { repositories: [] };
+if (existsSync(registryPath)) {
+  // Crude YAML re-read: just check whether `repositories: []` is empty.
+  const body = readFileSync(registryPath, "utf-8");
+  if (/repositories:\s*\[\s*\]/.test(body) || /repositories:\s*$/m.test(body)) {
+    // empty list — overwrite with discovered set if user opted in.
+  } else {
+    ok("config/repo-registry.yaml already populated — leaving as-is");
+    process.exit(0);
+  }
+}
+
+if (!autoYes) {
+  warn("Not running interactively — to populate, run with --yes:");
+  warn("  node scripts/setup/init-rag.mjs --yes");
+  warn("Candidates that would be added:");
+  for (const c of candidates) warn(`  - ${c.name} (${c.path})`);
+  process.exit(0);
+}
+
+// Build the YAML.
+const lines = [
+  "# Source Repository Registry",
+  "# Populated by scripts/setup/init-rag.mjs. Add/remove entries as needed.",
+  "# Format:",
+  "#   - name:    repo-slug",
+  "#     path:    ~/repo-slug",
+  "#     purpose: what this repo contains",
+  "#     index:   true | false  (indexed by state/rag/)",
+  "",
+  "repositories:",
+];
+for (const c of candidates) {
+  lines.push(`  - name: ${c.name}`);
+  lines.push(`    path: ${c.path}`);
+  lines.push(`    purpose: ""`);
+  lines.push(`    index: true`);
+}
+writeFileSync(registryPath, lines.join("\n") + "\n");
+ok(`wrote ${candidates.length} entries to config/repo-registry.yaml`);
+
+ok("done");

package/scripts/setup/init-session-router.mjs

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+/**
+ * init-session-router.mjs — Opt-in session router enablement.
+ *
+ * Session router enables LRU reuse of long-running Claude sessions for
+ * conversational items (Slack threads, Gmail threads). Requires
+ * SESSION_ROUTER_ENABLED=1 in .env. This init step appends that line if
+ * absent, but is intentionally `auto: false` in the registry so the
+ * operator confirms the decision.
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { join, resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const AGENT_DIR = process.env.AGENT_ROOT || process.env.AGENT_DIR || resolve(__dirname, "..", "..");
+
+const ok = (m) => process.stdout.write(`[init-session-router]  ✓ ${m}\n`);
+const warn = (m) => process.stdout.write(`[init-session-router]  ⚠ ${m}\n`);
+
+const envFile = join(AGENT_DIR, ".env");
+if (!existsSync(envFile)) {
+  warn(".env not present — create it first (copy .env.example).");
+  process.exit(0);
+}
+
+const body = readFileSync(envFile, "utf-8");
+if (/^SESSION_ROUTER_ENABLED=/m.test(body)) {
+  ok("SESSION_ROUTER_ENABLED already configured");
+} else {
+  const updated = body.replace(/\n*$/, "") + `\n\n# Session router (LRU reuse) — disabled by default. Set to 1 to enable.\nSESSION_ROUTER_ENABLED=1\n`;
+  writeFileSync(envFile, updated);
+  ok("appended SESSION_ROUTER_ENABLED=1 to .env");
+}
+
+// Touch the registry dir.
+mkdirSync(join(AGENT_DIR, "state/sessions"), { recursive: true });
+ok("done");

package/workflows/continuous/backlog-executor.yaml

@@ -135,7 +135,7 @@ steps:
 on_failure:
   action: log-and-notify
   message: "Backlog executor cycle failed at step {failed_step}"
-  notify: sophie-chief-of-staff
+  notify: agent-self # the executing agent (operator)
   severity: high
   # If quota-gate fails, the entire cycle is skipped — this is by design
   quota_gate_failure: skip_cycle

package/workflows/continuous/inbound-monitor.yaml

@@ -1,6 +1,6 @@
 # Continuous Inbound Monitoring Loop
 # Runs perpetually via launchd — polls all channels and dispatches responses
-# This is the heartbeat of Sophie's always-on executive operations
+# This is the heartbeat of the agent's always-on executive operations
 
 name: inbound-monitor
 type: continuous # Not scheduled — runs as a persistent loop
@@ -17,7 +17,7 @@ monitors:
     interval_seconds: 60
     scope:
       - type: mentions
-        description: Any @mention of Sophie or Mehran
+        description: Any @mention of the agent or the principal
       - type: dms
         description: All direct messages
       - type: channels
@@ -65,8 +65,8 @@ dispatch:
 
   routing:
     direct-reply:
-      handler: sophie-chief-of-staff
-      description: Sophie handles directly — default route for most inbound
+      handler: agent-self # the executing agent (operator)
+      description: The agent handles directly — default route for most inbound
       max_response_time: 120 # 2 minutes for DMs, 5 minutes for channels
       priority: highest
 
@@ -77,11 +77,11 @@ dispatch:
       max_concurrent: 5
 
     escalate-to-ceo:
-      handler: sophie-chief-of-staff
+      handler: agent-self # the executing agent (operator)
       description: >
-        Alert Mehran only for binding commitments, regulatory submissions,
-        deal terms, or genuinely strategic decisions. Sophie decides when this applies.
-      method: slack-dm # DM Mehran on Slack
+        Alert the principal only for binding commitments, regulatory submissions,
+        deal terms, or genuinely strategic decisions. The agent decides when this applies.
+      method: slack-dm # DM the principal on Slack
       fallback: whatsapp # If Slack unavailable, WhatsApp
 
     defer:
@@ -90,11 +90,11 @@ dispatch:
       output: outputs/inbound/deferred/
 
 # Autonomous response rules
-# Sophie is fully autonomous — she responds to all inbound communications
+# The agent is fully autonomous — she responds to all inbound communications
 # using her own judgement as Chief of Staff. No per-message approval gates.
 autonomous_response:
   enabled: true
-  mode: full_autonomy # Sophie decides what to send and when
+  mode: full_autonomy # The agent decides what to send and when
   categories:
     - id: dm-response
       description: Respond to any DM from any workspace user

package/workflows/daily/applicant-triage.yaml

@@ -191,7 +191,7 @@ steps:
 on_failure:
   action: log-and-notify
   message: "Daily applicant triage failed at step {failed_step}"
-  notify: sophie-chief-of-staff
+  notify: agent-self # the executing agent (operator)
   severity: medium
 
 final_output: outputs/briefs/daily/{date}/applicant-triage.md

package/workflows/daily/comms-triage.yaml

@@ -63,7 +63,7 @@ steps:
       update: knowledge/memory/executive-memory.yaml # add to open_loops
 
   - id: route-actions
-    agent: sophie-chief-of-staff
+    agent: agent-self # the executing agent (operator)
     action: route-action-items
     description: Route extracted action items to appropriate queues and agents
     timeout: 120
@@ -76,5 +76,5 @@ steps:
 on_failure:
   action: log-and-notify
   message: "Communications triage failed at step {failed_step}"
-  notify: sophie-chief-of-staff
+  notify: agent-self # the executing agent (operator)
   severity: high

package/workflows/daily/evening-wrap.yaml

@@ -99,7 +99,7 @@ steps:
 on_failure:
   action: log-and-notify
   message: "Evening wrap workflow failed at step {failed_step}"
-  notify: sophie-chief-of-staff
+  notify: agent-self # the executing agent (operator)
   severity: medium
 
 final_output: outputs/briefs/daily/{date}/ceo-evening-wrap.md