@titan-design/session-graph 0.9.0 → 0.10.0

package/dist/index.js

@@ -254,6 +254,45 @@ function applyEpisodeTranscriptSchema(db) {
   addColumnIfMissing(db, EPISODE_TABLE, "end_transcript_id", "INTEGER");
 }
 
+// src/audit-schema-v7.ts
+var ORIGIN_TASK_LINK_MIGRATION_NAME = "origin task link";
+function applyOriginTaskLinkSchema(db) {
+  addColumnIfMissing(db, "session_origin", "task_ids", "TEXT");
+  addColumnIfMissing(db, "session_origin", "task_source", "TEXT");
+}
+
+// src/audit-schema-v8.ts
+var REVIEW_VERDICT_MIGRATION_NAME = "review verdicts";
+var REVIEW_TABLE = "pr_review";
+var REVIEW_DDL = `
+  CREATE TABLE IF NOT EXISTS ${REVIEW_TABLE} (
+    source_key    TEXT PRIMARY KEY,
+    surface       TEXT NOT NULL,
+    verdict       TEXT NOT NULL,
+    ts            TEXT NOT NULL,
+    session_id    TEXT,
+    transcript_id INTEGER,
+    repo          TEXT,
+    repo_hint     TEXT,
+    cwd_repo      TEXT,
+    number        INTEGER NOT NULL,
+    pr_ref        TEXT
+  );
+  CREATE INDEX IF NOT EXISTS idx_${REVIEW_TABLE}_pr_ref ON ${REVIEW_TABLE}(pr_ref);
+  CREATE INDEX IF NOT EXISTS idx_${REVIEW_TABLE}_transcript ON ${REVIEW_TABLE}(transcript_id);
+`;
+var PR_COLUMNS = [
+  ["review_rounds_gh", "INTEGER"],
+  ["review_rounds_chat", "INTEGER"],
+  ["commit_times", "TEXT"]
+];
+function applyReviewVerdictSchema(db) {
+  db.exec(REVIEW_DDL);
+  for (const [column, type] of PR_COLUMNS) addColumnIfMissing(db, "pr", column, type);
+  db.exec("UPDATE pr SET review_rounds_gh = review_rounds");
+  db.exec("UPDATE pr SET outcome_checked_at = NULL");
+}
+
 // src/normalized-schema.ts
 import { conversationRef } from "@titan-design/agent-protocol";
 var NORMALIZED_DDL = `
@@ -451,6 +490,7 @@ var DERIVED_TABLES = [
   "pr",
   "pr_merge_observation",
   "pr_create_observation",
+  REVIEW_TABLE,
   "branch",
   "file",
   "task",
@@ -465,7 +505,9 @@ var MIGRATIONS = [
   } },
   { version: 4, name: AUDIT_MIGRATION_NAME, up: applyAuditSchema },
   { version: 5, name: ORIGIN_MIGRATION_NAME, up: applyOriginSchema },
-  { version: 6, name: EPISODE_TRANSCRIPT_MIGRATION_NAME, up: applyEpisodeTranscriptSchema }
+  { version: 6, name: EPISODE_TRANSCRIPT_MIGRATION_NAME, up: applyEpisodeTranscriptSchema },
+  { version: 7, name: ORIGIN_TASK_LINK_MIGRATION_NAME, up: applyOriginTaskLinkSchema },
+  { version: 8, name: REVIEW_VERDICT_MIGRATION_NAME, up: applyReviewVerdictSchema }
 ];
 
 // src/graph.ts
@@ -626,7 +668,7 @@ function advanceFacet(db, transcriptId, fromByteOffset, indexedTo, version = EXT
 }
 
 // src/apply.ts
-import { sessionRef } from "@titan-design/session-read";
+import { RELATIONS, sessionRef } from "@titan-design/session-read";
 function applyDelta(graph, transcriptId, delta, source = {}) {
   graph.db.transaction(() => {
     applyFacts(graph.db, transcriptId, delta);
@@ -635,6 +677,7 @@ function applyDelta(graph, transcriptId, delta, source = {}) {
     applyAssets(graph.db, delta);
     applyPhases(graph.db, transcriptId, delta);
     applyLinkedRows(graph, transcriptId, delta);
+    applyReviewVerdicts(graph.db, transcriptId, delta);
     applyAudit(graph.db, transcriptId, delta);
   })();
 }
@@ -702,6 +745,43 @@ function pick(row, sql) {
   const names = new Set([...sql.matchAll(/@(\w+)/g)].map((m) => m[1]));
   return Object.fromEntries([...names].map((name) => [name, row[name] ?? null]));
 }
+var UPSERT_CHAT_VERDICT = `
+  INSERT INTO ${REVIEW_TABLE} (source_key, surface, verdict, ts, session_id, transcript_id, repo, repo_hint, cwd_repo, number)
+  VALUES (@sourceKey, 'chat', @verdict, @ts, @sessionId, @transcriptId, @repo, @repoHint, @cwdRepo, @number)
+  ON CONFLICT (source_key) DO UPDATE SET verdict = excluded.verdict, ts = excluded.ts, session_id = excluded.session_id,
+    transcript_id = excluded.transcript_id, repo = excluded.repo, repo_hint = excluded.repo_hint,
+    cwd_repo = excluded.cwd_repo, number = excluded.number`;
+function applyReviewVerdicts(db, transcriptId, delta) {
+  const upsert = db.prepare(UPSERT_CHAT_VERDICT);
+  const keys = chatVerdictKeys(delta.reviewVerdicts);
+  delta.reviewVerdicts.forEach((v, i) => {
+    upsert.run({
+      sourceKey: keys[i],
+      verdict: v.verdict,
+      ts: v.ts,
+      sessionId: v.sessionId,
+      transcriptId,
+      repo: v.repo,
+      repoHint: v.repoHint,
+      cwdRepo: v.cwdRepo,
+      number: v.number
+    });
+  });
+}
+var hasOrdinal = (v) => Number.isInteger(v.ordinal) && v.ordinal >= 0;
+function chatVerdictKeys(verdicts) {
+  const used = /* @__PURE__ */ new Map();
+  const usedBy = (id) => used.get(id) ?? used.set(id, /* @__PURE__ */ new Set()).get(id);
+  for (const v of verdicts) if (hasOrdinal(v)) usedBy(v.toolUseId).add(v.ordinal);
+  return verdicts.map((v) => {
+    if (hasOrdinal(v)) return `chat:${v.toolUseId}:${v.ordinal}`;
+    const taken = usedBy(v.toolUseId);
+    let n = 0;
+    while (taken.has(n)) n += 1;
+    taken.add(n);
+    return `chat:${v.toolUseId}:${n}`;
+  });
+}
 function applyPhases(db, transcriptId, delta) {
   const current = db.prepare("SELECT phase_id, to_mode FROM permission_phase WHERE session_id = ? AND trigger = ? AND t_invalid IS NULL ORDER BY phase_id DESC LIMIT 1");
   const close = db.prepare("UPDATE permission_phase SET t_invalid = ? WHERE phase_id = ?");
@@ -734,11 +814,16 @@ function applyLinkedRows(graph, transcriptId, delta) {
   for (const s of delta.subagents) upsertSubagent.run(s.agentRef, s.sessionId, s.agentType, s.label, s.ts || null, factId(s.byteOffset));
   const linkTranscript = db.prepare("INSERT INTO subagent (agent_ref, child_session_id) VALUES (?, ?) ON CONFLICT (agent_ref) DO UPDATE SET child_session_id = excluded.child_session_id");
   for (const l of delta.subagentTranscripts) linkTranscript.run(l.agentRef, l.childSessionId);
-  for (const e of delta.edges) graph.edges.assert({ sourceRef: e.sourceRef, relation: e.relation, targetRef: e.targetRef, tValid: e.ts, factId: factId(e.byteOffset) });
+  for (const e of delta.edges) assertTranscriptEdge(graph, { sourceRef: e.sourceRef, relation: e.relation, targetRef: e.targetRef, tValid: e.ts, factId: factId(e.byteOffset) });
   for (const span of delta.spans) {
     graph.spans.index({ ownerRef: sessionRef(span.sessionId), field: span.field, sourceId: transcriptId, byteOffset: span.byteOffset, byteLength: span.byteLength }, span.text);
   }
 }
+function assertTranscriptEdge(graph, edge) {
+  const existing = edge.relation === RELATIONS.RAN ? graph.edges.current(edge.sourceRef, edge.relation, edge.targetRef) : void 0;
+  if (existing?.attrs?.via === "origin") graph.edges.supersede(edge);
+  else graph.edges.assert(edge);
+}
 function factIdFor(db, transcriptId, byteOffset) {
   const row = db.prepare("SELECT fact_id FROM fact WHERE transcript_id = ? AND byte_offset = ?").get(transcriptId, byteOffset);
   return row?.fact_id ?? null;
@@ -755,7 +840,7 @@ function purgeTranscript(graph, transcriptId) {
       graph.db.prepare(`DELETE FROM "${table}" WHERE session_id IN (SELECT session_id FROM session WHERE transcript_id = ?)`).run(transcriptId);
     }
     graph.db.prepare(`DELETE FROM "${KIT.edge}" WHERE fact_id IN (SELECT fact_id FROM fact WHERE transcript_id = ?)`).run(transcriptId);
-    for (const table of [...AUDIT_TABLES, FACET_TABLE]) {
+    for (const table of [...AUDIT_TABLES, FACET_TABLE, REVIEW_TABLE]) {
       graph.db.prepare(`DELETE FROM "${table}" WHERE transcript_id = ?`).run(transcriptId);
     }
     graph.db.prepare("DELETE FROM fact WHERE transcript_id = ?").run(transcriptId);
@@ -921,18 +1006,126 @@ import { promises as fs } from "fs";
 import { contentHash, resumePoint } from "@titan-design/locator";
 import { TranscriptParseError as TranscriptParseError2, extractTranscript as extractTranscript2 } from "@titan-design/session-read";
 
+// src/review-rounds.ts
+import { RELATIONS as RELATIONS2 } from "@titan-design/session-read";
+var isReviewerProfile = (profile) => profile === "reviewer" || profile.endsWith("-reviewer");
+function countRounds(changesRequestedAt, commitTimes) {
+  const commits = parseCommitTimes(commitTimes);
+  return commits ? answeredHeads(changesRequestedAt, commits).heads.size : null;
+}
+function parseCommitTimes(commitTimes) {
+  const commits = commitTimes.map(Date.parse);
+  return commits.some(Number.isNaN) ? null : commits;
+}
+function answeredHeads(reviewTimes, commits) {
+  const heads = /* @__PURE__ */ new Set();
+  let ignored = 0;
+  for (const ts of reviewTimes) {
+    const at = Date.parse(ts);
+    if (Number.isNaN(at)) {
+      ignored += 1;
+      continue;
+    }
+    const head = commits.filter((c) => c <= at).length;
+    if (head < commits.length) heads.add(head);
+  }
+  return { heads, ignored };
+}
+function projectReviewRounds(graph, options = {}) {
+  const isReviewer = options.isReviewerProfile ?? isReviewerProfile;
+  return graph.db.transaction(() => {
+    const resolved = resolveChatVerdicts(graph.db);
+    const invalidTimes = writeRounds(graph.db, isReviewer);
+    const { n } = graph.db.prepare(`SELECT count(*) AS n FROM ${REVIEW_TABLE} WHERE surface = 'chat' AND pr_ref IS NULL`).get();
+    return { resolved, unresolved: n, invalidTimes };
+  })();
+}
+function resolveChatVerdicts(db) {
+  const rows = db.prepare(`SELECT source_key, session_id, repo, repo_hint, cwd_repo, number FROM ${REVIEW_TABLE} WHERE surface = 'chat' AND pr_ref IS NULL`).all();
+  const update = db.prepare(`UPDATE ${REVIEW_TABLE} SET pr_ref = ? WHERE source_key = ?`);
+  let resolved = 0;
+  for (const row of rows) {
+    const prRef = resolvePrRef(db, row);
+    if (prRef) resolved += update.run(prRef, row.source_key).changes;
+  }
+  return resolved;
+}
+function resolvePrRef(db, row) {
+  const candidates = db.prepare("SELECT pr_ref, repo FROM pr WHERE number = ? AND repo IS NOT NULL").all(row.number);
+  if (row.repo) return candidates.find((c) => c.repo === row.repo)?.pr_ref ?? null;
+  const hinted = candidates.filter((c) => sameRepoName(c.repo, row.repo_hint));
+  if (hinted.length === 1) return hinted[0].pr_ref;
+  const pool = hinted.length > 0 ? hinted : candidates;
+  const linked = familyLinks(db, row.session_id);
+  const bySibling = pool.filter((c) => linked.has(c.pr_ref));
+  if (bySibling.length === 1) return bySibling[0].pr_ref;
+  const byCwd = (bySibling.length > 0 ? bySibling : pool).filter((c) => sameRepoName(c.repo, row.cwd_repo));
+  return byCwd.length === 1 ? byCwd[0].pr_ref : null;
+}
+function sameRepoName(repo, name) {
+  return name !== null && repo.split("/").pop().toLowerCase() === name.toLowerCase();
+}
+var FAMILY_LINKS = `
+  WITH parent(id) AS (
+    SELECT parent_session_id FROM session_origin WHERE session_id = @sessionId AND parent_session_id IS NOT NULL
+    UNION SELECT session_id FROM subagent WHERE child_session_id = @sessionId AND session_id IS NOT NULL
+  ), family(id) AS (
+    SELECT @sessionId UNION SELECT id FROM parent
+    UNION SELECT session_id FROM session_origin WHERE parent_session_id IN (SELECT id FROM parent)
+    UNION SELECT child_session_id FROM subagent WHERE session_id IN (SELECT id FROM parent) AND child_session_id IS NOT NULL
+    UNION SELECT substr(target_ref, 9) FROM "${KIT.edge}" WHERE relation = '${RELATIONS2.SPAWNED}' AND t_expired IS NULL
+      AND target_ref LIKE 'session:%' AND source_ref IN (SELECT 'session:' || id FROM parent)
+  )
+  SELECT DISTINCT target_ref FROM "${KIT.edge}" WHERE relation = '${RELATIONS2.LINKED}' AND t_expired IS NULL
+    AND source_ref IN (SELECT 'session:' || id FROM family)`;
+function familyLinks(db, sessionId) {
+  if (!sessionId) return /* @__PURE__ */ new Set();
+  const rows = db.prepare(FAMILY_LINKS).all({ sessionId });
+  return new Set(rows.map((r) => r.target_ref));
+}
+var CHANGES_REQUESTED = `
+  SELECT r.pr_ref, r.surface, r.ts, o.profile FROM ${REVIEW_TABLE} r LEFT JOIN session_origin o ON o.session_id = r.session_id
+  WHERE r.verdict = 'changes_requested' AND r.pr_ref IS NOT NULL`;
+function writeRounds(db, isReviewer) {
+  const byPr = /* @__PURE__ */ new Map();
+  for (const review of db.prepare(CHANGES_REQUESTED).all()) {
+    if (review.surface === "chat" && !(review.profile && isReviewer(review.profile))) continue;
+    byPr.set(review.pr_ref, [...byPr.get(review.pr_ref) ?? [], review]);
+  }
+  const update = db.prepare("UPDATE pr SET review_rounds_chat = ?, review_rounds = ? WHERE pr_ref = ?");
+  let invalidTimes = 0;
+  for (const pr of db.prepare("SELECT pr_ref, commit_times, review_rounds_gh FROM pr").all()) {
+    const { chat, total, invalid } = roundsFor(pr, byPr.get(pr.pr_ref) ?? []);
+    update.run(chat, total, pr.pr_ref);
+    invalidTimes += invalid;
+  }
+  return invalidTimes;
+}
+function roundsFor(pr, reviews) {
+  const commits = pr.commit_times === null ? null : parseCommitTimes(JSON.parse(pr.commit_times));
+  if (!commits) return { chat: null, total: pr.review_rounds_gh, invalid: pr.commit_times === null ? 0 : 1 };
+  const timesOn = (surface) => reviews.filter((r) => r.surface === surface).map((r) => r.ts);
+  const forge = answeredHeads(timesOn("github"), commits);
+  const chat = answeredHeads(timesOn("chat"), commits);
+  const chatOnly = [...chat.heads].filter((head) => !forge.heads.has(head)).length;
+  return { chat: chat.heads.size, total: (pr.review_rounds_gh ?? 0) + chatOnly, invalid: forge.ignored + chat.ignored };
+}
+
 // src/outcomes.ts
 var NO_PR_OUTCOMES = Object.freeze({ requested: 0, applied: 0, failed: false });
 var PRS_NEEDING_OUTCOME = `
   SELECT pr_ref, repo, number FROM pr
-  WHERE repo IS NOT NULL AND number IS NOT NULL AND (outcome_checked_at IS NULL OR state IS NOT 'merged')
-  ORDER BY pr_ref`;
+  WHERE repo IS NOT NULL AND number IS NOT NULL
+    AND (outcome_checked_at IS NULL OR state IS NOT 'merged' OR commit_times IS NULL)
+  ORDER BY CASE WHEN outcome_checked_at IS NULL THEN 0 WHEN state IS NOT 'merged' THEN 1 ELSE 2 END, pr_ref`;
 var APPLY_OUTCOME = `
   UPDATE pr SET
     state = CASE WHEN state = 'merged' THEN state ELSE COALESCE(lower(@state), state) END,
     merged_at = COALESCE(@mergedAt, merged_at),
     closed_at = COALESCE(@closedAt, closed_at),
     review_rounds = COALESCE(@reviewRounds, review_rounds),
+    review_rounds_gh = COALESCE(@reviewRounds, review_rounds_gh),
+    commit_times = COALESCE(@commitTimes, commit_times),
     outcome_checked_at = @checkedAt
   WHERE pr_ref = @prRef`;
 function prsNeedingOutcome(graph) {
@@ -952,6 +1145,7 @@ async function enrichPrs(graph, resolver) {
 }
 function write(graph, resolved, checkedAt) {
   const apply = graph.db.prepare(APPLY_OUTCOME);
+  const stored = graph.db.prepare("SELECT commit_times FROM pr WHERE pr_ref = ?");
   return graph.db.transaction(() => {
     let applied = 0;
     for (const [prRef, fields] of resolved) {
@@ -962,27 +1156,79 @@ function write(graph, resolved, checkedAt) {
         state: fields.state ?? null,
         mergedAt: fields.mergedAt ?? null,
         closedAt: fields.closedAt ?? null,
-        reviewRounds: fields.reviewRounds ?? null
+        reviewRounds: forgeRounds(fields, () => storedCommitTimes(stored.get(prRef))),
+        commitTimes: fields.commitTimes ? JSON.stringify(fields.commitTimes) : null
       }).changes;
+      if (fields.reviews) replaceForgeReviews(graph, prRef, fields.reviews);
     }
     return applied;
   })();
 }
+var isChangesRequested = (review) => review.state.toUpperCase() === "CHANGES_REQUESTED";
+function forgeRounds(fields, storedTimes) {
+  if (!fields.reviews) return fields.reviewRounds ?? null;
+  const commitTimes = fields.commitTimes ?? storedTimes();
+  const counted = commitTimes ? countRounds(fields.reviews.filter(isChangesRequested).map((r) => r.submittedAt), commitTimes) : null;
+  return counted ?? fields.reviewRounds ?? null;
+}
+function storedCommitTimes(row) {
+  const times = row?.commit_times;
+  return times ? JSON.parse(times) : null;
+}
+var FORGE_VERDICTS = { APPROVED: "approve", CHANGES_REQUESTED: "changes_requested" };
+var INSERT_FORGE_REVIEW = `
+  INSERT INTO ${REVIEW_TABLE} (source_key, surface, verdict, ts, repo, number, pr_ref)
+  SELECT 'gh:' || pr_ref || ':' || @ts, 'github', @verdict, @ts, repo, number, pr_ref FROM pr WHERE pr_ref = @prRef
+  ON CONFLICT (source_key) DO UPDATE SET verdict = CASE WHEN verdict = 'changes_requested' THEN verdict ELSE excluded.verdict END`;
+function replaceForgeReviews(graph, prRef, reviews) {
+  graph.db.prepare(`DELETE FROM ${REVIEW_TABLE} WHERE surface = 'github' AND pr_ref = ?`).run(prRef);
+  const insert = graph.db.prepare(INSERT_FORGE_REVIEW);
+  for (const review of reviews) {
+    const verdict = FORGE_VERDICTS[review.state.toUpperCase()];
+    if (verdict) insert.run({ prRef, verdict, ts: review.submittedAt });
+  }
+}
 
 // src/origin.ts
-import { RELATIONS, sessionRef as sessionRef3 } from "@titan-design/session-read";
+import { RELATIONS as RELATIONS3, sessionRef as sessionRef3, taskRef } from "@titan-design/session-read";
+var NO_TASK_LINK = "none";
 var NO_ORIGINS = Object.freeze({ requested: 0, applied: 0, events: 0, failed: false });
 var SESSIONS_NEEDING_ORIGIN = `
   SELECT s.session_id FROM session s LEFT JOIN session_origin o ON o.session_id = s.session_id
-  WHERE o.session_id IS NULL OR o.resolved_at < s.ended_at
+  WHERE o.session_id IS NULL OR o.resolved_at < s.ended_at OR o.task_source IS NULL
   ORDER BY s.session_id`;
+var ORIGIN_COLUMNS = [
+  "origin_system",
+  "agent_id",
+  "agent_name",
+  "parent_name",
+  "parent_session_id",
+  "profile",
+  "model_alias",
+  "surface",
+  "isolation",
+  "depth",
+  "origin_kind",
+  "config_dir",
+  "spawn_cwd",
+  "spawned_at",
+  "brief_chars",
+  "brief_excerpt",
+  "brief_path",
+  "launch_args",
+  "resolved_at"
+];
+var TASK_LINK_UPDATE = `task_source = COALESCE(excluded.task_source, task_source),
+    task_ids = CASE WHEN excluded.task_source IS NOT NULL THEN excluded.task_ids ELSE task_ids END`;
 var UPSERT_ORIGIN = `
-  INSERT OR REPLACE INTO session_origin (session_id, origin_system, agent_id, agent_name, parent_name, parent_session_id,
+  INSERT INTO session_origin (session_id, origin_system, agent_id, agent_name, parent_name, parent_session_id,
     profile, model_alias, surface, isolation, depth, origin_kind, config_dir, spawn_cwd, spawned_at,
-    brief_chars, brief_excerpt, brief_path, launch_args, resolved_at)
+    brief_chars, brief_excerpt, brief_path, launch_args, task_ids, task_source, resolved_at)
   VALUES (@sessionId, @originSystem, @agentId, @agentName, @parentName, @parentSessionId,
     @profile, @modelAlias, @surface, @isolation, @depth, @originKind, @configDir, @spawnCwd, @spawnedAt,
-    @briefChars, @briefExcerpt, @briefPath, @launchArgs, @resolvedAt)`;
+    @briefChars, @briefExcerpt, @briefPath, @launchArgs, @taskIds, @taskSource, @resolvedAt)
+  ON CONFLICT (session_id) DO UPDATE SET ${ORIGIN_COLUMNS.map((c) => `${c} = excluded.${c}`).join(", ")},
+    ${TASK_LINK_UPDATE}`;
 var UPSERT_EVENT = `
   INSERT INTO session_external_event (session_id, ts, origin_system, kind, detail)
   VALUES (@sessionId, @ts, COALESCE(@originSystem, (SELECT origin_system FROM session_origin WHERE session_id = @sessionId), 'unknown'), @kind, @detail)
@@ -999,14 +1245,16 @@ function sessionsNeedingOrigin(graph) {
 async function resolveOrigins(graph, resolver) {
   if (!resolver) return NO_ORIGINS;
   const sessionIds = sessionsNeedingOrigin(graph);
+  let resolved = [];
   try {
     const resolution = await resolver(sessionIds);
     const written = writeResolution(graph, resolution, (/* @__PURE__ */ new Date()).toISOString());
+    resolved = Object.keys(resolution.origins);
     return { requested: sessionIds.length, ...written, failed: false };
   } catch (err) {
     return { requested: sessionIds.length, applied: 0, events: 0, failed: true, error: err instanceof Error ? err.message : String(err) };
   } finally {
-    projectOrigins(graph);
+    projectOrigins(graph, resolved);
   }
 }
 function writeResolution(graph, resolution, resolvedAt) {
@@ -1045,21 +1293,54 @@ function originRow(sessionId, o, resolvedAt) {
     briefChars: o.briefChars ?? null,
     briefExcerpt: o.briefExcerpt ?? null,
     briefPath: o.briefPath ?? null,
-    launchArgs: o.launchArgs ?? null
+    launchArgs: o.launchArgs ?? null,
+    ...taskLinkColumns(o)
   };
 }
-function projectOrigins(graph) {
+function taskLinkColumns(o) {
+  if (o.taskIds === void 0) return { taskIds: null, taskSource: null };
+  if (!o.taskIds?.length) return { taskIds: null, taskSource: NO_TASK_LINK };
+  return { taskIds: JSON.stringify(o.taskIds), taskSource: o.taskSource ?? NO_TASK_LINK };
+}
+function projectOrigins(graph, resolved) {
   const spawned = graph.db.prepare("SELECT session_id, parent_session_id, spawned_at, resolved_at FROM session_origin WHERE parent_session_id IS NOT NULL").all();
   graph.db.transaction(() => {
     graph.db.prepare(PROJECT_SUBAGENTS).run();
     for (const o of spawned) {
-      graph.edges.assert({ sourceRef: sessionRef3(o.parent_session_id), relation: RELATIONS.SPAWNED, targetRef: sessionRef3(o.session_id), tValid: o.spawned_at ?? o.resolved_at });
+      graph.edges.assert({ sourceRef: sessionRef3(o.parent_session_id), relation: RELATIONS3.SPAWNED, targetRef: sessionRef3(o.session_id), tValid: o.spawned_at ?? o.resolved_at });
     }
+    projectTaskLinks(graph, resolved);
   })();
 }
+var LINK_CONFIDENCE = { name: 1, "name-over-brief": 1, "brief-anchor": 0.9, "brief-paragraph": 0.6 };
+var LOWEST_CONFIDENCE = 0.6;
+function projectTaskLinks(graph, resolved) {
+  const insertTask = graph.db.prepare("INSERT OR IGNORE INTO task (task_ref, task_id) VALUES (?, ?)");
+  const select = graph.db.prepare("SELECT session_id, task_ids, task_source, spawned_at, resolved_at FROM session_origin WHERE session_id = ?");
+  for (const sessionId of resolved) {
+    const o = select.get(sessionId);
+    if (!o) continue;
+    const taskIds = o.task_ids ? JSON.parse(o.task_ids) : [];
+    const source = sessionRef3(o.session_id);
+    const attrs = { via: "origin", source: o.task_source };
+    const confidence = LINK_CONFIDENCE[o.task_source ?? ""] ?? LOWEST_CONFIDENCE;
+    for (const taskId of taskIds) {
+      insertTask.run(taskRef(taskId), taskId);
+      graph.edges.assert({ sourceRef: source, relation: RELATIONS3.RAN, targetRef: taskRef(taskId), tValid: o.spawned_at ?? o.resolved_at, attrs, confidence });
+    }
+    expireStaleTaskLinks(graph, source, new Set(taskIds.map(taskRef)));
+  }
+}
+function expireStaleTaskLinks(graph, source, linked) {
+  for (const edge of graph.edges.from(source)) {
+    if (edge.relation === RELATIONS3.RAN && edge.attrs?.via === "origin" && !linked.has(edge.targetRef)) {
+      graph.edges.expire(source, RELATIONS3.RAN, edge.targetRef);
+    }
+  }
+}
 
 // src/tasks.ts
-import { taskRef } from "@titan-design/session-read";
+import { taskRef as taskRef2 } from "@titan-design/session-read";
 var NO_ENRICHMENT = Object.freeze({ requested: 0, applied: 0, failed: false });
 var UPSERT_TASK = `
   INSERT INTO task (task_ref, task_id, initiative, title, status, estimate) VALUES (@taskRef, @taskId, @initiative, @title, @status, @estimate)
@@ -1088,7 +1369,7 @@ function write2(graph, resolved) {
     for (const [taskId, fields] of resolved) {
       if (!fields) continue;
       applied += upsert.run({
-        taskRef: taskRef(taskId),
+        taskRef: taskRef2(taskId),
         taskId,
         initiative: fields.initiative ?? null,
         title: fields.title ?? null,
@@ -1143,7 +1424,7 @@ async function indexTranscript(graph, transcript, options = {}) {
   }
 }
 async function refreshCorpus(graph, transcripts, options = {}) {
-  const { resolveTasks, resolveOrigins: originResolver, resolvePrs, full, facetLimit, ...perTranscript } = options;
+  const { resolveTasks, resolveOrigins: originResolver, resolvePrs, isReviewerProfile: isReviewerProfile2, full, facetLimit, ...perTranscript } = options;
   const counts = { indexed: 0, unchanged: 0, rewound: 0, missing: 0, quarantined: 0 };
   const touched = [];
   let facts = 0;
@@ -1159,10 +1440,11 @@ async function refreshCorpus(graph, transcripts, options = {}) {
   const origins = await resolveOrigins(graph, originResolver);
   const reconciled = reconcile(graph);
   const prs = await enrichPrs(graph, resolvePrs);
+  const reviews = projectReviewRounds(graph, { isReviewerProfile: isReviewerProfile2 });
   const tasks = await enrichTasks(graph, resolveTasks, allTaskIds(graph));
   const markedMissing = await markMissing(graph, transcripts);
   const facetSummary = { facetsBackfilled: facets.backfilled, facetBacklog: facets.backlog };
-  return { transcripts: transcripts.length, ...counts, facts, turnsRolledUp, reconciled, tasks, origins, prs, markedMissing, ...facetSummary };
+  return { transcripts: transcripts.length, ...counts, facts, turnsRolledUp, reconciled, tasks, origins, prs, reviews, markedMissing, ...facetSummary };
 }
 async function markMissing(graph, discovered) {
   const present = new Set(discovered.map((t) => t.displayPath));
@@ -1465,22 +1747,30 @@ export {
   NO_ENRICHMENT,
   NO_ORIGINS,
   NO_PR_OUTCOMES,
+  NO_TASK_LINK,
   ORIGIN_DDL,
   ORIGIN_MIGRATION_NAME,
   ORIGIN_TABLES,
+  ORIGIN_TASK_LINK_MIGRATION_NAME,
   ORIGIN_VIEWS,
+  REVIEW_DDL,
+  REVIEW_TABLE,
+  REVIEW_VERDICT_MIGRATION_NAME,
   allSessionIds,
   allTaskIds,
   applyAudit,
   applyDelta,
   backfillFacets,
+  countRounds,
   enrichPrs,
   enrichTasks,
   indexCodexSource,
   indexTranscript,
+  isReviewerProfile,
   normalizedSessions,
   normalizedUsage,
   openSessionGraph,
+  projectReviewRounds,
   prsNeedingOutcome,
   purgeTranscript,
   readIndexedText,