ax-agents 0.1.9 → 0.1.11

package/ax.js

@@ -308,7 +308,7 @@ ${progress || "(No progress yet)"}
 ## Your Task
 ${userPrompt}
 
-Remember: Work on ONE thing, update ${relProgressPath}, run tests, commit.
+Remember: Work on ONE thing, update ${relProgressPath}, then verify it works.
 When ALL tasks are complete, output <promise>COMPLETE</promise>`;
 }
 
@@ -639,7 +639,7 @@ const RFP_PREAMBLE = `## Guidelines
 // Note: DO_PREAMBLE is a template - {progressPath} gets replaced at runtime
 const DO_PREAMBLE = `You are an autonomous coding agent in a loop. Each iteration:
 
-1. Read {progressPath} to see what's done.
+1. Read {progressPath} to see what's done (empty means nothing done yet).
 2. Choose the next task:
   - Start with trivial/mechanistic work. It banks progress, builds context, and constrains nothing.
   - Then do foundational work that makes harder problems easier and safer to approach.
@@ -1075,6 +1075,44 @@ function findClaudeLogPath(sessionId, sessionName) {
     return directPath;
   }
 
+  // Fallback: most recently modified session from index (handles /new creating new sessions)
+  if (existsSync(indexPath)) {
+    try {
+      const index = JSON.parse(readFileSync(indexPath, "utf-8"));
+      if (index.entries?.length) {
+        const sorted = [...index.entries].sort((a, b) => {
+          const aTime = a.modified ? new Date(a.modified).getTime() : 0;
+          const bTime = b.modified ? new Date(b.modified).getTime() : 0;
+          return bTime - aTime;
+        });
+        const newest = sorted[0];
+        if (newest?.fullPath && existsSync(newest.fullPath)) {
+          debug("log", `findClaudeLogPath: fallback to most recent via index -> ${newest.fullPath}`);
+          return newest.fullPath;
+        }
+      }
+    } catch (err) {
+      debugError("findClaudeLogPath:index-fallback", err);
+    }
+  }
+
+  // Final fallback: most recently modified .jsonl file (for projects without index)
+  try {
+    const files = readdirSync(claudeProjectDir)
+      .filter((f) => f.endsWith(".jsonl"))
+      .map((f) => {
+        const fullPath = path.join(claudeProjectDir, f);
+        return { path: fullPath, mtime: statSync(fullPath).mtimeMs };
+      })
+      .sort((a, b) => b.mtime - a.mtime);
+    if (files.length > 0) {
+      debug("log", `findClaudeLogPath: fallback to most recent file -> ${files[0].path}`);
+      return files[0].path;
+    }
+  } catch (err) {
+    debugError("findClaudeLogPath:file-fallback", err);
+  }
+
   debug("log", `findClaudeLogPath: not found`);
   return null;
 }
@@ -1120,13 +1158,54 @@ function findNewestClaudeSessionUuid(sessionName) {
 }
 
 /**
+ * Find Codex log path by checking which .jsonl file the Codex process has open.
+ * Uses lsof as the source of truth - whatever file the process has open is the current log.
+ * Falls back to timestamp-based matching if lsof fails.
  * @param {string} sessionName
  * @returns {string | null}
  */
 function findCodexLogPath(sessionName) {
   debug("log", `findCodexLogPath: sessionName=${sessionName}`);
-  // For Codex, we need to match by timing since we can't control the session ID
-  // Get tmux session creation time
+
+  // Primary method: find the log file via lsof (what file does Codex have open?)
+  try {
+    // Get tmux pane PID
+    const paneResult = spawnSync(
+      "tmux",
+      ["list-panes", "-t", sessionName, "-F", "#{pane_pid}"],
+      { encoding: "utf-8" }
+    );
+    if (paneResult.status === 0 && paneResult.stdout.trim()) {
+      const panePid = parseInt(paneResult.stdout.trim().split("\n")[0], 10);
+      if (!isNaN(panePid)) {
+        // Find child process named "codex"
+        const pgrepResult = spawnSync("pgrep", ["-P", panePid.toString(), "-x", "codex"], {
+          encoding: "utf-8",
+        });
+        if (pgrepResult.status === 0 && pgrepResult.stdout.trim()) {
+          const codexPid = parseInt(pgrepResult.stdout.trim().split("\n")[0], 10);
+          if (!isNaN(codexPid)) {
+            // Use lsof to find which .jsonl file it has open
+            const lsofResult = spawnSync("lsof", ["-p", codexPid.toString()], {
+              encoding: "utf-8",
+            });
+            if (lsofResult.status === 0) {
+              const match = lsofResult.stdout.match(/(\S+\.jsonl)\s*$/m);
+              if (match) {
+                debug("log", `findCodexLogPath: lsof found ${match[1]}`);
+                return match[1];
+              }
+            }
+          }
+        }
+      }
+    }
+    debug("log", `findCodexLogPath: lsof method failed, falling back to timestamp`);
+  } catch (err) {
+    debug("log", `findCodexLogPath: lsof exception, falling back to timestamp`);
+  }
+
+  // Fallback: timestamp-based matching (for when process isn't running or lsof fails)
   try {
     const result = spawnSync(
       "tmux",
@@ -1428,17 +1507,17 @@ function formatClaudeLogEntry(entry) {
       const input = part.input || part.arguments || {};
       let summary;
       if (name === "Bash" && input.command) {
-        summary = input.command.slice(0, 50);
+        summary = truncate(input.command, 50);
       } else if (
         name === "Task" &&
         (input.description || input.subagent_type)
       ) {
         // Task tool: show description or subagent type
         summary = input.description || input.subagent_type || "";
-        summary = summary.slice(0, 40);
+        summary = truncate(summary, 40);
       } else {
         const target = input.file_path || input.path || input.pattern || "";
-        summary = target.split("/").pop() || target.slice(0, 30);
+        summary = target.split("/").pop() || truncate(target, 30);
       }
       output.push({ type: "tool", content: `> ${name}(${summary})` });
     }
@@ -1476,14 +1555,14 @@ function formatCodexLogEntry(entry) {
     try {
       const args = JSON.parse(entry.payload.arguments || "{}");
       if (name === "shell_command" && args.command) {
-        summary = args.command.slice(0, 50);
+        summary = truncate(args.command, 50);
       } else if (name === "Task" && (args.description || args.subagent_type)) {
         // Task tool: show description or subagent type
         summary = args.description || args.subagent_type || "";
-        summary = summary.slice(0, 40);
+        summary = truncate(summary, 40);
       } else {
         const target = args.file_path || args.path || args.pattern || "";
-        summary = target.split("/").pop() || target.slice(0, 30);
+        summary = target.split("/").pop() || truncate(target, 30);
       }
     } catch {
       summary = "...";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ax-agents",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "description": "A CLI for orchestrating AI coding agents via tmux",
   "bin": {
     "ax": "ax.js",