@principal-ai/subsystems-studio 0.6.8 → 0.6.9

package/bundles/macos-arm64/subsystems-studio.app/Contents/Resources/app/bun/session-warmup-worker.js

@@ -10655,7 +10655,7 @@ import {
 import { homedir as homedir2 } from "os";
 import { join as join3 } from "path";
 var CACHE_ROOT = join3(homedir2(), ".principal", "session-events");
-var PROCESSING_VERSION = 1;
+var PROCESSING_VERSION = 2;
 var KEEP_DAYS = 14;
 function dayKeyOf(date) {
   const y = date.getFullYear();
@@ -10745,6 +10745,24 @@ function trimSessionEventRows(events) {
 
 // src/bun/session-pipeline.ts
 import { statSync as statSync3 } from "fs";
+
+// src/bun/maintain-sessions.ts
+function isMaintainSessionTitle(title) {
+  return /^Maintain\s*[\u2014\u2013-]/.test(title.trim());
+}
+function isMaintainAgentName(agent) {
+  return agent === "issue-fixer" || agent === "gap-filler";
+}
+function isMaintainSession(opts) {
+  if (isMaintainAgentName(opts.agent))
+    return true;
+  if (opts.title && isMaintainSessionTitle(opts.title))
+    return true;
+  return false;
+}
+
+// src/bun/opencode-v2-messages.ts
+import { Database } from "bun:sqlite";
 function openCodeDBPath() {
   const env = process.env;
   if (env["OPENCODE_DATA_DIR"])
@@ -10753,6 +10771,222 @@ function openCodeDBPath() {
   const xdgData = env["XDG_DATA_HOME"] || `${home}/.local/share`;
   return `${xdgData}/opencode/opencode.db`;
 }
+function tableExists(db, name) {
+  const row = db.prepare(`SELECT 1 AS ok FROM sqlite_master WHERE type = 'table' AND name = ?`).get(name);
+  return row != null;
+}
+function openReadonlyDb() {
+  return new Database(openCodeDBPath(), { readonly: true });
+}
+function resolveOpencodeSessionKind(sessionId, db) {
+  const owned = !db;
+  let conn = db ?? null;
+  try {
+    if (!conn)
+      conn = openReadonlyDb();
+    if (tableExists(conn, "session_v2")) {
+      const v2 = conn.prepare(`SELECT 1 AS ok FROM session_v2 WHERE id = ?`).get(sessionId);
+      if (v2)
+        return "v2";
+    }
+    if (tableExists(conn, "session")) {
+      const v1 = conn.prepare(`SELECT 1 AS ok FROM session WHERE id = ?`).get(sessionId);
+      if (v1)
+        return "v1";
+    }
+    return null;
+  } catch {
+    return null;
+  } finally {
+    if (owned) {
+      try {
+        conn?.close();
+      } catch {}
+    }
+  }
+}
+function isOpencodeV2Session(sessionId) {
+  return resolveOpencodeSessionKind(sessionId) === "v2";
+}
+function readOpencodeV2Session(sessionId) {
+  let db = null;
+  try {
+    db = openReadonlyDb();
+    if (!tableExists(db, "session_v2"))
+      return null;
+    const metaRow = db.prepare(`SELECT id, title, slug, agent, directory, version
+				 FROM session_v2 WHERE id = ?`).get(sessionId);
+    if (!metaRow)
+      return null;
+    const messages = tableExists(db, "session_message") ? db.prepare(`SELECT id, session_id, type, seq, time_created, data
+						 FROM session_message
+						 WHERE session_id = ?
+						 ORDER BY seq ASC`).all(sessionId) : [];
+    return {
+      meta: {
+        id: metaRow.id,
+        title: (metaRow.title ?? "").trim() || metaRow.id.slice(0, 12),
+        slug: metaRow.slug ?? "",
+        agent: metaRow.agent ?? undefined,
+        directory: metaRow.directory ?? undefined,
+        version: metaRow.version ?? undefined
+      },
+      messages
+    };
+  } catch {
+    return null;
+  } finally {
+    try {
+      db?.close();
+    } catch {}
+  }
+}
+function mapToolName(name) {
+  const n = name.trim().toLowerCase();
+  if (n === "shell" || n === "bash")
+    return "Bash";
+  if (n === "read")
+    return "Read";
+  if (n === "write")
+    return "Write";
+  if (n === "edit" || n === "multiedit")
+    return "Edit";
+  if (n === "glob")
+    return "Glob";
+  if (n === "grep")
+    return "Grep";
+  if (n === "list" || n === "ls")
+    return "Bash";
+  if (n === "webfetch")
+    return "WebFetch";
+  if (n === "websearch")
+    return "WebSearch";
+  if (n === "task")
+    return "Task";
+  return name;
+}
+function pathsFromToolInput(input) {
+  if (!input || typeof input !== "object")
+    return [];
+  const obj = input;
+  const paths = [];
+  for (const key of ["filePath", "file_path", "path", "pattern", "glob"]) {
+    if (typeof obj[key] === "string" && obj[key].trim()) {
+      paths.push(obj[key]);
+    }
+  }
+  return paths;
+}
+function applyFileContext(event, toolName, toolInput) {
+  const paths = pathsFromToolInput(toolInput);
+  if (paths.length === 0)
+    return;
+  event.rawFilePaths = [...new Set(paths)];
+  const op = getFileOperation(toolName);
+  if (op)
+    event.operation = op;
+}
+function sessionMessagesToUniversalEvents(sessionId, messages, opts) {
+  const workingDirectory = opts?.workingDirectory?.trim() || "";
+  const out = [];
+  for (const row of messages) {
+    let parsed;
+    try {
+      parsed = JSON.parse(row.data);
+    } catch {
+      continue;
+    }
+    const time = parsed["time"];
+    const created = typeof time?.["created"] === "number" ? time["created"] : typeof row.time_created === "number" ? row.time_created : Date.now();
+    const base = {
+      sessionId,
+      workingDirectory,
+      timestamp: created,
+      provider: SupportedAgent.OPENCODE,
+      raw: { id: row.id, type: row.type, seq: row.seq, data: parsed }
+    };
+    if (row.type === "user") {
+      const text = typeof parsed["text"] === "string" ? parsed["text"] : "";
+      out.push({
+        ...base,
+        eventType: "user-prompt-submit",
+        data: { prompt: text, messageID: row.id }
+      });
+      continue;
+    }
+    if (row.type !== "assistant")
+      continue;
+    const content = Array.isArray(parsed["content"]) ? parsed["content"] : [];
+    for (const part of content) {
+      const partType = typeof part["type"] === "string" ? part["type"] : "";
+      const partTime = part["time"];
+      const partCreated = typeof partTime?.["created"] === "number" ? partTime["created"] : typeof partTime?.["completed"] === "number" ? partTime["completed"] : created;
+      const partBase = {
+        ...base,
+        timestamp: partCreated,
+        raw: { ...base.raw, part }
+      };
+      if (partType === "reasoning") {
+        const text = typeof part["text"] === "string" ? part["text"] : "";
+        out.push({
+          ...partBase,
+          eventType: "model-reasoning",
+          data: { messageID: row.id, message: text }
+        });
+        continue;
+      }
+      if (partType === "text") {
+        const text = typeof part["text"] === "string" ? part["text"] : "";
+        out.push({
+          ...partBase,
+          eventType: "notification",
+          data: { messageID: row.id, message: text }
+        });
+        continue;
+      }
+      if (partType !== "tool")
+        continue;
+      const rawName = typeof part["name"] === "string" ? part["name"] : typeof part["tool"] === "string" ? part["tool"] : "unknown";
+      const toolName = mapToolName(rawName);
+      const callID = typeof part["id"] === "string" ? part["id"] : `${row.id}-${partCreated}`;
+      const state = typeof part["state"] === "object" && part["state"] !== null ? part["state"] : {};
+      const input = state["input"];
+      const status = typeof state["status"] === "string" ? state["status"].toLowerCase() : "";
+      const failed = status.includes("fail") || status.includes("error") || part["error"] != null;
+      const pre = {
+        ...partBase,
+        eventType: "pre-tool-use",
+        toolName,
+        toolInput: input,
+        data: { callID, tool: rawName }
+      };
+      applyFileContext(pre, rawName, input);
+      out.push(pre);
+      const post = {
+        ...partBase,
+        timestamp: typeof partTime?.["completed"] === "number" ? partTime["completed"] : partCreated,
+        eventType: failed ? "post-tool-use-failure" : "post-tool-use",
+        toolName,
+        toolInput: input,
+        toolOutput: state["content"] ?? state["output"] ?? state["metadata"],
+        data: { callID, tool: rawName, status: state["status"] }
+      };
+      applyFileContext(post, rawName, input);
+      out.push(post);
+    }
+  }
+  return out;
+}
+
+// src/bun/session-pipeline.ts
+function openCodeDBPath2() {
+  const env = process.env;
+  if (env["OPENCODE_DATA_DIR"])
+    return `${env["OPENCODE_DATA_DIR"]}/opencode/opencode.db`;
+  const home = env["HOME"] || env["USERPROFILE"] || "/root";
+  const xdgData = env["XDG_DATA_HOME"] || `${home}/.local/share`;
+  return `${xdgData}/opencode/opencode.db`;
+}
 var INCLUDE_RAW_EVENT_PAYLOADS = (process.env["TRAIL_INCLUDE_RAW"] ?? "") === "1";
 function wantRawPayloads(requestIncludeRaw) {
   return INCLUDE_RAW_EVENT_PAYLOADS || requestIncludeRaw;
@@ -10778,6 +11012,104 @@ var cursorReader = new CursorSessionReader;
 function isCursorSession(sessionId) {
   return cursorReader.readSession(sessionId) !== null;
 }
+async function runOpencodeV2MessagePipeline(sessionId) {
+  const record = readOpencodeV2Session(sessionId);
+  if (!record)
+    return null;
+  const sessionTitle = record.meta.title || "OpenCode V2 session";
+  const sessionSlug = record.meta.slug || "";
+  const workingDirectory = record.meta.directory ?? "";
+  const rawEvents = sessionMessagesToUniversalEvents(sessionId, record.messages, {
+    workingDirectory
+  });
+  if (rawEvents.length === 0)
+    return null;
+  const alexandriaRepos = loadAlexandriaRepos();
+  const knownRoots = new Map;
+  for (const [path, repo] of alexandriaRepos) {
+    knownRoots.set(path, {
+      root: repo.root,
+      remoteUrl: repo.remoteUrl,
+      owner: repo.owner,
+      repo: repo.repo
+    });
+  }
+  const adapter = new BunNormalizationAdapter(knownRoots);
+  const normalizationService = new PathNormalizationService(adapter);
+  const normalizedEvents = await normalizationService.normalizePathsBatch(rawEvents, workingDirectory);
+  for (const discovered of adapter.newlyDiscovered) {
+    registerProjectInAlexandria(discovered.root, discovered.remoteUrl);
+  }
+  const accState = createAccumulatedState(sessionTitle);
+  const events = [];
+  const repoSet = new Map;
+  for (let i = 0;i < normalizedEvents.length; i++) {
+    const normalizedEvent = normalizedEvents[i];
+    const accResult = eventOp(accState, normalizedEvent);
+    events.push({
+      seq: i,
+      type: normalizedEvent.eventType,
+      raw: INCLUDE_RAW_EVENT_PAYLOADS ? normalizedEvent.raw : undefined,
+      normalized: INCLUDE_RAW_EVENT_PAYLOADS ? normalizedEvent : { timestamp: normalizedEvent.timestamp },
+      accumulated: accResult
+    });
+    if (normalizedEvent.files) {
+      for (const f of normalizedEvent.files) {
+        const root = f.repository?.gitRoot;
+        if (root) {
+          const entry = repoSet.get(root) ?? { root, fileCount: 0 };
+          entry.fileCount++;
+          repoSet.set(root, entry);
+        }
+      }
+    }
+  }
+  const lastEvent = events[events.length - 1];
+  if (lastEvent) {
+    const lastTimestamp = lastEvent.normalized["timestamp"] ?? 0;
+    events.push({
+      seq: lastEvent.seq + 1,
+      type: "finished",
+      raw: null,
+      normalized: { timestamp: lastTimestamp },
+      accumulated: {
+        id: "",
+        timestamp: lastTimestamp,
+        sessionId: sessionSlug || sessionId,
+        sessionName: accState.sessionName,
+        sessionColor: accState.sessionColor,
+        operation: "finished",
+        files: [],
+        dependencies: [],
+        description: `${accState.sessionName} finished`,
+        layers: [],
+        contextTokens: accState.contextTokens
+      }
+    });
+  }
+  const repos = Array.from(repoSet.values()).sort((a, b) => b.fileCount - a.fileCount).map((r) => {
+    const parts = r.root.replace(/\/+$/, "").split("/");
+    const known = knownRoots.get(r.root);
+    return {
+      root: r.root,
+      fileCount: r.fileCount,
+      owner: known?.owner ?? null,
+      name: parts[parts.length - 1] ?? null,
+      editing: false
+    };
+  });
+  const repoRoot = repos.length > 0 ? repos[0].root : undefined;
+  return {
+    rawEvents,
+    normalizedEvents,
+    accState,
+    events,
+    repos,
+    repoRoot,
+    sessionTitle,
+    sessionSlug
+  };
+}
 async function runClinePipeline(sessionId) {
   const record = clineReader.readSession(sessionId);
   if (!record)
@@ -11241,7 +11573,7 @@ function dbFingerprint(dbPath) {
 async function buildSessionIndex({ days }) {
   const dayCount = Math.max(1, Math.floor(days ?? 7));
   const cutoff = Date.now() - dayCount * 86400000;
-  const dbPath = openCodeDBPath();
+  const dbPath = openCodeDBPath2();
   const cacheKey = `${dayCount}|${dbFingerprint(dbPath)}`;
   const cached = indexCache.get(cacheKey);
   if (cached)
@@ -11249,8 +11581,8 @@ async function buildSessionIndex({ days }) {
   let result;
   let db = null;
   try {
-    const { Database } = await import("bun:sqlite");
-    db = new Database(dbPath, { readonly: true });
+    const { Database: Database2 } = await import("bun:sqlite");
+    db = new Database2(dbPath, { readonly: true });
     const firstEvents = db.prepare(`SELECT
 					e.aggregate_id,
 					e.data
@@ -11263,6 +11595,7 @@ async function buildSessionIndex({ days }) {
       let title = row.aggregate_id.slice(0, 12);
       let slug = "";
       let createdAtStr = "";
+      let agentFromInfo;
       const durationMs = 0;
       try {
         const parsed = JSON.parse(row.data);
@@ -11275,12 +11608,18 @@ async function buildSessionIndex({ days }) {
         if (typeof rawSlug === "string") {
           slug = rawSlug;
         }
+        const rawAgent = info?.["agent"];
+        if (typeof rawAgent === "string") {
+          agentFromInfo = rawAgent;
+        }
         const rawTime = info?.["time"];
         const rawCreated = rawTime?.["created"];
         if (typeof rawCreated === "number") {
           createdAtStr = new Date(rawCreated).toISOString();
         }
       } catch {}
+      if (isMaintainSession({ title, agent: agentFromInfo }))
+        continue;
       const createdMs = createdAtStr ? new Date(createdAtStr).getTime() : 0;
       if (!createdMs)
         continue;
@@ -11606,6 +11945,17 @@ async function processSessionEvents(sessionId, opts) {
       return { ok: false, error: err.message };
     }
   }
+  if (isOpencodeV2Session(sessionId)) {
+    try {
+      const result = await runOpencodeV2MessagePipeline(sessionId);
+      if (!result) {
+        return { ok: false, error: "OpenCode V2 session not found or empty" };
+      }
+      return respondWithCachedPipeline(sessionId, "opencode-v2", result);
+    } catch (err) {
+      return { ok: false, error: err.message };
+    }
+  }
   const cacheKey = `opencode:${sessionId}:${includeRaw ? "raw" : "min"}`;
   let events = sessionEventsCache.get(cacheKey);
   let sessionSlug = "";
@@ -11613,11 +11963,11 @@ async function processSessionEvents(sessionId, opts) {
   let repoRoot;
   let repos = [];
   if (!events) {
-    const dbPath = openCodeDBPath();
+    const dbPath = openCodeDBPath2();
     let db = null;
     try {
-      const { Database } = await import("bun:sqlite");
-      db = new Database(dbPath, { readonly: true });
+      const { Database: Database2 } = await import("bun:sqlite");
+      db = new Database2(dbPath, { readonly: true });
       const rows = db.prepare(`SELECT id, aggregate_id, seq, type, data FROM event WHERE aggregate_id = ? ORDER BY seq ASC`).all(sessionId);
       if (rows.length > 0) {
         try {
@@ -11711,13 +12061,15 @@ async function processSessionEvents(sessionId, opts) {
       }).sort((a, b) => b.fileCount - a.fileCount);
       repoRoot = repos.length > 0 ? repos[0].root : undefined;
       events = built;
-      writeCachedSessionEvents(sessionId, {
-        agent: "opencode",
-        session: { slug: sessionSlug, title: sessionTitle, agent: "opencode" },
-        repoRoot,
-        repos,
-        events: trimSessionEventRows(built)
-      });
+      if (built.length > 0) {
+        writeCachedSessionEvents(sessionId, {
+          agent: "opencode",
+          session: { slug: sessionSlug, title: sessionTitle, agent: "opencode" },
+          repoRoot,
+          repos,
+          events: trimSessionEventRows(built)
+        });
+      }
       sessionEventsCache.set(cacheKey, events);
       while (sessionEventsCache.size > 4) {
         const oldestKey = sessionEventsCache.keys().next().value;

package/bundles/macos-arm64/subsystems-studio.app/Contents/Resources/metadata.json

@@ -2,5 +2,5 @@
   "identifier": "ai.principal.subsystems-studio",
   "name": "Subsystems Studio",
   "channel": "stable",
-  "hash": "ct2o0q8id5eq"
+  "hash": "13kyfkdd9mdni"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@principal-ai/subsystems-studio",
-  "version": "0.6.8",
-  "description": "Subsystems Studio — desktop host for subsystem models, throughlines, trails, and agent sessions. Pairs with the principal-ai CLI.",
+  "version": "0.6.9",
+  "description": "Subsystems Studio — desktop host for subsystem models, walkthroughs, trails, and agent sessions. Pairs with the principal-ai CLI.",
   "type": "module",
   "os": [
     "darwin"
@@ -44,8 +44,8 @@
     "@principal-ai/file-city-react": "^0.5.91",
     "@principal-ai/logo-component": "^0.1.23",
     "@principal-ai/repository-abstraction": "^0.5.7",
-    "@principal-ai/subsystems-core": "0.31.4",
-    "@principal-ai/subsystems-react": "0.20.6",
+    "@principal-ai/subsystems-core": "0.32.0",
+    "@principal-ai/subsystems-react": "0.21.1",
     "@types/bun": "latest",
     "@types/react": "^19.2.17",
     "@types/react-dom": "^19.2.3",