codiedev 0.9.31 → 0.9.32

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codiedev",
-  "version": "0.9.31",
+  "version": "0.9.32",
   "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",