@proagentstore/cli 0.4.42 → 0.4.44

package/dist/browser-runner/coding/engine-acts.js

@@ -94,6 +94,70 @@ function prRef(segment) {
     const num = segment.match(/\bgh\s+pr\s+(?:merge|create)\b(?:\s+-{1,2}\S+(?:=\S+)?)*\s+(\d+)\b/);
     return num ? `#${num[1]}` : null;
 }
+/** A pull request URL anywhere in a command's own output. Anchored on a literal `http` prefix. */
+const PR_URL = /https?:\/\/\S*?\/pull\/(\d+)/;
+/**
+ * Flatten a `tool_result` block's content to text — the RAW result, not the display line.
+ *
+ * `headless.ts`'s `toolResult()` collapses whitespace and truncates to 240 characters for the
+ * transcript, which is right for a human-readable pane and wrong here: `gh pr create` prints its
+ * URL after whatever else the compound command wrote, so the one token that matters is exactly what
+ * a 240-character cap would drop.
+ */
+export function resultText(content) {
+    if (typeof content === "string")
+        return content;
+    if (Array.isArray(content)) {
+        return content
+            .map((b) => (b && typeof b === "object" && "text" in b ? String(b.text ?? "") : ""))
+            .join("\n");
+    }
+    return "";
+}
+/** An act that names a pull request but does not yet say WHICH one. */
+function wantsPrNumber(act) {
+    return (act.kind === "pr.open" || act.kind === "pr.merge") && act.target === null;
+}
+/**
+ * Fill in the PR number from the command's OWN output, for the acts that lack one (#417).
+ *
+ * `gh pr create --fill` is the common form and carries no number on the command line, so
+ * {@link prRef} returns null and `pull-attribution.ts` leaves the row unbadged. That file states the
+ * rule — **ATTRIBUTION IS EXACT OR ABSENT** — and rejects the tempting repair of pairing an
+ * unnumbered `pr.open` with whichever PR appeared around the same time, because a badge that is
+ * right most of the time is worse than no badge.
+ *
+ * This is not that repair. `gh pr create` prints the new PR's URL on stdout, and that output comes
+ * back as the `tool_result` for the SAME `tool_use_id` as the command that was classified. It is the
+ * command's own answer, in the same class of fact as the `ok` flag already taken from that block —
+ * not a temporal guess about what appeared nearby. When the output names no PR the target stays
+ * null, so absent stays absent.
+ *
+ * Deliberately narrow, because the one failure this module exists to avoid is a confident wrong
+ * number: only `pr.open`/`pr.merge` are eligible, only when their target is still null, and only
+ * against the result correlated to them by `tool_use_id`. A PR URL quoted incidentally in some other
+ * command's output reaches no act.
+ *
+ * **The "already exists" case is decided, not overlooked.** `gh pr create` on a branch that already
+ * has a PR fails with "a pull request for branch X already exists:" and that PR's URL, and this
+ * attributes the act to it. That is a judgement: it IS the pull request for this branch and the
+ * agent did just act on it, and dropping a real signal to avoid a case where the answer is still
+ * true costs more than it saves. The act still carries `ok: false`, so the record remains honest
+ * that the command failed.
+ *
+ * Only reachable from the structured stream-json path. A Codex/Grok raw spawn has no
+ * `tool_use`/`tool_result` framing at all, so its PRs stay unattributed — regexing its transcript
+ * instead would reintroduce exactly the temporal guess this design refuses.
+ */
+export function fillTargetFromResult(acts, content) {
+    if (!acts.some(wantsPrNumber))
+        return acts;
+    const m = resultText(content).match(PR_URL);
+    if (!m)
+        return acts;
+    const target = `#${m[1]}`;
+    return acts.map((a) => (wantsPrNumber(a) ? { ...a, target } : a));
+}
 function pushTarget(segment) {
     // `git push [flags] <remote> <refspec>` — take the first two non-flag words after `push`.
     const after = segment.split(/\bgit\s+push\b/)[1] ?? "";

package/dist/browser-runner/coding/headless.js

@@ -1,5 +1,5 @@
 import { spawn } from "node:child_process";
-import { classifyCommand, commandFromToolInput } from "./engine-acts.js";
+import { classifyCommand, commandFromToolInput, fillTargetFromResult } from "./engine-acts.js";
 import { parseEngineUsage } from "./engine-usage.js";
 /**
  * Merge the platform's resolved engine env over the machine's, where an EMPTY value means
@@ -154,10 +154,26 @@ export class HeadlessSession {
     get authResolved() {
         return resolveEngineAuth(this.config.clientType, mergeEnv(process.env, this.config.env));
     }
+    /**
+     * Did this engine launch with a conversation to continue (#408)?
+     *
+     * Reported back to the cloud by `/coding/start` so the sentence the agent says to the user is
+     * something this side CONFIRMED rather than something the cloud asked for. The distinction is
+     * not academic: a runner published before #408 ignores `resumeFrom` entirely and always starts
+     * clean, so a cloud that announced "resumed where we left off" on its own intent would be
+     * telling most of the fleet's users the opposite of what happened.
+     *
+     * False for a raw (non-Claude) engine under every circumstance — `--resume` is a Claude Code
+     * flag and {@link buildClaudeArgs} is only reached in stream-json mode.
+     */
+    get resumedConversation() {
+        return this.mode === "stream-json" && this.claudeSessionId !== null;
+    }
     constructor(config) {
         this.config = config;
         this.engineLabel = `${config.clientType}:${config.id}`;
-        this.claudeSessionId = readState(config.statePath, config.id);
+        // Our own key first, the cloud's nominated predecessor second. See `resumeFrom`.
+        this.claudeSessionId = readState(config.statePath, config.id) ?? (config.resumeFrom ? readState(config.statePath, config.resumeFrom) : null);
         // Claude is the structured engine; everything else is a raw CLI.
         this.mode = config.clientType === "claude" ? "stream-json" : "raw";
         const { bin, args } = parseCommand(config.command);
@@ -604,7 +620,19 @@ export class HeadlessSession {
             return;
         this.awaitingResult.set(toolUseId, acts);
     }
-    /** The matching `tool_result` arrived — stamp the outcome and publish. */
+    /**
+     * The matching `tool_result` arrived — stamp the outcome and publish.
+     *
+     * The result carries more than the outcome: `gh pr create --fill` states its PR number nowhere
+     * but its own stdout, so an unnumbered `pr.open`/`pr.merge` takes it from here (#417). It is read
+     * from the RAW `block.content`, never from `toolResult()`'s display line — that truncates to 240
+     * characters for the transcript and would cut the URL off a verbose result.
+     *
+     * This path (and `noteAct`) is reachable ONLY from the structured stream-json handling above
+     * (`assistant` → `tool_use`, `user` → `tool_result`). A Codex/Grok session is a raw spawn with no
+     * such framing, so its PRs stay unattributed by construction; scraping its transcript instead
+     * would be the temporal guess `pull-attribution.ts` refuses.
+     */
     settleAct(block) {
         const id = typeof block.tool_use_id === "string" ? block.tool_use_id : "";
         const acts = this.awaitingResult.get(id);
@@ -612,7 +640,7 @@ export class HeadlessSession {
             return;
         this.awaitingResult.delete(id);
         const ok = block.is_error !== true;
-        for (const a of acts)
+        for (const a of fillTargetFromResult(acts, block.content))
             this.publishAct({ ...a, ok });
     }
     /** Publish everything still waiting, with an unknown outcome. */

package/dist/browser-runner/coding/runtime.js

@@ -89,12 +89,17 @@ export class CodingRuntime {
                 command: input.command,
                 env: input.env,
                 statePath: defaultStatePath(this.reposBaseDir),
+                resumeFrom: input.resumeFrom,
                 bin: input.bin,
             });
             this.sessions.set(input.sessionId, session);
         }
+        // Read BEFORE `start()`: a bad `--resume` can kill the process on spawn, and the engine
+        // clears its own key on that exit. Reporting after would say "started clean" about a launch
+        // that did carry a conversation, and the transcript (which shows the crash) would disagree.
+        const resumed = session.resumedConversation;
         session.start();
-        return this.snapshot(input.sessionId);
+        return { ...this.snapshot(input.sessionId), resumed };
     }
     /**
      * The pane the brain reasons over + the inferred run state.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@proagentstore/cli",
-  "version": "0.4.42",
+  "version": "0.4.44",
   "description": "CLI for creating, publishing, and running ProAgentStore agents",
   "license": "MIT",
   "type": "module",