@kmmao/happy-agent 0.4.1 → 0.5.1

package/dist/index.mjs

@@ -12,11 +12,12 @@ import { exec, execFile, spawn } from 'child_process';
 import { promisify } from 'util';
 import { readFile, mkdir, writeFile, readdir, stat } from 'fs/promises';
 import { createHash as createHash$1, randomUUID } from 'crypto';
-import { join as join$1, resolve } from 'path';
-import { realpathSync } from 'fs';
+import { join as join$1, resolve, dirname as dirname$1 } from 'path';
+import { realpathSync, readFileSync as readFileSync$1, mkdirSync as mkdirSync$1, writeFileSync as writeFileSync$1 } from 'fs';
 import { tmpdir } from 'os';
+import { createServer } from 'http';
 
-var version = "0.4.1";
+var version = "0.5.1";
 
 function loadConfig() {
   const serverUrl = (process.env.HAPPY_SERVER_URL ?? "https://happyserve.xycloud.info").replace(/\/+$/, "");
@@ -1836,12 +1837,15 @@ function isNotFound(err) {
 }
 
 const pidToSession = /* @__PURE__ */ new Map();
+let persistPath = null;
 function trackSession(session) {
   pidToSession.set(session.pid, session);
+  flush();
 }
 function untrackSession(pid) {
   const session = pidToSession.get(pid);
   pidToSession.delete(pid);
+  flush();
   return session;
 }
 function getTrackedSession(pid) {
@@ -1853,9 +1857,59 @@ function getAllTrackedSessions() {
 function getTrackedSessionCount() {
   return pidToSession.size;
 }
+function enablePersistence(filePath) {
+  persistPath = filePath;
+  load();
+}
+function load() {
+  if (!persistPath) return;
+  try {
+    const raw = readFileSync$1(persistPath, "utf-8");
+    const entries = JSON.parse(raw);
+    let recovered = 0;
+    for (const entry of entries) {
+      try {
+        process.kill(entry.pid, 0);
+      } catch {
+        continue;
+      }
+      pidToSession.set(entry.pid, {
+        pid: entry.pid,
+        directory: entry.directory,
+        startedAt: entry.startedAt,
+        happySessionId: entry.happySessionId,
+        lastActivityAt: entry.lastActivityAt,
+        automationContext: entry.automationContext
+      });
+      recovered++;
+    }
+    if (recovered > 0) {
+      logger.debug(`[TRACKED] Recovered ${recovered} sessions from ${persistPath}`);
+    }
+  } catch {
+  }
+}
+function flush() {
+  if (!persistPath) return;
+  try {
+    const entries = [...pidToSession.values()].map((s) => ({
+      pid: s.pid,
+      directory: s.directory,
+      startedAt: s.startedAt,
+      happySessionId: s.happySessionId,
+      lastActivityAt: s.lastActivityAt,
+      automationContext: s.automationContext
+    }));
+    mkdirSync$1(dirname$1(persistPath), { recursive: true });
+    writeFileSync$1(persistPath, JSON.stringify(entries, null, 2), "utf-8");
+  } catch (err) {
+    logger.debug(`[TRACKED] Failed to persist: ${err}`);
+  }
+}
 
 var trackedSessions = /*#__PURE__*/Object.freeze({
   __proto__: null,
+  enablePersistence: enablePersistence,
   getAllTrackedSessions: getAllTrackedSessions,
   getTrackedSession: getTrackedSession,
   getTrackedSessionCount: getTrackedSessionCount,
@@ -2023,11 +2077,11 @@ function stopSession(pid) {
   }
 }
 
-const PROMPT_DIR = join$1(tmpdir(), "happy", "agent-prompts");
+const PROMPT_DIR$1 = join$1(tmpdir(), "happy", "agent-prompts");
 async function writePromptFile(prefix, content) {
-  await mkdir(PROMPT_DIR, { recursive: true });
+  await mkdir(PROMPT_DIR$1, { recursive: true });
   const filename = `${prefix}-${Date.now()}.md`;
-  const filepath = join$1(PROMPT_DIR, filename);
+  const filepath = join$1(PROMPT_DIR$1, filename);
   await writeFile(filepath, content, "utf-8");
   return filepath;
 }
@@ -2211,6 +2265,8 @@ class MachineClient {
   automationServerUrl = "";
   automationAuthToken = "";
   scheduler = null;
+  loopCoordinator = null;
+  auditStore = null;
   constructor(opts) {
     this.token = opts.token;
     this.machine = opts.machine;
@@ -2252,6 +2308,34 @@ class MachineClient {
       return { sessions };
     });
   }
+  registerLoopHandlers() {
+    const coord = this.loopCoordinator;
+    this.rpcHandlerManager.registerHandler("create-loop", async (data) => {
+      const loop = coord.createLoop(data);
+      return { loop: { id: loop.id, name: loop.name, state: loop.state } };
+    });
+    this.rpcHandlerManager.registerHandler("list-loops", async () => {
+      return { loops: coord.listLoops() };
+    });
+    this.rpcHandlerManager.registerHandler("pause-loop", async (data) => {
+      return { success: coord.pauseLoop(data.loopId) };
+    });
+    this.rpcHandlerManager.registerHandler("resume-loop", async (data) => {
+      return { success: coord.resumeLoop(data.loopId) };
+    });
+    this.rpcHandlerManager.registerHandler("delete-loop", async (data) => {
+      return { success: coord.deleteLoop(data.loopId) };
+    });
+  }
+  registerAuditHandlers() {
+    const audit = this.auditStore;
+    this.rpcHandlerManager.registerHandler("query-audit-log", async (data) => {
+      return { events: audit.query(data) };
+    });
+    this.rpcHandlerManager.registerHandler("audit-summary", async () => {
+      return { summary: audit.summarize() };
+    });
+  }
   // -----------------------------------------------------------------------
   // Connection
   // -----------------------------------------------------------------------
@@ -2433,11 +2517,19 @@ class MachineClient {
    * Enable automation handling — agent will process webhook, supervisor,
    * and task triggers from the server by spawning Happy CLI sessions.
    */
-  enableAutomation(serverUrl, authToken, scheduler) {
+  enableAutomation(serverUrl, authToken, scheduler, loopCoordinator, auditStore) {
     this.automationEnabled = true;
     this.automationServerUrl = serverUrl;
     this.automationAuthToken = authToken;
     this.scheduler = scheduler;
+    this.loopCoordinator = loopCoordinator ?? null;
+    this.auditStore = auditStore ?? null;
+    if (this.loopCoordinator) {
+      this.registerLoopHandlers();
+    }
+    if (this.auditStore) {
+      this.registerAuditHandlers();
+    }
     logger.debug("[MACHINE] Automation enabled");
   }
   /** Internal dispatch for ephemeral events that need automation handling. */
@@ -2558,6 +2650,7 @@ class AutomationScheduler {
   retryDelayMs;
   defaultMaxAttempts;
   maxRecentCompletions;
+  onAudit;
   /** Active jobs indexed by id. */
   jobs = /* @__PURE__ */ new Map();
   /** dedupeKey → jobId for fast dedup lookups. */
@@ -2571,6 +2664,7 @@ class AutomationScheduler {
     this.retryDelayMs = options?.retryDelayMs ?? 5e3;
     this.defaultMaxAttempts = options?.maxAttempts ?? 3;
     this.maxRecentCompletions = options?.maxRecentCompletions ?? 50;
+    this.onAudit = options?.onAudit ?? null;
     this.pumpTimer = setInterval(() => this.pump(), 1e3);
   }
   // -----------------------------------------------------------------------
@@ -2601,6 +2695,7 @@ class AutomationScheduler {
     this.jobs.set(job.id, job);
     this.dedupeIndex.set(job.dedupeKey, job.id);
     logger.debug(`[SCHEDULER] Enqueued: ${job.kind} ${job.dedupeKey} (${job.priority}) id=${job.id}`);
+    this.onAudit?.({ kind: "job_enqueued", jobId: job.id, dedupeKey: job.dedupeKey, message: `${job.kind}:${job.priority}` });
     this.pump();
     return { job, deduped: false };
   }
@@ -2610,6 +2705,7 @@ class AutomationScheduler {
     job.status = "completed";
     job.updatedAt = Date.now();
     logger.debug(`[SCHEDULER] Completed: ${job.kind} ${job.dedupeKey} id=${jobId}`);
+    this.onAudit?.({ kind: "job_completed", jobId, dedupeKey: job.dedupeKey });
     this.finalize(job);
   }
   markFailed(jobId, error) {
@@ -2621,11 +2717,13 @@ class AutomationScheduler {
       job.status = "queued";
       job.nextRunAt = Date.now() + job.attempt * this.retryDelayMs;
       logger.debug(`[SCHEDULER] Retry queued: ${job.dedupeKey} attempt=${job.attempt}/${job.maxAttempts} nextRunAt=+${job.attempt * this.retryDelayMs}ms`);
+      this.onAudit?.({ kind: "job_retried", jobId, dedupeKey: job.dedupeKey, errorMessage: error, message: `attempt ${job.attempt}/${job.maxAttempts}` });
       this.pump();
       return;
     }
     job.status = "failed";
     logger.debug(`[SCHEDULER] Failed (exhausted): ${job.kind} ${job.dedupeKey} id=${jobId}: ${error}`);
+    this.onAudit?.({ kind: "job_failed", jobId, dedupeKey: job.dedupeKey, errorMessage: error });
     this.finalize(job);
   }
   getStatus() {
@@ -2685,6 +2783,7 @@ class AutomationScheduler {
     job.attempt++;
     job.updatedAt = Date.now();
     logger.debug(`[SCHEDULER] Dispatching: ${job.kind} ${job.dedupeKey} attempt=${job.attempt}`);
+    this.onAudit?.({ kind: "job_dispatched", jobId: job.id, dedupeKey: job.dedupeKey, message: `attempt ${job.attempt}` });
     job.run(job.id).then(({ pid }) => {
       if (job.status === "dispatching") {
         job.status = "running";
@@ -2720,6 +2819,459 @@ class AutomationScheduler {
   }
 }
 
+const PROMPT_DIR = join$1(tmpdir(), "happy", "agent-loop-prompts");
+const DEFAULT_MAX_CONSECUTIVE_FAILURES = 5;
+const DEFAULT_MAX_ITERATIONS = 0;
+class AgentLoopCoordinator {
+  loops = /* @__PURE__ */ new Map();
+  scheduler;
+  serverUrl;
+  authToken;
+  guardian;
+  tickTimer = null;
+  constructor(scheduler, serverUrl, authToken, guardian) {
+    this.scheduler = scheduler;
+    this.serverUrl = serverUrl;
+    this.authToken = authToken;
+    this.guardian = guardian ?? null;
+  }
+  // -----------------------------------------------------------------------
+  // Lifecycle
+  // -----------------------------------------------------------------------
+  start() {
+    if (this.tickTimer) return;
+    this.tickTimer = setInterval(() => this.tick(), 1e3);
+    logger.debug("[LOOP] Coordinator started");
+  }
+  shutdown() {
+    if (this.tickTimer) {
+      clearInterval(this.tickTimer);
+      this.tickTimer = null;
+    }
+    logger.debug("[LOOP] Coordinator shutdown");
+  }
+  // -----------------------------------------------------------------------
+  // CRUD
+  // -----------------------------------------------------------------------
+  createLoop(input) {
+    const loop = {
+      id: randomUUID(),
+      name: input.name,
+      prompt: input.prompt,
+      directory: input.directory,
+      intervalMs: Math.max(input.intervalMs, 1e4),
+      // min 10s
+      createdAt: Date.now(),
+      state: "idle",
+      iteration: 0,
+      nextRunAt: Date.now() + Math.max(input.intervalMs, 1e4),
+      consecutiveFailures: 0,
+      maxConsecutiveFailures: input.maxConsecutiveFailures ?? DEFAULT_MAX_CONSECUTIVE_FAILURES,
+      maxIterations: input.maxIterations ?? DEFAULT_MAX_ITERATIONS
+    };
+    this.loops.set(loop.id, loop);
+    logger.debug(`[LOOP] Created: ${loop.name} (${loop.id}) interval=${loop.intervalMs}ms`);
+    return loop;
+  }
+  getLoop(id) {
+    return this.loops.get(id);
+  }
+  listLoops() {
+    return [...this.loops.values()].map((l) => ({
+      id: l.id,
+      name: l.name,
+      state: l.state,
+      iteration: l.iteration,
+      intervalMs: l.intervalMs,
+      nextRunAt: l.nextRunAt,
+      lastCompletedAt: l.lastCompletedAt
+    }));
+  }
+  pauseLoop(id) {
+    const loop = this.loops.get(id);
+    if (!loop || loop.state === "paused") return false;
+    loop.state = "paused";
+    logger.debug(`[LOOP] Paused: ${loop.name} (${id})`);
+    return true;
+  }
+  resumeLoop(id) {
+    const loop = this.loops.get(id);
+    if (!loop || loop.state !== "paused") return false;
+    loop.state = "idle";
+    loop.nextRunAt = Date.now() + loop.intervalMs;
+    loop.consecutiveFailures = 0;
+    loop.errorMessage = void 0;
+    logger.debug(`[LOOP] Resumed: ${loop.name} (${id})`);
+    return true;
+  }
+  deleteLoop(id) {
+    const deleted = this.loops.delete(id);
+    if (deleted) logger.debug(`[LOOP] Deleted: ${id}`);
+    return deleted;
+  }
+  // -----------------------------------------------------------------------
+  // Scheduler callback
+  // -----------------------------------------------------------------------
+  onJobTerminal(loopId, status, errorMessage) {
+    const loop = this.loops.get(loopId);
+    if (!loop) return;
+    loop.activeJobId = void 0;
+    loop.lastCompletedAt = Date.now();
+    if (status === "completed") {
+      loop.consecutiveFailures = 0;
+      loop.state = "idle";
+      loop.nextRunAt = Date.now() + loop.intervalMs;
+      logger.debug(`[LOOP] Iteration ${loop.iteration} completed: ${loop.name}`);
+    } else {
+      loop.consecutiveFailures++;
+      loop.errorMessage = errorMessage;
+      if (loop.consecutiveFailures >= loop.maxConsecutiveFailures) {
+        loop.state = "blocked";
+        logger.debug(`[LOOP] Blocked after ${loop.consecutiveFailures} failures: ${loop.name}`);
+      } else {
+        loop.state = "idle";
+        loop.nextRunAt = Date.now() + loop.intervalMs;
+        logger.debug(`[LOOP] Iteration ${loop.iteration} failed (${loop.consecutiveFailures}/${loop.maxConsecutiveFailures}): ${loop.name}`);
+      }
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Tick
+  // -----------------------------------------------------------------------
+  tick() {
+    const now = Date.now();
+    for (const loop of this.loops.values()) {
+      if (loop.state !== "idle") continue;
+      if (loop.nextRunAt > now) continue;
+      if (loop.maxIterations > 0 && loop.iteration >= loop.maxIterations) {
+        loop.state = "paused";
+        logger.debug(`[LOOP] Max iterations reached (${loop.maxIterations}): ${loop.name}`);
+        continue;
+      }
+      this.enqueueLoop(loop);
+    }
+  }
+  enqueueLoop(loop) {
+    loop.iteration++;
+    loop.state = "active";
+    loop.lastStartedAt = Date.now();
+    const iterationNum = loop.iteration;
+    const loopId = loop.id;
+    const coordinator = this;
+    const guardianSessionId = this.guardian?.resolve({ loopId: loop.id }) ?? void 0;
+    const { job, deduped } = this.scheduler.enqueue({
+      kind: "task",
+      dedupeKey: `agent-loop:${loop.id}:${loop.iteration}`,
+      priority: "background",
+      run: async (jobId) => {
+        const promptFile = await writeLoopPromptFile(loop.name, loop.prompt, iterationNum);
+        const result = await spawnSession({
+          directory: loop.directory,
+          approvedNewDirectoryCreation: false,
+          happySessionId: guardianSessionId,
+          automationContext: {
+            kind: "agent_loop",
+            trigger: `loop:${loop.name}:iteration-${iterationNum}`
+          },
+          environmentVariables: {
+            HAPPY_INITIAL_PROMPT_FILE: promptFile,
+            HAPPY_LOOP_ID: loopId,
+            HAPPY_LOOP_NAME: loop.name,
+            HAPPY_LOOP_ITERATION: String(iterationNum),
+            HAPPY_SERVER_URL: coordinator.serverUrl,
+            HAPPY_AUTH_TOKEN: coordinator.authToken
+          }
+        });
+        if (result.type !== "success") {
+          throw new Error(result.type === "error" ? result.errorMessage : "Directory not approved");
+        }
+        const tracked = (await Promise.resolve().then(function () { return trackedSessions; })).getTrackedSession(result.pid);
+        if (tracked?.childProcess) {
+          tracked.childProcess.on("exit", (code) => {
+            const status = code === 0 ? "completed" : "failed";
+            coordinator.onJobTerminal(loopId, status, code !== 0 ? `exit code ${code}` : void 0);
+            if (code === 0) coordinator.scheduler.markCompleted(jobId);
+            else coordinator.scheduler.markFailed(jobId, `exit code ${code}`);
+          });
+        }
+        return { pid: result.pid };
+      }
+    });
+    if (deduped) {
+      loop.iteration--;
+      loop.state = "idle";
+      logger.debug(`[LOOP] Enqueue deduped: ${loop.name} iteration ${iterationNum}`);
+    } else {
+      loop.activeJobId = job.id;
+      logger.debug(`[LOOP] Enqueued: ${loop.name} iteration ${iterationNum} job=${job.id}`);
+    }
+  }
+}
+async function writeLoopPromptFile(name, prompt, iteration) {
+  await mkdir(PROMPT_DIR, { recursive: true });
+  const filename = `loop-${name.replace(/[^a-zA-Z0-9-]/g, "_")}-${iteration}-${Date.now()}.md`;
+  const filepath = join$1(PROMPT_DIR, filename);
+  const content = [
+    `# Agent Loop: ${name}`,
+    `Iteration: ${iteration}`,
+    "",
+    prompt
+  ].join("\n");
+  await writeFile(filepath, content, "utf-8");
+  return filepath;
+}
+
+class GuardianSessionRegistry {
+  entries = /* @__PURE__ */ new Map();
+  /**
+   * Find an existing session to reuse.
+   * Tries loop key first, then project key.
+   */
+  resolve(input) {
+    if (input.loopId) {
+      const entry = this.entries.get(`loop:${input.loopId}`);
+      if (entry) {
+        logger.debug(`[GUARDIAN] Resolved session ${entry.sessionId} for loop:${input.loopId}`);
+        return entry.sessionId;
+      }
+    }
+    if (input.projectId) {
+      const entry = this.entries.get(`project:${input.projectId}`);
+      if (entry) {
+        logger.debug(`[GUARDIAN] Resolved session ${entry.sessionId} for project:${input.projectId}`);
+        return entry.sessionId;
+      }
+    }
+    return null;
+  }
+  /**
+   * Remember a session for future reuse.
+   * Stores under both loop and project keys if available.
+   */
+  remember(sessionId, input) {
+    const now = Date.now();
+    if (input.loopId) {
+      const key = `loop:${input.loopId}`;
+      this.entries.set(key, {
+        key,
+        sessionId,
+        loopId: input.loopId,
+        projectId: input.projectId,
+        updatedAt: now
+      });
+      logger.debug(`[GUARDIAN] Remembered ${sessionId} for ${key}`);
+    }
+    if (input.projectId) {
+      const key = `project:${input.projectId}`;
+      if (!this.entries.has(key)) {
+        this.entries.set(key, {
+          key,
+          sessionId,
+          projectId: input.projectId,
+          updatedAt: now
+        });
+        logger.debug(`[GUARDIAN] Remembered ${sessionId} for ${key}`);
+      }
+    }
+  }
+  /**
+   * Forget a specific session (e.g., after it exits).
+   */
+  forgetSession(sessionId) {
+    let removed = 0;
+    for (const [key, entry] of this.entries) {
+      if (entry.sessionId === sessionId) {
+        this.entries.delete(key);
+        removed++;
+      }
+    }
+    if (removed > 0) {
+      logger.debug(`[GUARDIAN] Forgot session ${sessionId} (${removed} entries)`);
+    }
+    return removed;
+  }
+  /**
+   * Forget all entries for a loop.
+   */
+  forgetLoop(loopId) {
+    return this.entries.delete(`loop:${loopId}`);
+  }
+  /**
+   * Get all entries (for observability).
+   */
+  getSnapshot() {
+    return [...this.entries.values()].sort((a, b) => b.updatedAt - a.updatedAt);
+  }
+  /**
+   * Number of tracked guardian entries.
+   */
+  get size() {
+    return this.entries.size;
+  }
+}
+
+class AutomationAuditStore {
+  maxEntries;
+  events = [];
+  nextId = 1;
+  constructor(options) {
+    this.maxEntries = options?.maxEntries ?? 500;
+  }
+  /**
+   * Record an audit event.
+   */
+  record(event) {
+    const entry = {
+      ...event,
+      id: this.nextId++,
+      timestamp: Date.now()
+    };
+    this.events.push(entry);
+    while (this.events.length > this.maxEntries) {
+      this.events.shift();
+    }
+    logger.debug(`[AUDIT] ${entry.kind}: ${entry.message ?? entry.dedupeKey ?? entry.jobId ?? ""}`);
+    return entry;
+  }
+  /**
+   * Query events with optional filters.
+   */
+  query(filter) {
+    const limit = filter?.limit ?? 50;
+    let results = this.events;
+    if (filter?.kind) {
+      results = results.filter((e) => e.kind === filter.kind);
+    }
+    if (filter?.loopId) {
+      results = results.filter((e) => e.loopId === filter.loopId);
+    }
+    if (filter?.since) {
+      results = results.filter((e) => e.timestamp >= filter.since);
+    }
+    return results.slice(-limit).reverse();
+  }
+  /**
+   * Summary counts by kind.
+   */
+  summarize() {
+    const counts = {
+      job_enqueued: 0,
+      job_dispatched: 0,
+      job_completed: 0,
+      job_failed: 0,
+      job_retried: 0,
+      loop_started: 0,
+      loop_blocked: 0,
+      loop_paused: 0
+    };
+    for (const event of this.events) {
+      counts[event.kind]++;
+    }
+    return counts;
+  }
+  /**
+   * Total number of stored events.
+   */
+  get size() {
+    return this.events.length;
+  }
+}
+
+class WebhookServer {
+  server = null;
+  port = 0;
+  onSessionStarted = null;
+  /**
+   * Start the HTTP server on a random available port.
+   */
+  async start() {
+    return new Promise((resolve, reject) => {
+      this.server = createServer((req, res) => this.handleRequest(req, res));
+      this.server.on("error", (err) => {
+        logger.debug(`[WEBHOOK-SERVER] Error: ${err.message}`);
+        reject(err);
+      });
+      this.server.listen(0, "127.0.0.1", () => {
+        const addr = this.server.address();
+        if (addr && typeof addr === "object") {
+          this.port = addr.port;
+          logger.debug(`[WEBHOOK-SERVER] Listening on 127.0.0.1:${this.port}`);
+          resolve(this.port);
+        } else {
+          reject(new Error("Failed to get server address"));
+        }
+      });
+    });
+  }
+  /**
+   * Set the callback for session-started events.
+   */
+  setSessionStartedHandler(handler) {
+    this.onSessionStarted = handler;
+  }
+  /**
+   * Get the port the server is listening on.
+   */
+  getPort() {
+    return this.port;
+  }
+  /**
+   * Stop the server.
+   */
+  shutdown() {
+    if (this.server) {
+      this.server.close();
+      this.server = null;
+      logger.debug("[WEBHOOK-SERVER] Shutdown");
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Internal
+  // -----------------------------------------------------------------------
+  handleRequest(req, res) {
+    if (req.method === "POST" && req.url === "/session-started") {
+      this.handleSessionStarted(req, res);
+      return;
+    }
+    if (req.method === "GET" && (req.url === "/" || req.url === "/health")) {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ status: "ok", port: this.port }));
+      return;
+    }
+    res.writeHead(404);
+    res.end("Not Found");
+  }
+  handleSessionStarted(req, res) {
+    let body = "";
+    req.on("data", (chunk) => {
+      body += chunk.toString();
+    });
+    req.on("end", () => {
+      try {
+        const parsed = JSON.parse(body);
+        if (!parsed.sessionId || typeof parsed.sessionId !== "string") {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "sessionId is required" }));
+          return;
+        }
+        const hostPid = typeof parsed.metadata?.hostPid === "number" ? parsed.metadata.hostPid : void 0;
+        logger.debug(`[WEBHOOK-SERVER] Session started: ${parsed.sessionId} (hostPid=${hostPid})`);
+        this.onSessionStarted?.(
+          parsed.sessionId,
+          parsed.metadata ?? {},
+          hostPid
+        );
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ status: "ok" }));
+      } catch (err) {
+        logger.debug(`[WEBHOOK-SERVER] Parse error: ${err}`);
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Invalid JSON" }));
+      }
+    });
+  }
+}
+
 function pidFilePath(homeDir) {
   return join(homeDir, "agent-daemon.pid");
 }
@@ -2787,9 +3339,36 @@ async function startDaemon(options) {
     agentVersion: version,
     workingDirectory: workDir
   });
-  const scheduler = new AutomationScheduler({ maxConcurrentJobs: 2 });
+  const auditStore = new AutomationAuditStore();
+  const scheduler = new AutomationScheduler({
+    maxConcurrentJobs: 2,
+    onAudit: (event) => auditStore.record(event)
+  });
+  const guardian = new GuardianSessionRegistry();
+  const loopCoordinator = new AgentLoopCoordinator(scheduler, config.serverUrl, creds.token, guardian);
+  enablePersistence(join(config.homeDir, "agent-tracked-sessions.json"));
+  const webhookServer = new WebhookServer();
+  const webhookPort = await webhookServer.start();
+  webhookServer.setSessionStartedHandler((sessionId, _metadata, hostPid) => {
+    if (hostPid) {
+      const tracked = getTrackedSession(hostPid);
+      if (tracked) {
+        tracked.happySessionId = sessionId;
+        logger.debug(`[DAEMON] Session ${sessionId} linked to PID ${hostPid}`);
+        if (tracked.automationContext?.kind === "agent_loop") {
+          guardian.remember(sessionId, {
+            loopId: tracked.automationContext.trigger?.split(":")[1],
+            projectId: tracked.automationContext.projectId
+          });
+        }
+      }
+    }
+  });
+  process.env.HAPPY_DAEMON_HTTP_PORT = String(webhookPort);
+  console.log(`Webhook server: 127.0.0.1:${webhookPort}`);
   client.setTailscaleInfo(fullTailscale);
-  client.enableAutomation(config.serverUrl, creds.token, scheduler);
+  client.enableAutomation(config.serverUrl, creds.token, scheduler, loopCoordinator, auditStore);
+  loopCoordinator.start();
   client.connect();
   writePidFile(config.homeDir, process.pid);
   console.log(`Daemon started (PID ${process.pid})`);
@@ -2800,6 +3379,8 @@ async function startDaemon(options) {
     logger.debug(`[DAEMON] Received ${signal}, shutting down...`);
     console.log(`
 Received ${signal}, shutting down...`);
+    webhookServer.shutdown();
+    loopCoordinator.shutdown();
     scheduler.shutdown();
     client.shutdown();
     removePidFile(config.homeDir);