march-cli 0.1.38 → 0.1.39

package/src/cli/workspace/output-router.mjs

@@ -1,4 +1,4 @@
-const BACKGROUND_METHODS_TO_BUFFER = new Set([
+const RENDER_METHODS = new Set([
   "turnStart",
   "turnEnd",
   "assistantReplyEnd",
@@ -6,28 +6,35 @@ const BACKGROUND_METHODS_TO_BUFFER = new Set([
   "thinkingStart",
   "thinkingDelta",
   "thinkingEnd",
+  "thinkingBlock",
   "toolStart",
   "toolEnd",
   "retryStart",
   "retryEnd",
   "status",
-  "debugLines",
   "recall",
-  "providerQuotaSnapshot",
   "editDiff",
+  "write",
   "writeln",
+  "clearOutput",
 ]);
 
-export function createWorkspaceOutputRouter({ ui, activeProjectId, activeSessionId = null }) {
+const MAX_RENDER_EVENTS_PER_ROUTE = 4000;
+
+export function createWorkspaceOutputRouter({ ui, activeProjectId, activeSessionId = null, onRenderTimelineChange = null }) {
   let active = routeKey(activeProjectId, activeSessionId);
-  const buffers = new Map();
+  const timelines = new Map();
 
   return {
     setActiveProject(projectId) {
-      active = routeKey(projectId, null);
+      this.setActiveSession(projectId, null);
     },
-    setActiveSession(projectId, sessionId) {
-      active = routeKey(projectId, sessionId);
+    setActiveSession(projectId, sessionId, { renderTimeline = null } = {}) {
+      const next = routeKey(projectId, sessionId);
+      if (Array.isArray(renderTimeline)) setRenderEvents(next, renderTimeline);
+      if (next === active) return renderRoute(next);
+      active = next;
+      return renderRoute(next);
     },
     getActiveRouteKey() {
       return active;
@@ -46,8 +53,9 @@ export function createWorkspaceOutputRouter({ ui, activeProjectId, activeSession
           if (typeof value !== "function") return value;
           return (...args) => {
             const key = routeKey(projectId, typeof getSessionId === "function" ? getSessionId() : sessionId);
-            if (isActiveRoute(key) || !BACKGROUND_METHODS_TO_BUFFER.has(prop)) return value.apply(ui, args);
-            bufferBackgroundCall(key, prop, args);
+            if (!RENDER_METHODS.has(prop)) return value.apply(ui, args);
+            recordRenderEvent(key, prop, args);
+            if (key === active) return value.apply(ui, args);
             return undefined;
           };
         },
@@ -60,41 +68,47 @@ export function createWorkspaceOutputRouter({ ui, activeProjectId, activeSession
         },
       });
     },
-    getBufferedCalls(projectId, sessionId = null) {
-      return [...(buffers.get(routeKey(projectId, sessionId)) ?? [])];
+    renderActiveSession() {
+      return renderRoute(active);
     },
-    getBufferedCallCount(projectId, sessionId = null) {
-      return buffers.get(routeKey(projectId, sessionId))?.length ?? 0;
+    getRenderEvents(projectId, sessionId = null) {
+      return [...(timelines.get(routeKey(projectId, sessionId)) ?? [])];
     },
-    replayBufferedCalls(projectId, sessionId = null) {
-      const key = routeKey(projectId, sessionId);
-      const calls = buffers.get(key) ?? [];
-      buffers.delete(key);
-      for (const call of calls) replayBufferedCall(call);
-      return calls.length;
+    setRenderEvents(projectId, sessionId = null, events = []) {
+      setRenderEvents(routeKey(projectId, sessionId), events);
     },
-    clearBufferedCalls(projectId, sessionId = null) {
-      buffers.delete(routeKey(projectId, sessionId));
+    getRenderEventCount(projectId, sessionId = null) {
+      return timelines.get(routeKey(projectId, sessionId))?.length ?? 0;
     },
   };
 
-  function isActiveRoute(key) {
-    if (key === active) return true;
-    const current = parseRouteKey(active);
-    const candidate = parseRouteKey(key);
-    return current.sessionId == null && current.projectId === candidate.projectId;
+  function renderRoute(key) {
+    ui.clearOutput?.();
+    const events = timelines.get(key) ?? [];
+    for (const event of events) applyRenderEvent(event);
+    return events.length;
   }
 
-  function replayBufferedCall({ method, args }) {
+  function applyRenderEvent({ method, args }) {
     const value = ui[method];
     if (typeof value === "function") value.apply(ui, args);
   }
 
-  function bufferBackgroundCall(key, method, args) {
-    const calls = buffers.get(key) ?? [];
-    calls.push({ method, args, at: Date.now() });
-    if (calls.length > 2000) calls.splice(0, calls.length - 2000);
-    buffers.set(key, calls);
+  function recordRenderEvent(key, method, args) {
+    if (method === "clearOutput") {
+      timelines.delete(key);
+      onRenderTimelineChange?.({ ...parseRouteKey(key), events: [], event: { method, args } });
+      return;
+    }
+    const events = timelines.get(key) ?? [];
+    events.push({ method, args, at: Date.now() });
+    if (events.length > MAX_RENDER_EVENTS_PER_ROUTE) events.splice(0, events.length - MAX_RENDER_EVENTS_PER_ROUTE);
+    timelines.set(key, events);
+    onRenderTimelineChange?.({ ...parseRouteKey(key), events: [...events], event: { method, args } });
+  }
+
+  function setRenderEvents(key, events) {
+    timelines.set(key, normalizeRenderEvents(events));
   }
 }
 
@@ -106,3 +120,8 @@ function parseRouteKey(key) {
   const [projectId, sessionId = ""] = String(key ?? "").split(":", 2);
   return { projectId: projectId || null, sessionId: sessionId || null };
 }
+
+function normalizeRenderEvents(events) {
+  if (!Array.isArray(events)) return [];
+  return events.filter((event) => typeof event?.method === "string" && Array.isArray(event.args));
+}

package/src/cli/workspace/project-runtime.mjs

@@ -8,6 +8,7 @@ import { loadProjectLifecycleHookManifests } from "../../extensions/lifecycle-ma
 import { loadKeybindings } from "../input/keybindings.mjs";
 import { loadPromptTemplates } from "../input/prompt-templates.mjs";
 import { loadOrCreateProjectId } from "../../workspace/project-id.mjs";
+import { syncRuntimeSessionStateFromRunner } from "./runtime-session-state.mjs";
 
 export async function createWorkspaceProjectRuntime({
   project,
@@ -73,6 +74,7 @@ export async function createWorkspaceProjectRuntime({
     refreshStatusBar,
     onNotificationActivation,
   });
+  syncRuntimeSessionStateFromRunner(sessionState, runner, sessionsRoot);
 
   return {
     project,

package/src/cli/workspace/runtime-session-state.mjs

@@ -0,0 +1,9 @@
+import { join } from "node:path";
+
+export function syncRuntimeSessionStateFromRunner(sessionState, runner, sessionsRoot) {
+  const sessionId = runner?.getSessionStats?.()?.sessionId ?? null;
+  if (!sessionState || !sessionId) return null;
+  sessionState.sessionId = sessionId;
+  sessionState.sessionDir = sessionsRoot ? join(sessionsRoot, sessionId) : sessionState.sessionDir;
+  return sessionState;
+}

package/src/extensions/lifecycle-adapter.mjs

@@ -7,7 +7,7 @@ export const MARCH_LIFECYCLE_LAYERS = Object.freeze([
   {
     name: "march-agent-runtime",
     owner: "March runner",
-    effects: Object.freeze(["read-session-ref", "read-sidecar-metadata", "read-runtime-state"]),
+    effects: Object.freeze(["read-session-ref", "read-session-state", "read-runtime-state"]),
   },
   {
     name: "march-collaboration",
@@ -24,7 +24,7 @@ export const DEFAULT_MARCH_HOOK_POLICY = Object.freeze({
     "read-agent-ref",
     "read-workspace-ref",
     "read-session-ref",
-    "read-sidecar-metadata",
+    "read-session-state",
     "read-diff-metadata",
     "read-runtime-diagnostics",
     "write-diagnostics",

package/src/main.mjs

@@ -1,3 +1,4 @@
+import { createRequire } from "node:module";
 import { homedir } from "node:os";
 import { join, relative } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -13,6 +14,8 @@ import { installNetworkEnvironment } from "./network/environment.mjs";
 import { runEarlyCliCommand } from "./cli/startup/early-command.mjs";
 import { maybeRunGatewayDaemonCommand } from "./cli/startup/gateway-daemon-command.mjs";
 
+const { version: packageVersion } = createRequire(import.meta.url)("../package.json");
+
 export async function run(argv) {
   const cwd = process.cwd();
   loadDotEnv(cwd);
@@ -23,6 +26,10 @@ export async function run(argv) {
     showHelp();
     return 0;
   }
+  if (args.version) {
+    process.stdout.write(`${packageVersion}\n`);
+    return 0;
+  }
 
   const config = loadConfig(cwd);
   const stateRoot = join(homedir(), ".march");
@@ -67,7 +74,6 @@ export async function run(argv) {
   }
 
   const dumpContextPath = args.dumpContext ? relative(cwd, app.contextDumpRoot) : null;
-  if (app.startupResume.transcriptTurns?.length > 0) app.ui.restoreTranscript?.(app.startupResume.transcriptTurns);
   for (const line of formatStartupBanner({ cwd, modelId: app.runner.engine.modelId, thinkingLevel: app.runner.engine.thinkingLevel, mode: app.modeState.get(), dumpContextPath })) app.ui.writeln(line);
   try {
     await runInteractiveRepl({

package/src/session/sidecar-sync.mjs

@@ -1,19 +1,5 @@
-import { savePiSessionSidecar } from "./sidecar.mjs";
+import { syncMarchSessionState } from "./state/march-session-sync.mjs";
 
-export function syncPiSessionSidecar({ enabled = false, projectMarchDir, engine, sessionStats, metadata = {} }) {
-  if (!enabled || !projectMarchDir || !sessionStats?.persisted || !sessionStats.sessionFile) {
-    return null;
-  }
-
-  return savePiSessionSidecar({
-    projectMarchDir,
-    sessionRef: sessionStats.sessionFile,
-    engine,
-    metadata: {
-      sessionId: sessionStats.sessionId,
-      sessionFile: sessionStats.sessionFile,
-      runtimeHost: Boolean(sessionStats.runtimeHost),
-      ...metadata,
-    },
-  });
+export function syncPiSessionSidecar(options) {
+  return syncMarchSessionState(options);
 }

package/src/session/sidecar.mjs

@@ -1,69 +1,68 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { basename, join } from "node:path";
+import {
+  captureMarchSessionState,
+  getLegacyPiSidecarDir,
+  getLegacyPiSidecarPath,
+  loadMarchSessionStateForPiBackend,
+  loadLegacyPiSidecar,
+  saveMarchSessionStateValue,
+} from "./state/march-session-state.mjs";
 
 export const PI_SIDECAR_VERSION = 1;
 
 export function getPiSidecarDir(projectMarchDir) {
-  return join(projectMarchDir, "pi-sidecars");
+  return getLegacyPiSidecarDir(projectMarchDir);
 }
 
 export function getPiSidecarPath(projectMarchDir, sessionRef) {
-  return join(getPiSidecarDir(projectMarchDir), `${normalizeSessionRef(sessionRef)}.json`);
+  return getLegacyPiSidecarPath(projectMarchDir, sessionRef);
 }
 
 export function captureContextSidecar(engine, metadata = {}) {
-  return {
-    version: PI_SIDECAR_VERSION,
-    savedAt: new Date().toISOString(),
-    ...metadata,
-    cwd: engine.cwd,
-    modelId: engine.modelId,
-    provider: engine.provider,
-    sessionName: engine.sessionName ?? "",
-    thinkingLevel: engine.thinkingLevel,
-    namespace: engine.namespace,
-    pendingAssistantRecallHints: engine.pendingAssistantRecallHints ?? [],
-    turns: engine.turns,
-  };
+  return captureMarchSessionState(engine, {
+    sessionId: metadata.sessionId,
+    backend: {
+      type: "pi",
+      sessionId: metadata.sessionId ?? null,
+      sessionFile: metadata.sessionFile ?? null,
+      runtimeHost: Boolean(metadata.runtimeHost),
+    },
+    metadata,
+  });
 }
 
 export function savePiSessionSidecar({ projectMarchDir, sessionRef, engine, metadata = {} }) {
   return savePiSessionSidecarState({
     projectMarchDir,
     sessionRef,
-    state: captureContextSidecar(engine, metadata),
+    state: captureContextSidecar(engine, { sessionFile: sessionRef, ...metadata }),
   });
 }
 
 export function savePiSessionSidecarState({ projectMarchDir, sessionRef, state }) {
-  const sidecarDir = getPiSidecarDir(projectMarchDir);
-  mkdirSync(sidecarDir, { recursive: true });
-  validateSidecarState(state);
-  const path = getPiSidecarPath(projectMarchDir, sessionRef);
-  writeFileSync(path, JSON.stringify(state, null, 2), "utf8");
-  return { path, state };
+  return saveMarchSessionStateValue({
+    projectMarchDir,
+    sessionId: state.sessionId ?? state.backend?.sessionId ?? state.sessionFile ?? sessionRef,
+    state: normalizeLegacyState(state, sessionRef),
+  });
 }
 
 export function loadPiSessionSidecar({ projectMarchDir, sessionRef }) {
-  const path = getPiSidecarPath(projectMarchDir, sessionRef);
-  if (!existsSync(path)) return null;
-  const state = JSON.parse(readFileSync(path, "utf8"));
-  if (!isValidSidecarState(state)) {
-    throw new Error("Invalid pi session sidecar");
-  }
-  return { path, state };
+  return loadMarchSessionStateForPiBackend({ projectMarchDir, sessionId: null, sessionRef }) ?? loadLegacyPiSidecar({ projectMarchDir, sessionRef });
 }
 
-function validateSidecarState(state) {
-  if (!isValidSidecarState(state)) throw new Error("Invalid pi session sidecar");
+export function loadPiSessionContextState({ projectMarchDir, sessionRef, sessionId = null }) {
+  return loadMarchSessionStateForPiBackend({ projectMarchDir, sessionId, sessionRef });
 }
 
-function isValidSidecarState(state) {
-  return state?.version === PI_SIDECAR_VERSION && Boolean(state.cwd) && Array.isArray(state.turns);
-}
-
-function normalizeSessionRef(sessionRef) {
-  const ref = basename(String(sessionRef).trim()).replace(/\.jsonl$/i, "");
-  if (!ref || ref === "." || ref === "..") throw new Error("Invalid pi session reference");
-  return ref.replace(/[^a-zA-Z0-9._-]/g, "_");
+function normalizeLegacyState(state, sessionRef) {
+  return {
+    ...state,
+    sessionId: state.sessionId ?? state.backend?.sessionId ?? state.sessionFile ?? sessionRef,
+    backend: state.backend ?? {
+      type: "pi",
+      sessionId: state.sessionId ?? null,
+      sessionFile: state.sessionFile ?? sessionRef,
+      runtimeHost: Boolean(state.runtimeHost),
+    },
+  };
 }

package/src/session/state/march-session-state.mjs

@@ -0,0 +1,175 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { basename, join } from "node:path";
+import { loadPiSessionTranscriptTurns } from "../transcript.mjs";
+
+export const MARCH_SESSION_STATE_VERSION = 1;
+
+export function getMarchSessionStateRoot(projectMarchDir) {
+  return join(projectMarchDir, "sessions");
+}
+
+export function getMarchSessionStateDir(projectMarchDir, sessionId) {
+  return join(getMarchSessionStateRoot(projectMarchDir), normalizeSessionId(sessionId));
+}
+
+export function getMarchSessionStatePath(projectMarchDir, sessionId) {
+  return join(getMarchSessionStateDir(projectMarchDir, sessionId), "state.json");
+}
+
+export function captureMarchSessionState(engine, { sessionId, backend = null, metadata = {} } = {}) {
+  return {
+    version: MARCH_SESSION_STATE_VERSION,
+    savedAt: new Date().toISOString(),
+    sessionId: sessionId ?? metadata.sessionId ?? backend?.sessionId ?? null,
+    backend,
+    ...metadata,
+    cwd: engine.cwd,
+    modelId: engine.modelId,
+    provider: engine.provider,
+    sessionName: engine.sessionName ?? "",
+    thinkingLevel: engine.thinkingLevel,
+    namespace: engine.namespace,
+    pendingAssistantRecallHints: engine.pendingAssistantRecallHints ?? [],
+    turns: engine.turns,
+  };
+}
+
+export function saveMarchSessionState({ projectMarchDir, sessionId, engine, backend = null, metadata = {} }) {
+  return saveMarchSessionStateValue({
+    projectMarchDir,
+    sessionId,
+    state: captureMarchSessionState(engine, { sessionId, backend, metadata }),
+  });
+}
+
+export function saveMarchSessionStateValue({ projectMarchDir, sessionId, state }) {
+  if (!sessionId) throw new Error("March session id is required");
+  const existing = loadMarchSessionState({ projectMarchDir, sessionId })?.state ?? null;
+  const nextState = normalizeMarchSessionStateForSave({ ...existing, ...state, renderTimeline: state.renderTimeline ?? existing?.renderTimeline });
+  validateMarchSessionState(nextState);
+  const dir = getMarchSessionStateDir(projectMarchDir, sessionId);
+  mkdirSync(dir, { recursive: true });
+  const path = getMarchSessionStatePath(projectMarchDir, sessionId);
+  writeFileSync(path, JSON.stringify({ ...nextState, sessionId: nextState.sessionId ?? sessionId }, null, 2), "utf8");
+  return { path, state: { ...nextState, sessionId: nextState.sessionId ?? sessionId } };
+}
+
+export function loadMarchSessionState({ projectMarchDir, sessionId }) {
+  const path = getMarchSessionStatePath(projectMarchDir, sessionId);
+  if (!existsSync(path)) return null;
+  const state = normalizeMarchSessionStateForSave(JSON.parse(readFileSync(path, "utf8")));
+  if (!isValidMarchSessionState(state)) throw new Error("Invalid March session state");
+  return { path, state };
+}
+
+export function loadMarchSessionContextState({ projectMarchDir, sessionId, backendSessionFile = null }) {
+  const stored = loadMarchSessionState({ projectMarchDir, sessionId });
+  if (!stored) return null;
+  const sessionFile = backendSessionFile ?? stored.state.backend?.sessionFile ?? stored.state.sessionFile ?? null;
+  return { ...stored, state: withBackendTranscriptTurns(stored.state, sessionFile) };
+}
+
+export function listMarchSessionStates({ projectMarchDir }) {
+  const root = getMarchSessionStateRoot(projectMarchDir);
+  if (!existsSync(root)) return [];
+  return readdirSync(root, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => {
+      try {
+        return loadMarchSessionState({ projectMarchDir, sessionId: entry.name });
+      } catch {
+        return null;
+      }
+    })
+    .filter(Boolean);
+}
+
+export function loadMarchSessionStateForPiBackend({ projectMarchDir, sessionId, sessionRef }) {
+  const marchState = sessionId ? loadMarchSessionContextState({ projectMarchDir, sessionId, backendSessionFile: sessionRef }) : null;
+  if (marchState) return marchState;
+  const matchingState = findMarchSessionStateByPiBackend({ projectMarchDir, sessionRef });
+  if (matchingState) return { ...matchingState, state: withBackendTranscriptTurns(matchingState.state, sessionRef) };
+  return loadLegacyPiSidecarContextState({ projectMarchDir, sessionRef });
+}
+
+function findMarchSessionStateByPiBackend({ projectMarchDir, sessionRef }) {
+  const normalizedRef = normalizeSessionRef(sessionRef);
+  return listMarchSessionStates({ projectMarchDir }).find(({ state }) => {
+    const sessionFile = state.backend?.sessionFile ?? state.sessionFile ?? null;
+    return sessionFile && normalizeSessionRef(sessionFile) === normalizedRef;
+  }) ?? null;
+}
+
+export function getLegacyPiSidecarDir(projectMarchDir) {
+  return join(projectMarchDir, "pi-sidecars");
+}
+
+export function getLegacyPiSidecarPath(projectMarchDir, sessionRef) {
+  return join(getLegacyPiSidecarDir(projectMarchDir), `${normalizeSessionRef(sessionRef)}.json`);
+}
+
+export function loadLegacyPiSidecar({ projectMarchDir, sessionRef }) {
+  const path = getLegacyPiSidecarPath(projectMarchDir, sessionRef);
+  if (!existsSync(path)) return null;
+  const state = normalizeMarchSessionStateForSave(JSON.parse(readFileSync(path, "utf8")));
+  if (!isValidMarchSessionState(state)) throw new Error("Invalid March session state");
+  return { path, state };
+}
+
+export function loadLegacyPiSidecarContextState({ projectMarchDir, sessionRef }) {
+  const legacy = loadLegacyPiSidecar({ projectMarchDir, sessionRef });
+  if (!legacy) return null;
+  return { ...legacy, state: withBackendTranscriptTurns(legacy.state, sessionRef) };
+}
+
+export function normalizeSessionId(sessionId) {
+  const value = String(sessionId ?? "").trim();
+  if (!value || value === "." || value === "..") throw new Error("Invalid March session id");
+  return value.replace(/[^a-zA-Z0-9._-]/g, "_");
+}
+
+function validateMarchSessionState(state) {
+  if (!isValidMarchSessionState(state)) throw new Error("Invalid March session state");
+}
+
+function isValidMarchSessionState(state) {
+  return state?.version === MARCH_SESSION_STATE_VERSION
+    && Boolean(state.cwd)
+    && Array.isArray(state.turns)
+    && Array.isArray(state.renderTimeline);
+}
+
+function normalizeMarchSessionStateForSave(state) {
+  return {
+    ...state,
+    renderTimeline: normalizePersistedRenderTimeline(state.renderTimeline),
+  };
+}
+
+function normalizePersistedRenderTimeline(events) {
+  if (!Array.isArray(events)) return [];
+  return events
+    .filter((event) => typeof event?.method === "string" && Array.isArray(event.args))
+    .map((event) => ({ method: event.method, args: event.args, at: event.at ?? null }));
+}
+
+function normalizeSessionRef(sessionRef) {
+  const ref = basename(String(sessionRef).trim()).replace(/\.jsonl$/i, "");
+  if (!ref || ref === "." || ref === "..") throw new Error("Invalid pi session reference");
+  return ref.replace(/[^a-zA-Z0-9._-]/g, "_");
+}
+
+function withBackendTranscriptTurns(state, sessionFile) {
+  if (!sessionFile) return { ...state };
+  let transcriptTurns = [];
+  try {
+    transcriptTurns = loadPiSessionTranscriptTurns(sessionFile);
+  } catch {
+    return { ...state };
+  }
+  if (transcriptTurns.length <= (state.turns?.length ?? 0)) return { ...state };
+  return {
+    ...state,
+    turns: transcriptTurns,
+  };
+}

package/src/session/state/march-session-sync.mjs

@@ -0,0 +1,20 @@
+import { saveMarchSessionState } from "./march-session-state.mjs";
+
+export function syncMarchSessionState({ enabled = false, projectMarchDir, engine, sessionStats, metadata = {} }) {
+  if (!enabled || !projectMarchDir || !sessionStats?.persisted || !sessionStats.sessionId) {
+    return null;
+  }
+
+  return saveMarchSessionState({
+    projectMarchDir,
+    sessionId: sessionStats.sessionId,
+    engine,
+    backend: {
+      type: "pi",
+      sessionId: sessionStats.sessionId,
+      sessionFile: sessionStats.sessionFile ?? null,
+      runtimeHost: Boolean(sessionStats.runtimeHost),
+    },
+    metadata,
+  });
+}

package/src/session/state/march-session-ui-state.mjs

@@ -0,0 +1,60 @@
+import { existsSync, readFileSync } from "node:fs";
+import { getMarchSessionStatePath, loadMarchSessionState, saveMarchSessionStateValue } from "./march-session-state.mjs";
+
+export function loadMarchSessionRenderTimeline({ projectMarchDir, sessionId }) {
+  const persistedRender = readPersistedRenderTimelineInfo({ projectMarchDir, sessionId });
+  const stored = loadMarchSessionState({ projectMarchDir, sessionId });
+  if (!stored) return null;
+  const renderTimeline = normalizeSessionRenderTimeline(stored.state.renderTimeline);
+  return {
+    path: stored.path,
+    renderTimeline: persistedRender.hasUiOwnedTimeline ? renderTimeline : renderTimelineFromTurns(stored.state.turns ?? []),
+  };
+}
+
+export function saveMarchSessionRenderTimeline({ projectMarchDir, sessionId, renderTimeline }) {
+  const stored = loadMarchSessionState({ projectMarchDir, sessionId });
+  if (!stored) return null;
+  return saveMarchSessionStateValue({
+    projectMarchDir,
+    sessionId,
+    state: {
+      ...stored.state,
+      renderTimeline: normalizeSessionRenderTimeline(renderTimeline),
+      renderTimelineUpdatedAt: new Date().toISOString(),
+    },
+  });
+}
+
+export function normalizeSessionRenderTimeline(events) {
+  if (!Array.isArray(events)) return [];
+  return events
+    .filter((event) => typeof event?.method === "string" && Array.isArray(event.args))
+    .map((event) => ({ method: event.method, args: event.args, at: event.at ?? null }));
+}
+
+function readPersistedRenderTimelineInfo({ projectMarchDir, sessionId }) {
+  try {
+    const path = getMarchSessionStatePath(projectMarchDir, sessionId);
+    if (!existsSync(path)) return { hasUiOwnedTimeline: false };
+    const raw = JSON.parse(readFileSync(path, "utf8"));
+    const rawTimeline = normalizeSessionRenderTimeline(raw.renderTimeline);
+    return { hasUiOwnedTimeline: Boolean(raw.renderTimelineUpdatedAt) || rawTimeline.length > 0 };
+  } catch {
+    return { hasUiOwnedTimeline: false };
+  }
+}
+
+function renderTimelineFromTurns(turns) {
+  return turns.flatMap((turn) => {
+    const events = [];
+    if (turn.userMessage) events.push({ method: "writeln", args: [turn.userMessage], at: null });
+    if (turn.assistantMessage) {
+      events.push({ method: "turnStart", args: [], at: null });
+      events.push({ method: "textDelta", args: [turn.assistantMessage], at: null });
+      events.push({ method: "assistantReplyEnd", args: [], at: null });
+      events.push({ method: "turnEnd", args: [], at: null });
+    }
+    return events;
+  });
+}

package/src/workspace/session-index.mjs

@@ -1,5 +1,6 @@
 import { resolve } from "node:path";
 import { listPiSessionInfos } from "../session/pi-manager.mjs";
+import { listMarchSessionStates } from "../session/state/march-session-state.mjs";
 import { listRegisteredProjects } from "./project-registry.mjs";
 
 export async function listWorkspaceSessions({ stateRoot, currentProjectId = null, listSessions = listPiSessionInfos }) {
@@ -10,6 +11,7 @@ export async function listWorkspaceSessions({ stateRoot, currentProjectId = null
     let sessions = [];
     try {
       sessions = await listSessions({ cwd: project.rootPath, projectMarchDir });
+      sessions = mergeMarchSessionStates({ projectMarchDir, backendSessions: sessions });
     } catch {
       sessions = [];
     }
@@ -73,3 +75,28 @@ function formatWorkspaceSessionTime(value) {
   if (!value) return "no saved time";
   return String(value).slice(0, 16).replace("T", " ");
 }
+
+function mergeMarchSessionStates({ projectMarchDir, backendSessions }) {
+  const backendById = new Map(backendSessions.map((session) => [session.id, session]));
+  const backendByPath = new Map(backendSessions.map((session) => [session.path, session]));
+  const marchSessions = listMarchSessionStates({ projectMarchDir }).map(({ state }) => {
+    const backend = state.backend?.type === "pi"
+      ? backendById.get(state.backend.sessionId) ?? backendByPath.get(state.backend.sessionFile)
+      : null;
+    return {
+      id: state.sessionId,
+      path: state.backend?.sessionFile ?? backend?.path ?? null,
+      savedAt: state.savedAt,
+      createdAt: backend?.createdAt ?? "",
+      cwd: state.cwd,
+      name: state.sessionName || backend?.name || "",
+      turnCount: state.turns?.length ?? backend?.turnCount ?? 0,
+      firstMessage: state.turns?.[0]?.userMessage ?? backend?.firstMessage ?? "",
+      parentSessionPath: backend?.parentSessionPath ?? null,
+      backend,
+    };
+  });
+  const seenBackendIds = new Set(marchSessions.map((session) => session.backend?.id).filter(Boolean));
+  const legacyBackendSessions = backendSessions.filter((session) => !seenBackendIds.has(session.id));
+  return [...marchSessions, ...legacyBackendSessions];
+}