@agentconnect.md/daemon 0.0.0

package/dist/index.js

@@ -0,0 +1,2478 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/daemon.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { hostname, loadavg, freemem, totalmem } from "os";
+import chokidar from "chokidar";
+
+// src/config/load-config.ts
+import { readFileSync, existsSync, writeFileSync, mkdirSync } from "fs";
+import { dirname } from "path";
+
+// src/config/config-schema.ts
+import { z } from "zod";
+var RuntimeDefSchema = z.object({
+  command: z.string(),
+  args: z.array(z.string()).default([]),
+  env: z.array(z.object({ name: z.string(), value: z.string() })).default([])
+});
+var ConfigSchema = z.object({
+  version: z.literal(1),
+  daemonId: z.string().optional(),
+  controlPlane: z.object({
+    enabled: z.boolean().default(true),
+    url: z.string().optional(),
+    token: z.string().optional(),
+    heartbeatMs: z.number().int().default(15e3)
+  }).default({ enabled: false, heartbeatMs: 15e3 }),
+  agentsDir: z.string().optional(),
+  // resolved against root if absent
+  runtimes: z.record(z.string(), RuntimeDefSchema).optional(),
+  logging: z.object({ level: z.enum(["trace", "debug", "info", "warn", "error"]).default("info") }).default({ level: "info" }),
+  limits: z.object({
+    maxAgents: z.number().int().default(8),
+    maxConcurrentSessions: z.number().int().default(32),
+    agentIdleTimeoutMs: z.number().int().default(9e5)
+  }).default({ maxAgents: 8, maxConcurrentSessions: 32, agentIdleTimeoutMs: 9e5 })
+});
+
+// src/paths.ts
+import { homedir } from "os";
+import { join, resolve } from "path";
+function resolveRoot(root) {
+  const r = root ?? process.env.AGENTCONNECT_ROOT ?? join(homedir(), ".agentconnect");
+  return resolve(r.replace(/^~(?=$|\/)/, homedir()));
+}
+function configPath(root) {
+  return join(root, "config.json");
+}
+function statePath(root) {
+  return join(root, "state", "local.sqlite");
+}
+function defaultAgentsDir(root) {
+  return join(root, "agents");
+}
+function registryPath(root) {
+  return join(root, "acp_registry.json");
+}
+function registryCachePath(root) {
+  return join(root, "acp_registry.cache.json");
+}
+
+// src/config/load-config.ts
+function loadConfig(opts = {}) {
+  const root = resolveRoot(opts.root);
+  const file = opts.configPath ?? configPath(root);
+  let raw;
+  if (existsSync(file)) {
+    raw = JSON.parse(readFileSync(file, "utf8"));
+  } else if (opts.autoCreate) {
+    raw = { version: 1 };
+    mkdirSync(dirname(file), { recursive: true });
+    writeFileSync(file, JSON.stringify(raw, null, 2) + "\n");
+  } else if (opts.optional) {
+    raw = { version: 1 };
+  } else {
+    throw new Error(`config not found: ${file} (create it, pass --config, or run \`agentconnect login\`)`);
+  }
+  const cfg = ConfigSchema.parse(raw);
+  const o = opts.overrides ?? {};
+  if (o.daemonId) cfg.daemonId = o.daemonId;
+  if (o.logLevel) cfg.logging.level = o.logLevel;
+  if (o.maxAgents !== void 0) cfg.limits.maxAgents = o.maxAgents;
+  if (o.cpUrl) cfg.controlPlane.url = o.cpUrl;
+  if (o.cpToken) cfg.controlPlane.token = o.cpToken;
+  if (o.cpUrl || o.cpToken) cfg.controlPlane.enabled = true;
+  if (o.noCp) cfg.controlPlane.enabled = false;
+  cfg.agentsDir = o.agentsDir ?? cfg.agentsDir ?? defaultAgentsDir(root);
+  return cfg;
+}
+function persistDaemonId(root, daemonId) {
+  try {
+    const file = configPath(resolveRoot(root));
+    const raw = existsSync(file) ? JSON.parse(readFileSync(file, "utf8")) : { version: 1 };
+    raw.daemonId = daemonId;
+    mkdirSync(dirname(file), { recursive: true });
+    writeFileSync(file, JSON.stringify(raw, null, 2) + "\n");
+  } catch {
+  }
+}
+
+// src/agents/load-agents.ts
+import { readFileSync as readFileSync3, readdirSync, existsSync as existsSync3 } from "fs";
+import { join as join3, resolve as resolve2, isAbsolute, dirname as dirname2 } from "path";
+
+// src/agents/agent-schema.ts
+import { z as z2 } from "zod";
+var BindMatchSchema = z2.discriminatedUnion("kind", [
+  z2.object({ kind: z2.literal("mention") }),
+  z2.object({ kind: z2.literal("dm") }),
+  z2.object({ kind: z2.literal("keyword"), value: z2.string() }),
+  z2.object({ kind: z2.literal("auto") })
+]);
+var BindRuleConfigSchema = z2.object({
+  channel: z2.string().optional(),
+  // absent = any channel
+  thread: z2.string().optional(),
+  match: BindMatchSchema
+});
+var SlackConfigSchema = z2.object({
+  botToken: z2.string(),
+  appToken: z2.string(),
+  signingSecret: z2.string().optional(),
+  botUserId: z2.string().optional(),
+  // filled at connect via auth.test if absent
+  allowedUserIds: z2.array(z2.string()).default([]),
+  notificationChannelId: z2.string().optional(),
+  bindRules: z2.array(BindRuleConfigSchema).default([])
+});
+var IntegrationSchema = z2.object({
+  id: z2.string(),
+  platform: z2.literal("slack"),
+  slack: SlackConfigSchema
+});
+var CronDefSchema = z2.object({
+  id: z2.string(),
+  schedule: z2.string(),
+  target: z2.object({ platform: z2.literal("slack"), channel: z2.string() }),
+  trigger: z2.string()
+});
+var AgentSchema = z2.object({
+  id: z2.string(),
+  name: z2.string(),
+  status: z2.enum(["active", "inactive", "paused"]).default("active"),
+  runtime: z2.string(),
+  runtimeOverrides: z2.object({
+    model: z2.string().optional(),
+    env: z2.array(z2.object({ name: z2.string(), value: z2.string() })).default([])
+  }).optional(),
+  workspace: z2.object({
+    mode: z2.enum(["git-repo", "from-scratch"]),
+    path: z2.string(),
+    gitRepo: z2.string().optional(),
+    gitBranch: z2.string().default("main"),
+    pullOnNewSession: z2.boolean().default(true),
+    skills: z2.array(z2.string()).default([])
+  }),
+  integrations: z2.array(IntegrationSchema).default([]),
+  // zod 4: nested .default({}) does not apply inner field defaults — use explicit full literal
+  output: z2.object({ mode: z2.enum(["low", "medium", "high"]).default("low") }).default({ mode: "low" }),
+  permissions: z2.object({ policy: z2.enum(["ask", "auto"]).default("ask"), autoApprove: z2.array(z2.string()).default([]) }).default({ policy: "ask", autoApprove: [] }),
+  crons: z2.array(CronDefSchema).default([])
+});
+
+// src/agents/agent-env.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { join as join2 } from "path";
+function parseDotenv(text) {
+  const out = {};
+  for (const rawLine of text.split("\n")) {
+    const line = rawLine.replace(/\r$/, "").trim();
+    if (!line || line.startsWith("#")) continue;
+    const body = line.startsWith("export ") ? line.slice(7).trim() : line;
+    const eq = body.indexOf("=");
+    if (eq === -1) continue;
+    const key = body.slice(0, eq).trim();
+    if (!key) continue;
+    let value = body.slice(eq + 1).trim();
+    const q = value[0];
+    if (value.length >= 2 && (q === '"' || q === "'") && value.at(-1) === q) {
+      value = value.slice(1, -1);
+    }
+    out[key] = value;
+  }
+  return out;
+}
+function loadDotenv(dir) {
+  const file = join2(dir, ".env");
+  if (!existsSync2(file)) return {};
+  return parseDotenv(readFileSync2(file, "utf8"));
+}
+var VAR_RE = /\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g;
+function interpolateString(value, source, path, ctx) {
+  return value.replace(VAR_RE, (_m, name) => {
+    const resolved = source[name];
+    if (resolved === void 0) {
+      throw new Error(`agent "${ctx.id}": unresolved \${${name}} in ${path} (.env: ${ctx.envPath})`);
+    }
+    return resolved;
+  });
+}
+function walk(node, source, path, ctx) {
+  if (typeof node === "string") return interpolateString(node, source, path, ctx);
+  if (Array.isArray(node)) {
+    for (let i = 0; i < node.length; i++) node[i] = walk(node[i], source, `${path}[${i}]`, ctx);
+    return node;
+  }
+  if (node && typeof node === "object") {
+    const obj = node;
+    for (const key of Object.keys(obj)) {
+      obj[key] = walk(obj[key], source, path ? `${path}.${key}` : key, ctx);
+    }
+    return node;
+  }
+  return node;
+}
+function interpolateAgent(agent2, source, ctx) {
+  walk(agent2, source, "", ctx);
+}
+function agentChildEnv(agent2) {
+  return {
+    ...agent2.env,
+    ...Object.fromEntries((agent2.runtimeOverrides?.env ?? []).map((e) => [e.name, e.value]))
+  };
+}
+
+// src/agents/load-agents.ts
+var IGNORED_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git"]);
+var MAX_DEPTH = 4;
+function parseAgentFile(file) {
+  const dir = dirname2(file);
+  const env = loadDotenv(dir);
+  const agent2 = AgentSchema.parse(JSON.parse(readFileSync3(file, "utf8")));
+  interpolateAgent(agent2, { ...process.env, ...env }, { id: agent2.id, envPath: join3(dir, ".env") });
+  if (!isAbsolute(agent2.workspace.path)) {
+    agent2.workspace.path = resolve2(dir, agent2.workspace.path);
+  }
+  return { ...agent2, dir, env };
+}
+function findAgentFiles(dir, depth = 0) {
+  if (depth > MAX_DEPTH || !existsSync3(dir)) return [];
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  if (entries.some((e) => e.isFile() && e.name === "agent.json")) {
+    return [join3(dir, "agent.json")];
+  }
+  const out = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    if (IGNORED_DIRS.has(entry.name) || entry.name.startsWith(".")) continue;
+    out.push(...findAgentFiles(join3(dir, entry.name), depth + 1));
+  }
+  return out;
+}
+function discoverAgents(agentsDir) {
+  return findAgentFiles(agentsDir).map((file) => {
+    try {
+      return { agent: parseAgentFile(file), dir: dirname2(file) };
+    } catch (err) {
+      throw new Error(`invalid agent.json at ${file}: ${err.message}`);
+    }
+  });
+}
+function loadAgents(agentsDir) {
+  return discoverAgents(agentsDir).map((d) => d.agent).filter((a) => a.status === "active");
+}
+function selectAgent(agentsDir, name) {
+  const agents = discoverAgents(agentsDir).map((d) => d.agent);
+  if (name) {
+    const match = agents.find((a) => a.id === name);
+    if (!match) {
+      const available = agents.map((a) => a.id).sort().join(", ") || "(none)";
+      throw new Error(`agent "${name}" not found in ${agentsDir}. Available: ${available}`);
+    }
+    return match;
+  }
+  if (agents.length === 0) throw new Error(`no agent.json found in ${agentsDir}`);
+  if (agents.length > 1) {
+    const ids = agents.map((a) => a.id).sort().join(", ");
+    throw new Error(`multiple agents found in ${agentsDir}: ${ids}; use --agent <name> to specify one`);
+  }
+  return agents[0];
+}
+
+// src/reconciler/reconciler.ts
+function diffAgents(desired, actualIds) {
+  const desiredIds = new Set(desired.map((a) => a.id));
+  const toStart = desired.filter((a) => !actualIds.includes(a.id));
+  const toStop = actualIds.filter((id) => !desiredIds.has(id));
+  return { toStart, toStop };
+}
+
+// src/store/local-store.ts
+import Database from "better-sqlite3";
+import { mkdirSync as mkdirSync2 } from "fs";
+import { dirname as dirname3 } from "path";
+function sessionKey(platform, channel, thread, agentId) {
+  return `${platform}:${channel}:${thread}:${agentId}`;
+}
+var LocalStore = class {
+  db;
+  constructor(dbPath) {
+    mkdirSync2(dirname3(dbPath), { recursive: true });
+    this.db = new Database(dbPath);
+    this.db.pragma("journal_mode = WAL");
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS sessions (
+        key TEXT PRIMARY KEY, agentId TEXT, platform TEXT, channel TEXT, thread TEXT,
+        acpSessionId TEXT, state TEXT, lastDeliveredTs TEXT, updatedAt INTEGER
+      );
+      CREATE TABLE IF NOT EXISTS transcript (
+        channel TEXT, thread TEXT, ts TEXT, sender TEXT, text TEXT,
+        PRIMARY KEY (channel, thread, ts)
+      );
+      CREATE TABLE IF NOT EXISTS cp_routing (
+        id INTEGER PRIMARY KEY CHECK (id = 1),
+        routingEpoch INTEGER, assignments TEXT, globalRules TEXT
+      );
+    `);
+  }
+  getSession(key) {
+    return this.db.prepare("SELECT * FROM sessions WHERE key = ?").get(key);
+  }
+  upsertSession(rec) {
+    this.db.prepare(
+      `INSERT INTO sessions (key, agentId, platform, channel, thread, acpSessionId, state, lastDeliveredTs, updatedAt)
+         VALUES (@key, @agentId, @platform, @channel, @thread, @acpSessionId, @state, @lastDeliveredTs, @updatedAt)
+         ON CONFLICT(key) DO UPDATE SET
+           acpSessionId=excluded.acpSessionId, state=excluded.state,
+           lastDeliveredTs=excluded.lastDeliveredTs, updatedAt=excluded.updatedAt`
+    ).run(rec);
+  }
+  appendTranscript(e) {
+    this.db.prepare(
+      "INSERT OR IGNORE INTO transcript (channel, thread, ts, sender, text) VALUES (@channel, @thread, @ts, @sender, @text)"
+    ).run(e);
+  }
+  transcriptSince(channel, thread, sinceTs) {
+    if (sinceTs === null) {
+      return this.db.prepare("SELECT * FROM transcript WHERE channel = ? AND thread = ? ORDER BY ts ASC").all(channel, thread);
+    }
+    return this.db.prepare("SELECT * FROM transcript WHERE channel = ? AND thread = ? AND ts > ? ORDER BY ts ASC").all(channel, thread, sinceTs);
+  }
+  openSessionAgents(channel, thread) {
+    return this.db.prepare("SELECT agentId FROM sessions WHERE channel = ? AND thread = ? AND state != 'closed'").all(channel, thread).map((r) => r.agentId);
+  }
+  getCpRouting() {
+    return this.db.prepare("SELECT routingEpoch, assignments, globalRules FROM cp_routing WHERE id = 1").get();
+  }
+  setCpRouting(routingEpoch, assignments, globalRules) {
+    this.db.prepare(
+      `INSERT INTO cp_routing (id, routingEpoch, assignments, globalRules) VALUES (1, @routingEpoch, @assignments, @globalRules)
+         ON CONFLICT(id) DO UPDATE SET routingEpoch=excluded.routingEpoch, assignments=excluded.assignments, globalRules=excluded.globalRules`
+    ).run({ routingEpoch, assignments, globalRules });
+  }
+  close() {
+    this.db.close();
+  }
+};
+
+// src/acp/acp-host.ts
+import { spawn } from "child_process";
+import { Readable, Writable } from "stream";
+import {
+  ClientSideConnection,
+  ndJsonStream
+} from "@agentclientprotocol/sdk";
+var PROTOCOL_VERSION = 1;
+var AcpHost = class {
+  constructor(runtime, opts) {
+    this.runtime = runtime;
+    this.opts = opts;
+  }
+  runtime;
+  opts;
+  child;
+  conn;
+  async start() {
+    if (this.child) throw new Error("AcpHost: already started");
+    const child = spawn(this.runtime.command, this.runtime.args, {
+      stdio: ["pipe", "pipe", "inherit"],
+      env: {
+        ...process.env,
+        ...Object.fromEntries(this.runtime.env.map((e) => [e.name, e.value])),
+        ...this.opts.env ?? {}
+      }
+    });
+    this.child = child;
+    if (!child.stdin || !child.stdout) {
+      throw new Error("AcpHost: subprocess stdin/stdout are not piped");
+    }
+    const toAgent = Writable.toWeb(child.stdin);
+    const fromAgent = Readable.toWeb(child.stdout);
+    const stream = ndJsonStream(toAgent, fromAgent);
+    const self = this;
+    this.conn = new ClientSideConnection((_agent) => {
+      return {
+        async sessionUpdate(params) {
+          self.opts.onUpdate(params.sessionId, params.update);
+        },
+        async requestPermission(params) {
+          const allow = params.options.find((o) => o.kind === "allow_once" || o.kind === "allow_always");
+          const optionId = (allow ?? params.options[0])?.optionId;
+          return {
+            outcome: optionId ? { outcome: "selected", optionId } : { outcome: "cancelled" }
+          };
+        },
+        async readTextFile() {
+          throw new Error("fs.readTextFile not supported in MVP");
+        },
+        async writeTextFile() {
+          throw new Error("fs.writeTextFile not supported in MVP");
+        }
+      };
+    }, stream);
+    await this.conn.initialize({
+      protocolVersion: PROTOCOL_VERSION,
+      clientCapabilities: { fs: { readTextFile: false, writeTextFile: false } }
+    });
+  }
+  async newSession(cwd) {
+    const res = await this.conn.newSession({ cwd, mcpServers: [] });
+    return res.sessionId;
+  }
+  async prompt(sessionId, blocks) {
+    const res = await this.conn.prompt({ sessionId, prompt: blocks });
+    return res.stopReason;
+  }
+  async cancel(sessionId) {
+    await this.conn.cancel({ sessionId });
+  }
+  async stop() {
+    if (!this.child) return;
+    this.child.kill("SIGTERM");
+    await new Promise((resolve3) => this.child.once("exit", () => resolve3()));
+  }
+};
+
+// src/workspace/workspace-manager.ts
+import { mkdirSync as mkdirSync3, existsSync as existsSync4, writeFileSync as writeFileSync2 } from "fs";
+import { join as join4 } from "path";
+import { simpleGit } from "simple-git";
+var PULL_TIMEOUT_MS = 4500;
+async function prepareWorkspace(agent2) {
+  const cwd = agent2.workspace.path;
+  mkdirSync3(cwd, { recursive: true });
+  if (agent2.workspace.mode === "from-scratch") {
+    const mem = join4(cwd, "memory.md");
+    if (!existsSync4(mem)) writeFileSync2(mem, `# ${agent2.name} memory
+`);
+    return cwd;
+  }
+  if (agent2.workspace.pullOnNewSession && existsSync4(join4(cwd, ".git"))) {
+    try {
+      await Promise.race([
+        simpleGit(cwd).pull(["--ff-only"]),
+        new Promise((_, rej) => setTimeout(() => rej(new Error("pull timeout")), PULL_TIMEOUT_MS))
+      ]);
+    } catch {
+    }
+  }
+  return cwd;
+}
+
+// src/session/session-manager.ts
+var SessionManager = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  deps;
+  threadOwner(channel, thread) {
+    const owners = this.deps.store.openSessionAgents(channel, thread);
+    return owners.length === 1 ? owners[0] : null;
+  }
+  async handle(agentId, msg) {
+    const agent2 = this.deps.agentById(agentId);
+    if (!agent2) throw new Error(`unknown agent ${agentId}`);
+    const thread = msg.thread ?? msg.msgId;
+    const key = sessionKey(msg.platform, msg.channel, thread, agentId);
+    this.deps.store.appendTranscript({
+      channel: msg.channel,
+      thread,
+      ts: tsOf(msg),
+      sender: msg.sender.id,
+      text: msg.text
+    });
+    let rec = this.deps.store.getSession(key);
+    const host = await this.deps.hostFor(agentId);
+    if (!rec || !rec.acpSessionId) {
+      const cwd = await prepareWorkspace(agent2);
+      const acpSessionId = await host.newSession(cwd);
+      rec = {
+        key,
+        agentId,
+        platform: msg.platform,
+        channel: msg.channel,
+        thread,
+        acpSessionId,
+        state: "idle",
+        lastDeliveredTs: null,
+        updatedAt: Date.now()
+      };
+      this.deps.store.upsertSession(rec);
+    }
+    const gap = this.deps.store.transcriptSince(msg.channel, thread, rec.lastDeliveredTs);
+    const blocks = [];
+    const context = gap.slice(0, -1);
+    if (context.length > 0) {
+      const ctxText = context.map((e) => `[${e.sender}] ${e.text}`).join("\n");
+      blocks.push({ type: "text", text: `(thread context you may have missed)
+${ctxText}` });
+    }
+    blocks.push({ type: "text", text: msg.text });
+    rec.lastDeliveredTs = tsOf(msg);
+    rec.state = "prompting";
+    rec.updatedAt = Date.now();
+    this.deps.store.upsertSession(rec);
+    return { sessionId: rec.acpSessionId, blocks };
+  }
+};
+function tsOf(msg) {
+  const parts = msg.msgId.split(":");
+  return parts[parts.length - 1] ?? "0";
+}
+
+// src/router/routing-table.ts
+var KIND_ORDER = ["mention", "dm", "keyword", "auto"];
+function scopeMatches(r, msg) {
+  if (r.scope.channel !== void 0 && r.scope.channel !== msg.channel) return false;
+  if (r.scope.thread !== void 0 && r.scope.thread !== msg.thread) return false;
+  return true;
+}
+function kindMatches(r, msg) {
+  switch (r.match.kind) {
+    case "mention":
+      return r.botUserId !== "" && msg.mentionedBots.includes(r.botUserId);
+    case "dm":
+      return msg.isDm;
+    case "keyword":
+      return msg.text.toLowerCase().includes(r.match.value.toLowerCase());
+    case "auto":
+      return true;
+  }
+}
+var pickRule = (r) => ({ agentId: r.agentId, integrationId: r.integrationId });
+function routeRules(msg, rules, threadOwner) {
+  if (msg.sender.isBot) return null;
+  const authz = (r) => !r.allowedUserIds || r.allowedUserIds.length === 0 || r.allowedUserIds.includes(msg.sender.id);
+  const scopeCandidates = rules.filter((r) => scopeMatches(r, msg) && authz(r));
+  const kindCandidates = scopeCandidates.filter((r) => kindMatches(r, msg));
+  const mention = kindCandidates.find((r) => r.match.kind === "mention");
+  if (mention) return pickRule(mention);
+  if (msg.thread) {
+    const owner = threadOwner(msg.channel, msg.thread);
+    if (owner) {
+      const reachable = new Set(scopeCandidates.map((r) => r.agentId));
+      if (reachable.has(owner)) {
+        if (reachable.size === 1) {
+          const r = scopeCandidates.find((x) => x.agentId === owner);
+          return pickRule(r);
+        }
+        return null;
+      }
+    }
+  }
+  const cpInChannel = kindCandidates.some(
+    (r) => r.source === "cp" && r.scope.channel === msg.channel && (r.scope.thread === void 0 || r.scope.thread === msg.thread)
+  );
+  const layer = cpInChannel ? kindCandidates.filter((r) => r.source === "cp") : kindCandidates;
+  for (const kind of KIND_ORDER) {
+    if (kind === "mention") continue;
+    const r = layer.find((x) => x.match.kind === kind);
+    if (r) return pickRule(r);
+  }
+  return null;
+}
+
+// src/router/routing-rule.ts
+function resolveAgentIntegration(agent2, botUserIds) {
+  const int = agent2?.integrations.find((i) => i.platform === "slack");
+  if (!int) return null;
+  return { integrationId: int.id, botUserId: botUserIds[int.id] ?? int.slack.botUserId ?? "" };
+}
+function rulesFromAgent(agent2, botUserIds) {
+  const out = [];
+  for (const int of agent2.integrations) {
+    if (int.platform !== "slack") continue;
+    const botUserId = botUserIds[int.id] ?? int.slack.botUserId ?? "";
+    for (const br of int.slack.bindRules) {
+      out.push({
+        agentId: agent2.id,
+        integrationId: int.id,
+        botUserId,
+        scope: { ...br.channel ? { channel: br.channel } : {}, ...br.thread ? { thread: br.thread } : {} },
+        match: br.match,
+        allowedUserIds: int.slack.allowedUserIds,
+        source: "config"
+      });
+    }
+  }
+  return out;
+}
+function resolveCpRule(cp, resolve3) {
+  const r = resolve3(cp.agentId);
+  if (!r) return null;
+  return {
+    agentId: cp.agentId,
+    integrationId: r.integrationId,
+    botUserId: r.botUserId,
+    scope: cp.scope,
+    match: cp.match,
+    source: "cp",
+    ...cp.epoch !== void 0 ? { epoch: cp.epoch } : {}
+  };
+}
+function sessionKeyStr(sk) {
+  return `${sk.platform}:${sk.channel}:${sk.thread ?? "-"}`;
+}
+function cpRulesFromAssign(a, epoch) {
+  return a.bindRules.map((br) => ({
+    agentId: a.agentId,
+    scope: { channel: a.sessionKey.channel, ...a.sessionKey.thread ? { thread: a.sessionKey.thread } : {} },
+    match: br.match,
+    ...epoch !== void 0 ? { epoch } : {}
+  }));
+}
+function cpRulesFromUpdate(u) {
+  const out = [];
+  for (const r of u.rules) {
+    const m = r.match;
+    if (m?.kind === "mention" || m?.kind === "dm" || m?.kind === "auto") {
+      out.push({ agentId: r.agentId, scope: {}, match: { kind: m.kind }, epoch: u.routingEpoch });
+    } else if (m?.kind === "keyword" && typeof m.value === "string") {
+      out.push({ agentId: r.agentId, scope: {}, match: { kind: "keyword", value: m.value }, epoch: u.routingEpoch });
+    }
+  }
+  return out;
+}
+
+// src/router/cp-routing-layer.ts
+var CpRoutingLayer = class {
+  constructor(io) {
+    this.io = io;
+    const s = io.load();
+    if (s) {
+      this.routingEpoch = s.routingEpoch;
+      this.assignments = new Map(Object.entries(s.assignments));
+      this.globalRules = s.globalRules;
+    }
+  }
+  io;
+  routingEpoch = 0;
+  assignments = /* @__PURE__ */ new Map();
+  globalRules = [];
+  upsertAssign(a) {
+    this.assignments.set(sessionKeyStr(a.sessionKey), cpRulesFromAssign(a, this.routingEpoch));
+    this.persist();
+  }
+  applyUpdate(u) {
+    if (u.routingEpoch < this.routingEpoch) return;
+    this.routingEpoch = u.routingEpoch;
+    this.globalRules = cpRulesFromUpdate(u);
+    this.persist();
+  }
+  // Intentionally converges ONLY `assignments`: the register/ok reconcile snapshot carries no
+  // route/update global rules — those have their own epoch lifecycle via `applyUpdate`.
+  converge(snap) {
+    this.routingEpoch = snap.routingEpoch;
+    this.assignments = new Map(
+      snap.assignments.map((a) => [sessionKeyStr(a.sessionKey), cpRulesFromAssign(a, snap.routingEpoch)])
+    );
+    for (const k of snap.drop.assignments) this.assignments.delete(k);
+    this.persist();
+  }
+  effectiveRules() {
+    return [...[...this.assignments.values()].flat(), ...this.globalRules];
+  }
+  persist() {
+    this.io.save({
+      routingEpoch: this.routingEpoch,
+      assignments: Object.fromEntries(this.assignments),
+      globalRules: this.globalRules
+    });
+  }
+};
+
+// src/slack/connection.ts
+import pkg from "@slack/bolt";
+
+// src/slack/normalize.ts
+var MENTION_RE = /<@([A-Z0-9]+)>/g;
+function normalizeSlackEvent(event, ctx) {
+  const text = event.text ?? "";
+  const mentionedBots = [...text.matchAll(MENTION_RE)].map((m) => m[1]);
+  return {
+    msgId: `slack:${event.channel}:${event.ts}`,
+    traceId: ctx.traceId,
+    source: "user",
+    platform: "slack",
+    channel: event.channel,
+    thread: event.thread_ts ?? event.ts,
+    sender: { id: event.user ?? event.bot_id ?? "unknown", isBot: Boolean(event.bot_id) },
+    text,
+    mentionedBots,
+    isDm: event.channel_type === "im"
+  };
+}
+
+// src/slack/connection.ts
+var { App, LogLevel } = pkg;
+function consolidate(agents) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const a of agents) {
+    for (const int of a.integrations) {
+      if (int.platform !== "slack") continue;
+      const k = int.slack.appToken;
+      const g = groups.get(k) ?? { appToken: k, botToken: int.slack.botToken, integrations: [] };
+      g.integrations.push({ agentId: a.id, integrationId: int.id });
+      groups.set(k, g);
+    }
+  }
+  return groups;
+}
+var SlackConnection = class {
+  constructor(deps, factory = (o) => new App({
+    token: o.token,
+    appToken: o.appToken,
+    socketMode: true,
+    ...deps.boltDebug ? { logLevel: LogLevel.DEBUG } : {}
+  })) {
+    this.deps = deps;
+    this.app = factory({ token: deps.group.botToken, appToken: deps.group.appToken });
+  }
+  deps;
+  app;
+  botUserId = "";
+  async start() {
+    const log = this.deps.log;
+    log?.debug("slack: auth.test \u2192 resolving bot identity (HTTPS)\u2026");
+    const auth = await this.app.client.auth.test();
+    this.botUserId = auth.user_id ?? "";
+    log?.debug(`slack: auth.test ok \u2192 bot user ${this.botUserId}`);
+    const deliver = (ev, kind) => {
+      const msg = normalizeSlackEvent(ev, { traceId: this.deps.newTraceId() });
+      log?.debug(
+        `slack: inbound ${kind} ch=${msg.channel} user=${msg.sender.id} isBot=${msg.sender.isBot} isDm=${msg.isDm} mentions=[${msg.mentionedBots.join(",")}] text=${JSON.stringify(msg.text.slice(0, 80))}`
+      );
+      this.deps.onMessage(msg);
+    };
+    this.app.message(async ({ message }) => {
+      const ev = message;
+      if (ev.type !== "message" || !ev.channel) {
+        log?.debug(`slack: inbound event ignored (type=${ev.type}, channel=${ev.channel ?? "none"})`);
+        return;
+      }
+      deliver(ev, "message");
+    });
+    this.app.event("app_mention", async ({ event }) => {
+      const ev = event;
+      if (!ev.channel) return;
+      deliver(ev, "app_mention");
+    });
+    log?.debug("slack: app.start \u2192 opening Socket Mode WebSocket (wss://\u2026slack.com)\u2026");
+    await this.app.start();
+    log?.debug("slack: app.start resolved \u2192 socket established");
+  }
+  async postMessage(channel, text, threadTs) {
+    await this.app.client.chat.postMessage({ channel, text, thread_ts: threadTs });
+  }
+  /**
+   * Best-effort assistant loading status (assistant.threads.setStatus).
+   * Works in channels/DMs/assistant panel under chat:write (post Mar 2026).
+   * Pass status='' to clear. Never throws into dispatch.
+   */
+  async setStatus(channel, threadTs, status, loadingMessages) {
+    try {
+      await this.app.client.assistant.threads.setStatus({
+        channel_id: channel,
+        thread_ts: threadTs,
+        status,
+        ...loadingMessages ? { loading_messages: loadingMessages } : {}
+      });
+    } catch (err) {
+      this.deps.log?.debug(`slack: setStatus failed (ch=${channel} thread=${threadTs}): ${err.message}`);
+    }
+  }
+  async stop() {
+    await this.app.stop();
+  }
+};
+
+// src/slack/render.ts
+var OutputConverger = class {
+  constructor(mode) {
+    this.mode = mode;
+  }
+  mode;
+  buf = "";
+  flush() {
+    if (!this.buf.trim()) {
+      this.buf = "";
+      return [];
+    }
+    const text = this.buf;
+    this.buf = "";
+    return [{ kind: "post", text }];
+  }
+  onUpdate(update) {
+    switch (update.sessionUpdate) {
+      case "agent_message_chunk": {
+        const content = update.content;
+        if (content?.type === "text") this.buf += content.text ?? "";
+        return [];
+      }
+      case "agent_thought_chunk": {
+        if (this.mode === "low") return [...this.flush(), { kind: "set-status", text: "is thinking\u2026" }];
+        if (this.mode !== "high") return [];
+        const content = update.content;
+        return [...this.flush(), { kind: "update-main", text: `_thinking: ${content?.text ?? ""}_` }];
+      }
+      case "tool_call":
+      case "tool_call_update": {
+        const title = update.title ?? update.toolCallId ?? "tool";
+        if (this.mode === "low") return [...this.flush(), { kind: "set-status", text: title }];
+        return [...this.flush(), { kind: "update-main", text: `:hammer_and_wrench: ${title}` }];
+      }
+      case "usage_update":
+        return [];
+      // dropped (goes to telemetry, not the channel)
+      default:
+        return [];
+    }
+  }
+  onFinal(link) {
+    if (this.mode === "low") return [...this.flush(), { kind: "set-status", text: "" }];
+    return [...this.flush(), { kind: "post", text: `:white_check_mark: done \u2014 <${link}|details>` }];
+  }
+};
+
+// src/scheduler/scheduler.ts
+import { Cron } from "croner";
+function buildSyntheticMessage(agentId, cron, traceId) {
+  const msg = {
+    msgId: `cron:${cron.id}:${traceId}`,
+    traceId,
+    source: "cron",
+    platform: "slack",
+    channel: cron.target.channel,
+    thread: `cron:${cron.id}:${traceId}`,
+    // fresh thread per fire
+    sender: { id: `cron:${cron.id}`, isBot: false },
+    text: cron.trigger,
+    mentionedBots: [],
+    isDm: false,
+    trigger: "cron"
+  };
+  return { agentId, msg };
+}
+var Scheduler = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  deps;
+  jobs = [];
+  register(agentId, cron) {
+    this.jobs.push(
+      new Cron(cron.schedule, () => {
+        const { msg } = buildSyntheticMessage(agentId, cron, this.deps.newTraceId());
+        this.deps.onFire(agentId, msg);
+      })
+    );
+  }
+  stop() {
+    for (const j of this.jobs) j.stop();
+    this.jobs = [];
+  }
+};
+
+// src/runtimes/registry.ts
+import { z as z3 } from "zod";
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync3, existsSync as existsSync5, mkdirSync as mkdirSync4 } from "fs";
+import { dirname as dirname4 } from "path";
+var PackageDistSchema = z3.object({ package: z3.string(), args: z3.array(z3.string()).default([]) });
+var BinaryPlatformSchema = z3.object({
+  archive: z3.string().optional(),
+  cmd: z3.string(),
+  args: z3.array(z3.string()).default([]),
+  env: z3.record(z3.string(), z3.string()).default({})
+});
+var DistributionSchema = z3.object({
+  npx: PackageDistSchema.optional(),
+  uvx: PackageDistSchema.optional(),
+  binary: z3.record(z3.string(), BinaryPlatformSchema).optional()
+});
+var RegistryEntrySchema = z3.object({
+  id: z3.string(),
+  name: z3.string().default(""),
+  version: z3.string().default(""),
+  distribution: DistributionSchema
+});
+var RegistryDocSchema = z3.object({ agents: z3.union([z3.array(RegistryEntrySchema), z3.record(z3.string(), RegistryEntrySchema)]) }).transform((d) => ({
+  agents: Array.isArray(d.agents) ? Object.fromEntries(d.agents.map((a) => [a.id, a])) : d.agents
+}));
+function platformKey() {
+  const os = process.platform === "win32" ? "windows" : process.platform === "darwin" ? "darwin" : process.platform === "linux" ? "linux" : null;
+  const arch = process.arch === "arm64" ? "aarch64" : process.arch === "x64" ? "x86_64" : null;
+  if (!os || !arch) return null;
+  return `${os}-${arch}`;
+}
+function toRuntimeDef(entry) {
+  const d = entry.distribution;
+  if (d.npx) return { command: "npx", args: ["-y", d.npx.package, ...d.npx.args], env: [] };
+  if (d.uvx) return { command: "uvx", args: [d.uvx.package, ...d.uvx.args], env: [] };
+  if (d.binary) {
+    const key = platformKey();
+    const bin = key ? d.binary[key] : void 0;
+    if (!bin) return null;
+    return { command: bin.cmd, args: bin.args, env: Object.entries(bin.env).map(([name, value]) => ({ name, value })) };
+  }
+  return null;
+}
+var REGISTRY_URL = "https://cdn.agentclientprotocol.com/registry/v1/latest/registry.json";
+var DEFAULT_TIMEOUT_MS = 4500;
+function readCachedDoc(root) {
+  const file = registryPath(root);
+  if (!existsSync5(file)) return null;
+  try {
+    return RegistryDocSchema.parse(JSON.parse(readFileSync4(file, "utf8")));
+  } catch {
+    return null;
+  }
+}
+function readCacheMeta(root) {
+  const file = registryCachePath(root);
+  if (!existsSync5(file)) return {};
+  try {
+    return JSON.parse(readFileSync4(file, "utf8"));
+  } catch {
+    return {};
+  }
+}
+async function fetchRegistry(root, opts = {}) {
+  const doFetch = opts.fetchImpl ?? fetch;
+  const meta = readCacheMeta(root);
+  const headers = {};
+  if (meta.etag) headers["If-None-Match"] = meta.etag;
+  if (meta.lastModified) headers["If-Modified-Since"] = meta.lastModified;
+  const ac = new AbortController();
+  const timer = setTimeout(() => ac.abort(), opts.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+  try {
+    const res = await doFetch(REGISTRY_URL, { headers, signal: ac.signal });
+    if (res.status === 304) return readCachedDoc(root) ?? { agents: {} };
+    if (!res.ok) return readCachedDoc(root) ?? { agents: {} };
+    const bodyText = await res.text();
+    const doc = RegistryDocSchema.parse(JSON.parse(bodyText));
+    mkdirSync4(dirname4(registryPath(root)), { recursive: true });
+    writeFileSync3(registryPath(root), bodyText);
+    const newMeta = {
+      etag: res.headers.get("etag") ?? void 0,
+      lastModified: res.headers.get("last-modified") ?? void 0,
+      fetchedAt: Date.now()
+    };
+    writeFileSync3(registryCachePath(root), JSON.stringify(newMeta));
+    return doc;
+  } catch {
+    return readCachedDoc(root) ?? { agents: {} };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function defaultRuntimes(root, opts = {}) {
+  const mode = opts.mode ?? "blocking";
+  const cached = mode === "cache-first" ? readCachedDoc(root) : null;
+  let doc;
+  if (cached) {
+    doc = cached;
+    void fetchRegistry(root, opts).catch(() => {
+    });
+  } else {
+    doc = await fetchRegistry(root, opts);
+  }
+  const out = {};
+  for (const [id, entry] of Object.entries(doc.agents)) {
+    const rt = toRuntimeDef(entry);
+    if (rt) out[id] = rt;
+  }
+  return out;
+}
+async function resolveRuntimes(cfg, root, opts = {}) {
+  const userRuntimes = cfg.runtimes ?? {};
+  const needed = opts.neededRuntimes;
+  if (needed && needed.length > 0 && needed.every((n) => userRuntimes[n])) {
+    return { ...userRuntimes };
+  }
+  const defaults = await defaultRuntimes(root, opts);
+  return { ...defaults, ...userRuntimes };
+}
+
+// src/log.ts
+var ORDER = { trace: 10, debug: 20, info: 30, warn: 40, error: 50 };
+function makeLogger(level = "info") {
+  const threshold = ORDER[level] ?? ORDER.info;
+  const emit = (lvl, msg) => {
+    if (ORDER[lvl] < threshold) return;
+    const line = `[agentconnect] ${lvl.toUpperCase().padEnd(5)} ${msg}`;
+    if (ORDER[lvl] >= ORDER.warn) console.error(line);
+    else console.log(line);
+  };
+  return {
+    trace: (m) => emit("trace", m),
+    debug: (m) => emit("debug", m),
+    info: (m) => emit("info", m),
+    warn: (m) => emit("warn", m),
+    error: (m) => emit("error", m)
+  };
+}
+
+// ../protocol/dist/envelope.js
+import { z as z4 } from "zod";
+var Envelope = z4.object({
+  v: z4.literal(1),
+  // protocol major; bump = breaking
+  id: z4.string().uuid(),
+  // unique per frame (sender-generated)
+  ts: z4.string().datetime(),
+  // RFC3339, sender clock (advisory only)
+  type: z4.string(),
+  // frame discriminator, e.g. "register"
+  corr: z4.string().uuid().optional(),
+  // correlation: set on a reply to the request's `id`
+  payload: z4.unknown()
+  // validated by the per-type schema
+});
+var ControlExt = z4.object({
+  epoch: z4.number().int(),
+  // sessionEpoch this frame was issued under (§3.1 fencing)
+  seq: z4.number().int().optional(),
+  // per-agent monotonic, when agent-scoped
+  agentId: z4.string().uuid().optional(),
+  // present iff seq present
+  launchId: z4.string().uuid().optional()
+  // per-launch fence, §4.4
+});
+var NIL_UUID = "00000000-0000-0000-0000-000000000000";
+
+// ../protocol/dist/frames/auth.js
+import { z as z5 } from "zod";
+var AuthReq = z5.object({
+  daemonToken: z5.string(),
+  // short-lived, rotatable daemon credential; its `sub` IS the daemonId
+  // Optional: the token's `sub` is the authoritative daemonId. A daemon MAY echo
+  // it (legacy / explicit), but if present it must equal the token subject.
+  daemonId: z5.string().uuid().optional(),
+  machineId: z5.string().uuid().optional(),
+  // 🅼 machine identity, §3.2
+  attestation: z5.string().optional(),
+  // 🅼 signed proof (JWS), §3.2
+  agentVersion: z5.string(),
+  // daemon build/version
+  resume: z5.object({
+    lastEpoch: z5.number().int(),
+    // sessionEpoch the daemon last held
+    lastRecvSeq: z5.record(z5.string(), z5.number())
+    // per-agent last seq it consumed (§4)
+  }).optional()
+});
+var AuthOk = z5.object({
+  daemonId: z5.string().uuid(),
+  sessionEpoch: z5.number().int(),
+  // monotonic; bumped each successful (re)auth — fencing token
+  heartbeatSec: z5.number().int(),
+  // cadence the daemon must emit heartbeat at
+  serverTime: z5.string().datetime(),
+  resume: z5.object({
+    accepted: z5.boolean(),
+    // false ⇒ daemon must do a full register reconcile
+    redeliverFromSeq: z5.record(z5.string(), z5.number()).optional()
+  }).optional()
+});
+
+// ../protocol/dist/frames/register.js
+import { z as z9 } from "zod";
+
+// ../protocol/dist/frames/route.js
+import { z as z6 } from "zod";
+var Platform = z6.enum(["slack", "telegram"]);
+var SessionKey = z6.object({
+  platform: Platform,
+  channel: z6.string(),
+  thread: z6.string().optional()
+  // absent = channel-root
+});
+var BindRule = z6.object({
+  match: z6.discriminatedUnion("kind", [
+    z6.object({ kind: z6.literal("mention") }),
+    z6.object({ kind: z6.literal("dm") }),
+    z6.object({ kind: z6.literal("keyword"), value: z6.string() }),
+    z6.object({ kind: z6.literal("auto") })
+    // alert-channel auto-handle
+  ])
+});
+var RouteAssign = z6.object({
+  // also appears in RegisterOk.assignments[]
+  sessionKey: SessionKey,
+  agentId: z6.string().uuid(),
+  workspaceId: z6.string().uuid(),
+  // which D9 workspace to prepare
+  bindRules: z6.array(BindRule).default([])
+});
+var RouteAssignAck = z6.object({
+  ok: z6.boolean(),
+  sessionKey: SessionKey,
+  reason: z6.string().optional()
+});
+var RouteUpdate = z6.object({
+  routingEpoch: z6.number().int(),
+  rules: z6.array(z6.object({ match: z6.unknown(), agentId: z6.string().uuid() }))
+});
+var Drain = z6.object({
+  scope: z6.union([
+    z6.object({ kind: z6.literal("agent"), agentId: z6.string().uuid() }),
+    z6.object({ kind: z6.literal("daemon") }),
+    // whole-daemon drain (shutdown/upgrade)
+    z6.object({ kind: z6.literal("session"), sessionKey: SessionKey })
+  ]),
+  deadline: z6.string().datetime()
+  // hard cutoff; in-flight turns past this are cancelled
+});
+var DrainProgress = z6.object({
+  remaining: z6.number().int(),
+  drained: z6.array(SessionKey)
+});
+var DrainDone = z6.object({
+  released: z6.array(SessionKey)
+  // CP may now reassign — fenced by new epoch
+});
+
+// ../protocol/dist/frames/cron.js
+import { z as z7 } from "zod";
+var CronUpsert = z7.object({
+  cronId: z7.string().uuid(),
+  schedule: z7.string(),
+  // croner expression (tz-aware)
+  target: z7.object({ channel: z7.string() }),
+  trigger: z7.string(),
+  // synthetic message text injected into D4 on fire
+  enabled: z7.boolean().default(true)
+});
+var CronRemove = z7.object({
+  cronId: z7.string().uuid()
+});
+
+// ../protocol/dist/frames/secrets.js
+import { z as z8 } from "zod";
+var SecretsRequest = z8.object({
+  // D→C, REQ — daemon asks for a lease at session start
+  scope: z8.object({
+    platform: Platform,
+    workspaceId: z8.string().uuid()
+  })
+});
+var SecretsGrant = z8.object({
+  // C→D, REP (also in RegisterOk.leases[])
+  leaseId: z8.string().uuid(),
+  scope: z8.object({
+    platform: z8.string(),
+    workspaceId: z8.string().uuid()
+  }),
+  ref: z8.string(),
+  // Vault/KMS path or handle — NOT the secret
+  ttl: z8.number().int(),
+  // seconds
+  renewBeforeSec: z8.number().int()
+  // daemon should renew this many sec before expiry
+});
+var SecretsRenew = z8.object({
+  leaseId: z8.string().uuid()
+  // D→C REQ → new SecretsGrant
+});
+var SecretsRevoke = z8.object({
+  leaseId: z8.string().uuid(),
+  reason: z8.string()
+  // C→D EVT (hot revoke)
+});
+var ScopeAttestation = z8.object({
+  machineId: z8.string().uuid(),
+  scope: z8.enum(["attachment.put", "attachment.get", "facts.put"]),
+  resourceRef: z8.string(),
+  // opaque object key/prefix
+  jws: z8.string(),
+  // signed capability the store verifies offline
+  exp: z8.string().datetime()
+});
+
+// ../protocol/dist/frames/register.js
+var RegisterReq = z9.object({
+  host: z9.string(),
+  // hostname (display only)
+  capabilities: z9.object({
+    platforms: z9.array(Platform),
+    // D3 adapters present
+    runtimes: z9.array(z9.string()),
+    // e.g. ["claude","codex"]
+    acp: z9.boolean(),
+    // can this daemon host ACP sessions (D6)?
+    features: z9.array(z9.string()).default([])
+    // e.g. ["cli-wrapper-fallback","worktree-iso"]
+  }),
+  maxAgents: z9.number().int(),
+  // concurrency ceiling for placement (C3)
+  localState: z9.object({
+    // what the daemon currently believes it owns (for reconcile)
+    assignments: z9.array(z9.string()),
+    // sessionKeys it is actively serving
+    crons: z9.array(z9.string()),
+    // cronIds it has scheduled
+    leases: z9.array(z9.string())
+    // leaseIds it holds
+  })
+});
+var RegisterOk = z9.object({
+  routingEpoch: z9.number().int(),
+  // version of the routing table this snapshot reflects
+  // Authoritative reconcile snapshot — daemon converges its local cache to this:
+  assignments: z9.array(RouteAssign),
+  // the route/assign set the daemon SHOULD own
+  crons: z9.array(CronUpsert),
+  // the cron set it SHOULD run
+  leases: z9.array(SecretsGrant),
+  // secret leases it SHOULD hold
+  drop: z9.object({
+    // things in localState the CP says to release
+    assignments: z9.array(z9.string()),
+    crons: z9.array(z9.string())
+  })
+});
+
+// ../protocol/dist/frames/agent.js
+import { z as z10 } from "zod";
+var NormalizedMessageRef = z10.object({
+  sessionKey: SessionKey,
+  platformMsgId: z10.string(),
+  seenUpToSeq: z10.number().int()
+});
+var AgentLaunch = z10.object({
+  // C→D, carries ControlExt(epoch)
+  agentId: z10.string().uuid(),
+  runtime: z10.string(),
+  // must be in RegisterReq.capabilities.runtimes
+  workspaceId: z10.string().uuid(),
+  capabilities: z10.array(z10.string()),
+  // the active-capability pin (§8.1)
+  mode: z10.enum(["long_lived", "per_turn"]).default("long_lived")
+  // 🅰️ decision #2 knob
+});
+var AgentLaunched = z10.object({
+  // D→C, REP/EVT
+  agentId: z10.string().uuid(),
+  launchId: z10.string().uuid(),
+  // new fence value
+  acpSessionId: z10.string().optional(),
+  // 🅰️ present iff long-lived ACP session (default)
+  startedAt: z10.string().datetime(),
+  runtime: z10.string()
+  // e.g. "claude" / "codex"
+});
+var AgentStop = z10.object({
+  agentId: z10.string().uuid(),
+  launchId: z10.string().uuid(),
+  reason: z10.string()
+});
+var AgentPrompt = z10.object({
+  // C→D, carries ControlExt (epoch/seq/agentId/launchId)
+  sessionKey: SessionKey,
+  agentId: z10.string().uuid(),
+  content: NormalizedMessageRef,
+  // a REFERENCE/digest, NOT the body
+  seenUpToSeq: z10.number().int()
+  // freshness watermark, §4.5
+});
+var AgentPromptAck = z10.object({
+  // D→C reply (corr = prompt.id)
+  accepted: z10.boolean(),
+  reason: z10.enum(["queued", "held", "scope_denied", "no_session", "stale"]).optional(),
+  seq: z10.number().int()
+  // echoes the accepted seq
+});
+var AgentActivity = z10.object({
+  // D→C, EVT — activity-probe (§7.4)
+  agentId: z10.string().uuid(),
+  launchId: z10.string().uuid(),
+  state: z10.enum(["thinking", "tool_call", "awaiting_permission", "idle"]),
+  ts: z10.string().datetime()
+});
+var AgentScopeDenied = z10.object({
+  // D→C, EVT — capability-scope audit (§8.1)
+  agentId: z10.string().uuid(),
+  launchId: z10.string().uuid(),
+  capability: z10.string()
+});
+
+// ../protocol/dist/frames/telemetry.js
+import { z as z11 } from "zod";
+var Heartbeat = z11.object({
+  load: z11.object({
+    cpu: z11.number(),
+    mem: z11.number(),
+    agents: z11.number().int()
+  }),
+  health: z11.enum(["ok", "degraded"]),
+  activeSessions: z11.number().int(),
+  degradedScopes: z11.array(z11.string()).default([])
+  // e.g. expired-lease bindings (§6)
+});
+var EventSession = z11.object({
+  sessionId: z11.string().uuid(),
+  agentId: z11.string().uuid(),
+  launchId: z11.string().uuid(),
+  // 🅰️ ties the event to its launch (§4.4)
+  phase: z11.enum(["start", "plan", "problem", "end"]),
+  link: z11.string().optional(),
+  // deep-link to detail view
+  summary: z11.string().optional(),
+  // short, human-facing milestone text
+  ts: z11.string().datetime()
+});
+var FactsRuntimeProfile = z11.object({
+  runtime: z11.string(),
+  // "claude" / "codex" / ...
+  version: z11.string(),
+  models: z11.array(z11.string()),
+  contextWindow: z11.number().int().optional(),
+  acpSupport: z11.enum(["full", "partial", "none"]),
+  // gates the dual-mode decision (#1)
+  toolCalling: z11.boolean()
+});
+var ConfigPush = z11.object({
+  keys: z11.record(z11.string(), z11.unknown())
+});
+var DaemonRestart = z11.object({
+  reason: z11.string(),
+  drainFirst: z11.boolean().default(true)
+});
+var DaemonUpgrade = z11.object({
+  targetVersion: z11.string(),
+  drainFirst: z11.boolean().default(true)
+});
+var DaemonControlAck = z11.object({
+  accepted: z11.boolean(),
+  willDrainUntil: z11.string().datetime().optional()
+});
+var Ack = z11.object({
+  ok: z11.boolean(),
+  reason: z11.string().optional()
+});
+
+// ../protocol/dist/frames/error.js
+import { z as z12 } from "zod";
+var ErrorCode = z12.enum([
+  // protocol / framing
+  "UNKNOWN_FRAME",
+  "FRAME_TOO_LARGE",
+  "PROTOCOL_STATE",
+  "BAD_PAYLOAD",
+  // auth / identity
+  "AUTH_FAILED",
+  "ATTESTATION_INVALID",
+  // fencing / ordering
+  "STALE_EPOCH",
+  "STALE_LAUNCH",
+  "SEQ_GAP",
+  // delivery
+  "NO_SESSION",
+  "HELD",
+  "SCOPE_DENIED",
+  // secrets
+  "LEASE_EXPIRED",
+  "LEASE_DENIED",
+  // generic
+  "RATE_LIMITED",
+  "INTERNAL"
+]);
+var ErrorFrame = z12.object({
+  code: ErrorCode,
+  message: z12.string(),
+  // human-readable, redacted of secrets
+  retryable: z12.boolean(),
+  details: z12.record(z12.string(), z12.unknown()).optional()
+  // e.g. {expected: <seq>} for SEQ_GAP
+});
+
+// ../protocol/dist/frame.js
+import { z as z13 } from "zod";
+var FRAME_SCHEMAS = {
+  // ── auth / identity ──
+  auth: AuthReq,
+  "auth/ok": AuthOk,
+  // ── register / reconcile ──
+  register: RegisterReq,
+  "register/ok": RegisterOk,
+  // ── telemetry ──
+  heartbeat: Heartbeat,
+  // ── agent lifecycle / delivery ──
+  "agent/launch": AgentLaunch,
+  "agent/launched": AgentLaunched,
+  "agent/stop": AgentStop,
+  "agent/prompt": AgentPrompt,
+  "agent/prompt/ack": AgentPromptAck,
+  "agent/activity": AgentActivity,
+  "agent/scope-denied": AgentScopeDenied,
+  // ── routing / orchestration ──
+  "route/assign": RouteAssign,
+  "route/assign/ack": RouteAssignAck,
+  "route/update": RouteUpdate,
+  "daemon/drain": Drain,
+  "drain/progress": DrainProgress,
+  "drain/done": DrainDone,
+  // ── cron ──
+  "cron/upsert": CronUpsert,
+  "cron/remove": CronRemove,
+  // ── secrets ──
+  "secrets/request": SecretsRequest,
+  "secrets/grant": SecretsGrant,
+  "secrets/renew": SecretsRenew,
+  "secrets/revoke": SecretsRevoke,
+  "scope-attestation": ScopeAttestation,
+  // ── dashboard / facts ──
+  "event/session": EventSession,
+  "facts/runtime-profile": FactsRuntimeProfile,
+  // ── fleet / config ──
+  "config/push": ConfigPush,
+  "daemon/restart": DaemonRestart,
+  "daemon/upgrade": DaemonUpgrade,
+  // ── generic replies ──
+  "daemon/control/ack": DaemonControlAck,
+  ack: Ack,
+  // ── error ──
+  error: ErrorFrame
+};
+var FRAME_TYPES = Object.keys(FRAME_SCHEMAS);
+function frame(type, payload) {
+  return z13.object({
+    v: z13.literal(1),
+    id: z13.string().uuid(),
+    ts: z13.string().datetime(),
+    type: z13.literal(type),
+    corr: z13.string().uuid().optional(),
+    payload
+  });
+}
+var AnyFrame = z13.discriminatedUnion("type", [
+  frame("auth", FRAME_SCHEMAS["auth"]),
+  frame("auth/ok", FRAME_SCHEMAS["auth/ok"]),
+  frame("register", FRAME_SCHEMAS["register"]),
+  frame("register/ok", FRAME_SCHEMAS["register/ok"]),
+  frame("heartbeat", FRAME_SCHEMAS["heartbeat"]),
+  frame("agent/launch", FRAME_SCHEMAS["agent/launch"]),
+  frame("agent/launched", FRAME_SCHEMAS["agent/launched"]),
+  frame("agent/stop", FRAME_SCHEMAS["agent/stop"]),
+  frame("agent/prompt", FRAME_SCHEMAS["agent/prompt"]),
+  frame("agent/prompt/ack", FRAME_SCHEMAS["agent/prompt/ack"]),
+  frame("agent/activity", FRAME_SCHEMAS["agent/activity"]),
+  frame("agent/scope-denied", FRAME_SCHEMAS["agent/scope-denied"]),
+  frame("route/assign", FRAME_SCHEMAS["route/assign"]),
+  frame("route/assign/ack", FRAME_SCHEMAS["route/assign/ack"]),
+  frame("route/update", FRAME_SCHEMAS["route/update"]),
+  frame("daemon/drain", FRAME_SCHEMAS["daemon/drain"]),
+  frame("drain/progress", FRAME_SCHEMAS["drain/progress"]),
+  frame("drain/done", FRAME_SCHEMAS["drain/done"]),
+  frame("cron/upsert", FRAME_SCHEMAS["cron/upsert"]),
+  frame("cron/remove", FRAME_SCHEMAS["cron/remove"]),
+  frame("secrets/request", FRAME_SCHEMAS["secrets/request"]),
+  frame("secrets/grant", FRAME_SCHEMAS["secrets/grant"]),
+  frame("secrets/renew", FRAME_SCHEMAS["secrets/renew"]),
+  frame("secrets/revoke", FRAME_SCHEMAS["secrets/revoke"]),
+  frame("scope-attestation", FRAME_SCHEMAS["scope-attestation"]),
+  frame("event/session", FRAME_SCHEMAS["event/session"]),
+  frame("facts/runtime-profile", FRAME_SCHEMAS["facts/runtime-profile"]),
+  frame("config/push", FRAME_SCHEMAS["config/push"]),
+  frame("daemon/restart", FRAME_SCHEMAS["daemon/restart"]),
+  frame("daemon/upgrade", FRAME_SCHEMAS["daemon/upgrade"]),
+  frame("daemon/control/ack", FRAME_SCHEMAS["daemon/control/ack"]),
+  frame("ack", FRAME_SCHEMAS["ack"]),
+  frame("error", FRAME_SCHEMAS["error"])
+]);
+
+// ../protocol/dist/codec.js
+import { randomUUID } from "crypto";
+var MAX_FRAME_BYTES = 256 * 1024;
+var textEncoder = new TextEncoder();
+function byteLength(text) {
+  return textEncoder.encode(text).length;
+}
+function extractControlExt(json) {
+  if (typeof json !== "object" || json === null)
+    return void 0;
+  const o = json;
+  const ext = {};
+  if (typeof o.epoch === "number")
+    ext.epoch = o.epoch;
+  if (typeof o.seq === "number")
+    ext.seq = o.seq;
+  if (typeof o.agentId === "string")
+    ext.agentId = o.agentId;
+  if (typeof o.launchId === "string")
+    ext.launchId = o.launchId;
+  return Object.keys(ext).length > 0 ? ext : void 0;
+}
+function decodeEnvelope(text) {
+  if (byteLength(text) > MAX_FRAME_BYTES) {
+    return { ok: false, id: NIL_UUID, msg: "FRAME_TOO_LARGE" };
+  }
+  let json;
+  try {
+    json = JSON.parse(text);
+  } catch {
+    return { ok: false, id: NIL_UUID, msg: "invalid json" };
+  }
+  const env = Envelope.safeParse(json);
+  if (!env.success) {
+    const id = typeof json === "object" && json !== null && typeof json.id === "string" ? json.id : NIL_UUID;
+    return { ok: false, id, msg: env.error.message };
+  }
+  const schema = FRAME_SCHEMAS[env.data.type];
+  if (!schema) {
+    return { ok: false, id: env.data.id, msg: "UNKNOWN_FRAME" };
+  }
+  const payload = schema.safeParse(env.data.payload);
+  if (!payload.success) {
+    return { ok: false, id: env.data.id, msg: payload.error.message };
+  }
+  const ext = extractControlExt(json);
+  return {
+    ok: true,
+    frame: { ...env.data, payload: payload.data },
+    ...ext ? { ext } : {}
+  };
+}
+function buildEnvelope(type, payload, opts = {}) {
+  const base = {
+    v: 1,
+    id: opts.id ?? randomUUID(),
+    ts: opts.ts ?? (/* @__PURE__ */ new Date()).toISOString(),
+    type,
+    payload,
+    ...opts.corr ? { corr: opts.corr } : {},
+    ...opts.ext ?? {}
+  };
+  return base;
+}
+function encode(frame2) {
+  return JSON.stringify(frame2);
+}
+
+// src/cp/correlator.ts
+var WireError = class extends Error {
+  code;
+  retryable;
+  details;
+  constructor(code, message, retryable = false, details) {
+    super(message);
+    this.name = "WireError";
+    this.code = code;
+    this.retryable = retryable;
+    if (details) this.details = details;
+  }
+};
+var ReqRep = class {
+  constructor(clock, ackTimeoutMs, maxTries = 5) {
+    this.clock = clock;
+    this.ackTimeoutMs = ackTimeoutMs;
+    this.maxTries = maxTries;
+  }
+  clock;
+  ackTimeoutMs;
+  maxTries;
+  pending = /* @__PURE__ */ new Map();
+  request(frame2, write) {
+    const encoded = JSON.stringify(frame2);
+    return new Promise((resolve3, reject) => {
+      const entry = { id: frame2.id, encoded, resolve: resolve3, reject, tries: 1 };
+      this.pending.set(frame2.id, entry);
+      this.arm(entry, write);
+      write(encoded);
+    });
+  }
+  arm(entry, write) {
+    entry.timer = this.clock.setTimeout(() => {
+      if (!this.pending.has(entry.id)) return;
+      if (entry.tries >= this.maxTries) {
+        this.pending.delete(entry.id);
+        entry.reject(new WireError("INTERNAL", `no ack after ${this.maxTries} tries for ${entry.id}`, true));
+        return;
+      }
+      entry.tries += 1;
+      this.arm(entry, write);
+      write(entry.encoded);
+    }, this.ackTimeoutMs);
+  }
+  settle(frame2) {
+    const corr = frame2.corr;
+    if (!corr) return false;
+    const entry = this.pending.get(corr);
+    if (!entry) return false;
+    this.pending.delete(corr);
+    if (entry.timer !== void 0) this.clock.clearTimeout(entry.timer);
+    if (frame2.type === "error") {
+      const e = frame2.payload;
+      entry.reject(new WireError(e.code, e.message, e.retryable, e.details));
+    } else {
+      entry.resolve(frame2);
+    }
+    return true;
+  }
+  inflight() {
+    return this.pending.size;
+  }
+  rejectAll(err) {
+    for (const entry of this.pending.values()) {
+      if (entry.timer !== void 0) this.clock.clearTimeout(entry.timer);
+      entry.reject(err);
+    }
+    this.pending.clear();
+  }
+};
+
+// src/cp/client.ts
+var ACK_TIMEOUT_MS = 5e3;
+var BACKOFF_BASE_MS = 1e3;
+var BACKOFF_CAP_MS = 3e4;
+var CpClient = class {
+  constructor(deps) {
+    this.deps = deps;
+    this.correlator = new ReqRep(deps.clock, ACK_TIMEOUT_MS);
+  }
+  deps;
+  state = "CLOSED";
+  sessionEpoch = 0;
+  routingEpoch = 0;
+  transport;
+  correlator;
+  stopped = false;
+  fatal = false;
+  // 4401 — never auto-retry
+  attempt = 0;
+  reconnectTimer;
+  lastAuthedEpoch = 0;
+  // for resume on reconnect (per-agent seq tail is out of scope)
+  heartbeatTimer;
+  heartbeatMs = 0;
+  /** Non-blocking: kicks off the connect loop and returns. */
+  start() {
+    this.stopped = false;
+    this.fatal = false;
+    void this.attemptConnect();
+  }
+  async stop() {
+    this.stopped = true;
+    if (this.reconnectTimer !== void 0) {
+      this.deps.clock.clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = void 0;
+    }
+    this.stopHeartbeat();
+    this.correlator.rejectAll(new Error("stopping"));
+    this.transport?.close(1e3, "shutdown");
+    this.state = "CLOSED";
+  }
+  async attemptConnect() {
+    if (this.stopped || this.fatal) return;
+    this.state = "CONNECTING";
+    try {
+      const t = await this.deps.connect();
+      this.transport = t;
+      t.onMessage((txt) => void this.onText(txt));
+      t.onClose((c, r) => this.onClose(c, r));
+      await this.handshake();
+      this.attempt = 0;
+    } catch (err) {
+      this.deps.log.warn(`cp: connect/handshake failed: ${err.message}`);
+      this.transport?.close(1011, "handshake failed");
+      this.transport = void 0;
+      this.scheduleReconnect();
+    }
+  }
+  scheduleReconnect() {
+    if (this.stopped || this.fatal) return;
+    if (this.reconnectTimer !== void 0) return;
+    const jitter = this.deps.jitter ?? Math.random;
+    const base = Math.min(BACKOFF_CAP_MS, BACKOFF_BASE_MS * 2 ** this.attempt);
+    const delay = base + Math.floor(jitter() * base);
+    this.attempt += 1;
+    this.reconnectTimer = this.deps.clock.setTimeout(() => {
+      this.reconnectTimer = void 0;
+      void this.attemptConnect();
+    }, delay);
+  }
+  async handshake() {
+    this.state = "AUTHENTICATING";
+    const authPayload = {
+      daemonToken: this.deps.token,
+      agentVersion: this.deps.agentVersion
+    };
+    if (this.deps.daemonId) {
+      authPayload.daemonId = this.deps.daemonId;
+    }
+    if (this.lastAuthedEpoch > 0) {
+      authPayload.resume = { lastEpoch: this.lastAuthedEpoch, lastRecvSeq: {} };
+    }
+    const authOk = await this.request("auth", authPayload);
+    const ok = authOk.payload;
+    this.sessionEpoch = ok.sessionEpoch;
+    this.lastAuthedEpoch = ok.sessionEpoch;
+    if (ok.daemonId && ok.daemonId !== this.deps.daemonId) {
+      this.deps.daemonId = ok.daemonId;
+      this.deps.onDaemonId?.(ok.daemonId);
+    }
+    this.state = "REGISTERING";
+    const regOk = await this.request("register", {
+      host: this.deps.host,
+      capabilities: this.deps.capabilities(),
+      maxAgents: this.deps.maxAgents,
+      localState: this.deps.localState()
+    });
+    const snap = regOk.payload;
+    this.routingEpoch = snap.routingEpoch;
+    this.deps.configApply.applyReconcileSnapshot(snap);
+    this.state = "READY";
+    this.heartbeatMs = ok.heartbeatSec > 0 ? ok.heartbeatSec * 1e3 : this.deps.heartbeatDefaultMs;
+    this.armHeartbeat();
+    this.deps.log.info(`cp: READY (epoch=${this.sessionEpoch}, routingEpoch=${this.routingEpoch})`);
+  }
+  request(type, payload) {
+    const frame2 = buildEnvelope(type, payload);
+    return this.correlator.request(frame2, (e) => this.transport.send(e));
+  }
+  async onText(text) {
+    const decoded = decodeEnvelope(text);
+    if (!decoded.ok) {
+      this.sendError(decoded.id, this.decodeErrorCode(decoded.msg), decoded.msg, false);
+      return;
+    }
+    const frame2 = decoded.frame;
+    if (frame2.corr && this.correlator.settle(frame2)) return;
+    if (this.state !== "READY" && this.state !== "DRAINING") {
+      this.sendError(frame2.id, "PROTOCOL_STATE", `${frame2.type} illegal in ${this.state}`, false);
+      return;
+    }
+    if (decoded.ext?.epoch !== void 0 && decoded.ext.epoch < this.sessionEpoch) {
+      this.sendError(frame2.id, "STALE_EPOCH", "epoch < current", true);
+      return;
+    }
+    this.dispatchControl(frame2);
+  }
+  decodeErrorCode(msg) {
+    if (msg === "FRAME_TOO_LARGE") return "FRAME_TOO_LARGE";
+    if (msg === "UNKNOWN_FRAME") return "UNKNOWN_FRAME";
+    return "BAD_PAYLOAD";
+  }
+  sendError(corr, code, message, retryable) {
+    if (!this.transport) return;
+    this.transport.send(encode(buildEnvelope("error", { code, message, retryable }, { corr })));
+  }
+  onClose(code, _reason) {
+    this.stopHeartbeat();
+    this.correlator.rejectAll(new WireError("INTERNAL", "connection closed", true));
+    if (code === 4401) {
+      this.fatal = true;
+      this.state = "CLOSED";
+      this.deps.log.error("cp: AUTH_FAILED (4401) \u2014 not reconnecting; re-mint the daemon token");
+      return;
+    }
+    if (this.stopped) {
+      this.state = "CLOSED";
+      return;
+    }
+    this.state = "DEGRADED";
+    this.scheduleReconnect();
+  }
+  armHeartbeat() {
+    this.heartbeatTimer = this.deps.clock.setTimeout(() => {
+      if (this.state !== "READY") return;
+      this.transport?.send(
+        encode(
+          buildEnvelope("heartbeat", {
+            load: this.deps.loadSnapshot(),
+            health: "ok",
+            activeSessions: this.deps.activeSessions(),
+            degradedScopes: this.deps.degradedScopes?.() ?? []
+          })
+        )
+      );
+      this.armHeartbeat();
+    }, this.heartbeatMs);
+  }
+  stopHeartbeat() {
+    if (this.heartbeatTimer !== void 0) {
+      this.deps.clock.clearTimeout(this.heartbeatTimer);
+      this.heartbeatTimer = void 0;
+    }
+  }
+  /** C→D control dispatch. The CP changes config, never live routing. */
+  dispatchControl(frame2) {
+    switch (frame2.type) {
+      case "config/push":
+        this.deps.configApply.applyConfigPush(frame2.payload.keys);
+        return;
+      // EVT — no reply
+      case "cron/upsert":
+        try {
+          this.deps.configApply.upsertCron(frame2.payload);
+          this.reply(frame2, "ack", { ok: true });
+        } catch (err) {
+          this.sendError(frame2.id, "BAD_PAYLOAD", `cron upsert failed: ${err.message}`, false);
+        }
+        return;
+      case "cron/remove":
+        this.deps.configApply.removeCron(frame2.payload.cronId);
+        this.reply(frame2, "ack", { ok: true });
+        return;
+      case "route/assign": {
+        const a = frame2.payload;
+        this.deps.configApply.applyRouteAssign(a);
+        this.reply(frame2, "route/assign/ack", { ok: true, sessionKey: a.sessionKey });
+        return;
+      }
+      case "route/update":
+        this.deps.configApply.applyRouteUpdate(frame2.payload);
+        return;
+      // EVT — no reply
+      // ── unimplemented this slice ──
+      case "agent/launch":
+      case "agent/stop":
+      case "agent/prompt":
+      case "daemon/drain":
+      case "daemon/restart":
+      case "daemon/upgrade":
+        this.sendError(frame2.id, "INTERNAL", `${frame2.type} not implemented`, false);
+        return;
+      default:
+        this.deps.log.debug(`cp: ignoring ${frame2.type}`);
+        return;
+    }
+  }
+  reply(req, type, payload) {
+    this.transport?.send(encode(buildEnvelope(type, payload, { corr: req.id })));
+  }
+};
+
+// src/cp/transport.ts
+import WebSocket from "ws";
+var SUBPROTOCOL = "agentconnect.v1";
+var DEFAULT_WS_PATH = "/daemon/ws";
+var ClientTransport = class _ClientTransport {
+  constructor(ws) {
+    this.ws = ws;
+  }
+  ws;
+  get subprotocol() {
+    return this.ws.protocol;
+  }
+  /**
+   * Dial `wss://<host>/daemon/ws` with the `agentconnect.v1` subprotocol.
+   * Resolves once the socket is open; rejects on any error before open
+   * (refused, bad handshake/subprotocol → HTTP 400).
+   */
+  static dial(url) {
+    const wsUrl = url.endsWith(DEFAULT_WS_PATH) ? url : url.replace(/\/+$/, "") + DEFAULT_WS_PATH;
+    return new Promise((resolve3, reject) => {
+      const ws = new WebSocket(wsUrl, [SUBPROTOCOL], { maxPayload: MAX_FRAME_BYTES });
+      const onPreOpenError = (err) => {
+        ws.removeAllListeners();
+        reject(err);
+      };
+      ws.once("error", onPreOpenError);
+      ws.once("open", () => {
+        ws.removeListener("error", onPreOpenError);
+        resolve3(new _ClientTransport(ws));
+      });
+    });
+  }
+  send(text) {
+    this.ws.send(text);
+  }
+  onMessage(cb) {
+    this.ws.on("message", (data, isBinary) => {
+      if (isBinary) return;
+      cb(typeof data === "string" ? data : String(data));
+    });
+  }
+  onClose(cb) {
+    this.ws.on("close", (code, reason) => cb(code, reason.toString()));
+  }
+  close(code, reason) {
+    this.ws.close(code, reason);
+  }
+};
+
+// src/cp/cp-cron.ts
+import { Cron as Cron2 } from "croner";
+var CpCronRegistry = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  deps;
+  jobs = /* @__PURE__ */ new Map();
+  upsert(cron) {
+    this.remove(cron.cronId);
+    if (cron.enabled === false) return;
+    this.jobs.set(cron.cronId, new Cron2(cron.schedule, () => this.deps.onFire(cron)));
+  }
+  remove(cronId) {
+    this.jobs.get(cronId)?.stop();
+    this.jobs.delete(cronId);
+  }
+  converge(crons) {
+    const keep = new Set(crons.map((c) => c.cronId));
+    for (const id of [...this.jobs.keys()]) if (!keep.has(id)) this.remove(id);
+    for (const c of crons) this.upsert(c);
+  }
+  ids() {
+    return [...this.jobs.keys()];
+  }
+  stop() {
+    for (const id of [...this.jobs.keys()]) this.remove(id);
+  }
+};
+
+// src/cp/config-apply.ts
+var LOG_LEVELS = /* @__PURE__ */ new Set(["trace", "debug", "info", "warn", "error"]);
+function mergeConfigPush(cfg, keys) {
+  const applied = [];
+  const ignored = [];
+  for (const [key, value] of Object.entries(keys)) {
+    let ok = false;
+    switch (key) {
+      case "logging.level":
+        if (typeof value === "string" && LOG_LEVELS.has(value)) {
+          cfg.logging.level = value;
+          ok = true;
+        }
+        break;
+      case "limits.maxAgents":
+        if (typeof value === "number" && Number.isInteger(value)) {
+          cfg.limits.maxAgents = value;
+          ok = true;
+        }
+        break;
+      case "limits.maxConcurrentSessions":
+        if (typeof value === "number" && Number.isInteger(value)) {
+          cfg.limits.maxConcurrentSessions = value;
+          ok = true;
+        }
+        break;
+      case "limits.agentIdleTimeoutMs":
+        if (typeof value === "number" && Number.isInteger(value)) {
+          cfg.limits.agentIdleTimeoutMs = value;
+          ok = true;
+        }
+        break;
+      default:
+        ok = false;
+    }
+    ;
+    (ok ? applied : ignored).push(key);
+  }
+  return { applied, ignored };
+}
+
+// src/cp/clock.ts
+var SystemClock = class {
+  now() {
+    return Date.now();
+  }
+  setTimeout(fn, ms) {
+    return globalThis.setTimeout(fn, ms);
+  }
+  clearTimeout(h) {
+    globalThis.clearTimeout(h);
+  }
+};
+var systemClock = new SystemClock();
+
+// src/daemon.ts
+var LOADING_MSGS = ["Working on it\u2026", "Crunching through it\u2026", "Hang tight\u2026"];
+var Daemon = class {
+  constructor(opts = {}) {
+    this.opts = opts;
+  }
+  opts;
+  store;
+  agents = /* @__PURE__ */ new Map();
+  hosts = /* @__PURE__ */ new Map();
+  connections = [];
+  scheduler;
+  sessions;
+  // integrationId -> the SlackConnection that owns it (for replies)
+  connByIntegration = /* @__PURE__ */ new Map();
+  hostStarts = /* @__PURE__ */ new Map();
+  watcher;
+  debounceTimer;
+  agentsDir = "";
+  cfg;
+  log = makeLogger("info");
+  root = "";
+  runtimes = {};
+  cpClient;
+  cpCrons;
+  botUserIds = {};
+  cpRouting;
+  async start() {
+    const root = resolveRoot(this.opts.root);
+    const cfg = loadConfig({ root, overrides: this.opts.overrides, optional: !!this.opts.agentName, autoCreate: true });
+    this.cfg = cfg;
+    const cpTokenOnboarding = !!(cfg.controlPlane?.enabled && cfg.controlPlane.token);
+    if (!cfg.daemonId && !cpTokenOnboarding) {
+      cfg.daemonId = randomUUID2();
+      persistDaemonId(root, cfg.daemonId);
+    }
+    this.log = makeLogger(cfg.logging.level);
+    this.log.info(`starting daemon (root=${root})`);
+    this.log.info(
+      `control plane: ${cfg.controlPlane?.enabled ? `enabled (${cfg.controlPlane.url ?? "no url"})` : "disabled \u2014 running local"}`
+    );
+    this.agentsDir = cfg.agentsDir;
+    const agents = this.loadAgentList();
+    for (const a of agents) this.agents.set(a.id, a);
+    this.log.info(
+      `loaded ${agents.length} agent(s) from ${this.agentsDir}${agents.length ? `: ${agents.map((a) => a.id).join(", ")}` : ""}`
+    );
+    this.root = root;
+    this.runtimes = await resolveRuntimes(cfg, root, {
+      neededRuntimes: agents.map((a) => a.runtime),
+      mode: "cache-first"
+    });
+    this.log.info(`runtimes ready: ${Object.keys(this.runtimes).join(", ") || "(none)"}`);
+    this.store = new LocalStore(statePath(root));
+    this.cpRouting = new CpRoutingLayer({
+      load: () => {
+        const row = this.store.getCpRouting();
+        return row ? {
+          routingEpoch: row.routingEpoch,
+          assignments: JSON.parse(row.assignments),
+          globalRules: JSON.parse(row.globalRules)
+        } : void 0;
+      },
+      save: (s) => this.store.setCpRouting(s.routingEpoch, JSON.stringify(s.assignments), JSON.stringify(s.globalRules))
+    });
+    this.sessions = new SessionManager({
+      store: this.store,
+      // Must hand back a *started* host: handle() calls host.newSession() immediately,
+      // which needs the ACP connection that start() establishes.
+      hostFor: (agentId) => this.ensureHostAsync(agentId),
+      agentById: (id) => this.agents.get(id)
+    });
+    this.scheduler = new Scheduler({
+      onFire: (agentId, msg) => void this.dispatch(agentId, msg).catch(
+        (err) => this.log.error(`cron dispatch failed for agent "${agentId}": ${err.stack ?? err}`)
+      ),
+      newTraceId: () => randomUUID2()
+    });
+    const groups = consolidate(agents);
+    this.botUserIds = {};
+    if (groups.size === 0) this.log.info("slack: no slack integrations configured");
+    else this.log.info(`slack: opening ${groups.size} socket connection(s)`);
+    for (const group of groups.values()) {
+      const conn = new SlackConnection({
+        group,
+        newTraceId: () => randomUUID2(),
+        onMessage: (msg) => this.onInbound(msg),
+        log: this.log,
+        boltDebug: cfg.logging.level === "debug" || cfg.logging.level === "trace"
+      });
+      this.log.info(
+        `slack: connecting (${group.integrations.length} integration(s): ${group.integrations.map((i) => i.agentId).join(", ")})\u2026`
+      );
+      await conn.start();
+      this.log.info(`slack: socket connected as bot user ${conn.botUserId}`);
+      for (const { integrationId } of group.integrations) {
+        this.botUserIds[integrationId] = conn.botUserId;
+        this.connByIntegration.set(integrationId, conn);
+      }
+      this.connections.push(conn);
+    }
+    let cronCount = 0;
+    for (const a of agents)
+      for (const c of a.crons) {
+        this.scheduler.register(a.id, c);
+        cronCount++;
+      }
+    if (cronCount) this.log.info(`registered ${cronCount} cron(s)`);
+    this.watcher = chokidar.watch(this.agentsDir, {
+      ignoreInitial: true,
+      depth: 4,
+      ignored: (p) => /[\\/](node_modules|\.git)([\\/]|$)/.test(p)
+    });
+    const debounced = () => {
+      clearTimeout(this.debounceTimer);
+      this.debounceTimer = setTimeout(() => {
+        void this.reconcile().catch((err) => console.error("agentconnect: reconcile failed:", err));
+      }, 300);
+    };
+    this.watcher.on("add", debounced).on("change", debounced).on("unlink", debounced);
+    this.log.info(`watching ${this.agentsDir} for agent changes`);
+    this.startCpClient(root);
+    this.log.info("daemon ready");
+  }
+  // Multi-agent: all active agents under agentsDir. Single-agent (--agent): just
+  // the selected agent, regardless of status.
+  loadAgentList() {
+    return this.opts.agentName ? [selectAgent(this.agentsDir, this.opts.agentName)] : loadAgents(this.agentsDir);
+  }
+  async reconcile() {
+    const desired = this.loadAgentList();
+    const { toStart, toStop } = diffAgents(desired, [...this.agents.keys()]);
+    for (const id of toStop) {
+      const host = this.hosts.get(id);
+      if (host) {
+        await host.stop();
+        this.hosts.delete(id);
+      }
+      this.hostStarts.delete(id);
+      this.agents.delete(id);
+    }
+    for (const a of toStart) this.agents.set(a.id, a);
+  }
+  ensureHost(agentId, cfg) {
+    let host = this.hosts.get(agentId);
+    if (host) return host;
+    const agent2 = this.agents.get(agentId);
+    const onUpdate = (sid, u) => this.onAcpUpdate(agentId, sid, u);
+    if (this.opts.hostFactory) {
+      host = this.opts.hostFactory(agent2, onUpdate);
+    } else {
+      const runtime = this.runtimes[agent2.runtime];
+      if (!runtime) throw new Error(`runtime "${agent2.runtime}" not in config.runtimes or ACP registry`);
+      host = new AcpHost(runtime, { onUpdate, env: agentChildEnv(agent2) });
+    }
+    this.hosts.set(agentId, host);
+    return host;
+  }
+  // route an inbound Slack message
+  seenMsgIds = /* @__PURE__ */ new Set();
+  onInbound(msg) {
+    if (this.seenMsgIds.has(msg.msgId)) {
+      this.log.debug(`routing: duplicate ${msg.msgId} ignored`);
+      return;
+    }
+    this.seenMsgIds.add(msg.msgId);
+    if (this.seenMsgIds.size > 2e3) this.seenMsgIds.clear();
+    const result = routeRules(msg, this.mergedRules(), (c, t) => this.sessions.threadOwner(c, t));
+    if (!result) {
+      this.log.debug(
+        `routing: dropped message in ch=${msg.channel} (no agent matched \u2014 not a mention of a known bot, not a subscribed 'all' channel, not a thread/DM hit)`
+      );
+      return;
+    }
+    this.log.info(`routing: ch=${msg.channel} \u2192 agent "${result.agentId}" (integration ${result.integrationId})`);
+    void this.dispatch(result.agentId, msg, result.integrationId).catch(
+      (err) => this.log.error(`dispatch failed for agent "${result.agentId}": ${err.stack ?? err}`)
+    );
+  }
+  /** Local layer (agent.json) ∪ resolved CP layer; unservable CP rules are dropped + warn-logged. */
+  mergedRules() {
+    const local = [...this.agents.values()].flatMap((a) => rulesFromAgent(a, this.botUserIds));
+    const cp = [];
+    for (const cpRule of this.cpRouting?.effectiveRules() ?? []) {
+      const resolved = resolveCpRule(cpRule, (agentId) => this.resolveCpAgent(agentId));
+      if (resolved) cp.push(resolved);
+      else this.log.warn(`cp: routing rule for unknown/Slack-less agent "${cpRule.agentId}" skipped (degraded)`);
+    }
+    return [...local, ...cp];
+  }
+  /** Resolve a CP agentId (== local agent.id) to its Slack integration; null if unservable. */
+  resolveCpAgent(agentId) {
+    return resolveAgentIntegration(this.agents.get(agentId), this.botUserIds);
+  }
+  /** agentIds of CP rules that currently resolve to null (no servable Slack integration). */
+  cpDegradedScopes() {
+    const out = /* @__PURE__ */ new Set();
+    for (const cpRule of this.cpRouting?.effectiveRules() ?? []) {
+      if (!this.resolveCpAgent(cpRule.agentId)) out.add(cpRule.agentId);
+    }
+    return [...out];
+  }
+  // shared dispatch for user + cron messages
+  async dispatch(agentId, msg, integrationId) {
+    const agent2 = this.agents.get(agentId);
+    const conv = new OutputConverger(agent2.output.mode);
+    const replyConn = this.replyConnFor(agentId, integrationId);
+    const wasRunning = this.hostStarts.has(agentId);
+    const statusThread = msg.thread ?? msg.msgId;
+    void replyConn?.setStatus(msg.channel, statusThread, wasRunning ? "is thinking\u2026" : "is starting up\u2026", LOADING_MSGS);
+    const { sessionId, blocks } = await this.sessions.handle(agentId, msg);
+    this.pending.set(sessionId, { conv, channel: msg.channel, thread: msg.thread, conn: replyConn });
+    try {
+      const host = await this.ensureHostAsync(agentId);
+      if (!wasRunning) void replyConn?.setStatus(msg.channel, statusThread, "is thinking\u2026", LOADING_MSGS);
+      await host.prompt(sessionId, blocks);
+      for (const action of conv.onFinal(`local://session/${sessionId}`)) {
+        await this.applyAction(action, replyConn, msg.channel, statusThread);
+      }
+    } finally {
+      this.pending.delete(sessionId);
+    }
+  }
+  /** Route a converger action: set-status → setStatus (loading_messages only when not clearing); else postMessage. */
+  async applyAction(action, conn, channel, thread) {
+    if (action.kind === "set-status") {
+      if (conn && thread) await conn.setStatus(channel, thread, action.text, action.text ? LOADING_MSGS : void 0);
+      return;
+    }
+    await conn?.postMessage(channel, action.text, thread);
+  }
+  pending = /* @__PURE__ */ new Map();
+  onAcpUpdate(_agentId, sessionId, update) {
+    const p = this.pending.get(sessionId);
+    if (!p) return;
+    for (const action of p.conv.onUpdate(update)) {
+      void this.applyAction(action, p.conn, p.channel, p.thread).catch(
+        (err) => console.error("slack post failed:", err)
+      );
+    }
+  }
+  async ensureHostAsync(agentId) {
+    const host = this.ensureHost(agentId, this.cfg);
+    let p = this.hostStarts.get(agentId);
+    if (!p) {
+      p = host.start();
+      this.hostStarts.set(agentId, p);
+    }
+    await p;
+    return host;
+  }
+  replyConnFor(agentId, integrationId) {
+    const intId = integrationId ?? this.agents.get(agentId)?.integrations[0]?.id;
+    return intId ? this.connByIntegration.get(intId) : void 0;
+  }
+  // ── ConfigApply seam (CP changes config, never live routing) ──
+  cpConfigApply() {
+    return {
+      applyConfigPush: (keys) => {
+        const { applied, ignored } = mergeConfigPush(this.cfg, keys);
+        if (applied.includes("logging.level")) this.log = makeLogger(this.cfg.logging.level);
+        if (applied.length) this.log.info(`cp: applied config keys: ${applied.join(", ")}`);
+        if (ignored.length) this.log.warn(`cp: ignored config keys: ${ignored.join(", ")}`);
+      },
+      applyReconcileSnapshot: (snap) => {
+        this.cpCrons?.converge(snap.crons);
+        this.cpRouting?.converge({
+          routingEpoch: snap.routingEpoch,
+          assignments: snap.assignments,
+          drop: { assignments: snap.drop.assignments }
+        });
+        if (snap.leases.length) this.log.debug(`cp: ${snap.leases.length} lease(s) noted (secrets handled later)`);
+        if (snap.assignments.length) this.log.debug(`cp: converged ${snap.assignments.length} assignment(s)`);
+      },
+      upsertCron: (cron) => this.cpCrons.upsert(cron),
+      removeCron: (cronId) => this.cpCrons.remove(cronId),
+      applyRouteAssign: (a) => this.cpRouting?.upsertAssign(a),
+      applyRouteUpdate: (u) => this.cpRouting?.applyUpdate(u)
+    };
+  }
+  /** A CP cron fired: build a synthetic message and run it through the normal routing path. */
+  onCpCronFire(cron) {
+    const traceId = randomUUID2();
+    const msg = {
+      msgId: `cpcron:${cron.cronId}:${traceId}`,
+      traceId,
+      source: "cron",
+      platform: "slack",
+      channel: cron.target.channel,
+      thread: `cpcron:${cron.cronId}:${traceId}`,
+      sender: { id: `cpcron:${cron.cronId}`, isBot: false },
+      text: cron.trigger,
+      mentionedBots: [],
+      isDm: false,
+      trigger: "cron"
+    };
+    this.onInbound(msg);
+  }
+  startCpClient(root) {
+    const cp = this.cfg.controlPlane;
+    if (!cp?.enabled || !cp.url || !cp.token) {
+      this.log.info("cp: not connecting (disabled or missing url/token) \u2014 running local");
+      return;
+    }
+    this.cpCrons = new CpCronRegistry({ onFire: (cron) => this.onCpCronFire(cron) });
+    const url = cp.url;
+    this.cpClient = new CpClient({
+      url,
+      token: cp.token,
+      ...this.cfg.daemonId ? { daemonId: this.cfg.daemonId } : {},
+      onDaemonId: (id) => {
+        this.cfg.daemonId = id;
+        persistDaemonId(root, id);
+        this.log.info(`cp: adopted daemonId ${id} from auth/ok`);
+      },
+      agentVersion: "0.0.0",
+      host: hostname(),
+      heartbeatDefaultMs: cp.heartbeatMs,
+      maxAgents: this.cfg.limits.maxAgents,
+      capabilities: () => ({
+        platforms: ["slack"],
+        runtimes: Object.keys(this.runtimes),
+        acp: true,
+        features: []
+      }),
+      localState: () => ({ assignments: [], crons: this.cpCrons?.ids() ?? [], leases: [] }),
+      loadSnapshot: () => ({
+        cpu: loadavg()[0] ?? 0,
+        mem: totalmem() > 0 ? 1 - freemem() / totalmem() : 0,
+        agents: this.hosts.size
+      }),
+      activeSessions: () => this.pending.size,
+      degradedScopes: () => this.cpDegradedScopes(),
+      configApply: this.cpConfigApply(),
+      clock: systemClock,
+      connect: () => ClientTransport.dial(url),
+      log: this.log
+    });
+    this.cpClient.start();
+    this.log.info(`cp: connecting to ${url}\u2026`);
+  }
+  async stop() {
+    clearTimeout(this.debounceTimer);
+    await this.watcher?.close();
+    const errors = [];
+    this.scheduler?.stop();
+    await Promise.resolve(this.cpClient?.stop()).catch((e) => errors.push(e));
+    this.cpCrons?.stop();
+    for (const c of this.connections) await Promise.resolve(c.stop()).catch((e) => errors.push(e));
+    for (const h of this.hosts.values()) await Promise.resolve(h.stop()).catch((e) => errors.push(e));
+    this.store?.close();
+    if (errors.length) throw new AggregateError(errors, "stop: partial failure");
+  }
+};
+
+// src/cli/chat.ts
+import { createInterface } from "readline";
+function renderUpdate(out) {
+  return (_sessionId, update) => {
+    if (update.sessionUpdate === "agent_message_chunk" && update.content.type === "text") {
+      out.write(update.content.text);
+    } else if (update.sessionUpdate === "tool_call") {
+      const title = "title" in update && update.title || update.toolCallId || "tool";
+      out.write(`
+[tool] ${title}
+`);
+    }
+  };
+}
+async function runChat(opts) {
+  const out = opts.out ?? process.stdout;
+  const root = resolveRoot(opts.root);
+  const cfg = loadConfig({
+    root: opts.root,
+    configPath: opts.configPath,
+    optional: true,
+    overrides: { agentsDir: opts.agentsDir }
+  });
+  const agent2 = selectAgent(cfg.agentsDir, opts.agentName);
+  const runtimes = await resolveRuntimes(cfg, root, { neededRuntimes: [agent2.runtime], mode: "cache-first" });
+  const runtime = runtimes[agent2.runtime];
+  if (!runtime) {
+    const available = Object.keys(runtimes).sort().join(", ") || "(none)";
+    throw new Error(`runtime "${agent2.runtime}" not found. Available: ${available}`);
+  }
+  const host = new AcpHost(runtime, { onUpdate: renderUpdate(out), env: agentChildEnv(agent2) });
+  await host.start();
+  try {
+    const cwd = await prepareWorkspace(agent2);
+    const sessionId = await host.newSession(cwd);
+    const send = async (text) => {
+      const blocks = [{ type: "text", text }];
+      await host.prompt(sessionId, blocks);
+      out.write("\n");
+    };
+    if (typeof opts.message === "string" && opts.message.length > 0) {
+      await send(opts.message);
+      return;
+    }
+    const rl = createInterface({ input: opts.input ?? process.stdin });
+    out.write(`Chatting with ${agent2.name} (${agent2.id}). Type .exit to quit.
+> `);
+    try {
+      for await (const line of rl) {
+        const text = line.trim();
+        if (text === ".exit" || text === ".quit") break;
+        if (text.length > 0) await send(text);
+        out.write("> ");
+      }
+    } finally {
+      rl.close();
+    }
+  } finally {
+    await host.stop();
+  }
+}
+
+// src/index.ts
+var version = true ? "0.0.0" : "0.0.0-dev";
+var program = new Command();
+program.name("agentconnect").description("AgentConnect daemon \u2014 edge message + agent execution unit").version(version);
+program.option("--config <path>", "path to config.json (default ~/.agentconnect/config.json)").option("--root <dir>", "override ~/.agentconnect root directory").option("--cp-url <url>", "override controlPlane.url").option("--cp-token <token>", "override controlPlane.token").option("--no-cp", "run fully local, do not connect to the Control Plane").option("--daemon-id <id>", "override daemon identity").option("--log-level <level>", "trace|debug|info|warn|error").option("--agents-dir <dir>", "override agents directory").option("--max-agents <n>", "max agents this daemon advertises / enforces").option("--dry-run", "load + validate config and print the reconcile plan, then exit").option("--agent <name>", "select a single agent by id (run/chat)");
+var todo = (name) => () => {
+  console.log(`agentconnect: ${name} (not yet implemented)`);
+};
+program.command("run").description("Run the daemon in the foreground").action(async () => {
+  const opts = program.opts();
+  const daemon = new Daemon({
+    root: opts.root,
+    agentName: opts.agent,
+    overrides: {
+      cpUrl: opts.cpUrl,
+      cpToken: opts.cpToken,
+      noCp: opts.cp === false,
+      daemonId: opts.daemonId,
+      logLevel: opts.logLevel,
+      agentsDir: opts.agentsDir,
+      maxAgents: opts.maxAgents ? Number(opts.maxAgents) : void 0
+    }
+  });
+  try {
+    await daemon.start();
+  } catch (err) {
+    console.error(`agentconnect run: ${err.message}`);
+    process.exit(1);
+  }
+  const shutdown = async () => {
+    await daemon.stop();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  console.log("agentconnect: daemon running (Ctrl-C to stop)");
+});
+program.command("start").description("Start the daemon in the background (detached)").action(todo("start"));
+program.command("stop").description("Gracefully stop the daemon").action(todo("stop"));
+program.command("restart").description("Restart the daemon").action(todo("restart"));
+program.command("status").description("Print runtime status").action(todo("status"));
+program.command("install-service").description("Install launchd / systemd service").action(todo("install-service"));
+program.command("uninstall-service").description("Uninstall the system service").action(todo("uninstall-service"));
+program.command("login").description("Write daemon-token / CP url into config").action(todo("login"));
+var config = program.command("config").description("Read / write / validate config.json");
+config.command("get").action(todo("config get"));
+config.command("set").action(todo("config set"));
+config.command("validate").action(todo("config validate"));
+config.command("path").action(todo("config path"));
+var agent = program.command("agent").description("Manage local agent directories");
+agent.command("list").action(todo("agent list"));
+agent.command("add [id]").action(todo("agent add"));
+agent.command("remove [id]").action(todo("agent remove"));
+agent.command("enable [id]").action(todo("agent enable"));
+agent.command("disable [id]").action(todo("agent disable"));
+program.command("chat [message]").description("Discover an agent under --agents-dir (or --agent <name>) and chat over ACP").action(async (message) => {
+  const opts = program.opts();
+  try {
+    await runChat({
+      agentsDir: opts.agentsDir,
+      agentName: opts.agent,
+      message,
+      configPath: opts.config,
+      root: opts.root
+    });
+    process.exit(0);
+  } catch (err) {
+    console.error(`agentconnect chat: ${err.message}`);
+    process.exit(1);
+  }
+});
+program.parse();
+//# sourceMappingURL=index.js.map