@cleocode/core 2026.4.99 → 2026.4.100

package/dist/sentient/propose-tick.js

@@ -0,0 +1,549 @@
+// 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 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;
+}
+
+// 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}`
+    };
+  }
+}
+export {
+  PROPOSAL_TITLE_PATTERN,
+  TIER2_LABEL,
+  runProposeTick,
+  safeRunProposeTick
+};
+//# sourceMappingURL=propose-tick.js.map