@trawlme/cli 1.18.4 → 1.18.5

package/dist/commands/scraps.d.ts

@@ -1,5 +1,11 @@
 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. */
+interface BeforeRunState {
+    id?: string;
+    alreadyInFlight: boolean;
+}
 /**
  * #91 P1 — replaces "await the run to completion, THEN open the activities
  * SSE stream" (which showed NOTHING: the activities SSE
@@ -20,8 +26,21 @@ export declare const scraps: Command;
  *  - GET /api/scraps/:id — history[0].status/statusDetail, the SAME
  *    terminal-status signal `lastStatus()` above already trusts (status:null
  *    === in flight, #88 item 1) to know when the run is done.
+ *
+ * #93 item 1 — dedup-race fix. "Is this the run we're watching?" used to be
+ * a single check: `history[0]._id !== beforeHistoryId`. That's wrong when
+ * `before.alreadyInFlight` is true (a `trigger` call deduped onto a worker
+ * job that was ALREADY pending/running at capture time): the top row IS the
+ * run we're watching, but its `_id` never changes, so the old guard never
+ * released and the poll ran the full timeout to a false "Timed out". The run
+ * we're watching is now EITHER a brand-new id (fresh trigger, the common
+ * case) OR the same id that was already in-flight (status:null) at capture
+ * (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).
  */
-export declare function pollRunProgress(id: string, beforeHistoryId: string | undefined, opts?: {
+export declare function pollRunProgress(id: string, before: BeforeRunState | undefined, opts?: {
     intervalMs?: number;
     timeoutMs?: number;
 }): Promise<void>;
+export {};

package/dist/commands/scraps.js

@@ -83,21 +83,30 @@ async function watchActivities(id) {
     }
 }
 /**
- * #91 P1 — snapshot the current top history entry BEFORE triggering a run,
- * so pollRunProgress can later detect the NEW run once the server pushes it
- * (node persists a fresh {status:null, inFlight:true} row the moment a run
- * starts — see HistorysService.create in trawl_node — so a changed
- * history[0]._id is an honest "the new run has begun" signal). Best-effort:
- * a failed lookup just means the poll treats the very first history row it
- * sees as new, which is still correct for a scrap that has never run.
+ * #91 P1 / #93 item 1 — snapshot the current top history entry BEFORE
+ * triggering a run, so pollRunProgress can later tell "the run we just
+ * launched" apart from whatever the last run happened to be. Node persists a
+ * fresh {status:null, inFlight:true} row the moment a run starts (see
+ * HistorysService.create in trawl_node), so a changed history[0]._id is
+ * normally an honest "the new run has begun" signal — EXCEPT `trigger`
+ * (method:'worker') dedups onto an already-pending/running worker job
+ * (ScrapJobsService, LIVE_STATUSES) instead of creating a new row: the top
+ * row's `_id` never changes even though this launch IS that run. Recording
+ * `alreadyInFlight` (status===null at capture time) lets pollRunProgress
+ * 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).
  */
-async function captureBeforeHistoryId(id) {
+async function captureBeforeRunState(id) {
     try {
         const scrap = await api.get(`/api/scraps/${id}`);
-        return scrap.history?.[0]?._id;
+        const top = scrap.history?.[0];
+        return { id: top?._id, alreadyInFlight: top?.status === null };
     }
     catch {
-        return undefined;
+        return { id: undefined, alreadyInFlight: false };
     }
 }
 function sleep(ms) {
@@ -127,10 +136,24 @@ const POLL_TIMEOUT_MS = LONG_RUN_TIMEOUT_MS;
  *  - GET /api/scraps/:id — history[0].status/statusDetail, the SAME
  *    terminal-status signal `lastStatus()` above already trusts (status:null
  *    === in flight, #88 item 1) to know when the run is done.
+ *
+ * #93 item 1 — dedup-race fix. "Is this the run we're watching?" used to be
+ * a single check: `history[0]._id !== beforeHistoryId`. That's wrong when
+ * `before.alreadyInFlight` is true (a `trigger` call deduped onto a worker
+ * job that was ALREADY pending/running at capture time): the top row IS the
+ * run we're watching, but its `_id` never changes, so the old guard never
+ * released and the poll ran the full timeout to a false "Timed out". The run
+ * we're watching is now EITHER a brand-new id (fresh trigger, the common
+ * case) OR the same id that was already in-flight (status:null) at capture
+ * (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).
  */
-export async function pollRunProgress(id, beforeHistoryId, opts = {}) {
+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;
     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();
@@ -147,8 +170,12 @@ export async function pollRunProgress(id, beforeHistoryId, opts = {}) {
             continue; // transient — keep polling rather than aborting the wait
         }
         const last = scrap.history?.[0];
-        if (!last?._id || last._id === beforeHistoryId)
-            continue; // new run not recorded yet
+        if (!last?._id)
+            continue; // no history row recorded yet
+        const isNewRun = last._id !== beforeId;
+        const isDedupOntoInFlight = last._id === beforeId && beforeAlreadyInFlight;
+        if (!isNewRun && !isDedupOntoInFlight)
+            continue; // still the stale previous run
         try {
             const activities = await api.get(`/api/scraps/${id}/activities?history=${last._id}&limit=20`);
             // Server returns newest-first — print unseen ones oldest-first.
@@ -534,9 +561,10 @@ scraps
     .option('-w, --watch', 'Show progress after launching (polls — see `trawl scraps trigger --watch`, #91)')
     .action(async (id, opts) => {
     validateObjectId(id);
-    // #91 P1 — captured BEFORE launching so pollRunProgress can tell "the run
-    // that's about to finish" apart from whatever the last run happened to be.
-    const beforeHistoryId = opts.watch ? await captureBeforeHistoryId(id) : undefined;
+    // #91 P1 / #93 item 1 — captured BEFORE launching so pollRunProgress can
+    // tell "the run that's about to finish" apart from whatever the last run
+    // happened to be (including a dedup onto an already-in-flight run).
+    const beforeRun = opts.watch ? await captureBeforeRunState(id) : undefined;
     // #91 P0 — GET /api/scraps/load/:id runs the scrap synchronously
     // server-side (30-250s); the 30s default was aborting it mid-flight.
     await oraPromise(() => api.get(`/api/scraps/load/${id}`, { timeoutMs: LONG_RUN_TIMEOUT_MS }), {
@@ -544,7 +572,7 @@ scraps
         successText: 'Scrap launched',
     });
     if (opts.watch) {
-        await pollRunProgress(id, beforeHistoryId);
+        await pollRunProgress(id, beforeRun);
     }
 });
 // #70 — render an items array either as a table summary or --json. Shared by
@@ -641,6 +669,27 @@ scraps
             console.log(chalk.dim('No data yet. Run the scrap first.'));
             return;
         }
+        // #93 item 2 — --fresh used to render items without ever checking for a
+        // regression, unlike the persisted `data` path below (#88 item 2). The
+        // load() response's OWN embedded `scrap.history[0]` can't be trusted for
+        // this (see the ScrapLoadResult comment above): it may be the previous
+        // run's row, and even the right row never carries the regression flip.
+        // `--fresh` runs synchronously to completion server-side though — by the
+        // time this call returns, node has already awaited the regression patch
+        // — so a fresh GET /api/scraps/:id (the SAME read the persisted path
+        // below already trusts) reliably observes the finalized DB state.
+        // Best-effort: never fail --fresh's real output over this side check,
+        // and never gate on it — the items returned ARE this run's real,
+        // synchronously-computed data regardless of what this check finds.
+        try {
+            const fresh = await api.get(`/api/scraps/${id}`);
+            if (fresh.history?.[0]?.statusDetail === 'regression') {
+                console.error(chalk.yellow(`⚠ Item count regressed vs baseline for the last run of ${id} — see: trawl scraps doctor ${id}`));
+            }
+        }
+        catch {
+            // best-effort — the fresh run's items are still valid without this check
+        }
         renderScrapItems(items, opts.json);
         return;
     }
@@ -862,9 +911,13 @@ scraps
     .option('--wait', 'Run synchronously and wait for the result (legacy behaviour)')
     .action(async (id, opts) => {
     validateObjectId(id);
-    // #91 P1 — captured BEFORE triggering so pollRunProgress can tell "the
-    // run we just triggered" apart from whatever the last run happened to be.
-    const beforeHistoryId = opts.watch ? await captureBeforeHistoryId(id) : undefined;
+    // #91 P1 / #93 item 1 — captured BEFORE triggering so pollRunProgress can
+    // tell "the run we just triggered" apart from whatever the last run
+    // happened to be. This is the dedup-prone path: `trigger`'s method:'worker'
+    // collapses onto an already-pending/running worker job for the same scrap
+    // (ScrapJobsService, LIVE_STATUSES) instead of creating a new history row —
+    // captureBeforeRunState records that so pollRunProgress can still track it.
+    const beforeRun = opts.watch ? await captureBeforeRunState(id) : undefined;
     // #50 — default async: the backend (#1313) kicks off the run and returns a
     // 'queued' envelope immediately instead of holding the connection for the
     // whole run. --wait restores the old synchronous round-trip.
@@ -878,7 +931,7 @@ scraps
         successText: opts.wait ? 'Worker run complete' : 'Worker triggered',
     });
     if (opts.watch)
-        await pollRunProgress(id, beforeHistoryId);
+        await pollRunProgress(id, beforeRun);
 });
 // account subcommand group
 const account = scraps

package/dist/commands/skills.js

@@ -34,13 +34,31 @@ skills
         // #91 — same EISDIR class as autoUpdateInstalledSkills/installSkill: an
         // unreadable `.version` marker on one skill must not crash the whole
         // listing before the other skills are shown.
+        //
+        // #93 item 3 — the two scope reads must be guarded INDEPENDENTLY. A
+        // single try/catch wrapped around `getInstalledVersion(name, 'user') ??
+        // getInstalledVersion(name, 'local')` still throws the whole expression
+        // the moment the 'user' read throws (e.g. a corrupt/EISDIR `.version`
+        // marker) — `??` never gets a chance to evaluate the 'local' fallback,
+        // so a healthy local install gets masked as "not installed" too. Every
+        // other marker read in this codebase (installSkill, removeOrphanedSkills,
+        // autoUpdateInstalledSkills — all in lib/skills.ts) already guards each
+        // scope on its own; this was the one chained exception.
         let installedVersion;
         try {
-            installedVersion = getInstalledVersion(name, 'user') ?? getInstalledVersion(name, 'local');
+            installedVersion = getInstalledVersion(name, 'user');
         }
         catch {
             installedVersion = null;
         }
+        if (installedVersion === null) {
+            try {
+                installedVersion = getInstalledVersion(name, 'local');
+            }
+            catch {
+                installedVersion = null;
+            }
+        }
         const stale = installedVersion && installedVersion !== version;
         const tag = userInstalled
             ? localInstalled

package/package.json

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