@trawlme/cli 1.18.6 → 1.18.7

package/dist/commands/scraps.d.ts

@@ -1,10 +1,21 @@
 import { Command } from 'commander';
 export declare const scraps: Command;
 /** The top-of-history snapshot pollRunProgress needs to identify which run
- * it's watching — see captureBeforeRunState. */
+ * it's watching — see captureBeforeRunState.
+ *
+ * #97 — `captured` discriminates WHY `id` is undefined: `true` means the GET
+ * succeeded and the scrap genuinely has no history yet (an honest "never
+ * run" signal pollRunProgress can trust immediately); `false` means the GET
+ * itself threw, so `id`/`alreadyInFlight` carry NO information at all — the
+ * scrap could easily have prior (possibly terminal) history that this
+ * lookup simply never saw. Before this field existed, both cases produced
+ * the identical `{id: undefined, alreadyInFlight: false}` shape, so
+ * pollRunProgress could not tell them apart (see its own #97 comment).
+ */
 interface BeforeRunState {
     id?: string;
     alreadyInFlight: boolean;
+    captured: boolean;
 }
 /**
  * #91 P1 — replaces "await the run to completion, THEN open the activities
@@ -38,6 +49,35 @@ interface BeforeRunState {
  * (the dedup case) — a same-id row that was already TERMINAL at capture is
  * neither, and must not be latched onto as "done" (it's just the previous
  * run, still sitting there until a genuinely new run supersedes it).
+ *
+ * #97 — capture-failed fallback. The dedup-race fix above assumes `before`
+ * is trustworthy. When `captureBeforeRunState`'s own GET threw,
+ * `before.id` is `undefined` — and that is INDISTINGUISHABLE from "the
+ * scrap has genuinely never run" (also `id: undefined`), which is exactly
+ * the case `isNewRun` above is designed to match on the very first row that
+ * ever appears. So on the very first poll, ANY pre-existing history row —
+ * even the STALE PREVIOUS run, already terminal — satisfied
+ * `last._id !== undefined` and got reported as "the run we just launched"
+ * finishing, when it was really just whatever ran before.
+ *
+ * Fix: `before.captured === false` defers trusting a baseline at all.
+ * Instead of comparing against the (unknown) `beforeId` from the start, the
+ * FIRST successful poll read is treated as the deferred capture itself —
+ * exactly what `captureBeforeRunState` would have returned had its GET
+ * succeeded — and only READS from that point on are compared against it,
+ * via the exact same `isNewRun` / `isDedupOntoInFlight` logic above. A
+ * pre-existing terminal row observed on that first read becomes `beforeId`
+ * (not a match for itself), so it correctly falls into "still the stale
+ * previous run" below and the poll keeps waiting; a row still in flight
+ * becomes the `alreadyInFlight` baseline, exactly like a successful capture
+ * would have recorded. Either way this costs at most one extra poll
+ * interval, bounded by the same deadline as everything else. The one
+ * remaining edge case — capture failed AND the scrap never ran before AND
+ * the triggered run already finished by the very first poll — is genuinely
+ * undecidable from "stale pre-existing row" with no more information than
+ * this function has, so it resolves to the same honest timeout rather than
+ * risk reporting a possibly-wrong outcome (never a lie, at worst a timeout
+ * telling the caller to check `doctor`).
  */
 export declare function pollRunProgress(id: string, before: BeforeRunState | undefined, opts?: {
     intervalMs?: number;

package/dist/commands/scraps.js

@@ -96,17 +96,21 @@ async function watchActivities(id) {
  * recognize that dedup case too, instead of waiting forever for an `_id`
  * that will never arrive (#93 item 1).
  *
- * Best-effort: a failed lookup falls back to `{alreadyInFlight:false}`,
- * which is still correct for a scrap that has never run (id undefined).
+ * #97 — a failed lookup used to fall back to `{alreadyInFlight:false}` with
+ * no `id`, which LOOKED identical to "scrap has never run" — but is not:
+ * the scrap may well have prior (possibly terminal) history this GET simply
+ * never observed. `captured:false` flags that distinction explicitly so
+ * pollRunProgress can defer trusting a baseline instead of risking a stale
+ * pre-existing row being reported as the run just launched.
  */
 async function captureBeforeRunState(id) {
     try {
         const scrap = await api.get(`/api/scraps/${id}`);
         const top = scrap.history?.[0];
-        return { id: top?._id, alreadyInFlight: top?.status === null };
+        return { id: top?._id, alreadyInFlight: top?.status === null, captured: true };
     }
     catch {
-        return { id: undefined, alreadyInFlight: false };
+        return { id: undefined, alreadyInFlight: false, captured: false };
     }
 }
 function sleep(ms) {
@@ -148,12 +152,46 @@ const POLL_TIMEOUT_MS = LONG_RUN_TIMEOUT_MS;
  * (the dedup case) — a same-id row that was already TERMINAL at capture is
  * neither, and must not be latched onto as "done" (it's just the previous
  * run, still sitting there until a genuinely new run supersedes it).
+ *
+ * #97 — capture-failed fallback. The dedup-race fix above assumes `before`
+ * is trustworthy. When `captureBeforeRunState`'s own GET threw,
+ * `before.id` is `undefined` — and that is INDISTINGUISHABLE from "the
+ * scrap has genuinely never run" (also `id: undefined`), which is exactly
+ * the case `isNewRun` above is designed to match on the very first row that
+ * ever appears. So on the very first poll, ANY pre-existing history row —
+ * even the STALE PREVIOUS run, already terminal — satisfied
+ * `last._id !== undefined` and got reported as "the run we just launched"
+ * finishing, when it was really just whatever ran before.
+ *
+ * Fix: `before.captured === false` defers trusting a baseline at all.
+ * Instead of comparing against the (unknown) `beforeId` from the start, the
+ * FIRST successful poll read is treated as the deferred capture itself —
+ * exactly what `captureBeforeRunState` would have returned had its GET
+ * succeeded — and only READS from that point on are compared against it,
+ * via the exact same `isNewRun` / `isDedupOntoInFlight` logic above. A
+ * pre-existing terminal row observed on that first read becomes `beforeId`
+ * (not a match for itself), so it correctly falls into "still the stale
+ * previous run" below and the poll keeps waiting; a row still in flight
+ * becomes the `alreadyInFlight` baseline, exactly like a successful capture
+ * would have recorded. Either way this costs at most one extra poll
+ * interval, bounded by the same deadline as everything else. The one
+ * remaining edge case — capture failed AND the scrap never ran before AND
+ * the triggered run already finished by the very first poll — is genuinely
+ * undecidable from "stale pre-existing row" with no more information than
+ * this function has, so it resolves to the same honest timeout rather than
+ * risk reporting a possibly-wrong outcome (never a lie, at worst a timeout
+ * telling the caller to check `doctor`).
  */
 export async function pollRunProgress(id, before, opts = {}) {
     const intervalMs = opts.intervalMs ?? POLL_INTERVAL_MS;
     const timeoutMs = opts.timeoutMs ?? POLL_TIMEOUT_MS;
-    const beforeId = before?.id;
-    const beforeAlreadyInFlight = before?.alreadyInFlight ?? false;
+    let beforeId = before?.id;
+    let beforeAlreadyInFlight = before?.alreadyInFlight ?? false;
+    // #97 — only an EXPLICIT captured:false (capture's GET actually threw)
+    // defers the baseline. `before` itself being undefined (callers that skip
+    // capture entirely) or `captured` being true/absent both mean "trust
+    // beforeId as given", preserving every existing call site's behavior.
+    let baselineEstablished = before?.captured ?? true;
     console.log(chalk.dim('Live activity streaming has no signal for this run (async/cross-pod) — polling for progress instead…\n'));
     const deadline = Date.now() + timeoutMs;
     const seen = new Set();
@@ -172,6 +210,16 @@ export async function pollRunProgress(id, before, opts = {}) {
         const last = scrap.history?.[0];
         if (!last?._id)
             continue; // no history row recorded yet
+        if (!baselineEstablished) {
+            // #97 — deferred capture: whatever we see on this first successful
+            // read becomes the reference point, BEFORE the isNewRun check below
+            // ever runs against it. This must happen before that check, not
+            // after, so a pre-existing terminal row is recognized as stale on
+            // this very same iteration rather than one poll late.
+            beforeId = last._id;
+            beforeAlreadyInFlight = last.status === null;
+            baselineEstablished = true;
+        }
         const isNewRun = last._id !== beforeId;
         const isDedupOntoInFlight = last._id === beforeId && beforeAlreadyInFlight;
         if (!isNewRun && !isDedupOntoInFlight)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trawlme/cli",
-  "version": "1.18.6",
+  "version": "1.18.7",
   "description": "Trawl CLI — manage scraps from the terminal",
   "type": "module",
   "bin": {