memorix 1.2.6 → 1.2.7

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.7" : 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();
@@ -18126,10 +18164,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
@@ -34934,7 +34972,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 +35012,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 +35299,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 +35310,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 +37539,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 +38029,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 +38253,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 +38268,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 +38340,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 +38360,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 +38625,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 +38635,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 +39032,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 +39428,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 +39873,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 +40094,7 @@ var init_knowledge = __esm({
               );
               return;
             }
-            emitResult({ usage: usage() }, usage(), asJson);
+            emitResult({ usage: usage2() }, usage2(), asJson);
             return;
           }
           switch (action) {
@@ -39498,7 +40153,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 +47467,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 +47525,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 +48444,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 +48694,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 +66950,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(/^\./, "");
@@ -70075,7 +70731,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 +70813,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 +71086,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.7" : "1.0.1"
   });
   const originalRegisterTool = server.registerTool.bind(server);
   server.registerTool = ((name, ...args) => {
@@ -71078,12 +71734,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 +72540,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 +73866,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 +73889,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 +76883,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 +77067,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);
@@ -78121,6 +78857,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 +78980,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 +79122,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 +79162,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 +79185,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 +79241,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 +79290,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 +79306,8 @@ function normalizeHookInput(payload) {
     sessionId: agentSpecific.sessionId ?? "",
     cwd: agentSpecific.cwd ?? "",
     raw: payload,
-    ...agentSpecific
+    ...agentSpecific,
+    ...genericCompaction ? { compaction: genericCompaction } : {}
   };
 }
 var EVENT_MAP;
@@ -78760,10 +79561,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 +79745,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 +79775,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 +80057,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 {
@@ -84986,32 +85855,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 +86179,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 +86195,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 +86342,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 +86803,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 +87754,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 +92263,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 +92588,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 +92670,7 @@ var main = defineCommand({
       "resume",
       "explain",
       "codegraph",
+      "checkpoint",
       "knowledge",
       "reasoning",
       "retention",
@@ -91858,6 +92739,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");