@wenathlan/devthink 1.1.16 → 2.0.9

package/session.ts

@@ -1,155 +0,0 @@
-/** DevThink session model: one stable identity contract for CLI, gateway, local database, and URL-addressable web state. */
-import { existsSync, readFileSync, readdirSync, renameSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { ensurePaths, type DevThinkPaths } from "./config.ts";
-import type { ChatMessage } from "./providers.ts";
-import { createCompactId } from "./ids.ts";
-import { mirrorSession, type StoredSession, type StoredWorkspace } from "./storage.ts";
-
-export type SessionSection = "chat" | "inspector" | "settings" | "memory" | "providers" | "projects" | "routes" | "usage";
-export type SessionTab = { id: string; sessionId: string; workspaceId: string; label: string; provider?: string; sectionId: SessionSection; createdAt: string; updatedAt: string };
-export type SessionMessage = ChatMessage & { id: string; sessionId: string; workspaceId: string; tabId: string; sectionId: SessionSection; createdAt: string };
-export type Workspace = { id: string; title: string; createdAt: string; updatedAt: string };
-
-export type Session = {
-  id: string;
-  workspaceId: string;
-  title: string;
-  mode: string;
-  model?: string;
-  provider?: string;
-  createdAt: string;
-  updatedAt: string;
-  activeTabId: string;
-  tabs: SessionTab[];
-  messages: SessionMessage[];
-};
-
-function sessionPath(paths: DevThinkPaths, id: string): string {
-  return join(paths.sessions, `${id}.json`);
-}
-
-function safeTitle(messages: SessionMessage[]): string {
-  const first = messages.find((message) => message.role === "user");
-  return first?.content.slice(0, 80) || "Untitled session";
-}
-
-function workspacePath(paths: DevThinkPaths, id: string): string {
-  return join(paths.workspaces, `${id}.json`);
-}
-
-function atomicWrite(path: string, value: unknown): void {
-  const temporary = `${path}.${process.pid}.${Date.now()}.tmp`;
-  writeFileSync(temporary, `${JSON.stringify(value, null, 2)}\n`, "utf8");
-  renameSync(temporary, path);
-}
-
-function newWorkspace(id = createCompactId("w"), title = "Untitled workspace", now = new Date().toISOString()): Workspace {
-  return { id, title, createdAt: now, updatedAt: now };
-}
-
-function newTab(sessionId: string, workspaceId: string, provider: string | undefined, label: string, sectionId: SessionSection, now: string, id = createCompactId("t")): SessionTab {
-  return { id, sessionId, workspaceId, provider, label, sectionId, createdAt: now, updatedAt: now };
-}
-
-function normalizeSession(raw: Session): Session {
-  const now = raw.updatedAt || new Date().toISOString();
-  const workspaceId = raw.workspaceId || createCompactId("w");
-  const tabs = raw.tabs?.length ? raw.tabs.map((tab) => ({ ...tab, sessionId: raw.id, workspaceId, sectionId: tab.sectionId || "chat" as SessionSection })) : [newTab(raw.id, workspaceId, raw.provider, raw.title || "Untitled session", "chat", now)];
-  const activeTabId = tabs.some((tab) => tab.id === raw.activeTabId) ? raw.activeTabId : tabs[0].id;
-  const messages = (raw.messages || []).map((message) => ({ ...message, id: message.id || createCompactId("m"), sessionId: raw.id, workspaceId, tabId: message.tabId || activeTabId, sectionId: message.sectionId || "chat" as SessionSection, createdAt: message.createdAt || now }));
-  return { ...raw, workspaceId, activeTabId, tabs, messages };
-}
-
-function readSession(path: string): Session | undefined {
-  try {
-    if (!existsSync(path)) return undefined;
-    return normalizeSession(JSON.parse(readFileSync(path, "utf8")) as Session);
-  } catch {
-    return undefined;
-  }
-}
-
-function workspaceFor(session: Session): Workspace {
-  const title = session.title === "Untitled session" ? "Untitled workspace" : session.title;
-  return newWorkspace(session.workspaceId, title, session.createdAt);
-}
-
-function saveSession(paths: DevThinkPaths, session: Session): Session {
-  ensurePaths(paths);
-  const normalized = normalizeSession(session);
-  const existing = loadWorkspace(paths, normalized.workspaceId);
-  const workspace = { ...(existing || workspaceFor(normalized)), title: normalized.title === "Untitled session" ? existing?.title || "Untitled workspace" : normalized.title, updatedAt: normalized.updatedAt };
-  atomicWrite(sessionPath(paths, normalized.id), normalized);
-  atomicWrite(workspacePath(paths, workspace.id), workspace);
-  mirrorSession(paths, workspace as StoredWorkspace, normalized as StoredSession);
-  return normalized;
-}
-
-export function createWorkspace(paths: DevThinkPaths, title = "Untitled workspace", id = createCompactId("w")): Workspace {
-  ensurePaths(paths);
-  const workspace = newWorkspace(id, title);
-  atomicWrite(workspacePath(paths, id), workspace);
-  return workspace;
-}
-
-export function loadWorkspace(paths: DevThinkPaths, id: string): Workspace | undefined {
-  try {
-    if (!existsSync(workspacePath(paths, id))) return undefined;
-    return JSON.parse(readFileSync(workspacePath(paths, id), "utf8")) as Workspace;
-  } catch {
-    return undefined;
-  }
-}
-
-export function createSession(paths: DevThinkPaths, metadata: Pick<Session, "mode" | "model" | "provider"> & { workspaceId?: string; tabId?: string; sectionId?: SessionSection; title?: string }): Session {
-  const now = new Date().toISOString();
-  const id = createCompactId("s");
-  const workspace = metadata.workspaceId ? loadWorkspace(paths, metadata.workspaceId) || createWorkspace(paths, "Untitled workspace", metadata.workspaceId) : createWorkspace(paths);
-  const tab = newTab(id, workspace.id, metadata.provider, metadata.title || "Untitled session", metadata.sectionId || "chat", now, metadata.tabId);
-  const session: Session = { id, workspaceId: workspace.id, title: metadata.title || "Untitled session", mode: metadata.mode, model: metadata.model, provider: metadata.provider, createdAt: now, updatedAt: now, activeTabId: tab.id, tabs: [tab], messages: [] };
-  return saveSession(paths, session);
-}
-
-export function loadSession(paths: DevThinkPaths, id: string): Session | undefined {
-  const session = readSession(sessionPath(paths, id));
-  return session ? saveSession(paths, session) : undefined;
-}
-
-export function createTab(paths: DevThinkPaths, session: Session, input: { id?: string; label?: string; provider?: string; sectionId?: SessionSection }): Session {
-  const now = new Date().toISOString();
-  const tab = newTab(session.id, session.workspaceId, input.provider || session.provider, input.label || "New session", input.sectionId || "chat", now, input.id);
-  return saveSession(paths, { ...session, activeTabId: tab.id, updatedAt: now, tabs: [...session.tabs, tab] });
-}
-
-export function updateTab(paths: DevThinkPaths, session: Session, tabId: string, input: Partial<Pick<SessionTab, "label" | "provider" | "sectionId">>): Session {
-  const now = new Date().toISOString();
-  const tabs = session.tabs.map((tab) => tab.id === tabId ? { ...tab, ...input, updatedAt: now } : tab);
-  if (!tabs.some((tab) => tab.id === tabId)) throw new Error(`Tab not found: ${tabId}`);
-  return saveSession(paths, { ...session, activeTabId: tabId, updatedAt: now, tabs });
-}
-
-export function appendMessage(paths: DevThinkPaths, session: Session, message: ChatMessage, context?: { tabId?: string; sectionId?: SessionSection; id?: string }): Session {
-  const now = new Date().toISOString();
-  const tabId = context?.tabId || session.activeTabId;
-  if (!session.tabs.some((tab) => tab.id === tabId)) throw new Error(`Tab not found: ${tabId}`);
-  const nextMessages = [...session.messages, { ...message, id: context?.id || createCompactId("m"), sessionId: session.id, workspaceId: session.workspaceId, tabId, sectionId: context?.sectionId || "chat", createdAt: now }];
-  return saveSession(paths, { ...session, title: safeTitle(nextMessages), updatedAt: now, messages: nextMessages });
-}
-
-export function listSessions(paths: DevThinkPaths): Session[] {
-  if (!existsSync(paths.sessions)) return [];
-  return readdirSync(paths.sessions).filter((file) => file.endsWith(".json") && !file.endsWith(".memory.json")).map((file) => readSession(join(paths.sessions, file))).filter((session): session is Session => Boolean(session)).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
-}
-
-export function renderSessionMarkdown(session: Session): string {
-  const lines = [`# ${session.title}`, "", `- Workspace: ${session.workspaceId}`, `- Session: ${session.id}`, `- Active tab: ${session.activeTabId}`, `- Mode: ${session.mode}`, `- Provider: ${session.provider || "not configured"}`, `- Model: ${session.model || "not configured"}`, ""];
-  for (const message of session.messages) lines.push(`## ${message.role}`, "", message.content, "");
-  return `${lines.join("\n")}\n`;
-}
-
-export function exportSession(paths: DevThinkPaths, id: string, format: "json" | "markdown"): string {
-  const session = loadSession(paths, id);
-  if (!session) throw new Error(`Session not found: ${id}`);
-  return format === "json" ? `${JSON.stringify(session, null, 2)}\n` : renderSessionMarkdown(session);
-}

package/storage.ts

@@ -1,82 +0,0 @@
-/** DevThink local store: mirrors credential-free workbench records into a physical SQLite database. */
-import type { DevThinkPaths } from "./config.ts";
-
-type Statement = { run: (...values: unknown[]) => unknown; all: (...values: unknown[]) => unknown[] };
-type Database = { exec: (sql: string) => unknown; prepare: (sql: string) => Statement; close: () => void };
-type DatabaseConstructor = new (path: string) => Database;
-
-const sqliteModule = await import(process.versions.bun ? "bun:sqlite" : "node:sqlite");
-const DatabaseDriver = (process.versions.bun ? sqliteModule.Database : sqliteModule.DatabaseSync) as unknown as DatabaseConstructor;
-
-export type StoredWorkspace = { id: string; title: string; createdAt: string; updatedAt: string };
-export type StoredTab = { id: string; sessionId: string; workspaceId: string; label: string; provider?: string; sectionId: string; createdAt: string; updatedAt: string };
-export type StoredMessage = { id: string; sessionId: string; workspaceId: string; tabId: string; sectionId: string; role: string; content: string; createdAt: string };
-export type StoredSession = { id: string; workspaceId: string; title: string; mode: string; model?: string; provider?: string; activeTabId: string; createdAt: string; updatedAt: string; tabs: StoredTab[]; messages: StoredMessage[] };
-export type StoredPreference = { key: string; value: string; updatedAt: string };
-
-function initialize(database: Database): void {
-  database.exec(`
-    PRAGMA journal_mode = WAL;
-    PRAGMA foreign_keys = ON;
-    CREATE TABLE IF NOT EXISTS workspaces (id TEXT PRIMARY KEY, title TEXT NOT NULL, created_at TEXT NOT NULL, updated_at TEXT NOT NULL);
-    CREATE TABLE IF NOT EXISTS sessions (id TEXT PRIMARY KEY, workspace_id TEXT NOT NULL, title TEXT NOT NULL, mode TEXT NOT NULL, model TEXT, provider TEXT, active_tab_id TEXT NOT NULL, created_at TEXT NOT NULL, updated_at TEXT NOT NULL);
-    CREATE TABLE IF NOT EXISTS tabs (id TEXT PRIMARY KEY, session_id TEXT NOT NULL, workspace_id TEXT NOT NULL, label TEXT NOT NULL, provider TEXT, section_id TEXT NOT NULL, created_at TEXT NOT NULL, updated_at TEXT NOT NULL);
-    CREATE TABLE IF NOT EXISTS messages (id TEXT PRIMARY KEY, session_id TEXT NOT NULL, workspace_id TEXT NOT NULL, tab_id TEXT NOT NULL, section_id TEXT NOT NULL, role TEXT NOT NULL, content TEXT NOT NULL, created_at TEXT NOT NULL);
-    CREATE TABLE IF NOT EXISTS preferences (key TEXT PRIMARY KEY, value TEXT NOT NULL, updated_at TEXT NOT NULL);
-    CREATE INDEX IF NOT EXISTS sessions_workspace_updated ON sessions(workspace_id, updated_at DESC);
-    CREATE INDEX IF NOT EXISTS tabs_session_updated ON tabs(session_id, updated_at DESC);
-    CREATE INDEX IF NOT EXISTS messages_session_created ON messages(session_id, created_at ASC);
-  `);
-}
-
-/** Executes a local SQLite transaction without allowing database failures to erase JSON-compatible records. */
-export function mirrorSession(paths: DevThinkPaths, workspace: StoredWorkspace, session: StoredSession): void {
-  let database: Database | undefined;
-  try {
-    database = new DatabaseDriver(paths.database);
-    initialize(database);
-    database.exec("BEGIN IMMEDIATE");
-    database.prepare("INSERT INTO workspaces (id, title, created_at, updated_at) VALUES (?, ?, ?, ?) ON CONFLICT(id) DO UPDATE SET title = excluded.title, updated_at = excluded.updated_at").run(workspace.id, workspace.title, workspace.createdAt, workspace.updatedAt);
-    database.prepare("INSERT INTO sessions (id, workspace_id, title, mode, model, provider, active_tab_id, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?) ON CONFLICT(id) DO UPDATE SET workspace_id = excluded.workspace_id, title = excluded.title, mode = excluded.mode, model = excluded.model, provider = excluded.provider, active_tab_id = excluded.active_tab_id, updated_at = excluded.updated_at").run(session.id, session.workspaceId, session.title, session.mode, session.model ?? null, session.provider ?? null, session.activeTabId, session.createdAt, session.updatedAt);
-    database.prepare("DELETE FROM tabs WHERE session_id = ?").run(session.id);
-    database.prepare("DELETE FROM messages WHERE session_id = ?").run(session.id);
-    const addTab = database.prepare("INSERT INTO tabs (id, session_id, workspace_id, label, provider, section_id, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)");
-    const addMessage = database.prepare("INSERT INTO messages (id, session_id, workspace_id, tab_id, section_id, role, content, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)");
-    for (const tab of session.tabs) addTab.run(tab.id, tab.sessionId, tab.workspaceId, tab.label, tab.provider ?? null, tab.sectionId, tab.createdAt, tab.updatedAt);
-    for (const message of session.messages) addMessage.run(message.id, message.sessionId, message.workspaceId, message.tabId, message.sectionId, message.role, message.content, message.createdAt);
-    database.exec("COMMIT");
-  } catch {
-    try { database?.exec("ROLLBACK"); } catch { /* JSON compatibility record remains the authoritative fallback. */ }
-  } finally {
-    database?.close();
-  }
-}
-
-/** Reads non-sensitive workbench preferences from the CLI-owned local database. */
-export function readPreferences(paths: DevThinkPaths): Record<string, StoredPreference> {
-  let database: Database | undefined;
-  try {
-    database = new DatabaseDriver(paths.database);
-    initialize(database);
-    const rows = database.prepare("SELECT key, value, updated_at AS updatedAt FROM preferences ORDER BY key ASC").all() as StoredPreference[];
-    return Object.fromEntries(rows.map((row) => [row.key, row]));
-  } catch {
-    return {};
-  } finally {
-    database?.close();
-  }
-}
-
-/** Persists an allowlisted interface preference without mixing it with provider credentials. */
-export function savePreference(paths: DevThinkPaths, key: string, value: string): StoredPreference {
-  const preference = { key, value, updatedAt: new Date().toISOString() };
-  let database: Database | undefined;
-  try {
-    database = new DatabaseDriver(paths.database);
-    initialize(database);
-    database.prepare("INSERT INTO preferences (key, value, updated_at) VALUES (?, ?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at").run(preference.key, preference.value, preference.updatedAt);
-  } finally {
-    database?.close();
-  }
-  return preference;
-}

package/stream.ts

@@ -1,130 +0,0 @@
-export type ChatEvent =
-  | { type: "start"; provider: string; model: string }
-  | { type: "text"; text: string }
-  | { type: "reasoning"; text: string }
-  | { type: "tool"; name: string; input: unknown }
-  | { type: "error"; message: string }
-  | { type: "finish"; reason?: string };
-
-export type StreamOptions = {
-  provider: string;
-  model: string;
-  signal?: AbortSignal;
-};
-
-function decodeJson(value: string): Record<string, unknown> | null {
-  try {
-    const parsed: unknown = JSON.parse(value);
-    return parsed && typeof parsed === "object" ? (parsed as Record<string, unknown>) : null;
-  } catch {
-    return null;
-  }
-}
-
-function extractSseFrames(buffer: { value: string }, incoming: string): string[] {
-  buffer.value += incoming;
-  const frames = buffer.value.split(/\r?\n\r?\n/);
-  buffer.value = frames.pop() || "";
-  return frames;
-}
-
-function extractData(frame: string): string | null {
-  const lines = frame.split(/\r?\n/).filter((line) => line.startsWith("data:"));
-  if (lines.length === 0) return null;
-  const value = lines.map((line) => line.slice(5).trimStart()).join("\n").trim();
-  return value && value !== "[DONE]" ? value : null;
-}
-
-function textAt(value: unknown): string {
-  return typeof value === "string" ? value : "";
-}
-
-function normalizeOpenAi(frame: Record<string, unknown>): ChatEvent[] {
-  const choices = Array.isArray(frame.choices) ? frame.choices : [];
-  const choice = choices[0] as Record<string, unknown> | undefined;
-  const delta = (choice?.delta || {}) as Record<string, unknown>;
-  const events: ChatEvent[] = [];
-  const reasoning = textAt(delta.reasoning_content || delta.reasoning);
-  const text = textAt(delta.content);
-  if (reasoning) events.push({ type: "reasoning", text: reasoning });
-  if (text) events.push({ type: "text", text });
-  const finish = choice?.finish_reason;
-  if (finish) events.push({ type: "finish", reason: textAt(finish) });
-  return events;
-}
-
-function normalizeAnthropic(frame: Record<string, unknown>): ChatEvent[] {
-  const type = textAt(frame.type);
-  if (type === "content_block_delta") {
-    const delta = (frame.delta || {}) as Record<string, unknown>;
-    const text = textAt(delta.text);
-    return text ? [{ type: "text", text }] : [];
-  }
-  if (type === "message_stop") return [{ type: "finish", reason: "stop" }];
-  if (type === "error") {
-    const error = (frame.error || {}) as Record<string, unknown>;
-    return [{ type: "error", message: textAt(error.message) || "Anthropic returned an error." }];
-  }
-  return [];
-}
-
-function normalizeGoogle(frame: Record<string, unknown>): ChatEvent[] {
-  const candidates = Array.isArray(frame.candidates) ? frame.candidates : [];
-  const content = ((candidates[0] as Record<string, unknown> | undefined)?.content || {}) as Record<string, unknown>;
-  const parts = Array.isArray(content.parts) ? content.parts : [];
-  const events: ChatEvent[] = [];
-  for (const part of parts) {
-    const item = part as Record<string, unknown>;
-    const text = textAt(item.text);
-    if (text) events.push({ type: "text", text });
-  }
-  const finish = textAt((candidates[0] as Record<string, unknown> | undefined)?.finishReason);
-  if (finish) events.push({ type: "finish", reason: finish });
-  return events;
-}
-
-export function normalizeFrame(provider: string, frame: Record<string, unknown>): ChatEvent[] {
-  const lower = provider.toLowerCase();
-  if (lower === "anthropic") return normalizeAnthropic(frame);
-  if (lower === "google") return normalizeGoogle(frame);
-  const data = (frame.data || frame) as Record<string, unknown>;
-  if (data !== frame && textAt(data.delta_content)) return [{ type: "text", text: textAt(data.delta_content) }];
-  if (data !== frame && textAt(data.reasoning_content)) return [{ type: "reasoning", text: textAt(data.reasoning_content) }];
-  if (data.error || frame.error) return [{ type: "error", message: textAt(data.error || frame.error) || "The provider returned an error." }];
-  return normalizeOpenAi(frame);
-}
-
-export async function* parseEventStream(response: Response, options: StreamOptions): AsyncGenerator<ChatEvent> {
-  if (!response.body) throw new Error("The provider returned an empty stream.");
-  yield { type: "start", provider: options.provider, model: options.model };
-  const reader = response.body.getReader();
-  const decoder = new TextDecoder();
-  const buffer = { value: "" };
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      for (const frame of extractSseFrames(buffer, decoder.decode(value, { stream: true }))) {
-        const payload = extractData(frame);
-        if (!payload) continue;
-        const parsed = decodeJson(payload);
-        if (!parsed) continue;
-        for (const event of normalizeFrame(options.provider, parsed)) yield event;
-      }
-    }
-  } finally {
-    reader.releaseLock();
-  }
-  yield { type: "finish", reason: "stop" };
-}
-
-export async function collectEvents(events: AsyncIterable<ChatEvent>): Promise<{ text: string; reasoning: string }> {
-  let text = "";
-  let reasoning = "";
-  for await (const event of events) {
-    if (event.type === "text") text += event.text;
-    if (event.type === "reasoning") reasoning += event.text;
-    if (event.type === "error") throw new Error(event.message);
-  }
-  return { text, reasoning };
-}

package/sync.ts

@@ -1,27 +0,0 @@
-import { getIdentity } from "./identity.ts";
-import { listSessions, loadWorkspace, type Session, type Workspace } from "./session.ts";
-import { isSecureRemoteEndpoint } from "./compatibility.ts";
-import type { DevThinkConfig, DevThinkPaths } from "./config.ts";
-
-export type SyncSnapshot = { version: 1; userId: string; deviceId: string; exportedAt: string; workspaces: Workspace[]; sessions: Session[] };
-export type RemoteSyncStatus = { enabled: boolean; endpoint?: string; ready: boolean; reason?: string };
-
-export function exportLocalSnapshot(paths: DevThinkPaths): SyncSnapshot {
-  const identity = getIdentity(paths);
-  const sessions = listSessions(paths);
-  const workspaces = [...new Set(sessions.map((session) => session.workspaceId))].flatMap((workspaceId) => {
-    const workspace = loadWorkspace(paths, workspaceId);
-    return workspace ? [workspace] : [];
-  });
-  return { version: 1, userId: identity.userId, deviceId: identity.deviceId, exportedAt: new Date().toISOString(), workspaces, sessions };
-}
-
-export function remoteSyncStatus(config: DevThinkConfig): RemoteSyncStatus {
-  const remote = config.web?.remoteSync;
-  if (!remote?.enabled) return { enabled: false, ready: false, reason: "Remote synchronization is disabled; local pairing remains available." };
-  if (!remote.endpoint) return { enabled: true, ready: false, reason: "Set web.remoteSync.endpoint to a user-operated HTTPS API that implements the DevThink sync contract." };
-  if (!isSecureRemoteEndpoint(remote.endpoint)) {
-    return { enabled: true, endpoint: remote.endpoint, ready: false, reason: "Remote synchronization endpoint is not a valid HTTPS URL." };
-  }
-  return { enabled: true, endpoint: new URL(remote.endpoint).toString(), ready: true };
-}

package/terminal-ui.tsx

@@ -1,155 +0,0 @@
-/** Design: DevThink v1.1.15 — Ink shares the compact local workspace grammar, identity, destinations, settings and command language with the paired React workbench. */
-import { Box, Text, render, useApp, useInput, useWindowSize } from "ink";
-import { useMemo, useState } from "react";
-import { listProviders } from "./providers.ts";
-import { listSessions, type Session } from "./session.ts";
-import { readPreferences, savePreference } from "./storage.ts";
-import { getIdentity, pairingStatus } from "./identity.ts";
-import type { DevThinkConfig, DevThinkPaths } from "./config.ts";
-import type { ChatEvent } from "./stream.ts";
-import { isWorkspaceDestination, workspaceDestination, workspaceDestinations, type WorkspaceDestination } from "./workspace.ts";
-
-const categories = ["features", "bugs", "refactor", "snippets", "tasks", "notes", "all"] as const;
-const categoryGlyphs: Record<(typeof categories)[number], string> = { features: "ϟ", bugs: "⊗", refactor: "◌", snippets: "◫", tasks: "☑", notes: "□", all: "◉" };
-const entryArt = ["                 +++++", "          +++++++++++++++", "      ++++++     ++++++", "    +++++         +++++", "   +++++           +++++", "    +++++         +++++", "      ++++++   ++++++", "          +++++++++++++", "                 +++++"];
-
-type Runtime = { config: DevThinkConfig; paths: DevThinkPaths };
-type Execute = (prompt: string, current: Session | undefined, onEvent: (event: ChatEvent) => void) => Promise<Session | undefined>;
-type Entry = { role: "user" | "devthink" | "error"; title: string; body: string };
-
-function clip(value: string, width: number): string {
-  return value.length > width ? `${value.slice(0, Math.max(0, width - 1))}…` : value;
-}
-
-function TerminalEntry({ draft, provider, userId, width }: { draft: string; provider: string; userId: string; width: number }) {
-  return <Box flexDirection="column" width="100%" height="100%" minHeight={20} paddingX={2} paddingY={1} justifyContent="space-between">
-    <Box justifyContent="space-between"><Text color="#807970">✦ DEVTHINK</Text><Text color="#8ab4f8">{userId}</Text></Box>
-    <Box flexDirection="column" alignItems="center"><Box flexDirection="column" alignItems="center">{entryArt.map((line, index) => <Text key={`${line}-${index}`} color="#382c23">{line}</Text>)}</Box><Box marginTop={-1}><Text color="#ff5f00" bold>DEVTHINK</Text></Box><Box marginTop={1}><Text color="#746f66">begin with one intention</Text></Box><Box marginTop={2}><Text color="#282724">┌{"─".repeat(Math.max(16, width - 2))}┐</Text></Box><Text color="#e8e1d7">│ <Text color="#ff5f00">›_ </Text><Text color={draft ? "#e8e1d7" : "#746f66"}>{clip(draft || "Ask anything…", Math.max(12, width - 22))}</Text><Text color="#8ab4f8"> {provider}</Text><Text color="#ff5f00"> [open]</Text> │</Text><Text color="#282724">└{"─".repeat(Math.max(16, width - 2))}┘</Text></Box>
-    <Text color="#746f66">enter opens a local workspace · esc exits</Text>
-  </Box>;
-}
-
-function projectRows(runtime: Runtime): string[] {
-  const projects = new Map<string, { title: string; sessions: number }>();
-  for (const session of listSessions(runtime.paths)) projects.set(session.workspaceId, { title: session.title, sessions: (projects.get(session.workspaceId)?.sessions || 0) + 1 });
-  return [...projects.entries()].map(([id, project]) => `${id}  ${project.sessions} ${project.sessions === 1 ? "session" : "sessions"}  ${project.title}`);
-}
-
-function viewRows(view: WorkspaceDestination, runtime: Runtime, session: Session | undefined): string[] {
-  if (view === "history") return listSessions(runtime.paths).map((item) => `${item.id}  ${item.title}`) || ["No saved sessions."];
-  if (view === "projects") return projectRows(runtime) || ["No local projects."];
-  if (view === "providers") return listProviders().map((provider) => `${provider.id}  ${provider.protocol}  ${provider.env}`);
-  if (view === "usage") {
-    const sessions = listSessions(runtime.paths);
-    return [`workspaces ${new Set(sessions.map((item) => item.workspaceId)).size}`, `sessions ${sessions.length}`, `tabs ${sessions.reduce((total, item) => total + item.tabs.length, 0)}`, `messages ${sessions.reduce((total, item) => total + item.messages.length, 0)}`];
-  }
-  if (view === "routes") return ["GET /health", "GET /providers", "GET /workspaces", "GET /usage", "GET /preferences", "PATCH /preferences", "POST /sessions", "POST /chat"];
-  if (view === "settings") {
-    const preferences = Object.fromEntries(Object.entries(readPreferences(runtime.paths)).map(([key, preference]) => [key, preference.value]));
-    const identity = getIdentity(runtime.paths);
-    const pairing = pairingStatus(runtime.paths);
-    const sessions = listSessions(runtime.paths);
-    return [`userId ${identity.userId}`, `deviceId ${identity.deviceId}`, `browser sessions ${pairing.activeSessions}`, `database cli-owned-sqlite · ${new Set(sessions.map((session) => session.workspaceId)).size} workspaces · ${sessions.length} sessions`, `provider ${runtime.config.activeProvider || runtime.config.provider || "not configured"}`, `theme ${preferences.theme || "dark"}`, `railMode ${preferences.railMode || "auto"}`, `interfaceZoom ${preferences.interfaceZoom || "100"}`, "inspect all: devthink config settings", "edit identity: devthink identity --id <10-15 lowercase chars>", "edit: /settings set theme dark|light", "edit: /settings set railMode always|auto|off", "edit: /settings set interfaceZoom 80-150", "credentials remain in ~/.config/devthink/auth.json"];
-  }
-  if (session) return [`workspace ${session.workspaceId}`, `session ${session.id}`, `tab ${session.activeTabId}`];
-  return ["Describe the next feature, bug or piece of work below."];
-}
-
-function TerminalWorkspace({ runtime, execute, version }: { runtime: Runtime; execute: Execute; version: string }) {
-  const { exit } = useApp();
-  const { columns } = useWindowSize();
-  const [entered, setEntered] = useState(false);
-  const [active, setActive] = useState<(typeof categories)[number]>("all");
-  const [view, setView] = useState<WorkspaceDestination>("chat");
-  const [entries, setEntries] = useState<Entry[]>([]);
-  const [session, setSession] = useState<Session>();
-  const [draft, setDraft] = useState("");
-  const [pending, setPending] = useState(false);
-  const [preferenceRevision, setPreferenceRevision] = useState(0);
-  const provider = runtime.config.activeProvider || runtime.config.provider || "local";
-  const identity = getIdentity(runtime.paths);
-  const model = runtime.config.activeModel || runtime.config.model || "not configured";
-  const compact = columns < 100;
-  const terminalWidth = Math.max(38, columns - (compact ? 2 : 6));
-  const tabLine = compact ? workspaceDestinations.map((destination) => destination.glyph).join(" ") : workspaceDestinations.map((destination) => `${destination.id === view ? "[" : ""}${destination.glyph} ${destination.label}${destination.id === view ? "]" : ""}`).join("  ");
-  const rows = useMemo(() => viewRows(view, runtime, session), [preferenceRevision, runtime, session, view]);
-
-  function openView(next: WorkspaceDestination) {
-    setView(next);
-    setEntries((current) => [...current, { role: "devthink", title: workspaceDestination(next).label, body: rows.join(" · ") }]);
-  }
-
-  async function submit() {
-    const prompt = draft.trim();
-    if (!prompt || pending) return;
-    if (prompt === "/exit" || prompt === "/quit") return exit();
-    if (!entered) {
-      setEntries([{ role: "user", title: "first intention", body: prompt }, { role: "devthink", title: "local workspace ready", body: "The first command opened a local DevThink session. Use arrows or /view to inspect local history, projects, providers, usage, routes and settings." }]);
-      setDraft("");
-      setEntered(true);
-      return;
-    }
-    if (prompt === "/clear") { setEntries([]); setDraft(""); return; }
-    if (prompt === "/new") { setSession(undefined); setEntries([]); setView("chat"); setDraft(""); return; }
-    const viewMatch = prompt.match(/^\/(?:view\s+)?(chat|history|projects|providers|usage|routes|settings)$/);
-    if (viewMatch && isWorkspaceDestination(viewMatch[1])) { openView(viewMatch[1]); setDraft(""); return; }
-    if (prompt === "/sessions") { openView("history"); setDraft(""); return; }
-    const preferenceMatch = prompt.match(/^\/(?:settings\s+)?set\s+(theme|railMode|interfaceZoom)\s+(\S+)$/);
-    if (preferenceMatch) {
-      const [, key, value] = preferenceMatch;
-      const valid = (key === "theme" && ["dark", "light"].includes(value)) || (key === "railMode" && ["always", "auto", "off"].includes(value)) || (key === "interfaceZoom" && /^(?:[8-9][0-9]|1[0-4][0-9]|150)$/.test(value));
-      if (!valid) setEntries((current) => [...current, { role: "error", title: "settings", body: "Use theme dark|light, railMode always|auto|off, or interfaceZoom 80-150." }]);
-      else { savePreference(runtime.paths, key, value); setPreferenceRevision((current) => current + 1); setView("settings"); setEntries((current) => [...current, { role: "devthink", title: "settings", body: `${key} updated to ${value}.` }]); }
-      setDraft("");
-      return;
-    }
-    if (prompt === "/help") { setEntries((current) => [...current, { role: "devthink", title: "command reference", body: "/view chat|history|projects|providers|usage|routes|settings  /settings set <key> <value>  /new  /clear  /models  /modes  /sessions  /exit" }]); setDraft(""); return; }
-    setView("chat");
-    setEntries((current) => [...current, { role: "user", title: active, body: prompt }, { role: "devthink", title: "connecting", body: "waiting for local gateway events…" }]);
-    setDraft("");
-    setPending(true);
-    let partial = "";
-    try {
-      const next = await execute(prompt, session, (event) => {
-        if (event.type === "text" || event.type === "reasoning") partial += event.text;
-        setEntries((current) => current.map((entry, index) => index === current.length - 1 ? { ...entry, title: event.type === "start" ? "streaming" : "devthink", body: partial || "connecting to local provider…" } : entry));
-      });
-      setSession(next);
-      setEntries((current) => current.map((entry, index) => index === current.length - 1 ? { ...entry, title: "devthink", body: partial || next?.messages.at(-1)?.content || "the provider returned no text." } : entry));
-    } catch (error) {
-      setEntries((current) => current.map((entry, index) => index === current.length - 1 ? { role: "error", title: "gateway error", body: error instanceof Error ? error.message : "request could not be completed" } : entry));
-    } finally { setPending(false); }
-  }
-
-  useInput((input, key) => {
-    if (key.escape || (key.ctrl && input === "c")) return exit();
-    if (key.return) return void submit();
-    if (key.backspace || key.delete) return setDraft((current) => current.slice(0, -1));
-    if (entered && key.upArrow) return setView((current) => workspaceDestinations[(workspaceDestinations.findIndex((item) => item.id === current) + workspaceDestinations.length - 1) % workspaceDestinations.length].id);
-    if (entered && key.downArrow) return setView((current) => workspaceDestinations[(workspaceDestinations.findIndex((item) => item.id === current) + 1) % workspaceDestinations.length].id);
-    if (entered && view === "chat" && (key.leftArrow || key.tab)) return setActive((current) => categories[(categories.indexOf(current) + categories.length - 1) % categories.length]);
-    if (entered && view === "chat" && key.rightArrow) return setActive((current) => categories[(categories.indexOf(current) + 1) % categories.length]);
-    if (!key.ctrl && !key.meta && input) setDraft((current) => current + input);
-  });
-
-  if (!entered) return <TerminalEntry draft={draft} provider={provider} userId={identity.userId} width={terminalWidth} />;
-
-  return <Box flexDirection="column" width="100%" height="100%" minHeight={20} paddingX={compact ? 1 : 3} paddingY={1}>
-    <Box justifyContent="space-between"><Text color="#a19a91">✦ DEVTHINK <Text color="#746f66">/ {workspaceDestination(view).label}</Text></Text><Text color="#8ab4f8">◉ {identity.userId}</Text></Box>
-    <Text color="#282724">{"─".repeat(terminalWidth)}</Text>
-    <Text color="#746f66">{clip(tabLine, terminalWidth)}</Text>
-    <Box marginTop={1}><Text color="#e8e1d7">{workspaceDestination(view).glyph} {workspaceDestination(view).label.toUpperCase()} <Text color="#746f66">· {clip(model, 22)}</Text></Text></Box>
-    <Box flexDirection="column" flexGrow={1} justifyContent={entries.length && view === "chat" ? "flex-start" : "center"} alignItems={entries.length && view === "chat" ? "flex-start" : "center"}>
-      {view !== "chat" ? rows.map((row, index) => <Text key={`${view}-${index}`} color={index === 0 ? "#e8e1d7" : "#746f66"}>▎ {clip(row, terminalWidth - 4)}</Text>) : entries.length ? entries.map((entry, index) => <Box key={`${entry.title}-${index}`} flexDirection="column" marginBottom={1} paddingLeft={1}><Box><Text color={entry.role === "user" ? "#ff5f00" : entry.role === "error" ? "#ff6b6b" : "#8ab4f8"}>▎ {entry.title.toUpperCase()}</Text></Box><Box><Text color="#e8e1d7">{clip(entry.body, terminalWidth - 6)}</Text></Box></Box>) : <Box flexDirection="column" alignItems="center"><Text color="#4b4842">Nothing is active yet.</Text><Text color="#625c54">Describe the next feature, bug or piece of work below.</Text><Box marginTop={2}><Text color="#ff5f00" bold>DEVTHINK</Text></Box></Box>}
-    </Box>
-    <Text color="#282724">┌{"─".repeat(Math.max(16, terminalWidth - 2))}┐</Text>
-    <Text color="#e8e1d7">│ <Text color="#ff5f00">›_ </Text><Text color={draft ? "#e8e1d7" : "#746f66"}>{clip(draft || (view === "chat" ? `Ask DevThink about ${active === "all" ? "the work…" : `${active}…`}` : `Type /view chat to return…`), Math.max(12, terminalWidth - 20))}</Text><Text color="#8ab4f8"> {provider}</Text><Text color="#ff5f00"> [run]</Text> │</Text>
-    <Text color="#282724">└{"─".repeat(Math.max(16, terminalWidth - 2))}┘</Text>
-    <Text color="#746f66">↑↓ destinations · ←→ categories · /help commands · v{version} · esc exit</Text>
-  </Box>;
-}
-
-export async function startTerminalWorkspace(runtime: Runtime, version: string, execute: Execute): Promise<void> {
-  const app = render(<TerminalWorkspace runtime={runtime} version={version} execute={execute} />, { exitOnCtrlC: false });
-  await app.waitUntilExit();
-}