@cleocode/core 2026.3.58 → 2026.3.60

package/dist/index.js

@@ -13159,9 +13159,9 @@ async function readSequenceFromDb(cwd, accessor) {
     return isValidSequenceState(value) ? value : null;
   }
   const { getDb: getDb3 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
-  const { eq: eq11 } = await import("drizzle-orm");
+  const { eq: eq12 } = await import("drizzle-orm");
   const db = await getDb3(cwd);
-  const rows = await db.select().from(schemaMeta).where(eq11(schemaMeta.key, SEQUENCE_META_KEY)).all();
+  const rows = await db.select().from(schemaMeta).where(eq12(schemaMeta.key, SEQUENCE_META_KEY)).all();
   const raw = rows[0]?.value;
   if (!raw) return null;
   try {
@@ -14207,7 +14207,7 @@ async function linkPipelineAdr(projectRoot, taskId) {
     return result;
   }
   const { getDb: getDb3 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
-  const { and: and8, eq: eq11 } = await import("drizzle-orm");
+  const { and: and9, eq: eq12 } = await import("drizzle-orm");
   const db = await getDb3(projectRoot);
   const now = (/* @__PURE__ */ new Date()).toISOString();
   for (const filePath of matchingFiles) {
@@ -14217,7 +14217,7 @@ async function linkPipelineAdr(projectRoot, taskId) {
       const fm = record2.frontmatter;
       const content = readFileSync5(filePath, "utf-8");
       const relativePath = `.cleo/adrs/${filename}`;
-      const existing = await db.select({ id: architectureDecisions.id }).from(architectureDecisions).where(eq11(architectureDecisions.id, record2.id)).all();
+      const existing = await db.select({ id: architectureDecisions.id }).from(architectureDecisions).where(eq12(architectureDecisions.id, record2.id)).all();
       const rowBase = {
         id: record2.id,
         title: record2.title,
@@ -14237,19 +14237,19 @@ async function linkPipelineAdr(projectRoot, taskId) {
         updatedAt: now
       };
       if (existing.length > 0) {
-        await db.update(architectureDecisions).set(rowBase).where(eq11(architectureDecisions.id, record2.id));
+        await db.update(architectureDecisions).set(rowBase).where(eq12(architectureDecisions.id, record2.id));
       } else {
         await db.insert(architectureDecisions).values({ ...rowBase, createdAt: now });
       }
       result.synced++;
-      await db.delete(adrTaskLinks).where(and8(eq11(adrTaskLinks.adrId, record2.id), eq11(adrTaskLinks.taskId, taskId)));
+      await db.delete(adrTaskLinks).where(and9(eq12(adrTaskLinks.adrId, record2.id), eq12(adrTaskLinks.taskId, taskId)));
       await db.insert(adrTaskLinks).values({ adrId: record2.id, taskId, linkType: "implements" });
       result.linked.push({ adrId: record2.id, taskId });
       if (fm["Related ADRs"]) {
         const relatedIds = fm["Related ADRs"].split(",").map((r) => r.trim()).filter((r) => /^ADR-\d+$/.test(r));
         for (const toId of relatedIds) {
           try {
-            const targetExists = await db.select({ id: architectureDecisions.id }).from(architectureDecisions).where(eq11(architectureDecisions.id, toId)).all();
+            const targetExists = await db.select({ id: architectureDecisions.id }).from(architectureDecisions).where(eq12(architectureDecisions.id, toId)).all();
             if (targetExists.length > 0) {
               await db.insert(adrRelations).values({ fromAdrId: record2.id, toAdrId: toId, relationType: "related" }).onConflictDoNothing();
             }
@@ -14272,248 +14272,8 @@ var init_link_pipeline = __esm({
   }
 });
 
-// packages/core/src/agents/registry.ts
-var registry_exports2 = {};
-__export(registry_exports2, {
-  checkAgentHealth: () => checkAgentHealth,
-  classifyError: () => classifyError,
-  deregisterAgent: () => deregisterAgent,
-  generateAgentId: () => generateAgentId,
-  getAgentErrorHistory: () => getAgentErrorHistory,
-  getAgentInstance: () => getAgentInstance,
-  getHealthReport: () => getHealthReport,
-  heartbeat: () => heartbeat,
-  incrementTasksCompleted: () => incrementTasksCompleted,
-  listAgentInstances: () => listAgentInstances,
-  markCrashed: () => markCrashed,
-  registerAgent: () => registerAgent,
-  updateAgentStatus: () => updateAgentStatus
-});
-import { randomBytes } from "node:crypto";
-import { and as and3, eq as eq5, inArray as inArray4, lt as lt2, sql as sql8 } from "drizzle-orm";
-function generateAgentId() {
-  const now = /* @__PURE__ */ new Date();
-  const ts = now.toISOString().replace(/[-:T]/g, "").substring(0, 14);
-  const hex = randomBytes(3).toString("hex");
-  return `agt_${ts}_${hex}`;
-}
-async function registerAgent(opts, cwd) {
-  const db = await getDb(cwd);
-  const id = generateAgentId();
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const row = {
-    id,
-    agentType: opts.agentType,
-    status: "starting",
-    sessionId: opts.sessionId ?? null,
-    taskId: opts.taskId ?? null,
-    startedAt: now,
-    lastHeartbeat: now,
-    stoppedAt: null,
-    errorCount: 0,
-    totalTasksCompleted: 0,
-    capacity: "1.0",
-    metadataJson: opts.metadata ? JSON.stringify(opts.metadata) : "{}",
-    parentAgentId: opts.parentAgentId ?? null
-  };
-  await db.insert(agentInstances).values(row);
-  return row;
-}
-async function deregisterAgent(id, cwd) {
-  const db = await getDb(cwd);
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const existing = await db.select().from(agentInstances).where(eq5(agentInstances.id, id)).get();
-  if (!existing) return null;
-  if (existing.status === "stopped") return existing;
-  await db.update(agentInstances).set({ status: "stopped", stoppedAt: now }).where(eq5(agentInstances.id, id));
-  return { ...existing, status: "stopped", stoppedAt: now };
-}
-async function heartbeat(id, cwd) {
-  const db = await getDb(cwd);
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const existing = await db.select().from(agentInstances).where(eq5(agentInstances.id, id)).get();
-  if (!existing) return null;
-  if (existing.status === "stopped" || existing.status === "crashed") {
-    return existing.status;
-  }
-  await db.update(agentInstances).set({ lastHeartbeat: now }).where(eq5(agentInstances.id, id));
-  return existing.status;
-}
-async function updateAgentStatus(id, opts, cwd) {
-  const db = await getDb(cwd);
-  const existing = await db.select().from(agentInstances).where(eq5(agentInstances.id, id)).get();
-  if (!existing) return null;
-  const updates = {
-    status: opts.status
-  };
-  if (opts.taskId !== void 0) {
-    updates.taskId = opts.taskId;
-  }
-  if (opts.status === "active") {
-    updates.lastHeartbeat = (/* @__PURE__ */ new Date()).toISOString();
-  }
-  if (opts.status === "error" || opts.status === "crashed") {
-    updates.errorCount = existing.errorCount + 1;
-    if (opts.error) {
-      const errorType = classifyError(new Error(opts.error));
-      await db.insert(agentErrorLog).values({
-        agentId: id,
-        errorType,
-        message: opts.error,
-        occurredAt: (/* @__PURE__ */ new Date()).toISOString()
-      });
-    }
-  }
-  if (opts.status === "stopped") {
-    updates.stoppedAt = (/* @__PURE__ */ new Date()).toISOString();
-  }
-  await db.update(agentInstances).set(updates).where(eq5(agentInstances.id, id));
-  return { ...existing, ...updates };
-}
-async function incrementTasksCompleted(id, cwd) {
-  const db = await getDb(cwd);
-  await db.update(agentInstances).set({ totalTasksCompleted: sql8`${agentInstances.totalTasksCompleted} + 1` }).where(eq5(agentInstances.id, id));
-}
-async function listAgentInstances(filters, cwd) {
-  const db = await getDb(cwd);
-  const conditions = [];
-  if (filters?.status) {
-    const statuses = Array.isArray(filters.status) ? filters.status : [filters.status];
-    conditions.push(inArray4(agentInstances.status, statuses));
-  }
-  if (filters?.agentType) {
-    const types = Array.isArray(filters.agentType) ? filters.agentType : [filters.agentType];
-    conditions.push(inArray4(agentInstances.agentType, types));
-  }
-  if (filters?.sessionId) {
-    conditions.push(eq5(agentInstances.sessionId, filters.sessionId));
-  }
-  if (filters?.parentAgentId) {
-    conditions.push(eq5(agentInstances.parentAgentId, filters.parentAgentId));
-  }
-  if (conditions.length === 0) {
-    return db.select().from(agentInstances).all();
-  }
-  return db.select().from(agentInstances).where(and3(...conditions)).all();
-}
-async function getAgentInstance(id, cwd) {
-  const db = await getDb(cwd);
-  const row = await db.select().from(agentInstances).where(eq5(agentInstances.id, id)).get();
-  return row ?? null;
-}
-function classifyError(error40) {
-  const message = error40 instanceof Error ? error40.message : String(error40);
-  for (const pattern of RETRIABLE_PATTERNS) {
-    if (pattern.test(message)) return "retriable";
-  }
-  for (const pattern of PERMANENT_PATTERNS) {
-    if (pattern.test(message)) return "permanent";
-  }
-  return "unknown";
-}
-async function getAgentErrorHistory(agentId, cwd) {
-  const db = await getDb(cwd);
-  return db.select().from(agentErrorLog).where(eq5(agentErrorLog.agentId, agentId)).all();
-}
-async function checkAgentHealth(thresholdMs = 3e4, cwd) {
-  const db = await getDb(cwd);
-  const cutoff = new Date(Date.now() - thresholdMs).toISOString();
-  return db.select().from(agentInstances).where(
-    and3(
-      inArray4(agentInstances.status, ["active", "idle", "starting"]),
-      lt2(agentInstances.lastHeartbeat, cutoff)
-    )
-  ).all();
-}
-async function markCrashed(id, reason, cwd) {
-  return updateAgentStatus(
-    id,
-    { status: "crashed", error: reason ?? "Heartbeat timeout \u2014 agent presumed crashed" },
-    cwd
-  );
-}
-async function getHealthReport(thresholdMs = 3e4, cwd) {
-  const allAgents = await listAgentInstances(void 0, cwd);
-  const staleAgents = await checkAgentHealth(thresholdMs, cwd);
-  const report = {
-    total: allAgents.length,
-    active: 0,
-    idle: 0,
-    starting: 0,
-    error: 0,
-    crashed: 0,
-    stopped: 0,
-    totalErrors: 0,
-    staleAgents
-  };
-  for (const agent of allAgents) {
-    switch (agent.status) {
-      case "active":
-        report.active++;
-        break;
-      case "idle":
-        report.idle++;
-        break;
-      case "starting":
-        report.starting++;
-        break;
-      case "error":
-        report.error++;
-        break;
-      case "crashed":
-        report.crashed++;
-        break;
-      case "stopped":
-        report.stopped++;
-        break;
-    }
-    report.totalErrors += agent.errorCount;
-  }
-  return report;
-}
-var RETRIABLE_PATTERNS, PERMANENT_PATTERNS;
-var init_registry2 = __esm({
-  "packages/core/src/agents/registry.ts"() {
-    "use strict";
-    init_sqlite2();
-    init_agent_schema();
-    RETRIABLE_PATTERNS = [
-      /timeout/i,
-      /ECONNREFUSED/,
-      /ECONNRESET/,
-      /EPIPE/,
-      /ETIMEDOUT/,
-      /rate.?limit/i,
-      /429/,
-      /503/,
-      /502/,
-      /SQLITE_BUSY/i,
-      /database is locked/i,
-      /temporarily unavailable/i,
-      /too many requests/i,
-      /network/i,
-      /socket hang up/i
-    ];
-    PERMANENT_PATTERNS = [
-      /permission denied/i,
-      /EACCES/,
-      /authentication/i,
-      /unauthorized/i,
-      /401/,
-      /403/,
-      /404/,
-      /not found/i,
-      /invalid.*token/i,
-      /SQLITE_CONSTRAINT/i,
-      /syntax error/i,
-      /type error/i,
-      /reference error/i
-    ];
-  }
-});
-
 // packages/core/src/store/brain-accessor.ts
-import { and as and4, asc as asc2, desc as desc2, eq as eq7, gte as gte2, or as or3 } from "drizzle-orm";
+import { and as and3, asc as asc2, desc as desc2, eq as eq5, gte as gte2, or as or3 } from "drizzle-orm";
 async function getBrainAccessor(cwd) {
   const db = await getBrainDb(cwd);
   return new BrainDataAccessor(db);
@@ -14533,30 +14293,30 @@ var init_brain_accessor = __esm({
       // =========================================================================
       async addDecision(row) {
         await this.db.insert(brainDecisions).values(row);
-        const result = await this.db.select().from(brainDecisions).where(eq7(brainDecisions.id, row.id));
+        const result = await this.db.select().from(brainDecisions).where(eq5(brainDecisions.id, row.id));
         return result[0];
       }
       async getDecision(id) {
-        const result = await this.db.select().from(brainDecisions).where(eq7(brainDecisions.id, id));
+        const result = await this.db.select().from(brainDecisions).where(eq5(brainDecisions.id, id));
         return result[0] ?? null;
       }
       async findDecisions(params = {}) {
         const conditions = [];
         if (params.type) {
-          conditions.push(eq7(brainDecisions.type, params.type));
+          conditions.push(eq5(brainDecisions.type, params.type));
         }
         if (params.confidence) {
-          conditions.push(eq7(brainDecisions.confidence, params.confidence));
+          conditions.push(eq5(brainDecisions.confidence, params.confidence));
         }
         if (params.outcome) {
-          conditions.push(eq7(brainDecisions.outcome, params.outcome));
+          conditions.push(eq5(brainDecisions.outcome, params.outcome));
         }
         if (params.contextTaskId) {
-          conditions.push(eq7(brainDecisions.contextTaskId, params.contextTaskId));
+          conditions.push(eq5(brainDecisions.contextTaskId, params.contextTaskId));
         }
         let query = this.db.select().from(brainDecisions).orderBy(desc2(brainDecisions.createdAt));
         if (conditions.length > 0) {
-          query = query.where(and4(...conditions));
+          query = query.where(and3(...conditions));
         }
         if (params.limit) {
           query = query.limit(params.limit);
@@ -14564,34 +14324,34 @@ var init_brain_accessor = __esm({
         return query;
       }
       async updateDecision(id, updates) {
-        await this.db.update(brainDecisions).set({ ...updates, updatedAt: (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19) }).where(eq7(brainDecisions.id, id));
+        await this.db.update(brainDecisions).set({ ...updates, updatedAt: (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19) }).where(eq5(brainDecisions.id, id));
       }
       // =========================================================================
       // Patterns CRUD
       // =========================================================================
       async addPattern(row) {
         await this.db.insert(brainPatterns).values(row);
-        const result = await this.db.select().from(brainPatterns).where(eq7(brainPatterns.id, row.id));
+        const result = await this.db.select().from(brainPatterns).where(eq5(brainPatterns.id, row.id));
         return result[0];
       }
       async getPattern(id) {
-        const result = await this.db.select().from(brainPatterns).where(eq7(brainPatterns.id, id));
+        const result = await this.db.select().from(brainPatterns).where(eq5(brainPatterns.id, id));
         return result[0] ?? null;
       }
       async findPatterns(params = {}) {
         const conditions = [];
         if (params.type) {
-          conditions.push(eq7(brainPatterns.type, params.type));
+          conditions.push(eq5(brainPatterns.type, params.type));
         }
         if (params.impact) {
-          conditions.push(eq7(brainPatterns.impact, params.impact));
+          conditions.push(eq5(brainPatterns.impact, params.impact));
         }
         if (params.minFrequency !== void 0) {
           conditions.push(gte2(brainPatterns.frequency, params.minFrequency));
         }
         let query = this.db.select().from(brainPatterns).orderBy(desc2(brainPatterns.frequency));
         if (conditions.length > 0) {
-          query = query.where(and4(...conditions));
+          query = query.where(and3(...conditions));
         }
         if (params.limit) {
           query = query.limit(params.limit);
@@ -14599,18 +14359,18 @@ var init_brain_accessor = __esm({
         return query;
       }
       async updatePattern(id, updates) {
-        await this.db.update(brainPatterns).set({ ...updates, updatedAt: (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19) }).where(eq7(brainPatterns.id, id));
+        await this.db.update(brainPatterns).set({ ...updates, updatedAt: (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19) }).where(eq5(brainPatterns.id, id));
       }
       // =========================================================================
       // Learnings CRUD
       // =========================================================================
       async addLearning(row) {
         await this.db.insert(brainLearnings).values(row);
-        const result = await this.db.select().from(brainLearnings).where(eq7(brainLearnings.id, row.id));
+        const result = await this.db.select().from(brainLearnings).where(eq5(brainLearnings.id, row.id));
         return result[0];
       }
       async getLearning(id) {
-        const result = await this.db.select().from(brainLearnings).where(eq7(brainLearnings.id, id));
+        const result = await this.db.select().from(brainLearnings).where(eq5(brainLearnings.id, id));
         return result[0] ?? null;
       }
       async findLearnings(params = {}) {
@@ -14619,11 +14379,11 @@ var init_brain_accessor = __esm({
           conditions.push(gte2(brainLearnings.confidence, params.minConfidence));
         }
         if (params.actionable !== void 0) {
-          conditions.push(eq7(brainLearnings.actionable, params.actionable));
+          conditions.push(eq5(brainLearnings.actionable, params.actionable));
         }
         let query = this.db.select().from(brainLearnings).orderBy(desc2(brainLearnings.confidence));
         if (conditions.length > 0) {
-          query = query.where(and4(...conditions));
+          query = query.where(and3(...conditions));
         }
         if (params.limit) {
           query = query.limit(params.limit);
@@ -14631,37 +14391,37 @@ var init_brain_accessor = __esm({
         return query;
       }
       async updateLearning(id, updates) {
-        await this.db.update(brainLearnings).set({ ...updates, updatedAt: (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19) }).where(eq7(brainLearnings.id, id));
+        await this.db.update(brainLearnings).set({ ...updates, updatedAt: (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19) }).where(eq5(brainLearnings.id, id));
       }
       // =========================================================================
       // Observations CRUD
       // =========================================================================
       async addObservation(row) {
         await this.db.insert(brainObservations).values(row);
-        const result = await this.db.select().from(brainObservations).where(eq7(brainObservations.id, row.id));
+        const result = await this.db.select().from(brainObservations).where(eq5(brainObservations.id, row.id));
         return result[0];
       }
       async getObservation(id) {
-        const result = await this.db.select().from(brainObservations).where(eq7(brainObservations.id, id));
+        const result = await this.db.select().from(brainObservations).where(eq5(brainObservations.id, id));
         return result[0] ?? null;
       }
       async findObservations(params = {}) {
         const conditions = [];
         if (params.type) {
-          conditions.push(eq7(brainObservations.type, params.type));
+          conditions.push(eq5(brainObservations.type, params.type));
         }
         if (params.project) {
-          conditions.push(eq7(brainObservations.project, params.project));
+          conditions.push(eq5(brainObservations.project, params.project));
         }
         if (params.sourceType) {
-          conditions.push(eq7(brainObservations.sourceType, params.sourceType));
+          conditions.push(eq5(brainObservations.sourceType, params.sourceType));
         }
         if (params.sourceSessionId) {
-          conditions.push(eq7(brainObservations.sourceSessionId, params.sourceSessionId));
+          conditions.push(eq5(brainObservations.sourceSessionId, params.sourceSessionId));
         }
         let query = this.db.select().from(brainObservations).orderBy(desc2(brainObservations.createdAt));
         if (conditions.length > 0) {
-          query = query.where(and4(...conditions));
+          query = query.where(and3(...conditions));
         }
         if (params.limit) {
           query = query.limit(params.limit);
@@ -14669,7 +14429,7 @@ var init_brain_accessor = __esm({
         return query;
       }
       async updateObservation(id, updates) {
-        await this.db.update(brainObservations).set({ ...updates, updatedAt: (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19) }).where(eq7(brainObservations.id, id));
+        await this.db.update(brainObservations).set({ ...updates, updatedAt: (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19) }).where(eq5(brainObservations.id, id));
       }
       // =========================================================================
       // Memory Links CRUD
@@ -14679,22 +14439,22 @@ var init_brain_accessor = __esm({
       }
       async getLinksForMemory(memoryType, memoryId) {
         return this.db.select().from(brainMemoryLinks).where(
-          and4(
-            eq7(brainMemoryLinks.memoryType, memoryType),
-            eq7(brainMemoryLinks.memoryId, memoryId)
+          and3(
+            eq5(brainMemoryLinks.memoryType, memoryType),
+            eq5(brainMemoryLinks.memoryId, memoryId)
           )
         ).orderBy(asc2(brainMemoryLinks.createdAt));
       }
       async getLinksForTask(taskId) {
-        return this.db.select().from(brainMemoryLinks).where(eq7(brainMemoryLinks.taskId, taskId)).orderBy(asc2(brainMemoryLinks.createdAt));
+        return this.db.select().from(brainMemoryLinks).where(eq5(brainMemoryLinks.taskId, taskId)).orderBy(asc2(brainMemoryLinks.createdAt));
       }
       async removeLink(memoryType, memoryId, taskId, linkType) {
         await this.db.delete(brainMemoryLinks).where(
-          and4(
-            eq7(brainMemoryLinks.memoryType, memoryType),
-            eq7(brainMemoryLinks.memoryId, memoryId),
-            eq7(brainMemoryLinks.taskId, taskId),
-            eq7(brainMemoryLinks.linkType, linkType)
+          and3(
+            eq5(brainMemoryLinks.memoryType, memoryType),
+            eq5(brainMemoryLinks.memoryId, memoryId),
+            eq5(brainMemoryLinks.taskId, taskId),
+            eq5(brainMemoryLinks.linkType, linkType)
           )
         );
       }
@@ -14703,27 +14463,27 @@ var init_brain_accessor = __esm({
       // =========================================================================
       async addStickyNote(row) {
         await this.db.insert(brainStickyNotes).values(row);
-        const result = await this.db.select().from(brainStickyNotes).where(eq7(brainStickyNotes.id, row.id));
+        const result = await this.db.select().from(brainStickyNotes).where(eq5(brainStickyNotes.id, row.id));
         return result[0];
       }
       async getStickyNote(id) {
-        const result = await this.db.select().from(brainStickyNotes).where(eq7(brainStickyNotes.id, id));
+        const result = await this.db.select().from(brainStickyNotes).where(eq5(brainStickyNotes.id, id));
         return result[0] ?? null;
       }
       async findStickyNotes(params = {}) {
         const conditions = [];
         if (params.status) {
-          conditions.push(eq7(brainStickyNotes.status, params.status));
+          conditions.push(eq5(brainStickyNotes.status, params.status));
         }
         if (params.color) {
-          conditions.push(eq7(brainStickyNotes.color, params.color));
+          conditions.push(eq5(brainStickyNotes.color, params.color));
         }
         if (params.priority) {
-          conditions.push(eq7(brainStickyNotes.priority, params.priority));
+          conditions.push(eq5(brainStickyNotes.priority, params.priority));
         }
         let query = this.db.select().from(brainStickyNotes).orderBy(desc2(brainStickyNotes.createdAt));
         if (conditions.length > 0) {
-          query = query.where(and4(...conditions));
+          query = query.where(and3(...conditions));
         }
         if (params.limit) {
           query = query.limit(params.limit);
@@ -14731,31 +14491,31 @@ var init_brain_accessor = __esm({
         return query;
       }
       async updateStickyNote(id, updates) {
-        await this.db.update(brainStickyNotes).set({ ...updates, updatedAt: (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19) }).where(eq7(brainStickyNotes.id, id));
+        await this.db.update(brainStickyNotes).set({ ...updates, updatedAt: (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19) }).where(eq5(brainStickyNotes.id, id));
       }
       async deleteStickyNote(id) {
-        await this.db.delete(brainStickyNotes).where(eq7(brainStickyNotes.id, id));
+        await this.db.delete(brainStickyNotes).where(eq5(brainStickyNotes.id, id));
       }
       // =========================================================================
       // PageIndex Node CRUD (T5383)
       // =========================================================================
       async addPageNode(node) {
         await this.db.insert(brainPageNodes).values(node);
-        const result = await this.db.select().from(brainPageNodes).where(eq7(brainPageNodes.id, node.id));
+        const result = await this.db.select().from(brainPageNodes).where(eq5(brainPageNodes.id, node.id));
         return result[0];
       }
       async getPageNode(id) {
-        const result = await this.db.select().from(brainPageNodes).where(eq7(brainPageNodes.id, id));
+        const result = await this.db.select().from(brainPageNodes).where(eq5(brainPageNodes.id, id));
         return result[0] ?? null;
       }
       async findPageNodes(params = {}) {
         const conditions = [];
         if (params.nodeType) {
-          conditions.push(eq7(brainPageNodes.nodeType, params.nodeType));
+          conditions.push(eq5(brainPageNodes.nodeType, params.nodeType));
         }
         let query = this.db.select().from(brainPageNodes).orderBy(desc2(brainPageNodes.createdAt));
         if (conditions.length > 0) {
-          query = query.where(and4(...conditions));
+          query = query.where(and3(...conditions));
         }
         if (params.limit) {
           query = query.limit(params.limit);
@@ -14764,9 +14524,9 @@ var init_brain_accessor = __esm({
       }
       async removePageNode(id) {
         await this.db.delete(brainPageEdges).where(
-          or3(eq7(brainPageEdges.fromId, id), eq7(brainPageEdges.toId, id))
+          or3(eq5(brainPageEdges.fromId, id), eq5(brainPageEdges.toId, id))
         );
-        await this.db.delete(brainPageNodes).where(eq7(brainPageNodes.id, id));
+        await this.db.delete(brainPageNodes).where(eq5(brainPageNodes.id, id));
       }
       // =========================================================================
       // PageIndex Edge CRUD (T5383)
@@ -14774,34 +14534,34 @@ var init_brain_accessor = __esm({
       async addPageEdge(edge) {
         await this.db.insert(brainPageEdges).values(edge);
         const result = await this.db.select().from(brainPageEdges).where(
-          and4(
-            eq7(brainPageEdges.fromId, edge.fromId),
-            eq7(brainPageEdges.toId, edge.toId),
-            eq7(brainPageEdges.edgeType, edge.edgeType)
+          and3(
+            eq5(brainPageEdges.fromId, edge.fromId),
+            eq5(brainPageEdges.toId, edge.toId),
+            eq5(brainPageEdges.edgeType, edge.edgeType)
           )
         );
         return result[0];
       }
       async getPageEdges(nodeId, direction = "both") {
         if (direction === "out") {
-          return this.db.select().from(brainPageEdges).where(eq7(brainPageEdges.fromId, nodeId)).orderBy(asc2(brainPageEdges.createdAt));
+          return this.db.select().from(brainPageEdges).where(eq5(brainPageEdges.fromId, nodeId)).orderBy(asc2(brainPageEdges.createdAt));
         }
         if (direction === "in") {
-          return this.db.select().from(brainPageEdges).where(eq7(brainPageEdges.toId, nodeId)).orderBy(asc2(brainPageEdges.createdAt));
+          return this.db.select().from(brainPageEdges).where(eq5(brainPageEdges.toId, nodeId)).orderBy(asc2(brainPageEdges.createdAt));
         }
         return this.db.select().from(brainPageEdges).where(
           or3(
-            eq7(brainPageEdges.fromId, nodeId),
-            eq7(brainPageEdges.toId, nodeId)
+            eq5(brainPageEdges.fromId, nodeId),
+            eq5(brainPageEdges.toId, nodeId)
           )
         ).orderBy(asc2(brainPageEdges.createdAt));
       }
       async getNeighbors(nodeId, edgeType) {
-        const conditions = [eq7(brainPageEdges.fromId, nodeId)];
+        const conditions = [eq5(brainPageEdges.fromId, nodeId)];
         if (edgeType) {
-          conditions.push(eq7(brainPageEdges.edgeType, edgeType));
+          conditions.push(eq5(brainPageEdges.edgeType, edgeType));
         }
-        const edges = await this.db.select().from(brainPageEdges).where(and4(...conditions));
+        const edges = await this.db.select().from(brainPageEdges).where(and3(...conditions));
         if (edges.length === 0) return [];
         const neighborIds = edges.map((e) => e.toId);
         const nodes = [];
@@ -14813,10 +14573,10 @@ var init_brain_accessor = __esm({
       }
       async removePageEdge(fromId, toId, edgeType) {
         await this.db.delete(brainPageEdges).where(
-          and4(
-            eq7(brainPageEdges.fromId, fromId),
-            eq7(brainPageEdges.toId, toId),
-            eq7(brainPageEdges.edgeType, edgeType)
+          and3(
+            eq5(brainPageEdges.fromId, fromId),
+            eq5(brainPageEdges.toId, toId),
+            eq5(brainPageEdges.edgeType, edgeType)
           )
         );
       }
@@ -14824,6 +14584,246 @@ var init_brain_accessor = __esm({
   }
 });
 
+// packages/core/src/agents/registry.ts
+var registry_exports2 = {};
+__export(registry_exports2, {
+  checkAgentHealth: () => checkAgentHealth,
+  classifyError: () => classifyError,
+  deregisterAgent: () => deregisterAgent,
+  generateAgentId: () => generateAgentId,
+  getAgentErrorHistory: () => getAgentErrorHistory,
+  getAgentInstance: () => getAgentInstance,
+  getHealthReport: () => getHealthReport,
+  heartbeat: () => heartbeat,
+  incrementTasksCompleted: () => incrementTasksCompleted,
+  listAgentInstances: () => listAgentInstances,
+  markCrashed: () => markCrashed,
+  registerAgent: () => registerAgent,
+  updateAgentStatus: () => updateAgentStatus
+});
+import { randomBytes as randomBytes2 } from "node:crypto";
+import { and as and4, eq as eq6, inArray as inArray4, lt as lt2, sql as sql8 } from "drizzle-orm";
+function generateAgentId() {
+  const now = /* @__PURE__ */ new Date();
+  const ts = now.toISOString().replace(/[-:T]/g, "").substring(0, 14);
+  const hex = randomBytes2(3).toString("hex");
+  return `agt_${ts}_${hex}`;
+}
+async function registerAgent(opts, cwd) {
+  const db = await getDb(cwd);
+  const id = generateAgentId();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const row = {
+    id,
+    agentType: opts.agentType,
+    status: "starting",
+    sessionId: opts.sessionId ?? null,
+    taskId: opts.taskId ?? null,
+    startedAt: now,
+    lastHeartbeat: now,
+    stoppedAt: null,
+    errorCount: 0,
+    totalTasksCompleted: 0,
+    capacity: "1.0",
+    metadataJson: opts.metadata ? JSON.stringify(opts.metadata) : "{}",
+    parentAgentId: opts.parentAgentId ?? null
+  };
+  await db.insert(agentInstances).values(row);
+  return row;
+}
+async function deregisterAgent(id, cwd) {
+  const db = await getDb(cwd);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const existing = await db.select().from(agentInstances).where(eq6(agentInstances.id, id)).get();
+  if (!existing) return null;
+  if (existing.status === "stopped") return existing;
+  await db.update(agentInstances).set({ status: "stopped", stoppedAt: now }).where(eq6(agentInstances.id, id));
+  return { ...existing, status: "stopped", stoppedAt: now };
+}
+async function heartbeat(id, cwd) {
+  const db = await getDb(cwd);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const existing = await db.select().from(agentInstances).where(eq6(agentInstances.id, id)).get();
+  if (!existing) return null;
+  if (existing.status === "stopped" || existing.status === "crashed") {
+    return existing.status;
+  }
+  await db.update(agentInstances).set({ lastHeartbeat: now }).where(eq6(agentInstances.id, id));
+  return existing.status;
+}
+async function updateAgentStatus(id, opts, cwd) {
+  const db = await getDb(cwd);
+  const existing = await db.select().from(agentInstances).where(eq6(agentInstances.id, id)).get();
+  if (!existing) return null;
+  const updates = {
+    status: opts.status
+  };
+  if (opts.taskId !== void 0) {
+    updates.taskId = opts.taskId;
+  }
+  if (opts.status === "active") {
+    updates.lastHeartbeat = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  if (opts.status === "error" || opts.status === "crashed") {
+    updates.errorCount = existing.errorCount + 1;
+    if (opts.error) {
+      const errorType = classifyError(new Error(opts.error));
+      await db.insert(agentErrorLog).values({
+        agentId: id,
+        errorType,
+        message: opts.error,
+        occurredAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+  }
+  if (opts.status === "stopped") {
+    updates.stoppedAt = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  await db.update(agentInstances).set(updates).where(eq6(agentInstances.id, id));
+  return { ...existing, ...updates };
+}
+async function incrementTasksCompleted(id, cwd) {
+  const db = await getDb(cwd);
+  await db.update(agentInstances).set({ totalTasksCompleted: sql8`${agentInstances.totalTasksCompleted} + 1` }).where(eq6(agentInstances.id, id));
+}
+async function listAgentInstances(filters, cwd) {
+  const db = await getDb(cwd);
+  const conditions = [];
+  if (filters?.status) {
+    const statuses = Array.isArray(filters.status) ? filters.status : [filters.status];
+    conditions.push(inArray4(agentInstances.status, statuses));
+  }
+  if (filters?.agentType) {
+    const types = Array.isArray(filters.agentType) ? filters.agentType : [filters.agentType];
+    conditions.push(inArray4(agentInstances.agentType, types));
+  }
+  if (filters?.sessionId) {
+    conditions.push(eq6(agentInstances.sessionId, filters.sessionId));
+  }
+  if (filters?.parentAgentId) {
+    conditions.push(eq6(agentInstances.parentAgentId, filters.parentAgentId));
+  }
+  if (conditions.length === 0) {
+    return db.select().from(agentInstances).all();
+  }
+  return db.select().from(agentInstances).where(and4(...conditions)).all();
+}
+async function getAgentInstance(id, cwd) {
+  const db = await getDb(cwd);
+  const row = await db.select().from(agentInstances).where(eq6(agentInstances.id, id)).get();
+  return row ?? null;
+}
+function classifyError(error40) {
+  const message = error40 instanceof Error ? error40.message : String(error40);
+  for (const pattern of RETRIABLE_PATTERNS) {
+    if (pattern.test(message)) return "retriable";
+  }
+  for (const pattern of PERMANENT_PATTERNS) {
+    if (pattern.test(message)) return "permanent";
+  }
+  return "unknown";
+}
+async function getAgentErrorHistory(agentId, cwd) {
+  const db = await getDb(cwd);
+  return db.select().from(agentErrorLog).where(eq6(agentErrorLog.agentId, agentId)).all();
+}
+async function checkAgentHealth(thresholdMs = 3e4, cwd) {
+  const db = await getDb(cwd);
+  const cutoff = new Date(Date.now() - thresholdMs).toISOString();
+  return db.select().from(agentInstances).where(
+    and4(
+      inArray4(agentInstances.status, ["active", "idle", "starting"]),
+      lt2(agentInstances.lastHeartbeat, cutoff)
+    )
+  ).all();
+}
+async function markCrashed(id, reason, cwd) {
+  return updateAgentStatus(
+    id,
+    { status: "crashed", error: reason ?? "Heartbeat timeout \u2014 agent presumed crashed" },
+    cwd
+  );
+}
+async function getHealthReport(thresholdMs = 3e4, cwd) {
+  const allAgents = await listAgentInstances(void 0, cwd);
+  const staleAgents = await checkAgentHealth(thresholdMs, cwd);
+  const report = {
+    total: allAgents.length,
+    active: 0,
+    idle: 0,
+    starting: 0,
+    error: 0,
+    crashed: 0,
+    stopped: 0,
+    totalErrors: 0,
+    staleAgents
+  };
+  for (const agent of allAgents) {
+    switch (agent.status) {
+      case "active":
+        report.active++;
+        break;
+      case "idle":
+        report.idle++;
+        break;
+      case "starting":
+        report.starting++;
+        break;
+      case "error":
+        report.error++;
+        break;
+      case "crashed":
+        report.crashed++;
+        break;
+      case "stopped":
+        report.stopped++;
+        break;
+    }
+    report.totalErrors += agent.errorCount;
+  }
+  return report;
+}
+var RETRIABLE_PATTERNS, PERMANENT_PATTERNS;
+var init_registry2 = __esm({
+  "packages/core/src/agents/registry.ts"() {
+    "use strict";
+    init_sqlite2();
+    init_agent_schema();
+    RETRIABLE_PATTERNS = [
+      /timeout/i,
+      /ECONNREFUSED/,
+      /ECONNRESET/,
+      /EPIPE/,
+      /ETIMEDOUT/,
+      /rate.?limit/i,
+      /429/,
+      /503/,
+      /502/,
+      /SQLITE_BUSY/i,
+      /database is locked/i,
+      /temporarily unavailable/i,
+      /too many requests/i,
+      /network/i,
+      /socket hang up/i
+    ];
+    PERMANENT_PATTERNS = [
+      /permission denied/i,
+      /EACCES/,
+      /authentication/i,
+      /unauthorized/i,
+      /401/,
+      /403/,
+      /404/,
+      /not found/i,
+      /invalid.*token/i,
+      /SQLITE_CONSTRAINT/i,
+      /syntax error/i,
+      /type error/i,
+      /reference error/i
+    ];
+  }
+});
+
 // packages/core/src/store/project-detect.ts
 var project_detect_exports = {};
 __export(project_detect_exports, {
@@ -17866,19 +17866,19 @@ async function queryAudit(options) {
   try {
     const { getDb: getDb3 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
     const { auditLog: auditLog2 } = await Promise.resolve().then(() => (init_tasks_schema(), tasks_schema_exports));
-    const { and: and8, eq: eq11, gte: gte3, or: or4 } = await import("drizzle-orm");
+    const { and: and9, eq: eq12, gte: gte3, or: or4 } = await import("drizzle-orm");
     const db = await getDb3(process.cwd());
     const conditions = [];
-    if (options?.sessionId) conditions.push(eq11(auditLog2.sessionId, options.sessionId));
-    if (options?.domain) conditions.push(eq11(auditLog2.domain, options.domain));
+    if (options?.sessionId) conditions.push(eq12(auditLog2.sessionId, options.sessionId));
+    if (options?.domain) conditions.push(eq12(auditLog2.domain, options.domain));
     if (options?.operation)
       conditions.push(
-        or4(eq11(auditLog2.operation, options.operation), eq11(auditLog2.action, options.operation))
+        or4(eq12(auditLog2.operation, options.operation), eq12(auditLog2.action, options.operation))
       );
-    if (options?.taskId) conditions.push(eq11(auditLog2.taskId, options.taskId));
+    if (options?.taskId) conditions.push(eq12(auditLog2.taskId, options.taskId));
     if (options?.since) conditions.push(gte3(auditLog2.timestamp, options.since));
     const limit = options?.limit ?? 1e3;
-    const rows = await db.select().from(auditLog2).where(conditions.length > 0 ? and8(...conditions) : void 0).orderBy(auditLog2.timestamp).limit(limit);
+    const rows = await db.select().from(auditLog2).where(conditions.length > 0 ? and9(...conditions) : void 0).orderBy(auditLog2.timestamp).limit(limit);
     return rows.map((row) => ({
       timestamp: row.timestamp,
       sessionId: row.sessionId,
@@ -19102,6 +19102,7 @@ import { execFile as execFile3 } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { existsSync as existsSync33, constants as fsConstants3, readFileSync as readFileSync22, statSync as statSync8 } from "node:fs";
 import { access as access3, mkdir as mkdir5, readFile as readFile6, rm as rm2, writeFile as writeFile5 } from "node:fs/promises";
+import { homedir as getHomedir } from "node:os";
 import { dirname as dirname8, join as join37, resolve as resolve5 } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 import { promisify as promisify3 } from "node:util";
@@ -19913,12 +19914,30 @@ function checkGlobalTemplates() {
       fix: "cleo init (or restart MCP server)"
     };
   }
+  const xdgContent = readFileSync22(injectionPath, "utf-8");
+  const xdgVersion = xdgContent.match(/^Version:\s*(.+)$/m)?.[1]?.trim();
+  const home = getHomedir();
+  const legacyPath = join37(home, ".cleo", "templates", "CLEO-INJECTION.md");
+  if (existsSync33(legacyPath)) {
+    const legacyContent = readFileSync22(legacyPath, "utf-8");
+    const legacyVersion = legacyContent.match(/^Version:\s*(.+)$/m)?.[1]?.trim();
+    if (legacyVersion && xdgVersion && legacyVersion !== xdgVersion) {
+      return {
+        id: "global_templates",
+        category: "global",
+        status: "warning",
+        message: `Legacy template version (${legacyVersion}) out of sync with XDG (${xdgVersion})`,
+        details: { path: injectionPath, exists: true, xdgVersion, legacyVersion, legacyPath },
+        fix: "npm install -g @cleocode/cleo (reinstall syncs both paths)"
+      };
+    }
+  }
   return {
     id: "global_templates",
     category: "global",
     status: "passed",
-    message: "Global injection template present",
-    details: { path: injectionPath, exists: true },
+    message: `Global injection template present (v${xdgVersion ?? "unknown"})`,
+    details: { path: injectionPath, exists: true, version: xdgVersion },
     fix: null
   };
 }
@@ -20061,8 +20080,8 @@ function detectEnvMode() {
     const devKv = {};
     const devLines = devContent.trim().split("\n");
     for (let i = 1; i < devLines.length; i++) {
-      const eq11 = devLines[i].indexOf("=");
-      if (eq11 > 0) devKv[devLines[i].slice(0, eq11).trim()] = devLines[i].slice(eq11 + 1).trim();
+      const eq12 = devLines[i].indexOf("=");
+      if (eq12 > 0) devKv[devLines[i].slice(0, eq12).trim()] = devLines[i].slice(eq12 + 1).trim();
     }
     if (devKv["mode"] === "dev-ts" && devKv["source"]) {
       const devSource = devKv["source"].replace(/\\/g, "/");
@@ -20375,7 +20394,7 @@ var init_config = __esm({
           "session.autoStart": false,
           "session.requireNotes": true,
           "session.multiSession": false,
-          "hierarchy.requireAcceptanceCriteria": true,
+          "enforcement.acceptance.mode": "block",
           "lifecycle.mode": "strict"
         }
       },
@@ -20385,7 +20404,7 @@ var init_config = __esm({
           "session.autoStart": false,
           "session.requireNotes": false,
           "session.multiSession": true,
-          "hierarchy.requireAcceptanceCriteria": false,
+          "enforcement.acceptance.mode": "warn",
           "lifecycle.mode": "advisory"
         }
       },
@@ -20395,7 +20414,7 @@ var init_config = __esm({
           "session.autoStart": false,
           "session.requireNotes": false,
           "session.multiSession": true,
-          "hierarchy.requireAcceptanceCriteria": false,
+          "enforcement.acceptance.mode": "off",
           "lifecycle.mode": "off"
         }
       }
@@ -20774,13 +20793,13 @@ __export(pipeline_exports, {
   listPipelines: () => listPipelines,
   pipelineExists: () => pipelineExists
 });
-import { and as and5, asc as asc3, desc as desc3, eq as eq8, sql as sql9 } from "drizzle-orm";
+import { and as and6, asc as asc3, desc as desc3, eq as eq9, sql as sql9 } from "drizzle-orm";
 async function initializePipeline(taskId, options = {}) {
   const db = await getDb();
   const now = /* @__PURE__ */ new Date();
   const startStage2 = options.startStage || "research";
   const initialStatus = options.initialStatus || "active";
-  const existing = await db.select().from(lifecyclePipelines).where(eq8(lifecyclePipelines.taskId, taskId)).limit(1).all();
+  const existing = await db.select().from(lifecyclePipelines).where(eq9(lifecyclePipelines.taskId, taskId)).limit(1).all();
   if (existing.length > 0) {
     throw new CleoError(101 /* ALREADY_EXISTS */, `Pipeline already exists for task ${taskId}`);
   }
@@ -20829,13 +20848,13 @@ async function initializePipeline(taskId, options = {}) {
 }
 async function getPipeline(taskId) {
   const db = await getDb();
-  const result = await db.select().from(lifecyclePipelines).where(eq8(lifecyclePipelines.taskId, taskId)).limit(1).all();
+  const result = await db.select().from(lifecyclePipelines).where(eq9(lifecyclePipelines.taskId, taskId)).limit(1).all();
   if (result.length === 0) {
     return null;
   }
   const row = result[0];
   const isActive = row.status === "active";
-  const transitionResult = await db.select({ count: sql9`count(*)` }).from(lifecycleTransitions).where(eq8(lifecycleTransitions.pipelineId, row.id)).all();
+  const transitionResult = await db.select({ count: sql9`count(*)` }).from(lifecycleTransitions).where(eq9(lifecycleTransitions.pipelineId, row.id)).all();
   const transitionCount = Number(transitionResult[0]?.count || 0);
   return {
     id: taskId,
@@ -20858,7 +20877,7 @@ async function advanceStage(taskId, options) {
   if (!options.initiatedBy) {
     throw new CleoError(2 /* INVALID_INPUT */, "advanceStage() requires initiatedBy agent/user");
   }
-  const pipelineResult = await db.select().from(lifecyclePipelines).where(eq8(lifecyclePipelines.taskId, taskId)).limit(1).all();
+  const pipelineResult = await db.select().from(lifecyclePipelines).where(eq9(lifecyclePipelines.taskId, taskId)).limit(1).all();
   if (pipelineResult.length === 0) {
     throw new CleoError(4 /* NOT_FOUND */, `No pipeline found for task ${taskId}`);
   }
@@ -20866,9 +20885,9 @@ async function advanceStage(taskId, options) {
   const fromStage = pipeline2.currentStageId;
   const toStage = options.toStage;
   const currentStageResult = await db.select().from(lifecycleStages).where(
-    and5(
-      eq8(lifecycleStages.pipelineId, pipeline2.id),
-      eq8(lifecycleStages.stageName, fromStage)
+    and6(
+      eq9(lifecycleStages.pipelineId, pipeline2.id),
+      eq9(lifecycleStages.stageName, fromStage)
     )
   ).limit(1).all();
   if (currentStageResult.length === 0) {
@@ -20879,9 +20898,9 @@ async function advanceStage(taskId, options) {
   }
   const currentStageRecord = currentStageResult[0];
   const targetStageResult = await db.select().from(lifecycleStages).where(
-    and5(
-      eq8(lifecycleStages.pipelineId, pipeline2.id),
-      eq8(lifecycleStages.stageName, toStage)
+    and6(
+      eq9(lifecycleStages.pipelineId, pipeline2.id),
+      eq9(lifecycleStages.stageName, toStage)
     )
   ).limit(1).all();
   if (targetStageResult.length === 0) {
@@ -20894,14 +20913,14 @@ async function advanceStage(taskId, options) {
   await db.update(lifecycleStages).set({
     status: "completed",
     completedAt: now.toISOString()
-  }).where(eq8(lifecycleStages.id, currentStageRecord.id)).run();
+  }).where(eq9(lifecycleStages.id, currentStageRecord.id)).run();
   await db.update(lifecycleStages).set({
     status: "in_progress",
     startedAt: now.toISOString()
-  }).where(eq8(lifecycleStages.id, targetStageRecord.id)).run();
+  }).where(eq9(lifecycleStages.id, targetStageRecord.id)).run();
   await db.update(lifecyclePipelines).set({
     currentStageId: toStage
-  }).where(eq8(lifecyclePipelines.id, pipeline2.id)).run();
+  }).where(eq9(lifecyclePipelines.id, pipeline2.id)).run();
   await db.insert(lifecycleTransitions).values({
     id: `${pipeline2.id}_${now.getTime()}_${Math.random().toString(36).slice(2, 7)}`,
     pipelineId: pipeline2.id,
@@ -20918,7 +20937,7 @@ async function advanceStage(taskId, options) {
 }
 async function getCurrentStage(taskId) {
   const db = await getDb();
-  const result = await db.select({ currentStageId: lifecyclePipelines.currentStageId }).from(lifecyclePipelines).where(eq8(lifecyclePipelines.taskId, taskId)).limit(1).all();
+  const result = await db.select({ currentStageId: lifecyclePipelines.currentStageId }).from(lifecyclePipelines).where(eq9(lifecyclePipelines.taskId, taskId)).limit(1).all();
   if (result.length === 0) {
     throw new CleoError(4 /* NOT_FOUND */, `No pipeline found for task ${taskId}`);
   }
@@ -20930,43 +20949,43 @@ async function listPipelines(options = {}) {
   const conditions = [];
   if (options.status) {
     conditions.push(
-      eq8(
+      eq9(
         lifecyclePipelines.status,
         options.status
       )
     );
   }
   if (options.currentStage) {
-    conditions.push(eq8(lifecyclePipelines.currentStageId, options.currentStage));
+    conditions.push(eq9(lifecyclePipelines.currentStageId, options.currentStage));
   }
   if (conditions.length > 0) {
-    const whereClause = conditions.length === 1 ? conditions[0] : and5(...conditions);
+    const whereClause = conditions.length === 1 ? conditions[0] : and6(...conditions);
     query = db.select().from(lifecyclePipelines).where(whereClause);
   }
   if (options.orderBy) {
     const order = options.order === "asc" ? asc3 : desc3;
     switch (options.orderBy) {
       case "createdAt":
-        query = db.select().from(lifecyclePipelines).where(conditions.length > 0 ? and5(...conditions) : void 0).orderBy(order(lifecyclePipelines.startedAt));
+        query = db.select().from(lifecyclePipelines).where(conditions.length > 0 ? and6(...conditions) : void 0).orderBy(order(lifecyclePipelines.startedAt));
         break;
       case "currentStage":
-        query = db.select().from(lifecyclePipelines).where(conditions.length > 0 ? and5(...conditions) : void 0).orderBy(order(lifecyclePipelines.currentStageId));
+        query = db.select().from(lifecyclePipelines).where(conditions.length > 0 ? and6(...conditions) : void 0).orderBy(order(lifecyclePipelines.currentStageId));
         break;
     }
   } else {
-    query = db.select().from(lifecyclePipelines).where(conditions.length > 0 ? and5(...conditions) : void 0).orderBy(desc3(lifecyclePipelines.startedAt));
+    query = db.select().from(lifecyclePipelines).where(conditions.length > 0 ? and6(...conditions) : void 0).orderBy(desc3(lifecyclePipelines.startedAt));
   }
   if (options.limit) {
-    query = db.select().from(lifecyclePipelines).where(conditions.length > 0 ? and5(...conditions) : void 0).orderBy(desc3(lifecyclePipelines.startedAt)).limit(options.limit);
+    query = db.select().from(lifecyclePipelines).where(conditions.length > 0 ? and6(...conditions) : void 0).orderBy(desc3(lifecyclePipelines.startedAt)).limit(options.limit);
   }
   if (options.offset) {
-    query = db.select().from(lifecyclePipelines).where(conditions.length > 0 ? and5(...conditions) : void 0).orderBy(desc3(lifecyclePipelines.startedAt)).limit(options.limit || 100).offset(options.offset);
+    query = db.select().from(lifecyclePipelines).where(conditions.length > 0 ? and6(...conditions) : void 0).orderBy(desc3(lifecyclePipelines.startedAt)).limit(options.limit || 100).offset(options.offset);
   }
   const results = await query.all();
   return Promise.all(
     results.map(async (row) => {
       const isActive = row.status === "active";
-      const transitionResult = await db.select({ count: sql9`count(*)` }).from(lifecycleTransitions).where(eq8(lifecycleTransitions.pipelineId, row.id)).all();
+      const transitionResult = await db.select({ count: sql9`count(*)` }).from(lifecycleTransitions).where(eq9(lifecycleTransitions.pipelineId, row.id)).all();
       const transitionCount = Number(transitionResult[0]?.count || 0);
       return {
         id: row.taskId,
@@ -20985,7 +21004,7 @@ async function listPipelines(options = {}) {
 async function completePipeline(taskId, reason) {
   const db = await getDb();
   const now = /* @__PURE__ */ new Date();
-  const pipelineResult = await db.select().from(lifecyclePipelines).where(eq8(lifecyclePipelines.taskId, taskId)).limit(1).all();
+  const pipelineResult = await db.select().from(lifecyclePipelines).where(eq9(lifecyclePipelines.taskId, taskId)).limit(1).all();
   if (pipelineResult.length === 0) {
     throw new CleoError(4 /* NOT_FOUND */, `No pipeline found for task ${taskId}`);
   }
@@ -21000,21 +21019,21 @@ async function completePipeline(taskId, reason) {
       stageUpdate.metadataJson = JSON.stringify({ completionReason: reason });
     }
     await db.update(lifecycleStages).set(stageUpdate).where(
-      and5(
-        eq8(lifecycleStages.pipelineId, pipeline2.id),
-        eq8(lifecycleStages.stageName, pipeline2.currentStageId)
+      and6(
+        eq9(lifecycleStages.pipelineId, pipeline2.id),
+        eq9(lifecycleStages.stageName, pipeline2.currentStageId)
       )
     ).run();
   }
   await db.update(lifecyclePipelines).set({
     status: "completed",
     completedAt: now.toISOString()
-  }).where(eq8(lifecyclePipelines.id, pipeline2.id)).run();
+  }).where(eq9(lifecyclePipelines.id, pipeline2.id)).run();
 }
 async function cancelPipeline(taskId, reason) {
   const db = await getDb();
   const now = /* @__PURE__ */ new Date();
-  const pipelineResult = await db.select().from(lifecyclePipelines).where(eq8(lifecyclePipelines.taskId, taskId)).limit(1).all();
+  const pipelineResult = await db.select().from(lifecyclePipelines).where(eq9(lifecyclePipelines.taskId, taskId)).limit(1).all();
   if (pipelineResult.length === 0) {
     throw new CleoError(4 /* NOT_FOUND */, `No pipeline found for task ${taskId}`);
   }
@@ -21031,20 +21050,20 @@ async function cancelPipeline(taskId, reason) {
       blockedAt: now.toISOString(),
       blockReason: `Pipeline cancelled: ${reason}`
     }).where(
-      and5(
-        eq8(lifecycleStages.pipelineId, pipeline2.id),
-        eq8(lifecycleStages.stageName, pipeline2.currentStageId)
+      and6(
+        eq9(lifecycleStages.pipelineId, pipeline2.id),
+        eq9(lifecycleStages.stageName, pipeline2.currentStageId)
       )
     ).run();
   }
   await db.update(lifecyclePipelines).set({
     status: "cancelled",
     completedAt: now.toISOString()
-  }).where(eq8(lifecyclePipelines.id, pipeline2.id)).run();
+  }).where(eq9(lifecyclePipelines.id, pipeline2.id)).run();
 }
 async function pipelineExists(taskId) {
   const db = await getDb();
-  const result = await db.select({ count: sql9`count(*)` }).from(lifecyclePipelines).where(eq8(lifecyclePipelines.taskId, taskId)).all();
+  const result = await db.select({ count: sql9`count(*)` }).from(lifecyclePipelines).where(eq9(lifecyclePipelines.taskId, taskId)).all();
   return (result[0]?.count || 0) > 0;
 }
 async function getPipelineStatistics() {
@@ -21088,12 +21107,12 @@ async function getPipelineStatistics() {
 }
 async function getPipelineStages(taskId) {
   const db = await getDb();
-  const pipelineResult = await db.select({ id: lifecyclePipelines.id }).from(lifecyclePipelines).where(eq8(lifecyclePipelines.taskId, taskId)).limit(1).all();
+  const pipelineResult = await db.select({ id: lifecyclePipelines.id }).from(lifecyclePipelines).where(eq9(lifecyclePipelines.taskId, taskId)).limit(1).all();
   if (pipelineResult.length === 0) {
     throw new CleoError(4 /* NOT_FOUND */, `No pipeline found for task ${taskId}`);
   }
   const pipelineId = pipelineResult[0].id;
-  const stages = await db.select().from(lifecycleStages).where(eq8(lifecycleStages.pipelineId, pipelineId)).orderBy(asc3(lifecycleStages.sequence)).all();
+  const stages = await db.select().from(lifecycleStages).where(eq9(lifecycleStages.pipelineId, pipelineId)).orderBy(asc3(lifecycleStages.sequence)).all();
   return stages.map((stage) => ({
     id: stage.id,
     pipelineId: stage.pipelineId,
@@ -23949,9 +23968,9 @@ async function nexusRegister(projectPath, name2, permissions = "read") {
   const projectHash = generateProjectHash(projectPath);
   await nexusInit();
   const { getNexusDb: getNexusDb2 } = await Promise.resolve().then(() => (init_nexus_sqlite(), nexus_sqlite_exports));
-  const { eq: eq11 } = await import("drizzle-orm");
+  const { eq: eq12 } = await import("drizzle-orm");
   const db = await getNexusDb2();
-  const existingRows = await db.select().from(projectRegistry).where(eq11(projectRegistry.projectHash, projectHash));
+  const existingRows = await db.select().from(projectRegistry).where(eq12(projectRegistry.projectHash, projectHash));
   const existing = existingRows[0];
   if (existing?.permissions) {
     throw new CleoError(
@@ -23960,7 +23979,7 @@ async function nexusRegister(projectPath, name2, permissions = "read") {
     );
   }
   if (!existing) {
-    const nameConflictRows = await db.select().from(projectRegistry).where(eq11(projectRegistry.name, projectName));
+    const nameConflictRows = await db.select().from(projectRegistry).where(eq12(projectRegistry.name, projectName));
     if (nameConflictRows.length > 0) {
       throw new CleoError(
         6 /* VALIDATION_ERROR */,
@@ -23978,7 +23997,7 @@ async function nexusRegister(projectPath, name2, permissions = "read") {
       taskCount: meta.taskCount,
       labelsJson: JSON.stringify(meta.labels),
       lastSeen: now
-    }).where(eq11(projectRegistry.projectHash, projectHash));
+    }).where(eq12(projectRegistry.projectHash, projectHash));
   } else {
     if (!projectId) {
       projectId = randomUUID3();
@@ -24016,9 +24035,9 @@ async function nexusUnregister(nameOrHash) {
     throw new CleoError(4 /* NOT_FOUND */, `Project not found in registry: ${nameOrHash}`);
   }
   const { getNexusDb: getNexusDb2 } = await Promise.resolve().then(() => (init_nexus_sqlite(), nexus_sqlite_exports));
-  const { eq: eq11 } = await import("drizzle-orm");
+  const { eq: eq12 } = await import("drizzle-orm");
   const db = await getNexusDb2();
-  await db.delete(projectRegistry).where(eq11(projectRegistry.projectHash, project.hash));
+  await db.delete(projectRegistry).where(eq12(projectRegistry.projectHash, project.hash));
   await writeNexusAudit({
     action: "unregister",
     projectHash: project.hash,
@@ -24040,9 +24059,9 @@ async function nexusList() {
 async function nexusGetProject(nameOrHash) {
   try {
     const { getNexusDb: getNexusDb2 } = await Promise.resolve().then(() => (init_nexus_sqlite(), nexus_sqlite_exports));
-    const { eq: eq11, or: or4 } = await import("drizzle-orm");
+    const { eq: eq12, or: or4 } = await import("drizzle-orm");
     const db = await getNexusDb2();
-    const rows = await db.select().from(projectRegistry).where(or4(eq11(projectRegistry.projectHash, nameOrHash), eq11(projectRegistry.name, nameOrHash)));
+    const rows = await db.select().from(projectRegistry).where(or4(eq12(projectRegistry.projectHash, nameOrHash), eq12(projectRegistry.name, nameOrHash)));
     const row = rows[0];
     if (!row) return null;
     return rowToProject(row);
@@ -24065,14 +24084,14 @@ async function nexusSync(nameOrHash) {
   const meta = await readProjectMeta(project.path);
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const { getNexusDb: getNexusDb2 } = await Promise.resolve().then(() => (init_nexus_sqlite(), nexus_sqlite_exports));
-  const { eq: eq11 } = await import("drizzle-orm");
+  const { eq: eq12 } = await import("drizzle-orm");
   const db = await getNexusDb2();
   await db.update(projectRegistry).set({
     taskCount: meta.taskCount,
     labelsJson: JSON.stringify(meta.labels),
     lastSync: now,
     lastSeen: now
-  }).where(eq11(projectRegistry.projectHash, project.hash));
+  }).where(eq12(projectRegistry.projectHash, project.hash));
   await writeNexusAudit({
     action: "sync",
     projectHash: project.hash,
@@ -24086,7 +24105,7 @@ async function nexusSyncAll() {
   let synced = 0;
   let failed = 0;
   const { getNexusDb: getNexusDb2 } = await Promise.resolve().then(() => (init_nexus_sqlite(), nexus_sqlite_exports));
-  const { eq: eq11 } = await import("drizzle-orm");
+  const { eq: eq12 } = await import("drizzle-orm");
   const db = await getNexusDb2();
   for (const project of projects) {
     try {
@@ -24097,7 +24116,7 @@ async function nexusSyncAll() {
         labelsJson: JSON.stringify(meta.labels),
         lastSync: now,
         lastSeen: now
-      }).where(eq11(projectRegistry.projectHash, project.hash));
+      }).where(eq12(projectRegistry.projectHash, project.hash));
       synced++;
     } catch {
       failed++;
@@ -24117,9 +24136,9 @@ async function nexusSetPermission(nameOrHash, permission) {
     throw new CleoError(4 /* NOT_FOUND */, `Project not found in registry: ${nameOrHash}`);
   }
   const { getNexusDb: getNexusDb2 } = await Promise.resolve().then(() => (init_nexus_sqlite(), nexus_sqlite_exports));
-  const { eq: eq11 } = await import("drizzle-orm");
+  const { eq: eq12 } = await import("drizzle-orm");
   const db = await getNexusDb2();
-  await db.update(projectRegistry).set({ permissions: permission }).where(eq11(projectRegistry.projectHash, project.hash));
+  await db.update(projectRegistry).set({ permissions: permission }).where(eq12(projectRegistry.projectHash, project.hash));
   await writeNexusAudit({
     action: "set-permission",
     projectHash: project.hash,
@@ -24135,12 +24154,12 @@ async function nexusReconcile(projectRoot) {
   }
   await nexusInit();
   const { getNexusDb: getNexusDb2 } = await Promise.resolve().then(() => (init_nexus_sqlite(), nexus_sqlite_exports));
-  const { eq: eq11 } = await import("drizzle-orm");
+  const { eq: eq12 } = await import("drizzle-orm");
   const db = await getNexusDb2();
   const projectId = await readProjectId(projectRoot);
   const currentHash = generateProjectHash(projectRoot);
   if (projectId) {
-    const hashRows2 = await db.select().from(projectRegistry).where(eq11(projectRegistry.projectHash, currentHash));
+    const hashRows2 = await db.select().from(projectRegistry).where(eq12(projectRegistry.projectHash, currentHash));
     const hashMatch2 = hashRows2[0];
     if (hashMatch2 && hashMatch2.projectId !== projectId) {
       await writeNexusAudit({
@@ -24159,12 +24178,12 @@ async function nexusReconcile(projectRoot) {
     }
   }
   if (projectId) {
-    const idRows = await db.select().from(projectRegistry).where(eq11(projectRegistry.projectId, projectId));
+    const idRows = await db.select().from(projectRegistry).where(eq12(projectRegistry.projectId, projectId));
     const existing = idRows[0];
     if (existing) {
       const now = (/* @__PURE__ */ new Date()).toISOString();
       if (existing.projectPath === projectRoot) {
-        await db.update(projectRegistry).set({ lastSeen: now }).where(eq11(projectRegistry.projectId, projectId));
+        await db.update(projectRegistry).set({ lastSeen: now }).where(eq12(projectRegistry.projectId, projectId));
         await writeNexusAudit({
           action: "reconcile",
           projectHash: currentHash,
@@ -24180,7 +24199,7 @@ async function nexusReconcile(projectRoot) {
         projectPath: projectRoot,
         projectHash: currentHash,
         lastSeen: now
-      }).where(eq11(projectRegistry.projectId, projectId));
+      }).where(eq12(projectRegistry.projectId, projectId));
       await writeNexusAudit({
         action: "reconcile",
         projectHash: currentHash,
@@ -24192,11 +24211,11 @@ async function nexusReconcile(projectRoot) {
       return { status: "path_updated", oldPath, newPath: projectRoot };
     }
   }
-  const hashRows = await db.select().from(projectRegistry).where(eq11(projectRegistry.projectHash, currentHash));
+  const hashRows = await db.select().from(projectRegistry).where(eq12(projectRegistry.projectHash, currentHash));
   const hashMatch = hashRows[0];
   if (hashMatch) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
-    await db.update(projectRegistry).set({ lastSeen: now }).where(eq11(projectRegistry.projectHash, currentHash));
+    await db.update(projectRegistry).set({ lastSeen: now }).where(eq12(projectRegistry.projectHash, currentHash));
     await writeNexusAudit({
       action: "reconcile",
       projectHash: currentHash,
@@ -26401,7 +26420,7 @@ async function syncAdrsToDb(projectRoot) {
     return result;
   }
   const { getDb: getDb3 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
-  const { eq: eq11 } = await import("drizzle-orm");
+  const { eq: eq12 } = await import("drizzle-orm");
   const db = await getDb3(projectRoot);
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const allFiles = collectAdrFiles(adrsDir);
@@ -26435,15 +26454,15 @@ async function syncAdrsToDb(projectRoot) {
         topics: fm.Topics ?? null,
         updatedAt: now
       };
-      const existing = await db.select({ id: architectureDecisions.id }).from(architectureDecisions).where(eq11(architectureDecisions.id, record2.id)).all();
+      const existing = await db.select({ id: architectureDecisions.id }).from(architectureDecisions).where(eq12(architectureDecisions.id, record2.id)).all();
       if (existing.length > 0) {
-        await db.update(architectureDecisions).set(rowBase).where(eq11(architectureDecisions.id, record2.id));
+        await db.update(architectureDecisions).set(rowBase).where(eq12(architectureDecisions.id, record2.id));
         result.updated++;
       } else {
         await db.insert(architectureDecisions).values({ ...rowBase, createdAt: now });
         result.inserted++;
       }
-      await db.delete(adrTaskLinks).where(eq11(adrTaskLinks.adrId, record2.id));
+      await db.delete(adrTaskLinks).where(eq12(adrTaskLinks.adrId, record2.id));
       if (fm["Related Tasks"]) {
         for (const taskId of parseTaskIds2(fm["Related Tasks"])) {
           await db.insert(adrTaskLinks).values({ adrId: record2.id, taskId, linkType: "related" });
@@ -26545,18 +26564,27 @@ __export(agents_exports, {
   AGENT_INSTANCE_STATUSES: () => AGENT_INSTANCE_STATUSES,
   AGENT_TYPES: () => AGENT_TYPES,
   DEFAULT_RETRY_POLICY: () => DEFAULT_RETRY_POLICY,
+  HEARTBEAT_INTERVAL_MS: () => HEARTBEAT_INTERVAL_MS,
+  MAX_TASKS_PER_AGENT: () => MAX_TASKS_PER_AGENT,
+  STALE_THRESHOLD_MS: () => STALE_THRESHOLD_MS,
   agentErrorLog: () => agentErrorLog,
   agentInstances: () => agentInstances,
   calculateDelay: () => calculateDelay,
-  checkAgentHealth: () => checkAgentHealth,
+  checkAgentHealth: () => checkAgentHealth2,
   classifyError: () => classifyError,
   createRetryPolicy: () => createRetryPolicy,
   deregisterAgent: () => deregisterAgent,
+  detectCrashedAgents: () => detectCrashedAgents,
+  detectStaleAgents: () => detectStaleAgents,
   findLeastLoadedAgent: () => findLeastLoadedAgent,
+  findStaleAgentRows: () => checkAgentHealth,
   generateAgentId: () => generateAgentId,
+  getAgentCapacity: () => getAgentCapacity,
   getAgentErrorHistory: () => getAgentErrorHistory,
   getAgentInstance: () => getAgentInstance,
   getAgentPerformanceHistory: () => getAgentPerformanceHistory,
+  getAgentSpecializations: () => getAgentSpecializations,
+  getAgentsByCapacity: () => getAgentsByCapacity,
   getAvailableCapacity: () => getAvailableCapacity,
   getCapacitySummary: () => getCapacitySummary,
   getHealthReport: () => getHealthReport,
@@ -26568,85 +26596,35 @@ __export(agents_exports, {
   markCrashed: () => markCrashed,
   processAgentLifecycleEvent: () => processAgentLifecycleEvent,
   recordAgentExecution: () => recordAgentExecution,
+  recordAgentPerformance: () => recordAgentPerformance,
   recordFailurePattern: () => recordFailurePattern,
+  recordHeartbeat: () => recordHeartbeat,
   recoverCrashedAgents: () => recoverCrashedAgents,
   registerAgent: () => registerAgent,
   shouldRetry: () => shouldRetry,
   storeHealingStrategy: () => storeHealingStrategy,
+  updateAgentSpecializations: () => updateAgentSpecializations,
   updateAgentStatus: () => updateAgentStatus,
   updateCapacity: () => updateCapacity,
   withRetry: () => withRetry
 });
-init_agent_schema();
 
-// packages/core/src/agents/capacity.ts
+// packages/core/src/agents/agent-registry.ts
 init_sqlite2();
 init_agent_schema();
-init_registry2();
-import { eq as eq6 } from "drizzle-orm";
-async function updateCapacity(id, capacity, cwd) {
-  if (capacity < 0 || capacity > 1) {
-    throw new Error(`Capacity must be between 0.0 and 1.0, got ${capacity}`);
-  }
-  const db = await getDb(cwd);
-  const existing = await db.select().from(agentInstances).where(eq6(agentInstances.id, id)).get();
-  if (!existing) return null;
-  const capacityStr = capacity.toFixed(4);
-  await db.update(agentInstances).set({ capacity: capacityStr }).where(eq6(agentInstances.id, id));
-  return { ...existing, capacity: capacityStr };
-}
-async function getAvailableCapacity(cwd) {
-  const agents = await listAgentInstances({ status: ["active", "idle"] }, cwd);
-  return agents.reduce((sum, agent) => sum + parseCapacity(agent.capacity), 0);
-}
-async function findLeastLoadedAgent(agentType, cwd) {
-  const filters = agentType ? { status: ["active", "idle"], agentType } : { status: ["active", "idle"] };
-  const agents = await listAgentInstances(filters, cwd);
-  if (agents.length === 0) return null;
-  let best = agents[0];
-  let bestCapacity = parseCapacity(best.capacity);
-  for (let i = 1; i < agents.length; i++) {
-    const cap = parseCapacity(agents[i].capacity);
-    if (cap > bestCapacity) {
-      best = agents[i];
-      bestCapacity = cap;
-    }
-  }
-  return best;
-}
-async function isOverloaded(threshold = 0.1, cwd) {
-  const capacity = await getAvailableCapacity(cwd);
-  return capacity < threshold;
-}
-async function getCapacitySummary(threshold = 0.1, cwd) {
-  const agents = await listAgentInstances({ status: ["active", "idle"] }, cwd);
-  const totalCapacity = agents.reduce((sum, a) => sum + parseCapacity(a.capacity), 0);
-  const activeAgentCount = agents.length;
-  return {
-    totalCapacity,
-    activeAgentCount,
-    averageCapacity: activeAgentCount > 0 ? totalCapacity / activeAgentCount : 0,
-    overloaded: totalCapacity < threshold,
-    threshold
-  };
-}
-function parseCapacity(value) {
-  if (!value) return 0;
-  const parsed = parseFloat(value);
-  return Number.isNaN(parsed) ? 0 : Math.max(0, Math.min(1, parsed));
-}
+import { and as and5, eq as eq7, inArray as inArray5 } from "drizzle-orm";
 
 // packages/core/src/agents/execution-learning.ts
 init_brain_accessor();
-import { randomBytes as randomBytes2 } from "node:crypto";
+import { randomBytes } from "node:crypto";
 function generateDecisionId() {
-  return `AGT-${randomBytes2(5).toString("hex")}`;
+  return `AGT-${randomBytes(5).toString("hex")}`;
 }
 function generatePatternId() {
-  return `P-agt-${randomBytes2(4).toString("hex")}`;
+  return `P-agt-${randomBytes(4).toString("hex")}`;
 }
 function generateObservationId() {
-  return `O-agt-${randomBytes2(4).toString("hex")}`;
+  return `O-agt-${randomBytes(4).toString("hex")}`;
 }
 function nowSql() {
   return (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19);
@@ -26923,6 +26901,215 @@ function buildHealingSuggestion(agentType, taskType, errorType, frequency) {
   return `Unknown failure for ${agentType} on ${taskType} tasks (${frequency}x). Check agent logs, retry with fresh context, or reassign to a different agent type.`;
 }
 
+// packages/core/src/agents/agent-registry.ts
+init_registry2();
+var MAX_TASKS_PER_AGENT = 5;
+async function getAgentCapacity(agentId, cwd) {
+  const db = await getDb(cwd);
+  const agent = await db.select().from(agentInstances).where(eq7(agentInstances.id, agentId)).get();
+  if (!agent) return null;
+  const isTerminal = agent.status === "stopped" || agent.status === "crashed";
+  if (isTerminal) {
+    return {
+      agentId: agent.id,
+      agentType: agent.agentType,
+      status: agent.status,
+      activeTasks: 0,
+      remainingCapacity: 0,
+      maxCapacity: MAX_TASKS_PER_AGENT,
+      available: false
+    };
+  }
+  const children = await db.select({ id: agentInstances.id }).from(agentInstances).where(
+    and5(
+      eq7(agentInstances.parentAgentId, agentId),
+      inArray5(agentInstances.status, ["starting", "active", "idle", "error"])
+    )
+  ).all();
+  const selfTask = agent.taskId != null ? 1 : 0;
+  const activeTasks = selfTask + children.length;
+  const remainingCapacity = Math.max(0, MAX_TASKS_PER_AGENT - activeTasks);
+  return {
+    agentId: agent.id,
+    agentType: agent.agentType,
+    status: agent.status,
+    activeTasks,
+    remainingCapacity,
+    maxCapacity: MAX_TASKS_PER_AGENT,
+    available: remainingCapacity > 0
+  };
+}
+async function getAgentsByCapacity(agentType, cwd) {
+  const filters = agentType ? { status: ["active", "idle"], agentType } : { status: ["active", "idle"] };
+  const activeAgents = await listAgentInstances(filters, cwd);
+  const capacities = await Promise.all(
+    activeAgents.map((agent) => getAgentCapacity(agent.id, cwd))
+  );
+  return capacities.filter((c) => c !== null).sort((a, b) => b.remainingCapacity - a.remainingCapacity);
+}
+async function getAgentSpecializations(agentId, cwd) {
+  const db = await getDb(cwd);
+  const agent = await db.select({ metadataJson: agentInstances.metadataJson }).from(agentInstances).where(eq7(agentInstances.id, agentId)).get();
+  if (!agent) return [];
+  try {
+    const meta = JSON.parse(agent.metadataJson ?? "{}");
+    const specs = meta.specializations;
+    if (!Array.isArray(specs)) return [];
+    return specs.filter((s) => typeof s === "string");
+  } catch {
+    return [];
+  }
+}
+async function updateAgentSpecializations(agentId, specializations, cwd) {
+  const db = await getDb(cwd);
+  const agent = await db.select({ metadataJson: agentInstances.metadataJson }).from(agentInstances).where(eq7(agentInstances.id, agentId)).get();
+  if (!agent) return null;
+  let existing = {};
+  try {
+    existing = JSON.parse(agent.metadataJson ?? "{}");
+  } catch {
+  }
+  const updated = { ...existing, specializations };
+  await db.update(agentInstances).set({ metadataJson: JSON.stringify(updated) }).where(eq7(agentInstances.id, agentId));
+  return specializations;
+}
+async function recordAgentPerformance(agentId, metrics, cwd) {
+  const db = await getDb(cwd);
+  const agent = await db.select({ agentType: agentInstances.agentType, sessionId: agentInstances.sessionId }).from(agentInstances).where(eq7(agentInstances.id, agentId)).get();
+  if (!agent) return null;
+  const event = {
+    agentId,
+    agentType: agent.agentType,
+    taskId: metrics.taskId,
+    taskType: metrics.taskType,
+    outcome: metrics.outcome,
+    taskLabels: metrics.taskLabels,
+    sessionId: metrics.sessionId ?? agent.sessionId ?? void 0,
+    durationMs: metrics.durationMs,
+    errorMessage: metrics.errorMessage,
+    errorType: metrics.errorType
+  };
+  const decision = await recordAgentExecution(event, cwd);
+  return decision?.id ?? null;
+}
+
+// packages/core/src/agents/index.ts
+init_agent_schema();
+
+// packages/core/src/agents/capacity.ts
+init_sqlite2();
+init_agent_schema();
+init_registry2();
+import { eq as eq8 } from "drizzle-orm";
+async function updateCapacity(id, capacity, cwd) {
+  if (capacity < 0 || capacity > 1) {
+    throw new Error(`Capacity must be between 0.0 and 1.0, got ${capacity}`);
+  }
+  const db = await getDb(cwd);
+  const existing = await db.select().from(agentInstances).where(eq8(agentInstances.id, id)).get();
+  if (!existing) return null;
+  const capacityStr = capacity.toFixed(4);
+  await db.update(agentInstances).set({ capacity: capacityStr }).where(eq8(agentInstances.id, id));
+  return { ...existing, capacity: capacityStr };
+}
+async function getAvailableCapacity(cwd) {
+  const agents = await listAgentInstances({ status: ["active", "idle"] }, cwd);
+  return agents.reduce((sum, agent) => sum + parseCapacity(agent.capacity), 0);
+}
+async function findLeastLoadedAgent(agentType, cwd) {
+  const filters = agentType ? { status: ["active", "idle"], agentType } : { status: ["active", "idle"] };
+  const agents = await listAgentInstances(filters, cwd);
+  if (agents.length === 0) return null;
+  let best = agents[0];
+  let bestCapacity = parseCapacity(best.capacity);
+  for (let i = 1; i < agents.length; i++) {
+    const cap = parseCapacity(agents[i].capacity);
+    if (cap > bestCapacity) {
+      best = agents[i];
+      bestCapacity = cap;
+    }
+  }
+  return best;
+}
+async function isOverloaded(threshold = 0.1, cwd) {
+  const capacity = await getAvailableCapacity(cwd);
+  return capacity < threshold;
+}
+async function getCapacitySummary(threshold = 0.1, cwd) {
+  const agents = await listAgentInstances({ status: ["active", "idle"] }, cwd);
+  const totalCapacity = agents.reduce((sum, a) => sum + parseCapacity(a.capacity), 0);
+  const activeAgentCount = agents.length;
+  return {
+    totalCapacity,
+    activeAgentCount,
+    averageCapacity: activeAgentCount > 0 ? totalCapacity / activeAgentCount : 0,
+    overloaded: totalCapacity < threshold,
+    threshold
+  };
+}
+function parseCapacity(value) {
+  if (!value) return 0;
+  const parsed = parseFloat(value);
+  return Number.isNaN(parsed) ? 0 : Math.max(0, Math.min(1, parsed));
+}
+
+// packages/core/src/agents/health-monitor.ts
+init_registry2();
+var HEARTBEAT_INTERVAL_MS = 3e4;
+var STALE_THRESHOLD_MS = 3 * 6e4;
+var ALIVE_STATUSES = ["starting", "active", "idle"];
+async function recordHeartbeat(agentId, cwd) {
+  return heartbeat(agentId, cwd);
+}
+async function checkAgentHealth2(agentId, thresholdMs = STALE_THRESHOLD_MS, cwd) {
+  const all = await listAgentInstances(void 0, cwd);
+  const agent = all.find((a) => a.id === agentId);
+  if (!agent) return null;
+  return buildHealthStatus(agent, thresholdMs);
+}
+async function detectStaleAgents(thresholdMs = STALE_THRESHOLD_MS, cwd) {
+  const agents = await listAgentInstances({ status: ALIVE_STATUSES }, cwd);
+  return agents.map((a) => buildHealthStatus(a, thresholdMs)).filter((s) => s.stale).sort((a, b) => b.heartbeatAgeMs - a.heartbeatAgeMs);
+}
+async function detectCrashedAgents(thresholdMs = STALE_THRESHOLD_MS, cwd) {
+  const activeAgents = await listAgentInstances({ status: "active" }, cwd);
+  const cutoff = new Date(Date.now() - thresholdMs).toISOString();
+  const crashed = [];
+  for (const agent of activeAgents) {
+    if (agent.lastHeartbeat < cutoff) {
+      const updated = await markCrashed(
+        agent.id,
+        `Heartbeat timeout \u2014 no heartbeat for >${Math.round(thresholdMs / 1e3)}s`,
+        cwd
+      );
+      if (updated) {
+        crashed.push(updated);
+      }
+    }
+  }
+  crashed.sort((a, b) => {
+    const aHb = a.lastHeartbeat ?? "";
+    const bHb = b.lastHeartbeat ?? "";
+    return aHb < bHb ? -1 : aHb > bHb ? 1 : 0;
+  });
+  return crashed;
+}
+function buildHealthStatus(agent, thresholdMs) {
+  const lastHeartbeatMs = new Date(agent.lastHeartbeat).getTime();
+  const heartbeatAgeMs = Date.now() - lastHeartbeatMs;
+  const stale = ALIVE_STATUSES.includes(agent.status) ? heartbeatAgeMs > thresholdMs : false;
+  const healthy = !stale && ALIVE_STATUSES.includes(agent.status);
+  return {
+    agentId: agent.id,
+    status: agent.status,
+    lastHeartbeat: agent.lastHeartbeat,
+    heartbeatAgeMs,
+    healthy,
+    stale,
+    thresholdMs
+  };
+}
+
 // packages/core/src/agents/index.ts
 init_registry2();
 
@@ -39185,6 +39372,7 @@ __export(intelligence_exports, {
   gatherLearningContext: () => gatherLearningContext,
   matchPatterns: () => matchPatterns,
   predictAndStore: () => predictAndStore,
+  predictImpact: () => predictImpact,
   predictValidationOutcome: () => predictValidationOutcome,
   scoreVerificationConfidence: () => scoreVerificationConfidence,
   storeDetectedPattern: () => storeDetectedPattern,
@@ -40374,6 +40562,116 @@ function generateRecommendation2(changeType, affectedCount, cascadeDepth, taskId
       return `${severity} impact: reprioritizing ${taskId} may reorder ${affectedCount} downstream task(s) across ${cascadeDepth} level(s) of dependencies.`;
   }
 }
+function scoreTaskMatch(change, task) {
+  const STOP_WORDS3 = /* @__PURE__ */ new Set([
+    "a",
+    "an",
+    "the",
+    "and",
+    "or",
+    "in",
+    "of",
+    "to",
+    "for",
+    "with",
+    "on",
+    "at",
+    "by",
+    "is",
+    "it",
+    "be",
+    "as",
+    "if",
+    "do",
+    "not"
+  ]);
+  const tokenise = (text3) => text3.toLowerCase().split(/\W+/).filter((t) => t.length > 2 && !STOP_WORDS3.has(t));
+  const changeTokens = new Set(tokenise(change));
+  if (changeTokens.size === 0) return 0;
+  const taskText = `${task.title ?? ""} ${task.description ?? ""}`;
+  const taskTokens = new Set(tokenise(taskText));
+  let matches = 0;
+  for (const token of changeTokens) {
+    if (taskTokens.has(token)) matches++;
+  }
+  return matches / changeTokens.size;
+}
+async function predictImpact(change, cwd, accessor, matchLimit = 5) {
+  const acc = accessor ?? await getAccessor(cwd);
+  const tasks2 = await loadAllTasks2(acc);
+  const taskMap = new Map(tasks2.map((t) => [t.id, t]));
+  const dependentsMap = buildDependentsMap(tasks2);
+  const scored = tasks2.map((t) => ({ task: t, score: scoreTaskMatch(change, t) })).filter(({ score }) => score > 0).sort((a, b) => b.score - a.score);
+  const seeds = scored.slice(0, matchLimit).map(({ task }) => task);
+  if (seeds.length === 0) {
+    return {
+      change,
+      matchedTasks: [],
+      affectedTasks: [],
+      totalAffected: 0,
+      summary: `No tasks matched the change description "${change}".`
+    };
+  }
+  const directMatchIds = new Set(seeds.map((t) => t.id));
+  const exposureMap = /* @__PURE__ */ new Map();
+  for (const id of directMatchIds) {
+    exposureMap.set(id, "direct");
+  }
+  for (const seed of seeds) {
+    const transitive = collectTransitiveDependents(seed.id, dependentsMap);
+    for (const depId of transitive) {
+      if (!exposureMap.has(depId)) {
+        const isDirectDependent = (dependentsMap.get(seed.id) ?? /* @__PURE__ */ new Set()).has(depId);
+        exposureMap.set(depId, isDirectDependent ? "dependent" : "transitive");
+      }
+    }
+  }
+  const EXPOSURE_ORDER = {
+    direct: 0,
+    dependent: 1,
+    transitive: 2
+  };
+  const affectedTasks = [];
+  for (const [id, exposure] of exposureMap) {
+    const task = taskMap.get(id);
+    if (!task) continue;
+    const downstreamTransitive = collectTransitiveDependents(id, dependentsMap);
+    const downstreamCount = downstreamTransitive.size;
+    let reason;
+    if (exposure === "direct") {
+      reason = `Task title/description matched "${change}".`;
+    } else if (exposure === "dependent") {
+      const seedNames = seeds.filter((s) => (dependentsMap.get(s.id) ?? /* @__PURE__ */ new Set()).has(id)).map((s) => s.id).join(", ");
+      reason = `Directly depends on matched task(s): ${seedNames}.`;
+    } else {
+      reason = "Downstream of a matched task via transitive dependency chain.";
+    }
+    affectedTasks.push({
+      id,
+      title: task.title,
+      status: task.status,
+      priority: task.priority,
+      exposure,
+      downstreamCount,
+      reason
+    });
+  }
+  affectedTasks.sort((a, b) => {
+    const expDiff = EXPOSURE_ORDER[a.exposure] - EXPOSURE_ORDER[b.exposure];
+    if (expDiff !== 0) return expDiff;
+    return b.downstreamCount - a.downstreamCount;
+  });
+  const matchedTasks = affectedTasks.filter((t) => t.exposure === "direct");
+  const totalAffected = affectedTasks.length;
+  const summary = matchedTasks.length === 0 ? `No tasks matched "${change}".` : `${matchedTasks.length} task(s) matched "${change}"; ${totalAffected} total task(s) affected (including downstream).`;
+  return {
+    change,
+    matchedTasks,
+    affectedTasks,
+    totalAffected,
+    summary
+  };
+}
 
 // packages/core/src/intelligence/patterns.ts
 import { randomBytes as randomBytes7 } from "node:crypto";
@@ -40889,13 +41187,13 @@ function extractYamlArray(content, field) {
   }
   const lines = content.split("\n");
   const items = [];
-  let inArray5 = false;
+  let inArray6 = false;
   for (const line2 of lines) {
     if (line2.match(new RegExp(`^${field}:`))) {
-      inArray5 = true;
+      inArray6 = true;
       continue;
     }
-    if (inArray5) {
+    if (inArray6) {
       const itemMatch = line2.match(/^\s+-\s+["']?(.+?)["']?\s*$/);
       if (itemMatch) {
         items.push(itemMatch[1].trim());
@@ -41113,6 +41411,60 @@ function addIssue(params) {
   };
 }
 
+// packages/core/src/lib/index.ts
+var lib_exports = {};
+__export(lib_exports, {
+  computeDelay: () => computeDelay,
+  withRetry: () => withRetry2
+});
+
+// packages/core/src/lib/retry.ts
+async function withRetry2(fn, options) {
+  const maxAttempts = options?.maxAttempts ?? 3;
+  const baseDelayMs = options?.baseDelayMs ?? 2e3;
+  const maxDelayMs = options?.maxDelayMs ?? 3e4;
+  const retryableErrors = options?.retryableErrors;
+  let lastError;
+  let totalDelayMs = 0;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err;
+      const isLastAttempt = attempt === maxAttempts;
+      if (isLastAttempt) break;
+      if (retryableErrors !== void 0 && !isRetryable(err, retryableErrors)) break;
+      const delay = computeDelay(attempt, baseDelayMs, maxDelayMs);
+      totalDelayMs += delay;
+      await sleep2(delay);
+    }
+  }
+  const context = { attempts: maxAttempts, totalDelayMs };
+  augmentError(lastError, context);
+  throw lastError;
+}
+function computeDelay(attempt, baseDelayMs, maxDelayMs) {
+  const exponential = baseDelayMs * 2 ** (attempt - 1);
+  return Math.min(exponential, maxDelayMs);
+}
+function isRetryable(err, predicates) {
+  const message = err instanceof Error ? err.message : String(err);
+  return predicates.some((predicate) => {
+    if (predicate instanceof RegExp) return predicate.test(message);
+    return predicate(err);
+  });
+}
+function augmentError(err, context) {
+  if (err instanceof Error) {
+    const mutableErr = err;
+    mutableErr.attempts = context.attempts;
+    mutableErr.totalDelayMs = context.totalDelayMs;
+  }
+}
+function sleep2(ms) {
+  return new Promise((resolve10) => setTimeout(resolve10, ms));
+}
+
 // packages/core/src/lifecycle/index.ts
 var lifecycle_exports = {};
 __export(lifecycle_exports, {
@@ -41929,12 +42281,12 @@ async function getEnforcementMode(cwd) {
 }
 async function getLifecycleStatus(epicId, cwd) {
   const { getDb: getDb3 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
-  const { eq: eq11 } = await import("drizzle-orm");
+  const { eq: eq12 } = await import("drizzle-orm");
   const db = await getDb3(cwd);
   const pipelineResult = await db.select({
     pipeline: lifecyclePipelines,
     task: tasks
-  }).from(lifecyclePipelines).innerJoin(tasks, eq11(lifecyclePipelines.taskId, tasks.id)).where(eq11(lifecyclePipelines.taskId, epicId)).limit(1);
+  }).from(lifecyclePipelines).innerJoin(tasks, eq12(lifecyclePipelines.taskId, tasks.id)).where(eq12(lifecyclePipelines.taskId, epicId)).limit(1);
   if (pipelineResult.length === 0) {
     return {
       epicId,
@@ -41947,7 +42299,7 @@ async function getLifecycleStatus(epicId, cwd) {
   }
   const task = pipelineResult[0].task;
   const pipelineId = `pipeline-${epicId}`;
-  const stageRows = await db.select().from(lifecycleStages).where(eq11(lifecycleStages.pipelineId, pipelineId)).orderBy(lifecycleStages.sequence);
+  const stageRows = await db.select().from(lifecycleStages).where(eq12(lifecycleStages.pipelineId, pipelineId)).orderBy(lifecycleStages.sequence);
   const stageDataMap = /* @__PURE__ */ new Map();
   for (const row of stageRows) {
     let parsedChain;
@@ -42016,10 +42368,10 @@ async function getLifecycleStatus(epicId, cwd) {
 }
 async function getLifecycleHistory(epicId, cwd) {
   const { getDb: getDb3 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
-  const { eq: eq11 } = await import("drizzle-orm");
+  const { eq: eq12 } = await import("drizzle-orm");
   const db = await getDb3(cwd);
   const pipelineId = `pipeline-${epicId}`;
-  const stages = await db.select().from(lifecycleStages).where(eq11(lifecycleStages.pipelineId, pipelineId));
+  const stages = await db.select().from(lifecycleStages).where(eq12(lifecycleStages.pipelineId, pipelineId));
   if (stages.length === 0) {
     return { epicId, history: [] };
   }
@@ -42049,7 +42401,7 @@ async function getLifecycleHistory(epicId, cwd) {
   }
   const stageIds = stages.map((s) => s.id);
   if (stageIds.length > 0) {
-    const gateResults = await db.select().from(lifecycleGateResults).where(eq11(lifecycleGateResults.stageId, stageIds[0]));
+    const gateResults = await db.select().from(lifecycleGateResults).where(eq12(lifecycleGateResults.stageId, stageIds[0]));
     for (const gate of gateResults) {
       const stageName = stageIdToName.get(gate.stageId);
       if (stageName) {
@@ -42062,7 +42414,7 @@ async function getLifecycleHistory(epicId, cwd) {
       }
     }
     for (let i = 1; i < stageIds.length; i++) {
-      const additionalGates = await db.select().from(lifecycleGateResults).where(eq11(lifecycleGateResults.stageId, stageIds[i]));
+      const additionalGates = await db.select().from(lifecycleGateResults).where(eq12(lifecycleGateResults.stageId, stageIds[i]));
       for (const gate of additionalGates) {
         const stageName = stageIdToName.get(gate.stageId);
         if (stageName) {
@@ -42081,16 +42433,16 @@ async function getLifecycleHistory(epicId, cwd) {
 }
 async function getLifecycleGates(epicId, cwd) {
   const { getDb: getDb3 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
-  const { eq: eq11 } = await import("drizzle-orm");
+  const { eq: eq12 } = await import("drizzle-orm");
   const db = await getDb3(cwd);
   const pipelineId = `pipeline-${epicId}`;
-  const stages = await db.select().from(lifecycleStages).where(eq11(lifecycleStages.pipelineId, pipelineId));
+  const stages = await db.select().from(lifecycleStages).where(eq12(lifecycleStages.pipelineId, pipelineId));
   if (stages.length === 0) {
     return {};
   }
   const gates = {};
   for (const stage of stages) {
-    const gateRows = await db.select().from(lifecycleGateResults).where(eq11(lifecycleGateResults.stageId, stage.id));
+    const gateRows = await db.select().from(lifecycleGateResults).where(eq12(lifecycleGateResults.stageId, stage.id));
     if (gateRows.length > 0) {
       gates[stage.stageName] = {};
       for (const gateRow of gateRows) {
@@ -42154,7 +42506,7 @@ async function checkStagePrerequisites(epicId, targetStage, cwd) {
 }
 async function ensureLifecycleContext(epicId, stageName, cwd, options) {
   const { getDb: getDb3 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
-  const { eq: eq11 } = await import("drizzle-orm");
+  const { eq: eq12 } = await import("drizzle-orm");
   const db = await getDb3(cwd);
   const pipelineId = `pipeline-${epicId}`;
   const stageId = `stage-${epicId}-${stageName}`;
@@ -42162,7 +42514,7 @@ async function ensureLifecycleContext(epicId, stageName, cwd, options) {
   getNativeDb2().prepare(
     `INSERT OR IGNORE INTO tasks (id, title, status, priority, created_at) VALUES (?, ?, 'pending', 'medium', datetime('now'))`
   ).run(epicId, `Task ${epicId}`);
-  const existingPipeline = await db.select().from(lifecyclePipelines).where(eq11(lifecyclePipelines.id, pipelineId)).limit(1).all();
+  const existingPipeline = await db.select().from(lifecyclePipelines).where(eq12(lifecyclePipelines.id, pipelineId)).limit(1).all();
   if (existingPipeline.length === 0) {
     await db.insert(lifecyclePipelines).values({
       id: pipelineId,
@@ -42172,7 +42524,7 @@ async function ensureLifecycleContext(epicId, stageName, cwd, options) {
       startedAt: options.now
     }).run();
   }
-  const existingStage = await db.select().from(lifecycleStages).where(eq11(lifecycleStages.id, stageId)).limit(1).all();
+  const existingStage = await db.select().from(lifecycleStages).where(eq12(lifecycleStages.id, stageId)).limit(1).all();
   if (existingStage.length === 0) {
     const sequence = isValidStage(stageName) ? STAGE_ORDER[stageName] : 0;
     await db.insert(lifecycleStages).values({
@@ -42185,7 +42537,7 @@ async function ensureLifecycleContext(epicId, stageName, cwd, options) {
     }).run();
   }
   if (options.updateCurrentStage) {
-    await db.update(lifecyclePipelines).set({ currentStageId: stageId }).where(eq11(lifecyclePipelines.id, pipelineId)).run();
+    await db.update(lifecyclePipelines).set({ currentStageId: stageId }).where(eq12(lifecyclePipelines.id, pipelineId)).run();
   }
   return { db, pipelineId, stageId };
 }
@@ -42200,7 +42552,7 @@ async function recordStageProgress(epicId, stage, status, notes, cwd) {
       `Invalid status: ${status}. Valid: ${validStatuses.join(", ")}`
     );
   }
-  const { eq: eq11 } = await import("drizzle-orm");
+  const { eq: eq12 } = await import("drizzle-orm");
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const stageName = stage;
   const { db, stageId, pipelineId } = await ensureLifecycleContext(epicId, stage, cwd, {
@@ -42216,7 +42568,7 @@ async function recordStageProgress(epicId, stage, status, notes, cwd) {
     status,
     related: artifact.related
   };
-  const existingStage = await db.select().from(lifecycleStages).where(eq11(lifecycleStages.id, stageId)).limit(1).all();
+  const existingStage = await db.select().from(lifecycleStages).where(eq12(lifecycleStages.id, stageId)).limit(1).all();
   const sequence = STAGE_ORDER[stage];
   const stageValues = {
     status,
@@ -42243,7 +42595,7 @@ async function recordStageProgress(epicId, stage, status, notes, cwd) {
       provenanceChainJson: JSON.stringify(provenanceChain)
     }).run();
   } else {
-    await db.update(lifecycleStages).set(stageValues).where(eq11(lifecycleStages.id, stageId)).run();
+    await db.update(lifecycleStages).set(stageValues).where(eq12(lifecycleStages.id, stageId)).run();
   }
   if (status === "completed") {
     await linkProvenance(epicId, stageName, artifact.absolutePath, cwd);
@@ -42263,7 +42615,7 @@ async function resetStage(epicId, stage, reason, cwd) {
   if (!PIPELINE_STAGES.includes(stage)) {
     throw new CleoError(2 /* INVALID_INPUT */, `Invalid stage: ${stage}`);
   }
-  const { eq: eq11 } = await import("drizzle-orm");
+  const { eq: eq12 } = await import("drizzle-orm");
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const { db, stageId } = await ensureLifecycleContext(epicId, stage, cwd, {
     now,
@@ -42276,11 +42628,11 @@ async function resetStage(epicId, stage, reason, cwd) {
     skippedAt: null,
     skipReason: null,
     notesJson: JSON.stringify([`Reset: ${reason}`])
-  }).where(eq11(lifecycleStages.id, stageId)).run();
+  }).where(eq12(lifecycleStages.id, stageId)).run();
   return { epicId, stage, reason };
 }
 async function passGate(epicId, gateName, agent, notes, cwd) {
-  const { eq: eq11 } = await import("drizzle-orm");
+  const { eq: eq12 } = await import("drizzle-orm");
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const stageName = gateName.split("-")[0];
   const gateId = `gate-${epicId}-${stageName}-${gateName}`;
@@ -42289,7 +42641,7 @@ async function passGate(epicId, gateName, agent, notes, cwd) {
     stageStatusOnCreate: "in_progress",
     updateCurrentStage: true
   });
-  const existingGate = await db.select().from(lifecycleGateResults).where(eq11(lifecycleGateResults.id, gateId)).limit(1).all();
+  const existingGate = await db.select().from(lifecycleGateResults).where(eq12(lifecycleGateResults.id, gateId)).limit(1).all();
   const gateValues = {
     id: gateId,
     stageId,
@@ -42301,14 +42653,14 @@ async function passGate(epicId, gateName, agent, notes, cwd) {
     reason: null
   };
   if (existingGate.length > 0) {
-    await db.update(lifecycleGateResults).set(gateValues).where(eq11(lifecycleGateResults.id, gateId)).run();
+    await db.update(lifecycleGateResults).set(gateValues).where(eq12(lifecycleGateResults.id, gateId)).run();
   } else {
     await db.insert(lifecycleGateResults).values(gateValues).run();
   }
   return { epicId, gateName, timestamp: now };
 }
 async function failGate(epicId, gateName, reason, cwd) {
-  const { eq: eq11 } = await import("drizzle-orm");
+  const { eq: eq12 } = await import("drizzle-orm");
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const stageName = gateName.split("-")[0];
   const gateId = `gate-${epicId}-${stageName}-${gateName}`;
@@ -42317,7 +42669,7 @@ async function failGate(epicId, gateName, reason, cwd) {
     stageStatusOnCreate: "in_progress",
     updateCurrentStage: true
   });
-  const existingGate = await db.select().from(lifecycleGateResults).where(eq11(lifecycleGateResults.id, gateId)).limit(1).all();
+  const existingGate = await db.select().from(lifecycleGateResults).where(eq12(lifecycleGateResults.id, gateId)).limit(1).all();
   const gateValues = {
     id: gateId,
     stageId,
@@ -42329,7 +42681,7 @@ async function failGate(epicId, gateName, reason, cwd) {
     reason: reason ?? null
   };
   if (existingGate.length > 0) {
-    await db.update(lifecycleGateResults).set(gateValues).where(eq11(lifecycleGateResults.id, gateId)).run();
+    await db.update(lifecycleGateResults).set(gateValues).where(eq12(lifecycleGateResults.id, gateId)).run();
   } else {
     await db.insert(lifecycleGateResults).values(gateValues).run();
   }
@@ -46463,6 +46815,7 @@ init_registry3();
 // packages/core/src/nexus/sharing/index.ts
 init_config();
 init_paths();
+init_git_checkpoint();
 import { existsSync as existsSync54, readdirSync as readdirSync22, statSync as statSync15 } from "node:fs";
 import { readFile as readFile10, writeFile as writeFile9 } from "node:fs/promises";
 import { join as join61, relative as relative5 } from "node:path";
@@ -46509,6 +46862,30 @@ function collectCleoFiles(cleoDir) {
   walk(cleoDir);
   return files.sort();
 }
+async function getCleoGitRemotes(cleoDir) {
+  const result = await cleoGitCommand(["remote"], cleoDir);
+  if (!result.success || !result.stdout) return [];
+  return result.stdout.split("\n").map((r) => r.trim()).filter(Boolean);
+}
+async function hasCleoGitPendingChanges(cleoDir) {
+  const result = await cleoGitCommand(["status", "--porcelain"], cleoDir);
+  if (!result.success) return false;
+  return result.stdout.length > 0;
+}
+async function getLastSyncTimestamp(cleoDir) {
+  const result = await cleoGitCommand(["reflog", "--format=%gs %ci", "HEAD"], cleoDir);
+  if (!result.success || !result.stdout) return null;
+  for (const line2 of result.stdout.split("\n")) {
+    const trimmed = line2.trim();
+    if (/^(fetch|push|pull)\b/i.test(trimmed)) {
+      const isoMatch = trimmed.match(/(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} [+-]\d{4})$/);
+      if (isoMatch?.[1]) {
+        return new Date(isoMatch[1]).toISOString();
+      }
+    }
+  }
+  return null;
+}
 async function getSharingStatus(cwd) {
   const config2 = await loadConfig(cwd);
   const sharing = config2.sharing;
@@ -46525,12 +46902,27 @@ async function getSharingStatus(cwd) {
       ignored.push(file2);
     }
   }
+  const hasGit = isCleoGitInitialized(cleoDir);
+  let remotes = [];
+  let pendingChanges = false;
+  let lastSync = null;
+  if (hasGit) {
+    [remotes, pendingChanges, lastSync] = await Promise.all([
+      getCleoGitRemotes(cleoDir),
+      hasCleoGitPendingChanges(cleoDir),
+      getLastSyncTimestamp(cleoDir)
+    ]);
+  }
   return {
     mode: sharing.mode,
     allowlist: sharing.commitAllowlist,
     denylist: sharing.denylist,
     tracked,
-    ignored
+    ignored,
+    hasGit,
+    remotes,
+    pendingChanges,
+    lastSync
   };
 }
 function generateGitignoreEntries(sharing) {
@@ -46585,25 +46977,25 @@ init_logger();
 init_sqlite2();
 init_tasks_schema();
 import { randomUUID as randomUUID4 } from "node:crypto";
-import { and as and6, eq as eq9 } from "drizzle-orm";
+import { and as and7, eq as eq10 } from "drizzle-orm";
 async function getLinksByProvider(providerId, cwd) {
   const db = await getDb(cwd);
-  const rows = await db.select().from(externalTaskLinks).where(eq9(externalTaskLinks.providerId, providerId));
+  const rows = await db.select().from(externalTaskLinks).where(eq10(externalTaskLinks.providerId, providerId));
   return rows.map(rowToLink);
 }
 async function getLinkByExternalId(providerId, externalId, cwd) {
   const db = await getDb(cwd);
   const rows = await db.select().from(externalTaskLinks).where(
-    and6(
-      eq9(externalTaskLinks.providerId, providerId),
-      eq9(externalTaskLinks.externalId, externalId)
+    and7(
+      eq10(externalTaskLinks.providerId, providerId),
+      eq10(externalTaskLinks.externalId, externalId)
     )
   );
   return rows.length > 0 ? rowToLink(rows[0]) : null;
 }
 async function getLinksByTaskId(taskId, cwd) {
   const db = await getDb(cwd);
-  const rows = await db.select().from(externalTaskLinks).where(eq9(externalTaskLinks.taskId, taskId));
+  const rows = await db.select().from(externalTaskLinks).where(eq10(externalTaskLinks.taskId, taskId));
   return rows.map(rowToLink);
 }
 async function createLink(params, cwd) {
@@ -46647,11 +47039,11 @@ async function touchLink(linkId, updates, cwd) {
   if (updates?.metadata !== void 0) {
     values.metadataJson = JSON.stringify(updates.metadata);
   }
-  await db.update(externalTaskLinks).set(values).where(eq9(externalTaskLinks.id, linkId));
+  await db.update(externalTaskLinks).set(values).where(eq10(externalTaskLinks.id, linkId));
 }
 async function removeLinksByProvider(providerId, cwd) {
   const db = await getDb(cwd);
-  const result = await db.delete(externalTaskLinks).where(eq9(externalTaskLinks.providerId, providerId));
+  const result = await db.delete(externalTaskLinks).where(eq10(externalTaskLinks.providerId, providerId));
   return Number(result.changes);
 }
 function rowToLink(row) {
@@ -49703,7 +50095,7 @@ import { execFileSync as execFileSync7 } from "node:child_process";
 import { existsSync as existsSync63, renameSync as renameSync5 } from "node:fs";
 import { readFile as readFile12 } from "node:fs/promises";
 import { join as join67 } from "node:path";
-import { and as and7, count, desc as desc4, eq as eq10 } from "drizzle-orm";
+import { and as and8, count, desc as desc4, eq as eq11 } from "drizzle-orm";
 init_paths();
 init_tasks_schema();
 
@@ -50003,7 +50395,7 @@ function rowToManifest(row) {
 }
 async function findLatestPushedVersion(cwd) {
   const db = await getDb2(cwd);
-  const rows = await db.select({ version: releaseManifests.version }).from(releaseManifests).where(eq10(releaseManifests.status, "pushed")).orderBy(desc4(releaseManifests.pushedAt)).limit(1).all();
+  const rows = await db.select({ version: releaseManifests.version }).from(releaseManifests).where(eq11(releaseManifests.status, "pushed")).orderBy(desc4(releaseManifests.pushedAt)).limit(1).all();
   return rows[0]?.version;
 }
 async function prepareRelease(version2, tasks2, notes, loadTasksFn, cwd) {
@@ -50015,7 +50407,7 @@ async function prepareRelease(version2, tasks2, notes, loadTasksFn, cwd) {
   }
   const normalizedVersion = normalizeVersion(version2);
   const db = await getDb2(cwd);
-  const existing = await db.select().from(releaseManifests).where(eq10(releaseManifests.version, normalizedVersion)).limit(1).all();
+  const existing = await db.select().from(releaseManifests).where(eq11(releaseManifests.version, normalizedVersion)).limit(1).all();
   if (existing.length > 0) {
     throw new Error(`Release ${normalizedVersion} already exists (status: ${existing[0].status})`);
   }
@@ -50055,7 +50447,7 @@ async function generateReleaseChangelog(version2, loadTasksFn, cwd) {
   }
   const normalizedVersion = normalizeVersion(version2);
   const db = await getDb2(cwd);
-  const rows = await db.select().from(releaseManifests).where(eq10(releaseManifests.version, normalizedVersion)).limit(1).all();
+  const rows = await db.select().from(releaseManifests).where(eq11(releaseManifests.version, normalizedVersion)).limit(1).all();
   if (rows.length === 0) {
     throw new Error(`Release ${normalizedVersion} not found`);
   }
@@ -50192,7 +50584,7 @@ async function generateReleaseChangelog(version2, loadTasksFn, cwd) {
     sections.push("");
   }
   const changelog = sections.join("\n");
-  await db.update(releaseManifests).set({ changelog }).where(eq10(releaseManifests.version, normalizedVersion)).run();
+  await db.update(releaseManifests).set({ changelog }).where(eq11(releaseManifests.version, normalizedVersion)).run();
   const changelogPath = join67(cwd ?? process.cwd(), "CHANGELOG.md");
   let existingChangelogContent = "";
   try {
@@ -50230,8 +50622,8 @@ async function listManifestReleases(optionsOrCwd, cwd) {
   const db = await getDb2(effectiveCwd);
   const totalRow = await db.select({ count: count() }).from(releaseManifests).get();
   const total = totalRow?.count ?? 0;
-  const conditions = options.status ? [eq10(releaseManifests.status, options.status)] : [];
-  const whereClause = conditions.length > 0 ? and7(...conditions) : void 0;
+  const conditions = options.status ? [eq11(releaseManifests.status, options.status)] : [];
+  const whereClause = conditions.length > 0 ? and8(...conditions) : void 0;
   const filteredRow = await db.select({ count: count() }).from(releaseManifests).where(whereClause).get();
   const filtered = filteredRow?.count ?? 0;
   let query = db.select().from(releaseManifests).where(whereClause).orderBy(desc4(releaseManifests.createdAt));
@@ -50262,7 +50654,7 @@ async function showManifestRelease(version2, cwd) {
   }
   const normalizedVersion = normalizeVersion(version2);
   const db = await getDb2(cwd);
-  const rows = await db.select().from(releaseManifests).where(eq10(releaseManifests.version, normalizedVersion)).limit(1).all();
+  const rows = await db.select().from(releaseManifests).where(eq11(releaseManifests.version, normalizedVersion)).limit(1).all();
   if (rows.length === 0) {
     throw new Error(`Release ${normalizedVersion} not found`);
   }
@@ -50274,7 +50666,7 @@ async function commitRelease(version2, cwd) {
   }
   const normalizedVersion = normalizeVersion(version2);
   const db = await getDb2(cwd);
-  const rows = await db.select().from(releaseManifests).where(eq10(releaseManifests.version, normalizedVersion)).limit(1).all();
+  const rows = await db.select().from(releaseManifests).where(eq11(releaseManifests.version, normalizedVersion)).limit(1).all();
   if (rows.length === 0) {
     throw new Error(`Release ${normalizedVersion} not found`);
   }
@@ -50284,7 +50676,7 @@ async function commitRelease(version2, cwd) {
     );
   }
   const committedAt = (/* @__PURE__ */ new Date()).toISOString();
-  await db.update(releaseManifests).set({ status: "committed", committedAt }).where(eq10(releaseManifests.version, normalizedVersion)).run();
+  await db.update(releaseManifests).set({ status: "committed", committedAt }).where(eq11(releaseManifests.version, normalizedVersion)).run();
   return { version: normalizedVersion, status: "committed", committedAt };
 }
 async function tagRelease(version2, cwd) {
@@ -50293,12 +50685,12 @@ async function tagRelease(version2, cwd) {
   }
   const normalizedVersion = normalizeVersion(version2);
   const db = await getDb2(cwd);
-  const rows = await db.select().from(releaseManifests).where(eq10(releaseManifests.version, normalizedVersion)).limit(1).all();
+  const rows = await db.select().from(releaseManifests).where(eq11(releaseManifests.version, normalizedVersion)).limit(1).all();
   if (rows.length === 0) {
     throw new Error(`Release ${normalizedVersion} not found`);
   }
   const taggedAt = (/* @__PURE__ */ new Date()).toISOString();
-  await db.update(releaseManifests).set({ status: "tagged", taggedAt }).where(eq10(releaseManifests.version, normalizedVersion)).run();
+  await db.update(releaseManifests).set({ status: "tagged", taggedAt }).where(eq11(releaseManifests.version, normalizedVersion)).run();
   return { version: normalizedVersion, status: "tagged", taggedAt };
 }
 async function runReleaseGates(version2, loadTasksFn, cwd, opts) {
@@ -50307,7 +50699,7 @@ async function runReleaseGates(version2, loadTasksFn, cwd, opts) {
   }
   const normalizedVersion = normalizeVersion(version2);
   const db = await getDb2(cwd);
-  const rows = await db.select().from(releaseManifests).where(eq10(releaseManifests.version, normalizedVersion)).limit(1).all();
+  const rows = await db.select().from(releaseManifests).where(eq11(releaseManifests.version, normalizedVersion)).limit(1).all();
   if (rows.length === 0) {
     throw new Error(`Release ${normalizedVersion} not found`);
   }
@@ -50455,7 +50847,7 @@ async function cancelRelease(version2, projectRoot) {
   }
   const normalizedVersion = normalizeVersion(version2);
   const db = await getDb2(projectRoot);
-  const rows = await db.select().from(releaseManifests).where(eq10(releaseManifests.version, normalizedVersion)).limit(1).all();
+  const rows = await db.select().from(releaseManifests).where(eq11(releaseManifests.version, normalizedVersion)).limit(1).all();
   if (rows.length === 0) {
     return {
       success: false,
@@ -50472,7 +50864,7 @@ async function cancelRelease(version2, projectRoot) {
       version: normalizedVersion
     };
   }
-  await db.delete(releaseManifests).where(eq10(releaseManifests.version, normalizedVersion)).run();
+  await db.delete(releaseManifests).where(eq11(releaseManifests.version, normalizedVersion)).run();
   return {
     success: true,
     message: `Release ${normalizedVersion} cancelled and removed`,
@@ -50485,12 +50877,12 @@ async function rollbackRelease(version2, reason, cwd) {
   }
   const normalizedVersion = normalizeVersion(version2);
   const db = await getDb2(cwd);
-  const rows = await db.select().from(releaseManifests).where(eq10(releaseManifests.version, normalizedVersion)).limit(1).all();
+  const rows = await db.select().from(releaseManifests).where(eq11(releaseManifests.version, normalizedVersion)).limit(1).all();
   if (rows.length === 0) {
     throw new Error(`Release ${normalizedVersion} not found`);
   }
   const previousStatus = rows[0].status;
-  await db.update(releaseManifests).set({ status: "rolled_back" }).where(eq10(releaseManifests.version, normalizedVersion)).run();
+  await db.update(releaseManifests).set({ status: "rolled_back" }).where(eq11(releaseManifests.version, normalizedVersion)).run();
   return {
     version: normalizedVersion,
     previousStatus,
@@ -50600,7 +50992,7 @@ async function markReleasePushed(version2, pushedAt, cwd, provenance) {
     pushedAt,
     ...provenance?.commitSha != null ? { commitSha: provenance.commitSha } : {},
     ...provenance?.gitTag != null ? { gitTag: provenance.gitTag } : {}
-  }).where(eq10(releaseManifests.version, normalizedVersion)).run();
+  }).where(eq11(releaseManifests.version, normalizedVersion)).run();
 }
 async function migrateReleasesJsonToSqlite(projectRoot) {
   const releasesPath = join67(getCleoDirAbsolute(projectRoot), "releases.json");
@@ -50620,7 +51012,7 @@ async function migrateReleasesJsonToSqlite(projectRoot) {
   const db = await getDb2(projectRoot);
   let migrated = 0;
   for (const r of raw.releases) {
-    const existing = await db.select({ id: releaseManifests.id }).from(releaseManifests).where(eq10(releaseManifests.version, r.version)).limit(1).all();
+    const existing = await db.select({ id: releaseManifests.id }).from(releaseManifests).where(eq11(releaseManifests.version, r.version)).limit(1).all();
     if (existing.length > 0) continue;
     const id = `rel-${r.version.replace(/[^a-z0-9]/gi, "-")}`;
     await db.insert(releaseManifests).values({
@@ -56078,7 +56470,7 @@ async function queryTasks(cwd, since) {
   try {
     const { getDb: getDb3 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
     const { tasks: tasks2 } = await Promise.resolve().then(() => (init_tasks_schema(), tasks_schema_exports));
-    const { and: and8, gte: gte3 } = await import("drizzle-orm");
+    const { and: and9, gte: gte3 } = await import("drizzle-orm");
     const db = await getDb3(cwd);
     const conditions = [];
     if (since) {
@@ -56092,7 +56484,7 @@ async function queryTasks(cwd, since) {
       sessionId: tasks2.sessionId,
       completedAt: tasks2.completedAt,
       createdAt: tasks2.createdAt
-    }).from(tasks2).where(conditions.length > 0 ? and8(...conditions) : void 0).all();
+    }).from(tasks2).where(conditions.length > 0 ? and9(...conditions) : void 0).all();
     return rows;
   } catch (err) {
     log7.warn({ err }, "Failed to query tasks for workflow telemetry");
@@ -56103,7 +56495,7 @@ async function queryCompletionAuditRows(cwd, since) {
   try {
     const { getDb: getDb3 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
     const { auditLog: auditLog2 } = await Promise.resolve().then(() => (init_tasks_schema(), tasks_schema_exports));
-    const { and: and8, gte: gte3 } = await import("drizzle-orm");
+    const { and: and9, gte: gte3 } = await import("drizzle-orm");
     const db = await getDb3(cwd);
     const conditions = [];
     if (since) conditions.push(gte3(auditLog2.timestamp, since));
@@ -56115,7 +56507,7 @@ async function queryCompletionAuditRows(cwd, since) {
       afterJson: auditLog2.afterJson,
       operation: auditLog2.operation,
       domain: auditLog2.domain
-    }).from(auditLog2).where(conditions.length > 0 ? and8(...conditions) : void 0).orderBy(auditLog2.timestamp).all();
+    }).from(auditLog2).where(conditions.length > 0 ? and9(...conditions) : void 0).orderBy(auditLog2.timestamp).all();
     return allRows.filter((row) => {
       const isComplete = row.action === "task_completed" || row.action === "complete" || row.operation === "complete" && row.domain === "tasks";
       if (!isComplete && row.afterJson) {
@@ -64084,45 +64476,67 @@ async function bootstrapGlobalCleo(options) {
   await installSkillsGlobally(ctx);
   await installAgentDefinitionGlobally(ctx);
   await installProviderAdapters(ctx, options?.packageRoot);
+  await verifyBootstrapHealth(ctx);
   return ctx;
 }
+async function writeTemplateTo(content, destPath, isDryRun) {
+  if (isDryRun) return false;
+  const { dirname: dirname20 } = await import("node:path");
+  await mkdir17(dirname20(destPath), { recursive: true });
+  await writeFile12(destPath, content);
+  return true;
+}
 async function ensureGlobalTemplatesBootstrap(ctx, packageRootOverride) {
   const globalTemplatesDir = getCleoTemplatesDir();
   if (!ctx.isDryRun) {
     await mkdir17(globalTemplatesDir, { recursive: true });
   }
+  let templateContent = null;
   try {
     const pkgRoot = packageRootOverride ?? getPackageRoot();
     const templatePath = join104(pkgRoot, "templates", "CLEO-INJECTION.md");
     if (existsSync103(templatePath)) {
-      const content = readFileSync77(templatePath, "utf-8");
-      const destPath = join104(globalTemplatesDir, "CLEO-INJECTION.md");
-      if (!ctx.isDryRun) {
-        await writeFile12(destPath, content);
-      }
-      ctx.created.push(
-        `~/.cleo/templates/CLEO-INJECTION.md (${ctx.isDryRun ? "would refresh" : "refreshed"})`
-      );
-    } else {
-      try {
-        const { getInjectionTemplateContent: getInjectionTemplateContent2 } = await Promise.resolve().then(() => (init_injection(), injection_exports));
-        const content = getInjectionTemplateContent2();
-        if (content) {
-          const destPath = join104(globalTemplatesDir, "CLEO-INJECTION.md");
-          if (!ctx.isDryRun) {
-            await writeFile12(destPath, content);
-          }
-          ctx.created.push(
-            `~/.cleo/templates/CLEO-INJECTION.md (${ctx.isDryRun ? "would refresh" : "refreshed"} from embedded)`
-          );
-        }
-      } catch {
-        ctx.warnings.push("Could not refresh CLEO-INJECTION.md template");
-      }
+      templateContent = readFileSync77(templatePath, "utf-8");
     }
   } catch {
+  }
+  if (!templateContent) {
+    try {
+      const { getInjectionTemplateContent: getInjectionTemplateContent2 } = await Promise.resolve().then(() => (init_injection(), injection_exports));
+      templateContent = getInjectionTemplateContent2() ?? null;
+    } catch {
+      ctx.warnings.push("Could not refresh CLEO-INJECTION.md template");
+      return;
+    }
+  }
+  if (!templateContent) {
     ctx.warnings.push("Could not refresh CLEO-INJECTION.md template");
+    return;
   }
+  const xdgDest = join104(globalTemplatesDir, "CLEO-INJECTION.md");
+  const xdgWritten = await writeTemplateTo(templateContent, xdgDest, ctx.isDryRun);
+  ctx.created.push(
+    `${getCleoTemplatesTildePath()}/CLEO-INJECTION.md (${xdgWritten ? "refreshed" : "would refresh"})`
+  );
+  const home = homedir6();
+  const legacyTemplatesDir = join104(home, ".cleo", "templates");
+  if (legacyTemplatesDir !== globalTemplatesDir && existsSync103(join104(home, ".cleo"))) {
+    const legacyDest = join104(legacyTemplatesDir, "CLEO-INJECTION.md");
+    const legacyWritten = await writeTemplateTo(templateContent, legacyDest, ctx.isDryRun);
+    if (legacyWritten) {
+      ctx.created.push("~/.cleo/templates/CLEO-INJECTION.md (legacy sync)");
+    }
+  }
+}
+function sanitizeCaampFile(content) {
+  let cleaned = content.replace(/(<!-- CAAMP:END -->)\s*(<!-- CAAMP:END -->)/g, "$1");
+  cleaned = cleaned.replace(
+    /<!-- CAAMP:END -->\s*[A-Z][A-Za-z-]*\.md\s*(?:<!-- CAAMP:END -->)?/g,
+    "<!-- CAAMP:END -->"
+  );
+  cleaned = cleaned.replace(/^[A-Z][A-Za-z-]*\.md\s*$/gm, "");
+  cleaned = cleaned.replace(/\n{3,}/g, "\n\n");
+  return cleaned.trim() + "\n";
 }
 async function injectAgentsHub(ctx) {
   const globalAgentsDir = getAgentsHome();
@@ -64137,13 +64551,23 @@ async function injectAgentsHub(ctx) {
           /\n?<!-- CLEO:START[^>]*-->[\s\S]*?<!-- CLEO:END -->\n?/g,
           ""
         );
-        if (stripped !== content) {
-          await writeFile12(globalAgentsMd, stripped, "utf8");
+        const sanitized = sanitizeCaampFile(stripped);
+        if (sanitized !== content) {
+          await writeFile12(globalAgentsMd, sanitized, "utf8");
+          ctx.created.push("~/.agents/AGENTS.md (sanitized CAAMP corruption)");
         }
       }
       const templateRef = `@${getCleoTemplatesTildePath()}/CLEO-INJECTION.md`;
       const action = await inject2(globalAgentsMd, templateRef);
       ctx.created.push(`~/.agents/AGENTS.md (${action})`);
+      const postContent = await readFile19(globalAgentsMd, "utf8");
+      const caampBlocks = postContent.match(/<!-- CAAMP:START -->/g);
+      const caampEnds = postContent.match(/<!-- CAAMP:END -->/g);
+      if (caampBlocks && caampEnds && caampBlocks.length !== caampEnds.length) {
+        ctx.warnings.push(
+          `~/.agents/AGENTS.md has mismatched CAAMP markers (${caampBlocks.length} START vs ${caampEnds.length} END)`
+        );
+      }
     } else {
       ctx.created.push("~/.agents/AGENTS.md (would create/update CAAMP block)");
     }
@@ -64277,6 +64701,45 @@ async function installProviderAdapters(ctx, packageRootOverride) {
     );
   }
 }
+async function verifyBootstrapHealth(ctx) {
+  if (ctx.isDryRun) return;
+  try {
+    const xdgTemplatePath = join104(getCleoTemplatesDir(), "CLEO-INJECTION.md");
+    const agentsMd = join104(getAgentsHome(), "AGENTS.md");
+    if (!existsSync103(xdgTemplatePath)) {
+      ctx.warnings.push("Health: XDG template missing after bootstrap");
+      return;
+    }
+    const xdgContent = await readFile19(xdgTemplatePath, "utf8");
+    const xdgVersion = xdgContent.match(/^Version:\s*(.+)$/m)?.[1]?.trim();
+    const home = homedir6();
+    const legacyTemplatePath = join104(home, ".cleo", "templates", "CLEO-INJECTION.md");
+    if (existsSync103(legacyTemplatePath)) {
+      const legacyContent = await readFile19(legacyTemplatePath, "utf8");
+      const legacyVersion = legacyContent.match(/^Version:\s*(.+)$/m)?.[1]?.trim();
+      if (legacyVersion !== xdgVersion) {
+        ctx.warnings.push(
+          `Health: Legacy template version (${legacyVersion}) != XDG version (${xdgVersion})`
+        );
+      }
+    }
+    if (existsSync103(agentsMd)) {
+      const agentsContent = await readFile19(agentsMd, "utf8");
+      const expectedRef = `@${getCleoTemplatesTildePath()}/CLEO-INJECTION.md`;
+      if (!agentsContent.includes(expectedRef)) {
+        ctx.warnings.push(`Health: ~/.agents/AGENTS.md does not reference ${expectedRef}`);
+      }
+      const outsideCaamp = agentsContent.replace(
+        /<!-- CAAMP:START -->[\s\S]*?<!-- CAAMP:END -->/g,
+        ""
+      );
+      if (/[A-Z][A-Za-z-]*\.md/.test(outsideCaamp)) {
+        ctx.warnings.push("Health: ~/.agents/AGENTS.md has orphaned content outside CAAMP blocks");
+      }
+    }
+  } catch {
+  }
+}
 
 // packages/core/src/cleo.ts
 import path from "node:path";
@@ -64351,7 +64814,10 @@ var Cleo = class _Cleo {
       ),
       complete: (p) => completeTask({ taskId: p.taskId, notes: p.notes }, root, store),
       delete: (p) => deleteTask({ taskId: p.taskId, force: p.force }, root, store),
-      archive: (p) => archiveTasks({ before: p?.before, taskIds: p?.taskIds, dryRun: p?.dryRun }, root, store)
+      archive: (p) => archiveTasks({ before: p?.before, taskIds: p?.taskIds, dryRun: p?.dryRun }, root, store),
+      start: (taskId) => startTask(taskId, root, store),
+      stop: () => stopTask(root, store),
+      current: () => currentTask(root, store)
     };
   }
   // === Sessions ===
@@ -64359,7 +64825,11 @@ var Cleo = class _Cleo {
     const root = this.projectRoot;
     const store = this._store ?? void 0;
     return {
-      start: (p) => startSession({ name: p.name, scope: p.scope, agent: p.agent }, root, store),
+      start: (p) => startSession(
+        { name: p.name, scope: p.scope, agent: p.agent, startTask: p.startTask },
+        root,
+        store
+      ),
       end: (p) => endSession({ note: p?.note }, root, store),
       status: () => sessionStatus(root, store),
       resume: (id) => resumeSession(id, root, store),
@@ -64497,6 +64967,35 @@ var Cleo = class _Cleo {
       sharingStatus: () => getSharingStatus()
     };
   }
+  // === Agents ===
+  get agents() {
+    const root = this.projectRoot;
+    return {
+      register: (opts) => registerAgent(opts, root),
+      deregister: (agentId) => deregisterAgent(agentId, root),
+      health: (agentId) => checkAgentHealth2(agentId, void 0, root),
+      detectCrashed: (thresholdMs) => detectCrashedAgents(thresholdMs, root),
+      recordHeartbeat: (agentId) => heartbeat(agentId, root),
+      capacity: (agentId) => getAgentCapacity(agentId, root),
+      isOverloaded: (threshold) => isOverloaded(threshold, root),
+      list: (p) => listAgentInstances(
+        {
+          status: p?.status,
+          agentType: p?.agentType
+        },
+        root
+      )
+    };
+  }
+  // === Intelligence ===
+  get intelligence() {
+    const root = this.projectRoot;
+    const store = this._store ?? void 0;
+    return {
+      predictImpact: (change) => predictImpact(change, root, store ?? void 0),
+      blastRadius: (taskId) => calculateBlastRadius(taskId, store ?? void 0, root)
+    };
+  }
   // === Sync (Task Reconciliation) ===
   get sync() {
     const root = this.projectRoot;
@@ -64668,6 +65167,7 @@ export {
   isSuccessCode,
   isValidStatus,
   issue_exports as issue,
+  lib_exports as lib,
   lifecycle_exports as lifecycle,
   lifecycleEvidenceTypeSchema,
   lifecycleGateResultSchema,