codiedev 0.9.31 → 0.9.33

package/assets/git-refs.mjs

@@ -7,8 +7,6 @@ import { execFileSync } from "node:child_process";
 import { existsSync } from "node:fs";
 import { dirname, isAbsolute } from "node:path";
 
-const skillUseBySession = new Map();
-
 /**
  * The directory the agent last WROTE to. Reading refs from the plugin's cwd is
  * only right when `codie` was launched where the work lands. A dev who launches
@@ -27,15 +25,61 @@ const skillUseBySession = new Map();
  * catch it.
  */
 export const workDirBySession = new Map();
-const WRITE_TOOLS = new Set(["write", "edit", "patch"]);
+/**
+ * Tool ids as OpenCode actually registers them, captured from a live run — not
+ * read off the binary, which is what got this wrong twice. The patch tool is
+ * `apply_patch`; `patch` is kept only as a defensive alias.
+ */
+const WRITE_TOOLS = new Set(["write", "edit", "apply_patch", "patch"]);
+
+/**
+ * Which directory a tool call says the agent is working in, or null.
+ *
+ * Covering only `write`/`edit` was not enough. Two live `codie run` sessions
+ * were driven to create a file and the agent picked `bash` once and `patch`
+ * once — neither carries a `filePath` in its args, so both sessions reported
+ * the launch branch:
+ *
+ *   write / edit   args.filePath                     — known before the write
+ *   apply_patch    result.metadata.files[].filePath  — only known AFTER it runs
+ *
+ * `bash` is deliberately NOT handled. Honouring its `workdir` re-anchors on
+ * READS too — `bash {command:"git log", workdir:"/repo"}` would move the
+ * anchor off a tracked worktree and back to the primary checkout, which
+ * passes the trust check because both share an origin. That breaks the rule
+ * this module is built on: writes are the signal, reads are not. Mining the
+ * command text was tried instead and did not work live. See NEXT_RELEASE.md.
+ *
+ * `patch` takes `patchText`, so its args never name a file. Shape confirmed
+ * against the opencode binary:
+ *   metadata:{files:[{type:"update",filePath:…,relativePath:…,diff:…}]}
+ *
+ */
+function workDirFromTool(tool, args, result) {
+  if (!WRITE_TOOLS.has(tool)) return null;
+  const candidates = [
+    args?.filePath,
+    args?.file_path,
+    ...(Array.isArray(result?.metadata?.files) ? result.metadata.files : []).flatMap((file) => [
+      file?.movePath, // a move reports the destination, which is where the work is
+      file?.filePath,
+    ]),
+  ];
+  // relativePath is deliberately excluded — it resolves against a cwd we may
+  // not share, so it is not a usable anchor.
+  const hit = candidates.find((path) => typeof path === "string" && isAbsolute(path));
+  return hit ? dirname(hit) : null;
+}
 
-export function trackWorkPath(tool, args, sessionID, state = workDirBySession) {
-  if (!WRITE_TOOLS.has(tool)) return;
-  const filePath = args?.filePath ?? args?.file_path;
-  // Relative paths are resolved against a cwd we may not share, so they are
-  // not usable anchors.
-  if (typeof filePath !== "string" || !isAbsolute(filePath)) return;
-  state.set(sessionID, dirname(filePath));
+export function trackWorkPath({
+  tool,
+  args,
+  sessionID,
+  result = null,
+  state = workDirBySession,
+}) {
+  const dir = workDirFromTool(tool, args, result);
+  if (dir) state.set(sessionID, dir);
 }
 
 /**
@@ -93,7 +137,7 @@ function normalizeRemote(url) {
 const GIT_TTL_MS = 5_000;
 const gitCache = {};
 
-function clean(value, max) {
+export function clean(value, max) {
   const text = typeof value === "string" ? value.trim() : "";
   return text ? text.slice(0, max) : "";
 }

package/assets/opencode-plugin.mjs

@@ -4,6 +4,7 @@
 // names to inference requests handled by the company gateway.
 
 import {
+  clean,
   buildAttributionHeaders,
   resolveGitRefs,
   trackWorkPath,
@@ -34,10 +35,30 @@ export const CodiedevMetadata = async () => ({
     // Follow where the agent writes so refs come from the tree that becomes
     // the PR. Only the path's DIRECTORY is kept, and only to run git in it —
     // no path ever leaves this process.
-    trackWorkPath(input.tool, output.args, input.sessionID);
+    //
+    // `write`/`edit` name the file up front; `bash` may carry a workdir. Both
+    // are worth catching here so the very next request already reports the
+    // right branch.
+    trackWorkPath({
+      tool: input.tool,
+      args: output.args,
+      sessionID: input.sessionID,
+    });
     if (input.tool !== "skill") return;
     addSkill(input.sessionID, output.args?.name || output.args?.skill || output.args?.key);
   },
+  "tool.execute.after": async (input, output) => {
+    // `patch` takes patchText, so the files it touched are only known once it
+    // has run — they arrive in the result's metadata.files[]. Without this
+    // hook a patch-driven session never moves off the launch branch, which is
+    // exactly what two live runs showed.
+    trackWorkPath({
+      tool: input.tool,
+      args: input.args,
+      sessionID: input.sessionID,
+      result: output,
+    });
+  },
   "chat.headers": async (input, output) => {
     Object.assign(
       output.headers,

package/dist/cli.js

@@ -228,9 +228,13 @@ codiedev inbox — show messages from teammates
   Usage:
     codiedev inbox [--unread] [--limit N]
 
-  Lists pings with sender, subject artifact, and preview. Each row
+  Lists pings with sender, subject artifact, and preview. Each ping row
   shows a ping-id you can pass to 'codiedev read'.
 
+  Also lists feed posts and comments where a teammate @-mentioned you.
+  Those rows end in a portal link — the thread lives in the feed, so
+  read and reply to it there.
+
   Unread rows show as ● ; read rows as · .
 
   Examples:

package/dist/commands/inbox.d.ts

@@ -1,2 +1,3 @@
-export declare function runInbox(args: string[]): Promise<void>;
+import type { CodiedevConfig } from "../utils";
+export declare function runInbox(args: string[], configOverride?: CodiedevConfig): Promise<void>;
 export declare function runRead(args: string[]): Promise<void>;

package/dist/commands/inbox.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.runInbox = runInbox;
 exports.runRead = runRead;
 const shared_1 = require("./shared");
+const inboxFormat_1 = require("../inboxFormat");
 function parseInboxArgs(args) {
     let unreadOnly = false;
     let limit;
@@ -23,9 +24,9 @@ function parseInboxArgs(args) {
     }
     return { unreadOnly, limit };
 }
-async function runInbox(args) {
+async function runInbox(args, configOverride) {
     const { unreadOnly, limit } = parseInboxArgs(args);
-    const config = (0, shared_1.requireConfig)();
+    const config = configOverride ?? (0, shared_1.requireConfig)();
     const start = Date.now();
     try {
         const res = await (0, shared_1.apiRequest)("GET", "/api/cli/inbox", {
@@ -40,26 +41,14 @@ async function runInbox(args) {
             ok: true,
             latencyMs: Date.now() - start,
         });
-        const pings = res.pings;
-        const unreadCount = pings.filter((p) => !p.readAt).length;
-        if (pings.length === 0) {
-            console.log(unreadOnly ? "No unread messages." : "Inbox is empty.");
-            return;
-        }
-        console.log(`Inbox · ${pings.length} ${unreadOnly ? "unread" : "recent"}${unreadOnly ? "" : ` · ${unreadCount} unread`}`);
-        console.log();
-        for (const p of pings) {
-            const dot = p.readAt ? "·" : "●";
-            const from = p.from?.name ?? "unknown";
-            const when = (0, shared_1.timeAgo)(p.createdAt);
-            const where = p.subjectKey ? ` · on ${p.subjectKey}` : "";
-            const preview = p.preview || "(no body)";
-            console.log(`${dot}  ${from}${where} · ${when}`);
-            console.log(`    ${preview}`);
-            console.log(`    id: ${p.pingId}`);
-            console.log();
+        for (const line of (0, inboxFormat_1.formatInbox)({
+            pings: res.pings,
+            mentions: res.mentions,
+            unreadOnly,
+            limit,
+        })) {
+            console.log(line);
         }
-        console.log(`Mark read: codiedev read <ping-id>`);
     }
     catch (err) {
         (0, shared_1.recordAgentEvent)(config, {

package/dist/inboxFormat.d.ts

@@ -0,0 +1,38 @@
+export interface InboxPing {
+    pingId: string;
+    createdAt: number;
+    readAt?: number;
+    from: {
+        name: string;
+        email: string;
+    } | null;
+    subjectKey: string | null;
+    subject: {
+        title?: string;
+    } | null;
+    preview: string;
+}
+export interface InboxMention {
+    mentionId: string;
+    createdAt: number;
+    readAt?: number | null;
+    from: {
+        name: string;
+        email: string;
+    } | null;
+    postTitle: string | null;
+    preview: string | null;
+    url: string | null;
+}
+/**
+ * Render the inbox for BOTH surfaces — `codiedev inbox` and the MCP
+ * `codiedev_inbox` tool an agent calls for "any messages?". Shared so the
+ * agent path can never drift back to pings-only while the human path shows
+ * mentions.
+ */
+export declare function formatInbox(opts: {
+    pings: InboxPing[];
+    mentions?: InboxMention[];
+    unreadOnly: boolean;
+    limit?: number;
+}): string[];

package/dist/inboxFormat.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatInbox = formatInbox;
+const shared_1 = require("./commands/shared");
+/**
+ * Render the inbox for BOTH surfaces — `codiedev inbox` and the MCP
+ * `codiedev_inbox` tool an agent calls for "any messages?". Shared so the
+ * agent path can never drift back to pings-only while the human path shows
+ * mentions.
+ */
+function formatInbox(opts) {
+    const mentions = opts.mentions ?? [];
+    // The backend applies `limit` to each source independently, so asking for N
+    // can return up to 2N — and with no `--limit` it defaults to 50 per source,
+    // i.e. 100 rows, twice the pre-change maximum. Cap the COMBINED list by
+    // recency, always (matching the backend's own default), so the header is
+    // truthful and `--limit` actually holds.
+    //
+    // Selected by identity rather than by a `createdAt >= cutoff` filter: rows
+    // tied on the cutoff millisecond are reachable (Convex freezes Date.now()
+    // per transaction, and seeded activity carries synthetic stamps) and a
+    // threshold filter lets every tied row through, overshooting the limit.
+    const DEFAULT_LIMIT = 50;
+    const cap = opts.limit ?? DEFAULT_LIMIT;
+    // Pings claim the budget first, then mentions fill whatever is left — both
+    // newest-first. Before this change pings owned the whole budget, so this is
+    // purely additive and can never hide a ping that used to be visible. A flat
+    // recency cap would instead let a busy feed evict every direct ping, and
+    // pings are the actionable half: they carry the id you reply to, and losing
+    // them all takes the mark-read footer with them.
+    const byRecency = (xs) => [...xs].sort((a, b) => b.createdAt - a.createdAt);
+    const keptPings = byRecency(opts.pings).slice(0, cap);
+    const keptMentions = byRecency(mentions).slice(0, Math.max(0, cap - keptPings.length));
+    const total = keptPings.length + keptMentions.length;
+    if (total === 0) {
+        return [opts.unreadOnly ? "No unread messages." : "Inbox is empty."];
+    }
+    const unreadCount = keptPings.filter((p) => !p.readAt).length +
+        keptMentions.filter((m) => !m.readAt).length;
+    const lines = [
+        `Inbox · ${total} ${opts.unreadOnly ? "unread" : "recent"}${opts.unreadOnly ? "" : ` · ${unreadCount} unread`}`,
+        "",
+    ];
+    for (const p of keptPings) {
+        const dot = p.readAt ? "·" : "●";
+        const from = p.from?.name ?? "unknown";
+        const where = p.subjectKey ? ` · on ${p.subjectKey}` : "";
+        lines.push(`${dot}  ${from}${where} · ${(0, shared_1.timeAgo)(p.createdAt)}`);
+        lines.push(`    ${p.preview || "(no body)"}`);
+        lines.push(`    id: ${p.pingId}`);
+        lines.push("");
+    }
+    // Mentions carry no CLI-side body to reply to — the thread lives in the feed
+    // — so each row ends in the deep link rather than an id.
+    for (const m of keptMentions) {
+        const dot = m.readAt ? "·" : "●";
+        const from = m.from?.name ?? "someone";
+        const where = m.postTitle ? ` · on “${m.postTitle}”` : "";
+        lines.push(`${dot}  ${from} mentioned you${where} · ${(0, shared_1.timeAgo)(m.createdAt)}`);
+        if (m.preview)
+            lines.push(`    ${m.preview}`);
+        if (m.url)
+            lines.push(`    ${m.url}`);
+        lines.push("");
+    }
+    if (keptPings.length > 0)
+        lines.push("Mark read: codiedev read <ping-id>");
+    return lines;
+}

package/dist/mcp.js

@@ -51,6 +51,7 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const utils_1 = require("./utils");
 const shared_1 = require("./commands/shared");
+const inboxFormat_1 = require("./inboxFormat");
 const PKG_NAME = "codiedev";
 // Read version from the bundled package.json so the startup log + tool reports
 // always reflect the actually-installed version, rather than a stale constant.
@@ -748,33 +749,16 @@ async function handleInbox(args, config) {
         config,
         query: { unreadOnly: unreadOnly ? "1" : undefined, limit },
     });
-    if (res.pings.length === 0) {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: unreadOnly ? "No unread messages." : "Inbox is empty.",
-                },
-            ],
-        };
-    }
-    const unreadCount = res.pings.filter((p) => !p.readAt).length;
-    const lines = [
-        `Inbox · ${res.pings.length} ${unreadOnly ? "unread" : "recent"}${unreadOnly ? "" : ` · ${unreadCount} unread`}`,
-        "",
-    ];
-    for (const p of res.pings) {
-        const status = p.readAt ? "·" : "●";
-        const from = p.from?.name ?? "unknown";
-        const where = p.subjectKey ? ` · on ${p.subjectKey}` : "";
-        lines.push(`${status} ${from}${where} · ${(0, shared_1.timeAgo)(p.createdAt)}`);
-        lines.push(`    ${p.preview || "(no body)"}`);
-        lines.push(`    id: ${p.pingId}`);
-        lines.push("");
-    }
-    return {
-        content: [{ type: "text", text: lines.join("\n") }],
-    };
+    // Shared with `codiedev inbox` so this agent-facing path can never drift
+    // back to pings-only. CLAUDE.md routes "any messages?" here, so a
+    // mentions-blind version reproduces the bug for agents.
+    const text = (0, inboxFormat_1.formatInbox)({
+        pings: res.pings,
+        mentions: res.mentions,
+        unreadOnly,
+        limit,
+    }).join("\n");
+    return { content: [{ type: "text", text }] };
 }
 async function handleNote(args, config) {
     const body = asString(args.body);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codiedev",
-  "version": "0.9.31",
+  "version": "0.9.33",
   "description": "Connect Claude Code, Codex, Cursor, OpenCode, or VS Code Copilot to Codiedev for team session capture and artifact collaboration — and run the governed Codie harness",
   "bin": {
     "codiedev": "dist/cli.js",