@matthugh1/conductor-cli 0.2.4 → 0.3.0

package/dist/daemon-427UNQNA.js

@@ -0,0 +1,614 @@
+#!/usr/bin/env node
+
+// ../../src/core/daemon-runner.ts
+async function fillSlots(ctx, freeSlots, todayCount) {
+  let agents;
+  try {
+    agents = await ctx.client.listEnabledAgents(ctx.projectId);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    ctx.log(`Failed to list agents: ${msg}`);
+    ctx.counters.consecutiveFailures++;
+    ctx.counters.failedToday++;
+    return;
+  }
+  if (agents.length === 0) return;
+  const activeInitiativeIds = new Set(
+    [...ctx.activeTasks.values()].map((t) => t.initiativeId).filter((id) => id !== null)
+  );
+  let globalSlotsRemaining = Math.min(freeSlots, ctx.config.maxPerDay - todayCount);
+  for (const agent of agents) {
+    if (globalSlotsRemaining <= 0 || !ctx.running) break;
+    const agentRunning = runningCountForAgent(ctx.activeTasks, agent.id);
+    const agentCapacity = agent.maxConcurrent - agentRunning;
+    if (agentCapacity <= 0) continue;
+    const fetchLimit = Math.min(agentCapacity, globalSlotsRemaining);
+    let candidates;
+    try {
+      candidates = await ctx.client.getNextTasksForAgent(agent.id, fetchLimit);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      ctx.log(`Failed to fetch tasks for agent "${agent.name}": ${msg}`);
+      continue;
+    }
+    for (const task of candidates) {
+      if (globalSlotsRemaining <= 0 || !ctx.running) break;
+      if (ctx.attemptedIds.has(task.id)) continue;
+      ctx.attemptedIds.set(task.id, Date.now());
+      if (task.initiativeId !== null && activeInitiativeIds.has(task.initiativeId)) {
+        ctx.log(`Skipping "${task.title}" \u2014 another task from the same initiative is already running.`);
+        continue;
+      }
+      if (task.type === "deliverable" && task.deliverableId) {
+        try {
+          const delivDetail = await ctx.client.getDeliverableDetail(task.deliverableId);
+          if (delivDetail && ["feature", "enhancement", "refactor"].includes(delivDetail.type ?? "feature") && !delivDetail.prompt) {
+            ctx.log(`Skipping "${task.title}" \u2014 deliverable needs an implementation brief (prompt).`);
+            continue;
+          }
+        } catch {
+        }
+      }
+      let claimed;
+      try {
+        claimed = await ctx.client.claimTask(task.id);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        ctx.log(`Failed to claim task "${task.title}": ${msg}`);
+        continue;
+      }
+      if (!claimed) continue;
+      const spawned = await spawnAgentTask(ctx, claimed, agent);
+      if (spawned) {
+        globalSlotsRemaining--;
+        if (task.initiativeId !== null) {
+          activeInitiativeIds.add(task.initiativeId);
+        }
+      }
+    }
+  }
+}
+async function spawnAgentTask(ctx, task, agent) {
+  let worktreePath = null;
+  let initiativeTitle = null;
+  if (task.initiativeId) {
+    try {
+      const init = task.deliverableId ? await ctx.client.getInitiativeForDeliverable(task.deliverableId) : null;
+      initiativeTitle = init?.initiativeTitle ?? null;
+    } catch {
+    }
+  }
+  if (ctx.config.useWorktree && task.initiativeId) {
+    try {
+      const existing = await ctx.client.getWorktreeForInitiative(ctx.projectId, task.initiativeId);
+      if (existing) {
+        worktreePath = existing.worktreePath;
+        ctx.log(`Reusing existing worktree at ${worktreePath}`);
+      } else {
+        const { runGit } = await import("./git-wrapper-QRZYTYCZ.js");
+        const path = await import("path");
+        const slug = (initiativeTitle ?? "unknown").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60);
+        const branchName = slug;
+        const parentDir = path.dirname(ctx.projectPath);
+        const projectDir = path.basename(ctx.projectPath);
+        const worktreeDir = path.join(parentDir, `${projectDir}--${slug}`);
+        try {
+          await runGit(ctx.projectPath, ["rev-parse", "--verify", branchName]);
+        } catch {
+          await runGit(ctx.projectPath, ["branch", branchName]);
+        }
+        await runGit(ctx.projectPath, ["worktree", "add", worktreeDir, branchName]);
+        await ctx.client.registerWorktree({
+          projectId: ctx.projectId,
+          initiativeId: task.initiativeId,
+          branchName,
+          worktreePath: worktreeDir
+        });
+        worktreePath = worktreeDir;
+        ctx.log(`Created worktree for "${initiativeTitle}" at ${worktreePath}`);
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      ctx.log(`Worktree setup failed: ${msg}`);
+      if (task.deliverableId) {
+        ctx.log("Skipping \u2014 useWorktree is enabled. Refusing to run in main repo without isolation.");
+        return false;
+      }
+    }
+  } else if (ctx.config.useWorktree && task.deliverableId && !task.initiativeId) {
+    ctx.log(`Skipping "${task.title}" \u2014 useWorktree is enabled but no initiative set. Refusing to run without isolation.`);
+    return false;
+  }
+  const agentCwd = worktreePath ?? ctx.projectPath;
+  let run;
+  try {
+    run = await ctx.client.createRun({
+      projectId: ctx.projectId,
+      deliverableId: task.deliverableId ?? task.id,
+      pid: process.pid,
+      worktreePath: worktreePath ?? void 0
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    ctx.log(`Failed to create daemon run record: ${msg}`);
+    ctx.counters.consecutiveFailures++;
+    ctx.counters.failedToday++;
+    return false;
+  }
+  try {
+    await ctx.client.updateTask(task.id, { status: "running", runId: run.id });
+  } catch {
+  }
+  const { readFile } = await import("fs/promises");
+  const { join } = await import("path");
+  let claudeMd = "";
+  try {
+    claudeMd = await readFile(join(agentCwd, "CLAUDE.md"), "utf8");
+  } catch {
+  }
+  const { assembleTaskPrompt } = await import("./runner-prompt-7EUGIDWK.js");
+  const assembledPrompt = assembleTaskPrompt(
+    { name: agent.name, systemPrompt: agent.systemPrompt, agentSlug: agent.slug },
+    {
+      title: task.title,
+      prompt: task.prompt,
+      deliverableId: task.deliverableId,
+      projectName: ctx.projectPath
+    },
+    claudeMd
+  );
+  ctx.log(
+    `Spawning "${agent.name}" for: "${task.title}"${worktreePath ? ` (worktree: ${worktreePath})` : ""} [${ctx.activeTasks.size + 1}/${ctx.config.maxConcurrent} slots]`
+  );
+  const { spawnAgent } = await import("./agent-spawner-YCGFXFXX.js");
+  const spawned = spawnAgent({
+    item: {
+      priority: task.priority,
+      tier: "active",
+      type: "deliverable",
+      title: task.title,
+      reason: `Agent task: ${task.title}`,
+      action: "Execute task",
+      agentRole: agent.role ?? "implementation-engineer",
+      entityId: task.deliverableId ?? task.id,
+      entityType: "deliverable"
+    },
+    projectRoot: agentCwd,
+    runId: run.id,
+    projectId: ctx.projectId,
+    deliverableId: task.deliverableId ?? void 0,
+    timeoutMs: ctx.config.timeout * 6e4,
+    client: ctx.client,
+    assembledPrompt,
+    modelOverride: agent.model !== "claude-sonnet-4-20250514" ? agent.model : void 0,
+    skipPermissions: ctx.config.skipPermissions,
+    onLine: (stream, line) => {
+      if (stream === "stderr") {
+        ctx.writeErr(line);
+      }
+    }
+  });
+  if (spawned.pid !== null) {
+    try {
+      await ctx.client.updateRunPid(run.id, spawned.pid);
+    } catch {
+    }
+  }
+  ctx.activeTasks.set(task.id, {
+    promise: spawned.done,
+    cancel: spawned.cancel,
+    taskId: task.id,
+    runId: run.id,
+    agentId: agent.id,
+    agentName: agent.name,
+    deliverableId: task.deliverableId,
+    initiativeId: task.initiativeId,
+    worktreePath,
+    title: task.title
+  });
+  ctx.log(
+    `Picked: "${task.title}" (P${task.priority}) \u2192 agent "${agent.name}"${initiativeTitle ? ` [${initiativeTitle}]` : ""}`
+  );
+  return true;
+}
+async function handleCompletion(ctx, taskId, result) {
+  const task = ctx.activeTasks.get(taskId);
+  if (!task) return;
+  ctx.activeTasks.delete(taskId);
+  ctx.log(
+    `Agent "${task.agentName}" finished: ${result.outcome} (exit ${result.exitCode ?? "n/a"}, ${result.lineCount} lines, ${Math.round(result.durationMs / 1e3)}s)`
+  );
+  try {
+    await ctx.client.completeRun(task.runId, {
+      status: result.outcome === "completed" ? "completed" : result.outcome === "timeout" ? "timeout" : result.outcome === "cancelled" ? "cancelled" : "failed",
+      exitCode: result.exitCode ?? void 0,
+      errorMessage: result.errorMessage,
+      inputTokens: result.tokenUsage?.inputTokens,
+      outputTokens: result.tokenUsage?.outputTokens,
+      cacheReadTokens: result.tokenUsage?.cacheReadTokens,
+      cacheCreationTokens: result.tokenUsage?.cacheCreationTokens,
+      totalCostUsd: result.tokenUsage?.totalCostUsd
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    ctx.log(`Failed to update daemon run: ${msg}`);
+  }
+  if (result.tokenUsage) {
+    const t = result.tokenUsage;
+    const fmtK = (n) => n >= 1e3 ? `${Math.round(n / 1e3)}K` : String(n);
+    const totalIn = t.inputTokens + t.cacheReadTokens + t.cacheCreationTokens;
+    ctx.log(`[tokens] ${fmtK(totalIn)} in / ${fmtK(t.outputTokens)} out ($${t.totalCostUsd.toFixed(2)})`);
+  }
+  if (result.outcome === "completed") {
+    ctx.log(`Completed: "${task.title}" (agent: ${task.agentName})`);
+    ctx.counters.consecutiveFailures = 0;
+    ctx.counters.completedToday++;
+    try {
+      await ctx.client.updateTask(task.taskId, {
+        status: "completed",
+        result: `Completed successfully in ${Math.round(result.durationMs / 1e3)}s`
+      });
+    } catch {
+    }
+    if (task.deliverableId) {
+      try {
+        const compliance = await ctx.client.checkRunCompliance(
+          task.runId,
+          task.deliverableId
+        );
+        if (compliance.passed) {
+          ctx.log(`[protocol] Full compliance \u2713 for "${task.title}"`);
+        } else {
+          ctx.log(`[protocol] Missing for "${task.title}": ${compliance.missing.join(", ")}`);
+        }
+        await ctx.client.updateRunCompliance(task.runId, compliance);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        ctx.log(`[protocol] Compliance check failed: ${msg}`);
+      }
+    }
+    if (task.worktreePath) {
+      ctx.log(`Worktree preserved at ${task.worktreePath} for reuse by next task.`);
+    }
+  } else if (result.outcome === "cancelled") {
+    ctx.log(`Cancelled: "${task.title}" (agent: ${task.agentName})`);
+    ctx.counters.failedToday++;
+    try {
+      await ctx.client.updateTask(task.taskId, { status: "cancelled" });
+    } catch {
+    }
+    if (task.deliverableId) {
+      try {
+        await ctx.client.updateDeliverableStatus(task.deliverableId, "parked");
+      } catch {
+      }
+    }
+    if (task.worktreePath) {
+      ctx.log(`Worktree preserved at ${task.worktreePath} for debugging`);
+    }
+  } else {
+    const reason = result.errorMessage ?? `exit ${result.exitCode}`;
+    ctx.log(
+      `${result.outcome === "timeout" ? "Timed out" : "Failed"}: "${task.title}" (agent: ${task.agentName}) \u2014 ${reason}`
+    );
+    ctx.counters.consecutiveFailures++;
+    ctx.counters.failedToday++;
+    try {
+      await ctx.client.updateTask(task.taskId, {
+        status: "failed",
+        errorMessage: reason
+      });
+    } catch {
+    }
+    if (task.deliverableId) {
+      try {
+        await ctx.client.updateDeliverableStatus(task.deliverableId, "parked");
+      } catch {
+      }
+    }
+    if (task.worktreePath) {
+      ctx.log(`Worktree preserved at ${task.worktreePath} for debugging`);
+    }
+  }
+}
+function runningCountForAgent(activeTasks, agentId) {
+  let count = 0;
+  for (const t of activeTasks.values()) {
+    if (t.agentId === agentId) count++;
+  }
+  return count;
+}
+var ATTEMPTED_TTL_MS = 30 * 6e4;
+function pruneAttempted(attemptedIds, now) {
+  for (const [id, ts2] of attemptedIds) {
+    if (now - ts2 > ATTEMPTED_TTL_MS) attemptedIds.delete(id);
+  }
+}
+async function sleepWithCheck(ms, isRunning) {
+  const intervals = Math.ceil(ms / 1e3);
+  for (let i = 0; i < intervals && isRunning(); i++) {
+    await new Promise((r) => setTimeout(r, 1e3));
+  }
+}
+async function ingestAndRoute(ctx) {
+  try {
+    const ingested = await ctx.client.ingestAutonomousDeliverables(ctx.projectId, ctx.projectPath);
+    if (ingested > 0) ctx.log(`Ingested ${ingested} auto-generated task(s) into task backlog`);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    ctx.log(`Warning: auto-task ingestion failed: ${msg}`);
+  }
+  try {
+    const { routed, decisions } = await ctx.client.routePendingTasks(ctx.projectId, ctx.projectPath);
+    for (const decision of decisions) {
+      ctx.log(
+        `Routed task "${decision.taskTitle}" to ${decision.agentName} (${decision.explanation.summary}; weight=${decision.explanation.weight}; load=${decision.explanation.activeQueuedCount})`
+      );
+    }
+    if (routed > 0) ctx.log(`Auto-routed ${routed} pending daemon task(s)`);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    ctx.log(`Warning: daemon task routing failed: ${msg}`);
+  }
+}
+async function resolveProject(opts, client, log2, writeErr2) {
+  try {
+    const { readProjectId } = await import("./cli-config-LEERSU5N.js");
+    const configProjectId = readProjectId();
+    if (configProjectId) {
+      log2(`Using project ID from config: ${configProjectId}`);
+      return { projectPath: opts.projectRoot, projectId: configProjectId };
+    }
+    if (opts.projectName) {
+      const project2 = await client.resolveProject({ name: opts.projectName });
+      return { projectPath: project2.path, projectId: project2.id };
+    }
+    const project = await client.resolveProject({ path: opts.projectRoot });
+    return { projectPath: project.path, projectId: project.id };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    writeErr2(msg);
+    return { projectPath: null, projectId: null };
+  }
+}
+async function buildConfig(opts, projectPath) {
+  let fileConfig = {};
+  try {
+    const { readConfig } = await import("./cli-config-LEERSU5N.js");
+    const config = readConfig(projectPath);
+    fileConfig = config.daemon ?? {};
+  } catch {
+  }
+  const D = { checkInterval: 3e4, maxPerDay: 50, maxConsecutiveFailures: 3, timeout: 120, maxConcurrent: 1, skipPermissions: false };
+  return {
+    checkInterval: opts.checkInterval !== D.checkInterval ? opts.checkInterval : fileConfig.checkInterval ?? D.checkInterval,
+    maxPerDay: opts.maxPerDay !== D.maxPerDay ? opts.maxPerDay : fileConfig.maxPerDay ?? D.maxPerDay,
+    maxConsecutiveFailures: opts.maxConsecutiveFailures !== D.maxConsecutiveFailures ? opts.maxConsecutiveFailures : fileConfig.maxConsecutiveFailures ?? D.maxConsecutiveFailures,
+    timeout: opts.timeout !== D.timeout ? opts.timeout : fileConfig.timeout ?? D.timeout,
+    maxConcurrent: opts.maxConcurrent !== D.maxConcurrent ? opts.maxConcurrent : fileConfig.maxConcurrent ?? D.maxConcurrent,
+    useWorktree: !opts.noWorktree,
+    skipPermissions: opts.skipPermissions || (fileConfig.skipPermissions ?? false)
+  };
+}
+async function pollLoop(ctx, heartbeatInterval) {
+  while (ctx.running) {
+    try {
+      pruneAttempted(ctx.attemptedIds, Date.now());
+      if (ctx.counters.consecutiveFailures >= ctx.config.maxConsecutiveFailures) {
+        ctx.log(`Stopping: ${ctx.counters.consecutiveFailures} consecutive failures reached limit.`);
+        break;
+      }
+      await ingestAndRoute(ctx);
+      const freeSlots = ctx.config.maxConcurrent - ctx.activeTasks.size;
+      if (freeSlots > 0) {
+        const todayCount = await ctx.client.getQuota(ctx.projectId);
+        if (todayCount >= ctx.config.maxPerDay) {
+          ctx.log(`Daily quota reached (${todayCount}/${ctx.config.maxPerDay}). Waiting...`);
+        } else {
+          await fillSlots(ctx, freeSlots, todayCount);
+        }
+      }
+      if (ctx.activeTasks.size > 0) {
+        const taggedPromises = [...ctx.activeTasks.entries()].map(
+          ([id, task]) => task.promise.then((result) => ({ id, result }))
+        );
+        const sleepPromise = sleepWithCheck(ctx.config.checkInterval, () => ctx.running).then(() => null);
+        const completed = await Promise.race([...taggedPromises, sleepPromise]);
+        if (completed !== null) {
+          await handleCompletion(ctx, completed.id, completed.result);
+        }
+      } else {
+        await sleepWithCheck(ctx.config.checkInterval, () => ctx.running);
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      ctx.log(`Unexpected error in daemon loop: ${msg}`);
+      ctx.counters.consecutiveFailures++;
+      ctx.counters.failedToday++;
+      await sleepWithCheck(ctx.config.checkInterval, () => ctx.running);
+    }
+  }
+  if (ctx.activeTasks.size > 0) {
+    ctx.log(`Waiting for ${ctx.activeTasks.size} active task(s) to finish...`);
+    const remaining = [...ctx.activeTasks.entries()].map(
+      ([id, task]) => task.promise.then((result) => ({ id, result }))
+    );
+    const results = await Promise.allSettled(remaining);
+    for (const r of results) {
+      if (r.status === "fulfilled") {
+        await handleCompletion(ctx, r.value.id, r.value.result);
+      }
+    }
+  }
+  clearInterval(heartbeatInterval);
+}
+
+// ../../src/cli/daemon.ts
+function writeOut(text) {
+  process.stdout.write(text + "\n");
+}
+function writeErr(text) {
+  process.stderr.write(text + "\n");
+}
+function ts() {
+  return (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour12: false });
+}
+function log(msg) {
+  writeOut(`[${ts()}] ${msg}`);
+}
+async function cmdDaemonCancel(projectRoot, projectName, jsonOutput, apiUrl, apiKey) {
+  const { existsSync, readFileSync, unlinkSync } = await import("fs");
+  const { join } = await import("path");
+  const { createDaemonClient } = await import("./daemon-client-RVY2YLMA.js");
+  const resolvedUrl = apiUrl ?? process.env.CONDUCTOR_API_URL;
+  const client = createDaemonClient(resolvedUrl, apiKey);
+  let projectId;
+  try {
+    const project = projectName ? await client.resolveProject({ name: projectName }) : await client.resolveProject({ path: projectRoot });
+    projectId = project.id;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    writeErr(msg);
+    return 1;
+  }
+  const pidPath = join(projectRoot, ".conductor", `daemon-${projectId}.pid`);
+  if (!existsSync(pidPath)) {
+    if (jsonOutput) {
+      writeOut(JSON.stringify({ error: "No daemon running for this project." }));
+    } else {
+      writeErr("No daemon running for this project.");
+    }
+    return 1;
+  }
+  const pid = parseInt(readFileSync(pidPath, "utf8").trim(), 10);
+  if (!Number.isFinite(pid)) {
+    unlinkSync(pidPath);
+    writeErr("Stale PID file removed.");
+    return 1;
+  }
+  try {
+    process.kill(pid, "SIGTERM");
+    if (jsonOutput) {
+      writeOut(JSON.stringify({ cancelled: true, pid }));
+    } else {
+      writeOut(`Sent shutdown signal to daemon (PID ${pid}).`);
+    }
+    return 0;
+  } catch {
+    unlinkSync(pidPath);
+    if (jsonOutput) {
+      writeOut(JSON.stringify({ error: "Daemon process not found. Cleaned up stale PID file." }));
+    } else {
+      writeErr("Daemon process not found. Cleaned up stale PID file.");
+    }
+    return 1;
+  }
+}
+async function cmdDaemon(opts) {
+  const { mkdirSync, writeFileSync, unlinkSync, existsSync, readFileSync } = await import("fs");
+  const { join } = await import("path");
+  const { createDaemonClient } = await import("./daemon-client-RVY2YLMA.js");
+  const resolvedUrl = opts.apiUrl ?? process.env.CONDUCTOR_API_URL;
+  const client = createDaemonClient(resolvedUrl, opts.apiKey);
+  const resolved = await resolveProject(opts, client, log, writeErr);
+  if (!resolved.projectPath) return 1;
+  const { projectPath, projectId } = resolved;
+  const conductorDir = join(projectPath, ".conductor");
+  mkdirSync(conductorDir, { recursive: true });
+  const pidPath = join(conductorDir, `daemon-${projectId}.pid`);
+  if (existsSync(pidPath)) {
+    const existingPid = parseInt(readFileSync(pidPath, "utf8").trim(), 10);
+    if (Number.isFinite(existingPid)) {
+      try {
+        process.kill(existingPid, 0);
+        writeErr(`A daemon is already running for this project (PID ${existingPid}).`);
+        writeErr("Run: conductor daemon cancel --project <name>");
+        return 1;
+      } catch {
+        log("Cleaned up stale PID file from a previous daemon.");
+        unlinkSync(pidPath);
+      }
+    } else {
+      unlinkSync(pidPath);
+    }
+  }
+  writeFileSync(pidPath, String(process.pid), "utf8");
+  const daemonConfig = await buildConfig(opts, projectPath);
+  const activeTasks = /* @__PURE__ */ new Map();
+  const counters = { consecutiveFailures: 0, completedToday: 0, failedToday: 0 };
+  let running = true;
+  const ctx = {
+    client,
+    config: daemonConfig,
+    projectPath,
+    projectId,
+    activeTasks,
+    attemptedIds: /* @__PURE__ */ new Map(),
+    counters,
+    get running() {
+      return running;
+    },
+    log,
+    writeErr
+  };
+  const shutdown = () => {
+    log("Shutting down daemon gracefully...");
+    running = false;
+    for (const task of activeTasks.values()) task.cancel();
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  try {
+    await client.upsertHeartbeat({
+      projectId,
+      pid: process.pid,
+      state: "idle",
+      config: { ...daemonConfig },
+      stats: { completedToday: 0, failedToday: 0 }
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    writeErr(`Failed to write initial heartbeat: ${msg}`);
+    unlinkSync(pidPath);
+    return 1;
+  }
+  try {
+    const purged = await client.purgeOldRuns(30);
+    if (purged > 0) log(`Cleaned up ${purged} daemon run(s) older than 30 days`);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    log(`Warning: cleanup of old runs failed: ${msg}`);
+  }
+  log(`Daemon started for project: ${projectPath}`);
+  log(`PID: ${process.pid} | Poll: ${daemonConfig.checkInterval}ms | Daily: ${daemonConfig.maxPerDay} | Slots: ${daemonConfig.maxConcurrent}`);
+  const heartbeatInterval = setInterval(async () => {
+    try {
+      const firstActive = activeTasks.values().next().value;
+      await client.upsertHeartbeat({
+        projectId,
+        pid: process.pid,
+        state: activeTasks.size > 0 ? "executing" : "idle",
+        currentDeliverableId: firstActive?.deliverableId ?? void 0,
+        currentRunId: firstActive?.runId,
+        config: { ...daemonConfig },
+        stats: { completedToday: counters.completedToday, failedToday: counters.failedToday, activeCount: activeTasks.size }
+      });
+    } catch {
+    }
+  }, 3e4);
+  await pollLoop(ctx, heartbeatInterval);
+  log("Daemon stopped.");
+  try {
+    await client.clearHeartbeat(projectId);
+  } catch {
+  }
+  try {
+    unlinkSync(pidPath);
+  } catch {
+  }
+  return 0;
+}
+export {
+  cmdDaemon,
+  cmdDaemonCancel
+};

package/dist/{daemon-client-CTYOJMJP.js → daemon-client-RVY2YLMA.js}

@@ -426,6 +426,19 @@ function createDaemonClient(baseUrl = "https://conductor-297703646986.europe-wes
         "updateTask"
       );
       return task;
+    },
+    // ── Protocol compliance methods ────────────────────────────────────
+    async checkRunCompliance(runId, deliverableId) {
+      const res = await get(`/api/daemon/runs/${runId}/compliance`, {
+        deliverableId
+      });
+      return jsonBody(res, "checkRunCompliance");
+    },
+    async updateRunCompliance(runId, compliance) {
+      const res = await patch(`/api/daemon/runs/${runId}`, {
+        protocolCompliance: compliance
+      });
+      await assertOk(res, "updateRunCompliance");
     }
   };
 }