@learnrudi/cli 1.10.2 → 1.10.4

package/dist/index.cjs

@@ -34261,7 +34261,7 @@ var import_fs13 = __toESM(require("fs"), 1);
 init_src2();
 
 // packages/db/src/schema.js
-var SCHEMA_VERSION = 5;
+var SCHEMA_VERSION = 6;
 var SCHEMA_SQL = `
 -- Schema version tracking
 CREATE TABLE IF NOT EXISTS schema_version (
@@ -34282,6 +34282,7 @@ CREATE TABLE IF NOT EXISTS projects (
   cross_project_id TEXT,
   session_count INTEGER DEFAULT 0,
   total_cost REAL DEFAULT 0,
+  settings TEXT,
   created_at TEXT NOT NULL,
 
   UNIQUE(provider, name)
@@ -34303,15 +34304,17 @@ CREATE TABLE IF NOT EXISTS sessions (
 
   -- Display
   title TEXT,
+  title_override TEXT,
   snippet TEXT,
 
   -- State
   status TEXT DEFAULT 'active' CHECK (status IN ('active', 'archived', 'deleted')),
   model TEXT,
+  system_prompt TEXT,
 
   -- Context
   cwd TEXT,
-  dir_scope TEXT DEFAULT 'project',
+  dir_scope TEXT DEFAULT 'project' CHECK (dir_scope IN ('project', 'home')),
   git_branch TEXT,
   native_storage_path TEXT,
 
@@ -34321,7 +34324,8 @@ CREATE TABLE IF NOT EXISTS sessions (
   parent_session_id TEXT,
   agent_id TEXT,
   is_sidechain INTEGER DEFAULT 0,
-  session_type TEXT DEFAULT 'task',
+  session_type TEXT DEFAULT 'main',
+  slug TEXT,
   version TEXT,
   user_type TEXT DEFAULT 'external',
 
@@ -34344,8 +34348,13 @@ CREATE INDEX IF NOT EXISTS idx_sessions_provider ON sessions(provider);
 CREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project_id);
 CREATE INDEX IF NOT EXISTS idx_sessions_status ON sessions(status);
 CREATE INDEX IF NOT EXISTS idx_sessions_last_active ON sessions(last_active_at DESC);
-CREATE INDEX IF NOT EXISTS idx_sessions_provider_session ON sessions(provider, provider_session_id);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_sessions_provider_session_unique
+  ON sessions(provider, provider_session_id)
+  WHERE provider_session_id IS NOT NULL AND status != 'deleted';
 CREATE INDEX IF NOT EXISTS idx_sessions_cwd ON sessions(cwd);
+CREATE INDEX IF NOT EXISTS idx_sessions_parent ON sessions(parent_session_id);
+CREATE INDEX IF NOT EXISTS idx_sessions_agent ON sessions(agent_id);
+CREATE INDEX IF NOT EXISTS idx_sessions_type ON sessions(session_type);
 
 -- Turns (individual user->assistant exchanges)
 CREATE TABLE IF NOT EXISTS turns (
@@ -34353,6 +34362,7 @@ CREATE TABLE IF NOT EXISTS turns (
   session_id TEXT NOT NULL,
   provider TEXT NOT NULL,
   provider_session_id TEXT,
+  provider_turn_id TEXT,
 
   -- Sequence
   turn_number INTEGER NOT NULL,
@@ -34365,6 +34375,7 @@ CREATE TABLE IF NOT EXISTS turns (
   -- Config at time of turn
   model TEXT,
   permission_mode TEXT,
+  system_prompt TEXT,
 
   -- Metrics
   cost REAL,
@@ -34381,9 +34392,33 @@ CREATE TABLE IF NOT EXISTS turns (
 
   -- Rich metadata (JSON)
   tools_used TEXT,
+  tool_results TEXT,
+  todos TEXT,
+  thinking_config TEXT,
+  image_ids TEXT,
+  compact_metadata TEXT,
+
+  -- Turn linking
+  parent_turn_id TEXT,
+  uuid TEXT,
+  logical_parent_id TEXT,
+  leaf_uuid TEXT,
+
+  -- Message metadata
+  user_type TEXT,
+  is_meta INTEGER DEFAULT 0,
+  display_only INTEGER DEFAULT 0,
+
+  -- API metadata
+  service_tier TEXT,
+  api_request_id TEXT,
+
+  -- Event classification
+  kind TEXT DEFAULT 'message' CHECK (kind IN ('message', 'display', 'summary', 'tool', 'error')),
 
   -- Timestamps
   ts TEXT NOT NULL,
+  ts_ms INTEGER,
 
   FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE
 );
@@ -34392,6 +34427,9 @@ CREATE INDEX IF NOT EXISTS idx_turns_session ON turns(session_id);
 CREATE INDEX IF NOT EXISTS idx_turns_ts ON turns(ts DESC);
 CREATE INDEX IF NOT EXISTS idx_turns_model ON turns(model);
 CREATE INDEX IF NOT EXISTS idx_turns_session_number ON turns(session_id, turn_number);
+CREATE INDEX IF NOT EXISTS idx_turns_session_ts_ms ON turns(session_id, ts_ms);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_turns_provider_dedup
+  ON turns(session_id, provider_turn_id) WHERE provider_turn_id IS NOT NULL;
 
 -- Full-text search on turns
 CREATE VIRTUAL TABLE IF NOT EXISTS turns_fts USING fts5(
@@ -34453,6 +34491,160 @@ CREATE TABLE IF NOT EXISTS model_pricing (
 CREATE INDEX IF NOT EXISTS idx_model_pricing_provider ON model_pricing(provider);
 CREATE INDEX IF NOT EXISTS idx_model_pricing_pattern ON model_pricing(model_pattern);
 
+-- =============================================================================
+-- FILE POSITIONS (session file tailing)
+-- =============================================================================
+
+CREATE TABLE IF NOT EXISTS file_positions (
+  file_path TEXT PRIMARY KEY,
+  byte_offset INTEGER NOT NULL DEFAULT 0,
+  file_size INTEGER NOT NULL DEFAULT 0,
+  mtime_ms INTEGER NOT NULL DEFAULT 0,
+  inode TEXT,
+  provider TEXT NOT NULL CHECK (provider IN ('claude', 'codex', 'gemini', 'ollama')),
+  last_synced_at TEXT NOT NULL,
+  created_at TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_file_positions_provider ON file_positions(provider);
+
+-- =============================================================================
+-- FILE HISTORY (tracked files / revisions)
+-- =============================================================================
+
+CREATE TABLE IF NOT EXISTS tracked_files (
+  id TEXT PRIMARY KEY,
+  current_path TEXT NOT NULL,
+  risk_level TEXT DEFAULT 'low' CHECK (risk_level IN ('low', 'medium', 'high')),
+  created_at TEXT NOT NULL,
+  deleted_at TEXT
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS idx_tracked_files_path_active
+  ON tracked_files(current_path) WHERE deleted_at IS NULL;
+CREATE INDEX IF NOT EXISTS idx_tracked_files_path ON tracked_files(current_path);
+CREATE INDEX IF NOT EXISTS idx_tracked_files_active ON tracked_files(deleted_at) WHERE deleted_at IS NULL;
+
+CREATE TABLE IF NOT EXISTS file_revisions (
+  id TEXT PRIMARY KEY,
+  file_id TEXT NOT NULL,
+  revision_number INTEGER NOT NULL,
+  parent_revision_id TEXT,
+  content_hash TEXT NOT NULL,
+  size_bytes INTEGER NOT NULL,
+  kind TEXT NOT NULL CHECK (kind IN ('edit', 'revert', 'import', 'external', 'delete')),
+  author TEXT NOT NULL CHECK (author IN ('agent', 'user', 'external', 'system')),
+  summary TEXT,
+  is_binary INTEGER DEFAULT 0 CHECK (is_binary IN (0, 1)),
+  reverted_to_revision_id TEXT,
+  created_at TEXT NOT NULL,
+  path_at_revision TEXT NOT NULL,
+  FOREIGN KEY (file_id) REFERENCES tracked_files(id) ON DELETE CASCADE,
+  FOREIGN KEY (parent_revision_id) REFERENCES file_revisions(id),
+  FOREIGN KEY (reverted_to_revision_id) REFERENCES file_revisions(id)
+);
+
+CREATE INDEX IF NOT EXISTS idx_file_revisions_file ON file_revisions(file_id, created_at DESC);
+CREATE INDEX IF NOT EXISTS idx_file_revisions_file_rev ON file_revisions(file_id, revision_number DESC);
+CREATE INDEX IF NOT EXISTS idx_file_revisions_hash ON file_revisions(content_hash);
+CREATE INDEX IF NOT EXISTS idx_file_revisions_path ON file_revisions(path_at_revision);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_file_revisions_number ON file_revisions(file_id, revision_number);
+
+-- =============================================================================
+-- FILE CHANGES / SYSTEM EVENTS
+-- =============================================================================
+
+CREATE TABLE IF NOT EXISTS file_changes (
+  id TEXT PRIMARY KEY,
+  session_id TEXT NOT NULL,
+  turn_id TEXT,
+  file_path TEXT NOT NULL,
+  operation TEXT NOT NULL,
+  content_before_hash TEXT,
+  content_after_hash TEXT,
+  diff_summary TEXT,
+  ts TEXT NOT NULL,
+  ts_ms INTEGER,
+  FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE
+);
+
+CREATE INDEX IF NOT EXISTS idx_file_changes_session ON file_changes(session_id);
+CREATE INDEX IF NOT EXISTS idx_file_changes_path ON file_changes(file_path);
+CREATE INDEX IF NOT EXISTS idx_file_changes_ts ON file_changes(ts_ms);
+
+CREATE TABLE IF NOT EXISTS system_events (
+  id TEXT PRIMARY KEY,
+  session_id TEXT NOT NULL,
+  event_type TEXT NOT NULL,
+  payload TEXT,
+  ts TEXT NOT NULL,
+  ts_ms INTEGER,
+  FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE
+);
+
+CREATE INDEX IF NOT EXISTS idx_system_events_session ON system_events(session_id);
+CREATE INDEX IF NOT EXISTS idx_system_events_type ON system_events(event_type);
+
+-- =============================================================================
+-- SESSION RUNTIME
+-- =============================================================================
+
+CREATE TABLE IF NOT EXISTS session_runtime_state (
+  session_id TEXT PRIMARY KEY,
+  status TEXT NOT NULL CHECK(status IN ('running','completed','error','stopped')),
+  provider TEXT,
+  provider_session_id TEXT,
+  started_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  completed_at TEXT,
+  last_seq INTEGER NOT NULL DEFAULT 0,
+  cost_total REAL NOT NULL DEFAULT 0,
+  tokens_total INTEGER NOT NULL DEFAULT 0,
+  unseen_completion INTEGER NOT NULL DEFAULT 0,
+  last_error TEXT
+);
+
+CREATE TABLE IF NOT EXISTS session_runtime_events (
+  session_id TEXT NOT NULL,
+  seq INTEGER NOT NULL,
+  type TEXT NOT NULL,
+  payload_json TEXT NOT NULL,
+  ts TEXT NOT NULL,
+  PRIMARY KEY (session_id, seq)
+);
+
+CREATE INDEX IF NOT EXISTS idx_session_runtime_events_session_ts
+  ON session_runtime_events(session_id, ts);
+
+-- =============================================================================
+-- OBSERVABILITY LOGS
+-- =============================================================================
+
+CREATE TABLE IF NOT EXISTS logs (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  timestamp INTEGER NOT NULL,
+  source TEXT NOT NULL,
+  level TEXT NOT NULL CHECK (level IN ('debug', 'info', 'warn', 'error')),
+  type TEXT NOT NULL,
+  provider TEXT,
+  cid TEXT,
+  session_id TEXT,
+  terminal_id INTEGER,
+  feature TEXT,
+  step TEXT,
+  duration_ms INTEGER,
+  data_json TEXT NOT NULL,
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_logs_timestamp ON logs(timestamp DESC);
+CREATE INDEX IF NOT EXISTS idx_logs_source ON logs(source);
+CREATE INDEX IF NOT EXISTS idx_logs_level ON logs(level);
+CREATE INDEX IF NOT EXISTS idx_logs_type ON logs(type);
+CREATE INDEX IF NOT EXISTS idx_logs_provider ON logs(provider);
+CREATE INDEX IF NOT EXISTS idx_logs_session ON logs(session_id);
+CREATE INDEX IF NOT EXISTS idx_logs_duration ON logs(duration_ms) WHERE duration_ms IS NOT NULL;
+
 -- =============================================================================
 -- PACKAGES (stacks, prompts, runtimes, binaries, agents)
 -- =============================================================================
@@ -34568,16 +34760,15 @@ CREATE TABLE IF NOT EXISTS secrets_meta (
   last_used_at TEXT
 );
 `;
-function initSchema() {
-  const db3 = getDb();
+function initSchemaWithDb(db3) {
   const hasVersionTable = db3.prepare(`
     SELECT name FROM sqlite_master WHERE type='table' AND name='schema_version'
   `).get();
   if (!hasVersionTable) {
     console.log("Initializing database schema...");
     db3.exec(SCHEMA_SQL);
+    applySchemaUpdates(db3);
     db3.prepare("INSERT INTO schema_version (version, applied_at) VALUES (?, ?)").run(SCHEMA_VERSION, (/* @__PURE__ */ new Date()).toISOString());
-    seedModelPricing(db3);
     console.log(`Database initialized at schema version ${SCHEMA_VERSION}`);
     return { version: SCHEMA_VERSION, migrated: false };
   }
@@ -34586,8 +34777,380 @@ function initSchema() {
     runMigrations(db3, currentVersion, SCHEMA_VERSION);
     return { version: SCHEMA_VERSION, migrated: true, from: currentVersion };
   }
+  db3.exec(SCHEMA_SQL);
+  applySchemaUpdates(db3);
   return { version: currentVersion, migrated: false };
 }
+function initSchema() {
+  return initSchemaWithDb(getDb());
+}
+function applySchemaUpdates(db3) {
+  if (tableExists(db3, "projects")) {
+    ensureColumn(db3, "projects", "settings", "ALTER TABLE projects ADD COLUMN settings TEXT");
+  }
+  if (tableExists(db3, "sessions")) {
+    ensureColumn(db3, "sessions", "title_override", "ALTER TABLE sessions ADD COLUMN title_override TEXT");
+    ensureColumn(db3, "sessions", "system_prompt", "ALTER TABLE sessions ADD COLUMN system_prompt TEXT");
+    ensureColumn(
+      db3,
+      "sessions",
+      "dir_scope",
+      "ALTER TABLE sessions ADD COLUMN dir_scope TEXT DEFAULT 'project' CHECK (dir_scope IN ('project', 'home'))"
+    );
+    ensureColumn(
+      db3,
+      "sessions",
+      "inherit_project_prompt",
+      "ALTER TABLE sessions ADD COLUMN inherit_project_prompt INTEGER DEFAULT 1"
+    );
+    ensureColumn(db3, "sessions", "is_warmup", "ALTER TABLE sessions ADD COLUMN is_warmup INTEGER DEFAULT 0");
+    ensureColumn(db3, "sessions", "parent_session_id", "ALTER TABLE sessions ADD COLUMN parent_session_id TEXT");
+    ensureColumn(db3, "sessions", "agent_id", "ALTER TABLE sessions ADD COLUMN agent_id TEXT");
+    ensureColumn(db3, "sessions", "is_sidechain", "ALTER TABLE sessions ADD COLUMN is_sidechain INTEGER DEFAULT 0");
+    ensureColumn(
+      db3,
+      "sessions",
+      "session_type",
+      "ALTER TABLE sessions ADD COLUMN session_type TEXT DEFAULT 'main'"
+    );
+    ensureColumn(db3, "sessions", "slug", "ALTER TABLE sessions ADD COLUMN slug TEXT");
+    ensureColumn(db3, "sessions", "version", "ALTER TABLE sessions ADD COLUMN version TEXT");
+    ensureColumn(
+      db3,
+      "sessions",
+      "user_type",
+      "ALTER TABLE sessions ADD COLUMN user_type TEXT DEFAULT 'external'"
+    );
+    if (columnExists(db3, "sessions", "session_type")) {
+      db3.exec("UPDATE sessions SET session_type = 'main' WHERE session_type = 'task'");
+    }
+    ensureIndex(db3, "idx_sessions_parent", "CREATE INDEX IF NOT EXISTS idx_sessions_parent ON sessions(parent_session_id)");
+    ensureIndex(db3, "idx_sessions_agent", "CREATE INDEX IF NOT EXISTS idx_sessions_agent ON sessions(agent_id)");
+    ensureIndex(db3, "idx_sessions_type", "CREATE INDEX IF NOT EXISTS idx_sessions_type ON sessions(session_type)");
+    if (!indexExists(db3, "idx_sessions_provider_session_unique")) {
+      dedupeProviderSessions(db3);
+      db3.exec("DROP INDEX IF EXISTS idx_sessions_provider_session");
+      db3.exec(`
+        CREATE UNIQUE INDEX IF NOT EXISTS idx_sessions_provider_session_unique
+          ON sessions(provider, provider_session_id)
+          WHERE provider_session_id IS NOT NULL AND status != 'deleted'
+      `);
+    }
+  }
+  if (tableExists(db3, "turns")) {
+    ensureColumn(db3, "turns", "provider_turn_id", "ALTER TABLE turns ADD COLUMN provider_turn_id TEXT");
+    ensureColumn(db3, "turns", "system_prompt", "ALTER TABLE turns ADD COLUMN system_prompt TEXT");
+    ensureColumn(db3, "turns", "parent_turn_id", "ALTER TABLE turns ADD COLUMN parent_turn_id TEXT");
+    ensureColumn(db3, "turns", "uuid", "ALTER TABLE turns ADD COLUMN uuid TEXT");
+    ensureColumn(db3, "turns", "service_tier", "ALTER TABLE turns ADD COLUMN service_tier TEXT");
+    ensureColumn(db3, "turns", "api_request_id", "ALTER TABLE turns ADD COLUMN api_request_id TEXT");
+    ensureColumn(db3, "turns", "tool_results", "ALTER TABLE turns ADD COLUMN tool_results TEXT");
+    ensureColumn(db3, "turns", "user_type", "ALTER TABLE turns ADD COLUMN user_type TEXT");
+    ensureColumn(db3, "turns", "is_meta", "ALTER TABLE turns ADD COLUMN is_meta INTEGER DEFAULT 0");
+    ensureColumn(db3, "turns", "display_only", "ALTER TABLE turns ADD COLUMN display_only INTEGER DEFAULT 0");
+    ensureColumn(db3, "turns", "todos", "ALTER TABLE turns ADD COLUMN todos TEXT");
+    ensureColumn(db3, "turns", "thinking_config", "ALTER TABLE turns ADD COLUMN thinking_config TEXT");
+    ensureColumn(db3, "turns", "image_ids", "ALTER TABLE turns ADD COLUMN image_ids TEXT");
+    ensureColumn(db3, "turns", "compact_metadata", "ALTER TABLE turns ADD COLUMN compact_metadata TEXT");
+    ensureColumn(db3, "turns", "logical_parent_id", "ALTER TABLE turns ADD COLUMN logical_parent_id TEXT");
+    ensureColumn(db3, "turns", "leaf_uuid", "ALTER TABLE turns ADD COLUMN leaf_uuid TEXT");
+    if (!columnExists(db3, "turns", "ts_ms")) {
+      db3.exec("ALTER TABLE turns ADD COLUMN ts_ms INTEGER");
+      db3.exec(`
+        UPDATE turns
+        SET ts_ms = CASE
+          WHEN ts GLOB '[0-9]*' AND LENGTH(ts) >= 13 THEN CAST(ts AS INTEGER)
+          WHEN ts LIKE '____-__-__T__:__:__*' THEN
+            CAST((julianday(SUBSTR(ts, 1, 19)) - julianday('1970-01-01')) * 86400000 AS INTEGER)
+          ELSE CAST((julianday(ts) - julianday('1970-01-01')) * 86400000 AS INTEGER)
+        END
+        WHERE ts_ms IS NULL AND ts IS NOT NULL
+      `);
+    }
+    if (columnExists(db3, "turns", "ts_ms")) {
+      ensureIndex(
+        db3,
+        "idx_turns_session_ts_ms",
+        "CREATE INDEX IF NOT EXISTS idx_turns_session_ts_ms ON turns(session_id, ts_ms)"
+      );
+    }
+    if (!columnExists(db3, "turns", "kind")) {
+      db3.exec("ALTER TABLE turns ADD COLUMN kind TEXT DEFAULT 'message' CHECK (kind IN ('message', 'display', 'summary', 'tool', 'error'))");
+      db3.exec(`
+        UPDATE turns SET kind = 'display'
+        WHERE user_message LIKE '[display: %]' AND assistant_response IS NULL
+      `);
+    }
+    if (columnExists(db3, "turns", "provider_turn_id")) {
+      ensureIndex(
+        db3,
+        "idx_turns_provider_dedup",
+        "CREATE UNIQUE INDEX IF NOT EXISTS idx_turns_provider_dedup ON turns(session_id, provider_turn_id) WHERE provider_turn_id IS NOT NULL"
+      );
+    }
+  }
+  ensureTable(db3, "file_positions", `
+    CREATE TABLE IF NOT EXISTS file_positions (
+      file_path TEXT PRIMARY KEY,
+      byte_offset INTEGER NOT NULL DEFAULT 0,
+      file_size INTEGER NOT NULL DEFAULT 0,
+      mtime_ms INTEGER NOT NULL DEFAULT 0,
+      inode TEXT,
+      provider TEXT NOT NULL CHECK (provider IN ('claude', 'codex', 'gemini', 'ollama')),
+      last_synced_at TEXT NOT NULL,
+      created_at TEXT NOT NULL
+    );
+  `);
+  ensureIndex(
+    db3,
+    "idx_file_positions_provider",
+    "CREATE INDEX IF NOT EXISTS idx_file_positions_provider ON file_positions(provider)"
+  );
+  ensureTable(db3, "tracked_files", `
+    CREATE TABLE IF NOT EXISTS tracked_files (
+      id TEXT PRIMARY KEY,
+      current_path TEXT NOT NULL,
+      risk_level TEXT DEFAULT 'low' CHECK (risk_level IN ('low', 'medium', 'high')),
+      created_at TEXT NOT NULL,
+      deleted_at TEXT
+    );
+  `);
+  ensureIndex(
+    db3,
+    "idx_tracked_files_path_active",
+    "CREATE UNIQUE INDEX IF NOT EXISTS idx_tracked_files_path_active ON tracked_files(current_path) WHERE deleted_at IS NULL"
+  );
+  ensureIndex(
+    db3,
+    "idx_tracked_files_path",
+    "CREATE INDEX IF NOT EXISTS idx_tracked_files_path ON tracked_files(current_path)"
+  );
+  ensureIndex(
+    db3,
+    "idx_tracked_files_active",
+    "CREATE INDEX IF NOT EXISTS idx_tracked_files_active ON tracked_files(deleted_at) WHERE deleted_at IS NULL"
+  );
+  ensureTable(db3, "file_revisions", `
+    CREATE TABLE IF NOT EXISTS file_revisions (
+      id TEXT PRIMARY KEY,
+      file_id TEXT NOT NULL,
+      revision_number INTEGER NOT NULL,
+      parent_revision_id TEXT,
+      content_hash TEXT NOT NULL,
+      size_bytes INTEGER NOT NULL,
+      kind TEXT NOT NULL CHECK (kind IN ('edit', 'revert', 'import', 'external', 'delete')),
+      author TEXT NOT NULL CHECK (author IN ('agent', 'user', 'external', 'system')),
+      summary TEXT,
+      is_binary INTEGER DEFAULT 0 CHECK (is_binary IN (0, 1)),
+      reverted_to_revision_id TEXT,
+      created_at TEXT NOT NULL,
+      path_at_revision TEXT NOT NULL,
+      FOREIGN KEY (file_id) REFERENCES tracked_files(id) ON DELETE CASCADE,
+      FOREIGN KEY (parent_revision_id) REFERENCES file_revisions(id),
+      FOREIGN KEY (reverted_to_revision_id) REFERENCES file_revisions(id)
+    );
+  `);
+  ensureIndex(
+    db3,
+    "idx_file_revisions_file",
+    "CREATE INDEX IF NOT EXISTS idx_file_revisions_file ON file_revisions(file_id, created_at DESC)"
+  );
+  ensureIndex(
+    db3,
+    "idx_file_revisions_file_rev",
+    "CREATE INDEX IF NOT EXISTS idx_file_revisions_file_rev ON file_revisions(file_id, revision_number DESC)"
+  );
+  ensureIndex(
+    db3,
+    "idx_file_revisions_hash",
+    "CREATE INDEX IF NOT EXISTS idx_file_revisions_hash ON file_revisions(content_hash)"
+  );
+  ensureIndex(
+    db3,
+    "idx_file_revisions_path",
+    "CREATE INDEX IF NOT EXISTS idx_file_revisions_path ON file_revisions(path_at_revision)"
+  );
+  ensureIndex(
+    db3,
+    "idx_file_revisions_number",
+    "CREATE UNIQUE INDEX IF NOT EXISTS idx_file_revisions_number ON file_revisions(file_id, revision_number)"
+  );
+  if (tableExists(db3, "file_revisions")) {
+    ensureColumn(
+      db3,
+      "file_revisions",
+      "is_binary",
+      "ALTER TABLE file_revisions ADD COLUMN is_binary INTEGER DEFAULT 0 CHECK (is_binary IN (0, 1))"
+    );
+  }
+  ensureTable(db3, "file_changes", `
+    CREATE TABLE IF NOT EXISTS file_changes (
+      id TEXT PRIMARY KEY,
+      session_id TEXT NOT NULL,
+      turn_id TEXT,
+      file_path TEXT NOT NULL,
+      operation TEXT NOT NULL,
+      content_before_hash TEXT,
+      content_after_hash TEXT,
+      diff_summary TEXT,
+      ts TEXT NOT NULL,
+      ts_ms INTEGER,
+      FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE
+    );
+  `);
+  ensureIndex(
+    db3,
+    "idx_file_changes_session",
+    "CREATE INDEX IF NOT EXISTS idx_file_changes_session ON file_changes(session_id)"
+  );
+  ensureIndex(
+    db3,
+    "idx_file_changes_path",
+    "CREATE INDEX IF NOT EXISTS idx_file_changes_path ON file_changes(file_path)"
+  );
+  ensureIndex(
+    db3,
+    "idx_file_changes_ts",
+    "CREATE INDEX IF NOT EXISTS idx_file_changes_ts ON file_changes(ts_ms)"
+  );
+  ensureTable(db3, "system_events", `
+    CREATE TABLE IF NOT EXISTS system_events (
+      id TEXT PRIMARY KEY,
+      session_id TEXT NOT NULL,
+      event_type TEXT NOT NULL,
+      payload TEXT,
+      ts TEXT NOT NULL,
+      ts_ms INTEGER,
+      FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE
+    );
+  `);
+  ensureIndex(
+    db3,
+    "idx_system_events_session",
+    "CREATE INDEX IF NOT EXISTS idx_system_events_session ON system_events(session_id)"
+  );
+  ensureIndex(
+    db3,
+    "idx_system_events_type",
+    "CREATE INDEX IF NOT EXISTS idx_system_events_type ON system_events(event_type)"
+  );
+  ensureTable(db3, "session_runtime_state", `
+    CREATE TABLE IF NOT EXISTS session_runtime_state (
+      session_id TEXT PRIMARY KEY,
+      status TEXT NOT NULL CHECK(status IN ('running','completed','error','stopped')),
+      provider TEXT,
+      provider_session_id TEXT,
+      started_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      completed_at TEXT,
+      last_seq INTEGER NOT NULL DEFAULT 0,
+      cost_total REAL NOT NULL DEFAULT 0,
+      tokens_total INTEGER NOT NULL DEFAULT 0,
+      unseen_completion INTEGER NOT NULL DEFAULT 0,
+      last_error TEXT
+    )
+  `);
+  ensureTable(db3, "session_runtime_events", `
+    CREATE TABLE IF NOT EXISTS session_runtime_events (
+      session_id TEXT NOT NULL,
+      seq INTEGER NOT NULL,
+      type TEXT NOT NULL,
+      payload_json TEXT NOT NULL,
+      ts TEXT NOT NULL,
+      PRIMARY KEY (session_id, seq)
+    );
+  `);
+  ensureIndex(
+    db3,
+    "idx_session_runtime_events_session_ts",
+    "CREATE INDEX IF NOT EXISTS idx_session_runtime_events_session_ts ON session_runtime_events(session_id, ts)"
+  );
+  ensureTable(db3, "logs", `
+    CREATE TABLE IF NOT EXISTS logs (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      timestamp INTEGER NOT NULL,
+      source TEXT NOT NULL,
+      level TEXT NOT NULL CHECK (level IN ('debug', 'info', 'warn', 'error')),
+      type TEXT NOT NULL,
+      provider TEXT,
+      cid TEXT,
+      session_id TEXT,
+      terminal_id INTEGER,
+      feature TEXT,
+      step TEXT,
+      duration_ms INTEGER,
+      data_json TEXT NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+  `);
+  ensureIndex(
+    db3,
+    "idx_logs_timestamp",
+    "CREATE INDEX IF NOT EXISTS idx_logs_timestamp ON logs(timestamp DESC)"
+  );
+  ensureIndex(
+    db3,
+    "idx_logs_source",
+    "CREATE INDEX IF NOT EXISTS idx_logs_source ON logs(source)"
+  );
+  ensureIndex(
+    db3,
+    "idx_logs_level",
+    "CREATE INDEX IF NOT EXISTS idx_logs_level ON logs(level)"
+  );
+  ensureIndex(
+    db3,
+    "idx_logs_type",
+    "CREATE INDEX IF NOT EXISTS idx_logs_type ON logs(type)"
+  );
+  ensureIndex(
+    db3,
+    "idx_logs_provider",
+    "CREATE INDEX IF NOT EXISTS idx_logs_provider ON logs(provider)"
+  );
+  ensureIndex(
+    db3,
+    "idx_logs_session",
+    "CREATE INDEX IF NOT EXISTS idx_logs_session ON logs(session_id)"
+  );
+  ensureIndex(
+    db3,
+    "idx_logs_duration",
+    "CREATE INDEX IF NOT EXISTS idx_logs_duration ON logs(duration_ms) WHERE duration_ms IS NOT NULL"
+  );
+  ensureTable(db3, "model_pricing", `
+    CREATE TABLE IF NOT EXISTS model_pricing (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      provider TEXT NOT NULL CHECK (provider IN ('claude', 'codex', 'gemini', 'openai', 'ollama')),
+      model_pattern TEXT NOT NULL,
+      display_name TEXT,
+      input_cost_per_mtok REAL NOT NULL,
+      output_cost_per_mtok REAL NOT NULL,
+      cache_read_cost_per_mtok REAL DEFAULT 0,
+      cache_write_cost_per_mtok REAL DEFAULT 0,
+      effective_from TEXT NOT NULL,
+      effective_until TEXT,
+      notes TEXT,
+      UNIQUE(provider, model_pattern, effective_from)
+    );
+  `);
+  ensureIndex(
+    db3,
+    "idx_model_pricing_provider",
+    "CREATE INDEX IF NOT EXISTS idx_model_pricing_provider ON model_pricing(provider)"
+  );
+  ensureIndex(
+    db3,
+    "idx_model_pricing_pattern",
+    "CREATE INDEX IF NOT EXISTS idx_model_pricing_pattern ON model_pricing(model_pattern)"
+  );
+  if (tableExists(db3, "model_pricing")) {
+    const count = db3.prepare("SELECT COUNT(*) as count FROM model_pricing").get();
+    if (count && count.count === 0) {
+      seedModelPricing(db3);
+    }
+  }
+}
 function runMigrations(db3, from, to) {
   console.log(`Migrating database from v${from} to v${to}...`);
   const migrations = {
@@ -34751,17 +35314,64 @@ function runMigrations(db3, from, to) {
     },
     // Version 5: Add session metadata columns for Claude import
     5: (db4) => {
-      db4.exec(`
-        ALTER TABLE sessions ADD COLUMN dir_scope TEXT DEFAULT 'project';
-        ALTER TABLE sessions ADD COLUMN inherit_project_prompt INTEGER DEFAULT 1;
-        ALTER TABLE sessions ADD COLUMN is_warmup INTEGER DEFAULT 0;
-        ALTER TABLE sessions ADD COLUMN parent_session_id TEXT;
-        ALTER TABLE sessions ADD COLUMN agent_id TEXT;
-        ALTER TABLE sessions ADD COLUMN is_sidechain INTEGER DEFAULT 0;
-        ALTER TABLE sessions ADD COLUMN session_type TEXT DEFAULT 'task';
-        ALTER TABLE sessions ADD COLUMN version TEXT;
-        ALTER TABLE sessions ADD COLUMN user_type TEXT DEFAULT 'external';
-      `);
+      ensureColumn(
+        db4,
+        "sessions",
+        "dir_scope",
+        "ALTER TABLE sessions ADD COLUMN dir_scope TEXT DEFAULT 'project' CHECK (dir_scope IN ('project', 'home'))"
+      );
+      ensureColumn(
+        db4,
+        "sessions",
+        "inherit_project_prompt",
+        "ALTER TABLE sessions ADD COLUMN inherit_project_prompt INTEGER DEFAULT 1"
+      );
+      ensureColumn(
+        db4,
+        "sessions",
+        "is_warmup",
+        "ALTER TABLE sessions ADD COLUMN is_warmup INTEGER DEFAULT 0"
+      );
+      ensureColumn(
+        db4,
+        "sessions",
+        "parent_session_id",
+        "ALTER TABLE sessions ADD COLUMN parent_session_id TEXT"
+      );
+      ensureColumn(
+        db4,
+        "sessions",
+        "agent_id",
+        "ALTER TABLE sessions ADD COLUMN agent_id TEXT"
+      );
+      ensureColumn(
+        db4,
+        "sessions",
+        "is_sidechain",
+        "ALTER TABLE sessions ADD COLUMN is_sidechain INTEGER DEFAULT 0"
+      );
+      ensureColumn(
+        db4,
+        "sessions",
+        "session_type",
+        "ALTER TABLE sessions ADD COLUMN session_type TEXT DEFAULT 'main'"
+      );
+      ensureColumn(
+        db4,
+        "sessions",
+        "version",
+        "ALTER TABLE sessions ADD COLUMN version TEXT"
+      );
+      ensureColumn(
+        db4,
+        "sessions",
+        "user_type",
+        "ALTER TABLE sessions ADD COLUMN user_type TEXT DEFAULT 'external'"
+      );
+    },
+    // Version 6: Bring schema to Studio parity
+    6: (db4) => {
+      applySchemaUpdates(db4);
     }
   };
   for (let v2 = from + 1; v2 <= to; v2++) {
@@ -34780,6 +35390,72 @@ function runMigrations(db3, from, to) {
   }
   console.log("Migrations complete.");
 }
+function tableExists(db3, table) {
+  const result = db3.prepare(`
+    SELECT name FROM sqlite_master WHERE type='table' AND name=?
+  `).get(table);
+  return !!result;
+}
+function columnExists(db3, table, column) {
+  try {
+    const columns = db3.pragma(`table_info(${table})`);
+    return columns.some((col) => col.name === column);
+  } catch {
+    return false;
+  }
+}
+function indexExists(db3, indexName) {
+  const result = db3.prepare(`
+    SELECT name FROM sqlite_master WHERE type='index' AND name=?
+  `).get(indexName);
+  return !!result;
+}
+function ensureColumn(db3, table, column, statement) {
+  if (!columnExists(db3, table, column)) {
+    db3.exec(statement);
+  }
+}
+function ensureIndex(db3, indexName, statement) {
+  if (!indexExists(db3, indexName)) {
+    db3.exec(statement);
+  }
+}
+function ensureTable(db3, table, statement) {
+  if (!tableExists(db3, table)) {
+    db3.exec(statement);
+  }
+}
+function dedupeProviderSessions(db3) {
+  const duplicates = db3.prepare(`
+    SELECT provider, provider_session_id, COUNT(*) as cnt
+    FROM sessions
+    WHERE provider_session_id IS NOT NULL
+    GROUP BY provider, provider_session_id
+    HAVING COUNT(*) > 1
+  `).all();
+  if (!duplicates.length) {
+    return;
+  }
+  for (const dup of duplicates) {
+    const sessions = db3.prepare(`
+      SELECT id, turn_count, created_at
+      FROM sessions
+      WHERE provider = ? AND provider_session_id = ?
+      ORDER BY turn_count DESC, created_at ASC
+    `).all(dup.provider, dup.provider_session_id);
+    const keepId = sessions[0].id;
+    const deleteIds = sessions.slice(1).map((s2) => s2.id);
+    for (const id of deleteIds) {
+      db3.prepare(`
+        UPDATE sessions
+        SET status = 'deleted',
+            deleted_at = datetime('now'),
+            provider_session_id = provider_session_id || '-dup-' || id
+        WHERE id = ?
+      `).run(id);
+    }
+  }
+}
 function seedModelPricing(db3) {
   const insert = db3.prepare(`
     INSERT OR REPLACE INTO model_pricing
@@ -35657,8 +36333,8 @@ async function ensureEmbeddingProvider(preferredProvider = "auto", options = {})
     });
     console.log("\r  \u2713 Ollama installed     ");
     console.log("  Starting ollama serve...");
-    const { spawn: spawn4 } = await import("child_process");
-    const server = spawn4("ollama", ["serve"], {
+    const { spawn: spawn5 } = await import("child_process");
+    const server = spawn5("ollama", ["serve"], {
       detached: true,
       stdio: "ignore",
       env: { ...process.env, HOME: process.env.HOME }
@@ -36406,8 +37082,7 @@ Analyzing ${sessions.length} sessions...
   const projectSuggestions = [];
   const moveSuggestions = [];
   const knownProjects = {
-    "studio": "Prompt Stack Studio",
-    "prompt-stack": "Prompt Stack Studio",
+    "studio": "RUDI Studio",
     "RUDI": "RUDI",
     "rudi": "RUDI",
     "cli": "RUDI",
@@ -36495,8 +37170,8 @@ Proposed actions:`);
       console.log(`  ... and ${titleSuggestions.length - 5} more`);
     }
   }
-  const { writeFileSync: writeFileSync7 } = await import("fs");
-  writeFileSync7(outputFile, JSON.stringify(plan, null, 2));
+  const { writeFileSync: writeFileSync6 } = await import("fs");
+  writeFileSync6(outputFile, JSON.stringify(plan, null, 2));
   console.log(`
 \u2713 Plan saved to: ${outputFile}`);
   console.log("\nTo apply this plan:");
@@ -38446,281 +39121,6 @@ Wiring up RUDI router...`);
   console.log("  rudi index             # Rebuild tool cache");
 }
 
-// src/commands/migrate.js
-var fs30 = __toESM(require("fs"), 1);
-var path30 = __toESM(require("path"), 1);
-var import_os7 = __toESM(require("os"), 1);
-init_src();
-var HOME3 = import_os7.default.homedir();
-var OLD_PROMPT_STACK = path30.join(HOME3, ".prompt-stack");
-var SHIM_PATH = path30.join(PATHS.home, "shims", "rudi-mcp");
-function getOldStacks() {
-  const stacksDir = path30.join(OLD_PROMPT_STACK, "stacks");
-  if (!fs30.existsSync(stacksDir)) return [];
-  return fs30.readdirSync(stacksDir, { withFileTypes: true }).filter((d2) => d2.isDirectory() && !d2.name.startsWith(".")).filter((d2) => {
-    const hasManifest = fs30.existsSync(path30.join(stacksDir, d2.name, "manifest.json"));
-    const hasPackage = fs30.existsSync(path30.join(stacksDir, d2.name, "package.json"));
-    return hasManifest || hasPackage;
-  }).map((d2) => d2.name);
-}
-function copyStack(stackName) {
-  const oldPath = path30.join(OLD_PROMPT_STACK, "stacks", stackName);
-  const newPath = path30.join(PATHS.stacks, stackName);
-  if (!fs30.existsSync(oldPath)) {
-    return { success: false, error: "Source not found" };
-  }
-  if (fs30.existsSync(newPath)) {
-    return { success: true, skipped: true, reason: "Already exists" };
-  }
-  if (!fs30.existsSync(PATHS.stacks)) {
-    fs30.mkdirSync(PATHS.stacks, { recursive: true });
-  }
-  copyRecursive(oldPath, newPath);
-  return { success: true, copied: true };
-}
-function copyRecursive(src, dest) {
-  const stat = fs30.statSync(src);
-  if (stat.isDirectory()) {
-    fs30.mkdirSync(dest, { recursive: true });
-    for (const child of fs30.readdirSync(src)) {
-      copyRecursive(path30.join(src, child), path30.join(dest, child));
-    }
-  } else {
-    fs30.copyFileSync(src, dest);
-  }
-}
-function ensureShim() {
-  const shimsDir = path30.dirname(SHIM_PATH);
-  if (!fs30.existsSync(shimsDir)) {
-    fs30.mkdirSync(shimsDir, { recursive: true });
-  }
-  const shimContent = `#!/usr/bin/env bash
-set -euo pipefail
-if command -v rudi &> /dev/null; then
-  exec rudi mcp "$1"
-else
-  exec npx --yes @learnrudi/cli mcp "$1"
-fi
-`;
-  fs30.writeFileSync(SHIM_PATH, shimContent, { mode: 493 });
-}
-function buildNewEntry(stackName, agentId) {
-  const base = {
-    command: SHIM_PATH,
-    args: [stackName]
-  };
-  if (agentId === "claude-desktop" || agentId === "claude-code") {
-    return { type: "stdio", ...base };
-  }
-  return base;
-}
-function isOldEntry(entry) {
-  if (!entry) return false;
-  const command = entry.command || "";
-  const args = entry.args || [];
-  const cwd = entry.cwd || "";
-  return command.includes(".prompt-stack") || args.some((a2) => typeof a2 === "string" && a2.includes(".prompt-stack")) || cwd.includes(".prompt-stack");
-}
-function migrateAgentConfig(agentConfig, installedStacks, flags) {
-  const configPath = findAgentConfig(agentConfig);
-  if (!configPath) return { skipped: true, reason: "Config not found" };
-  let config;
-  try {
-    config = JSON.parse(fs30.readFileSync(configPath, "utf-8"));
-  } catch {
-    return { skipped: true, reason: "Could not parse config" };
-  }
-  const key = agentConfig.key;
-  const mcpServers = config[key] || {};
-  let updated = 0;
-  let removed = 0;
-  const changes = [];
-  for (const [name, entry] of Object.entries(mcpServers)) {
-    if (isOldEntry(entry)) {
-      if (installedStacks.includes(name)) {
-        const newEntry = buildNewEntry(name, agentConfig.id);
-        mcpServers[name] = newEntry;
-        updated++;
-        changes.push({ name, action: "updated" });
-      } else if (flags.removeOrphans) {
-        delete mcpServers[name];
-        removed++;
-        changes.push({ name, action: "removed (not installed)" });
-      } else {
-        changes.push({ name, action: "skipped (not installed in .rudi)" });
-      }
-    }
-  }
-  if (updated > 0 || removed > 0) {
-    const backupPath = configPath + ".backup." + Date.now();
-    fs30.copyFileSync(configPath, backupPath);
-    config[key] = mcpServers;
-    fs30.writeFileSync(configPath, JSON.stringify(config, null, 2));
-  }
-  return { updated, removed, changes };
-}
-async function cmdMigrate(args, flags) {
-  const subcommand = args[0];
-  if (!subcommand || subcommand === "help") {
-    console.log(`
-rudi migrate - Migrate from .prompt-stack to .rudi
-
-USAGE
-  rudi migrate status         Show what needs to be migrated
-  rudi migrate stacks         Copy stacks from .prompt-stack to .rudi
-  rudi migrate configs        Update agent configs to use new shim
-  rudi migrate all            Do everything
-
-OPTIONS
-  --remove-orphans    Remove entries for stacks not installed in .rudi
-  --dry-run           Show what would be done without making changes
-`);
-    return;
-  }
-  if (subcommand === "status") {
-    await migrateStatus();
-    return;
-  }
-  if (subcommand === "stacks") {
-    await migrateStacks(flags);
-    return;
-  }
-  if (subcommand === "configs") {
-    await migrateConfigs(flags);
-    return;
-  }
-  if (subcommand === "all") {
-    await migrateStacks(flags);
-    console.log("");
-    await migrateConfigs(flags);
-    return;
-  }
-  console.error(`Unknown subcommand: ${subcommand}`);
-  console.error("Run: rudi migrate help");
-}
-async function migrateStatus() {
-  console.log("\n=== Migration Status ===\n");
-  const oldStacks = getOldStacks();
-  console.log(`Old .prompt-stack stacks: ${oldStacks.length}`);
-  if (oldStacks.length > 0) {
-    for (const name of oldStacks) {
-      const existsInRudi = fs30.existsSync(path30.join(PATHS.stacks, name));
-      const status = existsInRudi ? "\u2713 (already in .rudi)" : "\u25CB (needs migration)";
-      console.log(`  ${status} ${name}`);
-    }
-  }
-  const newStacksDir = PATHS.stacks;
-  let newStacks = [];
-  if (fs30.existsSync(newStacksDir)) {
-    newStacks = fs30.readdirSync(newStacksDir, { withFileTypes: true }).filter((d2) => d2.isDirectory() && !d2.name.startsWith(".")).map((d2) => d2.name);
-  }
-  console.log(`
-New .rudi stacks: ${newStacks.length}`);
-  if (newStacks.length > 0) {
-    for (const name of newStacks) {
-      console.log(`  \u2713 ${name}`);
-    }
-  }
-  console.log("\n=== Agent Configs ===\n");
-  for (const agentConfig of AGENT_CONFIGS) {
-    const configPath = findAgentConfig(agentConfig);
-    if (!configPath) continue;
-    let config;
-    try {
-      config = JSON.parse(fs30.readFileSync(configPath, "utf-8"));
-    } catch {
-      continue;
-    }
-    const mcpServers = config[agentConfig.key] || {};
-    const entries = Object.entries(mcpServers);
-    const oldEntries = entries.filter(([_2, e2]) => isOldEntry(e2));
-    const newEntries = entries.filter(([_2, e2]) => !isOldEntry(e2));
-    if (entries.length === 0) continue;
-    console.log(`${agentConfig.name}:`);
-    console.log(`  Config: ${configPath}`);
-    console.log(`  Old entries: ${oldEntries.length}`);
-    console.log(`  New entries: ${newEntries.length}`);
-    if (oldEntries.length > 0) {
-      console.log("  Needs update:");
-      for (const [name] of oldEntries) {
-        const installed = newStacks.includes(name);
-        const status = installed ? "(ready)" : "(not in .rudi)";
-        console.log(`    - ${name} ${status}`);
-      }
-    }
-    console.log("");
-  }
-  console.log("Run: rudi migrate all");
-}
-async function migrateStacks(flags) {
-  console.log("=== Migrating Stacks ===\n");
-  const oldStacks = getOldStacks();
-  if (oldStacks.length === 0) {
-    console.log("No stacks found in .prompt-stack");
-    return;
-  }
-  console.log(`Found ${oldStacks.length} stack(s) in .prompt-stack
-`);
-  for (const name of oldStacks) {
-    if (flags.dryRun) {
-      const exists = fs30.existsSync(path30.join(PATHS.stacks, name));
-      console.log(`  [dry-run] ${name}: ${exists ? "would skip (exists)" : "would copy"}`);
-    } else {
-      const result = copyStack(name);
-      if (result.skipped) {
-        console.log(`  \u25CB ${name}: skipped (${result.reason})`);
-      } else if (result.copied) {
-        console.log(`  \u2713 ${name}: copied to .rudi/stacks/`);
-      } else {
-        console.log(`  \u2717 ${name}: ${result.error}`);
-      }
-    }
-  }
-  if (!flags.dryRun) {
-    console.log(`
-Stacks migrated to: ${PATHS.stacks}`);
-  }
-}
-async function migrateConfigs(flags) {
-  console.log("=== Updating Agent Configs ===\n");
-  if (!flags.dryRun) {
-    ensureShim();
-    console.log(`Shim ready: ${SHIM_PATH}
-`);
-  }
-  let installedStacks = [];
-  if (fs30.existsSync(PATHS.stacks)) {
-    installedStacks = fs30.readdirSync(PATHS.stacks, { withFileTypes: true }).filter((d2) => d2.isDirectory() && !d2.name.startsWith(".")).map((d2) => d2.name);
-  }
-  for (const agentConfig of AGENT_CONFIGS) {
-    const configPath = findAgentConfig(agentConfig);
-    if (!configPath) continue;
-    if (flags.dryRun) {
-      console.log(`${agentConfig.name}:`);
-      console.log(`  [dry-run] Would update entries using .prompt-stack paths`);
-      continue;
-    }
-    const result = migrateAgentConfig(agentConfig, installedStacks, flags);
-    if (result.skipped) {
-      continue;
-    }
-    console.log(`${agentConfig.name}:`);
-    console.log(`  Config: ${configPath}`);
-    if (result.changes && result.changes.length > 0) {
-      for (const change of result.changes) {
-        console.log(`    ${change.action}: ${change.name}`);
-      }
-    }
-    if (result.updated > 0 || result.removed > 0) {
-      console.log(`  Updated: ${result.updated}, Removed: ${result.removed}`);
-    } else {
-      console.log(`  No changes needed`);
-    }
-    console.log("");
-  }
-  console.log("Restart your agents to use the updated configs.");
-}
-
 // src/commands/index-tools.js
 init_src4();
 init_src4();
@@ -38860,7 +39260,7 @@ init_src4();
 var import_child_process11 = require("child_process");
 var import_fs24 = __toESM(require("fs"), 1);
 var import_path22 = __toESM(require("path"), 1);
-var import_os8 = __toESM(require("os"), 1);
+var import_os7 = __toESM(require("os"), 1);
 var AGENTS = [
   {
     id: "claude",
@@ -38905,7 +39305,7 @@ var BINARIES = [
   { id: "jq", name: "jq", command: "jq", versionFlag: "--version" }
 ];
 function fileExists(filePath) {
-  const resolved = filePath.replace("~", import_os8.default.homedir());
+  const resolved = filePath.replace("~", import_os7.default.homedir());
   return import_fs24.default.existsSync(resolved);
 }
 function checkKeychain(service) {
@@ -39156,7 +39556,7 @@ init_src4();
 var import_child_process12 = require("child_process");
 var import_fs25 = __toESM(require("fs"), 1);
 var import_path23 = __toESM(require("path"), 1);
-var import_os9 = __toESM(require("os"), 1);
+var import_os8 = __toESM(require("os"), 1);
 var AGENT_CREDENTIALS = {
   claude: { type: "keychain", service: "Claude Code-credentials" },
   codex: { type: "file", path: "~/.codex/auth.json" },
@@ -39164,7 +39564,7 @@ var AGENT_CREDENTIALS = {
   copilot: { type: "file", path: "~/.config/github-copilot/hosts.json" }
 };
 function fileExists2(filePath) {
-  const resolved = filePath.replace("~", import_os9.default.homedir());
+  const resolved = filePath.replace("~", import_os8.default.homedir());
   return import_fs25.default.existsSync(resolved);
 }
 function checkKeychain2(service) {
@@ -39673,7 +40073,7 @@ Lockfile: ${lockPath}`);
 // src/commands/apply.js
 var import_fs28 = require("fs");
 var import_path26 = require("path");
-var import_os10 = require("os");
+var import_os9 = require("os");
 var import_crypto3 = require("crypto");
 async function cmdApply(args, flags) {
   const planFile = args[0];
@@ -39856,10 +40256,10 @@ Applying plan ${planId}...
     }
     console.log(`  \u2713 Updated ${updated} titles`);
   }
-  const undoDir = (0, import_path26.join)((0, import_os10.homedir)(), ".rudi", "plans");
-  const { mkdirSync: mkdirSync5 } = await import("fs");
+  const undoDir = (0, import_path26.join)((0, import_os9.homedir)(), ".rudi", "plans");
+  const { mkdirSync: mkdirSync4 } = await import("fs");
   try {
-    mkdirSync5(undoDir, { recursive: true });
+    mkdirSync4(undoDir, { recursive: true });
   } catch (e2) {
   }
   const undoFile = (0, import_path26.join)(undoDir, `${planId}.undo.json`);
@@ -40035,6 +40435,215 @@ Project deleted: ${project.name}`);
   }
 }
 
+// src/commands/studio.js
+var import_fs29 = __toESM(require("fs"), 1);
+var import_path27 = __toESM(require("path"), 1);
+var import_os10 = __toESM(require("os"), 1);
+var import_child_process13 = require("child_process");
+var STUDIO_WEBSITE = "https://learnrudi.com";
+var STUDIO_PATHS = {
+  darwin: [
+    "/Applications/RUDI Studio.app",
+    import_path27.default.join(import_os10.default.homedir(), "Applications/RUDI Studio.app")
+  ],
+  win32: [
+    import_path27.default.join(import_os10.default.homedir(), "AppData/Local/Programs/RUDI Studio"),
+    "C:/Program Files/RUDI Studio"
+  ],
+  linux: [
+    "/opt/RUDI Studio",
+    import_path27.default.join(import_os10.default.homedir(), ".local/share/applications/rudi-studio")
+  ]
+};
+var APP_DATA_PATHS = {
+  darwin: [
+    import_path27.default.join(import_os10.default.homedir(), "Library/Application Support/RUDI Studio"),
+    import_path27.default.join(import_os10.default.homedir(), "Library/Application Support/rudi-studio"),
+    import_path27.default.join(import_os10.default.homedir(), "Library/Caches/RUDI Studio"),
+    import_path27.default.join(import_os10.default.homedir(), "Library/Caches/rudi-studio"),
+    import_path27.default.join(import_os10.default.homedir(), "Library/Preferences/com.rudi.studio.plist"),
+    import_path27.default.join(import_os10.default.homedir(), "Library/Saved Application State/com.rudi.studio.savedState")
+  ],
+  win32: [
+    import_path27.default.join(import_os10.default.homedir(), "AppData/Roaming/RUDI Studio"),
+    import_path27.default.join(import_os10.default.homedir(), "AppData/Local/RUDI Studio")
+  ],
+  linux: [
+    import_path27.default.join(import_os10.default.homedir(), ".config/RUDI Studio"),
+    import_path27.default.join(import_os10.default.homedir(), ".config/rudi-studio")
+  ]
+};
+function findStudioPath() {
+  const platform = process.platform;
+  const paths = STUDIO_PATHS[platform] || [];
+  for (const p2 of paths) {
+    if (import_fs29.default.existsSync(p2)) {
+      return p2;
+    }
+  }
+  return null;
+}
+function getStudioVersion(studioPath) {
+  if (process.platform === "darwin") {
+    const plistPath = import_path27.default.join(studioPath, "Contents/Info.plist");
+    if (import_fs29.default.existsSync(plistPath)) {
+      const content = import_fs29.default.readFileSync(plistPath, "utf-8");
+      const match = content.match(/<key>CFBundleShortVersionString<\/key>\s*<string>([^<]+)<\/string>/);
+      if (match) {
+        return match[1];
+      }
+    }
+  } else {
+    const pkgPath = import_path27.default.join(studioPath, "resources/app/package.json");
+    if (import_fs29.default.existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(import_fs29.default.readFileSync(pkgPath, "utf-8"));
+        return pkg.version;
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+function openUrl(url) {
+  const platform = process.platform;
+  let cmd, args;
+  if (platform === "darwin") {
+    cmd = "open";
+    args = [url];
+  } else if (platform === "win32") {
+    cmd = "cmd";
+    args = ["/c", "start", "", url];
+  } else {
+    cmd = "xdg-open";
+    args = [url];
+  }
+  (0, import_child_process13.spawn)(cmd, args, { detached: true, stdio: "ignore" }).unref();
+}
+async function studioOpen() {
+  console.log(`Opening ${STUDIO_WEBSITE}...`);
+  openUrl(STUDIO_WEBSITE);
+}
+async function studioVersion(flags) {
+  const studioPath = findStudioPath();
+  if (!studioPath) {
+    console.log("RUDI Studio is not installed");
+    console.log(`
+Get it at: ${STUDIO_WEBSITE}`);
+    process.exit(1);
+  }
+  const version = getStudioVersion(studioPath);
+  if (version) {
+    console.log(`RUDI Studio v${version}`);
+  } else {
+    console.log("RUDI Studio installed");
+    console.log(`  Location: ${studioPath}`);
+    console.log("  Version: unknown");
+  }
+  if (flags.verbose) {
+    console.log(`
+  Path: ${studioPath}`);
+  }
+}
+async function studioUninstall(flags) {
+  const studioPath = findStudioPath();
+  const platform = process.platform;
+  const dataPaths = APP_DATA_PATHS[platform] || [];
+  const existingDataPaths = dataPaths.filter((p2) => import_fs29.default.existsSync(p2));
+  if (!studioPath && existingDataPaths.length === 0) {
+    console.log("RUDI Studio is not installed");
+    process.exit(0);
+  }
+  console.log("The following will be removed:");
+  if (studioPath) {
+    console.log(`  App: ${studioPath}`);
+  }
+  for (const p2 of existingDataPaths) {
+    console.log(`  Data: ${p2}`);
+  }
+  console.log("");
+  console.log("Note: ~/.rudi/ will NOT be removed (managed by RUDI CLI)");
+  console.log("");
+  if (!flags.force && !flags.y) {
+    console.log("Run with --force or -y to confirm uninstall");
+    process.exit(0);
+  }
+  let errors = [];
+  if (studioPath) {
+    try {
+      import_fs29.default.rmSync(studioPath, { recursive: true, force: true });
+      console.log(`Removed: ${studioPath}`);
+    } catch (err) {
+      errors.push(`Failed to remove ${studioPath}: ${err.message}`);
+    }
+  }
+  for (const p2 of existingDataPaths) {
+    try {
+      import_fs29.default.rmSync(p2, { recursive: true, force: true });
+      console.log(`Removed: ${p2}`);
+    } catch (err) {
+      errors.push(`Failed to remove ${p2}: ${err.message}`);
+    }
+  }
+  if (errors.length > 0) {
+    console.log("");
+    console.log("Some items could not be removed:");
+    for (const err of errors) {
+      console.log(`  ${err}`);
+    }
+    console.log("");
+    console.log("You may need to remove them manually or use sudo.");
+    process.exit(1);
+  }
+  console.log("");
+  console.log("RUDI Studio uninstalled successfully");
+}
+function showHelp() {
+  console.log(`rudi studio - Manage RUDI Studio
+
+Usage:
+  rudi studio              Open RUDI website
+  rudi studio version      Show installed Studio version
+  rudi studio uninstall    Uninstall RUDI Studio
+
+Options:
+  --force, -y              Skip confirmation for uninstall
+  --verbose                Show additional details
+
+Examples:
+  rudi studio              # Open learnrudi.com in browser
+  rudi studio version      # Check installed version
+  rudi studio uninstall -y # Remove Studio and app data
+`);
+}
+async function cmdStudio(args, flags) {
+  const subcommand = args[0];
+  switch (subcommand) {
+    case "version":
+    case "v":
+      await studioVersion(flags);
+      break;
+    case "uninstall":
+    case "remove":
+    case "rm":
+      await studioUninstall(flags);
+      break;
+    case "help":
+    case "-h":
+    case "--help":
+      showHelp();
+      break;
+    case "open":
+    case void 0:
+      await studioOpen();
+      break;
+    default:
+      console.error(`Unknown subcommand: ${subcommand}`);
+      console.error(`Run 'rudi studio help' for usage`);
+      process.exit(1);
+  }
+}
+
 // src/index.js
 var VERSION2 = "2.0.0";
 async function main() {
@@ -40123,9 +40732,6 @@ async function main() {
       case "integrate":
         await cmdIntegrate(args, flags);
         break;
-      case "migrate":
-        await cmdMigrate(args, flags);
-        break;
       case "index":
         await cmdIndex(args, flags);
         break;
@@ -40145,6 +40751,9 @@ async function main() {
       case "package":
         await cmdInfo(args, flags);
         break;
+      case "studio":
+        await cmdStudio(args, flags);
+        break;
       // Shortcuts for listing specific package types
       case "stacks":
         await cmdList(["stacks"], flags);