@skyf0xx/hedgehog 5.4.2 → 6.0.2

package/src/db/code-intelligence.mjs

@@ -0,0 +1,291 @@
+// Pre-computed task context: the symbols and files a task's scope
+// actually touches, resolved from a code-intelligence index at compile
+// time and written onto the task row by plan.mjs.
+//
+// This is the only file in the build graph that knows the shape of the
+// CodeGraphContext calls. It imports nothing from CGC — the `provider`
+// is injected by the caller (bin/cli.mjs builds it, rebuild.mjs and
+// every repro harness pass null or a fake), so the graph keeps
+// compiling with no index present and no dependency to install.
+//
+// The index the calls read models a repo as: Repository(path, name),
+// File(path, language, hash), Module(name), Class(name, path,
+// start_line, end_line), Function(name, path, signature, docstring,
+// complexity, start_line, end_line); joined by CONTAINS, IMPORTS,
+// CALLS, INHERITS, IMPLEMENTS. File.path and Function.path are what map
+// a symbol back onto a Hedgehog scope glob.
+//
+// Failure is always null, never a throw. Resolution runs inside
+// plan.mjs's BEGIN IMMEDIATE transaction, where an escaping error rolls
+// the whole plan back and a hang holds a write lock — so a missing,
+// slow, or broken index costs a task its PRE-READ section and nothing
+// more.
+//
+// CGC is mandatory at `init`, so a working index is the ordinary case,
+// not this one. Null-everywhere is what an install that worked and
+// later broke falls back to: the environment deleted by hand, disk full
+// mid-reindex, the MCP subprocess crashed, or `.hedgehog/` copied to a
+// machine that never ran `init`. Mandatory-at-`init` guarantees the
+// moment `init` succeeds; it is not an invariant enforced for the rest
+// of the project's life, and this module is what absorbs the gap.
+
+import { matchesGlob } from './core.mjs';
+
+// How many symbols and files a single task row may carry. A row long
+// enough to be worth skimming is the point; a 500-symbol row bloats
+// every packet that reads it and gets skipped whole.
+export const MAX_SYMBOLS = 40;
+export const MAX_FILES = 30;
+
+// Transitive-caller depth for the blast radius. Deep enough to reach
+// past a task's own layer, shallow enough that a hub function doesn't
+// pull in the repo.
+export const CALLER_DEPTH = 3;
+
+// Wall-clock budget for the whole walk, seed query and every caller
+// call together. Spent, the walk returns whatever it has.
+export const RESOLVE_TIMEOUT_MS = 10_000;
+
+// How many seeds get a find_all_callers call. The seed set is already
+// capped by the Cypher query's own LIMIT; this bounds the round trips.
+const MAX_SEED_EXPANSIONS = 20;
+
+// The kinds this module reads out of the index. Both carry name, path
+// and start_line, which is the whole of what a symbol row holds.
+const SYMBOL_KINDS = ['Function', 'Class'];
+
+// A scope glob reduced to the literal directory prefix every path it
+// matches must start with: segments up to the first one carrying a
+// wildcard. `apps/{module}/**` has already had {module} filled by
+// plan.mjs, so what arrives here is concrete. An empty prefix means the
+// glob constrains nothing at the front and matches repo-wide.
+export function globPrefix(glob) {
+  const segments = String(glob).split('/');
+  const literal = [];
+  for (const segment of segments) {
+    if (/[*?[]/.test(segment)) break;
+    if (segment !== '') literal.push(segment);
+  }
+  return literal.join('/');
+}
+
+// The distinct prefixes a task's scope reduces to. A repo-wide prefix
+// ('') absorbs the rest — matching inside it is matching anywhere.
+function scopePrefixes(scopeGlobs) {
+  const prefixes = new Set();
+  for (const glob of scopeGlobs) {
+    const prefix = globPrefix(glob);
+    if (prefix === '') return [''];
+    prefixes.add(prefix);
+  }
+  return [...prefixes];
+}
+
+// task.scope_globs is stored as a JSON string (plan.mjs#layerTaskFields).
+// A row written by hand, or by an older compile, may hold something
+// else — a parse failure is a task with no resolvable scope, not an
+// error worth aborting a plan run for.
+function parseScopeGlobs(task) {
+  try {
+    const parsed = JSON.parse(task?.scope_globs ?? 'null');
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter((g) => typeof g === 'string' && g !== '');
+  } catch {
+    return [];
+  }
+}
+
+// Rejects the whole walk once the budget is spent. Racing each call
+// against this bounds total wall clock rather than per-call latency, so
+// twenty slow-but-finishing calls can't add up past the budget.
+function withDeadline(promise, deadline) {
+  const remaining = deadline - Date.now();
+  if (remaining <= 0) return Promise.reject(new Error('code-intelligence timeout'));
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error('code-intelligence timeout')), remaining);
+    Promise.resolve(promise).then(
+      (value) => {
+        clearTimeout(timer);
+        resolve(value);
+      },
+      (error) => {
+        clearTimeout(timer);
+        reject(error);
+      },
+    );
+  });
+}
+
+// Providers hand results back in whatever envelope their transport
+// used — a bare array, or one wrapped under `results`/`records`/`data`.
+// Anything else reads as no rows.
+function rowsOf(result) {
+  if (Array.isArray(result)) return result;
+  if (!result || typeof result !== 'object') return [];
+  for (const key of ['results', 'records', 'rows', 'data', 'nodes']) {
+    if (Array.isArray(result[key])) return result[key];
+  }
+  return [];
+}
+
+// One graph node reduced to the symbol shape a task row stores. The
+// node may arrive as the row itself or under a `node`/`symbol` key, and
+// its kind may come from a label list rather than a field.
+function toSymbol(row) {
+  const node = row?.node ?? row?.symbol ?? row;
+  if (!node || typeof node !== 'object') return null;
+
+  const name = node.name ?? node.symbol ?? null;
+  const path = node.path ?? node.file ?? node.file_path ?? null;
+  if (typeof name !== 'string' || typeof path !== 'string') return null;
+
+  const labels = Array.isArray(node.labels) ? node.labels : [];
+  const kind =
+    node.kind ?? labels.find((label) => SYMBOL_KINDS.includes(label)) ?? labels[0] ?? 'Symbol';
+
+  const startLine = node.start_line ?? node.startLine ?? null;
+
+  return {
+    name,
+    kind: String(kind),
+    path,
+    start_line: typeof startLine === 'number' ? startLine : null,
+  };
+}
+
+// Seeds: every Function and Class the index has inside the task's own
+// scope. Bound in the query rather than interpolated — `prefixes` comes
+// off a task row, and the provider runs this against a live graph.
+const SEED_CYPHER = `
+  MATCH (f:File)-[:CONTAINS]->(s)
+  WHERE (s:Function OR s:Class)
+    AND any(prefix IN $prefixes WHERE prefix = '' OR f.path STARTS WITH prefix)
+  RETURN s.name AS name, labels(s) AS labels, s.path AS path, s.start_line AS start_line
+  LIMIT $limit
+`;
+
+// Resolves the symbols and files one task's scope reaches: the symbols
+// declared inside its scope, plus the transitive callers of each — the
+// blast radius a change inside that scope carries.
+//
+// Returns { symbols, files } — symbols as { name, kind, path,
+// start_line }, files as repo-relative path strings, both capped — or
+// null when there is no provider, no scope, no index content, or
+// anything at all goes wrong.
+export async function resolveTaskContext(task, provider) {
+  if (!provider || typeof provider.execute_cypher_query !== 'function') return null;
+
+  try {
+    const deadline = Date.now() + RESOLVE_TIMEOUT_MS;
+
+    const scopeGlobs = parseScopeGlobs(task);
+    if (scopeGlobs.length === 0) return null;
+    const prefixes = scopePrefixes(scopeGlobs);
+
+    const seedResult = await withDeadline(
+      provider.execute_cypher_query({
+        cypher_query: SEED_CYPHER,
+        params: { prefixes, limit: MAX_SYMBOLS },
+      }),
+      deadline,
+    );
+
+    // Keyed by name+path so the same symbol reached from two seeds
+    // lands once; insertion order keeps the in-scope seeds ahead of
+    // the callers they pulled in, which is the order the caps trim to.
+    const symbols = new Map();
+    const files = new Set();
+
+    const remember = (row) => {
+      const symbol = toSymbol(row);
+      if (!symbol) return null;
+      const key = `${symbol.path}::${symbol.name}`;
+      if (!symbols.has(key)) symbols.set(key, symbol);
+      files.add(symbol.path);
+      return symbol;
+    };
+
+    const seeds = [];
+    for (const row of rowsOf(seedResult)) {
+      const symbol = remember(row);
+      if (symbol) seeds.push(symbol);
+    }
+    if (seeds.length === 0) return null;
+
+    // Blast radius: one transitive-caller call per seed, each scoped by
+    // the seed's own file so a common name resolves to the right symbol.
+    if (typeof provider.analyze_code_relationships === 'function') {
+      for (const seed of seeds.slice(0, MAX_SEED_EXPANSIONS)) {
+        if (symbols.size >= MAX_SYMBOLS && files.size >= MAX_FILES) break;
+        const callers = await withDeadline(
+          provider.analyze_code_relationships({
+            query_type: 'find_all_callers',
+            target: seed.name,
+            context: seed.path,
+            depth: CALLER_DEPTH,
+          }),
+          deadline,
+        );
+        for (const row of rowsOf(callers)) remember(row);
+      }
+    }
+
+    return {
+      symbols: [...symbols.values()].slice(0, MAX_SYMBOLS),
+      files: [...files].slice(0, MAX_FILES),
+    };
+  } catch {
+    return null;
+  }
+}
+
+// task.context_files is stored as a JSON array of repo-relative path
+// strings (resolveTaskContext, above). A row written by hand, or by an
+// older compile, may hold something else — a parse failure means no
+// computed radius to check, not an error worth surfacing.
+function parseContextFiles(task) {
+  try {
+    const parsed = JSON.parse(task?.context_files ?? 'null');
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter((f) => typeof f === 'string' && f !== '');
+  } catch {
+    return [];
+  }
+}
+
+// The declared radius a task's verify command is expected to cover:
+// verify_radius when set, scope_globs otherwise — the same fallback
+// conflict.mjs's verifyRadius(task) applies, kept in sync with it by
+// hand since the two read different columns off the same row.
+function declaredRadiusGlobs(task) {
+  const source = task?.verify_radius ?? task?.scope_globs;
+  try {
+    const parsed = JSON.parse(source ?? 'null');
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter((g) => typeof g === 'string' && g !== '');
+  } catch {
+    return [];
+  }
+}
+
+// Advisory only — never called from a path that blocks or gates. The
+// computed blast radius (context_files) against the declared radius
+// (verify_radius, falling back to scope_globs): files the index says the
+// task's code reaches that no declared glob covers. A wrong or stale
+// answer here costs a reader one ignored suggestion, never a build.
+//
+// Returns [] when context_files is absent, unparseable, or empty — "no
+// index available" and "index found nothing uncovered" read the same to
+// a caller, which is correct: neither is ever worth blocking on.
+export function radiusGaps(task) {
+  const files = parseContextFiles(task);
+  if (files.length === 0) return [];
+
+  const globs = declaredRadiusGlobs(task);
+  if (globs.length === 0) return files;
+
+  return files.filter((file) => {
+    const segments = file.split('/').filter((segment) => segment !== '');
+    return !globs.some((glob) => matchesGlob(segments, glob));
+  });
+}

package/src/db/community.mjs

@@ -15,7 +15,9 @@
 //      project. Both stated plainly.
 //
 // State lives in `.hedgehog/community.json`, per project rather than in
-// `~/.hedgehog/`.
+// `~/.hedgehog/`. That file is also where the other per-project
+// "already said once" record lives — the code-intelligence advisory at
+// the bottom of this file — so one read answers both.
 
 import { readFile, writeFile, mkdir } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
@@ -128,3 +130,26 @@ export function formatStarPrompt() {
     '  and carry on with the build.',
   ].join('\n');
 }
+
+// Whether the code-intelligence advisory should be shown by `status`
+// now. `status` runs at the start of every session, so a notice that
+// repeated there would be nagging rather than informing — this shows it
+// once and then goes quiet, leaving `update` (run deliberately, and far
+// less often) as the place the gap keeps being reported.
+//
+// Shares `.hedgehog/community.json` with the star prompt rather than
+// adding a second state file: both are per-project records of "this was
+// already said once," both are engine state excluded from every scope
+// check, and one file means one read.
+export async function shouldNoteCodeIntelligence(root) {
+  const { codeIntelligenceNotice } = await readState(root);
+  return codeIntelligenceNotice !== 'shown';
+}
+
+/** Record that the code-intelligence advisory has been shown. */
+export async function recordCodeIntelligenceNotice(root) {
+  await writeState(root, {
+    codeIntelligenceNotice: 'shown',
+    codeIntelligenceNoticeAt: new Date().toISOString(),
+  });
+}

package/src/db/core.mjs

@@ -319,8 +319,9 @@ function segmentMatches(pattern, segment) {
 }
 
 // Does a concrete path (as segments) match a glob? Standard `**`-aware
-// walk. Used only on paths this file generated, to prove non-containment.
-function matchesGlob(pathSegments, glob) {
+// walk. Used on paths this file generated, to prove non-containment, and
+// by code-intelligence.mjs's radiusGaps against paths the index reports.
+export function matchesGlob(pathSegments, glob) {
   const g = segmentsOf(glob);
   const walk = (gi, pi) => {
     if (gi === g.length) return pi === pathSegments.length;

package/src/db/drift.mjs

@@ -30,6 +30,7 @@ import {
   onceTaskId,
   taskId,
   CORE_MODULE,
+  loadIntentDependencies,
 } from './plan.mjs';
 import { loadOverrides } from './overrides.mjs';
 
@@ -166,6 +167,20 @@ export function taskDrift(db, task, core, overrides = new Map()) {
   } else {
     expectedParents = [taskId(task.intent_id, parentLayer.id)];
   }
+
+  // planTasks's "Cross-intent edge" adds, on every per-intent layer, one
+  // parent per intent this task's intent declared `--depends-on` —
+  // core.yaml alone can't say this (it comes from intent_dependencies),
+  // so a task whose intent has such a declaration always expects it here
+  // too, or every one of its layers reads as permanently drifted.
+  if (!isOnce) {
+    for (const dep of loadIntentDependencies(db)) {
+      if (dep.intent_id === task.intent_id) {
+        expectedParents = [...expectedParents, taskId(dep.depends_on_intent_id, layer.id)];
+      }
+    }
+  }
+
   const actualParents = recordedParents(db, task);
   const sortedExpected = [...expectedParents].sort();
   const sortedActual = [...actualParents].sort();

package/src/db/friction.mjs

@@ -38,3 +38,78 @@ export function listFriction(db) {
     .prepare(`SELECT id, task_id AS taskId, note, logged_at AS loggedAt FROM friction ORDER BY id ASC`)
     .all();
 }
+
+// Correlates friction onto the files the friction-carrying tasks
+// actually reach, via each task's `context_files` (the blast-radius file
+// set plan.mjs resolves at compile). Two notes on tasks whose radii
+// overlap on one file are evidence of a single underlying gap, which is
+// the grouping call tweaker makes by hand from the notes' wording alone.
+//
+// Returns { hotspots, uncorrelated }: hotspots as
+// [{ path, frictionCount, taskIds }] sorted by frictionCount descending,
+// uncorrelated the count of notes that reached no file. Both halves ship
+// together because a hotspot list is only readable against how much of
+// the log it covers — three correlated notes out of twenty, reported as
+// three, is worse than reporting nothing.
+//
+// Rows with a NULL task_id (a reviewed-marker row, see tweaker.md) trace
+// to no task and carry no radius, so they are neither correlated nor
+// counted as uncorrelated. Rows whose task has NULL `context_files` —
+// every task on a project with no index — are the uncorrelated total.
+//
+// Wrapped the way status.mjs#countFriction is: a build graph predating
+// the `friction` table throws on the read, and `status` is the command
+// every session starts with.
+export function frictionByModule(db) {
+  try {
+    const rows = db
+      .prepare(`
+        SELECT f.id AS id, f.task_id AS taskId, t.context_files AS contextFiles
+        FROM friction f
+        JOIN tasks t ON t.id = f.task_id
+        WHERE f.task_id IS NOT NULL
+        ORDER BY f.id ASC
+      `)
+      .all();
+
+    let uncorrelated = 0;
+    // Per path, the distinct tasks whose radius reaches it — a task with
+    // two notes counts twice, so frictionCount is over notes, not tasks.
+    const byPath = new Map();
+
+    for (const { taskId, contextFiles } of rows) {
+      // Falsy covers both NULL and the `undefined` a read-only handle
+      // returns on a graph that never migrated the column in.
+      const paths = contextFiles ? parseContextFiles(contextFiles) : null;
+      if (!paths || paths.length === 0) {
+        uncorrelated += 1;
+        continue;
+      }
+      for (const path of new Set(paths)) {
+        const entry = byPath.get(path) ?? { path, frictionCount: 0, taskIds: [] };
+        entry.frictionCount += 1;
+        if (!entry.taskIds.includes(taskId)) entry.taskIds.push(taskId);
+        byPath.set(path, entry);
+      }
+    }
+
+    const hotspots = [...byPath.values()].sort(
+      (a, b) => b.frictionCount - a.frictionCount || a.path.localeCompare(b.path),
+    );
+    return { hotspots, uncorrelated };
+  } catch {
+    return { hotspots: [], uncorrelated: 0 };
+  }
+}
+
+// `context_files` is a JSON array of repo-relative paths. A row written
+// by a provider that returned something else is worth no more than an
+// absent one, so anything unparseable or non-array reads as no files.
+function parseContextFiles(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed.filter((p) => typeof p === 'string') : null;
+  } catch {
+    return null;
+  }
+}

package/src/db/gate.mjs

@@ -93,7 +93,7 @@ export async function commitGateStatus(projectRoot) {
       applicable: true,
       state: 'not-installed',
       detail: 'lefthook.yml is committed, but no pre-commit hook is installed.',
-      repair: 'pnpm install   (or: pnpm dlx lefthook install)',
+      repair: 'pnpm dlx lefthook install',
     };
   }
 

package/src/db/next.mjs

@@ -314,6 +314,38 @@ function layerShapeLines(task, coreId) {
   return lines;
 }
 
+// Files a code-intelligence index found in this task's blast radius —
+// scope says what the agent may write, this says what it should read
+// first, so it sits directly after ALLOWED SCOPE. `context_files` is a
+// JSON array of repo-relative paths written by plan.mjs at compile time
+// (code-intelligence.mjs); NULL/undefined and a parse failure both mean
+// no section, the same way layerShapeLines returns null and prints
+// nothing.
+//
+// NULL here means the row was planned without a working index —
+// CGC's own environment gone missing, a reindex that never finished, a
+// dead MCP subprocess, or a graph moved onto a machine that hasn't run
+// `init` — or a read-only handle that predates the column. `next`
+// degrades to no PRE-READ section rather than to an error.
+//
+// Kept short like HONESTY: capped at ten files, because a section long
+// enough to skim is a section that isn't read.
+function preReadLines(task) {
+  if (!task.context_files) return null;
+  let files;
+  try {
+    files = JSON.parse(task.context_files);
+  } catch {
+    return null;
+  }
+  if (!Array.isArray(files) || files.length === 0) return null;
+
+  const lines = ['PRE-READ', "  Outside ALLOWED SCOPE, this layer's code calls into:"];
+  for (const file of files.slice(0, 10)) lines.push(`  - ${file}`);
+  if (files.length > 10) lines.push(`  ...and ${files.length - 10} more`);
+  return lines;
+}
+
 // The standing honesty requirement, appended to every packet.
 //
 // Every other section is task-specific — this one is constant, which is
@@ -344,8 +376,8 @@ const HONESTY = [
 ];
 
 // Renders a packet into the STATUS / INTENT / RELEVANT RULES /
-// INHERITED DEBT / WHY NOW / BLOCKED DOWNSTREAM / ALLOWED SCOPE / LAYER
-// SHAPE / VERIFICATION / HONESTY format. The spec
+// INHERITED DEBT / WHY NOW / BLOCKED DOWNSTREAM / ALLOWED SCOPE /
+// PRE-READ / LAYER SHAPE / VERIFICATION / HONESTY format. The spec
 // splits this across two examples — the `hedgehog next` display and "The
 // task packet" (which carries the intent and its rules) — but an agent
 // receives one thing, so the packet is one thing: everything the worker
@@ -524,6 +556,11 @@ export function formatPacket(packet, statusLine, coreId = null, exists = null) {
   lines.push('ALLOWED SCOPE');
   for (const glob of scopeGlobs) lines.push(`  ${glob}`);
   lines.push('');
+  const preRead = preReadLines(task);
+  if (preRead) {
+    lines.push(...preRead);
+    lines.push('');
+  }
   if (firstArrival.length > 0) {
     lines.push(...firstArrivalLines(task, firstArrival));
     lines.push('');

package/src/db/plan.mjs

@@ -267,7 +267,11 @@ function loadPendingIntents(db) {
     .all(...PENDING_INTENT_STATUSES);
 }
 
-function loadIntentDependencies(db) {
+// Exported for drift.mjs: expected cross-intent task edges (see
+// planTasks's "Cross-intent edge" comment below) depend on which
+// intents depend on which, and that's `intent_dependencies` regardless
+// of the intents' own compiled/pending status.
+export function loadIntentDependencies(db) {
   return db.prepare('SELECT * FROM intent_dependencies').all();
 }
 
@@ -392,10 +396,42 @@ const insertTask = (db) =>
   db.prepare(`
     INSERT INTO tasks
       (id, intent_id, module, layer, objective, scope_globs, verify_command,
-       commit_message, priority, exclusive, verify_radius, status)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'planned')
+       commit_message, priority, exclusive, verify_radius, status,
+       context_symbols, context_files, context_indexed_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'planned', ?, ?, ?)
   `);
 
+// The three context columns for one task row: symbols and files as JSON,
+// an ISO timestamp of the walk, or `null, null, null` when there's no
+// provider, the walk finds nothing, or anything at all goes wrong.
+//
+// A missing provider here is not the ordinary shape of a `plan` run —
+// CGC is mandatory at `init`, so a project reaching this function
+// normally has one. `null` is what a broken or removed install falls
+// back to instead of failing the plan outright: the CGC environment
+// deleted by hand, disk full mid-reindex, the MCP subprocess dead, or
+// `.hedgehog/` copied onto a machine that never ran `init` there. The
+// three columns land NULL and the graph keeps compiling.
+//
+// `provider` exposes a synchronous `resolveTaskContext(task)` returning
+// `{ symbols, files }` or null — code-intelligence.mjs's own
+// resolveTaskContext is async (it queries a live index), so the CLI
+// layer that constructs `provider` is what awaits it and hands plan.mjs
+// a synchronous face. That keeps planTasks itself synchronous, which
+// every existing caller (several inside a `try { ... } finally {
+// db.close() }`, some returning its result straight out of a callback)
+// depends on.
+function contextColumns(task, provider) {
+  try {
+    if (!provider || typeof provider.resolveTaskContext !== 'function') return [null, null, null];
+    const context = provider.resolveTaskContext(task);
+    if (!context || typeof context !== 'object') return [null, null, null];
+    return [JSON.stringify(context.symbols), JSON.stringify(context.files), new Date().toISOString()];
+  } catch {
+    return [null, null, null];
+  }
+}
+
 const insertDependency = (db) =>
   db.prepare(`
     INSERT OR IGNORE INTO dependencies (task_id, depends_on_task_id)
@@ -446,7 +482,13 @@ const insertTaskRequirement = (db) =>
 // override written after the fact needs `hedgehog plan --recompile`
 // (drift.mjs composes the same overrides Map) the same as any other
 // core.yaml-derived field would.
-export function planTasks(db, core, overrides = new Map()) {
+//
+// `provider`, when given, exposes a synchronous `resolveTaskContext(task)`
+// (see contextColumns above) — every task row compiled in this run is
+// resolved against it and written to context_symbols/context_files/
+// context_indexed_at. Absent (the default), every row gets NULL in all
+// three, which every read path treats as "no index available".
+export function planTasks(db, core, overrides = new Map(), { provider = null } = {}) {
   const intents = loadPendingIntents(db);
   const intentDependencies = loadIntentDependencies(db);
   const ordered = orderIntents(intents, intentDependencies);
@@ -486,6 +528,10 @@ export function planTasks(db, core, overrides = new Map()) {
       const { tasks, dependencies } = compileOnceTasks(core, overrides);
       for (const t of tasks) {
         if (taskExists(db, t.id)) continue;
+        const [contextSymbols, contextFiles, contextIndexedAt] = contextColumns(
+          t,
+          provider,
+        );
         runInsert.run(
           t.id,
           t.intent_id,
@@ -498,6 +544,9 @@ export function planTasks(db, core, overrides = new Map()) {
           t.priority,
           t.exclusive,
           t.verify_radius,
+          contextSymbols,
+          contextFiles,
+          contextIndexedAt,
         );
         compiledOnceTaskIds.push(t.id);
       }
@@ -523,6 +572,10 @@ export function planTasks(db, core, overrides = new Map()) {
             `task "${t.id}" for intent "${intent.id}" collides with the id of once: true layer "${t.id.toLowerCase()}" — rename the layer or the intent`,
           );
         }
+        const [contextSymbols, contextFiles, contextIndexedAt] = contextColumns(
+          t,
+          provider,
+        );
         runInsert.run(
           t.id,
           t.intent_id,
@@ -535,6 +588,9 @@ export function planTasks(db, core, overrides = new Map()) {
           t.priority,
           t.exclusive,
           t.verify_radius,
+          contextSymbols,
+          contextFiles,
+          contextIndexedAt,
         );
         for (const requirementId of requirementIds) {
           runInsertTaskReq.run(t.id, requirementId);

package/src/db/rebuild.mjs

@@ -328,6 +328,13 @@ export async function rebuildDb(
 
   const core = await loadCore(corePath);
   const overrides = await loadOverrides(overridesDir);
+
+  // No provider: every task this call plans lands with NULL context
+  // columns, the same as an unindexed project (see plan.mjs's
+  // contextColumns). Passing one here isn't a missing argument —
+  // building it needs an async pre-resolve pass equivalent to what
+  // buildCodeIntelligenceProvider does in the CLI layer, and rebuildDb
+  // has no such pass. That's real, separate work this call doesn't do.
   planTasks(db, core, overrides);
 
   const commitSubjects = loadCommitSubjects();

package/src/db/schema.mjs

@@ -121,7 +121,12 @@ CREATE TABLE IF NOT EXISTS friction (
 // IF NOT EXISTS` above is a no-op against a DB created by an earlier
 // version, so a new column has to be ALTERed in explicitly or every
 // statement naming it fails on that DB. Each entry is `[name, ddl]`.
-const TASK_COLUMN_MIGRATIONS = [['claim_snapshot', 'claim_snapshot TEXT']];
+const TASK_COLUMN_MIGRATIONS = [
+  ['claim_snapshot', 'claim_snapshot TEXT'],
+  ['context_symbols', 'context_symbols TEXT'],
+  ['context_files', 'context_files TEXT'],
+  ['context_indexed_at', 'context_indexed_at TEXT'],
+];
 
 // Brings an already-created `tasks` table up to the current column set.
 // Idempotent and cheap (one PRAGMA), so callers that must not fail on a