@agentprojectcontext/apx 1.81.0 → 1.89.1

package/src/core/sessions/index.js

@@ -16,6 +16,7 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { execFileSync } from "node:child_process";
 import { apcProjectFile } from "#core/apc/paths.js";
 import { parseFrontmatterFields as parseFrontmatter } from "#core/apc/frontmatter.js";
 
@@ -323,6 +324,9 @@ const claudeEngine = {
   resumeHint(id) {
     return `claude -p --resume ${id} "your prompt"`;
   },
+  resumeArgv(id) {
+    return ["claude", "--resume", id];
+  },
 };
 
 // ── codex engine ─────────────────────────────────────────────────────────────
@@ -487,6 +491,9 @@ const codexEngine = {
   resumeHint(id) {
     return `codex exec resume ${id} "your prompt"   (interactive: codex resume ${id})`;
   },
+  resumeArgv(id) {
+    return ["codex", "resume", id];
+  },
 };
 
 // ── apx engine (default) ─────────────────────────────────────────────────────
@@ -647,6 +654,144 @@ const apxEngine = {
   resumeHint(id) {
     return `apx session resume ${id}`;
   },
+  resumeArgv(id) {
+    // An APX session is a record of a runtime run, not a conversation a CLI can
+    // re-enter. `resume` prints what it was — the honest equivalent.
+    return ["apx", "session", "resume", id];
+  },
+};
+
+// ── opencode engine ──────────────────────────────────────────────────────────
+//
+// The one engine with no files to read: OpenCode keeps its sessions in its own
+// SQLite database, and APX stores nothing in SQL. So we ask OpenCode itself
+// instead of reaching into its database — its CLI is the supported interface,
+// and it survives schema changes we would otherwise have to chase.
+//
+// Two calls, deliberately split by cost. `opencode session list` prints every
+// session newest-first in about half a second, so the listing is memoised for a
+// few seconds — a Sessions search box would otherwise spawn a process per
+// keystroke. The working directory only exists in `opencode export <id>`, one
+// spawn per session, so it's paid only when a single session is opened.
+//
+// What we give up by not reading the database: sessions arrive without a cwd,
+// so they show in the global list and not in a per-project one.
+
+const OPENCODE_LIST_TTL_MS = 5000;
+let opencodeListCache = { at: 0, rows: [] };
+
+function opencodeCli(args, { timeoutMs = 15000 } = {}) {
+  try {
+    return execFileSync("opencode", args, {
+      encoding: "utf8",
+      timeout: timeoutMs,
+      stdio: ["ignore", "pipe", "ignore"],
+    });
+  } catch {
+    // Not installed, too slow, or a version without this subcommand. An engine
+    // that can't answer is an engine with no sessions — never a thrown listing.
+    return "";
+  }
+}
+
+// "2:26 PM" (today) or "4:48 PM · 7/6/2026". Locale-shaped, so anything we
+// don't recognise returns 0: the row still lists, it just sorts last rather
+// than claiming a time it doesn't have.
+export function parseOpencodeUpdated(text, now = Date.now()) {
+  const [clock, date] = String(text || "").split("·").map((s) => s.trim());
+  const t = /^(\d{1,2}):(\d{2})\s*(AM|PM)$/i.exec(clock || "");
+  if (!t) return 0;
+  let hour = Number(t[1]) % 12;
+  if (/PM/i.test(t[3])) hour += 12;
+  const when = new Date(now);
+  if (date) {
+    const d = /^(\d{1,2})\/(\d{1,2})\/(\d{4})$/.exec(date);
+    if (!d) return 0;
+    when.setFullYear(Number(d[3]), Number(d[1]) - 1, Number(d[2]));
+  }
+  when.setHours(hour, Number(t[2]), 0, 0);
+  return when.getTime();
+}
+
+// Fixed-width table: id, title, then the timestamp. Only `ses_` lines are rows,
+// which skips the header and its rule without having to count them.
+export function parseOpencodeSessionList(stdout, now = Date.now()) {
+  const rows = [];
+  for (const line of String(stdout || "").split("\n")) {
+    const m = /^(ses_\S+)\s\s+(.*?)\s\s+(\S.*?)\s*$/.exec(line);
+    if (!m) continue;
+    rows.push({ id: m[1], title: m[2].trim(), mtime: parseOpencodeUpdated(m[3], now) });
+  }
+  return rows;
+}
+
+const opencodeEngine = {
+  id: "opencode",
+  label: "OpenCode",
+  implemented: true,
+  detect(opts) {
+    const candidates = [
+      path.join(homeDir(opts), ".local", "share", "opencode"),
+      path.join(homeDir(opts), ".config", "opencode"),
+    ];
+    return candidates.some((c) => fs.existsSync(c))
+      ? { available: true }
+      : { available: false, reason: "OpenCode not installed" };
+  },
+  // No directory tree to walk: OpenCode is asked for all of its sessions at
+  // once. collectAllSessions calls this instead of listProjects/listSessions.
+  listAllSessions(opts = {}) {
+    const now = (opts.now || Date.now)();
+    if (opencodeListCache.rows.length && now - opencodeListCache.at < OPENCODE_LIST_TTL_MS) {
+      return opencodeListCache.rows;
+    }
+    const rows = parseOpencodeSessionList(opencodeCli(["session", "list"]), now);
+    opencodeListCache = { at: now, rows };
+    return rows;
+  },
+  findSessionById(id, opts = {}) {
+    // Guard the spawn: every cross-engine lookup would otherwise pay for an
+    // `opencode export` of a Claude uuid that can never match.
+    if (!/^ses_[A-Za-z0-9]+$/.test(String(id || ""))) return null;
+    let dump;
+    try {
+      dump = JSON.parse(opencodeCli(["export", id]));
+    } catch {
+      return null;
+    }
+    const info = dump?.info;
+    if (!info?.id) return null;
+    // The export already carries the conversation, so the last prompt costs
+    // nothing extra — and it's what the other engines contribute to a summary.
+    let lastPrompt = null;
+    for (const m of dump.messages || []) {
+      if (m?.info?.role !== "user") continue;
+      const text = (m.parts || [])
+        .filter((p) => p?.type === "text" && typeof p.text === "string")
+        .map((p) => p.text)
+        .join("\n")
+        .trim();
+      if (text) lastPrompt = text;
+    }
+    return {
+      engine: "opencode",
+      id: info.id,
+      path: null,
+      cwd: info.directory || null,
+      title: info.title || "",
+      lastPrompt,
+      mtime: Number(info.time?.updated) || (opts.now || Date.now)(),
+    };
+  },
+  continueHint() {
+    return `opencode --continue   (run from the project directory)`;
+  },
+  resumeHint(id) {
+    return `opencode --session ${id}`;
+  },
+  resumeArgv(id) {
+    return ["opencode", "--session", id];
+  },
 };
 
 // ── antigravity engine (detected, listing not implemented) ───────────────────
@@ -676,9 +821,34 @@ export const ENGINES = {
   apx: apxEngine,
   claude: claudeEngine,
   codex: codexEngine,
+  opencode: opencodeEngine,
   antigravity: antigravityEngine,
 };
 
+// ── resuming a session in its own CLI ────────────────────────────────────────
+//
+// Every engine re-enters a conversation differently, and getting it wrong is
+// silent: the CLI starts a NEW session and the user only notices once the
+// history they expected isn't there. So the command lives with the engine that
+// owns it, and both callers — the terminal the daemon spawns, and the line the
+// user copies to run it elsewhere — read it from here. One definition, so the
+// button and the terminal can never drift apart.
+
+/** argv for re-entering `id` interactively, or null if the engine can't. */
+export function resumeArgvFor(engineId, id) {
+  const engine = ENGINES[engineId];
+  if (!engine || typeof engine.resumeArgv !== "function" || !id) return null;
+  const argv = engine.resumeArgv(id);
+  return Array.isArray(argv) && argv.length ? argv : null;
+}
+
+/** The same command as one pasteable line. Quotes only what needs it. */
+export function resumeCommandFor(engineId, id) {
+  const argv = resumeArgvFor(engineId, id);
+  if (!argv) return null;
+  return argv.map((a) => (/^[A-Za-z0-9_.:/=-]+$/.test(a) ? a : `'${a.replace(/'/g, `'\\''`)}'`)).join(" ");
+}
+
 // ── cross-engine helpers (used by `apx session resume <id>` etc.) ────────────
 
 /**
@@ -725,9 +895,31 @@ export function collectAllSessions(opts = {}, { dir = null, engineId = null } =
   const out = [];
   for (const engine of Object.values(ENGINES)) {
     if (engineId && engine.id !== engineId) continue;
-    if (!engine.implemented || typeof engine.listSessions !== "function") continue;
+    if (!engine.implemented) continue;
     if (!engine.detect(opts).available) continue;
 
+    // Engines that don't file their sessions under a working directory answer
+    // in one shot instead. They can't honour a `dir` scope — having no cwd to
+    // match, they'd answer every project's question with the same rows — so a
+    // scoped listing skips them rather than polluting it.
+    if (typeof engine.listAllSessions === "function") {
+      if (dir) continue;
+      let rows = [];
+      try { rows = engine.listAllSessions(opts) || []; } catch { rows = []; }
+      for (const s of rows) {
+        out.push({
+          engine: engine.id,
+          id: s.id,
+          title: s.title || "",
+          mtime: s.mtime || 0,
+          cwd: s.cwd || null,
+          path: s.path || null,
+        });
+      }
+      continue;
+    }
+    if (typeof engine.listSessions !== "function") continue;
+
     const dirs = [];
     if (dir) {
       dirs.push(dir);

package/src/core/stores/agent-inbox.js

@@ -16,8 +16,27 @@
 // resolution.
 import { readAgents } from "../apc/parser.js";
 import { listConversations } from "./conversations.js";
-import { listGlobalThreads, readGlobalThread } from "./messages.js";
+import { CHANNELS } from "../constants/channels.js";
+import { listGlobalThreads, readGlobalThread, previewText } from "./messages.js";
 import { SUPERAGENT_ACTOR_ID } from "../constants/actors.js";
+import { readConfig } from "../config/index.js";
+import { resolveSuperAgentBlob } from "../apc/agent-identity.js";
+
+/**
+ * One entry per channel, keeping the FIRST seen — which is the most recent,
+ * because every list feeding this is already sorted newest-first.
+ *
+ * Written out rather than `new Map(items.map(…))`: that form keeps the LAST
+ * duplicate, so it silently picked each channel's OLDEST conversation and every
+ * row wore a months-stale date and preview.
+ */
+function latestPerChannel(items) {
+  const byChannel = new Map();
+  for (const item of items) {
+    if (!byChannel.has(item.channel)) byChannel.set(item.channel, item);
+  }
+  return [...byChannel.values()];
+}
 
 /** Most recent first; slug breaks ties so two identical calls agree. */
 function byRecency(a, b) {
@@ -33,10 +52,19 @@ function byRecency(a, b) {
  * @param {object} opts
  *   - limit          cap applied AFTER the merge
  *   - includeEmpty   also list agents that have never been talked to
+ *   - channel        scope each row to ONE channel (e.g. "web"): the row's
+ *                    headline conversation must be on that channel, and an agent
+ *                    with none drops out (unless includeEmpty). The inbox and the
+ *                    phone pass "web" so a Telegram thread never surfaces there;
+ *                    project-first navigation passes nothing and sees every channel.
+ *   - perChannel     emit one row per (agent, channel) instead of a single
+ *                    headline per agent, so a list can group by channel and a
+ *                    quiet channel is not hidden behind a louder one. Ignored
+ *                    when `channel` is set — that already scopes to one.
  * @returns {{ rows: object[], skipped: {id:any, error:string}[] }}
  */
 export function listAgentInbox(projects, opts = {}) {
-  const { limit, includeEmpty = false } = opts || {};
+  const { limit, includeEmpty = false, channel = null, perChannel = false } = opts || {};
   const rows = [];
   const skipped = [];
 
@@ -65,23 +93,50 @@ export function listAgentInbox(projects, opts = {}) {
         // whole project from the inbox.
         conversations = [];
       }
-      const latest = conversations[0] || null;
-      if (!latest && !includeEmpty) continue;
+      // A routine conversation is not a chat: the routine runs on its own and
+      // its delivered output lands in the agent's web chat, which is the row we
+      // want to show. Chatting inside the routine thread happens, but it should
+      // not become the agent's inbox entry — pick the latest NON-routine
+      // conversation instead. An agent whose only activity is routine runs has
+      // no chat to show and drops out of the inbox (unless includeEmpty).
+      //
+      // When `channel` is set, the headline must be on THAT channel — the inbox
+      // and the phone are web-only, so an agent whose only chat is on Telegram
+      // has nothing to show there and drops out (unless includeEmpty).
+      const eligible = conversations.filter((c) =>
+        channel ? c.channel === channel : c.channel !== CHANNELS.ROUTINE,
+      );
+      // `perChannel`: one row per channel this agent was talked to on, instead
+      // of a single headline. An agent reached on WhatsApp AND on the web is
+      // two conversations, and collapsing them to whichever spoke last hid the
+      // other one entirely — which is the whole reason WhatsApp threads were
+      // invisible even once they were being written.
+      const headlines = perChannel ? latestPerChannel(eligible) : [eligible[0] || null];
+      if (!headlines[0] && !includeEmpty) continue;
 
-      rows.push({
-        ...projectMeta,
-        agent_slug: agent.slug,
-        agent_name: agent.fields?.Name || agent.name || agent.slug,
-        agent_emoji: agent.fields?.Emoji || agent.emoji || null,
-        kind: "agent",
-        pinned: false,
-        conversation_id: latest?.id || null,
-        channel: latest?.channel || null,
-        messages: latest?.messages || 0,
-        // The agent's last REPLY, not the user's last prompt.
-        preview: latest?.preview || null,
-        last_activity_at: latest?.last_turn_at || latest?.started_at || "",
-      });
+      for (const latest of headlines) {
+        rows.push({
+          ...projectMeta,
+          agent_slug: agent.slug,
+          agent_name: agent.fields?.Name || agent.name || agent.slug,
+          agent_emoji: agent.fields?.Emoji || agent.emoji || null,
+          agent_icon: agent.fields?.Icon || agent.icon || null,
+          kind: "agent",
+          pinned: false,
+          conversation_id: latest?.id || null,
+          channel: latest?.channel || null,
+          messages: latest?.messages || 0,
+          // The agent's last REPLY, not the user's last prompt.
+          preview: latest?.preview || null,
+          // WHEN that reply was written — which is not when the thread last
+          // moved. A row moves for the owner's own send and for every tool the
+          // agent runs; only this moves when the agent actually SAYS something,
+          // which is the difference between one notification per answer and one
+          // per step of a 24-step turn. See lib/notify.ts.
+          preview_at: latest?.preview_at || null,
+          last_activity_at: latest?.last_turn_at || latest?.started_at || "",
+        });
+      }
     }
   }
 
@@ -90,8 +145,8 @@ export function listAgentInbox(projects, opts = {}) {
   // The super-agent is the single voice the owner talks to and the others
   // report through it. It is pinned first and marked distinct so the hierarchy
   // is visible, rather than sorted in among its own reports.
-  const superRow = buildSuperAgentRow();
-  const out = superRow ? [superRow, ...rows] : rows;
+  const superRows = buildSuperAgentRows({ channel, perChannel });
+  const out = [...superRows, ...rows];
 
   return {
     rows: Number.isFinite(limit) && limit > 0 ? out.slice(0, limit) : out,
@@ -107,7 +162,8 @@ export function listAgentInbox(projects, opts = {}) {
  * (~/.apx/messages/<channel>/YYYY-MM-DD.jsonl). So recency and the preview come
  * from there, not from agents/<slug>/conversations.
  */
-function buildSuperAgentRow() {
+function buildSuperAgentRows(opts = {}) {
+  const { channel = null, perChannel = false } = opts || {};
   let threads = [];
   try {
     threads = listGlobalThreads();
@@ -115,23 +171,51 @@ function buildSuperAgentRow() {
     threads = [];
   }
 
+  const eligible = threads.filter((t) =>
+    channel ? t.channel === channel : t.channel !== CHANNELS.ROUTINE,
+  );
+  // The super-agent is the one the owner actually talks to, so it is where
+  // per-channel matters most: telegram, whatsapp, web and desktop are four
+  // conversations, not one row wearing whichever channel spoke last.
+  if (perChannel) {
+    const heads = latestPerChannel(eligible);
+    if (!heads.length) return [superAgentRow(null, threads)];
+    return heads.map((t) => superAgentRow(t, threads));
+  }
+  return [superAgentRow(eligible[0] || null, threads)];
+}
+
+/** One super-agent row for one headline thread (or none yet). */
+function superAgentRow(latest, threads) {
+  // `messages` counts every thread on purpose: it is the super-agent's total
+  // volume, not this row's. The headline is picked by the caller — a routine
+  // run is never one, and the row stays pinned even with no thread yet (it
+  // falls through to a live session).
   const messages = threads.reduce((n, t) => n + (t.messages || 0), 0);
-  const latest = threads[0] || null; // listGlobalThreads sorts by last_ts desc
 
   let preview = null;
+  // When that reply was written. The thread's own `last_ts` moves for the
+  // owner's send too, so it cannot answer "did the agent say something new" —
+  // which is the only question a notification should be asking.
+  let previewAt = null;
   if (latest) {
     try {
       const thread = readGlobalThread({ channel: latest.channel, date: latest.id });
       const lastReply = [...(thread?.messages || [])]
         .reverse()
         .find((m) => m.role === "assistant");
-      preview = (lastReply?.content || "")
+      // A reply that was a FILE gets its file described, not the marker text
+      // that stands in for it on disk ("[photo]", "[image attached — saved to
+      // /Users/…]") — which is what the list used to print.
+      preview = previewText(lastReply?.content, lastReply?.media)
         .replace(/```[\s\S]*?```/g, " ")
         .replace(/\s+/g, " ")
         .trim()
         .slice(0, 160) || null;
+      previewAt = lastReply?.ts || null;
     } catch {
       preview = null;
+      previewAt = null;
     }
   }
 
@@ -142,12 +226,14 @@ function buildSuperAgentRow() {
     agent_slug: SUPERAGENT_ACTOR_ID,
     agent_name: null, // resolved by the surface via resolveAgentName()
     agent_emoji: null,
+    agent_icon: resolveSuperAgentBlob(readConfig()),
     kind: "super_agent",
     pinned: true,
     conversation_id: latest?.id || null,
     channel: latest?.channel || null,
     messages,
     preview,
+    preview_at: previewAt,
     last_activity_at: latest?.last_ts || "",
   };
 }

package/src/core/stores/code-sessions.js

@@ -61,6 +61,27 @@ export function listCodeSessions(storagePath) {
   return rows;
 }
 
+/**
+ * Every project's sessions in one list, newest-updated first.
+ *
+ * `projects` is plain data — `[{ id, name, storagePath }]` — so core stays free
+ * of the daemon's ProjectManager. Each row carries the `pid` and `projectName`
+ * it came from, because a session id alone is not addressable: every read after
+ * this one needs the project to resolve a storage path. Without that pairing an
+ * "all projects" list is a list of things you cannot open.
+ */
+export function listCodeSessionsAcross(projects = []) {
+  const rows = [];
+  for (const p of projects) {
+    if (!p?.storagePath) continue;
+    for (const row of listCodeSessions(p.storagePath)) {
+      rows.push({ ...row, pid: String(p.id), projectName: p.name || null });
+    }
+  }
+  rows.sort((a, b) => (b.updatedAt || "").localeCompare(a.updatedAt || ""));
+  return rows;
+}
+
 /** Full session (with messages) or null. */
 export function getCodeSession(storagePath, id) {
   if (!id || typeof id !== "string") return null;

package/src/core/stores/commitments.js

@@ -23,15 +23,19 @@
 //   renegotiate   — a NEW date, agreed with them. Distinct from missing:
 //                   moving a date with someone is not the same as letting it
 //                   slide, and the history keeps both.
+//   drop          — filed by mistake. NOT the same as `missed`: nobody was
+//                   ever waiting, so counting it as a broken promise would
+//                   poison the only number that matters here. The events stay
+//                   on disk; the row leaves the lists.
 //
-// State: "open" → "kept" | "missed" | "renegotiated" → (renegotiated reopens
-// as "open" with a new due, keeping the previous date in `history`).
+// State: "open" → "kept" | "missed" | "dropped" → (renegotiate reopens as
+// "open" with a new due, keeping the previous date in `history`).
 import fs from "node:fs";
 import path from "node:path";
 import { nowIso } from "../util/time.js";
 import { shortId as makeShortId } from "../util/ids.js";
 
-export const COMMITMENT_STATES = Object.freeze(["open", "kept", "missed", "renegotiated"]);
+export const COMMITMENT_STATES = Object.freeze(["open", "kept", "missed", "dropped"]);
 
 function commitmentsDir(storagePath) {
   return path.join(storagePath, "commitments");
@@ -125,6 +129,14 @@ function projectState(events) {
         existing.updated_at = ev.ts;
         break;
       }
+      case "drop": {
+        if (!existing) break;
+        existing.state = "dropped";
+        existing.closed_at = ev.ts;
+        existing.note = ev.note || existing.note || null;
+        existing.updated_at = ev.ts;
+        break;
+      }
       case "renegotiate": {
         if (!existing) break;
         existing.history.push({
@@ -296,6 +308,17 @@ export function missCommitment(storagePath, idOrPrefix, note = null) {
   return close(storagePath, idOrPrefix, "missed", note);
 }
 
+/**
+ * Filed by mistake — take it off the board without calling it broken.
+ *
+ * Deliberately not `missed`: "you failed Ana" and "this was never a promise"
+ * are different facts, and the second one must not show up in the first one's
+ * count. The log keeps every event either way.
+ */
+export function dropCommitment(storagePath, idOrPrefix, note = null) {
+  return close(storagePath, idOrPrefix, "drop", note);
+}
+
 function close(storagePath, idOrPrefix, op, note) {
   const existing = getCommitment(storagePath, idOrPrefix);
   if (!existing) return null;
@@ -325,6 +348,7 @@ export function countCommitments(storagePath, now = nowIso()) {
     open: open.length,
     kept: rows.filter((c) => c.state === "kept").length,
     missed: rows.filter((c) => c.state === "missed").length,
+    dropped: rows.filter((c) => c.state === "dropped").length,
     overdue: open.filter((c) => c.due && c.due < now).length,
     total: rows.length,
   };