@askexenow/exe-os 0.9.227 → 0.9.229

package/dist/bin/customer-readiness.js

@@ -0,0 +1,389 @@
+#!/usr/bin/env node
+
+// src/bin/customer-readiness.ts
+import { readFileSync, existsSync } from "fs";
+import { execSync } from "child_process";
+import path from "path";
+import { fileURLToPath } from "url";
+var __dirname = path.dirname(fileURLToPath(import.meta.url));
+var ROOT = path.resolve(__dirname, "../..");
+var pass = 0;
+var fail = 0;
+function test(name, fn) {
+  try {
+    const result = fn();
+    if (result === true || result === "pass") {
+      console.log(`  \x1B[32m\u2713\x1B[0m ${name}`);
+      pass++;
+    } else {
+      console.log(`  \x1B[31m\u2717\x1B[0m ${name}: ${result}`);
+      fail++;
+    }
+  } catch (err) {
+    console.log(`  \x1B[31m\u2717\x1B[0m ${name}: ${err instanceof Error ? err.message : String(err)}`);
+    fail++;
+  }
+}
+function readSrc(relPath) {
+  return readFileSync(path.join(ROOT, relPath), "utf8");
+}
+console.log("\n\x1B[1mCustomer Readiness Gate\x1B[0m\n");
+test("Mode 1 detection \u2014 bare exe-os shows guidance, not TUI", () => {
+  const cli = readSrc("src/bin/cli.ts");
+  if (!cli.includes("Mode 1 detected")) return "cli.ts missing Mode 1 detection";
+  if (!cli.includes("hasClaudeCode")) return "cli.ts missing Claude Code check";
+  return true;
+});
+test("Review orphans \u2014 no createTaskCore in review generation", () => {
+  const review = readSrc("src/lib/tasks-review.ts");
+  if (review.includes("createTaskCore(")) return "createTaskCore still called \u2014 will create orphan tasks";
+  return true;
+});
+test("Cloud sync \u2014 sqlSafe() protects all cloudPull functions", () => {
+  const sync = readSrc("src/lib/cloud-sync.ts");
+  if (!sync.includes("function sqlSafe")) return "sqlSafe() helper missing";
+  const count = (sync.match(/sqlSafe\(/g) || []).length;
+  if (count < 20) return `Only ${count} sqlSafe() usages (expected 20+)`;
+  return true;
+});
+test("Session scoping \u2014 task-scope.ts helper exists", () => {
+  if (!existsSync(path.join(ROOT, "src/lib/task-scope.ts"))) return "task-scope.ts missing";
+  const scope = readSrc("src/lib/task-scope.ts");
+  if (!scope.includes("sessionScopeFilter")) return "sessionScopeFilter not exported";
+  return true;
+});
+test("Session scoping \u2014 all task query files import scope helper", () => {
+  const taskFiles = execSync(
+    `grep -rl "FROM tasks" src/ --include="*.ts" --include="*.tsx"`,
+    { encoding: "utf8", cwd: ROOT }
+  ).trim().split("\n").filter(Boolean);
+  const exempt = ["close-task.ts", "tasks-review.ts", "tasks.ts", "cloud-sync.ts", "task-scope.ts", "database.ts"];
+  const unscoped = [];
+  for (const f of taskFiles) {
+    const basename = path.basename(f);
+    if (exempt.some((e) => basename === e)) continue;
+    const content = readFileSync(path.join(ROOT, f), "utf8");
+    if (!content.includes("task-scope") && !content.includes("sessionScopeFilter") && !content.includes("intentionally unscoped")) {
+      unscoped.push(f);
+    }
+  }
+  if (unscoped.length > 0) return `${unscoped.length} files missing scope: ${unscoped.slice(0, 3).join(", ")}`;
+  return true;
+});
+test("No unscoped task queries \u2014 all task queries have session scope or PK guard", () => {
+  let rawOutput;
+  try {
+    rawOutput = execSync(
+      `grep -rn -B5 -A5 "FROM.*tasks\\|UPDATE.*tasks" src/ --include="*.ts" | grep -v tasks-crud.ts | grep -v "__tests__" | grep -v ".test." | grep -v "customer-readiness" | grep -v "task-scope.ts"`,
+      { encoding: "utf8", cwd: ROOT }
+    ).trim();
+  } catch {
+    return true;
+  }
+  if (!rawOutput) return true;
+  const blocks = rawOutput.split(/^--$/m);
+  const unscoped = [];
+  for (const block of blocks) {
+    const blockLower = block.toLowerCase();
+    const hasScope = blockLower.includes("scope.sql") || blockLower.includes("sessionscopefilter") || blockLower.includes("strictsessionscopefilter") || blockLower.includes("session_scope") || blockLower.includes("intentionally unscoped") || blockLower.includes("audited 2026") || blockLower.includes("querytaskrows");
+    const isSafe = hasScope || /where\s+id\s*=\s*\?/.test(blockLower) || // PK lookup by full UUID
+    /where\s+task_file\s*=\s*\?/.test(blockLower) || // task_file exact match
+    /select\s+count\s*\(\s*\*\s*\)/.test(blockLower) || // COUNT(*) stats
+    /assigned_to\s*=\s*\?.*where\s+id/.test(blockLower) || // UPDATE by PK
+    /parent_task_id\s*=\s*\?/.test(blockLower) || // Cascade by parent PK
+    /blocked_by\s*=\s*\w+\.id/.test(blockLower) || // JOIN on PK (auto-unblock)
+    /project_name\s*=\s*'/.test(blockLower) || // Migration: hardcoded project rename
+    /device_id\s*is\s*null/.test(blockLower) || // Migration: backfill device_id
+    /status\s*=\s*'completed'/.test(blockLower) || // Migration: status rename
+    /status\s*=\s*'done'.*result\s*is\s*not\s*null/.test(blockLower) || // Migration: bulk close
+    blockLower.includes("conditions.join") || // Dynamic WHERE builder (git-task-sweep)
+    blockLower.includes("exe-rename") || // Rename is intentionally global
+    blockLower.includes("cleanup-stale") || // One-time legacy cleanup script
+    blockLower.includes("title like") || // Cascade cleanup by title pattern
+    blockLower.includes("assigned_to is null");
+    if (!isSafe) {
+      const queryLine = block.split("\n").find(
+        (l) => /FROM.*tasks|UPDATE.*tasks/i.test(l) && !l.trim().startsWith("//") && !l.trim().startsWith("*")
+      );
+      if (queryLine) {
+        const match = queryLine.match(/^([^:]+):(\d+)/);
+        if (match) unscoped.push(`${match[1]}:${match[2]}`);
+      }
+    }
+  }
+  const unique = [...new Set(unscoped)];
+  if (unique.length > 0) {
+    return `${unique.length} unscoped task quer${unique.length === 1 ? "y" : "ies"}: ${unique.slice(0, 5).join(", ")}${unique.length > 5 ? ` (+${unique.length - 5} more)` : ""}`;
+  }
+  return true;
+});
+test("Platform procedures \u2014 shipped as code (not DB only)", () => {
+  const procs = readSrc("src/lib/platform-procedures.ts");
+  const count = (procs.match(/title:/g) || []).length;
+  if (count < 13) return `Only ${count} procedures (expected 13+)`;
+  if (!procs.includes("PLATFORM_PROCEDURE_TITLES")) return "Missing dedup set";
+  return true;
+});
+test("Platform procedures \u2014 customer procedures stay in DB", () => {
+  const global = readSrc("src/lib/global-procedures.ts");
+  if (!global.includes("PLATFORM_PROCEDURE_TITLES")) return "Not filtering platform titles from DB";
+  if (!global.includes("_platformCache")) return "No platform cache";
+  if (!global.includes("_customerCache")) return "No customer cache separation";
+  return true;
+});
+test("Backfill exclusive lock \u2014 only 1 backfill at a time", () => {
+  const gate = readSrc("src/lib/worker-gate.ts");
+  if (!gate.includes("tryAcquireBackfillLock")) return "Missing backfill lock";
+  if (!gate.includes("backfill.lock")) return "Missing lockfile path";
+  const bf = readSrc("src/bin/backfill-vectors.ts");
+  if (!bf.includes("tryAcquireBackfillLock")) return "backfill-vectors.ts not using lock";
+  return true;
+});
+test("Daemon restart \u2014 uses SIGKILL + kills orphans", () => {
+  const orchestrator = readSrc("src/lib/daemon-restart-orchestrator.ts");
+  if (!orchestrator.includes("SIGKILL")) return "Still using SIGTERM";
+  if (!orchestrator.includes("pgrep")) return "No orphan kill via pgrep";
+  return true;
+});
+test("License self-heal \u2014 update mirrors cloud.apiKey to license.key", () => {
+  const update = readSrc("src/bin/update.ts");
+  if (!update.includes("mirrorLicenseKey")) return "update.ts missing license self-heal";
+  return true;
+});
+test("Golden path \u2014 orchestration model documented", () => {
+  if (!existsSync(path.join(ROOT, ".planning/ARCHITECTURE.md"))) return "ARCHITECTURE.md missing";
+  const arch = readFileSync(path.join(ROOT, ".planning/ARCHITECTURE.md"), "utf8");
+  if (!arch.includes("Orchestration Model")) return "Golden path section missing";
+  if (!arch.includes("create_task") || !arch.includes("Dispatch")) return "Dispatch rule missing";
+  return true;
+});
+test("No hardcoded 'yoshi'/'mari' in runtime task routing", () => {
+  const router = readSrc("src/lib/task-router.ts");
+  if (router.includes('"yoshi"') || router.includes("'yoshi'")) return "Hardcoded 'yoshi' in task-router.ts";
+  if (router.includes('"mari"') || router.includes("'mari'")) return "Hardcoded 'mari' in task-router.ts";
+  return true;
+});
+test("No hardcoded agent name\u2192role map in exe-new-employee", () => {
+  const newEmp = readSrc("src/bin/exe-new-employee.ts");
+  if (newEmp.includes("yoshi: ") && newEmp.includes('"cto"')) return "Hardcoded name\u2192role map still in exe-new-employee.ts";
+  return true;
+});
+test("No hardcoded 'exe' coordinator in SQL WHERE clauses", () => {
+  const sqlFiles = [
+    "src/runtime/orchestrator.ts",
+    "src/bin/exe-boot.ts",
+    "src/lib/review-polling.ts",
+    "src/bin/exe-heartbeat.ts",
+    "src/tui/hooks/useOrchestrator.ts"
+  ];
+  const violations = [];
+  for (const f of sqlFiles) {
+    const content = readSrc(f);
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (line.match(/=\s*'exe'/)) {
+        violations.push(`${f}:${i + 1}`);
+      }
+    }
+  }
+  if (violations.length > 0) return `Hardcoded 'exe' in SQL: ${violations.join(", ")}`;
+  return true;
+});
+test("Build output \u2014 referenced standalone dist/bin scripts are explicit tsup entries", () => {
+  const pkg = JSON.parse(readSrc("package.json"));
+  const tsup = readSrc("tsup.config.ts");
+  const commandDocs = execSync(
+    `grep -Rho "dist/bin/[A-Za-z0-9._-]*.js" src/commands package.json 2>/dev/null || true`,
+    { encoding: "utf8", cwd: ROOT }
+  ).trim().split("\n").filter(Boolean);
+  const refs = /* @__PURE__ */ new Set();
+  for (const value of Object.values(pkg.bin ?? {})) {
+    const match = value.match(/dist\/bin\/([^\/]+)\.js$/);
+    if (match?.[1]) refs.add(match[1]);
+  }
+  for (const script of Object.values(pkg.scripts ?? {})) {
+    for (const match of script.matchAll(/dist\/bin\/([A-Za-z0-9._-]+)\.js/g)) {
+      if (match[1]) refs.add(match[1]);
+    }
+  }
+  for (const ref of commandDocs) {
+    const match = ref.match(/dist\/bin\/([A-Za-z0-9._-]+)\.js$/);
+    if (match?.[1]) refs.add(match[1]);
+  }
+  const missing = [...refs].filter((name) => !tsup.includes(`"bin/${name}"`));
+  if (missing.length > 0) return `Missing tsup bin entries: ${missing.join(", ")}`;
+  return true;
+});
+test("Providers \u2014 active code imports lib/providers, not gateway/providers", () => {
+  const hits = execSync(
+    `grep -R "gateway/providers" -n src --include="*.ts" --include="*.tsx" || true`,
+    { encoding: "utf8", cwd: ROOT }
+  ).trim().split("\n").filter(Boolean).filter((line) => !line.includes("src/gateway/providers/") && !line.includes("src/bin/customer-readiness.ts"));
+  if (hits.length > 0) return `Deprecated provider imports: ${hits.slice(0, 3).join("; ")}`;
+  return true;
+});
+test("Support intake \u2014 customer CLI smoke test is routed", () => {
+  const cli = readSrc("src/bin/cli.ts");
+  const support = readSrc("src/bin/exe-support.ts");
+  const tsup = readSrc("tsup.config.ts");
+  const mcpTools = readSrc("src/mcp/tools/support.ts");
+  const registry = readSrc("src/mcp/register-tools.ts");
+  if (!cli.includes('args[0] === "support"')) return "exe-os support route missing";
+  if (!support.includes("support health") || !support.includes("support test")) return "support CLI missing health/test commands";
+  if (!tsup.includes('"bin/exe-support"')) return "exe-support missing from build entries";
+  if (!mcpTools.includes("support_health") || !mcpTools.includes("support_test")) return "support MCP tools missing";
+  if (!registry.includes("registerSupportTools")) return "support MCP tools not registered";
+  return true;
+});
+test("Support intake \u2014 API health route and cloud-sync license fallback exist", () => {
+  const api = readSrc("api-router/src/index.ts");
+  const supportRoutes = readSrc("api-router/src/support-routes.ts");
+  const wrangler = readSrc("api-router/wrangler.toml");
+  if (!api.includes("/v1/support/health")) return "support health route missing";
+  if (!supportRoutes.includes("handleSupportHealth")) return "handleSupportHealth missing";
+  if (!supportRoutes.includes("env.CLOUD_SYNC.fetch")) return "cloud-sync service binding fallback missing";
+  if (!wrangler.includes('binding = "CLOUD_SYNC"')) return "CLOUD_SYNC service binding missing";
+  return true;
+});
+test("CLI/MCP parity \u2014 customer ops wrappers are registered", () => {
+  const registry = readSrc("src/mcp/register-tools.ts");
+  const gates = readSrc("src/lib/tool-gates.ts");
+  const parity = readSrc("src/mcp/tools/cli-parity.ts");
+  const requiredTools = [
+    "healthcheck",
+    "doctor",
+    "rename_employee",
+    "status_brief",
+    "pending_work_summary",
+    "key_status",
+    "key_rotation_preflight",
+    "check_update",
+    "stack_update_check",
+    "cloud_status"
+  ];
+  if (!registry.includes("registerCliParityTools")) return "CLI parity tools not registered";
+  if (!gates.includes("registerCliParityTools")) return "CLI parity tools missing role gate";
+  for (const tool of requiredTools) {
+    if (!parity.includes(`"${tool}"`)) return `Missing MCP wrapper: ${tool}`;
+  }
+  return true;
+});
+test("Platform procedures \u2014 all MCP tool actions documented", () => {
+  const procs = readSrc("src/lib/platform-procedures.ts");
+  const requiredActions = {
+    memory: ["recall", "ask_team", "store", "commit", "search", "session_context", "get_by_id", "consolidate", "cardinality", "supersede"],
+    task: ["create", "list", "get", "update", "close", "checkpoint", "resume"],
+    graph: ["query_relationships", "entity_neighbors", "hot_entities", "stats", "export", "merge_entities", "similar_trajectories"],
+    identity: ["get", "update"],
+    behavior: ["store", "list", "deactivate"],
+    support: ["create_bug", "create_feature", "health", "triage_bug"],
+    message: ["send", "acknowledge"],
+    reminder: ["create", "list", "complete"],
+    session: ["events", "last_response"],
+    wiki: ["list", "get"],
+    document: ["ingest", "list", "purge", "set_importance", "rerank"],
+    diagnostics: ["healthcheck", "doctor", "status_brief", "check_update", "cloud_status", "pending_work_summary", "rename_employee", "tool_search", "drift"],
+    config: ["list_employees", "set_agent_config", "agent_spend", "daemon_health", "license_status", "cloud_sync", "memory_audit", "run_consolidation", "worker_gate", "auto_wake_status", "orchestration_phase", "company_procedure", "global_procedure", "create_trigger", "list_triggers", "export_orchestration", "import_orchestration"]
+  };
+  const requiredParams = [
+    "as_of",
+    // bi-temporal recall
+    "kind",
+    // memory type filter
+    "retrieval_mode",
+    // typed retrieval filtering
+    "procedure_for",
+    // procedure domain tag
+    "spawn_runtime",
+    // per-task runtime override
+    "spawn_model",
+    // per-task model override
+    "blocked_by",
+    // task dependency
+    "parent_task_id",
+    // subtask hierarchy
+    "complexity",
+    // task complexity level
+    "budget_tokens",
+    // token budget cap
+    "worker_gate",
+    // spawn slot check
+    "cloud_action"
+    // nested cloud sync actions
+  ];
+  const missing = [];
+  for (const [domain, actions] of Object.entries(requiredActions)) {
+    for (const action of actions) {
+      if (!procs.includes(action)) {
+        missing.push(`${domain}.${action}`);
+      }
+    }
+  }
+  for (const param of requiredParams) {
+    if (!procs.includes(param)) {
+      missing.push(`param:${param}`);
+    }
+  }
+  if (missing.length > 0) {
+    return `${missing.length} undocumented in procedures: ${missing.slice(0, 5).join(", ")}${missing.length > 5 ? ` (+${missing.length - 5} more)` : ""}`;
+  }
+  return true;
+});
+test("Build output \u2014 all URL-based dynamic imports have matching tsup entry points", () => {
+  const tsup = readSrc("tsup.config.ts");
+  const srcFiles = execSync(
+    `find src -name "*.ts" -not -path "*/node_modules/*" 2>/dev/null || true`,
+    { encoding: "utf8", cwd: ROOT }
+  ).trim().split("\n").filter(Boolean);
+  const missing = [];
+  for (const file of srcFiles) {
+    if (file.includes("customer-readiness")) continue;
+    const content = readSrc(file);
+    const urlImports = content.matchAll(/new URL\(\s*["'](\.\.?\/[^"'*]+\.js)["']\s*,\s*import\.meta\.url\s*\)/g);
+    for (const match of urlImports) {
+      const relPath = match[1];
+      if (relPath.includes("package.json")) continue;
+      const srcDir = path.dirname(file);
+      const resolved = path.normalize(path.join(srcDir, relPath));
+      const distKey = resolved.replace(/^src\//, "").replace(/\.js$/, "");
+      if (distKey.includes("..")) continue;
+      if (!tsup.includes(`"${distKey}"`)) {
+        missing.push(`${file} \u2192 ${relPath} (needs tsup entry: "${distKey}")`);
+      }
+    }
+  }
+  if (missing.length > 0) {
+    return `Dynamic imports without tsup entries will crash at runtime:
+  ${missing.join("\n  ")}`;
+  }
+  return true;
+});
+test("Build output \u2014 every tsup entry point has a corresponding dist/ file", () => {
+  const tsup = readSrc("tsup.config.ts");
+  const entryPattern = /"([^"]+)":\s*"src\//g;
+  const entries = [];
+  for (const match of tsup.matchAll(entryPattern)) {
+    if (match[1]) entries.push(match[1]);
+  }
+  const missing = [];
+  for (const entry of entries) {
+    const distPath = path.join(ROOT, "dist", entry + ".js");
+    if (!existsSync(distPath)) {
+      missing.push(`dist/${entry}.js`);
+    }
+  }
+  if (missing.length > 0) {
+    return `Missing dist files (build incomplete): ${missing.join(", ")}`;
+  }
+  return true;
+});
+console.log(`
+\x1B[1m${pass + fail} tests: ${pass} passed, ${fail} failed\x1B[0m
+`);
+if (fail > 0) {
+  console.log("\x1B[31mCustomer readiness gate FAILED \u2014 do not publish.\x1B[0m\n");
+  process.exit(1);
+} else {
+  console.log("\x1B[32mCustomer readiness gate PASSED \u2014 safe to publish.\x1B[0m\n");
+}

package/dist/bin/deferred-daemon-restart.js

@@ -0,0 +1,123 @@
+#!/usr/bin/env node
+import {
+  requestDeployRestart
+} from "../chunk-PWMMIGVQ.js";
+import "../chunk-R5U7XKVJ.js";
+
+// src/bin/deferred-daemon-restart.ts
+import { existsSync, openSync, closeSync, writeFileSync, unlinkSync } from "fs";
+import { spawn, execSync } from "child_process";
+import path from "path";
+import os from "os";
+var EXE_DIR = path.join(os.homedir(), ".exe-os");
+var DAEMON_PORT = 48739;
+var DEFERRED_RESTART_PID_PATH = path.join(EXE_DIR, "deferred-restart.pid");
+try {
+  writeFileSync(DEFERRED_RESTART_PID_PATH, String(process.pid));
+} catch {
+}
+function cleanupPid() {
+  try {
+    unlinkSync(DEFERRED_RESTART_PID_PATH);
+  } catch {
+  }
+}
+process.on("exit", cleanupPid);
+process.on("SIGTERM", () => {
+  cleanupPid();
+  process.exit(0);
+});
+process.on("SIGINT", () => {
+  cleanupPid();
+  process.exit(0);
+});
+var DELAY_MS = parseInt(process.env.EXE_DEFERRED_DELAY_MS ?? "3000", 10);
+await new Promise((resolve) => setTimeout(resolve, DELAY_MS));
+process.stderr.write("[deferred-restart] Starting daemon restart...\n");
+var result = requestDeployRestart("deploy-deferred");
+if (!result.ok) {
+  process.stderr.write(`[deferred-restart] Kill phase skipped: ${result.skipped}
+`);
+}
+try {
+  const launchdCheck = execSync("launchctl list com.askexe.exed 2>/dev/null", { encoding: "utf8", timeout: 3e3 });
+  if (launchdCheck.includes("com.askexe.exed")) {
+    process.stderr.write("[deferred-restart] launchd manages daemon \u2014 it will auto-restart. Done.\n");
+    process.exit(0);
+  }
+} catch {
+}
+var totalGB = os.totalmem() / (1024 * 1024 * 1024);
+function resolvePackageRoot() {
+  let dir = path.dirname(new URL(import.meta.url).pathname);
+  for (let i = 0; i < 5; i++) {
+    if (existsSync(path.join(dir, "package.json"))) return dir;
+    dir = path.dirname(dir);
+  }
+  try {
+    const globalRoot = execSync("npm root -g", { encoding: "utf8", timeout: 5e3 }).trim();
+    const pkgDir = path.join(globalRoot, "@askexenow", "exe-os");
+    if (existsSync(path.join(pkgDir, "package.json"))) return pkgDir;
+  } catch {
+  }
+  throw new Error("Cannot find exe-os package root");
+}
+try {
+  const pkgRoot = resolvePackageRoot();
+  const daemonPath = path.join(pkgRoot, "dist", "lib", "exe-daemon.js");
+  if (!existsSync(daemonPath)) {
+    process.stderr.write(`[deferred-restart] daemon not found at ${daemonPath}
+`);
+    process.exit(1);
+  }
+  const logPath = path.join(EXE_DIR, "exed.log");
+  const pidPath = path.join(EXE_DIR, "exed.pid");
+  const sockPath = path.join(EXE_DIR, "exed.sock");
+  let stderrFd = "ignore";
+  try {
+    stderrFd = openSync(logPath, "a");
+  } catch {
+  }
+  const heapCapMB = totalGB <= 8 ? 256 : Math.min(Math.max(2048, Math.round(totalGB * 0.25 * 1024)), 6144);
+  const child = spawn(process.execPath, [`--max-old-space-size=${heapCapMB}`, daemonPath], {
+    detached: true,
+    stdio: ["ignore", "ignore", stderrFd],
+    env: {
+      ...process.env,
+      EXE_DAEMON_SOCK: sockPath,
+      EXE_DAEMON_PID: pidPath
+    }
+  });
+  child.unref();
+  if (typeof stderrFd === "number") {
+    try {
+      closeSync(stderrFd);
+    } catch {
+    }
+  }
+  let daemonHealthy = false;
+  for (let attempt = 1; attempt <= 10; attempt++) {
+    await new Promise((r) => setTimeout(r, 1e3));
+    try {
+      const healthResp = execSync(
+        `curl -sf http://127.0.0.1:${DAEMON_PORT}/health 2>/dev/null`,
+        { encoding: "utf8", timeout: 3e3 }
+      );
+      if (healthResp.includes("ok") || healthResp.includes("healthy")) {
+        daemonHealthy = true;
+        break;
+      }
+    } catch {
+    }
+  }
+  if (daemonHealthy) {
+    process.stderr.write("[deferred-restart] Daemon restarted and healthy\n");
+  } else {
+    process.stderr.write("[deferred-restart] Daemon spawned but health check pending\n");
+  }
+} catch (err) {
+  process.stderr.write(`[deferred-restart] Failed: ${err instanceof Error ? err.message : String(err)}
+`);
+  process.exit(1);
+}
+process.exit(0);

package/dist/bin/exe-agent-config.js

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+import {
+  DEFAULT_MODELS,
+  KNOWN_RUNTIMES,
+  clearAgentRuntime,
+  getAgentRuntime,
+  loadAgentConfig,
+  setAgentRuntime
+} from "../chunk-GVP5U4WL.js";
+import {
+  DEFAULT_RUNTIME
+} from "../chunk-NGP6LSV2.js";
+import {
+  loadEmployeesSync
+} from "../chunk-UJOSFVWG.js";
+import "../chunk-QHIGMP2M.js";
+import "../chunk-FXU7JOXK.js";
+import "../chunk-TNTFEWU5.js";
+import "../chunk-LYH5HE24.js";
+import "../chunk-R5U7XKVJ.js";
+
+// src/bin/exe-agent-config.ts
+function showAll() {
+  const config = loadAgentConfig();
+  let employees = [];
+  try {
+    employees = loadEmployeesSync();
+  } catch {
+    process.stderr.write("Warning: could not load employee roster\n");
+  }
+  if (employees.length === 0) {
+    console.log("No employees in roster.");
+    return;
+  }
+  console.log("");
+  console.log("Agent Runtime Configuration");
+  console.log("\u2550".repeat(65));
+  console.log(
+    "Agent".padEnd(10) + "Role".padEnd(22) + "Runtime".padEnd(12) + "Model"
+  );
+  console.log("\u2500".repeat(65));
+  for (const emp of employees) {
+    const entry = config[emp.name];
+    const runtime = entry?.runtime ?? DEFAULT_RUNTIME;
+    const model = entry?.model ?? DEFAULT_MODELS[DEFAULT_RUNTIME];
+    const configured = entry ? "" : " (default)";
+    const role = (emp.role ?? "").length > 20 ? (emp.role ?? "").slice(0, 18) + ".." : emp.role ?? "";
+    console.log(
+      emp.name.padEnd(10) + role.padEnd(22) + runtime.padEnd(12) + model + configured
+    );
+  }
+  console.log("\u2500".repeat(65));
+  console.log("");
+  console.log("Available runtimes:");
+  for (const [rt, models] of Object.entries(KNOWN_RUNTIMES)) {
+    console.log(`  ${rt}: ${models.join(", ")}`);
+  }
+  console.log("");
+}
+function main() {
+  const args = process.argv.slice(2);
+  if (args.length === 0) {
+    showAll();
+    return;
+  }
+  const agentId = args[0];
+  if (args[1] === "--clear") {
+    clearAgentRuntime(agentId);
+    console.log(`Cleared config for ${agentId} \u2014 will use defaults.`);
+    return;
+  }
+  if (args.length < 3) {
+    const rt = getAgentRuntime(agentId);
+    console.log(`${agentId}: runtime=${rt.runtime} model=${rt.model}`);
+    return;
+  }
+  const runtime = args[1];
+  const model = args[2];
+  const result = setAgentRuntime(agentId, runtime, model);
+  if (!result.ok) {
+    process.stderr.write(`Error: ${result.error}
+`);
+    process.exit(1);
+  }
+  console.log(`Set ${agentId} \u2192 runtime=${runtime} model=${model}`);
+}
+main();