@cleocode/core 2026.4.99 → 2026.4.100

package/dist/sentient/index.js

@@ -0,0 +1,1162 @@
+// packages/core/src/sentient/daemon.ts
+import { spawn as spawn2 } from "node:child_process";
+import { createWriteStream, constants as fsConstants, watch } from "node:fs";
+import { open as fsOpen, mkdir as mkdir2 } from "node:fs/promises";
+import { join as join3 } from "node:path";
+import { fileURLToPath } from "node:url";
+import cron from "node-cron";
+
+// packages/core/src/sentient/ingesters/brain-ingester.ts
+var BRAIN_INGESTER_LIMIT = 10;
+var BRAIN_MIN_CITATION_COUNT = 3;
+var BRAIN_MIN_QUALITY_SCORE = 0.5;
+var BRAIN_LOOKBACK_DAYS = 7;
+function computeBrainWeight(citationCount, qualityScore) {
+  return Math.min(citationCount / 10 * qualityScore, 1);
+}
+function runBrainIngester(nativeDb) {
+  if (!nativeDb) {
+    return [];
+  }
+  try {
+    const stmt = nativeDb.prepare(`
+      SELECT id, title, text, citation_count, quality_score
+      FROM brain_observations
+      WHERE type IN ('bugfix', 'decision')
+        AND citation_count >= :minCitations
+        AND created_at >= datetime('now', :lookback)
+        AND quality_score >= :minQuality
+      ORDER BY citation_count DESC, quality_score DESC
+      LIMIT :limit
+    `);
+    const rows = stmt.all({
+      minCitations: BRAIN_MIN_CITATION_COUNT,
+      lookback: `-${BRAIN_LOOKBACK_DAYS} days`,
+      minQuality: BRAIN_MIN_QUALITY_SCORE,
+      limit: BRAIN_INGESTER_LIMIT
+    });
+    const candidates = rows.map((row) => {
+      const label = row.title ?? row.text.slice(0, 80);
+      return {
+        source: "brain",
+        sourceId: row.id,
+        title: `[T2-BRAIN] Recurring issue: ${label}`,
+        rationale: `Brain entry ${row.id} cited ${row.citation_count} times (quality ${row.quality_score.toFixed(2)}) in the last ${BRAIN_LOOKBACK_DAYS} days`,
+        weight: computeBrainWeight(row.citation_count, row.quality_score)
+      };
+    });
+    candidates.sort((a, b) => b.weight - a.weight);
+    return candidates;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[sentient/brain-ingester] WARNING: ${message}
+`);
+    return [];
+  }
+}
+
+// packages/core/src/sentient/ingesters/nexus-ingester.ts
+var NEXUS_BASE_WEIGHT = 0.3;
+var NEXUS_MIN_CALLER_COUNT = 5;
+var NEXUS_MIN_DEGREE = 20;
+var NEXUS_QUERY_LIMIT = 5;
+function toFingerprint(nodeId) {
+  return nodeId;
+}
+function runNexusIngester(nativeDb) {
+  if (!nativeDb) {
+    return [];
+  }
+  const seenIds = /* @__PURE__ */ new Set();
+  const candidates = [];
+  try {
+    const stmtA = nativeDb.prepare(`
+      SELECT n.id, n.name, n.file_path, COUNT(r.id) as caller_count
+      FROM nexus_nodes n
+      JOIN nexus_relations r ON r.target_id = n.id AND r.kind = 'calls'
+      WHERE NOT EXISTS (
+        SELECT 1 FROM nexus_relations r2
+        WHERE r2.source_id = n.id AND r2.kind = 'calls'
+      )
+      AND n.kind = 'function'
+      GROUP BY n.id
+      HAVING caller_count > :minCallers
+      ORDER BY caller_count DESC
+      LIMIT :limit
+    `);
+    const rowsA = stmtA.all({
+      minCallers: NEXUS_MIN_CALLER_COUNT,
+      limit: NEXUS_QUERY_LIMIT
+    });
+    for (const row of rowsA) {
+      const fp = toFingerprint(row.id);
+      if (seenIds.has(fp)) continue;
+      seenIds.add(fp);
+      candidates.push({
+        source: "nexus",
+        sourceId: row.id,
+        title: `[T2-NEXUS] Over-coupled symbol: ${row.name} (${row.caller_count} callers)`,
+        rationale: `Function ${row.name} in ${row.file_path} has ${row.caller_count} callers but makes no outbound calls \u2014 review for abstraction opportunity`,
+        weight: NEXUS_BASE_WEIGHT
+      });
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[sentient/nexus-ingester] WARNING query A: ${message}
+`);
+  }
+  try {
+    const stmtB = nativeDb.prepare(`
+      SELECT n.id, n.name, n.file_path, COUNT(r.id) as degree
+      FROM nexus_nodes n
+      JOIN nexus_relations r ON r.source_id = n.id OR r.target_id = n.id
+      GROUP BY n.id
+      HAVING degree > :minDegree
+      ORDER BY degree DESC
+      LIMIT :limit
+    `);
+    const rowsB = stmtB.all({
+      minDegree: NEXUS_MIN_DEGREE,
+      limit: NEXUS_QUERY_LIMIT
+    });
+    for (const row of rowsB) {
+      const fp = toFingerprint(row.id);
+      if (seenIds.has(fp)) continue;
+      seenIds.add(fp);
+      candidates.push({
+        source: "nexus",
+        sourceId: row.id,
+        title: `[T2-NEXUS] Over-coupled symbol: ${row.name} (${row.degree} edges)`,
+        rationale: `Symbol ${row.name} in ${row.file_path} has ${row.degree} total edges \u2014 review for over-coupling`,
+        weight: NEXUS_BASE_WEIGHT
+      });
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[sentient/nexus-ingester] WARNING query B: ${message}
+`);
+  }
+  return candidates;
+}
+
+// packages/core/src/sentient/ingesters/test-ingester.ts
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+var GATES_JSONL_PATH = ".cleo/audit/gates.jsonl";
+var COVERAGE_SUMMARY_PATH = ".cleo/coverage-summary.json";
+var MIN_LINE_COVERAGE_PCT = 80;
+var TEST_BASE_WEIGHT = 0.5;
+function runGatesIngester(projectRoot) {
+  const gatesPath = join(projectRoot, GATES_JSONL_PATH);
+  let raw;
+  try {
+    raw = readFileSync(gatesPath, "utf-8");
+  } catch {
+    return [];
+  }
+  const candidates = [];
+  const seenKeys = /* @__PURE__ */ new Set();
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    let record;
+    try {
+      record = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    const taskId = record.taskId;
+    const gate = record.gate ?? "unknown";
+    const failCount = record.failCount ?? 0;
+    if (typeof taskId !== "string" || failCount <= 0) continue;
+    const key = `${taskId}.${gate}`;
+    if (seenKeys.has(key)) continue;
+    seenKeys.add(key);
+    candidates.push({
+      source: "test",
+      sourceId: key,
+      title: `[T2-TEST] Fix flaky gate: ${taskId}.${gate}`,
+      rationale: `Gate '${gate}' on task ${taskId} has failed ${failCount} time(s)`,
+      weight: TEST_BASE_WEIGHT
+    });
+  }
+  return candidates;
+}
+function runCoverageIngester(projectRoot) {
+  const coveragePath = join(projectRoot, COVERAGE_SUMMARY_PATH);
+  let summary;
+  try {
+    const raw = readFileSync(coveragePath, "utf-8");
+    summary = JSON.parse(raw);
+  } catch {
+    return [];
+  }
+  const candidates = [];
+  for (const [filePath, entry] of Object.entries(summary)) {
+    if (filePath === "total") continue;
+    const pct = entry?.lines?.pct;
+    if (typeof pct !== "number" || pct >= MIN_LINE_COVERAGE_PCT) continue;
+    candidates.push({
+      source: "test",
+      sourceId: filePath,
+      title: `[T2-TEST] Increase coverage: ${filePath} (${pct}% lines)`,
+      rationale: `File ${filePath} has ${pct}% line coverage (target: ${MIN_LINE_COVERAGE_PCT}%)`,
+      weight: TEST_BASE_WEIGHT
+    });
+  }
+  return candidates;
+}
+function runTestIngester(projectRoot) {
+  try {
+    const gatesCandidates = runGatesIngester(projectRoot);
+    const coverageCandidates = runCoverageIngester(projectRoot);
+    const seenSourceIds = /* @__PURE__ */ new Set();
+    const merged = [];
+    for (const candidate of [...gatesCandidates, ...coverageCandidates]) {
+      if (seenSourceIds.has(candidate.sourceId)) continue;
+      seenSourceIds.add(candidate.sourceId);
+      merged.push(candidate);
+    }
+    return merged;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[sentient/test-ingester] WARNING: ${message}
+`);
+    return [];
+  }
+}
+
+// packages/core/src/sentient/proposal-rate-limiter.ts
+var SENTIENT_TIER2_TAG = "sentient-tier2";
+var DEFAULT_DAILY_PROPOSAL_LIMIT = 3;
+var SQLITE_BUSY_CODE = "SQLITE_BUSY";
+function countTodayProposals(nativeDb) {
+  if (!nativeDb) return 0;
+  const stmt = nativeDb.prepare(`
+    SELECT COUNT(*) as cnt
+    FROM tasks
+    WHERE labels_json LIKE :labelPattern
+      AND date(created_at) = date('now')
+      AND status IN ('proposed', 'pending', 'active', 'done')
+  `);
+  const row = stmt.get({ labelPattern: `%${SENTIENT_TIER2_TAG}%` });
+  return row?.cnt ?? 0;
+}
+function isRateLimitExceeded(nativeDb, limit = DEFAULT_DAILY_PROPOSAL_LIMIT) {
+  return countTodayProposals(nativeDb) >= limit;
+}
+function transactionalInsertProposal(nativeDb, insertSql, insertParams, limit = DEFAULT_DAILY_PROPOSAL_LIMIT) {
+  try {
+    nativeDb.exec("BEGIN IMMEDIATE");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (msg.includes(SQLITE_BUSY_CODE)) {
+      return { inserted: false, countBeforeInsert: 0, reason: "busy" };
+    }
+    throw err;
+  }
+  try {
+    const countBeforeInsert = countTodayProposals(nativeDb);
+    if (countBeforeInsert >= limit) {
+      nativeDb.exec("ROLLBACK");
+      return { inserted: false, countBeforeInsert, reason: "rate-limit" };
+    }
+    const stmt = nativeDb.prepare(insertSql);
+    stmt.run(insertParams);
+    nativeDb.exec("COMMIT");
+    return { inserted: true, countBeforeInsert };
+  } catch (err) {
+    try {
+      nativeDb.exec("ROLLBACK");
+    } catch {
+    }
+    throw err;
+  }
+}
+
+// packages/core/src/sentient/state.ts
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { dirname, join as join2 } from "node:path";
+var SENTIENT_STATE_SCHEMA_VERSION = "1.0";
+var DEFAULT_SENTIENT_STATE = {
+  schemaVersion: SENTIENT_STATE_SCHEMA_VERSION,
+  pid: null,
+  startedAt: null,
+  lastTickAt: null,
+  killSwitch: false,
+  killSwitchReason: null,
+  stats: {
+    tasksPicked: 0,
+    tasksCompleted: 0,
+    tasksFailed: 0,
+    ticksExecuted: 0,
+    ticksKilled: 0
+  },
+  stuckTasks: {},
+  stuckTimestamps: [],
+  activeTaskId: null,
+  tier2Enabled: false,
+  tier2Stats: {
+    proposalsGenerated: 0,
+    proposalsAccepted: 0,
+    proposalsRejected: 0
+  }
+};
+async function readSentientState(statePath) {
+  try {
+    const raw = await readFile(statePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    return {
+      ...DEFAULT_SENTIENT_STATE,
+      ...parsed,
+      stats: { ...DEFAULT_SENTIENT_STATE.stats, ...parsed.stats ?? {} },
+      stuckTasks: parsed.stuckTasks ?? {},
+      stuckTimestamps: parsed.stuckTimestamps ?? [],
+      tier2Enabled: parsed.tier2Enabled ?? false,
+      tier2Stats: { ...DEFAULT_SENTIENT_STATE.tier2Stats, ...parsed.tier2Stats ?? {} }
+    };
+  } catch {
+    return { ...DEFAULT_SENTIENT_STATE };
+  }
+}
+async function writeSentientState(statePath, state) {
+  const dir = dirname(statePath);
+  await mkdir(dir, { recursive: true });
+  const tmpPath = join2(dir, `.sentient-state-${process.pid}.tmp`);
+  const json = JSON.stringify(state, null, 2);
+  await writeFile(tmpPath, json, "utf-8");
+  await rename(tmpPath, statePath);
+}
+async function patchSentientState(statePath, patch) {
+  const current = await readSentientState(statePath);
+  const updated = {
+    ...current,
+    ...patch,
+    stats: { ...current.stats, ...patch.stats ?? {} }
+  };
+  await writeSentientState(statePath, updated);
+  return updated;
+}
+async function incrementStats(statePath, delta) {
+  const current = await readSentientState(statePath);
+  const nextStats = {
+    tasksPicked: current.stats.tasksPicked + (delta.tasksPicked ?? 0),
+    tasksCompleted: current.stats.tasksCompleted + (delta.tasksCompleted ?? 0),
+    tasksFailed: current.stats.tasksFailed + (delta.tasksFailed ?? 0),
+    ticksExecuted: current.stats.ticksExecuted + (delta.ticksExecuted ?? 0),
+    ticksKilled: current.stats.ticksKilled + (delta.ticksKilled ?? 0)
+  };
+  const updated = { ...current, stats: nextStats };
+  await writeSentientState(statePath, updated);
+  return updated;
+}
+
+// packages/core/src/sentient/propose-tick.ts
+var PROPOSAL_TITLE_PATTERN = /^\[T2-(BRAIN|NEXUS|TEST)\]/;
+var TIER2_LABEL = "sentient-tier2";
+function fingerprint(candidate) {
+  return `${candidate.source}:${candidate.sourceId}`;
+}
+async function killSwitchActive(statePath) {
+  const state = await readSentientState(statePath);
+  return state.killSwitch === true;
+}
+async function runProposeTick(options) {
+  const { projectRoot, statePath } = options;
+  if (await killSwitchActive(statePath)) {
+    return { kind: "killed", written: 0, count: 0, detail: "killSwitch active before ingest" };
+  }
+  const state = await readSentientState(statePath);
+  if (!state.tier2Enabled) {
+    return {
+      kind: "disabled",
+      written: 0,
+      count: 0,
+      detail: "tier2Enabled=false; enable via cleo sentient propose enable"
+    };
+  }
+  let brainDb;
+  let nexusDb;
+  let tasksNativeDb;
+  if (options.brainDb !== void 0) {
+    brainDb = options.brainDb;
+  } else {
+    try {
+      const { getBrainDb, getBrainNativeDb } = await import("@cleocode/core/internal");
+      await getBrainDb(projectRoot);
+      brainDb = getBrainNativeDb();
+    } catch {
+      brainDb = null;
+    }
+  }
+  if (options.nexusDb !== void 0) {
+    nexusDb = options.nexusDb;
+  } else {
+    try {
+      const { getNexusNativeDb } = await import("@cleocode/core/internal");
+      nexusDb = getNexusNativeDb();
+    } catch {
+      nexusDb = null;
+    }
+  }
+  if (options.tasksDb !== void 0) {
+    tasksNativeDb = options.tasksDb;
+  } else {
+    const { getNativeDb, getDb } = await import("@cleocode/core/internal");
+    await getDb(projectRoot);
+    tasksNativeDb = getNativeDb();
+  }
+  const [brainCandidates, nexusCandidates, testCandidates] = await Promise.all([
+    Promise.resolve(runBrainIngester(brainDb)),
+    Promise.resolve(runNexusIngester(nexusDb)),
+    Promise.resolve(runTestIngester(projectRoot))
+  ]);
+  if (await killSwitchActive(statePath)) {
+    return {
+      kind: "killed",
+      written: 0,
+      count: 0,
+      detail: "killSwitch active after ingest phase"
+    };
+  }
+  const seenFingerprints = /* @__PURE__ */ new Set();
+  const merged = [];
+  for (const candidate of [...brainCandidates, ...nexusCandidates, ...testCandidates]) {
+    if (!PROPOSAL_TITLE_PATTERN.test(candidate.title)) {
+      process.stderr.write(
+        `[sentient/propose-tick] Rejected candidate with invalid title format: "${candidate.title}"
+`
+      );
+      continue;
+    }
+    const fp = fingerprint(candidate);
+    if (seenFingerprints.has(fp)) continue;
+    seenFingerprints.add(fp);
+    merged.push(candidate);
+  }
+  if (merged.length === 0) {
+    return { kind: "no-candidates", written: 0, count: 0, detail: "no candidates from ingesters" };
+  }
+  merged.sort((a, b) => b.weight - a.weight);
+  const currentCount = tasksNativeDb ? countTodayProposals(tasksNativeDb) : 0;
+  const slotsRemaining = Math.max(0, DEFAULT_DAILY_PROPOSAL_LIMIT - currentCount);
+  if (slotsRemaining === 0) {
+    return {
+      kind: "rate-limited",
+      written: 0,
+      count: currentCount,
+      detail: `daily limit reached (${currentCount}/${DEFAULT_DAILY_PROPOSAL_LIMIT})`
+    };
+  }
+  const toWrite = merged.slice(0, slotsRemaining);
+  if (await killSwitchActive(statePath)) {
+    return {
+      kind: "killed",
+      written: 0,
+      count: currentCount,
+      detail: "killSwitch active before write phase"
+    };
+  }
+  let written = 0;
+  for (const candidate of toWrite) {
+    let taskId;
+    if (options.allocateTaskId) {
+      taskId = await options.allocateTaskId();
+    } else {
+      const { allocateNextTaskId } = await import("@cleocode/core/internal");
+      taskId = await allocateNextTaskId(projectRoot);
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const labels = JSON.stringify([TIER2_LABEL, `source:${candidate.source}`]);
+    if (!tasksNativeDb) {
+      process.stderr.write("[sentient/propose-tick] tasks DB not available; skipping write\n");
+      break;
+    }
+    const notesJson = JSON.stringify([
+      JSON.stringify({
+        kind: "proposal-meta",
+        proposedBy: "sentient-tier2",
+        source: candidate.source,
+        sourceId: candidate.sourceId,
+        weight: candidate.weight,
+        proposedAt: now
+      })
+    ]);
+    const insertSql = `
+      INSERT INTO tasks (
+        id, title, description, status, priority,
+        labels_json, notes_json,
+        created_at, updated_at,
+        role, scope
+      ) VALUES (
+        :id, :title, :description, :status, :priority,
+        :labelsJson, :notesJson,
+        :createdAt, :updatedAt,
+        :role, :scope
+      )
+    `;
+    const insertParams = {
+      id: taskId,
+      title: candidate.title,
+      description: candidate.rationale,
+      status: "proposed",
+      priority: "medium",
+      labelsJson: labels,
+      notesJson,
+      createdAt: now,
+      updatedAt: now,
+      role: "work",
+      scope: "feature"
+    };
+    try {
+      const result = transactionalInsertProposal(
+        tasksNativeDb,
+        insertSql,
+        insertParams,
+        DEFAULT_DAILY_PROPOSAL_LIMIT
+      );
+      if (result.inserted) {
+        written++;
+      } else if (result.reason === "rate-limit") {
+        break;
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`[sentient/propose-tick] INSERT failed for ${taskId}: ${message}
+`);
+    }
+  }
+  if (written > 0) {
+    const latestState = await readSentientState(statePath);
+    await patchSentientState(statePath, {
+      tier2Stats: {
+        ...latestState.tier2Stats,
+        proposalsGenerated: latestState.tier2Stats.proposalsGenerated + written
+      }
+    });
+  }
+  const finalCount = tasksNativeDb ? countTodayProposals(tasksNativeDb) : currentCount + written;
+  if (written === 0) {
+    return {
+      kind: "no-candidates",
+      written: 0,
+      count: finalCount,
+      detail: "candidates available but none written (rate limit or DB unavailable)"
+    };
+  }
+  return {
+    kind: "wrote",
+    written,
+    count: finalCount,
+    detail: `wrote ${written} proposal(s) (${finalCount}/${DEFAULT_DAILY_PROPOSAL_LIMIT} today)`
+  };
+}
+async function safeRunProposeTick(options) {
+  try {
+    return await runProposeTick(options);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      kind: "error",
+      written: 0,
+      count: 0,
+      detail: `propose tick threw: ${message}`
+    };
+  }
+}
+
+// packages/core/src/sentient/tick.ts
+import { spawn } from "node:child_process";
+var DREAM_VOLUME_THRESHOLD_DEFAULT = 50;
+var DREAM_IDLE_TICKS_DEFAULT = 5;
+var DEFAULT_ADAPTER = "claude-code";
+var RETRY_BACKOFF_MS = [3e4, 3e5, 18e5];
+var MAX_TASK_ATTEMPTS = RETRY_BACKOFF_MS.length;
+var SELF_PAUSE_STUCK_THRESHOLD = 5;
+var SELF_PAUSE_WINDOW_MS = 60 * 60 * 1e3;
+var SELF_PAUSE_REASON = "self-pause: 5 stuck tasks in 1 hour";
+var SPAWN_TIMEOUT_MS = 30 * 60 * 1e3;
+async function killSwitchActive2(statePath) {
+  const state = await readSentientState(statePath);
+  return state.killSwitch === true;
+}
+function pruneStuckWindow(timestamps, now) {
+  const cutoff = now - SELF_PAUSE_WINDOW_MS;
+  return timestamps.filter((t) => t >= cutoff);
+}
+async function defaultPickTask(projectRoot) {
+  const { Cleo } = await import("@cleocode/core/sdk");
+  const { getReadyTasks } = await import("@cleocode/core/tasks");
+  const cleo = await Cleo.init(projectRoot);
+  const pending = await cleo.tasks.find({ status: "pending", limit: 500 });
+  const candidates = Array.isArray(pending?.data?.tasks) ? pending.data.tasks : [];
+  if (candidates.length === 0) return null;
+  const ready = getReadyTasks(candidates);
+  if (ready.length === 0) return null;
+  ready.sort((a, b) => a.id.localeCompare(b.id));
+  return ready[0];
+}
+function defaultSpawn(taskId, adapter, projectRoot) {
+  return new Promise((resolve) => {
+    const args = ["orchestrate", "spawn", taskId, "--adapter", adapter];
+    const child = spawn("cleo", args, {
+      cwd: projectRoot,
+      env: { ...process.env, CLEO_SENTIENT_SPAWN: "1" },
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString("utf-8");
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString("utf-8");
+    });
+    const timer = setTimeout(() => {
+      child.kill("SIGTERM");
+    }, SPAWN_TIMEOUT_MS);
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      resolve({
+        exitCode: 1,
+        stdout,
+        stderr: stderr + `
+[sentient] spawn error: ${err.message}`
+      });
+    });
+    child.on("exit", (code) => {
+      clearTimeout(timer);
+      resolve({
+        exitCode: code ?? 1,
+        stdout: stdout.slice(-4e3),
+        stderr: stderr.slice(-4e3)
+      });
+    });
+  });
+}
+async function writeSuccessReceipt(projectRoot, taskId, exitCode) {
+  try {
+    const { Cleo } = await import("@cleocode/core/sdk");
+    const cleo = await Cleo.init(projectRoot);
+    await cleo.memory.observe({
+      text: `sentient-tier1: task ${taskId} completed successfully (exit=${exitCode})`,
+      title: `sentient-receipt: ${taskId}`
+    });
+  } catch {
+  }
+}
+var consecutiveIdleTicks = 0;
+async function maybeTriggerDream(projectRoot, opts, pickedTask) {
+  const volumeThreshold = opts.dreamVolumeThreshold ?? DREAM_VOLUME_THRESHOLD_DEFAULT;
+  const idleTicksThreshold = opts.dreamIdleTicks ?? DREAM_IDLE_TICKS_DEFAULT;
+  if (volumeThreshold <= 0 && idleTicksThreshold <= 0) return;
+  if (pickedTask) {
+    consecutiveIdleTicks = 0;
+  } else {
+    consecutiveIdleTicks += 1;
+  }
+  const dreamer = opts.checkAndDream ?? (async (root, dreamerOpts) => {
+    const { checkAndDream } = await import("@cleocode/core/internal");
+    return checkAndDream(root, dreamerOpts);
+  });
+  try {
+    await dreamer(projectRoot, {
+      volumeThreshold: volumeThreshold > 0 ? volumeThreshold : void 0,
+      inline: false
+    }).catch((err) => {
+      console.warn("[sentient/tick] dream trigger error:", err);
+    });
+  } catch (err) {
+    console.warn("[sentient/tick] dream trigger threw:", err);
+  }
+}
+async function writeFailureReceipt(projectRoot, taskId, attempt, exitCode, reason) {
+  try {
+    const { Cleo } = await import("@cleocode/core/sdk");
+    const cleo = await Cleo.init(projectRoot);
+    await cleo.memory.observe({
+      text: `sentient-tier1: task ${taskId} failed (attempt=${attempt}/${MAX_TASK_ATTEMPTS}, exit=${exitCode}). reason=${reason.slice(0, 500)}`,
+      title: `sentient-failure: ${taskId}`
+    });
+  } catch {
+  }
+}
+async function runTick(options) {
+  const { projectRoot, statePath } = options;
+  const adapter = options.adapter ?? DEFAULT_ADAPTER;
+  const now = Date.now();
+  if (await killSwitchActive2(statePath)) {
+    await incrementStats(statePath, { ticksKilled: 1 });
+    await patchSentientState(statePath, { lastTickAt: new Date(now).toISOString() });
+    return { kind: "killed", taskId: null, detail: "killSwitch active before pick" };
+  }
+  const picker = options.pickTask ?? defaultPickTask;
+  let task;
+  try {
+    task = await picker(projectRoot);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    await incrementStats(statePath, { ticksExecuted: 1 });
+    await patchSentientState(statePath, { lastTickAt: new Date(now).toISOString() });
+    return { kind: "error", taskId: null, detail: `picker threw: ${message}` };
+  }
+  if (task === null) {
+    await incrementStats(statePath, { ticksExecuted: 1 });
+    await patchSentientState(statePath, { lastTickAt: new Date(now).toISOString() });
+    return { kind: "no-task", taskId: null, detail: "no unblocked tasks available" };
+  }
+  const preSpawnState = await readSentientState(statePath);
+  const existingStuck = preSpawnState.stuckTasks[task.id];
+  if (existingStuck && existingStuck.nextRetryAt > now) {
+    await incrementStats(statePath, { ticksExecuted: 1 });
+    await patchSentientState(statePath, { lastTickAt: new Date(now).toISOString() });
+    return {
+      kind: "backoff",
+      taskId: task.id,
+      detail: `task ${task.id} in backoff until ${new Date(existingStuck.nextRetryAt).toISOString()}`
+    };
+  }
+  if (await killSwitchActive2(statePath)) {
+    await incrementStats(statePath, { ticksKilled: 1 });
+    await patchSentientState(statePath, { lastTickAt: new Date(now).toISOString() });
+    return { kind: "killed", taskId: task.id, detail: "killSwitch active before spawn" };
+  }
+  await incrementStats(statePath, { tasksPicked: 1 });
+  await patchSentientState(statePath, { activeTaskId: task.id });
+  let spawnResult;
+  if (options.dryRun === true) {
+    spawnResult = {
+      exitCode: 0,
+      stdout: "[dry-run] spawn skipped",
+      stderr: ""
+    };
+  } else {
+    try {
+      const spawner = options.spawn ?? ((tid, adp) => defaultSpawn(tid, adp, projectRoot));
+      spawnResult = await spawner(task.id, adapter);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      spawnResult = { exitCode: 1, stdout: "", stderr: `spawn threw: ${message}` };
+    }
+  }
+  if (await killSwitchActive2(statePath)) {
+    await incrementStats(statePath, { ticksKilled: 1 });
+    await patchSentientState(statePath, {
+      lastTickAt: new Date(Date.now()).toISOString(),
+      activeTaskId: null
+    });
+    return {
+      kind: "killed",
+      taskId: task.id,
+      detail: "killSwitch active after spawn; result not recorded"
+    };
+  }
+  if (spawnResult.exitCode === 0) {
+    await writeSuccessReceipt(projectRoot, task.id, spawnResult.exitCode);
+    const post2 = await readSentientState(statePath);
+    const { [task.id]: _removed, ...rest } = post2.stuckTasks;
+    void _removed;
+    await patchSentientState(statePath, {
+      stuckTasks: rest,
+      activeTaskId: null,
+      lastTickAt: new Date(Date.now()).toISOString()
+    });
+    await incrementStats(statePath, { tasksCompleted: 1, ticksExecuted: 1 });
+    return {
+      kind: "success",
+      taskId: task.id,
+      detail: `task ${task.id} completed (exit=0)`
+    };
+  }
+  const currentAttempts = existingStuck?.attempts ?? 0;
+  const nextAttempts = currentAttempts + 1;
+  const failureReason = spawnResult.stderr.slice(-500) || `exit=${spawnResult.exitCode}`;
+  await writeFailureReceipt(
+    projectRoot,
+    task.id,
+    nextAttempts,
+    spawnResult.exitCode,
+    failureReason
+  );
+  await incrementStats(statePath, { tasksFailed: 1, ticksExecuted: 1 });
+  if (nextAttempts >= MAX_TASK_ATTEMPTS) {
+    const windowed = pruneStuckWindow(preSpawnState.stuckTimestamps, now);
+    windowed.push(now);
+    const stuckRecord2 = {
+      attempts: nextAttempts,
+      lastFailureAt: new Date(now).toISOString(),
+      nextRetryAt: Number.MAX_SAFE_INTEGER,
+      // owner-only release
+      lastReason: failureReason
+    };
+    const post2 = await readSentientState(statePath);
+    const updatedStuckTasks = {
+      ...post2.stuckTasks,
+      [task.id]: stuckRecord2
+    };
+    const shouldSelfPause = windowed.length >= SELF_PAUSE_STUCK_THRESHOLD;
+    await patchSentientState(statePath, {
+      stuckTasks: updatedStuckTasks,
+      stuckTimestamps: windowed,
+      activeTaskId: null,
+      lastTickAt: new Date(now).toISOString(),
+      ...shouldSelfPause ? { killSwitch: true, killSwitchReason: SELF_PAUSE_REASON } : {}
+    });
+    if (shouldSelfPause) {
+      return {
+        kind: "self-paused",
+        taskId: task.id,
+        detail: `task ${task.id} is stuck; self-pause fired (${windowed.length}/${SELF_PAUSE_STUCK_THRESHOLD} stucks in window)`
+      };
+    }
+    return {
+      kind: "stuck",
+      taskId: task.id,
+      detail: `task ${task.id} stuck after ${nextAttempts} attempts; owner must re-enable via \`cleo sentient resume\``
+    };
+  }
+  const backoff = RETRY_BACKOFF_MS[nextAttempts - 1] ?? RETRY_BACKOFF_MS[RETRY_BACKOFF_MS.length - 1];
+  const stuckRecord = {
+    attempts: nextAttempts,
+    lastFailureAt: new Date(now).toISOString(),
+    nextRetryAt: now + backoff,
+    lastReason: failureReason
+  };
+  const post = await readSentientState(statePath);
+  await patchSentientState(statePath, {
+    stuckTasks: { ...post.stuckTasks, [task.id]: stuckRecord },
+    activeTaskId: null,
+    lastTickAt: new Date(now).toISOString()
+  });
+  return {
+    kind: "failure",
+    taskId: task.id,
+    detail: `task ${task.id} failed (attempt=${nextAttempts}/${MAX_TASK_ATTEMPTS}); retry scheduled at ${new Date(now + backoff).toISOString()}`
+  };
+}
+async function safeRunTick(options) {
+  let outcome;
+  try {
+    outcome = await runTick(options);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    try {
+      await incrementStats(options.statePath, { ticksExecuted: 1 });
+    } catch {
+    }
+    outcome = { kind: "error", taskId: null, detail: `tick threw: ${message}` };
+  }
+  const pickedTask = outcome.kind !== "no-task" && outcome.kind !== "killed" && outcome.kind !== "error" && outcome.taskId !== null;
+  await maybeTriggerDream(options.projectRoot, options, pickedTask).catch(() => {
+  });
+  return outcome;
+}
+function isFailureOutcome(outcome) {
+  return outcome.kind === "failure" || outcome.kind === "stuck" || outcome.kind === "self-paused";
+}
+async function getKillStatus(statePath) {
+  const state = await readSentientState(statePath);
+  return { killSwitch: state.killSwitch, killSwitchReason: state.killSwitchReason };
+}
+function _resetDreamTickState() {
+  consecutiveIdleTicks = 0;
+}
+function _getConsecutiveIdleTicks() {
+  return consecutiveIdleTicks;
+}
+
+// packages/core/src/sentient/daemon.ts
+var SENTIENT_STATE_FILE = ".cleo/sentient-state.json";
+var SENTIENT_LOCK_FILE = ".cleo/sentient.lock";
+var SENTIENT_CRON_EXPR = "*/5 * * * *";
+var SENTIENT_PROPOSE_CRON_EXPR = "0 */2 * * *";
+var SENTIENT_LOG_DIR = ".cleo/logs";
+var SENTIENT_LOG = "sentient.log";
+var SENTIENT_ERR = "sentient.err";
+async function acquireLock(lockPath) {
+  await mkdir2(join3(lockPath, ".."), { recursive: true });
+  try {
+    const handle = await fsOpen(
+      lockPath,
+      fsConstants.O_CREAT | fsConstants.O_EXCL | fsConstants.O_RDWR,
+      420
+    );
+    await handle.writeFile(String(process.pid), "utf-8");
+    return { path: lockPath, handle };
+  } catch (err) {
+    const code = err.code;
+    if (code !== "EEXIST") throw err;
+  }
+  let existing = null;
+  try {
+    existing = await fsOpen(lockPath, fsConstants.O_RDWR);
+    const buf = await existing.readFile({ encoding: "utf-8" });
+    const recordedPid = Number.parseInt(buf.trim(), 10);
+    if (Number.isFinite(recordedPid) && recordedPid > 0) {
+      try {
+        process.kill(recordedPid, 0);
+        await existing.close();
+        return null;
+      } catch {
+      }
+    }
+    await existing.truncate(0);
+    const pidBytes = Buffer.from(String(process.pid), "utf-8");
+    await existing.write(pidBytes, 0, pidBytes.length, 0);
+    return { path: lockPath, handle: existing };
+  } catch (err) {
+    if (existing) {
+      try {
+        await existing.close();
+      } catch {
+      }
+    }
+    throw err;
+  }
+}
+async function releaseLock(lock) {
+  try {
+    await lock.handle.close();
+  } catch {
+  }
+}
+async function bootstrapDaemon(projectRoot) {
+  const statePath = join3(projectRoot, SENTIENT_STATE_FILE);
+  const lockPath = join3(projectRoot, SENTIENT_LOCK_FILE);
+  const lock = await acquireLock(lockPath);
+  if (!lock) {
+    process.stderr.write(`[CLEO SENTIENT] lock acquisition failed \u2014 another daemon is running
+`);
+    process.exit(2);
+  }
+  await patchSentientState(statePath, {
+    pid: process.pid,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString()
+    // Clear killSwitch on boot only if owner did not explicitly leave it set.
+    // We preserve it here: re-starting a killed daemon must not silently
+    // resume. Owner explicitly clears via `cleo sentient resume`.
+  });
+  let watcher = null;
+  try {
+    watcher = watch(statePath, { persistent: false }, () => {
+    });
+  } catch {
+    watcher = null;
+  }
+  const shutdown = async (reason) => {
+    try {
+      watcher?.close();
+    } catch {
+    }
+    try {
+      await patchSentientState(statePath, {
+        pid: null,
+        killSwitchReason: reason
+      });
+    } catch {
+    }
+    try {
+      await releaseLock(lock);
+    } catch {
+    }
+    process.exit(0);
+  };
+  process.on("SIGTERM", () => {
+    void shutdown("SIGTERM");
+  });
+  process.on("SIGINT", () => {
+    void shutdown("SIGINT");
+  });
+  const tickOptions = { projectRoot, statePath };
+  const outcome = await safeRunTick(tickOptions);
+  process.stdout.write(
+    `[CLEO SENTIENT] boot tick: ${outcome.kind} (task=${outcome.taskId ?? "n/a"}) ${outcome.detail}
+`
+  );
+  cron.schedule(
+    SENTIENT_CRON_EXPR,
+    async () => {
+      const result = await safeRunTick(tickOptions);
+      process.stdout.write(
+        `[CLEO SENTIENT] tick: ${result.kind} (task=${result.taskId ?? "n/a"}) ${result.detail}
+`
+      );
+    },
+    {
+      timezone: "UTC",
+      noOverlap: true,
+      name: "cleo-sentient"
+    }
+  );
+  const proposeOptions = { projectRoot, statePath };
+  cron.schedule(
+    SENTIENT_PROPOSE_CRON_EXPR,
+    async () => {
+      const state = await readSentientState(statePath);
+      if (!state.tier2Enabled) return;
+      const result = await safeRunProposeTick(proposeOptions);
+      process.stdout.write(
+        `[CLEO SENTIENT T2] propose: ${result.kind} (written=${result.written}, count=${result.count}) ${result.detail}
+`
+      );
+    },
+    {
+      timezone: "UTC",
+      noOverlap: true,
+      name: "cleo-sentient-propose"
+    }
+  );
+}
+async function spawnSentientDaemon(projectRoot) {
+  const logsDir = join3(projectRoot, SENTIENT_LOG_DIR);
+  await mkdir2(logsDir, { recursive: true });
+  const logPath = join3(logsDir, SENTIENT_LOG);
+  const errPath = join3(logsDir, SENTIENT_ERR);
+  const outStream = createWriteStream(logPath, { flags: "a" });
+  const errStream = createWriteStream(errPath, { flags: "a" });
+  const daemonEntry = join3(fileURLToPath(import.meta.url), "..", "daemon-entry.js");
+  const child = spawn2(process.execPath, [daemonEntry, projectRoot], {
+    detached: true,
+    stdio: ["ignore", outStream, errStream],
+    env: { ...process.env, CLEO_SENTIENT_DAEMON: "1" }
+  });
+  child.unref();
+  const pid = child.pid ?? 0;
+  const statePath = join3(projectRoot, SENTIENT_STATE_FILE);
+  await patchSentientState(statePath, {
+    pid,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  return { pid, statePath, logPath };
+}
+async function stopSentientDaemon(projectRoot, reason = "cleo sentient stop") {
+  const statePath = join3(projectRoot, SENTIENT_STATE_FILE);
+  const state = await readSentientState(statePath);
+  await patchSentientState(statePath, {
+    killSwitch: true,
+    killSwitchReason: reason
+  });
+  const pid = state.pid;
+  if (!pid) {
+    return {
+      stopped: false,
+      pid: null,
+      reason: "killSwitch set; no daemon pid recorded (no active process to signal)"
+    };
+  }
+  try {
+    process.kill(pid, 0);
+  } catch {
+    await patchSentientState(statePath, { pid: null });
+    return {
+      stopped: true,
+      pid,
+      reason: `killSwitch set; daemon pid ${pid} was already dead (cleared)`
+    };
+  }
+  try {
+    process.kill(pid, "SIGTERM");
+    return { stopped: true, pid, reason: `killSwitch set + SIGTERM delivered to pid ${pid}` };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      stopped: false,
+      pid,
+      reason: `killSwitch set but SIGTERM failed: ${message}`
+    };
+  }
+}
+async function resumeSentientDaemon(projectRoot) {
+  const statePath = join3(projectRoot, SENTIENT_STATE_FILE);
+  return patchSentientState(statePath, {
+    killSwitch: false,
+    killSwitchReason: null
+  });
+}
+async function getSentientDaemonStatus(projectRoot) {
+  const statePath = join3(projectRoot, SENTIENT_STATE_FILE);
+  const state = await readSentientState(statePath);
+  let running = false;
+  if (state.pid) {
+    try {
+      process.kill(state.pid, 0);
+      running = true;
+    } catch {
+      running = false;
+    }
+  }
+  return {
+    running,
+    pid: running ? state.pid : null,
+    startedAt: state.startedAt,
+    lastTickAt: state.lastTickAt,
+    killSwitch: state.killSwitch,
+    killSwitchReason: state.killSwitchReason,
+    stats: state.stats,
+    stuckCount: Object.keys(state.stuckTasks).length,
+    activeTaskId: state.activeTaskId
+  };
+}
+export {
+  BRAIN_INGESTER_LIMIT,
+  BRAIN_LOOKBACK_DAYS,
+  BRAIN_MIN_CITATION_COUNT,
+  BRAIN_MIN_QUALITY_SCORE,
+  COVERAGE_SUMMARY_PATH,
+  DEFAULT_ADAPTER,
+  DEFAULT_DAILY_PROPOSAL_LIMIT,
+  DEFAULT_SENTIENT_STATE,
+  DREAM_IDLE_TICKS_DEFAULT,
+  DREAM_VOLUME_THRESHOLD_DEFAULT,
+  GATES_JSONL_PATH,
+  MAX_TASK_ATTEMPTS,
+  MIN_LINE_COVERAGE_PCT,
+  NEXUS_BASE_WEIGHT,
+  NEXUS_MIN_CALLER_COUNT,
+  NEXUS_MIN_DEGREE,
+  NEXUS_QUERY_LIMIT,
+  PROPOSAL_TITLE_PATTERN,
+  RETRY_BACKOFF_MS,
+  SELF_PAUSE_REASON,
+  SELF_PAUSE_STUCK_THRESHOLD,
+  SELF_PAUSE_WINDOW_MS,
+  SENTIENT_CRON_EXPR,
+  SENTIENT_ERR,
+  SENTIENT_LOCK_FILE,
+  SENTIENT_LOG,
+  SENTIENT_LOG_DIR,
+  SENTIENT_PROPOSE_CRON_EXPR,
+  SENTIENT_STATE_FILE,
+  SENTIENT_STATE_SCHEMA_VERSION,
+  SENTIENT_TIER2_TAG,
+  SPAWN_TIMEOUT_MS,
+  TEST_BASE_WEIGHT,
+  TIER2_LABEL,
+  _getConsecutiveIdleTicks,
+  _resetDreamTickState,
+  acquireLock,
+  bootstrapDaemon,
+  computeBrainWeight,
+  countTodayProposals,
+  getKillStatus,
+  getSentientDaemonStatus,
+  incrementStats,
+  isFailureOutcome,
+  isRateLimitExceeded,
+  patchSentientState,
+  readSentientState,
+  releaseLock,
+  resumeSentientDaemon,
+  runBrainIngester,
+  runNexusIngester,
+  runProposeTick,
+  runTestIngester,
+  runTick,
+  safeRunProposeTick,
+  safeRunTick,
+  spawnSentientDaemon,
+  stopSentientDaemon,
+  transactionalInsertProposal,
+  writeSentientState
+};
+//# sourceMappingURL=index.js.map