memorix 1.2.6 → 1.2.8

package/dist/cli/index.js

@@ -3212,7 +3212,7 @@ ${import_picocolors.default.gray(m3)}  ${s2}
 
 // src/cli/version.ts
 function getCliVersion() {
-  return true ? "1.2.6" : pkg.version;
+  return true ? "1.2.8" : pkg.version;
 }
 var init_version = __esm({
   "src/cli/version.ts"() {
@@ -9304,6 +9304,7 @@ function getDatabase(dataDir) {
   db2.exec(CREATE_OBSERVATION_CODE_REFS_TABLE);
   db2.exec(CREATE_MAINTENANCE_JOBS_TABLE);
   db2.exec(CREATE_MAINTENANCE_TARGETS_TABLE);
+  db2.exec(CREATE_COMPACTION_CHECKPOINTS_TABLE);
   try {
     db2.exec(`ALTER TABLE mini_skills ADD COLUMN sourceSnapshot TEXT NOT NULL DEFAULT ''`);
   } catch {
@@ -9344,7 +9345,7 @@ function getDatabase(dataDir) {
   _dbCache.set(normalized, db2);
   return db2;
 }
-var BetterSqlite3, CREATE_OBSERVATIONS_TABLE, CREATE_MINI_SKILLS_TABLE, CREATE_SESSIONS_TABLE, CREATE_META_TABLE, CREATE_TEAM_AGENTS_TABLE, CREATE_TEAM_MESSAGES_TABLE, CREATE_TEAM_TASKS_TABLE, CREATE_TEAM_TASK_DEPS_TABLE, CREATE_TEAM_LOCKS_TABLE, CREATE_TEAM_ROLES_TABLE, CREATE_CHAT_TRANSCRIPT_TABLE, CREATE_GRAPH_ENTITIES_TABLE, CREATE_GRAPH_RELATIONS_TABLE, CREATE_CODE_FILES_TABLE, CREATE_CODE_SYMBOLS_TABLE, CREATE_CODE_EDGES_TABLE, CREATE_OBSERVATION_CODE_REFS_TABLE, CREATE_SCHEMA_MIGRATIONS_TABLE, CREATE_CODE_STATE_SNAPSHOTS_TABLE, CREATE_KNOWLEDGE_CLAIMS_TABLE, CREATE_KNOWLEDGE_CLAIM_EVIDENCE_TABLE, CREATE_KNOWLEDGE_CLAIM_EVENTS_TABLE, CREATE_KNOWLEDGE_WORKSPACES_TABLE, CREATE_KNOWLEDGE_PAGES_TABLE, CREATE_KNOWLEDGE_PAGE_CLAIMS_TABLE, CREATE_KNOWLEDGE_PAGE_LINKS_TABLE, CREATE_KNOWLEDGE_PROPOSALS_TABLE, CREATE_KNOWLEDGE_WORKFLOWS_TABLE, CREATE_KNOWLEDGE_WORKFLOW_RUNS_TABLE, CREATE_MAINTENANCE_JOBS_TABLE, CREATE_MAINTENANCE_TARGETS_TABLE, CREATE_INDEXES, SCHEMA_MIGRATIONS, _dbCache;
+var BetterSqlite3, CREATE_OBSERVATIONS_TABLE, CREATE_MINI_SKILLS_TABLE, CREATE_SESSIONS_TABLE, CREATE_META_TABLE, CREATE_TEAM_AGENTS_TABLE, CREATE_TEAM_MESSAGES_TABLE, CREATE_TEAM_TASKS_TABLE, CREATE_TEAM_TASK_DEPS_TABLE, CREATE_TEAM_LOCKS_TABLE, CREATE_TEAM_ROLES_TABLE, CREATE_CHAT_TRANSCRIPT_TABLE, CREATE_GRAPH_ENTITIES_TABLE, CREATE_GRAPH_RELATIONS_TABLE, CREATE_CODE_FILES_TABLE, CREATE_CODE_SYMBOLS_TABLE, CREATE_CODE_EDGES_TABLE, CREATE_OBSERVATION_CODE_REFS_TABLE, CREATE_SCHEMA_MIGRATIONS_TABLE, CREATE_CODE_STATE_SNAPSHOTS_TABLE, CREATE_KNOWLEDGE_CLAIMS_TABLE, CREATE_KNOWLEDGE_CLAIM_EVIDENCE_TABLE, CREATE_KNOWLEDGE_CLAIM_EVENTS_TABLE, CREATE_KNOWLEDGE_WORKSPACES_TABLE, CREATE_KNOWLEDGE_PAGES_TABLE, CREATE_KNOWLEDGE_PAGE_CLAIMS_TABLE, CREATE_KNOWLEDGE_PAGE_LINKS_TABLE, CREATE_KNOWLEDGE_PROPOSALS_TABLE, CREATE_KNOWLEDGE_WORKFLOWS_TABLE, CREATE_KNOWLEDGE_WORKFLOW_RUNS_TABLE, CREATE_MAINTENANCE_JOBS_TABLE, CREATE_MAINTENANCE_TARGETS_TABLE, CREATE_COMPACTION_CHECKPOINTS_TABLE, CREATE_INDEXES, SCHEMA_MIGRATIONS, _dbCache;
 var init_sqlite_db = __esm({
   "src/store/sqlite-db.ts"() {
     "use strict";
@@ -9796,6 +9797,31 @@ CREATE TABLE IF NOT EXISTS maintenance_targets (
   data_dir     TEXT NOT NULL,
   updated_at   INTEGER NOT NULL
 );
+`;
+    CREATE_COMPACTION_CHECKPOINTS_TABLE = `
+CREATE TABLE IF NOT EXISTS compaction_checkpoints (
+  id                   TEXT PRIMARY KEY,
+  project_id           TEXT NOT NULL,
+  session_id           TEXT NOT NULL,
+  agent                TEXT NOT NULL,
+  phase                TEXT NOT NULL,
+  capture_kind         TEXT NOT NULL,
+  reason               TEXT NOT NULL DEFAULT 'unknown',
+  source_event         TEXT NOT NULL,
+  source_key           TEXT NOT NULL,
+  summary              TEXT,
+  tokens_before        INTEGER,
+  first_kept_entry_id  TEXT,
+  details_json         TEXT NOT NULL DEFAULT '{}',
+  transcript_available INTEGER NOT NULL DEFAULT 0,
+  status               TEXT NOT NULL DEFAULT 'active',
+  pre_captured_at      TEXT NOT NULL,
+  completed_at         TEXT,
+  delivered_at         TEXT,
+  delivery_count       INTEGER NOT NULL DEFAULT 0,
+  created_at           TEXT NOT NULL,
+  updated_at           TEXT NOT NULL
+);
 `;
     CREATE_INDEXES = `
 CREATE INDEX IF NOT EXISTS idx_observations_projectId ON observations(projectId);
@@ -9843,6 +9869,9 @@ CREATE INDEX IF NOT EXISTS idx_knowledge_workflow_runs_project_workflow ON knowl
 CREATE INDEX IF NOT EXISTS idx_maintenance_jobs_ready ON maintenance_jobs(status, run_after);
 CREATE INDEX IF NOT EXISTS idx_maintenance_jobs_project ON maintenance_jobs(project_id, status, run_after);
 CREATE INDEX IF NOT EXISTS idx_maintenance_targets_updated ON maintenance_targets(updated_at);
+CREATE INDEX IF NOT EXISTS idx_compaction_checkpoints_project_recent ON compaction_checkpoints(project_id, status, completed_at DESC, pre_captured_at DESC);
+CREATE INDEX IF NOT EXISTS idx_compaction_checkpoints_session_pending ON compaction_checkpoints(project_id, session_id, agent, phase, status, pre_captured_at DESC);
+CREATE INDEX IF NOT EXISTS idx_compaction_checkpoints_source ON compaction_checkpoints(project_id, source_key);
 CREATE UNIQUE INDEX IF NOT EXISTS idx_maintenance_jobs_active_dedupe
   ON maintenance_jobs(project_id, kind, dedupe_key)
   WHERE status IN ('pending', 'running', 'retry');
@@ -9916,6 +9945,15 @@ CREATE UNIQUE INDEX IF NOT EXISTS idx_maintenance_jobs_active_dedupe
           db2.exec("CREATE INDEX IF NOT EXISTS idx_knowledge_workflows_workspace_status ON knowledge_workflows(workspaceId, status, updatedAt DESC)");
           db2.exec("CREATE INDEX IF NOT EXISTS idx_knowledge_workflow_runs_project_workflow ON knowledge_workflow_runs(projectId, workflowId, startedAt DESC)");
         }
+      },
+      {
+        id: "1.2.7-compaction-checkpoints",
+        apply: (db2) => {
+          db2.exec(CREATE_COMPACTION_CHECKPOINTS_TABLE);
+          db2.exec("CREATE INDEX IF NOT EXISTS idx_compaction_checkpoints_project_recent ON compaction_checkpoints(project_id, status, completed_at DESC, pre_captured_at DESC)");
+          db2.exec("CREATE INDEX IF NOT EXISTS idx_compaction_checkpoints_session_pending ON compaction_checkpoints(project_id, session_id, agent, phase, status, pre_captured_at DESC)");
+          db2.exec("CREATE INDEX IF NOT EXISTS idx_compaction_checkpoints_source ON compaction_checkpoints(project_id, source_key)");
+        }
       }
     ];
     _dbCache = /* @__PURE__ */ new Map();
@@ -17146,6 +17184,10 @@ var init_maintenance_jobs = __esm({
         LIMIT 1
       `).get(input.projectId, input.kind, dedupeKey);
           if (existing) {
+            if (input.kind === "vector-backfill" && existing.status === "retry") {
+              this.commit();
+              return rowToJob(existing);
+            }
             const nextRunAfter = Math.min(Number(existing.run_after), runAfter);
             this.db.prepare(`
           UPDATE maintenance_jobs
@@ -17156,6 +17198,26 @@ var init_maintenance_jobs = __esm({
             this.commit();
             return rowToJob(updated);
           }
+          if (input.kind === "vector-backfill") {
+            const failed = this.db.prepare(`
+          SELECT * FROM maintenance_jobs
+          WHERE project_id = ? AND kind = ? AND dedupe_key = ? AND status = 'failed'
+          ORDER BY updated_at DESC
+          LIMIT 1
+        `).get(input.projectId, input.kind, dedupeKey);
+            if (failed) {
+              this.db.prepare(`
+            UPDATE maintenance_jobs
+            SET status = 'pending', attempts = 0, max_attempts = ?, run_after = ?,
+                payload_json = ?, lease_owner = NULL, lease_expires_at = NULL,
+                last_error = NULL, completed_at = NULL, updated_at = ?
+            WHERE id = ?
+          `).run(maxAttempts, runAfter, payloadJson, now3, failed.id);
+              const revived = this.getRow(failed.id);
+              this.commit();
+              return rowToJob(revived);
+            }
+          }
           const id = randomUUID2();
           this.db.prepare(`
         INSERT INTO maintenance_jobs (
@@ -17327,15 +17389,42 @@ var init_maintenance_jobs = __esm({
         const now3 = options2.now ?? Date.now();
         const delayMs = Number.isFinite(options2.delayMs) ? Math.max(0, Math.floor(options2.delayMs)) : 0;
         const payloadJson = options2.payload === void 0 ? null : JSON.stringify(options2.payload);
+        const status = options2.status === "retry" ? "retry" : "pending";
+        const hasLastError = options2.lastError !== void 0;
+        const lastError = hasLastError ? errorText(options2.lastError) : null;
         this.db.prepare(`
       UPDATE maintenance_jobs
-      SET status = 'pending', run_after = ?, attempts = CASE WHEN ? THEN 0 ELSE attempts END,
+      SET status = ?, run_after = ?, attempts = CASE WHEN ? THEN 0 ELSE attempts END,
           payload_json = COALESCE(?, payload_json),
+          last_error = CASE
+            WHEN ? THEN NULL
+            WHEN ? THEN ?
+            ELSE last_error
+          END,
           lease_owner = NULL, lease_expires_at = NULL, updated_at = ?
       WHERE id = ? AND status = 'running' AND lease_owner = ?
-    `).run(now3 + delayMs, options2.resetAttempts ? 1 : 0, payloadJson, now3, id, workerId);
+    `).run(
+          status,
+          now3 + delayMs,
+          options2.resetAttempts ? 1 : 0,
+          payloadJson,
+          options2.clearLastError ? 1 : 0,
+          hasLastError ? 1 : 0,
+          lastError,
+          now3,
+          id,
+          workerId
+        );
         return this.get(id);
       }
+      resolveFailedVectorBackfills(projectId, dedupeKey = "vector-backfill", now3 = Date.now()) {
+        const result = this.db.prepare(`
+      UPDATE maintenance_jobs
+      SET status = 'completed', completed_at = ?, updated_at = ?
+      WHERE project_id = ? AND kind = 'vector-backfill' AND dedupe_key = ? AND status = 'failed'
+    `).run(now3, now3, projectId, dedupeKey);
+        return Number(result.changes ?? 0);
+      }
       fail(id, workerId, error2, now3 = Date.now()) {
         this.begin();
         try {
@@ -17431,6 +17520,9 @@ var init_maintenance_jobs = __esm({
                 delayMs: result.delayMs,
                 resetAttempts: result.resetAttempts,
                 payload: result.payload,
+                status: result.status,
+                lastError: result.lastError,
+                clearLastError: result.clearLastError,
                 now: now3
               });
               return { state: "rescheduled", job: updated2 };
@@ -18126,10 +18218,10 @@ var init_store = __esm({
         return row ? rowToSnapshot(row) : void 0;
       }
       listSnapshots(projectId, limit = 20) {
-        const safeLimit = Number.isFinite(limit) ? Math.max(1, Math.min(200, Math.floor(limit))) : 20;
+        const safeLimit2 = Number.isFinite(limit) ? Math.max(1, Math.min(200, Math.floor(limit))) : 20;
         return this.db.prepare(
           "SELECT * FROM code_state_snapshots WHERE projectId = ? ORDER BY sourceEpoch DESC LIMIT ?"
-        ).all(projectId, safeLimit).map(rowToSnapshot);
+        ).all(projectId, safeLimit2).map(rowToSnapshot);
       }
       /**
        * Record a completed scan and mark all current structural facts with its
@@ -18409,6 +18501,9 @@ function normalizeEmbeddingFailure(error2) {
     message: raw
   };
 }
+function vectorBackfillError(error2) {
+  return sanitizeCredentials(normalizeEmbeddingFailure(error2).message).slice(0, 1e3);
+}
 function queueVectorBackfill(projectId) {
   const dataDir = projectDir;
   if (!dataDir) return;
@@ -19164,17 +19259,53 @@ async function backfillVectorEmbeddings(options2 = {}) {
   let succeeded = 0;
   let failed = 0;
   let lastFailure;
+  const recordFailure = (message) => {
+    if (!lastFailure) lastFailure = message;
+  };
+  const candidates = [];
+  for (const id of ids) {
+    const observation = observationById.get(id);
+    if (!observation) {
+      vectorMissingIds.delete(id);
+      continue;
+    }
+    candidates.push({
+      id,
+      observation,
+      text: [observation.title, observation.narrative, ...observation.facts].join(" ")
+    });
+  }
   try {
-    for (const id of ids) {
-      const obs = observationById.get(id);
-      if (!obs) {
-        vectorMissingIds.delete(id);
-        continue;
+    if (candidates.length === 0) {
+      return { attempted: ids.length, succeeded, failed };
+    }
+    let embeddings = null;
+    try {
+      const provider2 = await getEmbeddingProvider();
+      if (!provider2) {
+        if (isEmbeddingExplicitlyDisabled()) {
+          for (const candidate2 of candidates) vectorMissingIds.delete(candidate2.id);
+        } else {
+          recordFailure("embedding provider unavailable");
+          failed += candidates.length;
+        }
+      } else {
+        embeddings = await provider2.embedBatch(candidates.map((candidate2) => candidate2.text));
       }
-      const text = [obs.title, obs.narrative, ...obs.facts].join(" ");
-      try {
-        const embedding = await generateEmbedding(text);
-        if (embedding) {
+    } catch (error2) {
+      recordFailure(vectorBackfillError(error2));
+      failed += candidates.length;
+    }
+    if (embeddings) {
+      for (let index = 0; index < candidates.length; index++) {
+        const { id, observation: obs } = candidates[index];
+        const embedding = embeddings[index];
+        if (!embedding || embedding.length === 0) {
+          recordFailure("embedding provider returned no vector");
+          failed++;
+          continue;
+        }
+        try {
           if (!isVectorCompatibleWithCurrentIndex(embedding)) {
             await upgradeVectorSchemaAfterFirstEmbedding(embedding);
           }
@@ -19183,7 +19314,7 @@ async function backfillVectorEmbeddings(options2 = {}) {
             console.error(
               `[memorix] Backfill embedding mismatch for obs-${id}: provider returned ${embedding.length}d, index expects ${vectorDimensions ?? "unknown"}d (kept in queue)`
             );
-            lastFailure = `dimension mismatch: provider returned ${embedding.length}d, index expects ${vectorDimensions ?? "unknown"}d`;
+            recordFailure(`dimension mismatch: provider returned ${embedding.length}d, index expects ${vectorDimensions ?? "unknown"}d`);
             failed++;
             continue;
           }
@@ -19222,15 +19353,10 @@ async function backfillVectorEmbeddings(options2 = {}) {
           await insertObservation(doc);
           vectorMissingIds.delete(id);
           succeeded++;
-        } else if (isEmbeddingExplicitlyDisabled()) {
-          vectorMissingIds.delete(id);
-        } else {
-          lastFailure = "embedding provider unavailable";
+        } catch (error2) {
+          recordFailure(vectorBackfillError(error2));
           failed++;
         }
-      } catch (err) {
-        lastFailure = err instanceof Error ? err.message : String(err);
-        failed++;
       }
     }
   } finally {
@@ -19243,7 +19369,12 @@ async function backfillVectorEmbeddings(options2 = {}) {
       finishedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
   }
-  return { attempted: ids.length, succeeded, failed };
+  return {
+    attempted: ids.length,
+    succeeded,
+    failed,
+    ...lastFailure ? { lastError: lastFailure } : {}
+  };
 }
 var observations, nextId, projectDir, searchIndexPrepared, vectorMissingIds, vectorBackfillRunning, vectorSchemaUpgradePromise, lastVectorBackfill, embeddingFailureLogTimestamps, EMBEDDING_FAILURE_LOG_COOLDOWN_MS;
 var init_observations = __esm({
@@ -27531,6 +27662,7 @@ __export(setup_exports, {
   installOpenClawBundlePackage: () => installOpenClawBundlePackage,
   installPiPackage: () => installPiPackage,
   installPluginPackage: () => installPluginPackage,
+  removeLegacyCodexMemorixMcpConfig: () => removeLegacyCodexMemorixMcpConfig,
   tryInstallCodexPlugin: () => tryInstallCodexPlugin
 });
 import { spawnSync } from "child_process";
@@ -27778,6 +27910,31 @@ function mergeTomlMcpConfig(existingContent, generatedContent) {
   return `${parts.join("\n\n")}
 `;
 }
+function isLegacyCodexMemorixNodeServer(server) {
+  if (server.name !== "memorix" || server.command.trim().toLowerCase() !== "node") return false;
+  const startsMemorixStdio = server.args.some((arg) => arg.trim().toLowerCase() === "serve");
+  const sourceEntry = server.args.some((arg) => {
+    const normalized = arg.replace(/\\/g, "/").toLowerCase();
+    return /\/memorix\/dist\/cli\/index\.(?:[cm]?js)$/.test(normalized);
+  });
+  return startsMemorixStdio && sourceEntry;
+}
+async function removeLegacyCodexMemorixMcpConfig(configPath = path17.join(homedir24(), ".codex", "config.toml")) {
+  let existingContent;
+  try {
+    existingContent = await readFile5(configPath, "utf-8");
+  } catch {
+    return { configPath, removed: false };
+  }
+  const adapter = new CodexMCPAdapter();
+  const legacyServer = adapter.parse(existingContent).find(isLegacyCodexMemorixNodeServer);
+  if (!legacyServer) return { configPath, removed: false };
+  let nextContent = removeTomlSection(existingContent, "mcp_servers.memorix.env");
+  nextContent = removeTomlSection(nextContent, "mcp_servers.memorix");
+  await writeFile5(configPath, nextContent ? `${nextContent}
+` : "", "utf-8");
+  return { configPath, removed: true };
+}
 function mergeYamlMcpConfig(existingContent, generatedContent) {
   let existing = {};
   try {
@@ -28259,6 +28416,16 @@ async function installAgentSetup(agent, plan, global2) {
       const install = tryInstallCodexPlugin();
       if (install.ok) v3.success(install.message);
       else v3.warn(install.message);
+      if (install.ok) {
+        try {
+          const migration = await removeLegacyCodexMemorixMcpConfig();
+          if (migration.removed) {
+            v3.info(`codex: removed legacy source-path MCP config from ${migration.configPath}`);
+          }
+        } catch {
+          v3.warn("codex: plugin installed, but the legacy MCP config could not be checked");
+        }
+      }
     } else if (agent === "claude" && result.marketplaceRoot) {
       const install = tryInstallClaudePlugin(result.marketplaceRoot);
       if (install.ok) v3.success(install.message);
@@ -34934,7 +35101,7 @@ function renderTaskWorksetPrompt(input) {
   });
   appendLine(lines, "Task lens: " + input.lens, maxTokens, omitted, "lens");
   const hasContinuation = Boolean(
-    input.continuation?.previousSession || (input.continuation?.memories.length ?? 0) > 0
+    input.continuation?.previousSession || (input.continuation?.memories.length ?? 0) > 0 || input.continuation?.compactCheckpoint
   );
   if (hasContinuation && input.continuation) {
     appendLine(lines, "", maxTokens, omitted, "continuation-heading");
@@ -34974,6 +35141,24 @@ function renderTaskWorksetPrompt(input) {
         }
       );
     }
+    if (input.continuation.compactCheckpoint) {
+      const checkpoint = input.continuation.compactCheckpoint;
+      const source = `${checkpoint.agent}, ${checkpoint.captureKind}, ${checkpoint.reason}`;
+      appendLine(
+        lines,
+        "- Recent host compact checkpoint (" + source + "): " + short(checkpoint.summary, 36),
+        maxTokens,
+        omitted,
+        "continuation-compact-checkpoint",
+        selected,
+        {
+          kind: "continuation",
+          id: "compact:" + checkpoint.id,
+          reason: "recent host-native compact lifecycle evidence",
+          trust: "historical"
+        }
+      );
+    }
   }
   if (input.cautions.length > 0 || input.cautionMemory.length > 0) {
     appendLine(lines, "", maxTokens, omitted, "caution-heading");
@@ -35243,7 +35428,7 @@ async function buildTaskWorkset(input) {
     ...input.verificationHints
   ]).slice(0, 4);
   const normalizedCautions = unique(cautions.map((caution) => caution.kind)).map((kind) => cautions.find((caution) => caution.kind === kind)).slice(0, 6);
-  const continuation = input.continuation && (input.continuation.previousSession || input.continuation.memories.length > 0) ? {
+  const continuation = input.continuation && (input.continuation.previousSession || input.continuation.memories.length > 0 || input.continuation.compactCheckpoint) ? {
     ...input.continuation.previousSession ? {
       previousSession: {
         ...input.continuation.previousSession,
@@ -35254,7 +35439,13 @@ async function buildTaskWorkset(input) {
       ...memory,
       title: short(memory.title, 20),
       ...memory.detail ? { detail: short(memory.detail, CONTINUATION_DETAIL_TOKEN_BUDGET) } : {}
-    }))
+    })),
+    ...input.continuation.compactCheckpoint ? {
+      compactCheckpoint: {
+        ...input.continuation.compactCheckpoint,
+        summary: short(input.continuation.compactCheckpoint.summary, 44)
+      }
+    } : {}
   } : void 0;
   const base = {
     version: "1.2",
@@ -37477,6 +37668,311 @@ var init_session = __esm({
   }
 });
 
+// src/store/compaction-checkpoint-store.ts
+var compaction_checkpoint_store_exports = {};
+__export(compaction_checkpoint_store_exports, {
+  CompactionCheckpointStore: () => CompactionCheckpointStore
+});
+import { createHash as createHash10, randomUUID as randomUUID9 } from "crypto";
+function optionalText5(value) {
+  return typeof value === "string" && value ? value : void 0;
+}
+function optionalNumber2(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function parseDetails(value) {
+  if (typeof value !== "string" || !value) return void 0;
+  try {
+    const parsed = JSON.parse(value);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function sanitizeSummary(value) {
+  if (!value?.trim()) return void 0;
+  return sanitizeCredentials(value).slice(0, MAX_SUMMARY_CHARS).trim() || void 0;
+}
+function sanitizeDetails(value) {
+  if (!value) return void 0;
+  try {
+    const sanitized = sanitizeCredentials(JSON.stringify(value));
+    if (sanitized.length > MAX_DETAILS_CHARS) return { truncated: true };
+    const parsed = JSON.parse(sanitized);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : void 0;
+  } catch {
+    return { unavailable: true };
+  }
+}
+function sourceKeyFor(input, summary) {
+  if (input.sourceKey?.trim()) return input.sourceKey.trim().slice(0, 300);
+  const material = [
+    input.projectId,
+    input.sessionId,
+    input.agent,
+    input.sourceEvent,
+    summary ?? "",
+    input.tokensBefore ?? "",
+    input.firstKeptEntryId ?? ""
+  ].join("\0");
+  return `derived:${createHash10("sha256").update(material).digest("hex").slice(0, 32)}`;
+}
+function rowToCheckpoint(row) {
+  return {
+    id: row.id,
+    projectId: row.project_id,
+    sessionId: row.session_id,
+    agent: row.agent,
+    phase: row.phase,
+    captureKind: row.capture_kind,
+    reason: row.reason,
+    sourceEvent: row.source_event,
+    sourceKey: row.source_key,
+    ...optionalText5(row.summary) ? { summary: row.summary } : {},
+    ...optionalNumber2(row.tokens_before) !== void 0 ? { tokensBefore: Number(row.tokens_before) } : {},
+    ...optionalText5(row.first_kept_entry_id) ? { firstKeptEntryId: row.first_kept_entry_id } : {},
+    ...parseDetails(row.details_json) ? { details: parseDetails(row.details_json) } : {},
+    transcriptAvailable: Boolean(row.transcript_available),
+    status: row.status,
+    preCapturedAt: row.pre_captured_at,
+    ...optionalText5(row.completed_at) ? { completedAt: row.completed_at } : {},
+    ...optionalText5(row.delivered_at) ? { deliveredAt: row.delivered_at } : {},
+    deliveryCount: Number(row.delivery_count ?? 0),
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function safeReason(value) {
+  return value === "manual" || value === "auto" ? value : "unknown";
+}
+function safeLimit(value, fallback) {
+  if (!Number.isFinite(value) || value == null) return fallback;
+  return Math.max(1, Math.min(500, Math.floor(value)));
+}
+var MAX_SUMMARY_CHARS, MAX_DETAILS_CHARS, CompactionCheckpointStore;
+var init_compaction_checkpoint_store = __esm({
+  "src/store/compaction-checkpoint-store.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_secret_filter();
+    init_sqlite_db();
+    MAX_SUMMARY_CHARS = 24e3;
+    MAX_DETAILS_CHARS = 4e3;
+    CompactionCheckpointStore = class {
+      db;
+      constructor(dataDir) {
+        this.db = getDatabase(dataDir);
+      }
+      recordPreflight(input) {
+        const pending = this.db.prepare(`
+      SELECT * FROM compaction_checkpoints
+      WHERE project_id = ? AND session_id = ? AND agent = ?
+        AND phase = 'pre' AND status = 'active'
+      ORDER BY pre_captured_at DESC, created_at DESC
+      LIMIT 1
+    `).get(input.projectId, input.sessionId, input.agent);
+        if (pending) return rowToCheckpoint(pending);
+        const now3 = input.capturedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+        const checkpoint = {
+          id: randomUUID9(),
+          projectId: input.projectId,
+          sessionId: input.sessionId,
+          agent: input.agent,
+          phase: "pre",
+          captureKind: "preflight",
+          reason: safeReason(input.reason),
+          sourceEvent: input.sourceEvent,
+          sourceKey: `pre:${randomUUID9()}`,
+          transcriptAvailable: Boolean(input.transcriptAvailable),
+          status: "active",
+          preCapturedAt: now3,
+          deliveryCount: 0,
+          createdAt: now3,
+          updatedAt: now3
+        };
+        this.insert(checkpoint);
+        return checkpoint;
+      }
+      complete(input) {
+        const completedAt = input.completedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+        const summary = sanitizeSummary(input.summary);
+        const pending = this.db.prepare(`
+      SELECT * FROM compaction_checkpoints
+      WHERE project_id = ? AND session_id = ? AND agent = ?
+        AND phase = 'pre' AND status = 'active'
+      ORDER BY pre_captured_at DESC, created_at DESC
+      LIMIT 1
+    `).get(input.projectId, input.sessionId, input.agent);
+        if (!input.sourceKey?.trim() && !summary && input.tokensBefore === void 0 && !input.firstKeptEntryId && !pending) {
+          const priorLifecycle = this.db.prepare(`
+        SELECT * FROM compaction_checkpoints
+        WHERE project_id = ? AND session_id = ? AND agent = ?
+          AND phase = 'complete' AND capture_kind = 'lifecycle'
+          AND source_event = ? AND status = 'active'
+        ORDER BY completed_at DESC, created_at DESC
+        LIMIT 1
+      `).get(input.projectId, input.sessionId, input.agent, input.sourceEvent);
+          if (priorLifecycle) return rowToCheckpoint(priorLifecycle);
+        }
+        const sourceKey = input.sourceKey?.trim() ? input.sourceKey.trim().slice(0, 300) : pending ? `lifecycle:${pending.id}` : sourceKeyFor(input, summary);
+        const existing = this.db.prepare(`
+      SELECT * FROM compaction_checkpoints
+      WHERE project_id = ? AND source_key = ?
+      LIMIT 1
+    `).get(input.projectId, sourceKey);
+        if (existing) return rowToCheckpoint(existing);
+        const captureKind = summary ? "native-summary" : "lifecycle";
+        const details = sanitizeDetails(input.details);
+        if (pending) {
+          const checkpoint2 = rowToCheckpoint(pending);
+          const nextReason = safeReason(input.reason) === "unknown" ? checkpoint2.reason : safeReason(input.reason);
+          this.db.prepare(`
+        UPDATE compaction_checkpoints
+        SET phase = 'complete', capture_kind = ?, reason = ?, source_event = ?, source_key = ?,
+            summary = ?, tokens_before = ?, first_kept_entry_id = ?, details_json = ?,
+            completed_at = ?, updated_at = ?
+        WHERE id = ?
+      `).run(
+            captureKind,
+            nextReason,
+            input.sourceEvent,
+            sourceKey,
+            summary ?? null,
+            input.tokensBefore ?? null,
+            input.firstKeptEntryId ?? null,
+            JSON.stringify(details ?? {}),
+            completedAt,
+            completedAt,
+            checkpoint2.id
+          );
+          return this.get(checkpoint2.id);
+        }
+        const checkpoint = {
+          id: randomUUID9(),
+          projectId: input.projectId,
+          sessionId: input.sessionId,
+          agent: input.agent,
+          phase: "complete",
+          captureKind,
+          reason: safeReason(input.reason),
+          sourceEvent: input.sourceEvent,
+          sourceKey,
+          ...summary ? { summary } : {},
+          ...input.tokensBefore !== void 0 ? { tokensBefore: input.tokensBefore } : {},
+          ...input.firstKeptEntryId ? { firstKeptEntryId: input.firstKeptEntryId } : {},
+          ...details ? { details } : {},
+          transcriptAvailable: false,
+          status: "active",
+          preCapturedAt: completedAt,
+          completedAt,
+          deliveryCount: 0,
+          createdAt: completedAt,
+          updatedAt: completedAt
+        };
+        this.insert(checkpoint);
+        return checkpoint;
+      }
+      get(id) {
+        const row = this.db.prepare("SELECT * FROM compaction_checkpoints WHERE id = ?").get(id);
+        return row ? rowToCheckpoint(row) : void 0;
+      }
+      list(options2) {
+        const conditions = ["project_id = ?"];
+        const values = [options2.projectId];
+        if (options2.sessionId) {
+          conditions.push("session_id = ?");
+          values.push(options2.sessionId);
+        }
+        if (options2.agent) {
+          conditions.push("agent = ?");
+          values.push(options2.agent);
+        }
+        if (!options2.includeArchived) {
+          conditions.push("status = 'active'");
+        }
+        const rows = this.db.prepare(`
+      SELECT * FROM compaction_checkpoints
+      WHERE ${conditions.join(" AND ")}
+      ORDER BY COALESCE(completed_at, pre_captured_at) DESC, created_at DESC
+      LIMIT ?
+    `).all(...values, safeLimit(options2.limit, 20));
+        return rows.map(rowToCheckpoint);
+      }
+      findUndelivered(projectId, sessionId, agent) {
+        const row = this.db.prepare(`
+      SELECT * FROM compaction_checkpoints
+      WHERE project_id = ? AND session_id = ? AND agent = ?
+        AND phase = 'complete' AND status = 'active' AND delivered_at IS NULL
+      ORDER BY completed_at DESC, created_at DESC
+      LIMIT 1
+    `).get(projectId, sessionId, agent);
+        return row ? rowToCheckpoint(row) : void 0;
+      }
+      findLatestCompleted(projectId, options2 = {}) {
+        const excludeSession = options2.excludeSession;
+        const exclusion = excludeSession ? " AND NOT (session_id = ? AND agent = ? )" : "";
+        const values = excludeSession ? [projectId, excludeSession.sessionId, excludeSession.agent] : [projectId];
+        const row = this.db.prepare(`
+      SELECT * FROM compaction_checkpoints
+      WHERE project_id = ? AND phase = 'complete' AND status = 'active'
+      ${exclusion}
+      ORDER BY completed_at DESC, created_at DESC
+      LIMIT 1
+    `).get(...values);
+        return row ? rowToCheckpoint(row) : void 0;
+      }
+      archive(id, archivedAt = (/* @__PURE__ */ new Date()).toISOString()) {
+        const result = this.db.prepare(`
+      UPDATE compaction_checkpoints
+      SET status = 'archived', updated_at = ?
+      WHERE id = ? AND status = 'active'
+    `).run(archivedAt, id);
+        return Number(result.changes ?? 0) > 0 ? this.get(id) : void 0;
+      }
+      markDelivered(id, deliveredAt = (/* @__PURE__ */ new Date()).toISOString()) {
+        const result = this.db.prepare(`
+      UPDATE compaction_checkpoints
+      SET delivered_at = ?, delivery_count = delivery_count + 1, updated_at = ?
+      WHERE id = ? AND phase = 'complete' AND status = 'active' AND delivered_at IS NULL
+    `).run(deliveredAt, deliveredAt, id);
+        return Number(result.changes ?? 0) > 0 ? this.get(id) : void 0;
+      }
+      insert(checkpoint) {
+        this.db.prepare(`
+      INSERT INTO compaction_checkpoints (
+        id, project_id, session_id, agent, phase, capture_kind, reason,
+        source_event, source_key, summary, tokens_before, first_kept_entry_id,
+        details_json, transcript_available, status, pre_captured_at, completed_at,
+        delivered_at, delivery_count, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(
+          checkpoint.id,
+          checkpoint.projectId,
+          checkpoint.sessionId,
+          checkpoint.agent,
+          checkpoint.phase,
+          checkpoint.captureKind,
+          checkpoint.reason,
+          checkpoint.sourceEvent,
+          checkpoint.sourceKey,
+          checkpoint.summary ?? null,
+          checkpoint.tokensBefore ?? null,
+          checkpoint.firstKeptEntryId ?? null,
+          JSON.stringify(checkpoint.details ?? {}),
+          checkpoint.transcriptAvailable ? 1 : 0,
+          checkpoint.status,
+          checkpoint.preCapturedAt,
+          checkpoint.completedAt ?? null,
+          checkpoint.deliveredAt ?? null,
+          checkpoint.deliveryCount,
+          checkpoint.createdAt,
+          checkpoint.updatedAt
+        );
+      }
+    };
+  }
+});
+
 // src/codegraph/auto-context.ts
 var auto_context_exports = {};
 __export(auto_context_exports, {
@@ -37662,6 +38158,22 @@ async function buildAutoProjectContext(input) {
   if (continuationRequested) {
     await initSessionStore(input.dataDir);
     continuation = await getSessionResumeBrief(input.project.id, task, input.reader);
+    const { CompactionCheckpointStore: CompactionCheckpointStore2 } = await Promise.resolve().then(() => (init_compaction_checkpoint_store(), compaction_checkpoint_store_exports));
+    const checkpoint = new CompactionCheckpointStore2(input.dataDir).findLatestCompleted(
+      input.project.id,
+      input.excludeCompactionCheckpointFor ? { excludeSession: input.excludeCompactionCheckpointFor } : void 0
+    );
+    const completedAtMs = checkpoint ? Date.parse(checkpoint.completedAt ?? checkpoint.preCapturedAt) : Number.NaN;
+    if (checkpoint && Number.isFinite(completedAtMs) && completedAtMs <= now3.getTime() && now3.getTime() - completedAtMs <= COMPACT_CHECKPOINT_MAX_AGE_MS) {
+      continuation.compactCheckpoint = {
+        id: checkpoint.id,
+        agent: checkpoint.agent,
+        captureKind: checkpoint.captureKind === "native-summary" ? "native-summary" : "lifecycle",
+        reason: checkpoint.reason,
+        ...checkpoint.completedAt ? { completedAt: checkpoint.completedAt } : {},
+        summary: checkpoint.summary ?? "The host completed context compaction without exposing a native summary. Reconstruct only what the current task needs from current code and durable evidence."
+      };
+    }
   }
   const workset = await buildTaskWorkset({
     projectId: input.project.id,
@@ -37870,7 +38382,7 @@ function formatAutoProjectContextSummary(context) {
     reliableSources.length > 0 ? `- ${reliableSources.length} current code-bound memory link(s)` : "- none yet"
   );
   const continuation = context.workset.continuation;
-  if (continuation?.previousSession || continuation?.memories.length) {
+  if (continuation?.previousSession || continuation?.memories.length || continuation?.compactCheckpoint) {
     lines.push("", "Resume from prior work");
     if (continuation.previousSession) {
       const session = continuation.previousSession;
@@ -37885,6 +38397,12 @@ function formatAutoProjectContextSummary(context) {
         "- #" + memory.id + " " + memory.type + ": " + compactContinuationText(memory.title, 18) + detail
       );
     }
+    if (continuation.compactCheckpoint) {
+      const checkpoint = continuation.compactCheckpoint;
+      lines.push(
+        "- Recent host compact checkpoint (" + [checkpoint.agent, checkpoint.captureKind, checkpoint.reason].join(", ") + "): " + compactContinuationText(checkpoint.summary, 36)
+      );
+    }
   }
   return lines.join("\n");
 }
@@ -37951,7 +38469,7 @@ function formatLegacyAutoProjectContextPrompt(context) {
   );
   return lines.join("\n");
 }
-var DEFAULT_MAX_AGE_MS;
+var DEFAULT_MAX_AGE_MS, COMPACT_CHECKPOINT_MAX_AGE_MS;
 var init_auto_context = __esm({
   "src/codegraph/auto-context.ts"() {
     "use strict";
@@ -37971,6 +38489,7 @@ var init_auto_context = __esm({
     init_session_store();
     init_task_lens();
     DEFAULT_MAX_AGE_MS = 10 * 60 * 1e3;
+    COMPACT_CHECKPOINT_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
   }
 });
 
@@ -38235,7 +38754,7 @@ function addDefaultVerificationHints(input) {
   return uniq2(hints);
 }
 function selectRelevantObservations(observations2, task, limit) {
-  const safeLimit = Number.isFinite(limit) && limit > 0 ? Math.floor(limit) : 20;
+  const safeLimit2 = Number.isFinite(limit) && limit > 0 ? Math.floor(limit) : 20;
   const taskTokens2 = tokenize4(task);
   const ranked = observations2.map((observation, index) => ({
     observation,
@@ -38245,7 +38764,7 @@ function selectRelevantObservations(observations2, task, limit) {
   }));
   const positives = ranked.filter((item) => item.score > 0);
   const pool = positives.length > 0 ? positives : ranked;
-  return pool.sort((a3, b3) => b3.score - a3.score || b3.time - a3.time || b3.index - a3.index).slice(0, safeLimit).map((item) => item.observation);
+  return pool.sort((a3, b3) => b3.score - a3.score || b3.time - a3.time || b3.index - a3.index).slice(0, safeLimit2).map((item) => item.observation);
 }
 function assembleContextPackForTask(input) {
   const selected = selectRelevantObservations(input.observations, input.task, input.limit ?? 20);
@@ -38642,12 +39161,277 @@ ${formatUsageHint()}`;
   }
 });
 
+// src/memory/compaction.ts
+var compaction_exports = {};
+__export(compaction_exports, {
+  buildCompactionWorkset: () => buildCompactionWorkset,
+  captureCompactionCheckpoint: () => captureCompactionCheckpoint,
+  consumeCompactionWorkset: () => consumeCompactionWorkset
+});
+function normalizeBudget(value) {
+  if (!Number.isFinite(value) || value == null) return DEFAULT_WORKSET_BUDGET;
+  return Math.max(MIN_WORKSET_BUDGET, Math.min(2e3, Math.floor(value)));
+}
+function sourceLabel(checkpoint) {
+  if (checkpoint.captureKind === "native-summary") return "native host summary";
+  if (checkpoint.captureKind === "preflight") return "pre-compact lifecycle marker";
+  return "host lifecycle marker";
+}
+function buildCompactionWorkset(checkpoint, options2 = {}) {
+  const budget = normalizeBudget(options2.maxTokens);
+  const task = options2.task?.trim() ? truncateToTokenBudget(sanitizeCredentials(options2.task.trim()), Math.max(8, Math.floor(budget * 0.25))) : "";
+  const headerLines = [
+    "## Compact Continuation",
+    `- Host: ${checkpoint.agent} (${sourceLabel(checkpoint)})`,
+    `- Trigger: ${checkpoint.reason}`,
+    task ? `- Task now: ${task}` : "",
+    "- Current code remains authoritative."
+  ].filter(Boolean);
+  const header = `${headerLines.join("\n")}
+
+`;
+  const fallback = checkpoint.captureKind === "native-summary" ? "" : "The host did not expose a native compact summary. Reconstruct only what the current task needs from current code and Memorix evidence.";
+  const source = sanitizeCredentials(checkpoint.summary?.trim() || fallback);
+  const available = Math.max(0, budget - countTextTokens(header) - 4);
+  let excerpt = source ? truncateToTokenBudget(source, available) : "";
+  let text = `${header}${excerpt ? `### Host checkpoint
+${excerpt}` : ""}`.trim();
+  while (excerpt && countTextTokens(text) > budget) {
+    const nextExcerptBudget = Math.max(1, Math.floor(countTextTokens(excerpt) * 0.8));
+    excerpt = truncateToTokenBudget(excerpt, nextExcerptBudget);
+    text = `${header}${excerpt ? `### Host checkpoint
+${excerpt}` : ""}`.trim();
+  }
+  if (countTextTokens(text) > budget) text = truncateToTokenBudget(text, budget);
+  return {
+    checkpointId: checkpoint.id,
+    text,
+    tokens: countTextTokens(text)
+  };
+}
+function sourceEvent(input) {
+  const raw = input.raw;
+  const event = raw.hook_event_name ?? raw.event ?? raw.type;
+  return typeof event === "string" && event ? event : input.event;
+}
+async function captureCompactionCheckpoint(input) {
+  const isCompactResume = input.event === "session_start" && input.sessionStartReason?.trim().toLowerCase() === "compact";
+  if (input.event !== "pre_compact" && input.event !== "post_compact" && !isCompactResume) return null;
+  if (!input.sessionId || !input.cwd) return null;
+  const [
+    { detectProject: detectProject2 },
+    { getProjectDataDir: getProjectDataDir2 },
+    { initAliasRegistry: initAliasRegistry2, registerAlias: registerAlias2 }
+  ] = await Promise.all([
+    Promise.resolve().then(() => (init_detector(), detector_exports)),
+    Promise.resolve().then(() => (init_persistence(), persistence_exports)),
+    Promise.resolve().then(() => (init_aliases(), aliases_exports))
+  ]);
+  const project = detectProject2(input.cwd);
+  if (!project) return null;
+  const dataDir = await getProjectDataDir2(project.id);
+  initAliasRegistry2(dataDir);
+  const projectId = await registerAlias2(project);
+  const store2 = new CompactionCheckpointStore(dataDir);
+  if (input.event === "pre_compact") {
+    return store2.recordPreflight({
+      projectId,
+      sessionId: input.sessionId,
+      agent: input.agent,
+      reason: input.compaction?.reason,
+      sourceEvent: sourceEvent(input),
+      transcriptAvailable: Boolean(input.transcriptPath),
+      capturedAt: input.timestamp
+    });
+  }
+  return store2.complete({
+    projectId,
+    sessionId: input.sessionId,
+    agent: input.agent,
+    reason: input.compaction?.reason,
+    sourceEvent: sourceEvent(input),
+    sourceKey: input.compaction?.sourceKey,
+    summary: input.compaction?.summary,
+    tokensBefore: input.compaction?.tokensBefore,
+    firstKeptEntryId: input.compaction?.firstKeptEntryId,
+    details: input.compaction?.details,
+    completedAt: input.timestamp
+  });
+}
+async function consumeCompactionWorkset(input, options2 = {}) {
+  if (!input.sessionId || !input.cwd) return null;
+  const [
+    { detectProject: detectProject2 },
+    { getProjectDataDir: getProjectDataDir2 },
+    { initAliasRegistry: initAliasRegistry2, registerAlias: registerAlias2 }
+  ] = await Promise.all([
+    Promise.resolve().then(() => (init_detector(), detector_exports)),
+    Promise.resolve().then(() => (init_persistence(), persistence_exports)),
+    Promise.resolve().then(() => (init_aliases(), aliases_exports))
+  ]);
+  const project = detectProject2(input.cwd);
+  if (!project) return null;
+  const dataDir = await getProjectDataDir2(project.id);
+  initAliasRegistry2(dataDir);
+  const projectId = await registerAlias2(project);
+  const store2 = new CompactionCheckpointStore(dataDir);
+  const checkpoint = store2.findUndelivered(projectId, input.sessionId, input.agent);
+  if (!checkpoint) return null;
+  const workset = buildCompactionWorkset(checkpoint, options2);
+  if (!workset.text) return null;
+  store2.markDelivered(checkpoint.id);
+  return workset;
+}
+var DEFAULT_WORKSET_BUDGET, MIN_WORKSET_BUDGET;
+var init_compaction = __esm({
+  "src/memory/compaction.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_token_budget();
+    init_secret_filter();
+    init_compaction_checkpoint_store();
+    DEFAULT_WORKSET_BUDGET = 420;
+    MIN_WORKSET_BUDGET = 48;
+  }
+});
+
+// src/cli/commands/checkpoint.ts
+var checkpoint_exports = {};
+__export(checkpoint_exports, {
+  default: () => checkpoint_default
+});
+async function getCheckpointContext() {
+  const context = await getCliProjectContext();
+  const { initAliasRegistry: initAliasRegistry2, registerAlias: registerAlias2 } = await Promise.resolve().then(() => (init_aliases(), aliases_exports));
+  initAliasRegistry2(context.dataDir);
+  const canonicalId = await registerAlias2(context.project);
+  return {
+    ...context,
+    project: { ...context.project, id: canonicalId },
+    store: new CompactionCheckpointStore(context.dataDir)
+  };
+}
+function assertProjectCheckpoint(checkpoint, projectId, id) {
+  if (!checkpoint || checkpoint.projectId !== projectId) {
+    throw new Error(`No compact checkpoint "${id}" exists for this project.`);
+  }
+  return checkpoint;
+}
+function formatCheckpoint(checkpoint) {
+  const completion = checkpoint.completedAt ? `, completed ${checkpoint.completedAt}` : "";
+  const delivery = checkpoint.deliveredAt ? `, delivered ${checkpoint.deliveryCount}x` : "";
+  return [
+    `${shortId(checkpoint.id)} ${checkpoint.phase} ${checkpoint.agent} (${checkpoint.captureKind}, ${checkpoint.reason})`,
+    `  session: ${checkpoint.sessionId}`,
+    `  source: ${checkpoint.sourceEvent}${completion}${delivery}`,
+    `  status: ${checkpoint.status}${checkpoint.transcriptAvailable ? ", transcript marker available" : ""}`,
+    ...checkpoint.summary ? [`  summary: ${checkpoint.summary.replace(/\s+/g, " ").slice(0, 220)}`] : []
+  ].join("\n");
+}
+function usage() {
+  console.log("Memorix Compact Checkpoints");
+  console.log("");
+  console.log("Usage:");
+  console.log("  memorix checkpoint list [--session <id>] [--agent <name>] [--all]");
+  console.log("  memorix checkpoint show --id <checkpoint-id>");
+  console.log('  memorix checkpoint context [--id <checkpoint-id>] [--task "..."] [--budget 420]');
+  console.log("  memorix checkpoint archive --id <checkpoint-id>");
+}
+var checkpoint_default;
+var init_checkpoint = __esm({
+  "src/cli/commands/checkpoint.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_dist2();
+    init_compaction();
+    init_compaction_checkpoint_store();
+    init_operator_shared();
+    checkpoint_default = defineCommand({
+      meta: {
+        name: "checkpoint",
+        description: "Inspect and manage native compact continuity checkpoints"
+      },
+      args: {
+        id: { type: "string", description: "Checkpoint ID" },
+        session: { type: "string", description: "Filter by host session ID" },
+        agent: { type: "string", description: "Filter by host agent name" },
+        task: { type: "string", description: "Current task for a bounded continuation workset" },
+        budget: { type: "string", description: "Maximum workset token budget (default: 420)" },
+        limit: { type: "string", description: "Maximum checkpoints to list (default: 20)" },
+        all: { type: "boolean", description: "Include archived checkpoints in list output" },
+        json: { type: "boolean", description: "Emit machine-readable JSON output" }
+      },
+      run: async ({ args }) => {
+        const positional = args._ ?? [];
+        const action = (positional[0] ?? "list").toLowerCase();
+        const asJson = Boolean(args.json);
+        try {
+          const { project, store: store2 } = await getCheckpointContext();
+          const id = args.id?.trim();
+          switch (action) {
+            case "list": {
+              const checkpoints = store2.list({
+                projectId: project.id,
+                sessionId: args.session?.trim() || void 0,
+                agent: args.agent?.trim() || void 0,
+                includeArchived: Boolean(args.all),
+                limit: parsePositiveInt(args.limit, 20)
+              });
+              emitResult(
+                { project, checkpoints },
+                checkpoints.length ? checkpoints.map(formatCheckpoint).join("\n\n") : "No compact checkpoints for this project.",
+                asJson
+              );
+              return;
+            }
+            case "show": {
+              if (!id) throw new Error('id is required for "memorix checkpoint show".');
+              const checkpoint = assertProjectCheckpoint(store2.get(id), project.id, id);
+              emitResult({ project, checkpoint }, formatCheckpoint(checkpoint), asJson);
+              return;
+            }
+            case "context": {
+              const checkpoint = id ? assertProjectCheckpoint(store2.get(id), project.id, id) : store2.list({
+                projectId: project.id,
+                sessionId: args.session?.trim() || void 0,
+                agent: args.agent?.trim() || void 0,
+                limit: parsePositiveInt(args.limit, 20)
+              }).find((entry) => entry.phase === "complete");
+              if (!checkpoint) {
+                throw new Error("No completed compact checkpoint is available for this project and filter.");
+              }
+              const workset = buildCompactionWorkset(checkpoint, {
+                task: args.task?.trim(),
+                maxTokens: parsePositiveInt(args.budget, 420)
+              });
+              emitResult({ project, checkpoint, workset }, workset.text, asJson);
+              return;
+            }
+            case "archive": {
+              if (!id) throw new Error('id is required for "memorix checkpoint archive".');
+              assertProjectCheckpoint(store2.get(id), project.id, id);
+              const checkpoint = store2.archive(id);
+              if (!checkpoint) throw new Error(`Compact checkpoint "${id}" is already archived.`);
+              emitResult({ project, checkpoint }, `Archived compact checkpoint ${shortId(checkpoint.id)}.`, asJson);
+              return;
+            }
+            default:
+              usage();
+          }
+        } catch (error2) {
+          emitError(error2 instanceof Error ? error2.message : String(error2), asJson);
+        }
+      }
+    });
+  }
+});
+
 // src/knowledge/markdown.ts
-import { createHash as createHash10 } from "crypto";
+import { createHash as createHash11 } from "crypto";
 import { promises as fs16 } from "fs";
 import path23 from "path";
 function hashContent(content) {
-  return createHash10("sha256").update(content).digest("hex");
+  return createHash11("sha256").update(content).digest("hex");
 }
 function stringField(data, key) {
   const value = data[key];
@@ -38773,11 +39557,11 @@ __export(wiki_exports, {
   lintKnowledgeWorkspace: () => lintKnowledgeWorkspace,
   readKnowledgePage: () => readKnowledgePage
 });
-import { createHash as createHash11 } from "crypto";
+import { createHash as createHash12 } from "crypto";
 import { promises as fs17 } from "fs";
 import path24 from "path";
 function hash3(value) {
-  return createHash11("sha256").update(value).digest("hex");
+  return createHash12("sha256").update(value).digest("hex");
 }
 function now2() {
   return (/* @__PURE__ */ new Date()).toISOString();
@@ -39218,7 +40002,7 @@ function modeFrom(value) {
   if (value === "versioned") return "versioned";
   throw new Error("knowledge mode must be local or versioned");
 }
-function usage() {
+function usage2() {
   return [
     "Memorix Knowledge Commands",
     "",
@@ -39439,7 +40223,7 @@ var init_knowledge = __esm({
               );
               return;
             }
-            emitResult({ usage: usage() }, usage(), asJson);
+            emitResult({ usage: usage2() }, usage2(), asJson);
             return;
           }
           switch (action) {
@@ -39498,7 +40282,7 @@ var init_knowledge = __esm({
               return;
             }
             default:
-              emitResult({ usage: usage() }, usage(), asJson);
+              emitResult({ usage: usage2() }, usage2(), asJson);
           }
         } catch (error2) {
           emitError(error2 instanceof Error ? error2.message : String(error2), asJson);
@@ -46812,7 +47596,7 @@ __export(planner_exports, {
   materializeTaskGraph: () => materializeTaskGraph,
   seedAutonomousPipeline: () => seedAutonomousPipeline
 });
-import { randomUUID as randomUUID9 } from "crypto";
+import { randomUUID as randomUUID10 } from "crypto";
 function isPlannerTask(metadata) {
   if (!metadata) return null;
   try {
@@ -46870,7 +47654,7 @@ function seedAutonomousPipeline(teamStore, projectId, config2, opts) {
   const maxIterations = config2.maxIterations ?? 3;
   const taskBudget = config2.taskBudget ?? 15;
   const structuredPlan = opts?.structuredPlan ?? true;
-  const pipelineId = randomUUID9();
+  const pipelineId = randomUUID10();
   const meta = {
     plannerType: "plan",
     pipelineId,
@@ -47789,11 +48573,11 @@ __export(receipt_service_exports, {
   buildHandoffReceipt: () => buildHandoffReceipt,
   formatHandoffReceipt: () => formatHandoffReceipt
 });
-import { createHash as createHash12 } from "crypto";
+import { createHash as createHash13 } from "crypto";
 import { existsSync as existsSync16, readFileSync as readFileSync12 } from "fs";
 import path26 from "path";
 function sha256(value) {
-  return `sha256:${createHash12("sha256").update(value).digest("hex")}`;
+  return `sha256:${createHash13("sha256").update(value).digest("hex")}`;
 }
 function hashId(projectId, id) {
   return sha256(`${projectId}:obs:${id}`);
@@ -48039,6 +48823,7 @@ var init_tool_profile = __esm({
       memorix_rules_sync: ["full"],
       memorix_workspace_sync: ["full"],
       memorix_ingest_image: ["full"],
+      memorix_compaction_checkpoint: ["full"],
       // ── MCP Official Memory Server compatibility (KG tools) ──────────
       // These are only useful to users specifically migrating from the
       // reference mcp-memory server. Hide them unless explicitly enabled.
@@ -66294,9 +67079,9 @@ var init_graph_scope = __esm({
 });
 
 // src/rules/utils.ts
-import { createHash as createHash13 } from "crypto";
+import { createHash as createHash14 } from "crypto";
 function hashContent2(content) {
-  return createHash13("sha256").update(content.trim()).digest("hex").substring(0, 16);
+  return createHash14("sha256").update(content.trim()).digest("hex").substring(0, 16);
 }
 function generateRuleId(source, filePath) {
   const sanitized = filePath.replace(/[\/\\]/g, "-").replace(/^\./, "");
@@ -67875,6 +68660,26 @@ function vectorBatchSize(payload) {
   if (typeof value !== "number" || !Number.isFinite(value)) return DEFAULT_VECTOR_BATCH_SIZE;
   return Math.min(100, Math.max(1, Math.floor(value)));
 }
+function vectorBackfillFailureStreak(payload) {
+  const value = payload.vectorBackfillFailureStreak;
+  return typeof value === "number" && Number.isFinite(value) ? Math.min(16, Math.max(0, Math.floor(value))) : 0;
+}
+function vectorBackfillRetryDelayMs(streak) {
+  return Math.min(
+    VECTOR_FAILURE_MAX_RETRY_DELAY_MS,
+    VECTOR_FAILURE_BASE_RETRY_DELAY_MS * 2 ** Math.max(0, streak - 1)
+  );
+}
+function withoutVectorBackfillFailureStreak(payload) {
+  const { vectorBackfillFailureStreak: _streak, ...rest } = payload;
+  return rest;
+}
+function resolveSupersededVectorFailures(projectDir2, projectId) {
+  try {
+    new MaintenanceJobStore(projectDir2).resolveFailedVectorBackfills(projectId);
+  } catch {
+  }
+}
 function retentionBatchSize(payload) {
   const value = payload.limit;
   if (typeof value !== "number" || !Number.isFinite(value)) return DEFAULT_RETENTION_BATCH_SIZE;
@@ -68283,20 +69088,45 @@ function createProjectMaintenanceHandler(projectId, projectDir2, projectRoot, op
     if (isEmbeddingExplicitlyDisabled2()) return { action: "complete" };
     const { backfillVectorEmbeddings: backfillVectorEmbeddings2, getVectorStatus: getVectorStatus2 } = await Promise.resolve().then(() => (init_observations(), observations_exports));
     const before = getVectorStatus2(projectId);
-    if (before.missing === 0) return { action: "complete" };
+    if (before.missing === 0) {
+      resolveSupersededVectorFailures(projectDir2, projectId);
+      return { action: "complete" };
+    }
     const result = await backfillVectorEmbeddings2({
       projectId,
       limit: vectorBatchSize(job.payload)
     });
     const after = getVectorStatus2(projectId);
-    if (after.missing === 0) return { action: "complete" };
+    if (after.missing === 0) {
+      resolveSupersededVectorFailures(projectDir2, projectId);
+      return { action: "complete" };
+    }
     if (result.failed > 0 && result.succeeded === 0) {
-      throw new Error(`vector backfill made no progress (${result.failed}/${result.attempted} failed)`);
+      const streak = vectorBackfillFailureStreak(job.payload) + 1;
+      return {
+        action: "reschedule",
+        status: "retry",
+        delayMs: vectorBackfillRetryDelayMs(streak),
+        // This is a recoverable provider/index state, not a terminal job error.
+        // Keeping one retry row prevents new MCP processes from creating a storm.
+        resetAttempts: true,
+        payload: {
+          ...job.payload,
+          vectorBackfillFailureStreak: streak
+        },
+        lastError: result.lastError ?? `vector backfill made no progress (${result.failed}/${result.attempted} failed)`
+      };
     }
+    const priorFailureStreak = vectorBackfillFailureStreak(job.payload);
+    const payload = withoutVectorBackfillFailureStreak(job.payload);
     return {
       action: "reschedule",
       delayMs: result.attempted === 0 ? VECTOR_RETRY_DELAY_MS : 0,
-      resetAttempts: result.succeeded > 0
+      resetAttempts: result.succeeded > 0,
+      ...result.succeeded > 0 ? {
+        ...priorFailureStreak > 0 ? { payload } : {},
+        ...result.failed > 0 && result.lastError ? { lastError: result.lastError } : priorFailureStreak > 0 ? { clearLastError: true } : {}
+      } : {}
     };
   };
 }
@@ -68309,11 +69139,12 @@ function createProjectMaintenanceDispatcher(projectId, projectDir2, projectRoot,
     return isolatedRunner({ job, projectRoot, dataDir: projectDir2 });
   };
 }
-var DEFAULT_VECTOR_BATCH_SIZE, DEFAULT_RETENTION_BATCH_SIZE, DEFAULT_CONSOLIDATION_BATCH_SIZE, DEFAULT_CODEGRAPH_MAX_FILES, DEFAULT_CLAIM_DERIVATION_BATCH_SIZE, DEFAULT_OBSERVATION_QUALIFICATION_BATCH_SIZE, VECTOR_RETRY_DELAY_MS, DEDUP_PER_PAIR_TIMEOUT_MS;
+var DEFAULT_VECTOR_BATCH_SIZE, DEFAULT_RETENTION_BATCH_SIZE, DEFAULT_CONSOLIDATION_BATCH_SIZE, DEFAULT_CODEGRAPH_MAX_FILES, DEFAULT_CLAIM_DERIVATION_BATCH_SIZE, DEFAULT_OBSERVATION_QUALIFICATION_BATCH_SIZE, VECTOR_RETRY_DELAY_MS, VECTOR_FAILURE_BASE_RETRY_DELAY_MS, VECTOR_FAILURE_MAX_RETRY_DELAY_MS, DEDUP_PER_PAIR_TIMEOUT_MS;
 var init_project_maintenance = __esm({
   "src/runtime/project-maintenance.ts"() {
     "use strict";
     init_esm_shims();
+    init_maintenance_jobs();
     init_isolated_maintenance();
     init_lifecycle();
     init_timeout();
@@ -68324,6 +69155,8 @@ var init_project_maintenance = __esm({
     DEFAULT_CLAIM_DERIVATION_BATCH_SIZE = 100;
     DEFAULT_OBSERVATION_QUALIFICATION_BATCH_SIZE = 100;
     VECTOR_RETRY_DELAY_MS = 5e3;
+    VECTOR_FAILURE_BASE_RETRY_DELAY_MS = 6e4;
+    VECTOR_FAILURE_MAX_RETRY_DELAY_MS = 15 * 6e4;
     DEDUP_PER_PAIR_TIMEOUT_MS = 5e3;
   }
 });
@@ -69206,6 +70039,17 @@ async function handleApi(req, res, dataDir, projectId, projectName, baseDir, pro
           sourceCounts,
           recentObservations: sorted,
           embedding: embeddingStatus,
+          // A standalone dashboard has no access to an active MCP
+          // process's in-memory Orama index. Keep this explicit so the
+          // UI never presents an empty local singleton as a healthy
+          // all-vectors-indexed result.
+          vectorStatus: {
+            available: false,
+            total: 0,
+            missing: 0,
+            missingIds: [],
+            backfillRunning: false
+          },
           storage: storageInfo,
           maintenance,
           ...lifecycle ? { lifecycle } : {},
@@ -70075,7 +70919,7 @@ __export(server_exports2, {
   createMemorixServer: () => createMemorixServer,
   shouldAwaitProjectRuntime: () => shouldAwaitProjectRuntime
 });
-import { createHash as createHash14 } from "crypto";
+import { createHash as createHash15 } from "crypto";
 function formatFormationStageDurations(stageDurationsMs) {
   const orderedStages = ["extract", "resolve", "evaluate"];
   const parts = orderedStages.filter((stage) => stageDurationsMs[stage] !== void 0).map((stage) => `${stage}=${stageDurationsMs[stage]}ms`);
@@ -70157,7 +71001,7 @@ function coerceObjectArray(val) {
   return [];
 }
 function createDeterministicInstanceId(projectId, agentType, agentName) {
-  const digest2 = createHash14("sha256").update(projectId).update("\n").update(agentType).update("\n").update(agentName ?? "").digest("hex").slice(0, 24);
+  const digest2 = createHash15("sha256").update(projectId).update("\n").update(agentType).update("\n").update(agentName ?? "").digest("hex").slice(0, 24);
   return `auto-${digest2}`;
 }
 function shouldAwaitProjectRuntime(toolName) {
@@ -70430,7 +71274,7 @@ The path should point to a directory containing a .git folder.`
   };
   const server = existingServer ?? new McpServer({
     name: "memorix",
-    version: true ? "1.2.6" : "1.0.1"
+    version: true ? "1.2.8" : "1.0.1"
   });
   const originalRegisterTool = server.registerTool.bind(server);
   server.registerTool = ((name, ...args) => {
@@ -71078,12 +71922,12 @@ Use this as the \`topicKey\` parameter in \`memorix_store\` to enable upsert beh
         if (boundary) return boundary;
       }
       return withFreshIndex(async () => {
-        const safeLimit = limit != null ? coerceNumber(limit, 20) : void 0;
+        const safeLimit2 = limit != null ? coerceNumber(limit, 20) : void 0;
         const safeMaxTokens = maxTokens != null ? coerceNumber(maxTokens, 0) : void 0;
         const TIMEOUT_MS = 3e4;
         const searchPromise = compactSearch({
           query,
-          limit: safeLimit,
+          limit: safeLimit2,
           type,
           maxTokens: safeMaxTokens,
           since,
@@ -71884,10 +72728,10 @@ Entity: ${entityName} | ${facts.length} facts | ${obs.tokens} tokens${reasoningA
         const unresolved = requireResolvedProject("search reasoning in the current project");
         if (unresolved) return unresolved;
       }
-      const safeLimit = limit != null ? coerceNumber(limit, 10) : 10;
+      const safeLimit2 = limit != null ? coerceNumber(limit, 10) : 10;
       const result = await withFreshIndex(() => compactSearch({
         query,
-        limit: safeLimit,
+        limit: safeLimit2,
         type: "reasoning",
         projectId: scope === "global" ? void 0 : project.id,
         status: "active",
@@ -73210,9 +74054,9 @@ ${summary ? "Summary saved for next session context injection." : "No summary pr
       }
     },
     async ({ limit }) => {
-      const safeLimit = limit != null ? coerceNumber(limit, 3) : 3;
+      const safeLimit2 = limit != null ? coerceNumber(limit, 3) : 3;
       const { getSessionContext: getSessionContext2, listSessions: listSessions2 } = await Promise.resolve().then(() => (init_session(), session_exports));
-      const context = await getSessionContext2(projectDir2, project.id, safeLimit, getObservationReader());
+      const context = await getSessionContext2(projectDir2, project.id, safeLimit2, getObservationReader());
       const sessions = await listSessions2(projectDir2, project.id);
       const activeSessions = sessions.filter((s2) => s2.status === "active");
       const completedSessions = sessions.filter((s2) => s2.status === "completed");
@@ -73233,6 +74077,86 @@ ${summary ? "Summary saved for next session context injection." : "No summary pr
       };
     }
   );
+  server.registerTool(
+    "memorix_compaction_checkpoint",
+    {
+      title: "Compact Continuity Checkpoints",
+      description: "Inspect, preview, or archive bounded checkpoints recorded around a host-native context compaction. Use only to debug or explicitly review compaction continuity. These are lifecycle records, not durable memories or transcript backups. CLI equivalent: memorix checkpoint list|show|context|archive.",
+      inputSchema: {
+        action: external_exports.enum(["list", "show", "context", "archive"]).default("list"),
+        id: external_exports.string().optional().describe("Checkpoint ID for show, context, or archive"),
+        sessionId: external_exports.string().optional().describe("Optional host session ID filter"),
+        agent: external_exports.string().optional().describe("Optional host agent filter"),
+        task: external_exports.string().optional().describe("Current task for a bounded context preview"),
+        maxTokens: external_exports.number().optional().describe("Maximum tokens for action=context (default: 420)"),
+        limit: external_exports.number().optional().describe("Maximum records for action=list (default: 20)"),
+        includeArchived: external_exports.boolean().optional().default(false).describe("Include archived records in action=list")
+      }
+    },
+    async ({ action, id, sessionId, agent, task, maxTokens, limit, includeArchived }) => {
+      const unresolved = requireResolvedProject("inspect compact continuity checkpoints");
+      if (unresolved) return unresolved;
+      const [{ CompactionCheckpointStore: CompactionCheckpointStore2 }, { buildCompactionWorkset: buildCompactionWorkset2 }] = await Promise.all([
+        Promise.resolve().then(() => (init_compaction_checkpoint_store(), compaction_checkpoint_store_exports)),
+        Promise.resolve().then(() => (init_compaction(), compaction_exports))
+      ]);
+      const store2 = new CompactionCheckpointStore2(projectDir2);
+      const assertCheckpoint = (checkpointId) => {
+        const checkpoint2 = store2.get(checkpointId);
+        if (!checkpoint2 || checkpoint2.projectId !== project.id) return null;
+        return checkpoint2;
+      };
+      if (action === "list") {
+        const checkpoints = store2.list({
+          projectId: project.id,
+          sessionId: sessionId?.trim() || void 0,
+          agent: agent?.trim() || void 0,
+          includeArchived: Boolean(includeArchived),
+          limit: limit != null ? Math.max(1, Math.min(100, coerceNumber(limit, 20))) : 20
+        });
+        return {
+          content: [{ type: "text", text: JSON.stringify({ projectId: project.id, checkpoints }, null, 2) }]
+        };
+      }
+      if (!id?.trim()) {
+        return {
+          content: [{ type: "text", text: "id is required for this checkpoint action." }],
+          isError: true
+        };
+      }
+      const checkpoint = assertCheckpoint(id.trim());
+      if (!checkpoint) {
+        return {
+          content: [{ type: "text", text: `Checkpoint "${id.trim()}" was not found for the current project.` }],
+          isError: true
+        };
+      }
+      if (action === "show") {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ projectId: project.id, checkpoint }, null, 2) }]
+        };
+      }
+      if (action === "context") {
+        const workset = buildCompactionWorkset2(checkpoint, {
+          task: task?.trim(),
+          maxTokens: maxTokens != null ? coerceNumber(maxTokens, 420) : 420
+        });
+        return {
+          content: [{ type: "text", text: workset.text }]
+        };
+      }
+      const archived = store2.archive(checkpoint.id);
+      if (!archived) {
+        return {
+          content: [{ type: "text", text: `Checkpoint "${checkpoint.id}" is already archived.` }],
+          isError: true
+        };
+      }
+      return {
+        content: [{ type: "text", text: `Archived compact checkpoint ${archived.id}.` }]
+      };
+    }
+  );
   server.registerTool(
     "memorix_transfer",
     {
@@ -76147,7 +77071,7 @@ var init_serve_http = __esm({
       },
       run: async ({ args }) => {
         const { createServer: createServer2 } = await import("http");
-        const { randomUUID: randomUUID10 } = await import("crypto");
+        const { randomUUID: randomUUID11 } = await import("crypto");
         const { StreamableHTTPServerTransport: StreamableHTTPServerTransport2 } = await Promise.resolve().then(() => (init_streamableHttp(), streamableHttp_exports));
         const { isInitializeRequest: isInitializeRequest2 } = await Promise.resolve().then(() => (init_types4(), types_exports));
         const { createMemorixServer: createMemorixServer2 } = await Promise.resolve().then(() => (init_server4(), server_exports2));
@@ -76331,7 +77255,7 @@ var init_serve_http = __esm({
           if (!sessionId && isInitializeRequest2(body)) {
             let createdState = null;
             const transport = new StreamableHTTPServerTransport2({
-              sessionIdGenerator: () => randomUUID10(),
+              sessionIdGenerator: () => randomUUID11(),
               enableJsonResponse: true,
               onsessioninitialized: (sid) => {
                 if (createdState) sessions.set(sid, createdState);
@@ -76726,10 +77650,18 @@ var init_serve_http = __esm({
                 };
               } catch {
               }
-              let vectorStatus = { total: 0, missing: 0, missingIds: [], backfillRunning: false };
+              let vectorStatus = {
+                available: false,
+                total: 0,
+                missing: 0,
+                missingIds: [],
+                backfillRunning: false
+              };
               try {
-                const { getVectorStatus: getVectorStatus2 } = await Promise.resolve().then(() => (init_observations(), observations_exports));
-                vectorStatus = getVectorStatus2(statsProjectId);
+                const { getSearchIndexStatus: getSearchIndexStatus2, getVectorStatus: getVectorStatus2 } = await Promise.resolve().then(() => (init_observations(), observations_exports));
+                if (getSearchIndexStatus2(statsProjectId).prepared) {
+                  vectorStatus = { available: true, ...getVectorStatus2(statsProjectId) };
+                }
               } catch {
               }
               let searchMode = "fulltext";
@@ -78121,6 +79053,44 @@ function stringifyValue(value) {
     return String(value);
   }
 }
+function firstNumber2(...values) {
+  for (const value of values) {
+    if (typeof value === "number" && Number.isFinite(value)) return value;
+    if (typeof value === "string" && value.trim()) {
+      const parsed = Number(value);
+      if (Number.isFinite(parsed)) return parsed;
+    }
+  }
+  return void 0;
+}
+function normalizeCompactionReason(value) {
+  const normalized = value?.trim().toLowerCase();
+  if (normalized === "manual" || normalized === "auto") return normalized;
+  return "unknown";
+}
+function normalizeCompactionMetadata(payload, ...records) {
+  const nestedSources = records.filter((record2) => Boolean(record2));
+  const sources = [payload, ...nestedSources];
+  const from = (field) => sources.map((source) => source[field]);
+  const fromNested = (field) => nestedSources.map((source) => source[field]);
+  const summary = firstString(...from("summary"), ...from("compaction_summary"));
+  const sourceKey = firstString(...from("compaction_id"), ...from("entry_id"), ...fromNested("id"));
+  const reasonValue = firstString(...from("trigger"), ...from("reason"), ...from("compaction_reason"));
+  const tokensBefore = firstNumber2(...from("tokensBefore"), ...from("tokens_before"));
+  const firstKeptEntryId = firstString(...from("firstKeptEntryId"), ...from("first_kept_entry_id"));
+  const details = sources.map((source) => asRecord(source.details)).find((value) => Boolean(value));
+  if (!summary && !sourceKey && !tokensBefore && !firstKeptEntryId && !details && !reasonValue) {
+    return void 0;
+  }
+  return {
+    ...reasonValue ? { reason: normalizeCompactionReason(reasonValue) } : {},
+    ...sourceKey ? { sourceKey } : {},
+    ...summary ? { summary } : {},
+    ...tokensBefore !== void 0 ? { tokensBefore } : {},
+    ...firstKeptEntryId ? { firstKeptEntryId } : {},
+    ...details ? { details } : {}
+  };
+}
 function detectAgent(payload) {
   if (typeof payload._memorix_agent === "string") {
     return payload._memorix_agent;
@@ -78206,6 +79176,10 @@ function normalizeClaude(payload, event) {
   if (assistantMessage) {
     result.aiResponse = assistantMessage;
   }
+  if (event === "session_start") {
+    const source = firstString(payload.source, payload.session_start_reason, payload.reason);
+    if (source) result.sessionStartReason = source;
+  }
   return result;
 }
 function normalizeWindsurf(payload, event) {
@@ -78344,6 +79318,10 @@ function normalizeGemini(payload, event) {
   if (event === "user_prompt") {
     result.userPrompt = payload.prompt ?? "";
   }
+  if (event === "session_start") {
+    const source = firstString(payload.source, payload.session_start_reason, payload.reason);
+    if (source) result.sessionStartReason = source;
+  }
   return result;
 }
 function normalizeOpenCode(payload, event) {
@@ -78380,7 +79358,8 @@ function normalizeOpenCode(payload, event) {
 function normalizePi(payload, event) {
   const result = {
     sessionId: payload.session_id ?? payload.sessionId ?? "",
-    cwd: payload.cwd ?? ""
+    cwd: payload.cwd ?? "",
+    transcriptPath: payload.transcript_path ?? payload.transcriptPath
   };
   const toolName = payload.tool_name ?? "";
   if (toolName) {
@@ -78402,6 +79381,10 @@ function normalizePi(payload, event) {
   if (event === "post_command") {
     result.command = payload.command ?? "";
   }
+  if (event === "session_start") {
+    const source = firstString(payload.source, payload.reason);
+    if (source) result.sessionStartReason = source;
+  }
   if (result.toolInput && typeof result.toolInput === "object") {
     const filePath = result.toolInput.file_path ?? result.toolInput.filePath ?? result.toolInput.path;
     if (filePath) result.filePath = filePath;
@@ -78454,6 +79437,10 @@ function normalizeBridgePayload(payload, event) {
       openclawContext?.message
     ) ?? stringifyValue(openclawEvent?.message) ?? "";
   }
+  if (event === "session_start") {
+    const source = firstString(payload.source, bridgePayload?.source, bridgeKwargs?.source, openclawEvent?.reason);
+    if (source) result.sessionStartReason = source;
+  }
   return result;
 }
 function normalizeHookInput(payload) {
@@ -78499,6 +79486,15 @@ function normalizeHookInput(payload) {
     default:
       agentSpecific = { sessionId: "", cwd: "" };
   }
+  const openclawEvent = asRecord(payload.openclaw_event);
+  const genericCompaction = event === "pre_compact" || event === "post_compact" ? normalizeCompactionMetadata(
+    payload,
+    asRecord(payload.compaction),
+    asRecord(payload.compaction_entry),
+    asRecord(payload.compactionEntry),
+    asRecord(openclawEvent?.compaction),
+    asRecord(openclawEvent?.compaction_entry)
+  ) : void 0;
   return {
     event,
     agent,
@@ -78506,7 +79502,8 @@ function normalizeHookInput(payload) {
     sessionId: agentSpecific.sessionId ?? "",
     cwd: agentSpecific.cwd ?? "",
     raw: payload,
-    ...agentSpecific
+    ...agentSpecific,
+    ...genericCompaction ? { compaction: genericCompaction } : {}
   };
 }
 var EVENT_MAP;
@@ -78760,10 +79757,10 @@ __export(handler_exports, {
   resetCooldowns: () => resetCooldowns,
   runHook: () => runHook
 });
-import { createHash as createHash15 } from "crypto";
+import { createHash as createHash16 } from "crypto";
 function deriveHookActorId(input) {
   const material = `${input.agent ?? "unknown"}\0${input.sessionId ?? "unknown"}`;
-  return `hook:${createHash15("sha256").update(material).digest("hex").slice(0, 24)}`;
+  return `hook:${createHash16("sha256").update(material).digest("hex").slice(0, 24)}`;
 }
 function classifyTool(input) {
   if (input.event === "post_edit") return "file_modify";
@@ -78944,6 +79941,15 @@ async function buildHookProjectContext(input, task, target) {
       refresh: "auto",
       reader: { projectId: canonicalId },
       continuation: "always",
+      ...input.sessionId ? {
+        // A native compact recovery is delivered once per host session.
+        // Do not echo that same checkpoint back through the generic
+        // continuation brief on later events from this session.
+        excludeCompactionCheckpointFor: {
+          sessionId: input.sessionId,
+          agent: input.agent
+        }
+      } : {},
       enqueueRefresh: () => Promise.resolve().then(() => (init_lifecycle(), lifecycle_exports)).then(({ enqueueCodegraphRefresh: enqueueCodegraphRefresh2 }) => {
         enqueueCodegraphRefresh2({
           dataDir,
@@ -78965,27 +79971,80 @@ async function buildHookProjectContext(input, task, target) {
     return null;
   }
 }
+function isCompactSessionStart(input) {
+  return input.event === "session_start" && input.sessionStartReason?.trim().toLowerCase() === "compact";
+}
+async function consumeCompactContinuation(input, task) {
+  try {
+    const { consumeCompactionWorkset: consumeCompactionWorkset2 } = await Promise.resolve().then(() => (init_compaction(), compaction_exports));
+    const workset = await consumeCompactionWorkset2(input, { task, maxTokens: 420 });
+    return workset?.text;
+  } catch (error2) {
+    console.error("[memorix] compact continuation failed:", error2?.message ?? error2);
+    return void 0;
+  }
+}
 async function buildClaudeContinuationPromptContext(input) {
   if (input.agent !== "claude" || input.event !== "user_prompt" || !input.userPrompt?.trim()) {
     return void 0;
   }
-  const { isContinuationTask: isContinuationTask2 } = await Promise.resolve().then(() => (init_task_lens(), task_lens_exports));
-  if (!isContinuationTask2(input.userPrompt)) return void 0;
   if (await getHookInjectionMode(input) === "silent") return void 0;
-  const context = await buildHookProjectContext(input, input.userPrompt, "hook-user-prompt");
-  if (!context?.hasContinuation) return void 0;
-  return [
-    "Memorix prepared a bounded prior-work brief for this explicit continuation request.",
-    "Treat it as background context; current code wins. Use it before broad Git or file-history archaeology.",
-    "",
-    context.prompt
-  ].join("\n");
+  const compactContinuation = await consumeCompactContinuation(input, input.userPrompt);
+  if (compactContinuation) {
+    return [
+      "Memorix recovered one bounded checkpoint after the host compacted this session.",
+      "Treat it as background context; current code and the user request win.",
+      "",
+      compactContinuation
+    ].join("\n");
+  }
+  const { isContinuationTask: isContinuationTask2, resolveTaskLens: resolveTaskLens2 } = await Promise.resolve().then(() => (init_task_lens(), task_lens_exports));
+  const continuationRequested = isContinuationTask2(input.userPrompt);
+  if (continuationRequested) {
+    const context = await buildHookProjectContext(input, input.userPrompt, "hook-user-prompt");
+    if (context?.hasContinuation) {
+      return [
+        "Memorix prepared a bounded prior-work brief for this explicit continuation request.",
+        "Treat it as background context; current code wins. Use it before broad Git or file-history archaeology.",
+        "",
+        context.prompt
+      ].join("\n");
+    }
+  }
+  if (continuationRequested || resolveTaskLens2(input.userPrompt).id === "onboarding") {
+    return [
+      "Memorix is available for this handoff or continuation.",
+      "Before broad file or Git exploration, call memorix_project_context with the user's actual task.",
+      "If it is not visible yet, use Claude Code tool search for memorix_project_context; use CLI only when MCP discovery is unavailable."
+    ].join(" ");
+  }
+  return void 0;
 }
 async function handleSessionStart(input) {
   const injectMode = await getHookInjectionMode(input);
   if (injectMode === "silent") {
     return { observation: null, output: { continue: true } };
   }
+  if (input.agent === "codex" && isCompactSessionStart(input)) {
+    const compactContinuation = await consumeCompactContinuation(
+      input,
+      "Continue after the host compacted the current session."
+    );
+    if (compactContinuation) {
+      return {
+        observation: null,
+        output: {
+          continue: true,
+          systemMessage: [
+            "Memorix recovered one bounded checkpoint after the host compacted this session.",
+            "Treat it as background context; current code and the user request win.",
+            "",
+            compactContinuation
+          ].join("\n")
+        }
+      };
+    }
+  }
   let contextSummary = "";
   if (injectMode === "full") {
     const context = await buildHookProjectContext(input, "Continue the current task.", "hook-session-start");
@@ -79194,6 +80253,12 @@ async function runHook(agentOverride, eventOverride) {
     payload._memorix_event = eventOverride;
   }
   const input = normalizeHookInput(payload);
+  try {
+    const { captureCompactionCheckpoint: captureCompactionCheckpoint2 } = await Promise.resolve().then(() => (init_compaction(), compaction_exports));
+    await captureCompactionCheckpoint2(input);
+  } catch (checkpointError) {
+    console.error("[memorix] compact checkpoint failed:", checkpointError?.message ?? checkpointError);
+  }
   const { observation, output } = await handleHookEvent(input, { deferMaintenance: true });
   if (observation) {
     try {
@@ -81341,6 +82406,9 @@ function asRecordArray(value) {
 function codexPluginPath() {
   return `${homedir32()}/.codex/plugins/${CODEX_PLUGIN_NAME}`;
 }
+function codexPluginMcpPath() {
+  return `${codexPluginPath()}/.mcp.json`;
+}
 function codexMarketplacePath() {
   return `${homedir32()}/.agents/plugins/marketplace.json`;
 }
@@ -81373,6 +82441,7 @@ async function inspectCodexPluginBundle() {
   const pluginPath = codexPluginPath();
   const manifestPath = `${pluginPath}/.codex-plugin/plugin.json`;
   const hooksPath = `${pluginPath}/hooks/hooks.json`;
+  const mcpPath = codexPluginMcpPath();
   if (!existsSync25(pluginPath)) {
     return {
       scope: "global",
@@ -81420,6 +82489,19 @@ async function inspectCodexPluginBundle() {
   const issues = [];
   if (version2 !== getCliVersion()) issues.push("codex-plugin-version-mismatch");
   if (manifest.hooks !== "./hooks/hooks.json") issues.push("codex-hook-manifest-missing");
+  if (!existsSync25(mcpPath)) {
+    issues.push("codex-plugin-mcp-manifest-missing");
+  } else {
+    try {
+      const mcpConfig = asRecord2(JSON.parse(await readFile7(mcpPath, "utf-8")));
+      const server = coerceMcpServer("memorix", asRecord2(mcpConfig?.mcpServers)?.memorix);
+      if (!server || !isRecommendedStdioServer(server)) {
+        issues.push("codex-plugin-mcp-manifest-invalid");
+      }
+    } catch {
+      issues.push("codex-plugin-mcp-manifest-unreadable");
+    }
+  }
   let declared = [];
   if (!existsSync25(hooksPath)) {
     issues.push("codex-hook-manifest-missing");
@@ -81569,7 +82651,9 @@ async function inspectCodexHookTrust() {
     kind: "hook-trust",
     path: configPath,
     exists: true,
-    status: issues.length > 0 ? "repairable" : "ok",
+    // Codex records hook approval only after the user has reviewed it. Memorix
+    // must not treat an intentional, host-owned consent step as a broken setup.
+    status: issues.length > 0 ? "skipped" : "ok",
     issues,
     hookTrust: { trusted, expected: [...CODEX_HOOK_STATE_NAMES] }
   };
@@ -81637,7 +82721,7 @@ function defaultClaudeProjectKey(projectRoot) {
 function getClaudeLocalConfigPath() {
   return `${homedir32()}/.claude.json`;
 }
-function coerceClaudeLocalServer(name, value) {
+function coerceMcpServer(name, value) {
   const entry = asRecord2(value);
   if (!entry) return null;
   const args = Array.isArray(entry.args) ? entry.args.map(String) : [];
@@ -81696,7 +82780,7 @@ async function inspectClaudeLocalMcp(projectRoot) {
     };
   }
   const servers = asRecord2(localProject.project.mcpServers);
-  const server = coerceClaudeLocalServer("memorix", servers?.memorix);
+  const server = coerceMcpServer("memorix", servers?.memorix);
   if (!server) {
     return {
       scope: "local",
@@ -81747,6 +82831,56 @@ async function installClaudeLocalMcpConfig(projectRoot) {
   await writeFile7(configPath, `${JSON.stringify(config2, null, 2)}
 `, "utf-8");
 }
+async function inspectCodexPluginMcp() {
+  const runtime = inspectCodexPluginRuntime();
+  if (!runtime.runtime?.installed || !runtime.runtime.enabled) return null;
+  const mcpPath = codexPluginMcpPath();
+  if (!existsSync25(mcpPath)) {
+    return {
+      scope: "global",
+      path: mcpPath,
+      exists: false,
+      status: "repairable",
+      issues: ["codex-plugin-mcp-manifest-missing"],
+      managedByPlugin: true
+    };
+  }
+  try {
+    const config2 = asRecord2(JSON.parse(await readFile7(mcpPath, "utf-8")));
+    const server = coerceMcpServer("memorix", asRecord2(config2?.mcpServers)?.memorix);
+    if (!server) {
+      return {
+        scope: "global",
+        path: mcpPath,
+        exists: true,
+        status: "repairable",
+        issues: ["codex-plugin-mcp-manifest-invalid"],
+        managedByPlugin: true
+      };
+    }
+    const issues = [];
+    if (looksLikeStaleMemorixCommand(server)) issues.push("stale-command-path");
+    if (!isRecommendedStdioServer(server)) issues.push("nonstandard-mcp-command");
+    return {
+      scope: "global",
+      path: mcpPath,
+      exists: true,
+      status: issues.length > 0 ? "repairable" : "ok",
+      issues,
+      managedByPlugin: true,
+      server: sanitizeServer(server)
+    };
+  } catch {
+    return {
+      scope: "global",
+      path: mcpPath,
+      exists: true,
+      status: "repairable",
+      issues: ["codex-plugin-mcp-manifest-unreadable"],
+      managedByPlugin: true
+    };
+  }
+}
 async function inspectMcp(agent, projectRoot, scope) {
   if (!isMcpConfigAgent(agent)) {
     return { status: "skipped", issues: ["mcp-managed-by-package"], checks: [] };
@@ -81758,6 +82892,13 @@ async function inspectMcp(agent, projectRoot, scope) {
       checks.push(await inspectClaudeLocalMcp(projectRoot));
       continue;
     }
+    if (agent === "codex" && targetScope === "global") {
+      const pluginCheck = await inspectCodexPluginMcp();
+      if (pluginCheck) {
+        checks.push(pluginCheck);
+        continue;
+      }
+    }
     const configPath = adapter.getConfigPath(targetScope === "project" ? projectRoot : void 0);
     if (targetScope === "global" && configPath === adapter.getConfigPath(projectRoot)) continue;
     if (!existsSync25(configPath)) {
@@ -81902,10 +83043,19 @@ function formatAgentIntegrationReport(report) {
     lines.push(`${entry.agent}: ${status}`);
     if (entry.mcp.issues.length > 0) lines.push(`  MCP: ${entry.mcp.issues.join(", ")}`);
     if (entry.guidance.issues.length > 0) lines.push(`  Guidance: ${entry.guidance.issues.join(", ")}`);
-    if (entry.plugin.issues.length > 0) lines.push(`  Plugin: ${entry.plugin.issues.join(", ")}`);
+    const hookTrustPending = entry.plugin.issues.includes("codex-hook-trust-pending");
+    const pluginIssues = entry.plugin.issues.filter((issue2) => issue2 !== "codex-hook-trust-pending");
+    if (pluginIssues.length > 0) lines.push(`  Plugin: ${pluginIssues.join(", ")}`);
+    if (hookTrustPending) {
+      lines.push("  Hooks: waiting for Codex approval on first use; MCP remains available.");
+    }
   }
   lines.push("");
-  lines.push(`Repair: ${report.repairCommand}`);
+  if (report.summary.missing > 0 || report.summary.repairable > 0) {
+    lines.push(`Repair: ${report.repairCommand}`);
+  } else {
+    lines.push("No file repair needed.");
+  }
   return lines.join("\n");
 }
 async function repairAgentIntegrations(options2 = {}) {
@@ -81919,6 +83069,10 @@ async function repairAgentIntegrations(options2 = {}) {
     if (isMcpConfigAgent(entry.agent)) {
       for (const check2 of entry.mcp.checks) {
         if (check2.status === "ok" || check2.status === "skipped") continue;
+        if (check2.managedByPlugin) {
+          skipped.push(`${entry.agent}:mcp:${check2.scope}:plugin-managed`);
+          continue;
+        }
         if (check2.status === "missing" && !canInstallMissing) {
           skipped.push(`${entry.agent}:mcp:${check2.scope}:missing`);
           continue;
@@ -84986,32 +86140,32 @@ __export(cost_tracker_exports, {
   formatCostSummary: () => formatCostSummary,
   isBudgetExceeded: () => isBudgetExceeded
 });
-function calculateModelCost(model, usage2, customPrices) {
+function calculateModelCost(model, usage3, customPrices) {
   const prices = { ...DEFAULT_PRICES, ...customPrices };
   const price = findPrice(model, prices);
   if (!price) return null;
-  const inputCost = usage2.inputTokens / 1e6 * price.inputPer1M;
-  const outputCost = usage2.outputTokens / 1e6 * price.outputPer1M;
-  const cacheReadCost = usage2.cacheReadTokens / 1e6 * (price.cacheReadPer1M ?? 0);
-  const cacheWriteCost = usage2.cacheWriteTokens / 1e6 * (price.cacheWritePer1M ?? 0);
+  const inputCost = usage3.inputTokens / 1e6 * price.inputPer1M;
+  const outputCost = usage3.outputTokens / 1e6 * price.outputPer1M;
+  const cacheReadCost = usage3.cacheReadTokens / 1e6 * (price.cacheReadPer1M ?? 0);
+  const cacheWriteCost = usage3.cacheWriteTokens / 1e6 * (price.cacheWritePer1M ?? 0);
   return inputCost + outputCost + cacheReadCost + cacheWriteCost;
 }
 function calculatePipelineCost(tokenUsage, budgetUSD, customPrices) {
   const models2 = [];
   let totalUSD = 0;
   let hasAnyPrice = false;
-  for (const [model, usage2] of Object.entries(tokenUsage)) {
-    const cost = calculateModelCost(model, usage2, customPrices);
+  for (const [model, usage3] of Object.entries(tokenUsage)) {
+    const cost = calculateModelCost(model, usage3, customPrices);
     if (cost !== null) {
       hasAnyPrice = true;
       totalUSD = (totalUSD ?? 0) + cost;
     }
     models2.push({
       model,
-      inputTokens: usage2.inputTokens,
-      outputTokens: usage2.outputTokens,
-      cacheReadTokens: usage2.cacheReadTokens,
-      cacheWriteTokens: usage2.cacheWriteTokens,
+      inputTokens: usage3.inputTokens,
+      outputTokens: usage3.outputTokens,
+      cacheReadTokens: usage3.cacheReadTokens,
+      cacheWriteTokens: usage3.cacheWriteTokens,
       costUSD: cost !== null ? Math.round(cost * 1e4) / 1e4 : null
       // Round to 4 decimals
     });
@@ -85310,7 +86464,7 @@ var init_permission = __esm({
 });
 
 // src/orchestrate/memorix-bridge.ts
-import { createHash as createHash16 } from "crypto";
+import { createHash as createHash17 } from "crypto";
 async function getStoreObservation() {
   if (!_storeObservation) {
     const mod = await Promise.resolve().then(() => (init_observations(), observations_exports));
@@ -85326,7 +86480,7 @@ async function getSearchObservations() {
   return _searchObservations;
 }
 function automaticActorId(...parts) {
-  return `orchestrator:${createHash16("sha256").update(parts.join("\0")).digest("hex").slice(0, 24)}`;
+  return `orchestrator:${createHash17("sha256").update(parts.join("\0")).digest("hex").slice(0, 24)}`;
 }
 function isEligibleAutomaticLesson(entry) {
   return entry.admissionState !== "candidate" && entry.admissionState !== "ephemeral";
@@ -85473,7 +86627,7 @@ function sanitizeErrorPattern(text) {
 }
 function hashErrorPattern(errorOutput) {
   const sanitized = sanitizeErrorPattern(errorOutput).slice(0, 500);
-  return createHash16("sha256").update(sanitized).digest("hex").slice(0, 12);
+  return createHash17("sha256").update(sanitized).digest("hex").slice(0, 12);
 }
 function sleep2(ms) {
   return new Promise((resolve6) => setTimeout(() => resolve6([]), ms));
@@ -85934,12 +87088,12 @@ ${formatCostSummary(costSummary)}`);
           activeDispatches.splice(settled.idx, 1);
           const { dispatch, result } = settled;
           if (result.tokenUsage) {
-            for (const [model, usage2] of Object.entries(result.tokenUsage)) {
+            for (const [model, usage3] of Object.entries(result.tokenUsage)) {
               const prev = pipelineUsage[model] ?? { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, model };
-              prev.inputTokens += usage2.inputTokens;
-              prev.outputTokens += usage2.outputTokens;
-              prev.cacheReadTokens += usage2.cacheReadTokens;
-              prev.cacheWriteTokens += usage2.cacheWriteTokens;
+              prev.inputTokens += usage3.inputTokens;
+              prev.outputTokens += usage3.outputTokens;
+              prev.cacheReadTokens += usage3.cacheReadTokens;
+              prev.cacheWriteTokens += usage3.cacheWriteTokens;
               pipelineUsage[model] = prev;
             }
             if (traceDb && pipelineId) {
@@ -86885,10 +88039,10 @@ ${"\u2550".repeat(60)}`);
         if (result.tokenUsage) {
           console.error(`
 [COST] Token Usage:`);
-          for (const [model, usage2] of Object.entries(result.tokenUsage)) {
-            const total = usage2.inputTokens + usage2.outputTokens;
-            const cacheHits = usage2.cacheReadTokens;
-            console.error(`   ${model}: ${total.toLocaleString()} tokens (in: ${usage2.inputTokens.toLocaleString()}, out: ${usage2.outputTokens.toLocaleString()}${cacheHits > 0 ? `, cache: ${cacheHits.toLocaleString()}` : ""})`);
+          for (const [model, usage3] of Object.entries(result.tokenUsage)) {
+            const total = usage3.inputTokens + usage3.outputTokens;
+            const cacheHits = usage3.cacheReadTokens;
+            console.error(`   ${model}: ${total.toLocaleString()} tokens (in: ${usage3.inputTokens.toLocaleString()}, out: ${usage3.outputTokens.toLocaleString()}${cacheHits > 0 ? `, cache: ${cacheHits.toLocaleString()}` : ""})`);
           }
         }
         if (result.costSummary) {
@@ -91394,6 +92548,16 @@ var GUIDES = {
       'memorix codegraph context-pack --task "trace the auth flow" [--limit 20]'
     ]
   },
+  checkpoint: {
+    summary: "Inspect bounded recovery checkpoints created around host-native context compaction.",
+    usage: [
+      "memorix checkpoint list [--session <id>] [--agent <name>]",
+      "memorix checkpoint show --id <checkpoint-id>",
+      'memorix checkpoint context [--id <checkpoint-id>] [--task "continue auth fix"]',
+      "memorix checkpoint archive --id <checkpoint-id>"
+    ],
+    notes: ["Checkpoints are host lifecycle evidence, not durable project memory and not transcript backups."]
+  },
   knowledge: {
     summary: "Manage the reviewed, source-backed Knowledge Workspace and project workflows.",
     usage: [
@@ -91709,6 +92873,7 @@ var main = defineCommand({
     resume: () => Promise.resolve().then(() => (init_resume(), resume_exports)).then((m4) => m4.default),
     explain: () => Promise.resolve().then(() => (init_explain(), explain_exports)).then((m4) => m4.default),
     codegraph: () => Promise.resolve().then(() => (init_codegraph(), codegraph_exports)).then((m4) => m4.default),
+    checkpoint: () => Promise.resolve().then(() => (init_checkpoint(), checkpoint_exports)).then((m4) => m4.default),
     knowledge: () => Promise.resolve().then(() => (init_knowledge(), knowledge_exports)).then((m4) => m4.default),
     reasoning: () => Promise.resolve().then(() => (init_reasoning(), reasoning_exports)).then((m4) => m4.default),
     retention: () => Promise.resolve().then(() => (init_retention2(), retention_exports2)).then((m4) => m4.default),
@@ -91790,6 +92955,7 @@ var main = defineCommand({
       "resume",
       "explain",
       "codegraph",
+      "checkpoint",
       "knowledge",
       "reasoning",
       "retention",
@@ -91858,6 +93024,7 @@ var main = defineCommand({
       console.error("  resume     Resume prior work with one bounded project brief");
       console.error("  explain    Explain where Memorix project context comes from");
       console.error("  codegraph  Refresh/status/context-pack for CodeGraph Memory");
+      console.error("  checkpoint Inspect native compact continuity checkpoints");
       console.error("  knowledge  Review source-backed knowledge pages and project workflows");
       console.error("  reasoning  Store/search decision rationale");
       console.error("  retention  Inspect stale/archive status");