opencode-swarm 7.187.0 → 7.187.2

package/dist/cli/{index-6ersmqjd.js → index-j5db3v56.js}

@@ -1,60 +1,139 @@
 // @bun
+import {
+  sanitizeContextText
+} from "./index-m9zzj4ee.js";
 import {
   validateSwarmPath
 } from "./index-bejxkee0.js";
 import {
   observeReceiptTransition
-} from "./index-c8ffgcvz.js";
-import {
-  resolveHiveEventsPath
-} from "./index-ae75rja9.js";
-import {
-  resolveKnowledgeStoreDir
-} from "./index-rm676s0p.js";
-import {
-  atomicWriteFile
-} from "./index-t3hcd6zz.js";
+} from "./index-v9y0230d.js";
 import {
   assertProjectRoot
 } from "./index-t7hmqgjy.js";
 import {
   emit
-} from "./index-jtncfvhe.js";
+} from "./index-dx6bhbd6.js";
 import {
-  canonicalRootKey
-} from "./index-fzpt2djt.js";
-import {
-  require_proper_lockfile
-} from "./index-7g4c7s5r.js";
+  resolveActivePhaseId
+} from "./index-gx2vp8gx.js";
 import {
   loadPluginConfigWithMeta
-} from "./index-469xmpd6.js";
+} from "./index-w0bvez8c.js";
 import {
   KnowledgeConfigSchema,
   init_schema
-} from "./index-qzgfheb4.js";
-import {
-  init_logger,
-  warn
-} from "./index-zgwm4ryv.js";
-import {
-  __require,
-  __toESM
-} from "./index-a76rekgs.js";
+} from "./index-b5tthmy2.js";
 
-// src/hooks/knowledge-events.ts
-var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
-import { randomUUID as randomUUID3 } from "crypto";
-import { existsSync as existsSync3 } from "fs";
-import { appendFile, mkdir as mkdir2, readFile as readFile2, stat as stat2 } from "fs/promises";
-import * as path2 from "path";
-init_logger();
+// src/utils/context-decisions.ts
+function extractContextDecisions(content) {
+  const decisions = [];
+  const MAX_CONTENT_CHARS = 1e6;
+  const bounded = content.length > MAX_CONTENT_CHARS ? content.slice(0, MAX_CONTENT_CHARS) : content;
+  const lines = bounded.split(`
+`);
+  let inDecisionsSection = false;
+  let currentPhase = null;
+  let lineNumber = 0;
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i];
+    lineNumber = i + 1;
+    const phaseMatch = line.match(/^## Phase (\d+)/);
+    if (phaseMatch) {
+      currentPhase = parseInt(phaseMatch[1], 10);
+    }
+    if (line.trim() === "## Decisions") {
+      inDecisionsSection = true;
+      continue;
+    }
+    if (inDecisionsSection && line.startsWith("## ")) {
+      break;
+    }
+    if (inDecisionsSection && line.trim().startsWith("- ")) {
+      const text = line.trim().substring(2);
+      const confirmed = text.includes("\u2705") || text.includes("[confirmed]");
+      const timestampMatch = text.match(/\[(\d{4}-\d{2}-\d{2}T[\d:.]+Z?)\]/);
+      const timestamp = timestampMatch ? timestampMatch[1] : null;
+      const decisionPhaseMatch = text.match(/Phase (\d+)/);
+      const decisionPhase = decisionPhaseMatch ? parseInt(decisionPhaseMatch[1], 10) : currentPhase;
+      decisions.push({
+        raw: line,
+        text: text.replace(/\s*\[.*?\]\s*/g, "").trim(),
+        phase: decisionPhase,
+        confirmed,
+        timestamp,
+        line: lineNumber
+      });
+    }
+  }
+  return decisions;
+}
 
 // src/hooks/knowledge-receipt-ledger.ts
 import { createHash as createHash2, randomUUID as randomUUID2 } from "crypto";
 import { existsSync as existsSync2 } from "fs";
 init_schema();
 
+// src/hooks/extractors.ts
+function extractCurrentPhase(planContent) {
+  if (!planContent) {
+    return null;
+  }
+  planContent = sanitizeContextText(planContent);
+  const lines = planContent.split(`
+`);
+  for (let i = 0;i < Math.min(20, lines.length); i++) {
+    const line = lines[i].trim();
+    const progressMatch = line.match(/^## Phase (\d+):?\s*(.*?)\s*\[IN PROGRESS\]/i);
+    if (progressMatch) {
+      const phaseNum = progressMatch[1];
+      const description = progressMatch[2]?.trim() || "";
+      return `Phase ${phaseNum}: ${description} [IN PROGRESS]`;
+    }
+  }
+  for (let i = 0;i < Math.min(20, lines.length); i++) {
+    const line = lines[i].trim();
+    const blockedMatch = line.match(/^## Phase (\d+):?\s*(.*?)\s*\[BLOCKED\]/i);
+    if (blockedMatch) {
+      const phaseNum = blockedMatch[1];
+      const description = blockedMatch[2]?.trim() || "";
+      return `Phase ${phaseNum}: ${description} [BLOCKED]`;
+    }
+  }
+  for (let i = 0;i < Math.min(3, lines.length); i++) {
+    const line = lines[i].trim();
+    const phaseMatch = line.match(/Phase:\s*(\d+)/i);
+    if (phaseMatch) {
+      const phaseNum = phaseMatch[1];
+      return `Phase ${phaseNum} [PENDING]`;
+    }
+  }
+  return null;
+}
+function extractCurrentPhaseFromPlan(plan) {
+  const phaseId = resolveActivePhaseId(plan);
+  const phase = plan.phases.find((p) => p.id === phaseId);
+  if (!phase)
+    return null;
+  const statusMap = {
+    pending: "PENDING",
+    in_progress: "IN PROGRESS",
+    complete: "COMPLETE",
+    blocked: "BLOCKED"
+  };
+  const statusText = statusMap[phase.status] || "PENDING";
+  return sanitizeContextText(`Phase ${phase.id}: ${phase.name} [${statusText}]`);
+}
+function extractPhaseIdFromLabel(label) {
+  if (!label)
+    return;
+  const m = /^Phase\s+(\d+)/i.exec(label);
+  if (!m)
+    return;
+  const id = Number(m[1]);
+  return Number.isSafeInteger(id) && id >= 1 ? id : undefined;
+}
+
 // src/hooks/knowledge-receipt-ledger-storage.ts
 import { createHash, randomUUID } from "crypto";
 import * as fs from "fs";
@@ -504,6 +583,7 @@ var TRANSITIONS = new Set([
   "gate_release_committed",
   "phase_close_intent",
   "phase_closed",
+  "phase_id_backfilled",
   "repair_uncertainty_installed",
   "repair_uncertainty_cleared",
   "legacy_imported",
@@ -621,6 +701,29 @@ var keyOf = (traceId, entryId) => `${traceId.length}:${traceId}${entryId}`;
 var emptyKeyOf = (traceId, sessionId) => `${traceId.length}:${traceId}${sessionId}`;
 var phaseLifecycleKey = (phase, sessionId, taskId) => `${sessionId.length}:${sessionId}${phase.length}:${phase}${taskId === undefined ? "u:" : `s:${taskId.length}:${taskId}`}`;
 var repairUncertaintyKey = (phase, sessionId) => `${sessionId.length}:${sessionId}${phase.length}:${phase}`;
+function membershipMatchesPhaseIdentity(membership, phase, phaseId) {
+  if (phaseId === undefined)
+    return membership.phase === phase;
+  if (membership.phase_id === phaseId)
+    return true;
+  if (membership.phase_id === undefined && extractPhaseIdFromLabel(membership.phase) === phaseId)
+    return true;
+  return membership.phase === phase;
+}
+function findClosedLifecycleForPhase(state, scope) {
+  const labelKey = phaseLifecycleKey(scope.phase ?? "", scope.session_id, scope.task_id);
+  const byLabel = state.phaseLifecycle.get(labelKey);
+  if (byLabel !== undefined && (scope.phase_id === undefined || byLabel.phase_id === undefined || byLabel.phase_id === scope.phase_id))
+    return byLabel;
+  if (scope.phase_id === undefined)
+    return;
+  for (const lifecycle of state.phaseLifecycle.values()) {
+    if (lifecycle.session_id === scope.session_id && lifecycle.task_id === scope.task_id && (lifecycle.phase_id === scope.phase_id || lifecycle.phase_id === undefined && extractPhaseIdFromLabel(lifecycle.phase) === scope.phase_id)) {
+      return lifecycle;
+    }
+  }
+  return;
+}
 function nowIso() {
   return new Date(_internals3.nowMs()).toISOString();
 }
@@ -801,6 +904,7 @@ function parseMembership(value) {
     "entry_id",
     "session_id",
     "phase",
+    "phase_id",
     "task_id",
     "agent",
     "critical",
@@ -819,7 +923,7 @@ function parseMembership(value) {
     "source_link_id",
     "exposure_kind",
     "origin"
-  ]) || typeof value.trace_id !== "string" || !value.trace_id || typeof value.entry_id !== "string" || !value.entry_id || typeof value.session_id !== "string" || !value.session_id || !isOptionalString(value.phase) || !isOptionalString(value.task_id) || !isOptionalString(value.agent) || typeof value.critical !== "boolean" || value.rank !== undefined && !Number.isFinite(value.rank) || value.score !== undefined && !Number.isFinite(value.score) || !isValidTimestamp(value.committed_at) || typeof value.membership_event_id !== "string" || !value.membership_event_id || !Number.isFinite(value.grace_days) || value.grace_days < 0 || value.phase_close_intent_at !== undefined && !isValidTimestamp(value.phase_close_intent_at) || value.phase_closed_at !== undefined && !isValidTimestamp(value.phase_closed_at) || !isOptionalString(value.cohort_id) || !isOptionalString(value.source_link_id) || !isReceiptExposureKind(value.exposure_kind) || value.origin !== "v2" && value.origin !== "legacy") {
+  ]) || typeof value.trace_id !== "string" || !value.trace_id || typeof value.entry_id !== "string" || !value.entry_id || typeof value.session_id !== "string" || !value.session_id || !isOptionalString(value.phase) || value.phase_id !== undefined && (!Number.isSafeInteger(value.phase_id) || value.phase_id < 1) || !isOptionalString(value.task_id) || !isOptionalString(value.agent) || typeof value.critical !== "boolean" || value.rank !== undefined && !Number.isFinite(value.rank) || value.score !== undefined && !Number.isFinite(value.score) || !isValidTimestamp(value.committed_at) || typeof value.membership_event_id !== "string" || !value.membership_event_id || !Number.isFinite(value.grace_days) || value.grace_days < 0 || value.phase_close_intent_at !== undefined && !isValidTimestamp(value.phase_close_intent_at) || value.phase_closed_at !== undefined && !isValidTimestamp(value.phase_closed_at) || !isOptionalString(value.cohort_id) || !isOptionalString(value.source_link_id) || !isReceiptExposureKind(value.exposure_kind) || value.origin !== "v2" && value.origin !== "legacy") {
     return null;
   }
   const terminal = value.terminal === undefined ? undefined : parseTerminal(value.terminal);
@@ -848,6 +952,7 @@ function parseMembership(value) {
     entry_id: value.entry_id,
     session_id: value.session_id,
     phase: value.phase,
+    phase_id: value.phase_id,
     task_id: value.task_id,
     agent: value.agent,
     critical: value.critical,
@@ -924,17 +1029,19 @@ function parsePhaseLifecycle(value) {
     return null;
   if (!hasOnlyKeys(value, [
     "phase",
+    "phase_id",
     "session_id",
     "task_id",
     "intent_event_id",
     "intent_at",
     "closed_event_id",
     "closed_at"
-  ]) || typeof value.phase !== "string" || !value.phase || typeof value.session_id !== "string" || !value.session_id || !isOptionalString(value.task_id) || !isOptionalString(value.intent_event_id) || value.intent_at !== undefined && !isValidTimestamp(value.intent_at) || !isOptionalString(value.closed_event_id) || value.closed_at !== undefined && !isValidTimestamp(value.closed_at)) {
+  ]) || typeof value.phase !== "string" || !value.phase || value.phase_id !== undefined && (!Number.isSafeInteger(value.phase_id) || value.phase_id < 1) || typeof value.session_id !== "string" || !value.session_id || !isOptionalString(value.task_id) || !isOptionalString(value.intent_event_id) || value.intent_at !== undefined && !isValidTimestamp(value.intent_at) || !isOptionalString(value.closed_event_id) || value.closed_at !== undefined && !isValidTimestamp(value.closed_at)) {
     return null;
   }
   return {
     phase: value.phase,
+    phase_id: value.phase_id,
     session_id: value.session_id,
     task_id: value.task_id,
     intent_event_id: value.intent_event_id,
@@ -971,6 +1078,7 @@ function parseAuditSummary(value) {
     "gate_release_committed",
     "phase_close_intent",
     "phase_closed",
+    "phase_id_backfilled",
     "repair_uncertainty_installed",
     "repair_uncertainty_cleared",
     "legacy_imported",
@@ -998,7 +1106,8 @@ function summarizeRecord(record) {
     payload.memberships,
     payload.transitions,
     payload.markers,
-    payload.rejected
+    payload.rejected,
+    payload.items
   ]) {
     if (!Array.isArray(collection))
       continue;
@@ -1181,13 +1290,30 @@ function applyRecord(state, record) {
     const phase = record.payload.phase;
     const sessionId = record.payload.session_id;
     const taskId = record.payload.task_id;
+    const rawPhaseId = record.payload.phase_id;
+    const phaseId = Number.isSafeInteger(rawPhaseId) && rawPhaseId >= 1 ? rawPhaseId : undefined;
     if (typeof phase === "string" && typeof sessionId === "string" && isOptionalString(taskId)) {
-      const lifecycleKey = phaseLifecycleKey(phase, sessionId, taskId);
-      const lifecycle = state.phaseLifecycle.get(lifecycleKey) ?? {
-        phase,
-        session_id: sessionId,
-        task_id: taskId
-      };
+      let lifecycleKey = phaseLifecycleKey(phase, sessionId, taskId);
+      let lifecycle = state.phaseLifecycle.get(lifecycleKey);
+      if (lifecycle === undefined && phaseId !== undefined) {
+        for (const [candidateKey, candidate] of state.phaseLifecycle) {
+          if (candidate.session_id === sessionId && candidate.task_id === taskId && (candidate.phase_id === phaseId || candidate.phase_id === undefined && extractPhaseIdFromLabel(candidate.phase) === phaseId)) {
+            lifecycleKey = candidateKey;
+            lifecycle = candidate;
+            break;
+          }
+        }
+      }
+      if (lifecycle === undefined) {
+        lifecycle = {
+          phase,
+          session_id: sessionId,
+          task_id: taskId
+        };
+      }
+      if (lifecycle.phase_id === undefined && phaseId !== undefined) {
+        lifecycle.phase_id = phaseId;
+      }
       if (record.kind === "phase_close_intent" && !lifecycle.intent_event_id) {
         lifecycle.intent_event_id = record.event_id;
         lifecycle.intent_at = record.timestamp;
@@ -1197,7 +1323,7 @@ function applyRecord(state, record) {
       }
       state.phaseLifecycle.set(lifecycleKey, lifecycle);
       for (const membership of state.memberships.values()) {
-        if (membership.phase !== phase || membership.session_id !== sessionId || membership.task_id !== taskId)
+        if (!membershipMatchesPhaseIdentity(membership, phase, phaseId) || membership.session_id !== sessionId || membership.task_id !== taskId)
           continue;
         if (record.kind === "phase_close_intent" && !membership.phase_close_intent_at)
           membership.phase_close_intent_at = record.timestamp;
@@ -1214,6 +1340,16 @@ function applyRecord(state, record) {
         }
       }
     }
+  } else if (record.kind === "phase_id_backfilled") {
+    for (const item of Array.isArray(record.payload.items) ? record.payload.items : []) {
+      const candidate = item;
+      if (typeof candidate.trace_id !== "string" || typeof candidate.entry_id !== "string" || !Number.isSafeInteger(candidate.phase_id) || candidate.phase_id < 1)
+        continue;
+      const membership = state.memberships.get(keyOf(candidate.trace_id, candidate.entry_id));
+      if (membership && membership.phase_id === undefined) {
+        membership.phase_id = candidate.phase_id;
+      }
+    }
   } else if (record.kind === "repair_uncertainty_installed") {
     const uncertainty = parseRepairUncertainty(record.payload.uncertainty);
     if (uncertainty) {
@@ -1314,7 +1450,9 @@ function validateRecordPayload(row) {
       return hasOnlyKeys(payload, ["trace_id", "rejected"]) && typeof payload.trace_id === "string" && Array.isArray(payload.rejected) && payload.rejected.every((item) => isPlainRecord(item) && hasOnlyKeys(item, ["entry_id", "reason"]) && typeof item.entry_id === "string" && typeof item.reason === "string");
     case "phase_close_intent":
     case "phase_closed":
-      return hasOnlyKeys(payload, ["phase", "session_id", "task_id"]) && typeof payload.phase === "string" && !!payload.phase && typeof payload.session_id === "string" && !!payload.session_id && isOptionalString(payload.task_id);
+      return hasOnlyKeys(payload, ["phase", "phase_id", "session_id", "task_id"]) && typeof payload.phase === "string" && !!payload.phase && (payload.phase_id === undefined || Number.isSafeInteger(payload.phase_id) && payload.phase_id >= 1) && typeof payload.session_id === "string" && !!payload.session_id && isOptionalString(payload.task_id);
+    case "phase_id_backfilled":
+      return hasOnlyKeys(payload, ["items"]) && Array.isArray(payload.items) && payload.items.length > 0 && payload.items.every((item) => isPlainRecord(item) && hasOnlyKeys(item, ["trace_id", "entry_id", "phase_id"]) && typeof item.trace_id === "string" && !!item.trace_id && typeof item.entry_id === "string" && !!item.entry_id && Number.isSafeInteger(item.phase_id) && item.phase_id >= 1);
     case "repair_uncertainty_installed":
       return hasOnlyKeys(payload, ["uncertainty"]) && parseRepairUncertainty(payload.uncertainty) !== null;
     case "repair_uncertainty_cleared":
@@ -1360,6 +1498,7 @@ function validateRecord(value, state) {
     "gate_release_committed",
     "phase_close_intent",
     "phase_closed",
+    "phase_id_backfilled",
     "repair_uncertainty_installed",
     "repair_uncertainty_cleared",
     "legacy_imported",
@@ -1816,15 +1955,28 @@ async function commitDisplayedMembership(directory, input) {
   return runLocked(directory, input.grace_days, async (paths, state, graceDays) => {
     if (!input.trace_id || !input.session_id || input.entries.length === 0)
       throw new ReceiptStoreError("store_unavailable", "invalid displayed membership");
+    if (input.phase_id !== undefined && (!Number.isSafeInteger(input.phase_id) || input.phase_id < 1))
+      throw new ReceiptStoreError("store_unavailable", "invalid displayed membership: phase_id must be a safe integer >= 1");
     const eventId = randomUUID2();
     const committedAt = nowIso();
     const exposureKind = normalizeExposureKind(input.exposure_kind);
     const memberships = [];
     const newMemberships = [];
+    const closedLifecycle = findClosedLifecycleForPhase(state, {
+      phase: input.phase,
+      phase_id: input.phase_id,
+      session_id: input.session_id,
+      task_id: input.task_id
+    }) ?? (input.task_id !== undefined ? findClosedLifecycleForPhase(state, {
+      phase: input.phase,
+      phase_id: input.phase_id,
+      session_id: input.session_id,
+      task_id: undefined
+    }) : undefined);
     for (const entry of input.entries) {
       const existing = state.memberships.get(keyOf(input.trace_id, entry.entry_id));
       if (existing) {
-        if (existing.session_id !== input.session_id || existing.phase !== input.phase || existing.task_id !== input.task_id || existing.critical !== entry.critical || existing.cohort_id !== input.cohort_id || existing.source_link_id !== input.source_link_id || existing.exposure_kind !== exposureKind) {
+        if (existing.session_id !== input.session_id || existing.phase !== input.phase || existing.phase_id !== undefined && input.phase_id !== undefined && existing.phase_id !== input.phase_id || existing.task_id !== input.task_id || existing.critical !== entry.critical || existing.cohort_id !== input.cohort_id || existing.source_link_id !== input.source_link_id || existing.exposure_kind !== exposureKind) {
           throw new ReceiptStoreError("store_unavailable", `conflicting immutable membership for ${input.trace_id}/${entry.entry_id}`);
         }
         memberships.push({
@@ -1833,7 +1985,6 @@ async function commitDisplayedMembership(directory, input) {
         });
         continue;
       }
-      const closedLifecycle = state.phaseLifecycle.get(phaseLifecycleKey(input.phase ?? "", input.session_id, input.task_id)) ?? (input.task_id !== undefined ? state.phaseLifecycle.get(phaseLifecycleKey(input.phase ?? "", input.session_id)) : undefined);
       if (input.phase && closedLifecycle?.closed_event_id) {
         throw new ReceiptStoreError("store_unavailable", `cannot add receipt membership to closed lifecycle ${input.session_id}/${input.phase}`);
       }
@@ -1842,6 +1993,7 @@ async function commitDisplayedMembership(directory, input) {
         entry_id: entry.entry_id,
         session_id: input.session_id,
         phase: input.phase,
+        phase_id: input.phase_id,
         task_id: input.task_id,
         agent: input.agent,
         critical: entry.critical,
@@ -2060,7 +2212,7 @@ async function queryLiveMemberships(directory, filters = {}) {
       throw new ReceiptStoreError("store_unavailable", repairUncertaintyUnavailable(overlaps).detail);
     }
     return {
-      memberships: [...state.memberships.values()].filter((m) => (!filters.phase || m.phase === filters.phase) && (!filters.task_id || m.task_id === filters.task_id) && (!filters.session_id || m.session_id === filters.session_id) && (filters.include_terminal !== false || !m.terminal) && (filters.include_phase_closed !== false || !m.phase_closed_at) && (!filters.exposure_kind || m.exposure_kind === filters.exposure_kind)).map((m) => ({
+      memberships: [...state.memberships.values()].filter((m) => (filters.phase_id === undefined || membershipMatchesPhaseIdentity(m, filters.phase ?? "", filters.phase_id)) && (!filters.phase || filters.phase_id !== undefined || m.phase === filters.phase) && (!filters.task_id || m.task_id === filters.task_id) && (!filters.session_id || m.session_id === filters.session_id) && (filters.include_terminal !== false || !m.terminal) && (filters.include_phase_closed !== false || !m.phase_closed_at) && (!filters.exposure_kind || m.exposure_kind === filters.exposure_kind)).map((m) => ({
         ...m,
         terminal: m.terminal ? { ...m.terminal } : undefined
       }))
@@ -2097,11 +2249,12 @@ async function queryHistoricalOutcomes(directory, entryIds, graceDays) {
     return { memberships: [...memberships.values()] };
   }, { compact: false, writeSnapshot: false });
 }
-async function phaseTransition(directory, phase, kind, sessionId, taskId, graceDays) {
+async function phaseTransition(directory, phase, kind, sessionId, taskId, graceDays, phaseId) {
   return runLocked(directory, graceDays, async (paths, state) => {
     if (!phase.trim()) {
       throw new ReceiptStoreError("store_unavailable", "phase is required");
     }
+    const effectivePhaseId = phaseId !== undefined && Number.isSafeInteger(phaseId) && phaseId >= 1 ? phaseId : undefined;
     const scopeKeys = new Map;
     const addScope = (scopeSessionId, scopeTaskId) => {
       if (sessionId !== undefined && scopeSessionId !== sessionId || taskId !== undefined && scopeTaskId !== taskId)
@@ -2112,7 +2265,7 @@ async function phaseTransition(directory, phase, kind, sessionId, taskId, graceD
       });
     };
     for (const membership of state.memberships.values()) {
-      if (membership.phase === phase)
+      if (membershipMatchesPhaseIdentity(membership, phase, effectivePhaseId))
         addScope(membership.session_id, membership.task_id);
     }
     for (const trace of state.emptyTraces.values()) {
@@ -2120,9 +2273,20 @@ async function phaseTransition(directory, phase, kind, sessionId, taskId, graceD
         addScope(trace.session_id, trace.task_id);
     }
     for (const lifecycle of state.phaseLifecycle.values()) {
-      if (lifecycle.phase === phase)
+      if (effectivePhaseId !== undefined ? (lifecycle.phase_id === effectivePhaseId || lifecycle.phase_id === undefined && extractPhaseIdFromLabel(lifecycle.phase) === effectivePhaseId) && (sessionId === undefined || lifecycle.session_id === sessionId) : lifecycle.phase === phase)
         addScope(lifecycle.session_id, lifecycle.task_id);
     }
+    if (scopeKeys.size === 0 && sessionId !== undefined) {
+      const closedLifecycle = findClosedLifecycleForPhase(state, {
+        phase,
+        phase_id: effectivePhaseId,
+        session_id: sessionId,
+        task_id: taskId
+      });
+      if (closedLifecycle) {
+        addScope(closedLifecycle.session_id, closedLifecycle.task_id);
+      }
+    }
     if (scopeKeys.size === 0 && sessionId !== undefined) {
       addScope(sessionId, taskId);
     }
@@ -2134,14 +2298,45 @@ async function phaseTransition(directory, phase, kind, sessionId, taskId, graceD
     }
     let eventId = "";
     for (const [key, scope] of scopeKeys) {
-      const lifecycle = state.phaseLifecycle.get(key);
+      const lifecycle = findClosedLifecycleForPhase(state, {
+        phase,
+        phase_id: effectivePhaseId,
+        session_id: scope.session_id,
+        task_id: scope.task_id
+      }) ?? state.phaseLifecycle.get(key);
       const existingEventId = kind === "phase_close_intent" ? lifecycle?.intent_event_id : lifecycle?.closed_event_id;
       if (existingEventId) {
         eventId ||= existingEventId;
         continue;
       }
-      const row = makeRecord(state, kind, { phase, ...scope });
+      const row = makeRecord(state, kind, {
+        phase,
+        ...effectivePhaseId !== undefined ? { phase_id: effectivePhaseId } : {},
+        ...scope
+      });
       await appendRecord(paths, state, row);
+      if (lifecycle === undefined) {
+        state.phaseLifecycle.set(key, {
+          phase,
+          ...effectivePhaseId !== undefined ? { phase_id: effectivePhaseId } : {},
+          session_id: scope.session_id,
+          task_id: scope.task_id,
+          intent_event_id: kind === "phase_close_intent" ? row.event_id : undefined,
+          intent_at: kind === "phase_close_intent" ? row.timestamp : undefined,
+          closed_event_id: kind === "phase_closed" ? row.event_id : undefined,
+          closed_at: kind === "phase_closed" ? row.timestamp : undefined
+        });
+      } else {
+        if (lifecycle.phase_id === undefined && effectivePhaseId !== undefined)
+          lifecycle.phase_id = effectivePhaseId;
+        if (kind === "phase_close_intent" && !lifecycle.intent_event_id) {
+          lifecycle.intent_event_id = row.event_id;
+          lifecycle.intent_at = row.timestamp;
+        } else if (kind === "phase_closed" && !lifecycle.closed_event_id) {
+          lifecycle.closed_event_id = row.event_id;
+          lifecycle.closed_at = row.timestamp;
+        }
+      }
       eventId ||= row.event_id;
     }
     if (kind === "phase_closed")
@@ -2149,12 +2344,12 @@ async function phaseTransition(directory, phase, kind, sessionId, taskId, graceD
     return { event_id: eventId };
   });
 }
-var recordPhaseCloseIntent = (directory, phase, sessionId, taskId) => phaseTransition(directory, phase, "phase_close_intent", sessionId, taskId);
-var commitPhaseClosed = (directory, phase, sessionId, taskId) => phaseTransition(directory, phase, "phase_closed", sessionId, taskId);
-async function reconcilePhaseClose(directory, phase, durablePlanClosed, sessionId, taskId) {
+var recordPhaseCloseIntent = (directory, phase, sessionId, taskId, phaseId) => phaseTransition(directory, phase, "phase_close_intent", sessionId, taskId, undefined, phaseId);
+var commitPhaseClosed = (directory, phase, sessionId, taskId, phaseId) => phaseTransition(directory, phase, "phase_closed", sessionId, taskId, undefined, phaseId);
+async function reconcilePhaseClose(directory, phase, durablePlanClosed, sessionId, taskId, phaseId) {
   if (!durablePlanClosed)
     return { ok: true, reconciled: false };
-  const result = await commitPhaseClosed(directory, phase, sessionId, taskId);
+  const result = await commitPhaseClosed(directory, phase, sessionId, taskId, phaseId);
   return result.ok ? { ok: true, reconciled: true } : result;
 }
 async function compactIfNeeded(paths, state) {
@@ -2258,729 +2453,85 @@ function serializeArchive(summaries) {
 `)}
 ` : "";
 }
-var _internals3 = {
-  nowMs: () => Date.now(),
-  writeSnapshot,
-  atomicWriteFsynced,
-  appendFsynced,
-  commitApplicationMarkerBatch,
-  maxJournalRecords: MAX_JOURNAL_RECORDS,
-  maxArchiveRecords: MAX_ARCHIVE_RECORDS,
-  maxArchiveBytes: MAX_ARCHIVE_BYTES,
-  maxRepairQuarantineRecords: MAX_REPAIR_QUARANTINE_RECORDS
-};
-
-// src/hooks/knowledge-events.ts
-var KNOWLEDGE_EVENT_SCHEMA_VERSION = 1;
-var MAX_EVENT_LOG_ENTRIES = 5000;
-var counterRollupCache = new Map;
-var MAX_COUNTER_ROLLUP_CACHE_DIRS = 32;
-var RECEIPT_EVENT_TYPES = new Set([
-  "acknowledged",
-  "applied",
-  "ignored",
-  "contradicted",
-  "violated",
-  "n_a",
-  "override",
-  "no_relevant"
-]);
-function resolveKnowledgeEventsPath(directory) {
-  return path2.join(resolveKnowledgeStoreDir(directory), "knowledge-events.jsonl");
-}
-function resolveKnowledgeCounterBaselinePath(directory) {
-  return path2.join(resolveKnowledgeStoreDir(directory), "knowledge-counter-baseline.json");
-}
-var resolveHiveEventsPath2 = resolveHiveEventsPath;
-function resolveLegacyApplicationLogPath(directory) {
-  return path2.join(resolveKnowledgeStoreDir(directory), "knowledge-application.jsonl");
-}
-function newTraceId() {
-  return randomUUID3();
-}
-function newEventId() {
-  return randomUUID3();
-}
-function withDefaults(event) {
-  return {
-    schema_version: KNOWLEDGE_EVENT_SCHEMA_VERSION,
-    ...event,
-    event_id: event.event_id || newEventId(),
-    timestamp: event.timestamp || new Date().toISOString()
-  };
-}
-async function appendKnowledgeEvent(directory, event) {
-  const [populated] = await appendKnowledgeEventsBatch(directory, [event]);
-  return populated;
-}
-async function appendKnowledgeEventsBatch(directory, events) {
-  if (events.length === 0)
-    return [];
-  const populated = events.map(withDefaults);
-  const filePath = resolveKnowledgeEventsPath(directory);
-  const dirPath = path2.dirname(filePath);
-  await mkdir2(dirPath, { recursive: true });
-  let release;
-  try {
-    release = await import_proper_lockfile.default.lock(dirPath, {
-      retries: { retries: 200, minTimeout: 10, maxTimeout: 100 }
-    });
-    await appendFile(filePath, `${populated.map((e) => JSON.stringify(e)).join(`
-`)}
-`, "utf-8");
-    try {
-      const content = await readFile2(filePath, "utf-8");
-      const lines = content.split(`
-`).filter((line) => line.trim().length > 0);
-      if (lines.length > MAX_EVENT_LOG_ENTRIES) {
-        const evicted = lines.slice(0, lines.length - MAX_EVENT_LOG_ENTRIES);
-        const trimmed = lines.slice(lines.length - MAX_EVENT_LOG_ENTRIES);
-        await foldEvictedEventsIntoBaseline(directory, evicted, filePath);
-        await atomicWriteFile(filePath, `${trimmed.join(`
-`)}
-`);
-      }
-    } catch (err) {
-      warn(`[knowledge-events] local cap trim failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
-    }
-  } finally {
-    if (release)
-      await release().catch(() => {});
-  }
-  return populated;
-}
-async function recordKnowledgeEvent(directory, event) {
-  try {
-    return await appendKnowledgeEvent(directory, event);
-  } catch (err) {
-    warn(`[knowledge-events] recordKnowledgeEvent failed: ${err instanceof Error ? err.message : String(err)}`);
-    return null;
-  }
-}
-async function recordKnowledgeEventsBatch(directory, events) {
-  try {
-    return await appendKnowledgeEventsBatch(directory, events);
-  } catch (err) {
-    warn(`[knowledge-events] recordKnowledgeEventsBatch failed: ${err instanceof Error ? err.message : String(err)}`);
-    return null;
-  }
-}
-async function appendHiveKnowledgeEvent(event) {
-  const populated = withDefaults(event);
-  const filePath = resolveHiveEventsPath2();
-  const dirPath = path2.dirname(filePath);
-  await mkdir2(dirPath, { recursive: true });
-  let release;
-  try {
-    release = await import_proper_lockfile.default.lock(dirPath, {
-      retries: { retries: 200, minTimeout: 10, maxTimeout: 100 },
-      stale: 5000
-    });
-    await appendFile(filePath, `${JSON.stringify(populated)}
-`, "utf-8");
-    try {
-      const content = await readFile2(filePath, "utf-8");
-      const lines = content.split(`
-`).filter((line) => line.trim().length > 0);
-      if (lines.length > MAX_EVENT_LOG_ENTRIES) {
-        const trimmed = lines.slice(lines.length - MAX_EVENT_LOG_ENTRIES);
-        await atomicWriteFile(filePath, `${trimmed.join(`
-`)}
-`);
-      }
-    } catch (err) {
-      warn(`[knowledge-events] hive cap trim failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
-    }
-  } finally {
-    if (release)
-      await release().catch(() => {});
-  }
-  return populated;
-}
-async function recordHiveKnowledgeEvent(event) {
-  try {
-    return await appendHiveKnowledgeEvent(event);
-  } catch (err) {
-    warn(`[knowledge-events] recordHiveKnowledgeEvent failed: ${err instanceof Error ? err.message : String(err)}`);
-    return null;
-  }
-}
-async function readKnowledgeEvents(directory, maxEvents) {
-  const filePath = resolveKnowledgeEventsPath(directory);
-  if (!existsSync3(filePath))
-    return [];
-  const content = await readFile2(filePath, "utf-8");
-  const out = [];
-  const max = maxEvents !== undefined && maxEvents > 0 ? maxEvents : Infinity;
-  for (const line of content.split(`
-`)) {
-    if (out.length >= max)
-      break;
-    const trimmed = line.trim();
-    if (!trimmed)
-      continue;
-    try {
-      out.push(JSON.parse(trimmed));
-    } catch {
-      warn(`[knowledge-events] Skipping corrupted JSONL line in ${filePath}: ${trimmed.slice(0, 80)}`);
-    }
-  }
-  return out;
-}
-async function readHiveKnowledgeEvents() {
-  const filePath = resolveHiveEventsPath2();
-  if (!existsSync3(filePath))
-    return [];
-  const content = await readFile2(filePath, "utf-8");
-  return parseEventLines(content.split(`
-`), filePath);
-}
-async function readLegacyApplicationRecords(directory) {
-  const filePath = resolveLegacyApplicationLogPath(directory);
-  if (!existsSync3(filePath))
-    return [];
-  const content = await readFile2(filePath, "utf-8");
-  const out = [];
-  for (const line of content.split(`
-`)) {
-    const trimmed = line.trim();
-    if (!trimmed)
-      continue;
-    try {
-      out.push(JSON.parse(trimmed));
-    } catch {
-      warn(`[knowledge-events] Skipping corrupted JSONL line in ${filePath}: ${trimmed.slice(0, 80)}`);
-    }
-  }
-  return out;
-}
-var MAX_VIOLATION_TIMESTAMPS = 10;
-function emptyRollup() {
-  return {
-    shown_count: 0,
-    acknowledged_count: 0,
-    applied_explicit_count: 0,
-    ignored_count: 0,
-    violated_count: 0,
-    contradicted_count: 0,
-    n_a_count: 0,
-    succeeded_after_shown_count: 0,
-    failed_after_shown_count: 0,
-    partial_after_shown_count: 0,
-    violation_timestamps: []
-  };
-}
-function cloneRollup(input) {
-  return {
-    ...emptyRollup(),
-    ...input,
-    violation_timestamps: [...input.violation_timestamps ?? []]
-  };
-}
-function cloneRollupMap(input) {
-  const out = new Map;
-  for (const [id, rollup] of input) {
-    out.set(id, cloneRollup(rollup));
-  }
-  return out;
-}
-function normalizeRollupTimestamps(rollup) {
-  if (rollup.violation_timestamps.length > 1) {
-    rollup.violation_timestamps.sort((a, b) => a < b ? 1 : a > b ? -1 : 0);
-  }
-  if (rollup.violation_timestamps.length > MAX_VIOLATION_TIMESTAMPS) {
-    rollup.violation_timestamps = rollup.violation_timestamps.slice(0, MAX_VIOLATION_TIMESTAMPS);
-  }
-  return rollup;
-}
-function mergeRollupInto(target, source) {
-  target.shown_count += source.shown_count ?? 0;
-  target.acknowledged_count += source.acknowledged_count ?? 0;
-  target.applied_explicit_count += source.applied_explicit_count ?? 0;
-  target.ignored_count += source.ignored_count ?? 0;
-  target.violated_count += source.violated_count ?? 0;
-  target.contradicted_count += source.contradicted_count ?? 0;
-  target.n_a_count += source.n_a_count ?? 0;
-  target.succeeded_after_shown_count += source.succeeded_after_shown_count ?? 0;
-  target.failed_after_shown_count += source.failed_after_shown_count ?? 0;
-  target.partial_after_shown_count += source.partial_after_shown_count ?? 0;
-  if (source.last_applied_at) {
-    target.last_applied_at = maxIso(target.last_applied_at, source.last_applied_at);
-  }
-  if (source.last_acknowledged_at) {
-    target.last_acknowledged_at = maxIso(target.last_acknowledged_at, source.last_acknowledged_at);
-  }
-  target.violation_timestamps.push(...source.violation_timestamps ?? []);
-  normalizeRollupTimestamps(target);
-}
-function get(map, id) {
-  let r = map.get(id);
-  if (!r) {
-    r = emptyRollup();
-    map.set(id, r);
-  }
-  return r;
-}
-function maxIso(current, candidate) {
-  if (!current)
-    return candidate;
-  return candidate > current ? candidate : current;
-}
-async function readCounterBaseline(directory) {
-  const filePath = resolveKnowledgeCounterBaselinePath(directory);
-  if (!existsSync3(filePath))
-    return new Map;
-  let raw;
-  try {
-    raw = JSON.parse(await readFile2(filePath, "utf-8"));
-  } catch (err) {
-    warn(`[knowledge-events] corrupted counter baseline at ${filePath}; ignoring folded baseline and replaying live events only: ${err instanceof Error ? err.message : String(err)}`);
-    return new Map;
-  }
-  const map = new Map;
-  for (const [id, rollup] of Object.entries(raw)) {
-    map.set(id, normalizeRollupTimestamps(cloneRollup(rollup)));
-  }
-  return map;
-}
-async function writeCounterBaseline(directory, baseline) {
-  const filePath = resolveKnowledgeCounterBaselinePath(directory);
-  const out = {};
-  for (const [id, rollup] of [...baseline.entries()].sort(([a], [b]) => a.localeCompare(b))) {
-    out[id] = normalizeRollupTimestamps(cloneRollup(rollup));
-  }
-  await atomicWriteFile(filePath, `${JSON.stringify(out, null, 2)}
-`);
-}
-async function statCacheKey(filePath) {
-  try {
-    const fileStat = await stat2(filePath);
-    return `${fileStat.mtimeMs}:${fileStat.ctimeMs}:${fileStat.size}`;
-  } catch (err) {
-    if (err?.code === "ENOENT")
-      return "missing";
-    throw err;
-  }
-}
-async function buildCounterRollupCacheKey(directory) {
-  const [eventsKey, legacyKey, baselineKey] = await Promise.all([
-    statCacheKey(resolveKnowledgeEventsPath(directory)),
-    statCacheKey(resolveLegacyApplicationLogPath(directory)),
-    statCacheKey(resolveKnowledgeCounterBaselinePath(directory))
-  ]);
-  return `${eventsKey}|${legacyKey}|${baselineKey}`;
-}
-function setCounterRollupCache(directory, key, rollups) {
-  const cacheKey = canonicalRootKey(directory);
-  if (counterRollupCache.has(cacheKey)) {
-    counterRollupCache.delete(cacheKey);
-  }
-  counterRollupCache.set(cacheKey, {
-    key,
-    rollups: cloneRollupMap(rollups)
-  });
-  while (counterRollupCache.size > MAX_COUNTER_ROLLUP_CACHE_DIRS) {
-    const oldestKey = counterRollupCache.keys().next().value;
-    if (oldestKey === undefined)
-      break;
-    counterRollupCache.delete(oldestKey);
-  }
-}
-function parseEventLines(lines, filePath) {
-  const out = [];
-  for (const line of lines) {
-    const trimmed = line.trim();
-    if (!trimmed)
-      continue;
-    try {
-      out.push(JSON.parse(trimmed));
-    } catch {
-      warn(`[knowledge-events] Skipping corrupted JSONL line in ${filePath}: ${trimmed.slice(0, 80)}`);
-    }
-  }
-  return out;
-}
-async function foldEvictedEventsIntoBaseline(directory, evictedLines, filePath) {
-  const evictedEvents = parseEventLines(evictedLines, filePath);
-  if (evictedEvents.length === 0)
-    return;
-  const baseline = await readCounterBaseline(directory);
-  for (const [id, rollup] of recomputeCounters(evictedEvents)) {
-    mergeRollupInto(get(baseline, id), rollup);
-  }
-  await writeCounterBaseline(directory, baseline);
-}
-function recomputeCounters(events, legacyRecords = [], baseline = new Map) {
-  const map = new Map;
-  const retrievedIds = new Set;
-  for (const [id, rollup] of baseline) {
-    map.set(id, cloneRollup(rollup));
-    if ((rollup.shown_count ?? 0) > 0)
-      retrievedIds.add(id);
-  }
-  for (const e of events) {
-    switch (e.type) {
-      case "retrieved": {
-        for (const id of e.result_ids) {
-          retrievedIds.add(id);
-          get(map, id).shown_count += 1;
-        }
-        break;
-      }
-      case "acknowledged": {
-        if (!e.knowledge_id)
-          break;
-        const r = get(map, e.knowledge_id);
-        r.acknowledged_count += 1;
-        r.last_acknowledged_at = maxIso(r.last_acknowledged_at, e.timestamp);
-        break;
-      }
-      case "applied": {
-        if (!e.knowledge_id)
-          break;
-        const r = get(map, e.knowledge_id);
-        r.applied_explicit_count += 1;
-        r.last_applied_at = maxIso(r.last_applied_at, e.timestamp);
-        break;
-      }
-      case "ignored":
-        if (!e.knowledge_id)
-          break;
-        get(map, e.knowledge_id).ignored_count += 1;
-        break;
-      case "violated": {
-        if (!e.knowledge_id)
-          break;
-        const r = get(map, e.knowledge_id);
-        r.violated_count += 1;
-        r.violation_timestamps.push(e.timestamp);
-        break;
-      }
-      case "contradicted":
-        if (!e.knowledge_id)
-          break;
-        get(map, e.knowledge_id).contradicted_count += 1;
-        break;
-      case "n_a":
-        if (!e.knowledge_id)
-          break;
-        get(map, e.knowledge_id).n_a_count += 1;
-        break;
-      case "no_relevant":
-        break;
-      case "unacknowledged":
-        break;
-      case "outcome": {
-        if (!e.knowledge_id)
-          break;
-        const r = get(map, e.knowledge_id);
-        if (e.outcome === "success")
-          r.succeeded_after_shown_count += 1;
-        else if (e.outcome === "failure")
-          r.failed_after_shown_count += 1;
-        else if (e.outcome === "partial")
-          r.partial_after_shown_count += 1;
-        break;
-      }
-    }
-  }
-  for (const rec of legacyRecords) {
-    const r = get(map, rec.knowledgeId);
-    switch (rec.result) {
-      case "shown":
-        if (!retrievedIds.has(rec.knowledgeId))
-          r.shown_count += 1;
-        break;
-      case "acknowledged":
-        r.acknowledged_count += 1;
-        r.last_acknowledged_at = maxIso(r.last_acknowledged_at, rec.timestamp);
-        break;
-      case "applied":
-        r.applied_explicit_count += 1;
-        r.last_applied_at = maxIso(r.last_applied_at, rec.timestamp);
-        break;
-      case "ignored":
-        r.ignored_count += 1;
-        break;
-      case "contradicted":
-        r.contradicted_count += 1;
-        break;
-      case "violated":
-        r.violated_count += 1;
-        r.violation_timestamps.push(rec.timestamp);
-        break;
-    }
-  }
-  for (const r of map.values()) {
-    normalizeRollupTimestamps(r);
-  }
-  return map;
-}
-function countViolationsInWindow(timestamps, windowDays, now = new Date) {
-  const cutoff = now.getTime() - windowDays * 24 * 60 * 60 * 1000;
-  let count = 0;
-  for (const ts of timestamps) {
-    const t = Date.parse(ts);
-    if (!Number.isNaN(t) && t >= cutoff)
-      count += 1;
-  }
-  return count;
-}
-function countEmptyTraceTerminals(events) {
-  let n = 0;
-  for (const e of events) {
-    if (e.type === "no_relevant")
-      n += 1;
-  }
-  return n;
-}
-async function countEntryViolationsInWindow(directory, entryId, windowDays, now = new Date) {
-  try {
-    const cutoff = now.getTime() - windowDays * 24 * 60 * 60 * 1000;
-    const [events, legacyRecords] = await Promise.all([
-      readKnowledgeEvents(directory),
-      readLegacyApplicationRecords(directory)
-    ]);
-    let count = 0;
-    for (const e of events) {
-      if (e.type !== "violated" || e.knowledge_id !== entryId)
+async function inspectMembershipPhaseIds(directory) {
+  return runLocked(directory, undefined, async (_paths, state) => {
+    let backfillable = 0;
+    const unparsable = [];
+    let missing = 0;
+    for (const membership of state.memberships.values()) {
+      if (membership.phase_id !== undefined)
         continue;
-      const t = Date.parse(e.timestamp);
-      if (!Number.isNaN(t) && t >= cutoff)
-        count += 1;
-    }
-    for (const rec of legacyRecords) {
-      if (rec.result !== "violated" || rec.knowledgeId !== entryId)
+      missing++;
+      if (membership.phase === undefined) {
+        unparsable.push({
+          trace_id: membership.trace_id,
+          entry_id: membership.entry_id
+        });
         continue;
-      const t = Date.parse(rec.timestamp);
-      if (!Number.isNaN(t) && t >= cutoff)
-        count += 1;
+      }
+      if (extractPhaseIdFromLabel(membership.phase) !== undefined) {
+        backfillable++;
+      } else {
+        unparsable.push({
+          trace_id: membership.trace_id,
+          entry_id: membership.entry_id,
+          label: membership.phase
+        });
+      }
     }
-    return count;
-  } catch {
-    return 0;
-  }
+    return { missing, backfillable, unparsable };
+  }, { compact: false, writeSnapshot: false });
 }
-async function countEntryContradictionsInWindow(directory, entryId, windowDays, now = new Date) {
-  try {
-    const cutoff = now.getTime() - windowDays * 24 * 60 * 60 * 1000;
-    const events = await readKnowledgeEvents(directory);
-    let count = 0;
-    for (const e of events) {
-      if (e.type !== "contradicted" || e.knowledge_id !== entryId)
+async function backfillMembershipPhaseIds(directory) {
+  return runLocked(directory, undefined, async (paths, state) => {
+    const items = [];
+    const skipped = [];
+    for (const membership of state.memberships.values()) {
+      if (membership.phase_id !== undefined)
         continue;
-      const t = Date.parse(e.timestamp);
-      if (!Number.isNaN(t) && t >= cutoff)
-        count += 1;
-    }
-    return count;
-  } catch {
-    return 0;
-  }
-}
-async function readKnowledgeCounterRollups(directory) {
-  try {
-    const cacheKey = await buildCounterRollupCacheKey(directory);
-    const directoryKey = canonicalRootKey(directory);
-    const cached = counterRollupCache.get(directoryKey);
-    if (cached?.key === cacheKey) {
-      counterRollupCache.delete(directoryKey);
-      counterRollupCache.set(directoryKey, cached);
-      return cloneRollupMap(cached.rollups);
-    }
-    const [events, legacyRecords, baseline] = await Promise.all([
-      readKnowledgeEvents(directory),
-      readLegacyApplicationRecords(directory),
-      readCounterBaseline(directory)
-    ]);
-    const rollups = recomputeCounters(events, legacyRecords, baseline);
-    setCounterRollupCache(directory, cacheKey, rollups);
-    return cloneRollupMap(rollups);
-  } catch (err) {
-    warn(`[knowledge-events] readKnowledgeCounterRollups failed: ${err instanceof Error ? err.message : String(err)}`);
-    return new Map;
-  }
-}
-async function readAuthoritativeKnowledgeCounterRollups(directory) {
-  const history = await queryHistoricalOutcomes(directory);
-  if (!history.ok)
-    return new Map;
-  const rollups = new Map;
-  for (const membership of history.memberships) {
-    const rollup = get(rollups, membership.entry_id);
-    rollup.shown_count += 1;
-    if (membership.application_marker) {
-      rollup.acknowledged_count += 1;
-      rollup.last_acknowledged_at = maxIso(rollup.last_acknowledged_at, membership.application_marker.committed_at);
-    }
-    const compatible = membership;
-    const seen = new Set;
-    for (const terminal of [
-      ...compatible.terminal_history ?? [],
-      ...compatible.historical_terminals ?? [],
-      ...membership.terminal ? [membership.terminal] : []
-    ]) {
-      if (seen.has(terminal.event_id))
+      const phaseId = extractPhaseIdFromLabel(membership.phase);
+      if (phaseId === undefined) {
+        skipped.push({
+          trace_id: membership.trace_id,
+          entry_id: membership.entry_id,
+          label: membership.phase
+        });
         continue;
-      seen.add(terminal.event_id);
-      switch (terminal.outcome) {
-        case "applied":
-          rollup.applied_explicit_count += 1;
-          rollup.last_applied_at = maxIso(rollup.last_applied_at, terminal.committed_at);
-          break;
-        case "ignored":
-          rollup.ignored_count += 1;
-          break;
-        case "violated":
-          rollup.violated_count += 1;
-          rollup.violation_timestamps.push(terminal.committed_at);
-          break;
-        case "contradicted":
-          rollup.contradicted_count += 1;
-          break;
-        case "n_a":
-          rollup.n_a_count += 1;
-          break;
       }
-    }
-    normalizeRollupTimestamps(rollup);
-  }
-  return rollups;
-}
-function effectiveRetrievalOutcomes(stored, rollup) {
-  const base = stored ?? {
-    applied_count: 0,
-    succeeded_after_count: 0,
-    failed_after_count: 0
-  };
-  if (!rollup)
-    return base;
-  const { n_a_count: _na, ...rollupWithoutNa } = rollup;
-  return {
-    ...base,
-    ...rollupWithoutNa,
-    succeeded_after_shown_count: (base.succeeded_after_shown_count ?? 0) + (rollup.succeeded_after_shown_count ?? 0),
-    failed_after_shown_count: (base.failed_after_shown_count ?? 0) + (rollup.failed_after_shown_count ?? 0)
-  };
-}
-var VERDICT_CONFIDENCE_BOOST = 0.03;
-var VERDICT_CONFIDENCE_DECAY = 0.05;
-async function applyKnowledgeVerdictFeedback(directory, options) {
-  try {
-    const history = await _internals4.queryHistoricalOutcomes(directory);
-    if (!history.ok)
-      return { processed: 0, bumps: 0 };
-    const seenEventIds = new Set;
-    const events = history.memberships.flatMap((membership) => {
-      const compatible = membership;
-      const terminals = [
-        ...compatible.terminal_history ?? [],
-        ...compatible.historical_terminals ?? [],
-        ...membership.terminal ? [membership.terminal] : []
-      ];
-      return terminals.flatMap((terminal) => {
-        if (terminal.outcome !== "applied" && terminal.outcome !== "violated" && terminal.outcome !== "ignored" || seenEventIds.has(terminal.event_id)) {
-          return [];
-        }
-        seenEventIds.add(terminal.event_id);
-        return [
-          {
-            type: terminal.outcome,
-            event_id: terminal.event_id,
-            knowledge_id: membership.entry_id,
-            timestamp: terminal.committed_at
-          }
-        ];
+      items.push({
+        trace_id: membership.trace_id,
+        entry_id: membership.entry_id,
+        phase_id: phaseId
       });
-    }).sort((a, b) => a.timestamp === b.timestamp ? a.event_id.localeCompare(b.event_id) : a.timestamp.localeCompare(b.timestamp));
-    const markerIndex = options?.sinceTimestamp && options.sinceEventId ? events.findIndex((e) => e.timestamp === options.sinceTimestamp && e.event_id === options.sinceEventId) : -1;
-    const actionable = events.filter((e, index) => {
-      if (options?.sinceTimestamp && e.timestamp < options.sinceTimestamp) {
-        return false;
-      }
-      if (options?.sinceTimestamp && e.timestamp === options.sinceTimestamp) {
-        if (!options.sinceEventId) {
-          return false;
-        }
-        if (markerIndex < 0) {
-          return false;
+    }
+    if (items.length > 0) {
+      const eventId = randomUUID2();
+      const row = makeRecord(state, "phase_id_backfilled", { items }, eventId);
+      await appendRecord(paths, state, row);
+      for (const item of items) {
+        const membership = state.memberships.get(keyOf(item.trace_id, item.entry_id));
+        if (membership && membership.phase_id === undefined) {
+          membership.phase_id = item.phase_id;
         }
-        return index > markerIndex;
       }
-      return true;
-    });
-    if (actionable.length === 0) {
-      return { processed: 0, bumps: 0 };
-    }
-    const groups = new Map;
-    let lastProcessedTimestamp;
-    let lastProcessedEventId;
-    for (const event of actionable) {
-      if (typeof event.timestamp === "string" && (!lastProcessedTimestamp || event.timestamp >= lastProcessedTimestamp)) {
-        lastProcessedTimestamp = event.timestamp;
-        lastProcessedEventId = event.event_id;
-      }
-      const kid = event.knowledge_id;
-      if (!kid)
-        continue;
-      const group = groups.get(kid) ?? [];
-      group.push(event);
-      groups.set(kid, group);
-    }
-    const deltas = [];
-    for (const [id, group] of groups) {
-      const positives = group.filter((event) => event.type === "applied").length;
-      const negatives = group.length - positives;
-      if (positives === 0 && negatives === 0)
-        continue;
-      const delta = positives > negatives ? VERDICT_CONFIDENCE_BOOST : -VERDICT_CONFIDENCE_DECAY;
-      deltas.push({
-        id,
-        delta,
-        receipt_events: group.map((event) => ({
-          event_id: event.event_id,
-          timestamp: event.timestamp,
-          outcome: event.type
-        }))
-      });
-    }
-    let bumps = 0;
-    if (deltas.length > 0) {
-      const { bumpKnowledgeConfidenceBatch } = await import("./knowledge-store-bw1dk2eb.js");
-      bumps = await bumpKnowledgeConfidenceBatch(directory, deltas, options?.floorOptions);
     }
     return {
-      processed: groups.size,
-      bumps,
-      lastProcessedTimestamp,
-      lastProcessedEventId
+      backfilled: items.length,
+      skipped,
+      journal_records: items.length > 0 ? 1 : 0
     };
-  } catch (err) {
-    warn(`[knowledge-events] applyKnowledgeVerdictFeedback failed (fail-open): ${err instanceof Error ? err.message : String(err)}`);
-    return { processed: 0, bumps: 0 };
-  }
-}
-var _internals4 = {
-  resolveKnowledgeEventsPath,
-  resolveKnowledgeCounterBaselinePath,
-  appendKnowledgeEvent,
-  recordKnowledgeEvent,
-  readKnowledgeEvents,
-  queryHistoricalOutcomes,
-  readCounterBaseline,
-  readLegacyApplicationRecords,
-  readKnowledgeCounterRollups,
-  readAuthoritativeKnowledgeCounterRollups,
-  effectiveRetrievalOutcomes,
-  recomputeCounters,
-  applyKnowledgeVerdictFeedback,
-  newTraceId,
-  newEventId,
-  resolveHiveEventsPath: resolveHiveEventsPath2,
-  appendHiveKnowledgeEvent,
-  recordHiveKnowledgeEvent,
-  readHiveKnowledgeEvents,
-  mergeRollupInto
+  });
+}
+var _internals3 = {
+  nowMs: () => Date.now(),
+  writeSnapshot,
+  atomicWriteFsynced,
+  appendFsynced,
+  commitApplicationMarkerBatch,
+  maxJournalRecords: MAX_JOURNAL_RECORDS,
+  maxArchiveRecords: MAX_ARCHIVE_RECORDS,
+  maxArchiveBytes: MAX_ARCHIVE_BYTES,
+  maxRepairQuarantineRecords: MAX_REPAIR_QUARANTINE_RECORDS
 };
 
-export { commitDisplayedMembership, commitEmptyRetrieval, commitGateReleaseBatch, queryLiveMemberships, queryHistoricalOutcomes, recordPhaseCloseIntent, reconcilePhaseClose, KNOWLEDGE_EVENT_SCHEMA_VERSION, MAX_EVENT_LOG_ENTRIES, RECEIPT_EVENT_TYPES, resolveKnowledgeEventsPath, resolveKnowledgeCounterBaselinePath, resolveHiveEventsPath2 as resolveHiveEventsPath, resolveLegacyApplicationLogPath, newTraceId, newEventId, appendKnowledgeEvent, appendKnowledgeEventsBatch, recordKnowledgeEvent, recordKnowledgeEventsBatch, appendHiveKnowledgeEvent, recordHiveKnowledgeEvent, readKnowledgeEvents, readHiveKnowledgeEvents, readLegacyApplicationRecords, MAX_VIOLATION_TIMESTAMPS, recomputeCounters, countViolationsInWindow, countEmptyTraceTerminals, countEntryViolationsInWindow, countEntryContradictionsInWindow, readKnowledgeCounterRollups, readAuthoritativeKnowledgeCounterRollups, effectiveRetrievalOutcomes, applyKnowledgeVerdictFeedback, _internals4 as _internals };
+export { extractContextDecisions, extractCurrentPhase, extractCurrentPhaseFromPlan, extractPhaseIdFromLabel, commitDisplayedMembership, commitEmptyRetrieval, commitGateReleaseBatch, queryLiveMemberships, queryHistoricalOutcomes, recordPhaseCloseIntent, reconcilePhaseClose, inspectMembershipPhaseIds, backfillMembershipPhaseIds };