ubume 0.1.0

package/src/session/conversation.ts

@@ -0,0 +1,107 @@
+import type { ProviderId } from "../core/providerLauncher/types.js";
+import type { ProviderBackendKind, ProviderRoute } from "../core/providerRuntime/types.js";
+import type { ConversationMessage, ConversationMetadata } from "../core/workspace/conversationStore.js";
+import type { AssistantEvent, TimelineEvent, UserPromptEvent } from "./types.js";
+
+/**
+ * Route restored by /resume. Local conversations must keep their saved backend:
+ * without it the route falls back to LM Studio's default endpoint, so an
+ * Unsloth-served model fails with a connection error.
+ */
+export function buildResumedProviderRoute(
+  metadata: Pick<ConversationMetadata, "modelId" | "backendKind" | "reasoning" | "localBackend">,
+  providerId: ProviderId,
+  fallbackBackendKind: ProviderBackendKind,
+): ProviderRoute {
+  return {
+    providerId,
+    modelId: metadata.modelId,
+    backendKind: metadata.backendKind && metadata.backendKind !== "unavailable"
+      ? metadata.backendKind as ProviderBackendKind
+      : fallbackBackendKind,
+    ...(metadata.reasoning ? { reasoning: metadata.reasoning } : {}),
+    ...(providerId === "local" && metadata.localBackend ? { localBackend: metadata.localBackend } : {}),
+  };
+}
+
+export function conversationMessagesToTimeline(
+  messages: readonly ConversationMessage[],
+  createEventId: () => number,
+  createTurnId?: () => number,
+): TimelineEvent[] {
+  const events: TimelineEvent[] = [];
+  // Restored turns must draw from the app's turn counter: the timeline groups
+  // events by turnId, so restored ids that collide with the next live turn
+  // would fold the new prompt and run into an old turn.
+  let localTurnId = 0;
+  const nextTurnId = createTurnId ?? (() => ++localTurnId);
+  let turnId = 0;
+  for (const message of messages) {
+    if (message.role === "user") {
+      turnId = nextTurnId();
+      const user: UserPromptEvent = {
+        id: createEventId(),
+        type: "user",
+        createdAt: Date.now(),
+        prompt: message.content,
+        turnId,
+      };
+      events.push(user);
+      continue;
+    }
+    const assistant: AssistantEvent = {
+      id: createEventId(),
+      type: "assistant",
+      createdAt: Date.now(),
+      content: message.activitySummary
+        ? `${message.content}\n\n---\n${message.activitySummary}`
+        : message.content,
+      contentChunks: [],
+      turnId,
+    };
+    events.push(assistant);
+  }
+  return events;
+}
+
+/**
+ * Plain role/content history for a provider request. Local Harness session
+ * reuse hashes this array, so activity summaries are only folded into content
+ * when requested (providers that restart from visible history).
+ */
+export function toProviderConversationHistory(
+  messages: readonly ConversationMessage[],
+  options: { includeActivitySummaries: boolean },
+): ConversationMessage[] {
+  return messages.map((message) => ({
+    role: message.role,
+    content: options.includeActivitySummaries && message.activitySummary
+      ? `${message.content}\n\n${message.activitySummary}`
+      : message.content,
+  }));
+}
+
+export function formatConversationHistory(messages: readonly ConversationMessage[]): string {
+  return messages.map((message) => {
+    const label = message.role === "user" ? "User" : "Assistant";
+    return `${label}:\n${message.content}`;
+  }).join("\n\n");
+}
+
+export function selectConversationContext(
+  messages: readonly ConversationMessage[],
+  maxCharacters?: number,
+): ConversationMessage[] {
+  if (!maxCharacters || maxCharacters <= 0) return [...messages];
+  const selected: ConversationMessage[] = [];
+  let total = 0;
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index];
+    if (!message) continue;
+    const cost = message.content.length;
+    if (selected.length > 0 && total + cost > maxCharacters) break;
+    selected.unshift(message);
+    total += cost;
+  }
+  return selected;
+}

package/src/session/liveRenderScheduler.ts

@@ -0,0 +1,214 @@
+import type { BackendProgressUpdate } from "../core/providers/types.js";
+import type { RunFileActivity } from "../core/workspace/workspaceActivity.js";
+import type { RunToolActivity } from "./types.js";
+import * as renderDebug from "../core/perf/renderDebug.js";
+
+export type LiveRenderUpdate =
+  | { type: "assistant"; chunk: string }
+  | { type: "plan"; chunk: string }
+  | { type: "progress"; update: BackendProgressUpdate }
+  | { type: "activity"; activity: RunFileActivity[] }
+  | { type: "tool"; activity: RunToolActivity };
+
+type TimerHandle = ReturnType<typeof setTimeout>;
+
+export interface LiveRenderSchedulerOptions {
+  flush: (updates: LiveRenderUpdate[]) => void;
+  assistantFlushMs: number;
+  progressOnlyFlushMs: number;
+  setTimer?: (callback: () => void, delayMs: number) => TimerHandle;
+  clearTimer?: (timer: TimerHandle) => void;
+}
+
+export interface LiveRenderScheduler {
+  enqueue: (update: LiveRenderUpdate) => void;
+  flushNow: () => boolean;
+  cancel: () => void;
+  hasPendingUpdates: () => boolean;
+  getStats: () => LiveRenderSchedulerStats;
+}
+
+export interface LiveRenderSchedulerStats {
+  providerEvents: number;
+  flushes: number;
+  averageFlushIntervalMs: number;
+  maxFlushIntervalMs: number;
+}
+
+// ─── Update coalescing ───────────────────────────────────────────────────────
+
+function findPendingUpdateIndex(
+  updates: LiveRenderUpdate[],
+  predicate: (update: LiveRenderUpdate) => boolean,
+): number {
+  for (let index = updates.length - 1; index >= 0; index -= 1) {
+    if (predicate(updates[index]!)) return index;
+  }
+  return -1;
+}
+
+function mergeLiveRenderUpdate(updates: LiveRenderUpdate[], update: LiveRenderUpdate): boolean {
+  const previous = updates[updates.length - 1];
+
+  if (update.type === "assistant" || update.type === "plan") {
+    if (previous?.type === update.type) {
+      previous.chunk += update.chunk;
+    } else {
+      updates.push({ ...update });
+    }
+    return true;
+  }
+
+  if (update.type === "progress") {
+    const index = findPendingUpdateIndex(
+      updates,
+      (pending) => pending.type === "progress" && pending.update.id === update.update.id,
+    );
+    if (index >= 0 && updates[index]?.type === "progress") {
+      updates[index] = update;
+    } else {
+      updates.push(update);
+    }
+    return false;
+  }
+
+  if (update.type === "tool") {
+    const index = findPendingUpdateIndex(
+      updates,
+      (pending) => pending.type === "tool" && pending.activity.id === update.activity.id,
+    );
+    if (index >= 0 && updates[index]?.type === "tool") {
+      const previousTool = updates[index];
+      updates[index] = {
+        type: "tool",
+        activity: { ...previousTool.activity, ...update.activity },
+      };
+    } else {
+      updates.push(update);
+    }
+    return false;
+  }
+
+  const activityIndex = findPendingUpdateIndex(updates, (pending) => pending.type === "activity");
+  if (activityIndex >= 0 && updates[activityIndex]?.type === "activity") {
+    updates[activityIndex].activity.push(...update.activity);
+  } else {
+    updates.push({ type: "activity", activity: [...update.activity] });
+  }
+  return false;
+}
+
+// ─── Scheduler ───────────────────────────────────────────────────────────────
+
+export function createLiveRenderScheduler({
+  flush,
+  assistantFlushMs,
+  progressOnlyFlushMs,
+  setTimer = setTimeout,
+  clearTimer = clearTimeout,
+}: LiveRenderSchedulerOptions): LiveRenderScheduler {
+  let pendingUpdates: LiveRenderUpdate[] = [];
+  let hasPendingAssistantDelta = false;
+  let timer: TimerHandle | null = null;
+  let isFlushing = false;
+  let flushAgain = false;
+  let providerEvents = 0;
+  let flushes = 0;
+  let totalFlushIntervalMs = 0;
+  let maxFlushIntervalMs = 0;
+  let lastFlushMonotonicMs: number | null = null;
+
+  const cancelScheduledFlush = () => {
+    if (timer) {
+      clearTimer(timer);
+      timer = null;
+    }
+  };
+
+  const drain = (): boolean => {
+    if (isFlushing) {
+      flushAgain = true;
+      return false;
+    }
+
+    cancelScheduledFlush();
+
+    if (pendingUpdates.length === 0) {
+      hasPendingAssistantDelta = false;
+      return false;
+    }
+
+    isFlushing = true;
+    let flushed = false;
+    try {
+      do {
+        flushAgain = false;
+        const updates = pendingUpdates;
+        pendingUpdates = [];
+        hasPendingAssistantDelta = false;
+        if (updates.length > 0) {
+          flushed = true;
+          const startedAt = performance.now();
+          flush(updates);
+          flushes += 1;
+          if (lastFlushMonotonicMs !== null) {
+            const intervalMs = Math.max(0, Math.round(startedAt - lastFlushMonotonicMs));
+            totalFlushIntervalMs += intervalMs;
+            maxFlushIntervalMs = Math.max(maxFlushIntervalMs, intervalMs);
+          }
+          lastFlushMonotonicMs = startedAt;
+          renderDebug.traceSchedulerFlush({
+            reason: updates.some((update) => update.type === "assistant" || update.type === "plan") ? "stream" : "progress",
+            updates: updates.length,
+            assistantChunks: updates.filter((update) => update.type === "assistant").length,
+            progressUpdates: updates.filter((update) => update.type === "progress").length,
+            toolUpdates: updates.filter((update) => update.type === "tool").length,
+            activityUpdates: updates.filter((update) => update.type === "activity").length,
+            durationMs: Math.round(performance.now() - startedAt),
+          });
+        }
+      } while (flushAgain || pendingUpdates.length > 0);
+    } finally {
+      isFlushing = false;
+    }
+
+    return flushed;
+  };
+
+  const schedule = () => {
+    if (timer || isFlushing) return;
+
+    const interval = hasPendingAssistantDelta ? assistantFlushMs : progressOnlyFlushMs;
+    timer = setTimer(() => {
+      timer = null;
+      drain();
+    }, interval);
+  };
+
+  return {
+    enqueue(update) {
+      providerEvents += 1;
+      const addedAssistant = mergeLiveRenderUpdate(pendingUpdates, update);
+      hasPendingAssistantDelta ||= addedAssistant;
+      schedule();
+    },
+    flushNow: drain,
+    cancel() {
+      cancelScheduledFlush();
+      pendingUpdates = [];
+      hasPendingAssistantDelta = false;
+    },
+    hasPendingUpdates() {
+      return pendingUpdates.length > 0;
+    },
+    getStats() {
+      const intervalCount = Math.max(0, flushes - 1);
+      return {
+        providerEvents,
+        flushes,
+        averageFlushIntervalMs: intervalCount > 0 ? Math.round(totalFlushIntervalMs / intervalCount) : 0,
+        maxFlushIntervalMs,
+      };
+    },
+  };
+}

package/src/session/persistedResponse.ts

@@ -0,0 +1,93 @@
+import type { ConversationMessage } from "../core/workspace/conversationStore.js";
+import type { RunFileOperation } from "../core/workspace/workspaceActivity.js";
+
+export type PersistedRunStatus = "completed" | "canceled" | "failed";
+
+export interface PersistedFileActivity {
+  path: string;
+  operation: RunFileOperation;
+}
+
+const MAX_SUMMARY_FILES = 20;
+const MAX_SUMMARY_COMMANDS = 10;
+const MAX_COMMAND_CHARS = 80;
+const MAX_ERROR_CHARS = 200;
+
+export function selectPersistedAssistantResponse(
+  renderedResponse: string | undefined,
+  completeResponse: string | undefined,
+): string | undefined {
+  return completeResponse ?? renderedResponse;
+}
+
+function truncate(value: string, maxChars: number): string {
+  return value.length > maxChars ? `${value.slice(0, maxChars - 1).trimEnd()}…` : value;
+}
+
+function joinCapped(items: readonly string[], cap: number): string {
+  const shown = items.slice(0, cap).join(", ");
+  return items.length > cap ? `${shown}, +${items.length - cap} more` : shown;
+}
+
+/** Compact, deterministic record of what a run did, stored with its reply for /resume. */
+export function formatRunActivitySummary(
+  toolCommands: readonly string[],
+  fileActivity: readonly PersistedFileActivity[],
+): string {
+  const files = new Map<string, RunFileOperation>();
+  for (const entry of fileActivity) {
+    const path = entry.path.trim();
+    if (!path) continue;
+    // A file created during the run stays "created" even if edited again.
+    if (files.get(path) === "created" && entry.operation === "modified") continue;
+    files.set(path, entry.operation);
+  }
+  const commands = [...new Set(
+    toolCommands
+      .map((command) => command.replace(/\s+/g, " ").trim())
+      .filter(Boolean)
+      .map((command) => truncate(command, MAX_COMMAND_CHARS)),
+  )];
+
+  const lines: string[] = [];
+  if (files.size > 0) {
+    lines.push(`Files changed: ${joinCapped([...files].map(([path, operation]) => `${path} (${operation})`), MAX_SUMMARY_FILES)}`);
+  }
+  if (commands.length > 0) {
+    lines.push(`Commands run: ${joinCapped(commands, MAX_SUMMARY_COMMANDS)}`);
+  }
+  return lines.join("\n");
+}
+
+/**
+ * Builds the assistant message saved for a finished run. Completed replies keep
+ * their content byte-for-byte (Local Harness session reuse hashes it) and carry
+ * the activity summary separately; interrupted replies keep whatever streamed.
+ */
+export function buildPersistedAssistantMessage(input: {
+  status: PersistedRunStatus;
+  renderedResponse?: string;
+  completeResponse?: string;
+  streamedText: string;
+  errorMessage?: string;
+  toolCommands: readonly string[];
+  fileActivity: readonly PersistedFileActivity[];
+}): ConversationMessage | undefined {
+  const summary = formatRunActivitySummary(input.toolCommands, input.fileActivity);
+
+  if (input.status === "completed") {
+    const content = selectPersistedAssistantResponse(input.renderedResponse, input.completeResponse);
+    if (content?.trim()) {
+      return { role: "assistant", content, ...(summary ? { activitySummary: summary } : {}) };
+    }
+    return summary ? { role: "assistant", content: summary } : undefined;
+  }
+
+  const partial = input.streamedText.trim();
+  if (!partial && !summary) return undefined;
+  const firstErrorLine = input.errorMessage?.split("\n").find((line) => line.trim())?.trim();
+  const note = input.status === "canceled"
+    ? "[Run canceled before finishing]"
+    : `[Run failed${firstErrorLine ? `: ${truncate(firstErrorLine, MAX_ERROR_CHARS)}` : ""}]`;
+  return { role: "assistant", content: [partial, note, summary].filter(Boolean).join("\n\n") };
+}

package/src/session/planFlow.ts

@@ -0,0 +1,159 @@
+import type { AvailableMode } from "../config/settings.js";
+
+export type PlanFeedbackMode = "revise" | "constraints";
+
+export interface PlanFeedbackRequest {
+  mode: PlanFeedbackMode;
+  text: string;
+}
+
+interface PlanFlowContext {
+  originalPrompt: string;
+  executionMode: AvailableMode;
+  constraints: string[];
+  planFilePath: string | null;
+}
+
+export type PlanFlowState =
+  | { kind: "idle" }
+  | (PlanFlowContext & {
+    kind: "generating";
+    currentPlan: string | null;
+    pendingFeedback: PlanFeedbackRequest | null;
+  })
+  | (PlanFlowContext & {
+    kind: "awaiting_action";
+    currentPlan: string;
+  })
+  | (PlanFlowContext & {
+    kind: "collecting_feedback";
+    currentPlan: string;
+    mode: PlanFeedbackMode;
+  })
+  | (PlanFlowContext & {
+    kind: "executing";
+    currentPlan: string;
+  });
+
+export type PlanGeneratingState = Extract<PlanFlowState, { kind: "generating" }>;
+export type PlanAwaitingActionState = Extract<PlanFlowState, { kind: "awaiting_action" }>;
+export type PlanCollectingFeedbackState = Extract<PlanFlowState, { kind: "collecting_feedback" }>;
+export type PlanExecutingState = Extract<PlanFlowState, { kind: "executing" }>;
+
+export function createInitialPlanFlowState(): PlanFlowState {
+  return { kind: "idle" };
+}
+
+/**
+ * The mode an approved plan executes under. Plan mode is orthogonal to the
+ * execution mode, so a session in `suggest` (read-only sandbox) can enter plan
+ * mode; approving the plan is an explicit request to write, so lift it to
+ * `auto-edit`. Write-capable modes are kept as-is.
+ */
+export function resolvePlanExecutionMode(mode: AvailableMode): AvailableMode {
+  return mode === "suggest" ? "auto-edit" : mode;
+}
+
+export function startPlanGeneration(originalPrompt: string, executionMode: AvailableMode): PlanGeneratingState {
+  return {
+    kind: "generating",
+    originalPrompt,
+    executionMode: resolvePlanExecutionMode(executionMode),
+    constraints: [],
+    planFilePath: null,
+    currentPlan: null,
+    pendingFeedback: null,
+  };
+}
+
+export function finishPlanGeneration(
+  state: PlanFlowState,
+  currentPlan: string,
+  planFilePath: string | null,
+): PlanFlowState {
+  if (state.kind !== "generating") {
+    return state;
+  }
+
+  return {
+    kind: "awaiting_action",
+    originalPrompt: state.originalPrompt,
+    executionMode: state.executionMode,
+    constraints: state.constraints,
+    currentPlan,
+    planFilePath,
+  };
+}
+
+export function beginPlanFeedback(state: PlanFlowState, mode: PlanFeedbackMode): PlanFlowState {
+  if (state.kind !== "awaiting_action") {
+    return state;
+  }
+
+  return {
+    kind: "collecting_feedback",
+    originalPrompt: state.originalPrompt,
+    executionMode: state.executionMode,
+    constraints: state.constraints,
+    currentPlan: state.currentPlan,
+    planFilePath: state.planFilePath,
+    mode,
+  };
+}
+
+export function submitPlanFeedback(state: PlanFlowState, text: string): PlanFlowState {
+  if (state.kind !== "collecting_feedback") {
+    return state;
+  }
+
+  const nextConstraints = state.mode === "constraints"
+    ? [...state.constraints, text]
+    : state.constraints;
+
+  return {
+    kind: "generating",
+    originalPrompt: state.originalPrompt,
+    executionMode: state.executionMode,
+    constraints: nextConstraints,
+    planFilePath: state.planFilePath,
+    currentPlan: state.currentPlan,
+    pendingFeedback: {
+      mode: state.mode,
+      text,
+    },
+  };
+}
+
+export function cancelPlanFeedback(state: PlanFlowState): PlanFlowState {
+  if (state.kind !== "collecting_feedback") {
+    return state;
+  }
+
+  return {
+    kind: "awaiting_action",
+    originalPrompt: state.originalPrompt,
+    executionMode: state.executionMode,
+    constraints: state.constraints,
+    currentPlan: state.currentPlan,
+    planFilePath: state.planFilePath,
+  };
+}
+
+export function approvePlanExecution(state: PlanFlowState): PlanFlowState {
+  if (state.kind !== "awaiting_action") {
+    return state;
+  }
+
+  return {
+    kind: "executing",
+    originalPrompt: state.originalPrompt,
+    executionMode: state.executionMode,
+    constraints: state.constraints,
+    currentPlan: state.currentPlan,
+    planFilePath: state.planFilePath,
+  };
+}
+
+export function resetPlanFlow(): PlanFlowState {
+  return createInitialPlanFlowState();
+}

package/src/session/planTranscript.ts

@@ -0,0 +1,19 @@
+import type { TimelineEvent } from "./types.js";
+import { getRunPlanText } from "./types.js";
+
+function normalizePlanText(text: string): string {
+  return text.replace(/\s+/g, " ").trim();
+}
+
+export function hasFinalizedTranscriptPlan(events: readonly TimelineEvent[], planText: string | null | undefined): boolean {
+  const expected = normalizePlanText(planText ?? "");
+  if (!expected) return false;
+
+  return events.some((event) => {
+    if (event.type !== "run") return false;
+    if (event.status !== "completed") return false;
+    if (event.plan?.status !== "completed") return false;
+    const transcriptPlan = normalizePlanText(getRunPlanText(event.plan));
+    return transcriptPlan.length > 0 && transcriptPlan === expected;
+  });
+}

package/src/session/promptRunSchedule.ts

@@ -0,0 +1,26 @@
+export type CancelScheduledPromptRunStart = () => void;
+
+export function schedulePromptRunStartAfterVisibleCommit(
+  start: () => void,
+): CancelScheduledPromptRunStart {
+  let cancelled = false;
+  let timer: ReturnType<typeof setTimeout> | null = null;
+
+  queueMicrotask(() => {
+    if (cancelled) return;
+    timer = setTimeout(() => {
+      timer = null;
+      if (!cancelled) {
+        start();
+      }
+    }, 0);
+  });
+
+  return () => {
+    cancelled = true;
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+  };
+}