@cleocode/cleo 2026.3.58 → 2026.3.60

package/dist/mcp/index.js

@@ -13163,9 +13163,9 @@ async function readSequenceFromDb(cwd, accessor) {
     return isValidSequenceState(value) ? value : null;
   }
   const { getDb: getDb4 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
-  const { eq: eq16 } = await import("drizzle-orm");
+  const { eq: eq17 } = await import("drizzle-orm");
   const db = await getDb4(cwd);
-  const rows = await db.select().from(schemaMeta).where(eq16(schemaMeta.key, SEQUENCE_META_KEY)).all();
+  const rows = await db.select().from(schemaMeta).where(eq17(schemaMeta.key, SEQUENCE_META_KEY)).all();
   const raw = rows[0]?.value;
   if (!raw) return null;
   try {
@@ -15276,7 +15276,7 @@ async function linkPipelineAdr(projectRoot, taskId) {
     return result;
   }
   const { getDb: getDb4 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
-  const { and: and11, eq: eq16 } = await import("drizzle-orm");
+  const { and: and12, eq: eq17 } = await import("drizzle-orm");
   const db = await getDb4(projectRoot);
   const now2 = (/* @__PURE__ */ new Date()).toISOString();
   for (const filePath of matchingFiles) {
@@ -15286,7 +15286,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(eq16(architectureDecisions.id, record2.id)).all();
+      const existing = await db.select({ id: architectureDecisions.id }).from(architectureDecisions).where(eq17(architectureDecisions.id, record2.id)).all();
       const rowBase = {
         id: record2.id,
         title: record2.title,
@@ -15306,19 +15306,19 @@ async function linkPipelineAdr(projectRoot, taskId) {
         updatedAt: now2
       };
       if (existing.length > 0) {
-        await db.update(architectureDecisions).set(rowBase).where(eq16(architectureDecisions.id, record2.id));
+        await db.update(architectureDecisions).set(rowBase).where(eq17(architectureDecisions.id, record2.id));
       } else {
         await db.insert(architectureDecisions).values({ ...rowBase, createdAt: now2 });
       }
       result.synced++;
-      await db.delete(adrTaskLinks).where(and11(eq16(adrTaskLinks.adrId, record2.id), eq16(adrTaskLinks.taskId, taskId)));
+      await db.delete(adrTaskLinks).where(and12(eq17(adrTaskLinks.adrId, record2.id), eq17(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(eq16(architectureDecisions.id, toId)).all();
+            const targetExists = await db.select({ id: architectureDecisions.id }).from(architectureDecisions).where(eq17(architectureDecisions.id, toId)).all();
             if (targetExists.length > 0) {
               await db.insert(adrRelations).values({ fromAdrId: record2.id, toAdrId: toId, relationType: "related" }).onConflictDoNothing();
             }
@@ -15479,7 +15479,7 @@ async function syncAdrsToDb(projectRoot) {
     return result;
   }
   const { getDb: getDb4 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
-  const { eq: eq16 } = await import("drizzle-orm");
+  const { eq: eq17 } = await import("drizzle-orm");
   const db = await getDb4(projectRoot);
   const now2 = (/* @__PURE__ */ new Date()).toISOString();
   const allFiles = collectAdrFiles(adrsDir);
@@ -15513,15 +15513,15 @@ async function syncAdrsToDb(projectRoot) {
         topics: fm.Topics ?? null,
         updatedAt: now2
       };
-      const existing = await db.select({ id: architectureDecisions.id }).from(architectureDecisions).where(eq16(architectureDecisions.id, record2.id)).all();
+      const existing = await db.select({ id: architectureDecisions.id }).from(architectureDecisions).where(eq17(architectureDecisions.id, record2.id)).all();
       if (existing.length > 0) {
-        await db.update(architectureDecisions).set(rowBase).where(eq16(architectureDecisions.id, record2.id));
+        await db.update(architectureDecisions).set(rowBase).where(eq17(architectureDecisions.id, record2.id));
         result.updated++;
       } else {
         await db.insert(architectureDecisions).values({ ...rowBase, createdAt: now2 });
         result.inserted++;
       }
-      await db.delete(adrTaskLinks).where(eq16(adrTaskLinks.adrId, record2.id));
+      await db.delete(adrTaskLinks).where(eq17(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" });
@@ -15657,310 +15657,8 @@ var init_adrs = __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 now2 = /* @__PURE__ */ new Date();
-  const ts = now2.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 now2 = (/* @__PURE__ */ new Date()).toISOString();
-  const row = {
-    id,
-    agentType: opts.agentType,
-    status: "starting",
-    sessionId: opts.sessionId ?? null,
-    taskId: opts.taskId ?? null,
-    startedAt: now2,
-    lastHeartbeat: now2,
-    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 now2 = (/* @__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: now2 }).where(eq5(agentInstances.id, id));
-  return { ...existing, status: "stopped", stoppedAt: now2 };
-}
-async function heartbeat(id, cwd) {
-  const db = await getDb(cwd);
-  const now2 = (/* @__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: now2 }).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/agents/capacity.ts
-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));
-}
-var init_capacity = __esm({
-  "packages/core/src/agents/capacity.ts"() {
-    "use strict";
-    init_sqlite2();
-    init_agent_schema();
-    init_registry2();
-  }
-});
-
 // 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);
@@ -15980,30 +15678,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);
@@ -16011,34 +15709,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);
@@ -16046,18 +15744,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 = {}) {
@@ -16066,11 +15764,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);
@@ -16078,37 +15776,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);
@@ -16116,7 +15814,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
@@ -16126,22 +15824,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)
           )
         );
       }
@@ -16150,27 +15848,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);
@@ -16178,31 +15876,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);
@@ -16211,9 +15909,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)
@@ -16221,34 +15919,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 = [];
@@ -16260,10 +15958,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)
           )
         );
       }
@@ -16272,15 +15970,15 @@ var init_brain_accessor = __esm({
 });
 
 // packages/core/src/agents/execution-learning.ts
-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);
@@ -16563,6 +16261,473 @@ var init_execution_learning = __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 now2 = /* @__PURE__ */ new Date();
+  const ts = now2.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 now2 = (/* @__PURE__ */ new Date()).toISOString();
+  const row = {
+    id,
+    agentType: opts.agentType,
+    status: "starting",
+    sessionId: opts.sessionId ?? null,
+    taskId: opts.taskId ?? null,
+    startedAt: now2,
+    lastHeartbeat: now2,
+    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 now2 = (/* @__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: now2 }).where(eq6(agentInstances.id, id));
+  return { ...existing, status: "stopped", stoppedAt: now2 };
+}
+async function heartbeat(id, cwd) {
+  const db = await getDb(cwd);
+  const now2 = (/* @__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: now2 }).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/agents/agent-registry.ts
+import { and as and5, eq as eq7, inArray as inArray5 } from "drizzle-orm";
+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 isTerminal2 = agent.status === "stopped" || agent.status === "crashed";
+  if (isTerminal2) {
+    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;
+}
+var MAX_TASKS_PER_AGENT;
+var init_agent_registry = __esm({
+  "packages/core/src/agents/agent-registry.ts"() {
+    "use strict";
+    init_sqlite2();
+    init_agent_schema();
+    init_execution_learning();
+    init_registry2();
+    MAX_TASKS_PER_AGENT = 5;
+  }
+});
+
+// packages/core/src/agents/capacity.ts
+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));
+}
+var init_capacity = __esm({
+  "packages/core/src/agents/capacity.ts"() {
+    "use strict";
+    init_sqlite2();
+    init_agent_schema();
+    init_registry2();
+  }
+});
+
+// packages/core/src/agents/health-monitor.ts
+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
+  };
+}
+var HEARTBEAT_INTERVAL_MS, STALE_THRESHOLD_MS, ALIVE_STATUSES;
+var init_health_monitor = __esm({
+  "packages/core/src/agents/health-monitor.ts"() {
+    "use strict";
+    init_registry2();
+    HEARTBEAT_INTERVAL_MS = 3e4;
+    STALE_THRESHOLD_MS = 3 * 6e4;
+    ALIVE_STATUSES = ["starting", "active", "idle"];
+  }
+});
+
 // packages/core/src/agents/retry.ts
 function createRetryPolicy(overrides) {
   return { ...DEFAULT_RETRY_POLICY, ...overrides };
@@ -16689,18 +16854,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,
@@ -16712,11 +16886,14 @@ __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
@@ -16724,9 +16901,11 @@ __export(agents_exports, {
 var init_agents = __esm({
   "packages/core/src/agents/index.ts"() {
     "use strict";
+    init_agent_registry();
     init_agent_schema();
     init_capacity();
     init_execution_learning();
+    init_health_monitor();
     init_registry2();
     init_retry();
   }
@@ -20598,19 +20777,19 @@ async function queryAudit(options) {
   try {
     const { getDb: getDb4 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
     const { auditLog: auditLog2 } = await Promise.resolve().then(() => (init_tasks_schema(), tasks_schema_exports));
-    const { and: and11, eq: eq16, gte: gte4, or: or6 } = await import("drizzle-orm");
+    const { and: and12, eq: eq17, gte: gte4, or: or6 } = await import("drizzle-orm");
     const db = await getDb4(process.cwd());
     const conditions = [];
-    if (options?.sessionId) conditions.push(eq16(auditLog2.sessionId, options.sessionId));
-    if (options?.domain) conditions.push(eq16(auditLog2.domain, options.domain));
+    if (options?.sessionId) conditions.push(eq17(auditLog2.sessionId, options.sessionId));
+    if (options?.domain) conditions.push(eq17(auditLog2.domain, options.domain));
     if (options?.operation)
       conditions.push(
-        or6(eq16(auditLog2.operation, options.operation), eq16(auditLog2.action, options.operation))
+        or6(eq17(auditLog2.operation, options.operation), eq17(auditLog2.action, options.operation))
       );
-    if (options?.taskId) conditions.push(eq16(auditLog2.taskId, options.taskId));
+    if (options?.taskId) conditions.push(eq17(auditLog2.taskId, options.taskId));
     if (options?.since) conditions.push(gte4(auditLog2.timestamp, options.since));
     const limit = options?.limit ?? 1e3;
-    const rows = await db.select().from(auditLog2).where(conditions.length > 0 ? and11(...conditions) : void 0).orderBy(auditLog2.timestamp).limit(limit);
+    const rows = await db.select().from(auditLog2).where(conditions.length > 0 ? and12(...conditions) : void 0).orderBy(auditLog2.timestamp).limit(limit);
     return rows.map((row) => ({
       timestamp: row.timestamp,
       sessionId: row.sessionId,
@@ -34355,6 +34534,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
+  };
+}
 var init_impact = __esm({
   "packages/core/src/intelligence/impact.ts"() {
     "use strict";
@@ -34758,6 +35047,7 @@ __export(intelligence_exports, {
   gatherLearningContext: () => gatherLearningContext,
   matchPatterns: () => matchPatterns,
   predictAndStore: () => predictAndStore,
+  predictImpact: () => predictImpact,
   predictValidationOutcome: () => predictValidationOutcome,
   scoreVerificationConfidence: () => scoreVerificationConfidence,
   storeDetectedPattern: () => storeDetectedPattern,
@@ -35572,6 +35862,7 @@ import { execFile as execFile3 } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { existsSync as existsSync34, 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";
@@ -36383,12 +36674,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 (existsSync34(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
   };
 }
@@ -36506,13 +36815,13 @@ function extractYamlArray(content, field) {
   }
   const lines = content.split("\n");
   const items = [];
-  let inArray6 = false;
+  let inArray7 = false;
   for (const line2 of lines) {
     if (line2.match(new RegExp(`^${field}:`))) {
-      inArray6 = true;
+      inArray7 = true;
       continue;
     }
-    if (inArray6) {
+    if (inArray7) {
       const itemMatch = line2.match(/^\s+-\s+["']?(.+?)["']?\s*$/);
       if (itemMatch) {
         items.push(itemMatch[1].trim());
@@ -36808,6 +37117,71 @@ var init_issue = __esm({
   }
 });
 
+// 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((resolve13) => setTimeout(resolve13, ms));
+}
+var init_retry2 = __esm({
+  "packages/core/src/lib/retry.ts"() {
+    "use strict";
+  }
+});
+
+// packages/core/src/lib/index.ts
+var lib_exports = {};
+__export(lib_exports, {
+  computeDelay: () => computeDelay,
+  withRetry: () => withRetry2
+});
+var init_lib = __esm({
+  "packages/core/src/lib/index.ts"() {
+    "use strict";
+    init_retry2();
+  }
+});
+
 // packages/core/src/lifecycle/evidence.ts
 import { basename as basename5, relative as relative2 } from "node:path";
 async function recordEvidence(epicId, stage, uri, type, options) {
@@ -37647,12 +38021,12 @@ async function getEnforcementMode(cwd) {
 }
 async function getLifecycleStatus(epicId, cwd) {
   const { getDb: getDb4 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
-  const { eq: eq16 } = await import("drizzle-orm");
+  const { eq: eq17 } = await import("drizzle-orm");
   const db = await getDb4(cwd);
   const pipelineResult = await db.select({
     pipeline: lifecyclePipelines,
     task: tasks
-  }).from(lifecyclePipelines).innerJoin(tasks, eq16(lifecyclePipelines.taskId, tasks.id)).where(eq16(lifecyclePipelines.taskId, epicId)).limit(1);
+  }).from(lifecyclePipelines).innerJoin(tasks, eq17(lifecyclePipelines.taskId, tasks.id)).where(eq17(lifecyclePipelines.taskId, epicId)).limit(1);
   if (pipelineResult.length === 0) {
     return {
       epicId,
@@ -37665,7 +38039,7 @@ async function getLifecycleStatus(epicId, cwd) {
   }
   const task = pipelineResult[0].task;
   const pipelineId = `pipeline-${epicId}`;
-  const stageRows = await db.select().from(lifecycleStages).where(eq16(lifecycleStages.pipelineId, pipelineId)).orderBy(lifecycleStages.sequence);
+  const stageRows = await db.select().from(lifecycleStages).where(eq17(lifecycleStages.pipelineId, pipelineId)).orderBy(lifecycleStages.sequence);
   const stageDataMap = /* @__PURE__ */ new Map();
   for (const row of stageRows) {
     let parsedChain;
@@ -37734,10 +38108,10 @@ async function getLifecycleStatus(epicId, cwd) {
 }
 async function getLifecycleHistory(epicId, cwd) {
   const { getDb: getDb4 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
-  const { eq: eq16 } = await import("drizzle-orm");
+  const { eq: eq17 } = await import("drizzle-orm");
   const db = await getDb4(cwd);
   const pipelineId = `pipeline-${epicId}`;
-  const stages = await db.select().from(lifecycleStages).where(eq16(lifecycleStages.pipelineId, pipelineId));
+  const stages = await db.select().from(lifecycleStages).where(eq17(lifecycleStages.pipelineId, pipelineId));
   if (stages.length === 0) {
     return { epicId, history: [] };
   }
@@ -37767,7 +38141,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(eq16(lifecycleGateResults.stageId, stageIds[0]));
+    const gateResults = await db.select().from(lifecycleGateResults).where(eq17(lifecycleGateResults.stageId, stageIds[0]));
     for (const gate of gateResults) {
       const stageName = stageIdToName.get(gate.stageId);
       if (stageName) {
@@ -37780,7 +38154,7 @@ async function getLifecycleHistory(epicId, cwd) {
       }
     }
     for (let i = 1; i < stageIds.length; i++) {
-      const additionalGates = await db.select().from(lifecycleGateResults).where(eq16(lifecycleGateResults.stageId, stageIds[i]));
+      const additionalGates = await db.select().from(lifecycleGateResults).where(eq17(lifecycleGateResults.stageId, stageIds[i]));
       for (const gate of additionalGates) {
         const stageName = stageIdToName.get(gate.stageId);
         if (stageName) {
@@ -37799,16 +38173,16 @@ async function getLifecycleHistory(epicId, cwd) {
 }
 async function getLifecycleGates(epicId, cwd) {
   const { getDb: getDb4 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
-  const { eq: eq16 } = await import("drizzle-orm");
+  const { eq: eq17 } = await import("drizzle-orm");
   const db = await getDb4(cwd);
   const pipelineId = `pipeline-${epicId}`;
-  const stages = await db.select().from(lifecycleStages).where(eq16(lifecycleStages.pipelineId, pipelineId));
+  const stages = await db.select().from(lifecycleStages).where(eq17(lifecycleStages.pipelineId, pipelineId));
   if (stages.length === 0) {
     return {};
   }
   const gates = {};
   for (const stage of stages) {
-    const gateRows = await db.select().from(lifecycleGateResults).where(eq16(lifecycleGateResults.stageId, stage.id));
+    const gateRows = await db.select().from(lifecycleGateResults).where(eq17(lifecycleGateResults.stageId, stage.id));
     if (gateRows.length > 0) {
       gates[stage.stageName] = {};
       for (const gateRow of gateRows) {
@@ -37872,7 +38246,7 @@ async function checkStagePrerequisites(epicId, targetStage, cwd) {
 }
 async function ensureLifecycleContext(epicId, stageName, cwd, options) {
   const { getDb: getDb4 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
-  const { eq: eq16 } = await import("drizzle-orm");
+  const { eq: eq17 } = await import("drizzle-orm");
   const db = await getDb4(cwd);
   const pipelineId = `pipeline-${epicId}`;
   const stageId = `stage-${epicId}-${stageName}`;
@@ -37880,7 +38254,7 @@ async function ensureLifecycleContext(epicId, stageName, cwd, options) {
   getNativeDb3().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(eq16(lifecyclePipelines.id, pipelineId)).limit(1).all();
+  const existingPipeline = await db.select().from(lifecyclePipelines).where(eq17(lifecyclePipelines.id, pipelineId)).limit(1).all();
   if (existingPipeline.length === 0) {
     await db.insert(lifecyclePipelines).values({
       id: pipelineId,
@@ -37890,7 +38264,7 @@ async function ensureLifecycleContext(epicId, stageName, cwd, options) {
       startedAt: options.now
     }).run();
   }
-  const existingStage = await db.select().from(lifecycleStages).where(eq16(lifecycleStages.id, stageId)).limit(1).all();
+  const existingStage = await db.select().from(lifecycleStages).where(eq17(lifecycleStages.id, stageId)).limit(1).all();
   if (existingStage.length === 0) {
     const sequence = isValidStage(stageName) ? STAGE_ORDER[stageName] : 0;
     await db.insert(lifecycleStages).values({
@@ -37903,7 +38277,7 @@ async function ensureLifecycleContext(epicId, stageName, cwd, options) {
     }).run();
   }
   if (options.updateCurrentStage) {
-    await db.update(lifecyclePipelines).set({ currentStageId: stageId }).where(eq16(lifecyclePipelines.id, pipelineId)).run();
+    await db.update(lifecyclePipelines).set({ currentStageId: stageId }).where(eq17(lifecyclePipelines.id, pipelineId)).run();
   }
   return { db, pipelineId, stageId };
 }
@@ -37918,7 +38292,7 @@ async function recordStageProgress(epicId, stage, status, notes, cwd) {
       `Invalid status: ${status}. Valid: ${validStatuses.join(", ")}`
     );
   }
-  const { eq: eq16 } = await import("drizzle-orm");
+  const { eq: eq17 } = await import("drizzle-orm");
   const now2 = (/* @__PURE__ */ new Date()).toISOString();
   const stageName = stage;
   const { db, stageId, pipelineId } = await ensureLifecycleContext(epicId, stage, cwd, {
@@ -37934,7 +38308,7 @@ async function recordStageProgress(epicId, stage, status, notes, cwd) {
     status,
     related: artifact.related
   };
-  const existingStage = await db.select().from(lifecycleStages).where(eq16(lifecycleStages.id, stageId)).limit(1).all();
+  const existingStage = await db.select().from(lifecycleStages).where(eq17(lifecycleStages.id, stageId)).limit(1).all();
   const sequence = STAGE_ORDER[stage];
   const stageValues = {
     status,
@@ -37961,7 +38335,7 @@ async function recordStageProgress(epicId, stage, status, notes, cwd) {
       provenanceChainJson: JSON.stringify(provenanceChain)
     }).run();
   } else {
-    await db.update(lifecycleStages).set(stageValues).where(eq16(lifecycleStages.id, stageId)).run();
+    await db.update(lifecycleStages).set(stageValues).where(eq17(lifecycleStages.id, stageId)).run();
   }
   if (status === "completed") {
     await linkProvenance(epicId, stageName, artifact.absolutePath, cwd);
@@ -37981,7 +38355,7 @@ async function resetStage(epicId, stage, reason, cwd) {
   if (!PIPELINE_STAGES.includes(stage)) {
     throw new CleoError(2 /* INVALID_INPUT */, `Invalid stage: ${stage}`);
   }
-  const { eq: eq16 } = await import("drizzle-orm");
+  const { eq: eq17 } = await import("drizzle-orm");
   const now2 = (/* @__PURE__ */ new Date()).toISOString();
   const { db, stageId } = await ensureLifecycleContext(epicId, stage, cwd, {
     now: now2,
@@ -37994,11 +38368,11 @@ async function resetStage(epicId, stage, reason, cwd) {
     skippedAt: null,
     skipReason: null,
     notesJson: JSON.stringify([`Reset: ${reason}`])
-  }).where(eq16(lifecycleStages.id, stageId)).run();
+  }).where(eq17(lifecycleStages.id, stageId)).run();
   return { epicId, stage, reason };
 }
 async function passGate(epicId, gateName, agent, notes, cwd) {
-  const { eq: eq16 } = await import("drizzle-orm");
+  const { eq: eq17 } = await import("drizzle-orm");
   const now2 = (/* @__PURE__ */ new Date()).toISOString();
   const stageName = gateName.split("-")[0];
   const gateId = `gate-${epicId}-${stageName}-${gateName}`;
@@ -38007,7 +38381,7 @@ async function passGate(epicId, gateName, agent, notes, cwd) {
     stageStatusOnCreate: "in_progress",
     updateCurrentStage: true
   });
-  const existingGate = await db.select().from(lifecycleGateResults).where(eq16(lifecycleGateResults.id, gateId)).limit(1).all();
+  const existingGate = await db.select().from(lifecycleGateResults).where(eq17(lifecycleGateResults.id, gateId)).limit(1).all();
   const gateValues = {
     id: gateId,
     stageId,
@@ -38019,14 +38393,14 @@ async function passGate(epicId, gateName, agent, notes, cwd) {
     reason: null
   };
   if (existingGate.length > 0) {
-    await db.update(lifecycleGateResults).set(gateValues).where(eq16(lifecycleGateResults.id, gateId)).run();
+    await db.update(lifecycleGateResults).set(gateValues).where(eq17(lifecycleGateResults.id, gateId)).run();
   } else {
     await db.insert(lifecycleGateResults).values(gateValues).run();
   }
   return { epicId, gateName, timestamp: now2 };
 }
 async function failGate(epicId, gateName, reason, cwd) {
-  const { eq: eq16 } = await import("drizzle-orm");
+  const { eq: eq17 } = await import("drizzle-orm");
   const now2 = (/* @__PURE__ */ new Date()).toISOString();
   const stageName = gateName.split("-")[0];
   const gateId = `gate-${epicId}-${stageName}-${gateName}`;
@@ -38035,7 +38409,7 @@ async function failGate(epicId, gateName, reason, cwd) {
     stageStatusOnCreate: "in_progress",
     updateCurrentStage: true
   });
-  const existingGate = await db.select().from(lifecycleGateResults).where(eq16(lifecycleGateResults.id, gateId)).limit(1).all();
+  const existingGate = await db.select().from(lifecycleGateResults).where(eq17(lifecycleGateResults.id, gateId)).limit(1).all();
   const gateValues = {
     id: gateId,
     stageId,
@@ -38047,7 +38421,7 @@ async function failGate(epicId, gateName, reason, cwd) {
     reason: reason ?? null
   };
   if (existingGate.length > 0) {
-    await db.update(lifecycleGateResults).set(gateValues).where(eq16(lifecycleGateResults.id, gateId)).run();
+    await db.update(lifecycleGateResults).set(gateValues).where(eq17(lifecycleGateResults.id, gateId)).run();
   } else {
     await db.insert(lifecycleGateResults).values(gateValues).run();
   }
@@ -38121,8 +38495,8 @@ function detectEnvMode() {
     const devKv = {};
     const devLines = devContent.trim().split("\n");
     for (let i = 1; i < devLines.length; i++) {
-      const eq16 = devLines[i].indexOf("=");
-      if (eq16 > 0) devKv[devLines[i].slice(0, eq16).trim()] = devLines[i].slice(eq16 + 1).trim();
+      const eq17 = devLines[i].indexOf("=");
+      if (eq17 > 0) devKv[devLines[i].slice(0, eq17).trim()] = devLines[i].slice(eq17 + 1).trim();
     }
     if (devKv["mode"] === "dev-ts" && devKv["source"]) {
       const devSource = devKv["source"].replace(/\\/g, "/");
@@ -38435,7 +38809,7 @@ var init_config = __esm({
           "session.autoStart": false,
           "session.requireNotes": true,
           "session.multiSession": false,
-          "hierarchy.requireAcceptanceCriteria": true,
+          "enforcement.acceptance.mode": "block",
           "lifecycle.mode": "strict"
         }
       },
@@ -38445,7 +38819,7 @@ var init_config = __esm({
           "session.autoStart": false,
           "session.requireNotes": false,
           "session.multiSession": true,
-          "hierarchy.requireAcceptanceCriteria": false,
+          "enforcement.acceptance.mode": "warn",
           "lifecycle.mode": "advisory"
         }
       },
@@ -38455,7 +38829,7 @@ var init_config = __esm({
           "session.autoStart": false,
           "session.requireNotes": false,
           "session.multiSession": true,
-          "hierarchy.requireAcceptanceCriteria": false,
+          "enforcement.acceptance.mode": "off",
           "lifecycle.mode": "off"
         }
       }
@@ -38834,13 +39208,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 now2 = /* @__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}`);
   }
@@ -38889,13 +39263,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,
@@ -38918,7 +39292,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}`);
   }
@@ -38926,9 +39300,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) {
@@ -38939,9 +39313,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) {
@@ -38954,14 +39328,14 @@ async function advanceStage(taskId, options) {
   await db.update(lifecycleStages).set({
     status: "completed",
     completedAt: now2.toISOString()
-  }).where(eq8(lifecycleStages.id, currentStageRecord.id)).run();
+  }).where(eq9(lifecycleStages.id, currentStageRecord.id)).run();
   await db.update(lifecycleStages).set({
     status: "in_progress",
     startedAt: now2.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}_${now2.getTime()}_${Math.random().toString(36).slice(2, 7)}`,
     pipelineId: pipeline2.id,
@@ -38978,7 +39352,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}`);
   }
@@ -38990,43 +39364,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,
@@ -39045,7 +39419,7 @@ async function listPipelines(options = {}) {
 async function completePipeline(taskId, reason) {
   const db = await getDb();
   const now2 = /* @__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}`);
   }
@@ -39060,21 +39434,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: now2.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 now2 = /* @__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}`);
   }
@@ -39091,20 +39465,20 @@ async function cancelPipeline(taskId, reason) {
       blockedAt: now2.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: now2.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() {
@@ -39148,12 +39522,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,
@@ -45454,9 +45828,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: eq16 } = await import("drizzle-orm");
+  const { eq: eq17 } = await import("drizzle-orm");
   const db = await getNexusDb2();
-  const existingRows = await db.select().from(projectRegistry).where(eq16(projectRegistry.projectHash, projectHash));
+  const existingRows = await db.select().from(projectRegistry).where(eq17(projectRegistry.projectHash, projectHash));
   const existing = existingRows[0];
   if (existing?.permissions) {
     throw new CleoError(
@@ -45465,7 +45839,7 @@ async function nexusRegister(projectPath, name2, permissions = "read") {
     );
   }
   if (!existing) {
-    const nameConflictRows = await db.select().from(projectRegistry).where(eq16(projectRegistry.name, projectName));
+    const nameConflictRows = await db.select().from(projectRegistry).where(eq17(projectRegistry.name, projectName));
     if (nameConflictRows.length > 0) {
       throw new CleoError(
         6 /* VALIDATION_ERROR */,
@@ -45483,7 +45857,7 @@ async function nexusRegister(projectPath, name2, permissions = "read") {
       taskCount: meta.taskCount,
       labelsJson: JSON.stringify(meta.labels),
       lastSeen: now2
-    }).where(eq16(projectRegistry.projectHash, projectHash));
+    }).where(eq17(projectRegistry.projectHash, projectHash));
   } else {
     if (!projectId) {
       projectId = randomUUID3();
@@ -45521,9 +45895,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: eq16 } = await import("drizzle-orm");
+  const { eq: eq17 } = await import("drizzle-orm");
   const db = await getNexusDb2();
-  await db.delete(projectRegistry).where(eq16(projectRegistry.projectHash, project.hash));
+  await db.delete(projectRegistry).where(eq17(projectRegistry.projectHash, project.hash));
   await writeNexusAudit({
     action: "unregister",
     projectHash: project.hash,
@@ -45545,9 +45919,9 @@ async function nexusList() {
 async function nexusGetProject(nameOrHash) {
   try {
     const { getNexusDb: getNexusDb2 } = await Promise.resolve().then(() => (init_nexus_sqlite(), nexus_sqlite_exports));
-    const { eq: eq16, or: or6 } = await import("drizzle-orm");
+    const { eq: eq17, or: or6 } = await import("drizzle-orm");
     const db = await getNexusDb2();
-    const rows = await db.select().from(projectRegistry).where(or6(eq16(projectRegistry.projectHash, nameOrHash), eq16(projectRegistry.name, nameOrHash)));
+    const rows = await db.select().from(projectRegistry).where(or6(eq17(projectRegistry.projectHash, nameOrHash), eq17(projectRegistry.name, nameOrHash)));
     const row = rows[0];
     if (!row) return null;
     return rowToProject(row);
@@ -45570,14 +45944,14 @@ async function nexusSync(nameOrHash) {
   const meta = await readProjectMeta(project.path);
   const now2 = (/* @__PURE__ */ new Date()).toISOString();
   const { getNexusDb: getNexusDb2 } = await Promise.resolve().then(() => (init_nexus_sqlite(), nexus_sqlite_exports));
-  const { eq: eq16 } = await import("drizzle-orm");
+  const { eq: eq17 } = await import("drizzle-orm");
   const db = await getNexusDb2();
   await db.update(projectRegistry).set({
     taskCount: meta.taskCount,
     labelsJson: JSON.stringify(meta.labels),
     lastSync: now2,
     lastSeen: now2
-  }).where(eq16(projectRegistry.projectHash, project.hash));
+  }).where(eq17(projectRegistry.projectHash, project.hash));
   await writeNexusAudit({
     action: "sync",
     projectHash: project.hash,
@@ -45591,7 +45965,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: eq16 } = await import("drizzle-orm");
+  const { eq: eq17 } = await import("drizzle-orm");
   const db = await getNexusDb2();
   for (const project of projects) {
     try {
@@ -45602,7 +45976,7 @@ async function nexusSyncAll() {
         labelsJson: JSON.stringify(meta.labels),
         lastSync: now2,
         lastSeen: now2
-      }).where(eq16(projectRegistry.projectHash, project.hash));
+      }).where(eq17(projectRegistry.projectHash, project.hash));
       synced++;
     } catch {
       failed++;
@@ -45622,9 +45996,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: eq16 } = await import("drizzle-orm");
+  const { eq: eq17 } = await import("drizzle-orm");
   const db = await getNexusDb2();
-  await db.update(projectRegistry).set({ permissions: permission }).where(eq16(projectRegistry.projectHash, project.hash));
+  await db.update(projectRegistry).set({ permissions: permission }).where(eq17(projectRegistry.projectHash, project.hash));
   await writeNexusAudit({
     action: "set-permission",
     projectHash: project.hash,
@@ -45640,12 +46014,12 @@ async function nexusReconcile(projectRoot) {
   }
   await nexusInit();
   const { getNexusDb: getNexusDb2 } = await Promise.resolve().then(() => (init_nexus_sqlite(), nexus_sqlite_exports));
-  const { eq: eq16 } = await import("drizzle-orm");
+  const { eq: eq17 } = 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(eq16(projectRegistry.projectHash, currentHash));
+    const hashRows2 = await db.select().from(projectRegistry).where(eq17(projectRegistry.projectHash, currentHash));
     const hashMatch2 = hashRows2[0];
     if (hashMatch2 && hashMatch2.projectId !== projectId) {
       await writeNexusAudit({
@@ -45664,12 +46038,12 @@ async function nexusReconcile(projectRoot) {
     }
   }
   if (projectId) {
-    const idRows = await db.select().from(projectRegistry).where(eq16(projectRegistry.projectId, projectId));
+    const idRows = await db.select().from(projectRegistry).where(eq17(projectRegistry.projectId, projectId));
     const existing = idRows[0];
     if (existing) {
       const now2 = (/* @__PURE__ */ new Date()).toISOString();
       if (existing.projectPath === projectRoot) {
-        await db.update(projectRegistry).set({ lastSeen: now2 }).where(eq16(projectRegistry.projectId, projectId));
+        await db.update(projectRegistry).set({ lastSeen: now2 }).where(eq17(projectRegistry.projectId, projectId));
         await writeNexusAudit({
           action: "reconcile",
           projectHash: currentHash,
@@ -45685,7 +46059,7 @@ async function nexusReconcile(projectRoot) {
         projectPath: projectRoot,
         projectHash: currentHash,
         lastSeen: now2
-      }).where(eq16(projectRegistry.projectId, projectId));
+      }).where(eq17(projectRegistry.projectId, projectId));
       await writeNexusAudit({
         action: "reconcile",
         projectHash: currentHash,
@@ -45697,11 +46071,11 @@ async function nexusReconcile(projectRoot) {
       return { status: "path_updated", oldPath, newPath: projectRoot };
     }
   }
-  const hashRows = await db.select().from(projectRegistry).where(eq16(projectRegistry.projectHash, currentHash));
+  const hashRows = await db.select().from(projectRegistry).where(eq17(projectRegistry.projectHash, currentHash));
   const hashMatch = hashRows[0];
   if (hashMatch) {
     const now2 = (/* @__PURE__ */ new Date()).toISOString();
-    await db.update(projectRegistry).set({ lastSeen: now2 }).where(eq16(projectRegistry.projectHash, currentHash));
+    await db.update(projectRegistry).set({ lastSeen: now2 }).where(eq17(projectRegistry.projectHash, currentHash));
     await writeNexusAudit({
       action: "reconcile",
       projectHash: currentHash,
@@ -46556,6 +46930,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;
@@ -46572,12 +46970,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) {
@@ -46629,6 +47042,7 @@ var init_sharing = __esm({
     "use strict";
     init_config();
     init_paths();
+    init_git_checkpoint();
     GITIGNORE_START = "# CLEO:SHARING:START - Auto-managed by cleo sharing sync";
     GITIGNORE_END = "# CLEO:SHARING:END";
   }
@@ -46636,25 +47050,25 @@ var init_sharing = __esm({
 
 // packages/core/src/reconciliation/link-store.ts
 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) {
@@ -46698,11 +47112,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) {
@@ -50656,7 +51070,7 @@ import { execFileSync as execFileSync7 } from "node:child_process";
 import { existsSync as existsSync64, 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";
 async function getDb2(cwd) {
   const { getDb: _getDb } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
   return _getDb(cwd);
@@ -50725,7 +51139,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) {
@@ -50737,7 +51151,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})`);
   }
@@ -50777,7 +51191,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`);
   }
@@ -50914,7 +51328,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 {
@@ -50952,8 +51366,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));
@@ -50984,7 +51398,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`);
   }
@@ -50996,7 +51410,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`);
   }
@@ -51006,7 +51420,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) {
@@ -51015,12 +51429,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) {
@@ -51029,7 +51443,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`);
   }
@@ -51177,7 +51591,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,
@@ -51194,7 +51608,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`,
@@ -51207,12 +51621,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,
@@ -51322,7 +51736,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");
@@ -51342,7 +51756,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({
@@ -57098,7 +57512,7 @@ async function queryTasks(cwd, since) {
   try {
     const { getDb: getDb4 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
     const { tasks: tasks2 } = await Promise.resolve().then(() => (init_tasks_schema(), tasks_schema_exports));
-    const { and: and11, gte: gte4 } = await import("drizzle-orm");
+    const { and: and12, gte: gte4 } = await import("drizzle-orm");
     const db = await getDb4(cwd);
     const conditions = [];
     if (since) {
@@ -57112,7 +57526,7 @@ async function queryTasks(cwd, since) {
       sessionId: tasks2.sessionId,
       completedAt: tasks2.completedAt,
       createdAt: tasks2.createdAt
-    }).from(tasks2).where(conditions.length > 0 ? and11(...conditions) : void 0).all();
+    }).from(tasks2).where(conditions.length > 0 ? and12(...conditions) : void 0).all();
     return rows;
   } catch (err) {
     log7.warn({ err }, "Failed to query tasks for workflow telemetry");
@@ -57123,7 +57537,7 @@ async function queryCompletionAuditRows(cwd, since) {
   try {
     const { getDb: getDb4 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
     const { auditLog: auditLog2 } = await Promise.resolve().then(() => (init_tasks_schema(), tasks_schema_exports));
-    const { and: and11, gte: gte4 } = await import("drizzle-orm");
+    const { and: and12, gte: gte4 } = await import("drizzle-orm");
     const db = await getDb4(cwd);
     const conditions = [];
     if (since) conditions.push(gte4(auditLog2.timestamp, since));
@@ -57135,7 +57549,7 @@ async function queryCompletionAuditRows(cwd, since) {
       afterJson: auditLog2.afterJson,
       operation: auditLog2.operation,
       domain: auditLog2.domain
-    }).from(auditLog2).where(conditions.length > 0 ? and11(...conditions) : void 0).orderBy(auditLog2.timestamp).all();
+    }).from(auditLog2).where(conditions.length > 0 ? and12(...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) {
@@ -66555,46 +66969,68 @@ 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: dirname22 } = await import("node:path");
+  await mkdir17(dirname22(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 (existsSync104(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 && existsSync104(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();
   const globalAgentsMd = join104(globalAgentsDir, "AGENTS.md");
@@ -66608,13 +67044,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)");
     }
@@ -66748,6 +67194,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 (!existsSync104(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 (existsSync104(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 (existsSync104(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 {
+  }
+}
 var init_bootstrap = __esm({
   "packages/core/src/bootstrap.ts"() {
     "use strict";
@@ -66764,6 +67249,8 @@ var init_cleo = __esm({
     "use strict";
     init_export();
     init_import();
+    init_agents();
+    init_intelligence();
     init_lifecycle2();
     init_brain_retrieval();
     init_brain_search();
@@ -66778,6 +67265,7 @@ var init_cleo = __esm({
     init_sessions();
     init_sticky();
     init_data_accessor();
+    init_task_work();
     init_add();
     init_archive2();
     init_complete();
@@ -66849,7 +67337,10 @@ var init_cleo = __esm({
           ),
           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 ===
@@ -66857,7 +67348,11 @@ var init_cleo = __esm({
         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),
@@ -66995,6 +67490,35 @@ var init_cleo = __esm({
           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;
@@ -67037,6 +67561,7 @@ var init_src2 = __esm({
     init_inject();
     init_intelligence();
     init_issue();
+    init_lib();
     init_lifecycle2();
     init_mcp();
     init_memory();
@@ -68426,9 +68951,9 @@ async function addChain(chain, projectRoot) {
 }
 async function showChain(id, projectRoot) {
   const { getDb: getDb4 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
-  const { eq: eq16 } = await import("drizzle-orm");
+  const { eq: eq17 } = await import("drizzle-orm");
   const db = await getDb4(projectRoot);
-  const rows = await db.select().from(warpChains).where(eq16(warpChains.id, id));
+  const rows = await db.select().from(warpChains).where(eq17(warpChains.id, id));
   if (rows.length === 0) return null;
   return JSON.parse(rows[0].definition);
 }
@@ -68475,9 +69000,9 @@ async function createInstance(params, projectRoot) {
 }
 async function showInstance(id, projectRoot) {
   const { getDb: getDb4 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
-  const { eq: eq16 } = await import("drizzle-orm");
+  const { eq: eq17 } = await import("drizzle-orm");
   const db = await getDb4(projectRoot);
-  const rows = await db.select().from(warpChainInstances).where(eq16(warpChainInstances.id, id));
+  const rows = await db.select().from(warpChainInstances).where(eq17(warpChainInstances.id, id));
   if (rows.length === 0) return null;
   const row = rows[0];
   return {
@@ -68523,11 +69048,11 @@ async function advanceInstance(id, nextStage, gateResults, projectRoot) {
     }
   }
   const { getDb: getDb4 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
-  const { eq: eq16 } = await import("drizzle-orm");
+  const { eq: eq17 } = await import("drizzle-orm");
   const db = await getDb4(projectRoot);
   const now2 = (/* @__PURE__ */ new Date()).toISOString();
   const existingResults = [];
-  const row = (await db.select().from(warpChainInstances).where(eq16(warpChainInstances.id, id)))[0];
+  const row = (await db.select().from(warpChainInstances).where(eq17(warpChainInstances.id, id)))[0];
   if (row?.gateResults) {
     existingResults.push(...JSON.parse(row.gateResults));
   }
@@ -68537,7 +69062,7 @@ async function advanceInstance(id, nextStage, gateResults, projectRoot) {
     gateResults: JSON.stringify(allResults),
     status: "active",
     updatedAt: now2
-  }).where(eq16(warpChainInstances.id, id));
+  }).where(eq17(warpChainInstances.id, id));
   return {
     ...instance,
     currentStage: nextStage,
@@ -70229,7 +70754,7 @@ var init_engine_compat = __esm({
 import { createHash as createHash12 } from "node:crypto";
 import { existsSync as existsSync106, readFileSync as readFileSync78, renameSync as renameSync7 } from "node:fs";
 import { join as join105 } from "node:path";
-import { and as and8, count as count2, desc as desc5, eq as eq11, gte as gte3, isNull as isNull3, like as like3, lte as lte2, or as or4 } from "drizzle-orm";
+import { and as and9, count as count2, desc as desc5, eq as eq12, gte as gte3, isNull as isNull3, like as like3, lte as lte2, or as or4 } from "drizzle-orm";
 async function getDb3(cwd) {
   const { getDb: _getDb } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
   return _getDb(cwd);
@@ -70251,10 +70776,10 @@ function buildManifestSqlFilters(filter) {
   const conditions = [isNull3(pipelineManifest.archivedAt)];
   if (filter.status) {
     const storedStatus = filter.status === "completed" ? "active" : filter.status;
-    conditions.push(eq11(pipelineManifest.status, storedStatus));
+    conditions.push(eq12(pipelineManifest.status, storedStatus));
   }
   if (filter.agent_type) {
-    conditions.push(eq11(pipelineManifest.type, filter.agent_type));
+    conditions.push(eq12(pipelineManifest.type, filter.agent_type));
   }
   if (filter.dateAfter) {
     conditions.push(gte3(pipelineManifest.createdAt, `${filter.dateAfter} 00:00:00`));
@@ -70347,7 +70872,7 @@ async function pipelineManifestShow(researchId, projectRoot) {
   }
   try {
     const db = await getDb3(projectRoot);
-    const rows = await db.select().from(pipelineManifest).where(eq11(pipelineManifest.id, researchId)).limit(1);
+    const rows = await db.select().from(pipelineManifest).where(eq12(pipelineManifest.id, researchId)).limit(1);
     if (rows.length === 0) {
       return {
         success: false,
@@ -70389,7 +70914,7 @@ async function pipelineManifestList(params, projectRoot) {
     const offset = normalizeOffset2(params.offset);
     const pageLimit = effectivePageLimit2(limit, offset);
     const { conditions, requiresInMemoryFiltering } = buildManifestSqlFilters(filter);
-    const whereClause = and8(...conditions);
+    const whereClause = and9(...conditions);
     const totalRow = await db.select({ count: count2() }).from(pipelineManifest).where(isNull3(pipelineManifest.archivedAt)).get();
     const total = totalRow?.count ?? 0;
     if (!requiresInMemoryFiltering) {
@@ -70437,7 +70962,7 @@ async function pipelineManifestFind(query, options, projectRoot) {
     const db = await getDb3(projectRoot);
     const likePattern = `%${query}%`;
     const rows = await db.select().from(pipelineManifest).where(
-      and8(
+      and9(
         isNull3(pipelineManifest.archivedAt),
         or4(like3(pipelineManifest.content, likePattern), like3(pipelineManifest.type, likePattern))
       )
@@ -70630,7 +71155,7 @@ async function pipelineManifestArchive(beforeDate, projectRoot) {
     }
     const archivedAt = now();
     for (const row of toArchive) {
-      await db.update(pipelineManifest).set({ archivedAt }).where(eq11(pipelineManifest.id, row.id));
+      await db.update(pipelineManifest).set({ archivedAt }).where(eq12(pipelineManifest.id, row.id));
     }
     const remaining = rows.length - toArchive.length;
     return { success: true, data: { archived: toArchive.length, remaining } };
@@ -70979,25 +71504,25 @@ async function measureTokenExchange(input) {
   );
 }
 async function whereClauses(filters) {
-  const { eq: eq16, gte: gte4, lte: lte3 } = await import("drizzle-orm");
+  const { eq: eq17, gte: gte4, lte: lte3 } = await import("drizzle-orm");
   const clauses = [];
-  if (filters.provider) clauses.push(eq16(tokenUsage.provider, filters.provider));
-  if (filters.transport) clauses.push(eq16(tokenUsage.transport, filters.transport));
-  if (filters.gateway) clauses.push(eq16(tokenUsage.gateway, filters.gateway));
-  if (filters.domain) clauses.push(eq16(tokenUsage.domain, filters.domain));
-  if (filters.operation) clauses.push(eq16(tokenUsage.operation, filters.operation));
-  if (filters.sessionId) clauses.push(eq16(tokenUsage.sessionId, filters.sessionId));
-  if (filters.taskId) clauses.push(eq16(tokenUsage.taskId, filters.taskId));
-  if (filters.method) clauses.push(eq16(tokenUsage.method, filters.method));
-  if (filters.confidence) clauses.push(eq16(tokenUsage.confidence, filters.confidence));
-  if (filters.requestId) clauses.push(eq16(tokenUsage.requestId, filters.requestId));
+  if (filters.provider) clauses.push(eq17(tokenUsage.provider, filters.provider));
+  if (filters.transport) clauses.push(eq17(tokenUsage.transport, filters.transport));
+  if (filters.gateway) clauses.push(eq17(tokenUsage.gateway, filters.gateway));
+  if (filters.domain) clauses.push(eq17(tokenUsage.domain, filters.domain));
+  if (filters.operation) clauses.push(eq17(tokenUsage.operation, filters.operation));
+  if (filters.sessionId) clauses.push(eq17(tokenUsage.sessionId, filters.sessionId));
+  if (filters.taskId) clauses.push(eq17(tokenUsage.taskId, filters.taskId));
+  if (filters.method) clauses.push(eq17(tokenUsage.method, filters.method));
+  if (filters.confidence) clauses.push(eq17(tokenUsage.confidence, filters.confidence));
+  if (filters.requestId) clauses.push(eq17(tokenUsage.requestId, filters.requestId));
   if (filters.since) clauses.push(gte4(tokenUsage.createdAt, filters.since));
   if (filters.until) clauses.push(lte3(tokenUsage.createdAt, filters.until));
   return clauses;
 }
 async function recordTokenExchange(input) {
   const { getDb: getDb4 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
-  const { eq: eq16 } = await import("drizzle-orm");
+  const { eq: eq17 } = await import("drizzle-orm");
   const measurement = await measureTokenExchange(input);
   const db = await getDb4(input.cwd);
   const row = {
@@ -71026,22 +71551,22 @@ async function recordTokenExchange(input) {
     })
   };
   await db.insert(tokenUsage).values(row);
-  const inserted = await db.select().from(tokenUsage).where(eq16(tokenUsage.id, row.id)).limit(1);
+  const inserted = await db.select().from(tokenUsage).where(eq17(tokenUsage.id, row.id)).limit(1);
   return inserted[0];
 }
 async function showTokenUsage(id, cwd) {
   const { getDb: getDb4 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
-  const { eq: eq16 } = await import("drizzle-orm");
+  const { eq: eq17 } = await import("drizzle-orm");
   const db = await getDb4(cwd);
-  const rows = await db.select().from(tokenUsage).where(eq16(tokenUsage.id, id)).limit(1);
+  const rows = await db.select().from(tokenUsage).where(eq17(tokenUsage.id, id)).limit(1);
   return rows[0] ?? null;
 }
 async function listTokenUsage(filters = {}, cwd) {
   const { getDb: getDb4 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
-  const { and: and11, count: count4, desc: desc7 } = await import("drizzle-orm");
+  const { and: and12, count: count4, desc: desc7 } = await import("drizzle-orm");
   const db = await getDb4(cwd);
   const clauses = await whereClauses(filters);
-  const where = clauses.length > 0 ? and11(...clauses) : void 0;
+  const where = clauses.length > 0 ? and12(...clauses) : void 0;
   const totalRows = await db.select({ count: count4() }).from(tokenUsage);
   const filteredRows = await db.select({ count: count4() }).from(tokenUsage).where(where);
   let query = db.select().from(tokenUsage).orderBy(desc7(tokenUsage.createdAt));
@@ -71057,10 +71582,10 @@ async function listTokenUsage(filters = {}, cwd) {
 }
 async function summarizeTokenUsage(filters = {}, cwd) {
   const { getDb: getDb4 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
-  const { and: and11, desc: desc7 } = await import("drizzle-orm");
+  const { and: and12, desc: desc7 } = await import("drizzle-orm");
   const db = await getDb4(cwd);
   const clauses = await whereClauses(filters);
-  const where = clauses.length > 0 ? and11(...clauses) : void 0;
+  const where = clauses.length > 0 ? and12(...clauses) : void 0;
   const rows = await db.select().from(tokenUsage).where(where).orderBy(desc7(tokenUsage.createdAt));
   const byMethod = /* @__PURE__ */ new Map();
   const byTransport = /* @__PURE__ */ new Map();
@@ -71101,17 +71626,17 @@ async function summarizeTokenUsage(filters = {}, cwd) {
 }
 async function deleteTokenUsage(id, cwd) {
   const { getDb: getDb4 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
-  const { eq: eq16 } = await import("drizzle-orm");
+  const { eq: eq17 } = await import("drizzle-orm");
   const db = await getDb4(cwd);
-  await db.delete(tokenUsage).where(eq16(tokenUsage.id, id));
+  await db.delete(tokenUsage).where(eq17(tokenUsage.id, id));
   return { deleted: true, id };
 }
 async function clearTokenUsage(filters = {}, cwd) {
   const { getDb: getDb4 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
-  const { and: and11, count: count4 } = await import("drizzle-orm");
+  const { and: and12, count: count4 } = await import("drizzle-orm");
   const db = await getDb4(cwd);
   const clauses = await whereClauses(filters);
-  const where = clauses.length > 0 ? and11(...clauses) : void 0;
+  const where = clauses.length > 0 ? and12(...clauses) : void 0;
   const countRows = await db.select({ count: count4() }).from(tokenUsage).where(where);
   await db.delete(tokenUsage).where(where);
   return { deleted: countRows[0]?.count ?? 0 };
@@ -71522,7 +72047,7 @@ __export(session_store_exports, {
   updateSession: () => updateSession,
   workHistory: () => workHistory
 });
-import { and as and9, desc as desc6, eq as eq12, isNull as isNull4 } from "drizzle-orm";
+import { and as and10, desc as desc6, eq as eq13, isNull as isNull4 } from "drizzle-orm";
 async function createSession(session, cwd) {
   const db = await getDb(cwd);
   const tw = session.taskWork;
@@ -71544,7 +72069,7 @@ async function createSession(session, cwd) {
 }
 async function getSession(sessionId, cwd) {
   const db = await getDb(cwd);
-  const rows = await db.select().from(sessions).where(eq12(sessions.id, sessionId)).all();
+  const rows = await db.select().from(sessions).where(eq13(sessions.id, sessionId)).all();
   if (rows.length === 0) return null;
   return rowToSession(rows[0]);
 }
@@ -71573,16 +72098,16 @@ async function updateSession(sessionId, updates, cwd) {
     updateRow.handoffConsumedBy = updates.handoffConsumedBy;
   if (updates.debriefJson !== void 0) updateRow.debriefJson = updates.debriefJson;
   if (updates.handoffJson !== void 0) updateRow.handoffJson = updates.handoffJson;
-  db.update(sessions).set(updateRow).where(eq12(sessions.id, sessionId)).run();
+  db.update(sessions).set(updateRow).where(eq13(sessions.id, sessionId)).run();
   return getSession(sessionId, cwd);
 }
 async function listSessions2(filters, cwd) {
   const db = await getDb(cwd);
   const conditions = [];
   if (filters?.active) {
-    conditions.push(eq12(sessions.status, "active"));
+    conditions.push(eq13(sessions.status, "active"));
   }
-  const query = db.select().from(sessions).where(conditions.length > 0 ? and9(...conditions) : void 0).orderBy(desc6(sessions.startedAt));
+  const query = db.select().from(sessions).where(conditions.length > 0 ? and10(...conditions) : void 0).orderBy(desc6(sessions.startedAt));
   const rows = filters?.limit ? await query.limit(filters.limit).all() : await query.all();
   return rows.map(rowToSession);
 }
@@ -71604,20 +72129,20 @@ async function startTask2(sessionId, taskId, cwd) {
   const db = await getDb(cwd);
   const now2 = (/* @__PURE__ */ new Date()).toISOString();
   db.update(taskWorkHistory).set({ clearedAt: now2 }).where(
-    and9(
-      eq12(taskWorkHistory.sessionId, sessionId),
+    and10(
+      eq13(taskWorkHistory.sessionId, sessionId),
       isNull4(taskWorkHistory.clearedAt)
     )
   ).run();
   db.insert(taskWorkHistory).values({ sessionId, taskId, setAt: now2 }).run();
-  db.update(sessions).set({ currentTask: taskId, taskStartedAt: now2 }).where(eq12(sessions.id, sessionId)).run();
+  db.update(sessions).set({ currentTask: taskId, taskStartedAt: now2 }).where(eq13(sessions.id, sessionId)).run();
 }
 async function getCurrentTask(sessionId, cwd) {
   const db = await getDb(cwd);
   const rows = await db.select({
     currentTask: sessions.currentTask,
     taskStartedAt: sessions.taskStartedAt
-  }).from(sessions).where(eq12(sessions.id, sessionId)).all();
+  }).from(sessions).where(eq13(sessions.id, sessionId)).all();
   if (rows.length === 0) return { taskId: null, since: null };
   return { taskId: rows[0].currentTask, since: rows[0].taskStartedAt };
 }
@@ -71625,16 +72150,16 @@ async function stopTask2(sessionId, cwd) {
   const db = await getDb(cwd);
   const now2 = (/* @__PURE__ */ new Date()).toISOString();
   db.update(taskWorkHistory).set({ clearedAt: now2 }).where(
-    and9(
-      eq12(taskWorkHistory.sessionId, sessionId),
+    and10(
+      eq13(taskWorkHistory.sessionId, sessionId),
       isNull4(taskWorkHistory.clearedAt)
     )
   ).run();
-  db.update(sessions).set({ currentTask: null, taskStartedAt: null }).where(eq12(sessions.id, sessionId)).run();
+  db.update(sessions).set({ currentTask: null, taskStartedAt: null }).where(eq13(sessions.id, sessionId)).run();
 }
 async function workHistory(sessionId, limit = 50, cwd) {
   const db = await getDb(cwd);
-  const rows = await db.select().from(taskWorkHistory).where(eq12(taskWorkHistory.sessionId, sessionId)).orderBy(desc6(taskWorkHistory.setAt), desc6(taskWorkHistory.id)).limit(limit).all();
+  const rows = await db.select().from(taskWorkHistory).where(eq13(taskWorkHistory.sessionId, sessionId)).orderBy(desc6(taskWorkHistory.setAt), desc6(taskWorkHistory.id)).limit(limit).all();
   return rows.map((r) => ({
     taskId: r.taskId,
     setAt: r.setAt,
@@ -71645,16 +72170,16 @@ async function gcSessions2(maxAgeDays = 30, cwd) {
   const db = await getDb(cwd);
   const threshold = /* @__PURE__ */ new Date();
   threshold.setDate(threshold.getDate() - maxAgeDays);
-  const before = await db.select({ id: sessions.id }).from(sessions).where(and9(eq12(sessions.status, "ended"))).all();
+  const before = await db.select({ id: sessions.id }).from(sessions).where(and10(eq13(sessions.status, "ended"))).all();
   const toUpdate = before;
   if (toUpdate.length > 0) {
-    db.update(sessions).set({ status: "orphaned" }).where(eq12(sessions.status, "ended")).run();
+    db.update(sessions).set({ status: "orphaned" }).where(eq13(sessions.status, "ended")).run();
   }
   return toUpdate.length;
 }
 async function getActiveSession(cwd) {
   const db = await getDb(cwd);
-  const rows = await db.select().from(sessions).where(eq12(sessions.status, "active")).orderBy(desc6(sessions.startedAt)).limit(1).all();
+  const rows = await db.select().from(sessions).where(eq13(sessions.status, "active")).orderBy(desc6(sessions.startedAt)).limit(1).all();
   if (rows.length === 0) return null;
   return rowToSession(rows[0]);
 }
@@ -71668,7 +72193,7 @@ var init_session_store = __esm({
 });
 
 // packages/core/src/store/cross-db-cleanup.ts
-import { eq as eq13, or as or5 } from "drizzle-orm";
+import { eq as eq14, or as or5 } from "drizzle-orm";
 async function cleanupBrainRefsOnTaskDelete(taskId, cwd) {
   let brainDb = null;
   try {
@@ -71678,16 +72203,16 @@ async function cleanupBrainRefsOnTaskDelete(taskId, cwd) {
   }
   const nodeId = `task:${taskId}`;
   try {
-    await brainDb.update(brainDecisions).set({ contextEpicId: null }).where(eq13(brainDecisions.contextEpicId, taskId));
-    await brainDb.update(brainDecisions).set({ contextTaskId: null }).where(eq13(brainDecisions.contextTaskId, taskId));
-    await brainDb.delete(brainMemoryLinks).where(eq13(brainMemoryLinks.taskId, taskId));
+    await brainDb.update(brainDecisions).set({ contextEpicId: null }).where(eq14(brainDecisions.contextEpicId, taskId));
+    await brainDb.update(brainDecisions).set({ contextTaskId: null }).where(eq14(brainDecisions.contextTaskId, taskId));
+    await brainDb.delete(brainMemoryLinks).where(eq14(brainMemoryLinks.taskId, taskId));
     await brainDb.delete(brainPageEdges).where(
       or5(
-        eq13(brainPageEdges.fromId, nodeId),
-        eq13(brainPageEdges.toId, nodeId)
+        eq14(brainPageEdges.fromId, nodeId),
+        eq14(brainPageEdges.toId, nodeId)
       )
     );
-    await brainDb.delete(brainPageNodes).where(eq13(brainPageNodes.id, nodeId));
+    await brainDb.delete(brainPageNodes).where(eq14(brainPageNodes.id, nodeId));
   } catch {
   }
 }
@@ -71700,12 +72225,12 @@ var init_cross_db_cleanup = __esm({
 });
 
 // packages/core/src/store/data-safety.ts
-import { eq as eq14 } from "drizzle-orm";
+import { eq as eq15 } from "drizzle-orm";
 async function checkTaskExists(taskId, cwd, config2 = {}) {
   const cfg = { ...DEFAULT_CONFIG2, ...config2 };
   if (!cfg.detectCollisions) return false;
   const db = await getDb(cwd);
-  const existing = await db.select().from(tasks).where(eq14(tasks.id, taskId)).all();
+  const existing = await db.select().from(tasks).where(eq15(tasks.id, taskId)).all();
   const exists2 = existing.length > 0;
   if (exists2 && cfg.strictMode) {
     throw new SafetyError(
@@ -71853,7 +72378,7 @@ __export(task_store_exports, {
   updateTask: () => updateTask2,
   updateTaskSafe: () => updateTaskSafe
 });
-import { and as and10, asc as asc4, count as count3, eq as eq15, inArray as inArray5, isNull as isNull5, ne as ne3, sql as sql11 } from "drizzle-orm";
+import { and as and11, asc as asc4, count as count3, eq as eq16, inArray as inArray6, isNull as isNull5, ne as ne3, sql as sql11 } from "drizzle-orm";
 async function insertTaskRow(task, cwd) {
   const db = await getDb(cwd);
   const row = taskToRow(task);
@@ -71867,10 +72392,10 @@ async function insertTaskRow(task, cwd) {
 }
 async function getTask(taskId, cwd) {
   const db = await getDb(cwd);
-  const rows = await db.select().from(tasks).where(eq15(tasks.id, taskId)).all();
+  const rows = await db.select().from(tasks).where(eq16(tasks.id, taskId)).all();
   if (rows.length === 0) return null;
   const task = rowToTask(rows[0]);
-  const deps = await db.select().from(taskDependencies).where(eq15(taskDependencies.taskId, taskId)).all();
+  const deps = await db.select().from(taskDependencies).where(eq16(taskDependencies.taskId, taskId)).all();
   if (deps.length > 0) {
     task.depends = deps.map((d) => d.dependsOn);
   }
@@ -71906,9 +72431,9 @@ async function updateTask2(taskId, updates, cwd) {
     updateRow.cancellationReason = updates.cancellationReason;
   if (updates.verification !== void 0)
     updateRow.verificationJson = JSON.stringify(updates.verification);
-  db.update(tasks).set(updateRow).where(eq15(tasks.id, taskId)).run();
+  db.update(tasks).set(updateRow).where(eq16(tasks.id, taskId)).run();
   if (updates.depends !== void 0) {
-    db.delete(taskDependencies).where(eq15(taskDependencies.taskId, taskId)).run();
+    db.delete(taskDependencies).where(eq16(taskDependencies.taskId, taskId)).run();
     for (const depId of updates.depends) {
       db.insert(taskDependencies).values({ taskId, dependsOn: depId }).run();
     }
@@ -71917,9 +72442,9 @@ async function updateTask2(taskId, updates, cwd) {
 }
 async function deleteTask2(taskId, cwd) {
   const db = await getDb(cwd);
-  const existing = await db.select({ id: tasks.id }).from(tasks).where(eq15(tasks.id, taskId)).all();
+  const existing = await db.select({ id: tasks.id }).from(tasks).where(eq16(tasks.id, taskId)).all();
   if (existing.length === 0) return false;
-  db.delete(tasks).where(eq15(tasks.id, taskId)).run();
+  db.delete(tasks).where(eq16(tasks.id, taskId)).run();
   void cleanupBrainRefsOnTaskDelete(taskId, cwd);
   return true;
 }
@@ -71927,17 +72452,17 @@ async function listTasks2(filters, cwd) {
   const db = await getDb(cwd);
   const conditions = [];
   conditions.push(ne3(tasks.status, "archived"));
-  if (filters?.status) conditions.push(eq15(tasks.status, filters.status));
+  if (filters?.status) conditions.push(eq16(tasks.status, filters.status));
   if (filters?.parentId !== void 0) {
     if (filters.parentId === null) {
       conditions.push(isNull5(tasks.parentId));
     } else {
-      conditions.push(eq15(tasks.parentId, filters.parentId));
+      conditions.push(eq16(tasks.parentId, filters.parentId));
     }
   }
-  if (filters?.type) conditions.push(eq15(tasks.type, filters.type));
-  if (filters?.phase) conditions.push(eq15(tasks.phase, filters.phase));
-  const query = db.select().from(tasks).where(conditions.length > 0 ? and10(...conditions) : void 0).orderBy(asc4(tasks.position), asc4(tasks.createdAt));
+  if (filters?.type) conditions.push(eq16(tasks.type, filters.type));
+  if (filters?.phase) conditions.push(eq16(tasks.phase, filters.phase));
+  const query = db.select().from(tasks).where(conditions.length > 0 ? and11(...conditions) : void 0).orderBy(asc4(tasks.position), asc4(tasks.createdAt));
   const rows = filters?.limit ? await query.limit(filters.limit).all() : await query.all();
   const tasks2 = rows.map(rowToTask);
   await loadDependencies(tasks2, cwd);
@@ -71947,7 +72472,7 @@ async function findTasks2(query, limit = 20, cwd) {
   const db = await getDb(cwd);
   const pattern = `%${query}%`;
   const rows = await db.select().from(tasks).where(
-    and10(
+    and11(
       ne3(tasks.status, "archived"),
       sql11`(${tasks.id} LIKE ${pattern} OR ${tasks.title} LIKE ${pattern} OR ${tasks.description} LIKE ${pattern})`
     )
@@ -71966,14 +72491,14 @@ async function archiveTask(taskId, reason, cwd) {
     archiveReason: reason ?? "completed",
     cycleTimeDays: cycleTime,
     updatedAt: now2
-  }).where(eq15(tasks.id, taskId)).run();
+  }).where(eq16(tasks.id, taskId)).run();
   return true;
 }
 async function loadDependencies(tasks2, cwd) {
   if (tasks2.length === 0) return;
   const db = await getDb(cwd);
   const taskIds = tasks2.map((t) => t.id);
-  const deps = await db.select().from(taskDependencies).where(inArray5(taskDependencies.taskId, taskIds)).all();
+  const deps = await db.select().from(taskDependencies).where(inArray6(taskDependencies.taskId, taskIds)).all();
   const depMap = /* @__PURE__ */ new Map();
   for (const dep of deps) {
     if (!depMap.has(dep.taskId)) depMap.set(dep.taskId, []);
@@ -71993,9 +72518,9 @@ async function addDependency(taskId, dependsOn, cwd) {
 async function removeDependency(taskId, dependsOn, cwd) {
   const db = await getDb(cwd);
   db.delete(taskDependencies).where(
-    and10(
-      eq15(taskDependencies.taskId, taskId),
-      eq15(taskDependencies.dependsOn, dependsOn)
+    and11(
+      eq16(taskDependencies.taskId, taskId),
+      eq16(taskDependencies.dependsOn, dependsOn)
     )
   ).run();
 }
@@ -72005,7 +72530,7 @@ async function addRelation(taskId, relatedTo, relationType = "related", cwd, rea
 }
 async function getRelations(taskId, cwd) {
   const db = await getDb(cwd);
-  const rows = await db.select().from(taskRelations).where(eq15(taskRelations.taskId, taskId)).all();
+  const rows = await db.select().from(taskRelations).where(eq16(taskRelations.taskId, taskId)).all();
   return rows.map((r) => ({
     relatedTo: r.relatedTo,
     type: r.relationType,
@@ -72029,7 +72554,7 @@ async function getBlockerChain(taskId, cwd) {
 }
 async function getChildren2(parentId, cwd) {
   const db = await getDb(cwd);
-  const rows = await db.select().from(tasks).where(eq15(tasks.parentId, parentId)).orderBy(asc4(tasks.position), asc4(tasks.createdAt)).all();
+  const rows = await db.select().from(tasks).where(eq16(tasks.parentId, parentId)).orderBy(asc4(tasks.position), asc4(tasks.createdAt)).all();
   return rows.map(rowToTask);
 }
 async function getSubtree(rootId, cwd) {
@@ -73634,10 +74159,10 @@ async function migrateJsonToSqlite2(cwd, options) {
   const jsonCounts = countJsonRecords(cleoDir);
   result.jsonCounts = jsonCounts;
   if (dbExists(cwd)) {
-    const { ne: ne4, eq: eq16, count: count4 } = await import("drizzle-orm");
+    const { ne: ne4, eq: eq17, count: count4 } = await import("drizzle-orm");
     const db2 = await getDb(cwd);
     const tasksResult = await db2.select({ count: count4() }).from(tasks).where(ne4(tasks.status, "archived")).get();
-    const archivedResult = await db2.select({ count: count4() }).from(tasks).where(eq16(tasks.status, "archived")).get();
+    const archivedResult = await db2.select({ count: count4() }).from(tasks).where(eq17(tasks.status, "archived")).get();
     const sessionsResult = await db2.select({ count: count4() }).from(sessions).get();
     const existingCounts = {
       tasks: tasksResult?.count ?? 0,
@@ -73821,10 +74346,10 @@ async function migrateJsonToSqlite2(cwd, options) {
 async function exportToJson(cwd) {
   const { listTasks: listTasks3 } = await Promise.resolve().then(() => (init_task_store(), task_store_exports));
   const { listSessions: listSessions3 } = await Promise.resolve().then(() => (init_session_store(), session_store_exports));
-  const { eq: eq16 } = await import("drizzle-orm");
+  const { eq: eq17 } = await import("drizzle-orm");
   const tasks2 = await listTasks3(void 0, cwd);
   const db = await getDb(cwd);
-  const archivedRows = await db.select().from(tasks).where(eq16(tasks.status, "archived")).all();
+  const archivedRows = await db.select().from(tasks).where(eq17(tasks.status, "archived")).all();
   const archived = archivedRows.map((row) => ({
     id: row.id,
     title: row.title,
@@ -76408,7 +76933,7 @@ async function validateSqliteRows(type, projectRoot) {
   const { getDb: getDb4 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
   const schemaTable = await Promise.resolve().then(() => (init_tasks_schema(), tasks_schema_exports));
   const zodSchemas = await Promise.resolve().then(() => (init_validation_schemas(), validation_schemas_exports));
-  const { ne: ne4, eq: eq16 } = await import("drizzle-orm");
+  const { ne: ne4, eq: eq17 } = await import("drizzle-orm");
   const db = await getDb4(projectRoot);
   const errors = [];
   switch (type) {
@@ -76420,7 +76945,7 @@ async function validateSqliteRows(type, projectRoot) {
       break;
     }
     case "archive": {
-      const rows = await db.select().from(schemaTable.tasks).where(eq16(schemaTable.tasks.status, "archived"));
+      const rows = await db.select().from(schemaTable.tasks).where(eq17(schemaTable.tasks.status, "archived"));
       for (const row of rows) {
         errors.push(...collectZodErrors(zodSchemas.selectTaskSchema.safeParse(row), row.id));
       }
@@ -77496,6 +78021,7 @@ __export(internal_exports, {
   GATE_VALIDATION_RULES: () => GATE_VALIDATION_RULES,
   GateLayer: () => GateLayer,
   GateStatus: () => GateStatus,
+  HEARTBEAT_INTERVAL_MS: () => HEARTBEAT_INTERVAL_MS,
   HookRegistry: () => HookRegistry,
   LIFECYCLE_PIPELINE_STATUSES: () => LIFECYCLE_PIPELINE_STATUSES,
   LIFECYCLE_STAGE_STATUSES: () => LIFECYCLE_STAGE_STATUSES,
@@ -77509,6 +78035,7 @@ __export(internal_exports, {
   RateLimiter: () => RateLimiter,
   SESSION_STATUSES: () => SESSION_STATUSES,
   STAGE_STATUS_ICONS: () => STAGE_STATUS_ICONS,
+  STALE_THRESHOLD_MS: () => STALE_THRESHOLD_MS,
   STATUS_REGISTRY: () => STATUS_REGISTRY,
   STRICTNESS_PRESETS: () => STRICTNESS_PRESETS,
   SecurityError: () => SecurityError,
@@ -77588,7 +78115,7 @@ __export(internal_exports, {
   canRunNatively: () => canRunNatively,
   cancelRelease: () => cancelRelease,
   channelToDistTag: () => channelToDistTag,
-  checkAgentHealth: () => checkAgentHealth,
+  checkAgentHealth: () => checkAgentHealth2,
   checkConsensusManifest: () => checkConsensusManifest,
   checkContributionManifest: () => checkContributionManifest,
   checkDecompositionManifest: () => checkDecompositionManifest,
@@ -77620,6 +78147,7 @@ __export(internal_exports, {
   computeBriefing: () => computeBriefing,
   computeChecksum: () => computeChecksum,
   computeDebrief: () => computeDebrief,
+  computeDelay: () => computeDelay,
   computeEpicStatus: () => computeEpicStatus,
   computeHandoff: () => computeHandoff,
   computeHelp: () => computeHelp,
@@ -77692,9 +78220,11 @@ __export(internal_exports, {
   deleteTokenUsage: () => deleteTokenUsage,
   deregisterAgent: () => deregisterAgent,
   describeChannel: () => describeChannel,
+  detectCrashedAgents: () => detectCrashedAgents,
   detectEnvMode: () => detectEnvMode,
   detectPlatform: () => detectPlatform,
   detectProjectType: () => detectProjectType,
+  detectStaleAgents: () => detectStaleAgents,
   detectVersion: () => detectVersion,
   determineInstallationTargets: () => determineInstallationTargets,
   discoverRelated: () => discoverRelated2,
@@ -77724,6 +78254,7 @@ __export(internal_exports, {
   findAdrs: () => findAdrs,
   findLeastLoadedAgent: () => findLeastLoadedAgent,
   findSessions: () => findSessions,
+  findStaleAgentRows: () => checkAgentHealth,
   findTasks: () => findTasks,
   formatError: () => formatError3,
   formatOutput: () => formatOutput,
@@ -77883,6 +78414,7 @@ __export(internal_exports, {
   isValidStatus: () => isValidStatus,
   isValidWorkflowGateName: () => isValidWorkflowGateName,
   issue: () => issue_exports,
+  lib: () => lib_exports,
   lifecycle: () => lifecycle_exports,
   lifecycleEvidenceTypeSchema: () => lifecycleEvidenceTypeSchema,
   lifecycleGateResultSchema: () => lifecycleGateResultSchema,
@@ -77983,6 +78515,7 @@ __export(internal_exports, {
   pipelineManifestPending: () => pipelineManifestPending,
   pipelineManifestShow: () => pipelineManifestShow,
   pipelineManifestStats: () => pipelineManifestStats,
+  predictImpact: () => predictImpact,
   predictValidationOutcome: () => predictValidationOutcome,
   prepareRelease: () => prepareRelease,
   prepareSpawn: () => prepareSpawn,
@@ -78007,6 +78540,7 @@ __export(internal_exports, {
   recordAssumption: () => recordAssumption,
   recordDecision: () => recordDecision,
   recordFailurePattern: () => recordFailurePattern,
+  recordHeartbeat: () => recordHeartbeat,
   recordStageProgress: () => recordStageProgress,
   recordTokenExchange: () => recordTokenExchange,
   recoverCrashedAgents: () => recoverCrashedAgents,
@@ -78143,6 +78677,7 @@ __export(internal_exports, {
   validateWorkflowGateUpdate: () => validateWorkflowGateUpdate,
   validation: () => validation_exports,
   withRetry: () => withRetry,
+  withRetryShared: () => withRetry2,
   writeMemoryBridge: () => writeMemoryBridge,
   writeSnapshot: () => writeSnapshot
 });
@@ -78167,6 +78702,7 @@ var init_internal = __esm({
     init_patterns2();
     init_prediction();
     init_diagnostics();
+    init_retry2();
     init_chain_store();
     init_lifecycle2();
     init_tessera_engine();
@@ -82054,6 +82590,30 @@ var OPERATIONS = [
     sessionRequired: false,
     requiredParams: []
   },
+  {
+    gateway: "query",
+    domain: "tasks",
+    operation: "impact",
+    description: "tasks.impact (query) \u2014 predict downstream effects of a free-text change description using keyword matching and reverse dependency graph traversal",
+    tier: 1,
+    idempotent: true,
+    sessionRequired: false,
+    requiredParams: ["change"],
+    params: [
+      {
+        name: "change",
+        type: "string",
+        required: true,
+        description: 'Free-text description of the proposed change (e.g. "Modify authentication flow")'
+      },
+      {
+        name: "matchLimit",
+        type: "number",
+        required: false,
+        description: "Maximum number of seed tasks to match by keyword (default: 5)"
+      }
+    ]
+  },
   {
     gateway: "query",
     domain: "tasks",
@@ -86406,10 +86966,10 @@ async function releaseShip(params, projectRoot) {
         );
         const { getDb: getDb4 } = await Promise.resolve().then(() => (init_internal(), internal_exports));
         const { releaseManifests: releaseManifests2 } = await Promise.resolve().then(() => (init_internal(), internal_exports));
-        const { eq: eq16 } = await import("drizzle-orm");
+        const { eq: eq17 } = await import("drizzle-orm");
         const normalizedVer = version2.startsWith("v") ? version2 : `v${version2}`;
         const db = await getDb4(cwd);
-        await db.update(releaseManifests2).set({ epicId }).where(eq16(releaseManifests2.version, normalizedVer)).run();
+        await db.update(releaseManifests2).set({ epicId }).where(eq17(releaseManifests2.version, normalizedVer)).run();
         await generateReleaseChangelog(version2, () => loadTasks2(projectRoot), cwd);
       }
       logStep(0, 8, "Auto-prepare release record", true);
@@ -87641,6 +88201,15 @@ async function taskAnalyze(projectRoot, taskId, params) {
     return engineError("E_GENERAL", `Task analysis failed: ${message}`);
   }
 }
+async function taskImpact(projectRoot, change, matchLimit) {
+  try {
+    const result = await predictImpact(change, projectRoot, void 0, matchLimit);
+    return { success: true, data: result };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return engineError("E_GENERAL", `Impact prediction failed: ${message}`);
+  }
+}
 async function taskRestore(projectRoot, taskId, params) {
   try {
     const result = await coreTaskRestore(projectRoot, taskId, params);
@@ -92539,6 +93108,22 @@ var TasksHandler = class {
           const result = await taskAnalyze(projectRoot, taskId, { tierLimit });
           return wrapResult(result, "query", "tasks", operation, startTime);
         }
+        case "impact": {
+          const change = params?.change;
+          if (!change) {
+            return errorResult(
+              "query",
+              "tasks",
+              operation,
+              "E_INVALID_INPUT",
+              "change is required (free-text description of the proposed change)",
+              startTime
+            );
+          }
+          const matchLimit = params?.matchLimit;
+          const result = await taskImpact(projectRoot, change, matchLimit);
+          return wrapResult(result, "query", "tasks", operation, startTime);
+        }
         case "next": {
           const result = await taskNext(
             projectRoot,
@@ -92787,6 +93372,7 @@ var TasksHandler = class {
         "blockers",
         "depends",
         "analyze",
+        "impact",
         "next",
         "plan",
         "relates",