@cleocode/cleo 2026.3.71 → 2026.3.72

package/dist/mcp/index.js

@@ -67855,6 +67855,162 @@ var init_bootstrap = __esm({
   }
 });
 
+// packages/core/src/sessions/snapshot.ts
+async function serializeSession(projectRoot, options = {}, accessor) {
+  const acc = accessor ?? await getAccessor(projectRoot);
+  const maxObs = options.maxObservations ?? 10;
+  const maxDescLen = options.maxDescriptionLength ?? 500;
+  const sessions2 = await acc.loadSessions();
+  let session;
+  if (options.sessionId) {
+    session = sessions2.find((s) => s.id === options.sessionId);
+  } else {
+    session = sessions2.filter((s) => s.status === "active").sort((a, b) => new Date(b.startedAt).getTime() - new Date(a.startedAt).getTime())[0];
+  }
+  if (!session) {
+    throw new CleoError(
+      31 /* SESSION_NOT_FOUND */,
+      options.sessionId ? `Session '${options.sessionId}' not found` : "No active session to serialize",
+      { fix: "Use 'cleo session list' to see available sessions" }
+    );
+  }
+  const handoff = await computeHandoff(projectRoot, { sessionId: session.id });
+  const decisionLog = await getDecisionLog(projectRoot, { sessionId: session.id });
+  const decisions = decisionLog.map((d) => ({
+    decision: d.decision,
+    rationale: d.rationale,
+    taskId: d.taskId,
+    recordedAt: d.timestamp ?? (/* @__PURE__ */ new Date()).toISOString()
+  }));
+  let observations = [];
+  try {
+    const { searchBrainCompact: searchBrainCompact2 } = await Promise.resolve().then(() => (init_brain_retrieval(), brain_retrieval_exports));
+    const results = await searchBrainCompact2(projectRoot, {
+      query: session.id,
+      limit: maxObs,
+      tables: ["observations"]
+    });
+    if (Array.isArray(results)) {
+      observations = results.map(
+        (r) => ({
+          id: r.id,
+          text: r.text ?? "",
+          type: r.type ?? "discovery",
+          createdAt: r.createdAt ?? ""
+        })
+      );
+    }
+  } catch {
+  }
+  let activeTask = null;
+  if (session.taskWork?.taskId) {
+    try {
+      const { tasks: tasks2 } = await acc.queryTasks({});
+      const task = tasks2.find((t) => t.id === session.taskWork?.taskId);
+      if (task) {
+        const desc7 = task.description ?? "";
+        activeTask = {
+          taskId: task.id,
+          title: task.title,
+          status: task.status,
+          priority: task.priority ?? "medium",
+          description: desc7.length > maxDescLen ? desc7.slice(0, maxDescLen) + "..." : desc7,
+          acceptance: Array.isArray(task.acceptance) ? task.acceptance.join("\n") : task.acceptance ?? void 0
+        };
+      }
+    } catch {
+    }
+  }
+  const startTime = new Date(session.startedAt).getTime();
+  const now2 = Date.now();
+  const durationMinutes = Math.round((now2 - startTime) / 6e4);
+  return {
+    version: SNAPSHOT_VERSION,
+    capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    session,
+    handoff,
+    decisions,
+    observations,
+    activeTask,
+    durationMinutes
+  };
+}
+async function restoreSession(projectRoot, snapshot, options = {}, accessor) {
+  if (snapshot.version > SNAPSHOT_VERSION) {
+    throw new CleoError(
+      6 /* VALIDATION_ERROR */,
+      `Snapshot version ${snapshot.version} is newer than supported version ${SNAPSHOT_VERSION}`,
+      { fix: "Upgrade @cleocode/core to a newer version that supports this snapshot format" }
+    );
+  }
+  const acc = accessor ?? await getAccessor(projectRoot);
+  const activate = options.activate ?? true;
+  if (activate) {
+    const sessions2 = await acc.loadSessions();
+    const scope = snapshot.session.scope;
+    const activeConflict = sessions2.find(
+      (s) => s.status === "active" && s.scope.type === scope.type && s.scope.epicId === scope.epicId && s.id !== snapshot.session.id
+    );
+    if (activeConflict) {
+      throw new CleoError(
+        32 /* SCOPE_CONFLICT */,
+        `Active session '${activeConflict.id}' already exists for scope ${scope.type}${scope.epicId ? ":" + scope.epicId : ""}`,
+        {
+          fix: `End the active session first with 'cleo session end' or restore without activating`,
+          alternatives: [
+            { action: "End conflicting session", command: "cleo session end" },
+            { action: "Restore without activating", command: "Restore with activate: false" }
+          ]
+        }
+      );
+    }
+  }
+  const restoredSession = {
+    ...snapshot.session,
+    status: activate ? "active" : snapshot.session.status,
+    notes: [
+      ...snapshot.session.notes ?? [],
+      `Restored from snapshot at ${(/* @__PURE__ */ new Date()).toISOString()} (captured ${snapshot.capturedAt}, duration ${snapshot.durationMinutes}m)`
+    ],
+    resumeCount: (snapshot.session.resumeCount ?? 0) + 1
+  };
+  if (options.agent) {
+    restoredSession.agent = options.agent;
+    restoredSession.notes = [
+      ...restoredSession.notes ?? [],
+      `Agent handoff: ${snapshot.session.agent ?? "unknown"} \u2192 ${options.agent}`
+    ];
+  }
+  restoredSession.handoffJson = JSON.stringify(snapshot.handoff);
+  await acc.upsertSingleSession(restoredSession);
+  try {
+    const { hooks: hooks2 } = await Promise.resolve().then(() => (init_registry(), registry_exports));
+    await hooks2.dispatch("onSessionStart", projectRoot, {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      sessionId: restoredSession.id,
+      name: restoredSession.name,
+      scope: restoredSession.scope,
+      agent: restoredSession.agent,
+      restored: true,
+      snapshotCapturedAt: snapshot.capturedAt
+    });
+  } catch {
+  }
+  return restoredSession;
+}
+var SNAPSHOT_VERSION;
+var init_snapshot2 = __esm({
+  "packages/core/src/sessions/snapshot.ts"() {
+    "use strict";
+    init_src();
+    init_errors3();
+    init_data_accessor();
+    init_decisions();
+    init_handoff();
+    SNAPSHOT_VERSION = 1;
+  }
+});
+
 // packages/core/src/cleo.ts
 import path from "node:path";
 var Cleo;
@@ -67877,6 +68033,7 @@ var init_cleo = __esm({
     init_link_store();
     init_release2();
     init_sessions();
+    init_snapshot2();
     init_sticky();
     init_data_accessor();
     init_task_work();
@@ -67986,7 +68143,15 @@ var init_cleo = __esm({
           recordAssumption: (p) => recordAssumption(root, p),
           contextDrift: (p) => getContextDrift(root, p),
           decisionLog: (p) => getDecisionLog(root, { sessionId: p?.sessionId, taskId: p?.taskId }),
-          lastHandoff: (scope) => getLastHandoff(root, scope)
+          lastHandoff: (scope) => getLastHandoff(root, scope),
+          serialize: (p) => serializeSession(root, {
+            sessionId: p?.sessionId,
+            maxObservations: p?.maxObservations
+          }),
+          restore: (snapshot, p) => restoreSession(root, snapshot, {
+            agent: p?.agent,
+            activate: p?.activate
+          })
         };
       }
       // === Memory ===
@@ -68235,6 +68400,7 @@ var init_src2 = __esm({
     init_migration();
     init_reconciliation();
     init_sessions();
+    init_snapshot2();
     init_migrate();
     init_storage_preflight();
     init_task_work();
@@ -79483,6 +79649,7 @@ __export(internal_exports, {
   resolveTask: () => resolveTask,
   restoreBackup: () => restoreBackup,
   restoreFromBackup: () => restoreFromBackup,
+  restoreSession: () => restoreSession,
   resumeSession: () => resumeSession,
   roadmap: () => roadmap_exports,
   rollbackRelease: () => rollbackRelease,
@@ -79510,6 +79677,7 @@ __export(internal_exports, {
   selectSessionSchema: () => selectSessionSchema,
   selectTaskSchema: () => selectTaskSchema,
   sequence: () => sequence_exports,
+  serializeSession: () => serializeSession,
   sessionStatus: () => sessionStatus,
   sessionStatusSchema: () => sessionStatusSchema,
   sessions: () => sessions_exports,