nemoris 0.1.0

package/src/cli-main.js

@@ -0,0 +1,2763 @@
+import os from "node:os";
+import path from "node:path";
+import fs from "node:fs";
+import { fileURLToPath } from "node:url";
+import {
+  notifyCompaction,
+  parseConversationTurns,
+  resolveCompactionCondensedFanout,
+  resolveCompactionThreshold,
+} from "./utils/compaction.js";
+import { MemoryStore } from "./memory/memory-store.js";
+import { buildTaskPacket } from "./runtime/task-packet.js";
+import { JobRunner } from "./jobs/job-runner.js";
+import { OpenClawShadowBridge } from "./shadow/bridge.js";
+import { ProviderRegistry } from "./providers/registry.js";
+import { Scheduler } from "./runtime/scheduler.js";
+import { Executor } from "./runtime/executor.js";
+import { SchedulerDaemon, acquireDaemonLifecycleLock } from "./runtime/daemon.js";
+import { RunReviewer } from "./runtime/review.js";
+import { Evaluator } from "./runtime/evaluation.js";
+import { EmbeddingService } from "./memory/embedding-service.js";
+import { EmbeddingIndex } from "./memory/embedding-index.js";
+import { DeliveryManager } from "./runtime/delivery-manager.js";
+import { StandaloneTransportServer } from "./runtime/transport-server.js";
+import { PeerRegistry } from "./runtime/peer-registry.js";
+import { RunStore } from "./runtime/run-store.js";
+import { NotificationStore } from "./runtime/notification-store.js";
+import { DeliveryStore } from "./runtime/delivery-store.js";
+import { buildRetentionPolicy, pruneJsonBuckets } from "./runtime/retention.js";
+import { ImprovementHarness } from "./runtime/improvement-harness.js";
+import { getReportFallbackPolicy } from "./runtime/report-fallback.js";
+import { buildLaneReadiness } from "./runtime/lane-readiness.js";
+import { DependencyHealth } from "./runtime/dependency-health.js";
+import { PeerReadinessProbe } from "./runtime/peer-readiness.js";
+import { buildPilotStatus } from "./runtime/pilot-status.js";
+import { buildCutoverReadiness } from "./runtime/cutover-readiness.js";
+import { validateAllConfigs } from "./config/schema-validator.js";
+import { buildRuntimeStatus, formatRuntimeStatus } from "./runtime/status-aggregator.js";
+import { resolveAlias } from "./onboarding/aliases.js";
+import { registerWebhook, whoami, getMe } from "./runtime/telegram-inbound.js";
+import { formatCommandHelp, formatGeneralHelp, hasHelpFlag, isKnownCommand, shouldShowAllCommands } from "./cli/help.js";
+import {
+  MCP_EMPTY_STATE_MESSAGE,
+  getDaemonPaths,
+  isPidRunning,
+  listServeDaemonPids,
+  restartDaemonCommand,
+  readTrackedPid,
+  runLogsCommand,
+  startDaemonCommand,
+  stopDaemonCommand,
+} from "./cli/runtime-control.js";
+import { resolveAuthProfilesPath, resolveInstallDir } from "./auth/auth-profiles.js";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const projectRoot = path.join(__dirname, "..");
+const stateRoot = path.join(projectRoot, "state", "memory");
+const liveRoot = resolveLiveRoot(projectRoot);
+const scheduler = new Scheduler({
+  projectRoot,
+  liveRoot,
+  stateRoot: path.join(projectRoot, "state")
+});
+const executor = new Executor({
+  projectRoot,
+  liveRoot,
+  stateRoot: path.join(projectRoot, "state")
+});
+const daemon = new SchedulerDaemon({
+  projectRoot,
+  liveRoot,
+  stateRoot: path.join(projectRoot, "state")
+});
+const reviewer = new RunReviewer({
+  stateRoot: path.join(projectRoot, "state")
+});
+const deliveryManager = new DeliveryManager({
+  projectRoot,
+  liveRoot,
+  stateRoot: path.join(projectRoot, "state")
+});
+const evaluator = new Evaluator({
+  projectRoot,
+  liveRoot,
+  stateRoot: path.join(projectRoot, "state")
+});
+const improvementHarness = new ImprovementHarness({
+  projectRoot,
+  stateRoot: path.join(projectRoot, "state"),
+  executor,
+  evaluator
+});
+const dependencyHealth = new DependencyHealth({
+  projectRoot,
+  liveRoot
+});
+const peerReadinessProbe = new PeerReadinessProbe({ liveRoot });
+const embeddingService = new EmbeddingService({ projectRoot });
+const embeddingIndex = new EmbeddingIndex({
+  rootDir: path.join(projectRoot, "state", "memory"),
+  embeddingService
+});
+
+function resolveLiveRoot(projectRoot) {
+  if (process.env.NEMORIS_STANDALONE === "1" || process.env.NEMORIS_STANDALONE === "true") {
+    return null;
+  }
+  const explicit = process.env.NEMORIS_LIVE_ROOT;
+  if (!explicit) {
+    const homedir = process.env.HOME || os.homedir();
+    return path.join(homedir, ".openclaw");
+  }
+  return path.isAbsolute(explicit) ? explicit : path.resolve(projectRoot, explicit);
+}
+
+function parseArgs(argv) {
+  const [command, ...rest] = argv.slice(2);
+  return { command, rest };
+}
+
+function parseFlagValue(args, flag) {
+  const index = args.indexOf(flag);
+  if (index === -1) return null;
+  const value = args[index + 1];
+  if (!value || value.startsWith("--")) return null;
+  return value;
+}
+
+function resolveRuntimeInstallDir() {
+  return resolveInstallDir({ env: process.env, cwd: process.cwd() });
+}
+
+async function seedDemo(memoryStore) {
+  await memoryStore.appendEvent("main", {
+    title: "heartbeat status",
+    content: "Heartbeat found no urgent notifications but token budget was tight in the morning run.",
+    category: "health_summary",
+    salience: 0.52
+  });
+
+  await memoryStore.writeSummary("main", {
+    title: "memory rollout decision",
+    summary: "Use policy-gated durable memory with checkpoints instead of transcript compaction.",
+    content: "The system should store facts and summaries separately and keep job loops resumable.",
+    category: "decision",
+    salience: 0.9
+  });
+
+  await memoryStore.writeFact(
+    "main",
+    {
+      title: "local model lane",
+      content: "Use local Ollama models for heartbeat, extraction, formatting, and cheap cron work only.",
+      category: "workflow_rule",
+      reason: "Preserves cost control without giving sensitive orchestration to a weak model.",
+      sourceRefs: ["ARCHITECTURE.md"]
+    },
+    {
+      allow_durable_writes: true,
+      require_source_reference: true,
+      require_write_reason: true,
+      max_writes_per_run: 5,
+      categories: {
+        allowed: ["workflow_rule", "decision"],
+        blocked: ["ephemeral_chatter"]
+      }
+    }
+  );
+
+  await memoryStore.putScratchpad("main", "current-build", {
+    title: "open tasks",
+    content: "Implement provider adapters after the memory-first core is stable.",
+    category: "pending_work",
+    expiresAt: new Date(Date.now() + 12 * 60 * 60 * 1000).toISOString(),
+    salience: 0.65
+  });
+
+  await memoryStore.saveCheckpoint("main", "latest", {
+    objective: "Build the parallel-safe V2 runtime",
+    status: "in_progress",
+    nextActions: ["add provider adapters", "build shadow-mode bridge"],
+    blockers: []
+  });
+}
+
+async function runDemo() {
+  const memoryStore = new MemoryStore({ rootDir: stateRoot });
+  await seedDemo(memoryStore);
+
+  const packet = await buildTaskPacket({
+    agentId: "main",
+    objective: "Design a heartbeat and memory rollup system with low token overhead",
+    memoryStore,
+    allowedTools: ["read_file", "list_dir", "run_tests"],
+    artifactRefs: ["ARCHITECTURE.md", "MEMORY_SYSTEM.md"],
+    budget: {
+      maxTokens: 6000,
+      maxRuntimeSeconds: 45
+    }
+  });
+
+  const runner = new JobRunner({ memoryStore });
+  const result = await runner.run(
+    {
+      id: "workspace-health",
+      agentId: "main",
+      taskType: "workspace_health",
+      budget: {
+        maxTokens: 2000,
+        maxRuntimeSeconds: 15
+      }
+    },
+    async () => ({
+      summary: "Workspace health demo completed without touching live OpenClaw state.",
+      output: "Demo run confirmed that the memory-first runtime can checkpoint and summarize job results.",
+      nextActions: ["implement provider adapters"]
+    })
+  );
+
+  console.log(JSON.stringify({ packet, result }, null, 2));
+}
+
+async function inspectMemory(agentId, query) {
+  const memoryStore = new MemoryStore({ rootDir: stateRoot });
+  const result = await memoryStore.query(agentId, query, { limit: 10 });
+  console.log(JSON.stringify(result, null, 2));
+}
+
+async function shadowSummary(agentId) {
+  const bridge = new OpenClawShadowBridge({ liveRoot });
+  const summary = await bridge.buildWorkspaceSnapshot(agentId);
+  console.log(
+    JSON.stringify(
+      {
+        agentId,
+        docs: summary.docs.map((doc) => doc.fullPath),
+        recentMemory: summary.recentMemory.map((entry) => entry.filePath),
+        sessions: summary.sessionEntries.slice(0, 5)
+      },
+      null,
+      2
+    )
+  );
+}
+
+async function shadowImport(agentId) {
+  const memoryStore = new MemoryStore({ rootDir: stateRoot });
+  const bridge = new OpenClawShadowBridge({ liveRoot });
+  const policy = {
+    allow_durable_writes: true,
+    require_source_reference: true,
+    require_write_reason: true,
+    max_writes_per_run: 5,
+    categories: {
+      allowed: ["artifact_summary"],
+      blocked: ["ephemeral_chatter", "raw_tool_output"]
+    }
+  };
+  const result = await bridge.importWorkspaceSnapshot(agentId, memoryStore, policy);
+  console.log(
+    JSON.stringify(
+      {
+        agentId,
+        importedDocs: result.docs.length,
+        importedMemoryFiles: result.recentMemory.length
+      },
+      null,
+      2
+    )
+  );
+}
+
+async function providerHealth(providerId) {
+  const registry = new ProviderRegistry();
+  const providerConfigs = {
+    anthropic: {
+      id: "anthropic",
+      adapter: "anthropic",
+      authRef: "env:NEMORIS_ANTHROPIC_API_KEY",
+      baseUrl: "https://api.anthropic.com"
+    },
+    openrouter: {
+      id: "openrouter",
+      adapter: "openrouter",
+      authRef: "env:OPENROUTER_API_KEY",
+      baseUrl: "https://openrouter.ai/api/v1",
+      appName: "Nemoris V2"
+    },
+    ollama: {
+      id: "ollama",
+      adapter: "ollama",
+      authRef: "env:OLLAMA_API_KEY",
+      baseUrl: "http://127.0.0.1:11434"
+    }
+  };
+
+  const adapter = registry.create(providerConfigs[providerId]);
+  const result = await adapter.healthCheck();
+  console.log(JSON.stringify(result, null, 2));
+}
+
+async function providerCapabilities(providerId) {
+  const runtime = await scheduler.loadRuntime();
+  const providerConfig = runtime.providers[providerId];
+  if (!providerConfig) {
+    throw new Error(`Unknown provider: ${providerId}`);
+  }
+
+  const registry = new ProviderRegistry();
+  const result = registry.describe(providerConfig);
+  console.log(JSON.stringify(result, null, 2));
+}
+
+async function manifestSummary() {
+  const runtime = await scheduler.loadRuntime();
+  console.log(
+    JSON.stringify(
+      {
+        providers: Object.keys(runtime.providers),
+        agents: Object.keys(runtime.agents),
+        jobs: Object.keys(runtime.jobs),
+        policies: Object.keys(runtime.policies),
+        lanes: Object.keys(runtime.router)
+      },
+      null,
+      2
+    )
+  );
+}
+
+async function planJob(jobId) {
+  const plan = await scheduler.hydrateJob(jobId, { shadowImport: true });
+  console.log(JSON.stringify(plan, null, 2));
+}
+
+async function liveCronSummary() {
+  const summary = await scheduler.summarizeLiveCron();
+  console.log(JSON.stringify(summary, null, 2));
+}
+
+async function compareJobs() {
+  const comparison = await scheduler.compareJobs();
+  console.log(JSON.stringify(comparison, null, 2));
+}
+
+async function executeJob(jobId, mode = "dry-run", modelOverride = null) {
+  const result = await executor.executeJob(jobId, {
+    mode,
+    shadowImport: true,
+    modelOverride
+  });
+  console.log(
+    JSON.stringify(
+      {
+        filePath: result.filePath,
+        mode: result.mode,
+        providerId: result.providerId,
+        modelId: result.modelId,
+        routingDecision: result.routingDecision,
+        fallback: result.fallback || null,
+        providerHealth: result.providerHealth,
+        preflight: result.preflight,
+        summary: result.result.summary,
+        nextActions: result.result.nextActions,
+        notificationFiles: result.notificationFiles || []
+      },
+      null,
+      2
+    )
+  );
+}
+
+async function executeJobWithReportFallback(jobId, mode = "provider", modelOverride = null) {
+  const result = await executor.executeJob(jobId, {
+    mode,
+    shadowImport: true,
+    modelOverride,
+    allowReportFallback: true
+  });
+  console.log(
+    JSON.stringify(
+      {
+        filePath: result.filePath,
+        mode: result.mode,
+        providerId: result.providerId,
+        modelId: result.modelId,
+        routingDecision: result.routingDecision,
+        fallback: result.fallback || null,
+        providerHealth: result.providerHealth,
+        preflight: result.preflight,
+        summary: result.result.summary,
+        nextActions: result.result.nextActions,
+        notificationFiles: result.notificationFiles || []
+      },
+      null,
+      2
+    )
+  );
+}
+
+async function shadowCompare(jobId) {
+  const comparison = await executor.shadowCompare(jobId);
+  console.log(JSON.stringify(comparison, null, 2));
+}
+
+async function providerModePolicy() {
+  const { getProviderModePolicy } = await import("./runtime/guards.js");
+  console.log(JSON.stringify(getProviderModePolicy(), null, 2));
+}
+
+async function tickScheduler(mode = "dry-run") {
+  const result = await daemon.tick({
+    now: new Date(),
+    mode
+  });
+  console.log(JSON.stringify(result, null, 2));
+}
+
+async function dueJobs() {
+  const jobs = await daemon.listDueJobs(new Date());
+  console.log(JSON.stringify(jobs, null, 2));
+}
+
+async function reviewRuns(limit = 10) {
+  const review = await reviewer.review(Number(limit));
+  console.log(JSON.stringify(review, null, 2));
+}
+
+async function reviewNotifications(limit = 10) {
+  const notifications = await reviewer.notificationStore.listRecent(Number(limit));
+  console.log(JSON.stringify(notifications, null, 2));
+}
+
+async function reviewDeliveries(limit = 10) {
+  const deliveries = await reviewer.deliveryStore.listRecent(Number(limit));
+  console.log(JSON.stringify(deliveries, null, 2));
+}
+
+async function reviewPendingHandoffs(limit = 10) {
+  const handoffs = await deliveryManager.listPendingHandoffs(Number(limit));
+  console.log(JSON.stringify(handoffs, null, 2));
+}
+
+async function sweepPendingHandoffs() {
+  const runtime = await scheduler.loadRuntime();
+  const result = await deliveryManager.sweepPendingHandoffs({
+    timeoutMinutes: runtime.runtime?.handoffs?.pendingTimeoutMinutes,
+    escalateOnExpiry: runtime.runtime?.handoffs?.escalateOnExpiry,
+    escalationDeliveryProfile: runtime.runtime?.handoffs?.escalationDeliveryProfile
+  });
+  console.log(JSON.stringify(result, null, 2));
+}
+
+async function deliverNotifications(mode = "shadow", limit = "10") {
+  const result = await deliveryManager.deliverPending({
+    mode,
+    limit: Number(limit)
+  });
+  console.log(JSON.stringify(result, null, 2));
+}
+
+async function deliverNotificationFile(mode = "shadow", notificationFilePath = null) {
+  if (!notificationFilePath) {
+    throw new Error("deliver-notification-file requires <mode> <notification-file-path>");
+  }
+  const resolvedPath = path.isAbsolute(notificationFilePath)
+    ? notificationFilePath
+    : path.resolve(projectRoot, notificationFilePath);
+  const result = await deliveryManager.deliverPending({
+    mode,
+    limit: 1,
+    notificationFiles: [resolvedPath]
+  });
+  console.log(JSON.stringify(result, null, 2));
+}
+
+async function maintenanceStatus() {
+  const state = await daemon.stateStore.getMeta("maintenance", null);
+  console.log(JSON.stringify(state, null, 2));
+}
+
+async function resolveDeliveryProfile(profileName = "gateway_preview_main") {
+  const runtime = await scheduler.loadRuntime();
+  const profile = await deliveryManager.resolveProfileConfig(
+    profileName,
+    deliveryManager.resolveProfileEntry(runtime.delivery, profileName) || {}
+  );
+  console.log(JSON.stringify(profile, null, 2));
+}
+
+async function sendTestDelivery(profileName = "gateway_preview_main", mode = "shadow", ...messageParts) {
+  const message =
+    messageParts.join(" ").trim() ||
+    `Nemoris V2 delivery test · ${new Date().toISOString()} · mode=${mode} · profile=${profileName}`;
+  const result = await deliveryManager.sendTestDelivery({
+    profileName,
+    mode,
+    message
+  });
+  console.log(JSON.stringify(result, null, 2));
+}
+
+async function chooseHandoffPeer(notificationFilePath, peerId, deliveryProfile = null) {
+  if (!notificationFilePath || !peerId) {
+    throw new Error("choose-handoff-peer requires <notification-file-path> and <peer-id>");
+  }
+  const resolvedPath = path.isAbsolute(notificationFilePath)
+    ? notificationFilePath
+    : path.resolve(projectRoot, notificationFilePath);
+  const result = await deliveryManager.chooseHandoffPeer(resolvedPath, peerId, {
+    deliveryProfile
+  });
+  console.log(JSON.stringify(result, null, 2));
+}
+
+async function chooseTopHandoffPeer(notificationFilePath, deliveryProfile = null) {
+  if (!notificationFilePath) {
+    throw new Error("choose-top-handoff-peer requires <notification-file-path>");
+  }
+  const resolvedPath = path.isAbsolute(notificationFilePath)
+    ? notificationFilePath
+    : path.resolve(projectRoot, notificationFilePath);
+  const result = await deliveryManager.chooseTopSuggestedPeer(resolvedPath, {
+    deliveryProfile
+  });
+  console.log(JSON.stringify(result, null, 2));
+}
+
+async function serveTransport(port = "4318") {
+  const authToken = process.env.NEMORIS_TRANSPORT_TOKEN || null;
+  const runtime = await scheduler.loadRuntime();
+  const server = new StandaloneTransportServer({
+    stateRoot: path.join(projectRoot, "state"),
+    authToken,
+    retention: runtime.runtime?.retention?.transportInbox || {},
+    requestTimeoutMs: runtime.runtime?.shutdown?.transportShutdownTimeoutMs || 5000
+  });
+  // Attach Telegram inbound if configured
+  const telegramConfig = runtime.runtime?.telegram;
+  if (telegramConfig?.operatorChatId) {
+    const schedulerStateStore = daemon.stateStore;
+    await schedulerStateStore.ensureReady();
+    const peerNames = Object.keys(runtime.peers?.peers || {});
+    const agentNames = Object.fromEntries(
+      Object.entries(runtime.agents || {}).map(([id, agent]) => [id, agent?.name || id])
+    );
+    server.attachTelegramInbound({
+      stateStore: schedulerStateStore,
+      telegramConfig,
+      availablePeers: peerNames,
+      contextLedger: null,
+      agentNames,
+      routerConfig: runtime.router,
+      agentConfigs: runtime.agents,
+    });
+    const execApprovalGate = server.telegramHandler?.getExecApprovalGate?.();
+    daemon.executor.setExecApprovalGate(execApprovalGate);
+    executor.setExecApprovalGate(execApprovalGate);
+  }
+
+  // Attach Slack inbound if configured
+  const slackConfig = runtime.runtime?.slack;
+  if (slackConfig?.enabled) {
+    const schedulerStateStore = daemon.stateStore;
+    await schedulerStateStore.ensureReady();
+    const peerNames = Object.keys(runtime.peers?.peers || {});
+    server.attachSlackInbound({
+      stateStore: schedulerStateStore,
+      slackConfig,
+      availablePeers: peerNames,
+    });
+  }
+
+  const address = await server.listen(Number(port) || 4318, "127.0.0.1");
+  const shutdown = async () => {
+    await server.close();
+    process.exit(0);
+  };
+  process.once("SIGINT", shutdown);
+  process.once("SIGTERM", shutdown);
+  console.log(
+    JSON.stringify(
+      {
+        ok: true,
+        transport: "standalone_http",
+        address,
+        authRequired: Boolean(authToken)
+      },
+      null,
+      2
+    )
+  );
+}
+
+async function setupTelegram() {
+  const runtime = await scheduler.loadRuntime();
+  const telegramConfig = runtime.runtime?.telegram || {};
+
+  const tokenEnvName = telegramConfig.botTokenEnv || "NEMORIS_TELEGRAM_BOT_TOKEN";
+  const token = process.env[tokenEnvName];
+  if (!token) {
+    console.log(`\n❌ ${tokenEnvName} is not set.`);
+    console.log(`   Get a token from @BotFather on Telegram and set it in your environment.`);
+    console.log(`   Example: export ${tokenEnvName}=your-bot-token\n`);
+    process.exitCode = 1;
+    return;
+  }
+
+  // Validate token against Telegram API
+  const me = await getMe(token);
+  if (me.ok) {
+    console.log(`✅ Token valid — @${me.username}`);
+  } else {
+    console.log(`❌ Token invalid: ${me.error}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  if (telegramConfig.operatorChatId) {
+    console.log(`✅ Operator chat ID: ${telegramConfig.operatorChatId}`);
+  } else {
+    console.log(`\n⚠️  telegram.operator_chat_id is not set in config/runtime.toml.`);
+    console.log(`   Run: nemoris telegram whoami`);
+    console.log(`   Then add your chat_id to config/runtime.toml.\n`);
+  }
+
+  if (telegramConfig.pollingMode) {
+    console.log(`✅ Mode: long polling (no webhook needed)`);
+    return;
+  }
+
+  const webhookUrl = telegramConfig.webhookUrl;
+  if (!webhookUrl) {
+    console.log(`\n❌ telegram.webhook_url is not configured in config/runtime.toml.`);
+    console.log(`   You need a public URL for webhooks, or switch to polling_mode = true.\n`);
+    process.exitCode = 1;
+    return;
+  }
+
+  console.log(`\nRegistering webhook...`);
+  const result = await registerWebhook(token, webhookUrl);
+  if (result.ok) {
+    console.log(`✅ Webhook registered: ${webhookUrl}/telegram/webhook`);
+  } else {
+    console.log(`❌ Webhook registration failed: ${result.error}`);
+    process.exitCode = 1;
+  }
+}
+
+function formatModelsOverview(overview) {
+  const lines = [
+    "Auth overview",
+    "─────────────────────────────────────────",
+  ];
+
+  for (const entry of overview.authLines || []) {
+    lines.push(`  ${entry.provider.padEnd(13)} ${entry.ok ? "✓" : "✗"}  ${entry.method}  ${entry.detail}`);
+  }
+
+  lines.push("");
+  lines.push("Models");
+  lines.push("─────────────────────────────────────────");
+  lines.push(`  Default    : ${overview.defaultModel || "not configured"}`);
+  lines.push(`  Fallback   : ${overview.fallbackModel || "not configured"}`);
+  lines.push(`  Local      : ${overview.localModel || "not configured"}`);
+  return `${lines.join("\n")}\n`;
+}
+
+async function showModelsOverview(installDir = resolveRuntimeInstallDir()) {
+  const loader = new ConfigLoader({ rootDir: path.join(installDir, "config") });
+  const [{ buildModelsOverview }, router, providers] = await Promise.all([
+    import("./onboarding/model-catalog.js"),
+    loader.loadRouter(),
+    loader.loadProviders(),
+  ]);
+
+  const overview = buildModelsOverview({
+    router,
+    providers,
+    authProfilesPath: resolveAuthProfilesPath({ env: process.env, cwd: process.cwd() }),
+  });
+  writeOutput(process.stdout, formatModelsOverview(overview));
+}
+
+async function telegramWhoami() {
+  const runtime = await scheduler.loadRuntime();
+  const telegramConfig = runtime.runtime?.telegram || {};
+  const tokenEnvName = telegramConfig.botTokenEnv || "NEMORIS_TELEGRAM_BOT_TOKEN";
+  const token = process.env[tokenEnvName];
+  if (!token) {
+    console.log(`❌ ${tokenEnvName} is not set. Cannot query Telegram.`);
+    process.exitCode = 1;
+    return;
+  }
+
+  console.log("Querying Telegram for your chat info...");
+  const result = await whoami(token, { webhookUrl: telegramConfig.webhookUrl || null });
+  if (!result) {
+    console.log("No messages found. Send a message to your bot first, then re-run this command.");
+    return;
+  }
+  console.log(`\n  chat_id:    ${result.chatId}`);
+  console.log(`  username:   ${result.username || "(not set)"}`);
+  console.log(`  first_name: ${result.firstName || "(not set)"}`);
+  console.log(`\nAdd this to config/runtime.toml:`);
+  console.log(`  operator_chat_id = "${result.chatId}"\n`);
+}
+
+async function serveDaemon(mode = "dry-run", intervalMs = "30000", installDir = null) {
+  const root = installDir || resolveRuntimeInstallDir();
+  const rootLiveRoot = resolveLiveRoot(root);
+  const stateDir = path.join(root, "state");
+
+  // Construct fresh instances scoped to the correct install dir —
+  // module-level singletons use __dirname which points to the npm
+  // package dir, not the user's install dir.
+  const localScheduler = new Scheduler({
+    projectRoot: root,
+    liveRoot: rootLiveRoot,
+    stateRoot: stateDir
+  });
+  const localExecutor = new Executor({
+    projectRoot: root,
+    liveRoot: rootLiveRoot,
+    stateRoot: stateDir
+  });
+  const localDaemon = new SchedulerDaemon({
+    projectRoot: root,
+    liveRoot: rootLiveRoot,
+    stateRoot: stateDir
+  });
+  // Wire executor into daemon
+  localDaemon.executor = localExecutor;
+
+  const runtime = await localScheduler.loadRuntime();
+  fs.mkdirSync(stateDir, { recursive: true });
+
+  // Acquire exclusive daemon lock — prevents multiple daemon processes from running simultaneously.
+  const lockResult = acquireDaemonLifecycleLock({ stateDir });
+  if (!lockResult || !lockResult.release) {
+    // Lock held by another process — acquireDaemonLifecycleLock already printed error.
+    process.exit(1);
+  }
+  const { pidFile, release: releaseLock } = lockResult;
+
+  const removePidFile = () => {
+    try {
+      releaseLock();
+    } catch {
+      // Best effort cleanup.
+    }
+  };
+
+  process.once("exit", removePidFile);
+
+  // Phase 1: Startup Banner (shadow read)
+  if (process.env.NEMORIS_LIVE_ROOT) {
+    const { OpenClawShadowBridge } = await import("./shadow/bridge.js");
+    const bridge = new OpenClawShadowBridge({ liveRoot: process.env.NEMORIS_LIVE_ROOT });
+    try {
+      const agents = await bridge.listAgents();
+      const cronJobs = await bridge.loadCronJobs();
+      console.log(JSON.stringify({
+        service: "nemoris_startup",
+        event: "openclaw_detected",
+        agentCount: agents.length,
+        cronJobCount: cronJobs.length,
+        message: `OpenClaw detected at ${process.env.NEMORIS_LIVE_ROOT} — ${agents.length} agents, ${cronJobs.length} cron jobs available. Run 'nemoris migrate' to import.`
+      }));
+    } catch (_) {}
+  }
+
+  const drainTimeoutMs = runtime.runtime?.shutdown?.drainTimeoutMs || 15000;
+  const pollIntervalMs = Math.max(1000, Number(intervalMs) || 30000);
+  let timer = null;
+
+  const runTick = async () => {
+    try {
+      const result = await localDaemon.tick({
+        now: new Date(),
+        mode
+      });
+      console.log(JSON.stringify(result, null, 2));
+    } catch (error) {
+      console.error(
+        JSON.stringify({ ok: false, service: "scheduler_daemon", error: error.message })
+      );
+    }
+  };
+
+  // Telegram inbound — polling mode (no tunnel) or webhook mode
+  const stateStore = localDaemon.stateStore;
+  await stateStore.ensureReady();
+  localDaemon.installGlobalHandlers();
+  // Wire state store into tool registry for tool result caching
+  localDaemon.executor.toolRegistry.setStateStore(stateStore);
+
+  // Wire MCP consumer if config exists
+  if (runtime.mcp?.servers && Object.keys(runtime.mcp.servers).length > 0) {
+    const { McpConsumer } = await import("./mcp/consumer.js");
+    const mcpConsumer = new McpConsumer({ config: runtime.mcp });
+    localDaemon.setMcpConsumer(mcpConsumer);
+    localDaemon.executor.toolRegistry.setMcpConsumer(mcpConsumer);
+    console.log(JSON.stringify({ service: "mcp_consumer", status: "READY", servers: Object.keys(runtime.mcp.servers) }));
+  }
+
+  // Reap jobs stuck in 'running' state from a previous daemon run
+  const { reapOrphanedJobs } = await import("./runtime/orphan-reaper.js");
+  reapOrphanedJobs(stateStore);
+
+  // Context ledger — event-sourced session store (Phase 1: dual-write)
+  const { ContextLedger } = await import("./runtime/context-ledger.js");
+  const contextLedger = new ContextLedger({
+    dbPath: path.join(root, "state", "context-ledger.sqlite"),
+  });
+  contextLedger.open();
+
+  const telegramConfig = runtime.runtime?.telegram;
+  let telegramPoller = null;
+
+  if (telegramConfig?.botTokenEnv) {
+    const token = process.env[telegramConfig.botTokenEnv];
+    if (token && telegramConfig.pollingMode) {
+      // Long-polling mode — no tunnel or transport server required
+      const { startTelegramPolling, TelegramInboundHandler } = await import("./runtime/telegram-inbound.js");
+      const peerNames = Object.keys(runtime.peers?.peers || {});
+      const agentNames = Object.fromEntries(
+        Object.entries(runtime.agents || {}).map(([id, agent]) => [id, agent?.name || id])
+      );
+      const handler = new TelegramInboundHandler({
+        stateStore,
+        telegramConfig,
+        availablePeers: peerNames,
+        agentNames,
+        contextLedger,
+        routerConfig: runtime.router,
+        agentConfigs: runtime.agents,
+        stopPolling: () => telegramPoller?.stop(),
+      });
+      const execApprovalGate = handler.getExecApprovalGate();
+      localDaemon.executor.setExecApprovalGate(execApprovalGate);
+      localExecutor.setExecApprovalGate(execApprovalGate);
+      telegramPoller = startTelegramPolling({ botToken: token, handler });
+      await stateStore.setMeta("telegram_inbound", { status: "READY", mode: "polling" });
+      console.log(JSON.stringify({ service: "telegram_inbound", status: "READY", mode: "polling" }));
+    } else if (token && telegramConfig.webhookUrl) {
+      // Webhook mode — requires tunnel + transport server
+      const webhookResult = await registerWebhook(token, telegramConfig.webhookUrl);
+      if (webhookResult.ok) {
+        await stateStore.setMeta("telegram_inbound", { status: "READY", webhook: `${telegramConfig.webhookUrl}/telegram/webhook` });
+        console.log(JSON.stringify({ service: "telegram_inbound", status: "READY", webhook: `${telegramConfig.webhookUrl}/telegram/webhook` }));
+      } else {
+        await stateStore.setMeta("telegram_inbound", { status: "NOT_READY", error: webhookResult.error });
+        console.error(JSON.stringify({ service: "telegram_inbound", status: "NOT_READY", error: webhookResult.error }));
+      }
+    } else if (!token) {
+      await stateStore.setMeta("telegram_inbound", { status: "NOT_READY", error: `${telegramConfig.botTokenEnv} not set` });
+      console.error(JSON.stringify({ service: "telegram_inbound", status: "NOT_READY", error: `${telegramConfig.botTokenEnv} not set` }));
+    }
+  }
+
+  const slackConfig = runtime.runtime?.slack;
+  let slackHandler = null;
+  if (slackConfig?.enabled) {
+    const { SlackInboundHandler } = await import("./runtime/slack-inbound.js");
+    const peerNames = Object.keys(runtime.peers?.peers || {});
+    slackHandler = new SlackInboundHandler({
+      stateStore,
+      slackConfig,
+      availablePeers: peerNames,
+    });
+    console.log(JSON.stringify({ service: "slack_inbound", status: "READY", eventsPath: slackConfig.eventsPath }));
+  }
+
+  const { TuiServer } = await import("./runtime/tui-server.js");
+  let tuiServer = null;
+  let tuiDeliveryAdapter = null;
+  try {
+    tuiServer = new TuiServer({
+      stateStore,
+      stateRoot: path.join(root, "state"),
+      runtime,
+      contextLedger,
+      execApprovalGate: localDaemon.executor.execApprovalGate,
+    });
+    await tuiServer.start();
+    tuiDeliveryAdapter = localDaemon.deliveryManager.createAdapter("tui");
+    console.log(JSON.stringify({ service: "tui_socket", status: "READY", socketPath: tuiServer.socketPath }));
+  } catch (error) {
+    console.error(JSON.stringify({ service: "tui_socket", status: "NOT_READY", error: error.message }));
+    tuiServer = null;
+    tuiDeliveryAdapter = null;
+  }
+
+  // Graceful drain helpers
+  let shuttingDown = false;
+
+  const waitForDrainEmpty = async (timeoutMs = drainTimeoutMs) => {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      const running = stateStore.getRunningInteractiveJobCount();
+      if (running === 0) return;
+      await new Promise((r) => setTimeout(r, 100));
+    }
+  };
+
+  // Interactive drain loop — 100ms polling, independent of scheduled tick
+  let interactiveRunning = true;
+  const interactiveDrain = async () => {
+    const { drainInteractiveOnce } = await import("./runtime/daemon.js");
+    const { appendTurn, processInteractiveHandoffs } = await import("./runtime/telegram-inbound.js");
+    const { fireCompletionPings } = await import("./runtime/completion-ping.js");
+    const { sendFailurePing } = await import("./runtime/failure-ping.js");
+
+    while (interactiveRunning) {
+      try {
+        await drainInteractiveOnce(stateStore, async (job) => {
+          // Interactive jobs don't have TOML definitions — hydrate from message + agent config
+          const chatSession = stateStore.getChatSession(job.chat_id);
+          const { compactSessionContext } = await import("./runtime/session-compactor.js");
+
+          // Load raw conversation context (JSON string or null)
+          const sessionId = job.chat_id || job.job_id;
+          let rawContext = (() => {
+            try {
+              const { snapshot } = contextLedger.loadState(sessionId);
+              if (snapshot) {
+                console.log(JSON.stringify({ service: "context_ledger", path: "ledger", session_id: sessionId }));
+                // Return raw string — hydrateInteractiveJob calls JSON.parse() on it
+                return snapshot.state_json;
+              }
+            } catch (err) {
+              console.error(JSON.stringify({ service: "context_ledger", error: err.message, session_id: sessionId }));
+            }
+            console.log(JSON.stringify({ service: "context_ledger", path: "blob", session_id: sessionId }));
+            return chatSession?.conversation_context || null;
+          })();
+
+          // Session compaction — summarise old turns to keep context manageable
+          try {
+            const agentCfg = runtime.agents?.[job.agent_id];
+            const compactionThreshold = resolveCompactionThreshold(agentCfg);
+            const condensedFanout = resolveCompactionCondensedFanout(agentCfg);
+            const compactionModel = agentCfg?.limits?.compaction_model ?? "ollama/qwen3:8b";
+            const transcriptContext = chatSession?.conversation_context || null;
+            const turns = parseConversationTurns(transcriptContext);
+
+            // Pre-compaction memory flush: if approaching threshold, ask agent to write memory
+            if (turns.length >= compactionThreshold - 1) {
+              import("./runtime/telegram-inbound.js").then(({ appendTurn }) => {
+                const flushCtx = appendTurn(transcriptContext, "user",
+                  "Please write any important facts from our conversation to memory before we continue.");
+                daemon.scheduler.hydrateInteractiveJob({
+                  jobId: `${job.job_id}_memflush`,
+                  agentId: job.agent_id,
+                  input: "Please write any important facts from our conversation to memory before we continue.",
+                  conversationContext: flushCtx,
+                }, { shadowImport: false }).catch((err) => {
+                  console.error(JSON.stringify({ service: "session_compactor", event: "memflush_error", error: err.message }));
+                });
+              }).catch(() => {});
+            }
+
+            if (turns.length >= compactionThreshold) {
+              const turnsBefore = turns.length;
+              const noticeToken = runtime.runtime?.telegram?.botTokenEnv
+                ? process.env[runtime.runtime.telegram.botTokenEnv]
+                : null;
+              const noticeChatId = runtime.runtime?.telegram?.operatorChatId || job.chat_id;
+              if (noticeToken && noticeChatId && job.source === "telegram") {
+                await notifyCompaction(async (chatId, text) => {
+                  await fetch(`https://api.telegram.org/bot${noticeToken}/sendMessage`, {
+                    method: "POST",
+                    headers: { "content-type": "application/json" },
+                    body: JSON.stringify({ chat_id: chatId, text }),
+                  }).catch(() => {});
+                }, noticeChatId);
+              }
+              const compacted = await compactSessionContext(turns, {
+                maxTurns: compactionThreshold,
+                compactionModel,
+                condensedFanout,
+                ledger: contextLedger,
+                sessionId,
+              });
+              if (compacted.compacted) {
+                rawContext = JSON.stringify(compacted.turns);
+                console.log(JSON.stringify({
+                  service: "session_compactor",
+                  session_id: sessionId,
+                  turns_before: turnsBefore,
+                  turns_after: compacted.turns.length,
+                  summary_length: compacted.summary?.length ?? 0,
+                }));
+                // Dual-write compacted context back to blob
+                if (chatSession) {
+                  stateStore.updateConversationContext(job.chat_id, rawContext);
+                }
+                try {
+                  contextLedger.appendEvent({
+                    session_id: sessionId,
+                    kind: "compaction",
+                    payload_json: {
+                      turns_before: turnsBefore,
+                      turns_after: compacted.turns.length,
+                      summary: compacted.summary || "",
+                    },
+                  });
+                } catch (_) {}
+                if (job.chat_id) {
+                  return { requeue: true, reason: "compaction" };
+                }
+              }
+            }
+          } catch (compactErr) {
+            // Compaction failure must never break a turn
+            console.error(JSON.stringify({ service: "session_compactor", error: compactErr.message, session_id: sessionId }));
+          }
+
+          const plan = await daemon.scheduler.hydrateInteractiveJob({
+            jobId: job.job_id,
+            agentId: job.agent_id,
+            input: job.input,
+            imageRefs: job.image_refs ? JSON.parse(job.image_refs) : null,
+            conversationContext: rawContext,
+            sessionId: job.chat_id || job.job_id,
+          }, {
+            shadowImport: true,
+            modelOverride: chatSession?.model_override,
+            focusMode: chatSession?.focus_mode || null,
+            thinkMode: chatSession?.think_mode || null,
+            sourceType: job.source_type || 'human',
+            sourceAgentId: job.source_agent_id || null,
+          });
+
+          // Typing indicator — refresh every 5s until executor returns
+          const typingChatId = job.source === "telegram" ? job.chat_id || null : null;
+          const tgCfg = (await daemon.scheduler.loadRuntime()).runtime?.telegram;
+          const typingToken = tgCfg?.botTokenEnv ? process.env[tgCfg.botTokenEnv] : null;
+          let typingTimer = null;
+          if (typingToken && typingChatId) {
+            const sendTyping = () => fetch(`https://api.telegram.org/bot${typingToken}/sendChatAction`, {
+              method: "POST",
+              headers: { "content-type": "application/json" },
+              body: JSON.stringify({ chat_id: typingChatId, action: "typing" }),
+            }).catch(() => {});
+            sendTyping(); // fire immediately
+            typingTimer = setInterval(sendTyping, 5000);
+          }
+
+          const executorMode = mode === "live" ? "provider" : mode;
+
+          // Set per-job tool context (memory_search, trigger_job, web_search)
+          if (daemon.executor._toolContext) {
+            const ctx = daemon.executor._toolContext;
+            ctx.callerAgentId = job.agent_id;
+            ctx.memoryStore = daemon.scheduler.memoryStore;
+            ctx.stateStore = stateStore;
+            ctx.currentJobId = job.job_id;
+            ctx.openRouterApiKey = process.env.OPENROUTER_API_KEY;
+            ctx.agents = runtime.agents || {};
+            ctx.jobs = runtime.jobs || {};
+            ctx.getBreaker = (agentId) => {
+              const agentCfg = runtime.agents?.[agentId];
+              const modelId = agentCfg?.model || "unknown";
+              return daemon.executor._getBreaker(modelId, runtime.runtime);
+            };
+          }
+
+          // Progress ping — fires once after 10s if turn is still running
+          let progressPingFired = false;
+          const progressPingTimer = setTimeout(async () => {
+            if (!progressPingFired && typingToken && typingChatId) {
+              progressPingFired = true;
+              try {
+                await fetch(`https://api.telegram.org/bot${typingToken}/sendMessage`, {
+                  method: "POST",
+                  headers: { "content-type": "application/json" },
+                  body: JSON.stringify({ chat_id: typingChatId, text: "Still working ⏳" }),
+                });
+              } catch (_) {}
+            }
+          }, 10_000);
+
+          // Turn timeout — 2 minutes hard cap
+          const MAX_TURN_MS = 120_000;
+          let turnTimeoutTimer;
+          const turnTimeoutPromise = new Promise((_, reject) => {
+            turnTimeoutTimer = setTimeout(() => reject(new Error("turn_timeout")), MAX_TURN_MS);
+          });
+
+          let run;
+          try {
+            run = await Promise.race([
+              daemon.executor.executeJob(job.job_id, {
+                mode: executorMode,
+                plan,
+                shadowImport: false, // already done in hydrateInteractiveJob
+                sessionId: job.chat_id || job.job_id,
+                skipApprovalNotification: job.source === "tui",
+              }),
+              turnTimeoutPromise,
+            ]);
+          } finally {
+            clearTimeout(progressPingTimer);
+            clearTimeout(turnTimeoutTimer);
+            if (typingTimer) clearInterval(typingTimer);
+          }
+
+          // Extract response text from the run result
+          const resultOutput = run?.result?.output;
+          const responseText = typeof resultOutput === "string"
+            ? resultOutput
+            : resultOutput?.output || resultOutput?.summary || run?.result?.summary || "(no response)";
+
+          // Detect waiting_for_human: response ends with a question mark
+          const responseStr = typeof responseText === "string" ? responseText : JSON.stringify(responseText);
+          const endsWithQuestion = responseStr.trimEnd().endsWith("?");
+          if (endsWithQuestion && stateStore.db) {
+            stateStore.db.prepare("UPDATE interactive_jobs SET waiting_for_human = 1 WHERE job_id = ?").run(job.job_id);
+          }
+          const toolCalls = run?.result?.toolCalls || run?.toolCalls || [];
+
+          // Deliver response to source agent if this was an inter-agent message
+          if (job.source_type === 'agent' && job.reply_session_key) {
+            let agentDelivered = false;
+            try {
+              const { OpenClawPeerDeliveryAdapter } = await import("./runtime/delivery-adapters/openclaw-peer.js");
+              const peerAdapter = new OpenClawPeerDeliveryAdapter();
+              await peerAdapter.deliver(
+                { message: typeof responseText === "string" ? responseText : JSON.stringify(responseText) },
+                { target: { sessionKey: job.reply_session_key }, profileConfig: {} }
+              );
+              agentDelivered = true;
+              console.log(JSON.stringify({ service: "inter_agent_routing", event: "delivered", jobId: job.job_id, replySessionKey: job.reply_session_key }));
+            } catch (peerErr) {
+              console.warn(JSON.stringify({ service: "inter_agent_routing", event: "delivery_failed", jobId: job.job_id, error: peerErr.message }));
+            }
+            if (!agentDelivered) {
+              // Fallback: send to operator Telegram with warning prefix
+              const telegramConfig = (await daemon.scheduler.loadRuntime()).runtime?.telegram;
+              const botToken = telegramConfig?.botTokenEnv ? process.env[telegramConfig.botTokenEnv] : null;
+              const operatorChatId = telegramConfig?.operatorChatId;
+              if (botToken && operatorChatId) {
+                const { splitTelegramMessage, markdownToTelegramHtml } = await import("./runtime/telegram-inbound.js");
+                const fallbackText = `⚠️ [Agent reply — routing failed, sending here instead]\n\n${typeof responseText === "string" ? responseText : JSON.stringify(responseText)}`;
+                const htmlText = markdownToTelegramHtml(fallbackText);
+                for (const chunk of splitTelegramMessage(htmlText)) {
+                  await fetch(`https://api.telegram.org/bot${botToken}/sendMessage`, {
+                    method: "POST",
+                    headers: { "content-type": "application/json" },
+                    body: JSON.stringify({ chat_id: operatorChatId, text: chunk, parse_mode: "HTML" }),
+                  }).catch(() => {});
+                }
+              }
+            }
+          }
+
+          if (job.source === "tui" && job.chat_id && tuiDeliveryAdapter && tuiServer) {
+            try {
+              const turnTokens = (run?.usage?.tokensIn || 0) + (run?.usage?.tokensOut || 0);
+              await tuiDeliveryAdapter.deliver({
+                jobId: job.job_id,
+                message: typeof responseText === "string" ? responseText : JSON.stringify(responseText),
+                tokens: turnTokens,
+                cost: run?.costUsd || 0,
+                toolCalls,
+              }, {
+                sessionKey: job.chat_id,
+                status: await tuiServer.buildStatusPayload(job.chat_id),
+              });
+            } catch (deliveryError) {
+              console.error(JSON.stringify({ service: "tui_delivery", jobId: job.job_id, error: deliveryError.message }));
+            }
+          }
+
+          // Deliver response to Telegram (skip for agent-only dispatch jobs)
+          const telegramConfig = (await daemon.scheduler.loadRuntime()).runtime?.telegram;
+          const botToken = telegramConfig?.botTokenEnv ? process.env[telegramConfig.botTokenEnv] : null;
+          const deliverChatId = job.source_type === 'agent'
+            ? null // already handled above
+            : (job.chat_id || (job.source === "agent_dispatch" ? telegramConfig?.operatorChatId : null));
+          if (job.source === "telegram" && botToken && deliverChatId && job.source !== "completion_ping") {
+            const { splitTelegramMessage, markdownToTelegramHtml } = await import("./runtime/telegram-inbound.js");
+            // Strip XML tool call artifacts that some models emit inline in text
+            // alongside native tool_use blocks. Covers multiple format variants:
+            //   <function_calls>...</function_calls>  (Anthropic legacy)
+            //   <tool_call>...</tool_call>             (Qwen / OpenAI compat)
+            //   <tool_response>...</tool_response>     (model echoing tool results)
+            //   <invoke>...</invoke>                   (Claude XML compat)
+            const cleanResponseText = (typeof responseText === "string" ? responseText : JSON.stringify(responseText))
+              .replace(/<function_calls>[\s\S]*?<\/function_calls>/g, "")
+              .replace(/<function_response>[\s\S]*?<\/function_response>/g, "")
+              .replace(/<tool_call>[\s\S]*?<\/tool_call>/g, "")
+              .replace(/<tool_response>[\s\S]*?<\/tool_response>/g, "")
+              .replace(/<invoke>[\s\S]*?<\/invoke>/g, "")
+              .replace(/<function_calls>[\s\S]*?<\/antml:function_calls>/g, "")
+              .trim();
+            const htmlText = markdownToTelegramHtml(cleanResponseText || "(no response)");
+            const chunks = splitTelegramMessage(htmlText);
+            for (const chunk of chunks) {
+              const sendRes = await fetch(`https://api.telegram.org/bot${botToken}/sendMessage`, {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                body: JSON.stringify({ chat_id: deliverChatId, text: chunk, parse_mode: "HTML" }),
+              });
+              if (!sendRes.ok) {
+                const sendBody = await sendRes.text().catch(() => "");
+                console.error(JSON.stringify({ service: "interactive_delivery", jobId: job.job_id, chatId: deliverChatId, status: sendRes.status, error: sendBody }));
+              }
+            }
+          }
+
+          // React ✅ on the original inbound message after Telegram delivery
+          if (botToken && deliverChatId && job.source === "telegram" && job.job_id) {
+            try {
+              // jobId format: telegram-<chatId>-<messageId>
+              const parts = job.job_id.split("-");
+              const inboundMsgId = parts.length >= 3 ? Number(parts[parts.length - 1]) : null;
+              if (inboundMsgId) {
+                fetch(`https://api.telegram.org/bot${botToken}/setMessageReaction`, {
+                  method: "POST",
+                  headers: { "content-type": "application/json" },
+                  body: JSON.stringify({ chat_id: deliverChatId, message_id: inboundMsgId, reaction: [{ type: "emoji", emoji: "✅" }] }),
+                }).catch(() => {}); // best-effort
+              }
+            } catch (_) {}
+          }
+
+          // Deliver response to Slack
+          if (slackHandler && job.source === "slack") {
+            const channelId = job.chat_id.split(":")[2]; // slack:teamId:channelId
+            const cleanResponseText = (typeof responseText === "string" ? responseText : JSON.stringify(responseText))
+              .replace(/<function_calls>[\s\S]*?<\/function_calls>/g, "")
+              .replace(/<function_response>[\s\S]*?<\/function_response>/g, "")
+              .replace(/<tool_call>[\s\S]*?<\/tool_call>/g, "")
+              .replace(/<tool_response>[\s\S]*?<\/tool_response>/g, "")
+              .replace(/<invoke>[\s\S]*?<\/invoke>/g, "")
+              .trim();
+            await slackHandler.postMessage(channelId, cleanResponseText || "(no response)");
+          }
+
+          // Update conversation context (blob — existing source of truth)
+          if (chatSession) {
+            let ctx = chatSession.conversation_context || null;
+            const imageRef = job.image_refs
+              ? JSON.parse(job.image_refs)?.[0] || null
+              : null;
+            ctx = appendTurn(ctx, "user", job.input, imageRef);
+            ctx = appendTurn(ctx, "assistant", typeof responseText === "string" ? responseText : JSON.stringify(responseText));
+            stateStore.updateConversationContext(job.chat_id, ctx);
+          }
+
+          // Dual-write: context ledger events (Phase 1 — ledger is passive, blob drives behaviour)
+          try {
+            const sessionId = job.chat_id || job.job_id;
+            const msgInEvent = contextLedger.appendEvent({
+              session_id: sessionId,
+              kind: "message_in",
+              payload_json: { channel: job.source || "telegram", user_id: job.chat_id || "", text: job.input },
+            });
+
+            // Log tool calls/results if present
+            for (const tc of toolCalls) {
+              const tcEvent = contextLedger.appendEvent({
+                session_id: sessionId,
+                kind: "tool_call",
+                payload_json: { tool_name: tc.name || tc.tool_name, call_id: tc.id || tc.call_id || "", args: tc.args || tc.input },
+                parent_event_id: msgInEvent.id,
+              });
+              if (tc.result !== undefined || tc.output !== undefined) {
+                contextLedger.appendEvent({
+                  session_id: sessionId,
+                  kind: "tool_result",
+                  payload_json: { tool_name: tc.name || tc.tool_name, call_id: tc.id || tc.call_id || "", ok: !tc.error, result: tc.result ?? tc.output },
+                  parent_event_id: tcEvent.id,
+                });
+              }
+            }
+
+            contextLedger.appendEvent({
+              session_id: sessionId,
+              kind: "message_out",
+              payload_json: { channel: job.source || "telegram", text: typeof responseText === "string" ? responseText : JSON.stringify(responseText) },
+              token_cost_in: run?.usage?.tokensIn ?? run?.usage?.prompt_tokens ?? run?.result?.usage?.prompt_tokens ?? null,
+              token_cost_out: run?.usage?.tokensOut ?? run?.usage?.completion_tokens ?? run?.result?.usage?.completion_tokens ?? null,
+              parent_event_id: msgInEvent.id,
+            });
+
+            // Emit outbox item for Telegram sends (passive — not enforced yet)
+            if (job.chat_id && job.source === "telegram" && job.source !== "completion_ping") {
+              contextLedger.enqueueOutbox({
+                session_id: sessionId,
+                kind: "send_telegram",
+                payload_json: { chat_id: job.chat_id, text: typeof responseText === "string" ? responseText : JSON.stringify(responseText) },
+                dedupe_key: `send_telegram:${job.job_id}`,
+              });
+            }
+          } catch (ledgerErr) {
+            // Dual-write: ledger failure must not break the turn
+            console.error(JSON.stringify({ service: "context_ledger", error: ledgerErr.message, jobId: job.job_id }));
+          }
+
+          return run;
+        }, {
+          onJobFailure: async (job, error) => {
+            if (job.source === "tui" && job.chat_id && tuiDeliveryAdapter && tuiServer) {
+              try {
+                await tuiDeliveryAdapter.deliver({
+                  jobId: job.job_id,
+                  error: error.message,
+                }, {
+                  sessionKey: job.chat_id,
+                  status: await tuiServer.buildStatusPayload(job.chat_id),
+                });
+              } catch (deliveryError) {
+                console.error(JSON.stringify({ service: "tui_delivery", jobId: job.job_id, error: deliveryError.message }));
+              }
+              return;
+            }
+            if (job.source !== "telegram") return;
+            const tgCfg = (await daemon.scheduler.loadRuntime()).runtime?.telegram;
+            const botToken = tgCfg?.botTokenEnv ? process.env[tgCfg.botTokenEnv] : null;
+            await sendFailurePing(job, error, { botToken, operatorChatId: tgCfg?.operatorChatId });
+          },
+        });
+        await processInteractiveHandoffs(stateStore);
+
+        // Fire completion pings for finished dispatch jobs
+        const tgConf = (await daemon.scheduler.loadRuntime()).runtime?.telegram;
+        const pingToken = tgConf?.botTokenEnv ? process.env[tgConf.botTokenEnv] : null;
+        if (tgConf && pingToken) {
+          await fireCompletionPings(stateStore, tgConf, { botToken: pingToken });
+        }
+      } catch (error) {
+        console.error(JSON.stringify({ service: "interactive_drain", error: error.message }));
+      }
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+  };
+
+  const drainPromise = interactiveDrain();
+
+  const shutdown = async () => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    interactiveRunning = false;
+    if (telegramPoller) telegramPoller.stop();
+    if (timer) {
+      clearInterval(timer);
+      timer = null;
+    }
+    // Wait for in-flight interactive jobs to complete before exiting
+    await waitForDrainEmpty(drainTimeoutMs);
+    await drainPromise;
+    if (tuiServer) {
+      await tuiServer.close();
+    }
+    contextLedger.close();
+    await daemon.close({ drainTimeoutMs });
+    removePidFile();
+    process.exit(0);
+  };
+
+  process.once("SIGINT", shutdown);
+  process.once("SIGTERM", shutdown);
+
+  console.log(
+    JSON.stringify({
+      ok: true,
+      service: "scheduler_daemon",
+      mode,
+      intervalMs: pollIntervalMs,
+      maxJobsPerTick: runtime.runtime?.concurrency?.maxJobsPerTick ?? runtime.runtime?.concurrency?.maxConcurrentJobs ?? 2
+    })
+  );
+
+  await runTick();
+  timer = setInterval(() => {
+    runTick();
+  }, pollIntervalMs);
+}
+
+async function pruneState(scope = "all") {
+  const runtime = await scheduler.loadRuntime();
+  const statePath = path.join(projectRoot, "state");
+  const operations = [];
+
+  if (scope === "all" || scope === "runs") {
+    operations.push(
+      new RunStore({
+        rootDir: path.join(statePath, "runs"),
+        retention: runtime.runtime?.retention?.runs || {}
+      }).prune()
+    );
+  }
+  if (scope === "all" || scope === "notifications") {
+    operations.push(
+      new NotificationStore({
+        rootDir: path.join(statePath, "notifications"),
+        retention: runtime.runtime?.retention?.notifications || {}
+      }).prune()
+    );
+  }
+  if (scope === "all" || scope === "deliveries") {
+    operations.push(
+      new DeliveryStore({
+        rootDir: path.join(statePath, "deliveries"),
+        retention: runtime.runtime?.retention?.deliveries || {}
+      }).prune()
+    );
+  }
+  if (scope === "all" || scope === "transport") {
+    operations.push(
+      pruneJsonBuckets(
+        path.join(statePath, "transport", "inbox"),
+        buildRetentionPolicy(runtime.runtime?.retention?.transportInbox || {}, {
+          ttlDays: 7,
+          maxFilesPerBucket: 1000
+        })
+      )
+    );
+  }
+
+  const results = await Promise.all(operations);
+  console.log(JSON.stringify({ scope, results }, null, 2));
+}
+
+async function reviewInbox(limit = "10") {
+  const server = new StandaloneTransportServer({
+    stateRoot: path.join(projectRoot, "state")
+  });
+  const items = await server.listInbox(Number(limit) || 10);
+  console.log(JSON.stringify(items, null, 2));
+}
+
+async function evaluateRuns(limit = 20) {
+  const evaluation = await evaluator.evaluate(Number(limit));
+  console.log(JSON.stringify(evaluation, null, 2));
+}
+
+async function evaluateJob(jobId) {
+  const evaluation = await evaluator.evaluateAndPersistJob(jobId);
+  console.log(JSON.stringify(evaluation, null, 2));
+}
+
+async function improvementTargets() {
+  const targets = await improvementHarness.listTargets();
+  console.log(JSON.stringify(targets, null, 2));
+}
+
+async function runImprovement(targetId, variantId = "baseline") {
+  const result = await improvementHarness.runVariant(targetId, variantId);
+  console.log(JSON.stringify(result, null, 2));
+}
+
+async function runImprovementWithReportFallback(targetId, variantId = "baseline") {
+  const result = await improvementHarness.runVariant(targetId, variantId, {
+    allowReportFallback: true
+  });
+  console.log(JSON.stringify(result, null, 2));
+}
+
+async function compareImprovements(targetId, candidateVariantId, baselineVariantId = "baseline") {
+  const result = await improvementHarness.compareVariants(targetId, baselineVariantId, candidateVariantId);
+  console.log(JSON.stringify(result, null, 2));
+}
+
+async function compareImprovementsWithReportFallback(targetId, candidateVariantId, baselineVariantId = "baseline") {
+  const result = await improvementHarness.compareVariants(targetId, baselineVariantId, candidateVariantId, {
+    allowReportFallback: true
+  });
+  console.log(JSON.stringify(result, null, 2));
+}
+
+async function repairAndCompareImprovement(targetId, candidateVariantId, baselineVariantId = "baseline") {
+  const result = await improvementHarness.repairAndCompare(targetId, candidateVariantId, baselineVariantId);
+  console.log(JSON.stringify(result, null, 2));
+}
+
+async function repairAndCompareImprovementWithReportFallback(targetId, candidateVariantId, baselineVariantId = "baseline") {
+  const result = await improvementHarness.repairAndCompare(targetId, candidateVariantId, baselineVariantId, {
+    allowReportFallback: true
+  });
+  console.log(JSON.stringify(result, null, 2));
+}
+
+async function shadowEvalJob(jobId, modelOverride = null) {
+  const run = await executor.executeJob(jobId, {
+    mode: "provider",
+    shadowImport: true,
+    modelOverride
+  });
+  const evaluation = await evaluator.evaluateAndPersistJob(jobId);
+  console.log(
+    JSON.stringify(
+      {
+        run: {
+          filePath: run.filePath,
+          mode: run.mode,
+          providerId: run.providerId,
+          modelId: run.modelId,
+          routingDecision: run.routingDecision,
+          preflight: run.preflight,
+          summary: run.result.summary
+        },
+        evaluation
+      },
+      null,
+      2
+    )
+  );
+}
+
+async function benchmarkModels(jobId, models) {
+  if (!models.length) {
+    throw new Error("benchmark-models requires at least one model id");
+  }
+
+  const results = [];
+  for (const modelId of models) {
+    const run = await executor.executeJob(jobId, {
+      mode: "provider",
+      shadowImport: true,
+      modelOverride: modelId
+    });
+    const evaluation = await evaluator.evaluateAndPersistJob(jobId);
+    results.push({
+      modelId,
+      runFile: run.filePath,
+      evalFile: evaluation.filePath,
+      overallScore: evaluation.rubric.overallScore,
+      contractAdherence: evaluation.contractCheck?.satisfiedRatio ?? null,
+      comparisonNotes: evaluation.comparisonNotes
+    });
+  }
+
+  console.log(JSON.stringify({ jobId, results }, null, 2));
+}
+
+async function indexEmbeddings(agentId) {
+  const result = await scheduler.memoryStore.rebuildEmbeddings(agentId, {
+    embeddingIndex
+  });
+  console.log(JSON.stringify(result, null, 2));
+}
+
+async function queryEmbeddings(agentId, query) {
+  const results = await embeddingIndex.query(agentId, query, 10);
+  console.log(JSON.stringify(results, null, 2));
+}
+
+async function embeddingHealth(agentId, probe = false) {
+  const result = await scheduler.memoryStore.getEmbeddingHealth(agentId, {
+    embeddingIndex,
+    probe
+  });
+  console.log(JSON.stringify(result, null, 2));
+}
+
+async function embeddingReadiness() {
+  const result = await embeddingService.getReadiness();
+  console.log(JSON.stringify(result, null, 2));
+}
+
+async function reportFallbackReadinessData(jobId = "workspace-health") {
+  const runtime = await scheduler.loadRuntime();
+  const job = runtime.jobs[jobId];
+  if (!job) {
+    throw new Error(`Unknown job: ${jobId}`);
+  }
+
+  const policy = getReportFallbackPolicy(runtime.runtime);
+  const provider = runtime.providers.openrouter || null;
+  const authRef = provider?.authRef || null;
+  const envName = authRef?.startsWith("env:") ? authRef.slice(4) : null;
+  const authPresent = envName ? Boolean(process.env[envName]) : false;
+
+  return {
+    jobId,
+    jobConfigured: Boolean(job.reportFallback?.enabled),
+    jobPolicy: job.reportFallback || null,
+    runtimePolicy: policy,
+    remoteProviderModeAllowed: Boolean(process.env.NEMORIS_ALLOW_REMOTE_PROVIDER_MODE === "1" || process.env.NEMORIS_ALLOW_REMOTE_PROVIDER_MODE === "true"),
+    providerConfigured: Boolean(provider),
+    providerId: provider?.id || null,
+    authRef,
+    authPresent,
+    ready: Boolean(job.reportFallback?.enabled && policy.enabled && authPresent && (process.env.NEMORIS_ALLOW_REMOTE_PROVIDER_MODE === "1" || process.env.NEMORIS_ALLOW_REMOTE_PROVIDER_MODE === "true")),
+    blockedReasons: [
+      !job.reportFallback?.enabled ? "job_not_configured" : null,
+      !policy.enabled ? "report_fallback_disabled" : null,
+      !provider ? "openrouter_provider_missing" : null,
+      provider && !authPresent ? "openrouter_auth_missing" : null,
+      !(process.env.NEMORIS_ALLOW_REMOTE_PROVIDER_MODE === "1" || process.env.NEMORIS_ALLOW_REMOTE_PROVIDER_MODE === "true")
+        ? "remote_provider_mode_disabled"
+        : null
+    ].filter(Boolean)
+  };
+}
+
+async function reportFallbackReadiness(jobId = "workspace-health") {
+  const result = await reportFallbackReadinessData(jobId);
+  console.log(JSON.stringify(result, null, 2));
+}
+
+async function configValidate() {
+  const config = await scheduler.loadRuntime();
+  const schemaResult = validateAllConfigs(config, path.join(projectRoot, "config"));
+  console.log(
+    JSON.stringify(
+      {
+        ok: schemaResult.ok,
+        checkedAt: new Date().toISOString(),
+        providers: Object.keys(config.providers),
+        agents: Object.keys(config.agents),
+        jobs: Object.keys(config.jobs).length,
+        lanes: Object.keys(config.router).length,
+        schemaErrors: schemaResult.errors
+      },
+      null,
+      2
+    )
+  );
+  if (!schemaResult.ok) {
+    process.exitCode = 1;
+  }
+}
+
+async function peerReadiness(peerId = "nemo") {
+  const runtime = await scheduler.loadRuntime();
+  const result = await peerReadinessProbe.probe(runtime, peerId);
+  console.log(JSON.stringify(result, null, 2));
+}
+
+async function dependencyHealthForJob(jobId = "workspace-health") {
+  const result = await dependencyHealth.forJob(jobId);
+  console.log(JSON.stringify(result, null, 2));
+}
+
+async function getLaneReadiness(jobId = "workspace-health") {
+  const runtime = await scheduler.loadRuntime();
+  const job = runtime.jobs[jobId];
+  if (!job) {
+    throw new Error(`Unknown job: ${jobId}`);
+  }
+
+  const [evaluation, maintenance, embeddingHealth] = await Promise.all([
+    evaluator.evaluateJob(jobId),
+    daemon.stateStore.getMeta("maintenance", null),
+    scheduler.memoryStore.getEmbeddingHealth(job.agentId, {
+      embeddingIndex,
+      probe: false
+    })
+  ]);
+
+  const [reportFallback, dependencies] = await Promise.all([
+    reportFallbackReadinessData(jobId),
+    dependencyHealth.forJob(jobId)
+  ]);
+
+  const readiness = buildLaneReadiness({
+    jobId,
+    job,
+    evaluation,
+    embeddingHealth,
+    reportFallback,
+    maintenance,
+    dependencyHealth: dependencies
+  });
+
+  return readiness;
+}
+
+async function laneReadiness(jobId = "workspace-health") {
+  const readiness = await getLaneReadiness(jobId);
+
+  console.log(JSON.stringify(readiness, null, 2));
+}
+
+async function pilotStatus(jobId = "workspace-health", limit = 10) {
+  const [readiness, review, evaluation, dependencies, reportFallback] = await Promise.all([
+    getLaneReadiness(jobId),
+    reviewer.review(Number(limit)),
+    evaluator.evaluateJob(jobId),
+    dependencyHealth.forJob(jobId),
+    reportFallbackReadinessData(jobId)
+  ]);
+
+  const status = buildPilotStatus({
+    jobId,
+    readiness,
+    evaluation,
+    runs: review.recentRuns || [],
+    dependencyHealth: dependencies,
+    reportFallback
+  });
+
+  console.log(JSON.stringify(status, null, 2));
+}
+
+async function cutoverReadiness(jobId = "workspace-health", limit = 10) {
+  const [readiness, review, evaluation, dependencies, reportFallback] = await Promise.all([
+    getLaneReadiness(jobId),
+    reviewer.review(Number(limit)),
+    evaluator.evaluateJob(jobId),
+    dependencyHealth.forJob(jobId),
+    reportFallbackReadinessData(jobId)
+  ]);
+
+  const status = buildPilotStatus({
+    jobId,
+    readiness,
+    evaluation,
+    runs: review.recentRuns || [],
+    dependencyHealth: dependencies,
+    reportFallback
+  });
+
+  const cutover = buildCutoverReadiness({ readiness, pilotStatus: status });
+  console.log(JSON.stringify(cutover, null, 2));
+}
+
+async function buildPilotBundle(jobId = "workspace-health", limit = 10) {
+  const [readiness, review, evaluation, dependencies, reportFallback] = await Promise.all([
+    getLaneReadiness(jobId),
+    reviewer.review(Number(limit)),
+    evaluator.evaluateJob(jobId),
+    dependencyHealth.forJob(jobId),
+    reportFallbackReadinessData(jobId)
+  ]);
+
+  const status = buildPilotStatus({
+    jobId,
+    readiness,
+    evaluation,
+    runs: review.recentRuns || [],
+    dependencyHealth: dependencies,
+    reportFallback
+  });
+  const cutover = buildCutoverReadiness({ readiness, pilotStatus: status });
+
+  return {
+    readiness,
+    pilotStatus: status,
+    cutover,
+    evaluation
+  };
+}
+
+function summarizePilotBundle(bundle) {
+  return {
+    readiness: {
+      tier: bundle.readiness.readinessTier,
+      blockers: bundle.readiness.blockers,
+      warnings: bundle.readiness.warnings,
+      checks: bundle.readiness.checks,
+      summary: bundle.readiness.summary,
+      interactionDiagnosis: bundle.readiness.interaction?.diagnosis || null
+    },
+    pilotStatus: {
+      recommendation: bundle.pilotStatus.recommendation,
+      providerRunsObserved: bundle.pilotStatus.providerRunsObserved,
+      healthyProviderRuns: bundle.pilotStatus.healthyProviderRuns,
+      latestProviderRun: bundle.pilotStatus.latestProviderRun,
+      reportFallback: {
+        ready: bundle.pilotStatus.reportFallback?.ready ?? null,
+        blockedReasons: bundle.pilotStatus.reportFallback?.blockedReasons || []
+      }
+    },
+    cutover: bundle.cutover,
+    evaluation: {
+      overallScore: bundle.evaluation.rubric?.overallScore ?? null,
+      contractSatisfiedRatio: bundle.evaluation.contractCheck?.satisfiedRatio ?? null,
+      interactionDiagnosis: bundle.evaluation.interaction?.diagnosis || null,
+      interactionArtifacts: bundle.evaluation.interactionArtifacts || null,
+      comparisonNotes: bundle.evaluation.comparisonNotes || []
+    }
+  };
+}
+
+async function dailyDriverTrustPack(limit = 10) {
+  const workspaceHealth = await buildPilotBundle("workspace-health", limit);
+  const memoryRollup = await buildPilotBundle("memory-rollup", limit);
+
+  const pack = {
+    checkedAt: new Date().toISOString(),
+    lanes: {
+      workspaceHealth: summarizePilotBundle(workspaceHealth),
+      memoryRollup: summarizePilotBundle(memoryRollup)
+    },
+    summary: {
+      workspaceHealthVerdict: workspaceHealth.cutover.verdict,
+      memoryRollupVerdict: memoryRollup.cutover.verdict,
+      currentDailyDriver: workspaceHealth.cutover.verdict === "READY" ? "workspace-health" : null,
+      nextLaneCandidate: "memory-rollup",
+      rollbackTriggers: [
+        "provider_unreachable",
+        "delivery_uncertain",
+        "expired_followups_or_handoffs",
+        "contract_adherence_drop",
+        "repeated_lexical_fallback"
+      ]
+    }
+  };
+
+  console.log(JSON.stringify(pack, null, 2));
+}
+
+async function jobEmbeddingHealth(jobId, probe = false) {
+  const runtime = await scheduler.loadRuntime();
+  const job = runtime.jobs[jobId];
+  if (!job) {
+    throw new Error(`Unknown job: ${jobId}`);
+  }
+  const agentId = job.agentId;
+  const result = await scheduler.memoryStore.getEmbeddingHealth(agentId, {
+    embeddingIndex,
+    probe
+  });
+  console.log(
+    JSON.stringify(
+      {
+        jobId,
+        agentId,
+        ...result
+      },
+      null,
+      2
+    )
+  );
+}
+
+async function rebuildJobEmbeddings(jobId) {
+  const plan = await scheduler.hydrateJob(jobId, { shadowImport: true });
+  try {
+    const result = await scheduler.memoryStore.rebuildEmbeddings(plan.agent.id, {
+      embeddingIndex: scheduler.embeddingIndex
+    });
+    console.log(
+      JSON.stringify(
+        {
+          jobId,
+          agentId: plan.agent.id,
+          workspaceRoot: plan.agent.workspaceRoot,
+          shadowImport: true,
+          ...result
+        },
+        null,
+        2
+      )
+    );
+  } catch (error) {
+    const health = await scheduler.memoryStore.getEmbeddingHealth(plan.agent.id, {
+      embeddingIndex: scheduler.embeddingIndex,
+      probe: false
+    });
+    console.log(
+      JSON.stringify(
+        {
+          jobId,
+          agentId: plan.agent.id,
+          workspaceRoot: plan.agent.workspaceRoot,
+          shadowImport: true,
+          ok: false,
+          error: error?.message || String(error),
+          embeddingHealth: health.embeddingHealth
+        },
+        null,
+        2
+      )
+    );
+    process.exitCode = 1;
+  }
+}
+
+async function memoryBackends(agentId) {
+  const runtime = await scheduler.loadRuntime();
+  const agent = runtime.agents[agentId];
+  const result = await scheduler.backendManager.inspect(agentId, agent?.workspaceRoot || null);
+  console.log(JSON.stringify(result, null, 2));
+}
+
+async function listAgentCards() {
+  const runtime = await scheduler.loadRuntime();
+  const registry = new PeerRegistry(runtime.peers);
+  console.log(JSON.stringify(registry.listCards(), null, 2));
+}
+
+async function findAgentCards(query = "") {
+  const runtime = await scheduler.loadRuntime();
+  const registry = new PeerRegistry(runtime.peers);
+  console.log(JSON.stringify(registry.findByCapability(query), null, 2));
+}
+
+async function suggestPeers(taskType = "workspace_health", query = "") {
+  const runtime = await scheduler.loadRuntime();
+  const registry = new PeerRegistry(runtime.peers);
+  const suggestions = registry.suggestPeers({
+    taskType,
+    query: query || taskType,
+    preferredDeliveryProfile: runtime.delivery?.defaultInteractiveProfile || null,
+    limit: 5
+  });
+  console.log(JSON.stringify(suggestions, null, 2));
+}
+
+async function previewWorkspaceHealthValidation() {
+  const run = await executor.executeJob("workspace-health", {
+    mode: "dry-run",
+    shadowImport: true
+  });
+  console.log(
+    JSON.stringify(
+      {
+        jobId: "workspace-health",
+        filePath: run.filePath,
+        interaction: run.interaction,
+        notificationFiles: run.notificationFiles || [],
+        followUpFile: run.followUpFile || null,
+        guidance: {
+          previewDeliveryProfile: "gateway_preview_main",
+          liveDeliveryProfile: "gateway_telegram_main"
+        }
+      },
+      null,
+      2
+    )
+  );
+}
+
+async function validateWorkspaceHealth(mode = "preview", modelOverride = null) {
+  const runtimeMode = mode === "live" ? "live" : "shadow";
+  const executionMode = mode === "live" ? "provider" : "dry-run";
+  const run = await executor.executeJob("workspace-health", {
+    mode: executionMode,
+    shadowImport: true,
+    modelOverride
+  });
+  const delivery = await deliveryManager.deliverPending({
+    mode: runtimeMode,
+    limit: 10,
+    notificationFiles: run.notificationFiles || []
+  });
+  console.log(
+    JSON.stringify(
+      {
+        validation: mode,
+        run: {
+          filePath: run.filePath,
+          mode: run.mode,
+          providerId: run.providerId,
+          modelId: run.modelId,
+          interaction: run.interaction,
+          notificationFiles: run.notificationFiles || []
+        },
+        delivery
+      },
+      null,
+      2
+    )
+  );
+}
+
+async function validateWorkspaceHealthFull(selection = "top", modelOverride = null, deliveryProfile = "peer_preview") {
+  const run = await executor.executeJob("workspace-health", {
+    mode: "dry-run",
+    shadowImport: true,
+    modelOverride
+  });
+  const pendingFollowUps = await deliveryManager.listPendingFollowUps(20);
+  const followUp = pendingFollowUps.find((item) => (run.notificationFiles || []).includes(item.filePath));
+  if (!followUp) {
+    throw new Error("No pending follow-up was created for workspace-health.");
+  }
+  const consumed = await deliveryManager.consumeFollowUp(followUp.filePath);
+  const handoff = consumed.created.find((item) => item.stage === "handoff");
+  if (!handoff) {
+    throw new Error("Consumed follow-up did not produce a handoff notification.");
+  }
+
+  const chosen =
+    selection === "top"
+      ? await deliveryManager.chooseTopSuggestedPeer(handoff.filePath, { deliveryProfile })
+      : await deliveryManager.chooseHandoffPeer(handoff.filePath, selection, { deliveryProfile });
+
+  const delivery = await deliveryManager.deliverPending({
+    mode: "live",
+    limit: 1,
+    notificationFiles: [chosen.filePath]
+  });
+
+  const evaluation = await evaluator.evaluateAndPersistJob("workspace-health");
+  console.log(
+    JSON.stringify(
+      {
+        run: {
+          filePath: run.filePath,
+          notificationFiles: run.notificationFiles || []
+        },
+        followUp: consumed.followUp,
+        generatedNotifications: consumed.created,
+        handoff: chosen,
+        delivery,
+        evaluation: {
+          filePath: evaluation.filePath,
+          interaction: evaluation.interaction,
+          comparisonNotes: evaluation.comparisonNotes
+        }
+      },
+      null,
+      2
+    )
+  );
+}
+
+async function validateWorkspaceHealthRepeatable(selection = "top", modelOverride = null, deliveryProfile = "peer_preview") {
+  const cleanup = await deliveryManager.sweepPendingFollowUps({
+    now: new Date(),
+    timeoutMinutes: 0,
+    escalateOnExpiry: false
+  });
+  const run = await executor.executeJob("workspace-health", {
+    mode: "dry-run",
+    shadowImport: true,
+    modelOverride
+  });
+  const pendingFollowUps = await deliveryManager.listPendingFollowUps(20);
+  const followUp = pendingFollowUps.find((item) => (run.notificationFiles || []).includes(item.filePath));
+  if (!followUp) {
+    throw new Error("No pending follow-up was created for workspace-health.");
+  }
+  const consumed = await deliveryManager.consumeFollowUp(followUp.filePath);
+  const handoff = consumed.created.find((item) => item.stage === "handoff");
+  if (!handoff) {
+    throw new Error("Consumed follow-up did not produce a handoff notification.");
+  }
+  const chosen =
+    selection === "top"
+      ? await deliveryManager.chooseTopSuggestedPeer(handoff.filePath, { deliveryProfile })
+      : await deliveryManager.chooseHandoffPeer(handoff.filePath, selection, { deliveryProfile });
+  const delivery = await deliveryManager.deliverPending({
+    mode: "live",
+    limit: 1,
+    notificationFiles: [chosen.filePath]
+  });
+  const evaluation = await evaluator.evaluateAndPersistJob("workspace-health");
+  console.log(
+    JSON.stringify(
+      {
+        cleanup,
+        run: {
+          filePath: run.filePath,
+          notificationFiles: run.notificationFiles || []
+        },
+        followUp: consumed.followUp,
+        generatedNotifications: consumed.created,
+        handoff: chosen,
+        delivery,
+        evaluation: {
+          filePath: evaluation.filePath,
+          interaction: evaluation.interaction,
+          comparisonNotes: evaluation.comparisonNotes
+        }
+      },
+      null,
+      2
+    )
+  );
+}
+
+async function validateWorkspaceHealthPilot(
+  selection = "top",
+  mode = "dry-run",
+  modelOverride = null,
+  deliveryProfile = "peer_preview"
+) {
+  const cleanup = await deliveryManager.sweepPendingFollowUps({
+    now: new Date(),
+    timeoutMinutes: 0,
+    escalateOnExpiry: false
+  });
+  const run = await executor.executeJob("workspace-health", {
+    mode,
+    shadowImport: true,
+    modelOverride
+  });
+  const pendingFollowUps = await deliveryManager.listPendingFollowUps(20);
+  const followUp = pendingFollowUps.find((item) => (run.notificationFiles || []).includes(item.filePath));
+  if (!followUp) {
+    throw new Error("No pending follow-up was created for workspace-health.");
+  }
+  const consumed = await deliveryManager.consumeFollowUp(followUp.filePath);
+  const handoff = consumed.created.find((item) => item.stage === "handoff");
+  if (!handoff) {
+    throw new Error("Consumed follow-up did not produce a handoff notification.");
+  }
+  const chosen =
+    selection === "top"
+      ? await deliveryManager.chooseTopSuggestedPeer(handoff.filePath, { deliveryProfile })
+      : await deliveryManager.chooseHandoffPeer(handoff.filePath, selection, { deliveryProfile });
+  const delivery = await deliveryManager.deliverPending({
+    mode: "live",
+    limit: 1,
+    notificationFiles: [chosen.filePath]
+  });
+  const evaluation = await evaluator.evaluateAndPersistJob("workspace-health");
+  const readiness = await getLaneReadiness("workspace-health");
+  console.log(
+    JSON.stringify(
+      {
+        cleanup,
+        run: {
+          filePath: run.filePath,
+          mode: run.mode,
+          providerId: run.providerId,
+          modelId: run.modelId,
+          notificationFiles: run.notificationFiles || []
+        },
+        followUp: consumed.followUp,
+        generatedNotifications: consumed.created,
+        handoff: chosen,
+        delivery,
+        evaluation: {
+          filePath: evaluation.filePath,
+          interaction: evaluation.interaction,
+          comparisonNotes: evaluation.comparisonNotes
+        },
+        readiness
+      },
+      null,
+      2
+    )
+  );
+}
+
+async function validateMemoryRollup(mode = "provider", modelOverride = null, deliveryMode = "live") {
+  const resolvedModelOverride = modelOverride && modelOverride !== "-" ? modelOverride : null;
+  const run = await executor.executeJob("memory-rollup", {
+    mode,
+    shadowImport: true,
+    modelOverride: resolvedModelOverride
+  });
+  const delivery = await deliveryManager.deliverPending({
+    mode: deliveryMode,
+    limit: 10,
+    notificationFiles: run.notificationFiles || []
+  });
+  const evaluation = await evaluator.evaluateAndPersistJob("memory-rollup");
+  const bundle = await buildPilotBundle("memory-rollup");
+  const ackNotificationPresent = evaluation.interaction?.ackQueued === true;
+  const completionNotificationPresent = evaluation.interaction?.completionQueued === true;
+  const deliveryReceiptsPresent = evaluation.interaction?.deliveryEvidenceHealthy === true;
+  const deliveryUncertain = evaluation.interaction?.deliveryUncertain === true;
+
+  console.log(
+    JSON.stringify(
+      {
+        validation: {
+          mode,
+          deliveryMode,
+          ok: ackNotificationPresent && completionNotificationPresent && deliveryReceiptsPresent && !deliveryUncertain,
+          ackNotificationPresent,
+          completionNotificationPresent,
+          deliveryReceiptsPresent,
+          deliveryUncertain
+        },
+        run: {
+          filePath: run.filePath,
+          mode: run.mode,
+          providerId: run.providerId,
+          modelId: run.modelId,
+          notificationFiles: run.notificationFiles || []
+        },
+        delivery,
+        evaluation: {
+          filePath: evaluation.filePath,
+          contractCheck: evaluation.contractCheck,
+          interaction: evaluation.interaction,
+          interactionArtifacts: evaluation.interactionArtifacts,
+          comparisonNotes: evaluation.comparisonNotes
+        },
+        readiness: bundle.readiness,
+        pilotStatus: bundle.pilotStatus,
+        cutover: bundle.cutover
+      },
+      null,
+      2
+    )
+  );
+}
+
+async function reviewPendingFollowUps(limit = 10) {
+  const items = await deliveryManager.listPendingFollowUps(Number(limit));
+  console.log(JSON.stringify(items, null, 2));
+}
+
+async function sweepPendingFollowUps() {
+  const result = await deliveryManager.sweepPendingFollowUps();
+  console.log(JSON.stringify(result, null, 2));
+}
+
+async function consumeFollowUp(notificationFilePath) {
+  if (!notificationFilePath) {
+    throw new Error("consume-follow-up requires <notification-file-path>");
+  }
+  const result = await deliveryManager.consumeFollowUp(notificationFilePath);
+  console.log(JSON.stringify(result, null, 2));
+}
+
+async function queryQmd(agentId, query) {
+  const runtime = await scheduler.loadRuntime();
+  const agent = runtime.agents[agentId];
+  const result = await scheduler.backendManager.queryQmd(agentId, query, agent?.workspaceRoot || null, 5);
+  console.log(JSON.stringify(result, null, 2));
+}
+
+async function sqliteStatus(agentId) {
+  const memoryStore = new MemoryStore({ rootDir: stateRoot });
+  const result = await memoryStore.sqliteStatus(agentId);
+  console.log(JSON.stringify(result, null, 2));
+}
+
+async function sqliteCheckpoint(agentId, thresholdBytes) {
+  const memoryStore = new MemoryStore({ rootDir: stateRoot });
+  const result = await memoryStore.manageSqlite(agentId, {
+    thresholdBytes: thresholdBytes ? Number(thresholdBytes) : undefined
+  });
+  console.log(JSON.stringify(result, null, 2));
+}
+
+async function runtimeStatus(jsonFlag = false) {
+  const installDir = resolveRuntimeInstallDir();
+  const status = await buildRuntimeStatus({
+    projectRoot: installDir,
+    stateRoot: path.join(installDir, "state"),
+    liveRoot: resolveLiveRoot(installDir)
+  });
+
+  if (jsonFlag) {
+    console.log(JSON.stringify(status, null, 2));
+  } else {
+    console.log(formatRuntimeStatus(status));
+  }
+}
+
+async function mcpList() {
+  const { ConfigLoader } = await import("./config/loader.js");
+  const loader = new ConfigLoader({ rootDir: path.join(projectRoot, "config") });
+  const mcp = await loader.loadMcp();
+
+  if (!mcp.servers || Object.keys(mcp.servers).length === 0) {
+    console.log(MCP_EMPTY_STATE_MESSAGE);
+    return;
+  }
+
+  const { McpConsumer } = await import("./mcp/consumer.js");
+  const consumer = new McpConsumer({ config: mcp });
+
+  try {
+    const schemas = await consumer.allSchemas();
+    if (schemas.length === 0) {
+      console.log("MCP servers configured but no tools available.");
+      return;
+    }
+    console.log(`\nMCP Tools (${schemas.length}):\n`);
+    let lastServer = null;
+    for (const s of schemas) {
+      if (s.server !== lastServer) {
+        if (lastServer !== null) console.log("");
+        console.log(`  ${s.server}:`);
+        lastServer = s.server;
+      }
+      console.log(`    ${s.name.padEnd(40)} ${s.description}`);
+    }
+    console.log("");
+  } finally {
+    await consumer.shutdown();
+  }
+}
+
+async function listTools() {
+  const { ToolRegistry } = await import("./tools/registry.js");
+  const { registerMicroToolHandlers } = await import("./tools/micro/index.js");
+  const registry = new ToolRegistry();
+  registerMicroToolHandlers(registry, { workspaceRoot: projectRoot });
+  try {
+    const toolsDir = path.join(projectRoot, "config", "tools");
+    await registry.loadTools(toolsDir);
+  } catch { /* no tools dir is fine */ }
+  console.log("Configured tools:\n");
+  for (const id of registry.allToolIds()) {
+    const tool = registry.resolve(id);
+    console.log(`  ${id.padEnd(20)} ${(tool.tier || "micro").padEnd(8)} ${tool.description || ""}`);
+  }
+}
+
+async function addTool(toolId) {
+  if (!toolId) { console.error("Usage: nemoris tools add <tool-id>"); process.exitCode = 1; return; }
+  const { readFile: readFileAsync, writeFile: writeFileAsync, mkdir: mkdirAsync } = await import("node:fs/promises");
+  const catalogUrl = new URL("./tools/catalog.json", import.meta.url);
+  const catalog = JSON.parse(await readFileAsync(catalogUrl, "utf8"));
+  const entry = catalog[toolId];
+  if (!entry) {
+    console.error(`Unknown tool: ${toolId}. Available: ${Object.keys(catalog).join(", ")}`);
+    process.exitCode = 1;
+    return;
+  }
+  const toolsDir = path.join(projectRoot, "config", "tools");
+  await mkdirAsync(toolsDir, { recursive: true });
+  const lines = [
+    `[tool]`,
+    `id = "${toolId}"`,
+    `tier = "${entry.tier}"`,
+    `description = "${entry.description}"`,
+    `command = "${entry.command}"`,
+    `args = [${entry.args.map(a => `"${a}"`).join(", ")}]`,
+  ];
+  if (entry.env && Object.keys(entry.env).length > 0) {
+    const envPairs = Object.entries(entry.env).map(([k, v]) => `${k} = "${v}"`).join(", ");
+    lines.push(`env = { ${envPairs} }`);
+  }
+  lines.push("", `[tool.limits]`);
+  lines.push(`timeout_ms = ${entry.tier === "cli" ? 120000 : 30000}`);
+  lines.push(`max_output_bytes = ${entry.tier === "cli" ? 10485760 : 1048576}`);
+  const toml = lines.join("\n") + "\n";
+  await writeFileAsync(path.join(toolsDir, `${toolId}.toml`), toml);
+  console.log(`✓ Tool '${toolId}' added to config/tools/${toolId}.toml`);
+  for (const [envKey, prompt] of Object.entries(entry.env_prompts || {})) {
+    if (!process.env[envKey]) {
+      console.log(`  Set ${envKey} in your environment (${prompt})`);
+    }
+  }
+}
+
+async function listSkills() {
+  const { SkillsLoader } = await import("./skills/loader.js");
+  const loader = new SkillsLoader();
+  const skillsDir = path.join(projectRoot, "config", "skills");
+  await loader.loadSkills(skillsDir);
+  const all = loader.listAll();
+  if (all.length === 0) {
+    console.log("No skills configured. Run 'nemoris setup' to create defaults.");
+    return;
+  }
+  console.log("Configured skills:\n");
+  for (const [id, skill] of all) {
+    console.log(`  ${id.padEnd(25)} agents: ${skill.agent_scope.join(", ")}`);
+    console.log(`  ${"".padEnd(25)} tools: ${[...skill.tools.required, ...skill.tools.optional].join(", ")}`);
+  }
+}
+
+async function listImprovements() {
+  const { readdir: readdirAsync } = await import("node:fs/promises");
+  const { ImprovementEngine } = await import("./runtime/improvement-engine.js");
+  const engine = new ImprovementEngine({ stateRoot: path.join(projectRoot, "state") });
+  const tuningsRoot = path.join(projectRoot, "state", "tunings");
+  try {
+    const jobDirs = await readdirAsync(tuningsRoot);
+    let found = false;
+    for (const jobId of jobDirs) {
+      const tunings = await engine.loadTunings(jobId);
+      if (tunings.length > 0) {
+        found = true;
+        console.log(`\n${jobId} (${tunings.length} active tunings):`);
+        for (const t of tunings) {
+          console.log(`  ${t.trigger || "unknown"} — ${t.timestamp || "no timestamp"}`);
+        }
+      }
+    }
+    if (!found) console.log("No active tunings.");
+  } catch {
+    console.log("No active tunings.");
+  }
+}
+
+function writeOutput(stream, text) {
+  if (!text) {
+    return;
+  }
+  stream.write(text.endsWith("\n") ? text : `${text}\n`);
+}
+
+export async function main(argv = process.argv) {
+  let { command, rest } = parseArgs(argv);
+
+  if (!command) {
+    writeOutput(process.stdout, formatGeneralHelp());
+    return 0;
+  }
+
+  if (command === "--help" || command === "-h") {
+    writeOutput(process.stdout, formatGeneralHelp({ includeInternal: shouldShowAllCommands(rest) }));
+    return 0;
+  }
+
+  if (command === "--all" || command === "internal") {
+    writeOutput(process.stdout, formatGeneralHelp({ includeInternal: true }));
+    return 0;
+  }
+
+  if (hasHelpFlag(rest)) {
+    const helpText = formatCommandHelp(command);
+    if (helpText) {
+      writeOutput(process.stdout, helpText);
+      return 0;
+    }
+  }
+
+  if (!isKnownCommand(command)) {
+    writeOutput(process.stderr, formatGeneralHelp({ includeInternal: shouldShowAllCommands(rest) }));
+    process.exitCode = 1;
+    return 1;
+  }
+
+  const aliasResolved = resolveAlias(command, rest);
+  if (aliasResolved !== null) {
+    [command, ...rest] = aliasResolved;
+  }
+
+  if (command === "start") {
+    const installDir = resolveRuntimeInstallDir();
+    if (rest.includes("--foreground")) {
+      const [mode = "live", intervalMs = "30000"] = rest.filter((arg) => arg !== "--foreground");
+      await serveDaemon(mode, intervalMs, installDir);
+      return 0;
+    }
+    const result = await startDaemonCommand({ projectRoot: installDir });
+    writeOutput(result.exitCode === 0 ? process.stdout : process.stderr, result.message);
+    process.exitCode = result.exitCode;
+    return result.exitCode;
+  } else if (command === "stop") {
+    const result = await stopDaemonCommand({ projectRoot: resolveRuntimeInstallDir() });
+    writeOutput(result.exitCode === 0 ? process.stdout : process.stderr, result.message);
+    process.exitCode = result.exitCode;
+    return result.exitCode;
+  } else if (command === "restart") {
+    const result = await restartDaemonCommand({ projectRoot: resolveRuntimeInstallDir() });
+    writeOutput(result.exitCode === 0 ? process.stdout : process.stderr, result.message);
+    process.exitCode = result.exitCode;
+    return result.exitCode;
+  } else if (command === "logs") {
+    const result = await runLogsCommand({ projectRoot: resolveRuntimeInstallDir(), args: rest });
+    writeOutput(result.stream || process.stdout, result.message || "");
+    process.exitCode = result.exitCode;
+    return result.exitCode;
+  } else if (command === "chat") {
+    const installDir = resolveRuntimeInstallDir();
+    const { pidFile } = getDaemonPaths(installDir);
+    const trackedPid = readTrackedPid(pidFile);
+    const hasTrackedDaemon = isPidRunning(trackedPid);
+    const runningPids = hasTrackedDaemon ? [trackedPid] : await listServeDaemonPids();
+    if (runningPids.length === 0) {
+      writeOutput(process.stderr, "Daemon not running. Start with: nemoris start");
+      process.exitCode = 1;
+      return 1;
+    }
+    const { parseChatFlags, runChat } = await import("./tui/chat.js");
+    const flags = parseChatFlags(rest);
+    return runChat({
+      projectRoot: installDir,
+      stateDir: path.join(installDir, "state"),
+      agent: flags.agent,
+      model: flags.model,
+      noColor: flags.noColor,
+      json: flags.json,
+    });
+  } else if (command === "demo") {
+    await runDemo();
+  } else if (command === "inspect-memory") {
+    const [agentId = "main", query = "memory"] = rest;
+    await inspectMemory(agentId, query);
+  } else if (command === "shadow-summary") {
+    const [agentId = "main"] = rest;
+    await shadowSummary(agentId);
+  } else if (command === "shadow-import") {
+    const [agentId = "main"] = rest;
+    await shadowImport(agentId);
+  } else if (command === "provider-health") {
+    const [providerId = "ollama"] = rest;
+    await providerHealth(providerId);
+  } else if (command === "provider-capabilities") {
+    const [providerId = "ollama"] = rest;
+    await providerCapabilities(providerId);
+  } else if (command === "manifest-summary") {
+    await manifestSummary();
+  } else if (command === "plan-job") {
+    const [jobId = "heartbeat-check"] = rest;
+    await planJob(jobId);
+  } else if (command === "live-cron-summary") {
+    await liveCronSummary();
+  } else if (command === "compare-jobs") {
+    await compareJobs();
+  } else if (command === "execute-job") {
+    const [jobId = "heartbeat-check", mode = "dry-run", modelOverride = null] = rest;
+    await executeJob(jobId, mode, modelOverride);
+  } else if (command === "execute-job-with-report-fallback") {
+    const [jobId = "workspace-health", mode = "provider", modelOverride = null] = rest;
+    await executeJobWithReportFallback(jobId, mode, modelOverride);
+  } else if (command === "shadow-compare") {
+    const [jobId = "heartbeat-check"] = rest;
+    await shadowCompare(jobId);
+  } else if (command === "provider-mode-policy") {
+    await providerModePolicy();
+  } else if (command === "tick-scheduler") {
+    const [mode = "dry-run"] = rest;
+    await tickScheduler(mode);
+  } else if (command === "due-jobs") {
+    await dueJobs();
+  } else if (command === "review-runs") {
+    const [limit = "10"] = rest;
+    await reviewRuns(limit);
+  } else if (command === "review-notifications") {
+    const [limit = "10"] = rest;
+    await reviewNotifications(limit);
+  } else if (command === "review-deliveries") {
+    const [limit = "10"] = rest;
+    await reviewDeliveries(limit);
+  } else if (command === "review-pending-handoffs") {
+    const [limit = "10"] = rest;
+    await reviewPendingHandoffs(limit);
+  } else if (command === "review-pending-followups") {
+    const [limit = "10"] = rest;
+    await reviewPendingFollowUps(limit);
+  } else if (command === "sweep-pending-followups") {
+    await sweepPendingFollowUps();
+  } else if (command === "sweep-pending-handoffs") {
+    await sweepPendingHandoffs();
+  } else if (command === "deliver-notifications") {
+    const [mode = "shadow", limit = "10"] = rest;
+    await deliverNotifications(mode, limit);
+  } else if (command === "deliver-notification-file") {
+    const [mode = "shadow", notificationFilePath = null] = rest;
+    await deliverNotificationFile(mode, notificationFilePath);
+  } else if (command === "resolve-delivery-profile") {
+    const [profileName = "gateway_preview_main"] = rest;
+    await resolveDeliveryProfile(profileName);
+  } else if (command === "send-test-delivery") {
+    const [profileName = "gateway_preview_main", mode = "shadow", ...messageParts] = rest;
+    await sendTestDelivery(profileName, mode, ...messageParts);
+  } else if (command === "choose-handoff-peer") {
+    const [notificationFilePath = null, peerId = null, deliveryProfile = null] = rest;
+    await chooseHandoffPeer(notificationFilePath, peerId, deliveryProfile);
+  } else if (command === "choose-top-handoff-peer") {
+    const [notificationFilePath = null, deliveryProfile = null] = rest;
+    await chooseTopHandoffPeer(notificationFilePath, deliveryProfile);
+  } else if (command === "consume-follow-up") {
+    const [notificationFilePath = null] = rest;
+    await consumeFollowUp(notificationFilePath);
+  } else if (command === "serve-transport") {
+    const [port = "4318"] = rest;
+    await serveTransport(port);
+  } else if (command === "serve-daemon") {
+    const [mode = "dry-run", intervalMs = "30000"] = rest;
+    await serveDaemon(mode, intervalMs, resolveRuntimeInstallDir());
+  } else if (command === "migrate") {
+    const { runMigration } = await import("./runtime/migration.js");
+    const dryRun = rest.includes("--dry-run");
+    const liveRoot = process.env.NEMORIS_LIVE_ROOT || path.join(process.env.HOME || os.homedir(), ".openclaw");
+    const result = await runMigration({ installDir: projectRoot, liveRoot, dryRun });
+    console.log(JSON.stringify(result, null, 2));
+    return 0;
+  } else if (command === "review-inbox") {
+    const [limit = "10"] = rest;
+    await reviewInbox(limit);
+  } else if (command === "evaluate-runs") {
+    const [limit = "20"] = rest;
+    await evaluateRuns(limit);
+  } else if (command === "evaluate-job") {
+    const [jobId = "heartbeat-check"] = rest;
+    await evaluateJob(jobId);
+  } else if (command === "improvement-targets") {
+    await improvementTargets();
+  } else if (command === "run-improvement") {
+    const [targetId = "workspaceHealth", variantId = "baseline"] = rest;
+    await runImprovement(targetId, variantId);
+  } else if (command === "run-improvement-with-report-fallback") {
+    const [targetId = "workspaceHealth", variantId = "baseline"] = rest;
+    await runImprovementWithReportFallback(targetId, variantId);
+  } else if (command === "compare-improvements") {
+    const [targetId = "workspaceHealth", candidateVariantId = null, baselineVariantId = "baseline"] = rest;
+    await compareImprovements(targetId, candidateVariantId, baselineVariantId);
+  } else if (command === "compare-improvements-with-report-fallback") {
+    const [targetId = "workspaceHealth", candidateVariantId = null, baselineVariantId = "baseline"] = rest;
+    await compareImprovementsWithReportFallback(targetId, candidateVariantId, baselineVariantId);
+  } else if (command === "repair-and-compare-improvement") {
+    const [targetId = "workspaceHealth", candidateVariantId = null, baselineVariantId = "baseline"] = rest;
+    await repairAndCompareImprovement(targetId, candidateVariantId, baselineVariantId);
+  } else if (command === "repair-and-compare-improvement-with-report-fallback") {
+    const [targetId = "workspaceHealth", candidateVariantId = null, baselineVariantId = "baseline"] = rest;
+    await repairAndCompareImprovementWithReportFallback(targetId, candidateVariantId, baselineVariantId);
+  } else if (command === "shadow-eval-job") {
+    const [jobId = "heartbeat-check", modelOverride = null] = rest;
+    await shadowEvalJob(jobId, modelOverride);
+  } else if (command === "benchmark-models") {
+    const [jobId = "workspace-health", ...models] = rest;
+    await benchmarkModels(jobId, models);
+  } else if (command === "index-embeddings") {
+    const [agentId = "heartbeat"] = rest;
+    await indexEmbeddings(agentId);
+  } else if (command === "embedding-readiness") {
+    await embeddingReadiness();
+  } else if (command === "config-validate" || command === "validate-config") {
+    await configValidate();
+  } else if (command === "peer-readiness") {
+    const [peerId = "nemo"] = rest;
+    await peerReadiness(peerId);
+  } else if (command === "dependency-health") {
+    const [jobId = "workspace-health"] = rest;
+    await dependencyHealthForJob(jobId);
+  } else if (command === "report-fallback-readiness") {
+    const [jobId = "workspace-health"] = rest;
+    await reportFallbackReadiness(jobId);
+  } else if (command === "lane-readiness") {
+    const [jobId = "workspace-health"] = rest;
+    await laneReadiness(jobId);
+  } else if (command === "pilot-status") {
+    const [jobId = "workspace-health", limit = "10"] = rest;
+    await pilotStatus(jobId, limit);
+  } else if (command === "cutover-readiness") {
+    const [jobId = "workspace-health", limit = "10"] = rest;
+    await cutoverReadiness(jobId, limit);
+  } else if (command === "daily-driver-trust-pack") {
+    const [limit = "10"] = rest;
+    await dailyDriverTrustPack(limit);
+  } else if (command === "embedding-health") {
+    const [agentId = "heartbeat", probeArg = "false"] = rest;
+    await embeddingHealth(agentId, probeArg === "true" || probeArg === "probe");
+  } else if (command === "job-embedding-health") {
+    const [jobId = "heartbeat-check", probeArg = "false"] = rest;
+    await jobEmbeddingHealth(jobId, probeArg === "true" || probeArg === "probe");
+  } else if (command === "rebuild-job-embeddings") {
+    const [jobId = "heartbeat-check"] = rest;
+    await rebuildJobEmbeddings(jobId);
+  } else if (command === "query-embeddings") {
+    const [agentId = "heartbeat", query = "heartbeat memory"] = rest;
+    await queryEmbeddings(agentId, query);
+  } else if (command === "memory-backends") {
+    const [agentId = "heartbeat"] = rest;
+    await memoryBackends(agentId);
+  } else if (command === "list-agent-cards") {
+    await listAgentCards();
+  } else if (command === "find-agent-cards") {
+    const [query = "research"] = rest;
+    await findAgentCards(query);
+  } else if (command === "suggest-peers") {
+    const [taskType = "workspace_health", query = "workspace health"] = rest;
+    await suggestPeers(taskType, query);
+  } else if (command === "preview-workspace-health-validation") {
+    await previewWorkspaceHealthValidation();
+  } else if (command === "validate-workspace-health") {
+    const [mode = "preview", modelOverride = null] = rest;
+    await validateWorkspaceHealth(mode, modelOverride);
+  } else if (command === "validate-workspace-health-full") {
+    const [selection = "top", modelOverride = null, deliveryProfile = "peer_preview"] = rest;
+    await validateWorkspaceHealthFull(selection, modelOverride, deliveryProfile);
+  } else if (command === "validate-workspace-health-repeatable") {
+    const [selection = "top", modelOverride = null, deliveryProfile = "peer_preview"] = rest;
+    await validateWorkspaceHealthRepeatable(selection, modelOverride, deliveryProfile);
+  } else if (command === "validate-workspace-health-pilot") {
+    const [selection = "top", mode = "dry-run", modelOverride = null, deliveryProfile = "peer_preview"] = rest;
+    await validateWorkspaceHealthPilot(selection, mode, modelOverride, deliveryProfile);
+  } else if (command === "validate-memory-rollup") {
+    const [mode = "provider", modelOverride = null, deliveryMode = "live"] = rest;
+    await validateMemoryRollup(mode, modelOverride, deliveryMode);
+  } else if (command === "query-qmd") {
+    const [agentId = "heartbeat", query = "memory heartbeat"] = rest;
+    await queryQmd(agentId, query);
+  } else if (command === "sqlite-status") {
+    const [agentId = "main"] = rest;
+    await sqliteStatus(agentId);
+  } else if (command === "sqlite-checkpoint") {
+    const [agentId = "main", thresholdBytes = null] = rest;
+    await sqliteCheckpoint(agentId, thresholdBytes);
+  } else if (command === "maintenance-status") {
+    await maintenanceStatus();
+  } else if (command === "prune-state") {
+    const [scope = "all"] = rest;
+    await pruneState(scope);
+  } else if (command === "runtime-status") {
+    const jsonFlag = rest.includes("--json");
+    await runtimeStatus(jsonFlag);
+  } else if (command === "models") {
+    await showModelsOverview(resolveRuntimeInstallDir());
+  } else if (command === "setup" && rest[0] === "telegram") {
+    await setupTelegram();
+  } else if (command === "telegram" && rest[0] === "whoami") {
+    await telegramWhoami();
+  } else if (command === "uninstall") {
+    const { runUninstall } = await import("./onboarding/uninstall.js");
+    const force = rest.includes("--force") || rest.includes("-f");
+    return runUninstall({ installDir: resolveRuntimeInstallDir(), force });
+  } else if (command === "setup") {
+    const { runWizard } = await import("./onboarding/wizard.js");
+    const nonInteractive = rest.includes("--non-interactive");
+    const advanced = rest.includes("--advanced");
+    return runWizard({
+      installDir: resolveRuntimeInstallDir(),
+      nonInteractive,
+      advanced,
+      acceptRisk: rest.includes("--accept-risk"),
+      flow: parseFlagValue(rest, "--flow"),
+      anthropicKey: parseFlagValue(rest, "--anthropic-key"),
+      openaiKey: parseFlagValue(rest, "--openai-key"),
+      openrouterKey: parseFlagValue(rest, "--openrouter-key"),
+      telegramToken: parseFlagValue(rest, "--telegram-token"),
+    });
+  } else if (command === "init") {
+    const { runWizard } = await import("./onboarding/wizard.js");
+    const nonInteractive = rest.includes("--non-interactive");
+    const advanced = rest.includes("--advanced");
+    return runWizard({
+      installDir: resolveRuntimeInstallDir(),
+      nonInteractive,
+      advanced,
+      acceptRisk: rest.includes("--accept-risk"),
+      flow: parseFlagValue(rest, "--flow"),
+      anthropicKey: parseFlagValue(rest, "--anthropic-key"),
+      openaiKey: parseFlagValue(rest, "--openai-key"),
+      openrouterKey: parseFlagValue(rest, "--openrouter-key"),
+      telegramToken: parseFlagValue(rest, "--telegram-token"),
+    });
+  } else if (command === "doctor") {
+    const { runDoctor, formatDoctorReport } = await import("./onboarding/doctor.js");
+    const results = await runDoctor(resolveRuntimeInstallDir());
+    const json = rest.includes("--json");
+    if (json) {
+      console.log(JSON.stringify(results, null, 2));
+    } else {
+      console.log(formatDoctorReport(results));
+    }
+    return results.exitCode;
+  } else if (command === "battle") {
+    const { runBattle, parseBattleFlags } = await import("./battle.js");
+    const flags = parseBattleFlags(rest);
+    await runBattle(flags);
+  } else if (command === "mcp") {
+    if (rest.length === 0 || rest[0] === "list") {
+      await mcpList();
+    } else {
+      writeOutput(process.stderr, formatCommandHelp("mcp"));
+      process.exitCode = 1;
+      return 1;
+    }
+  } else if (command === "tools") {
+    const [sub, toolId] = rest;
+    if (sub === "add") {
+      await addTool(toolId);
+    } else {
+      await listTools();
+    }
+  } else if (command === "skills") {
+    await listSkills();
+  } else if (command === "improvements") {
+    await listImprovements();
+  } else {
+    writeOutput(process.stderr, formatGeneralHelp({ includeInternal: shouldShowAllCommands(rest) }));
+    process.exitCode = 1;
+    return 1;
+  }
+
+  return process.exitCode || 0;
+}