omnirush 0.8.1 → 0.8.2

package/assets/extensions/omnirush/capture/workspace-collector.ts

@@ -89,6 +89,9 @@ const ENVELOPE_WRITE_CHUNK_BYTES = 64 * 1024;
 const MAX_CHANGE_JOURNAL_ENTRIES = 512;
 const MAX_CHANGE_JOURNAL_BYTES = 768 * 1024;
 const MAX_SESSION_LEDGER_ENTRIES = 512;
+const SESSION_LEDGER_LOCK_TIMEOUT_MS = 5_000;
+const SESSION_LEDGER_LOCK_STALE_MS = 60_000;
+const SESSION_LEDGER_LOCK_RETRY_MS = 25;
 const MAX_TOUCHED_PATHS = 128;
 const MAX_GIT_STATUS_ENTRIES = 500;
 const MAX_GIT_RECENT_COMMITS = 50;
@@ -2977,6 +2980,44 @@ async function writeFileAtomic(path: string, data: Buffer | string): Promise<voi
   }
 }
 
+async function withSessionLedgerLock<T>(lockPath: string, task: () => Promise<T>): Promise<T> {
+  const started = Date.now();
+  await mkdir(dirname(lockPath), { recursive: true, mode: 0o700 });
+  let handle: Awaited<ReturnType<typeof open>> | null = null;
+  while (!handle) {
+    try {
+      handle = await open(lockPath, "wx", 0o600);
+      await handle.writeFile(`${process.pid}\n`);
+    } catch (error) {
+      await handle?.close().catch(() => undefined);
+      handle = null;
+      const code = typeof error === "object" && error !== null && "code" in error
+        ? (error as { code?: string }).code
+        : undefined;
+      if (code !== "EEXIST") throw error;
+      try {
+        const info = await stat(lockPath);
+        if (Date.now() - info.mtimeMs > SESSION_LEDGER_LOCK_STALE_MS) {
+          await rm(lockPath, { force: true });
+          continue;
+        }
+      } catch {
+        // The owner may have released the lock between EEXIST and stat.
+      }
+      if (Date.now() - started >= SESSION_LEDGER_LOCK_TIMEOUT_MS) {
+        throw new Error("timed out waiting for the session ledger lock");
+      }
+      await new Promise<void>((resolvePromise) => setTimeout(resolvePromise, SESSION_LEDGER_LOCK_RETRY_MS));
+    }
+  }
+  try {
+    return await task();
+  } finally {
+    await handle.close().catch(() => undefined);
+    await rm(lockPath, { force: true }).catch(() => undefined);
+  }
+}
+
 function parseSpoolMeta(value: unknown): SpoolMeta | null {
   if (!value || typeof value !== "object") return null;
   const record = value as Partial<SpoolMeta>;
@@ -3105,19 +3146,27 @@ export class WorkspaceCollector {
     this.ledger = await readSessionLedger(this.ledgerPath);
   }
 
-  private async saveLedger(): Promise<void> {
+  private async saveLedger(sessionId: string): Promise<void> {
     if (!this.ledgerPath) return;
     await this.ledgerReady;
-    const entries = Object.entries(this.ledger.sessions)
-      .sort(([, left], [, right]) => right.lastSeenAt.localeCompare(left.lastSeenAt))
-      .slice(0, MAX_SESSION_LEDGER_ENTRIES);
-    this.ledger.sessions = Object.fromEntries(entries);
-    const snapshot = JSON.stringify(this.ledger);
+    const record = this.ledger.sessions[sessionId]
+      ? JSON.parse(JSON.stringify(this.ledger.sessions[sessionId])) as SessionLedgerRecord
+      : undefined;
     this.ledgerWriteTail = this.ledgerWriteTail
       .catch(() => undefined)
       .then(async () => {
-        await mkdir(dirname(this.ledgerPath!), { recursive: true, mode: 0o700 });
-        await writeFileAtomic(this.ledgerPath!, snapshot);
+        await withSessionLedgerLock(`${this.ledgerPath!}.lock`, async () => {
+          // Reload while holding the lock so concurrent processes merge their
+          // session record instead of overwriting one another's progress.
+          const merged = await readSessionLedger(this.ledgerPath);
+          if (record) merged.sessions[sessionId] = record;
+          const entries = Object.entries(merged.sessions)
+            .sort(([, left], [, right]) => right.lastSeenAt.localeCompare(left.lastSeenAt))
+            .slice(0, MAX_SESSION_LEDGER_ENTRIES);
+          merged.sessions = Object.fromEntries(entries);
+          this.ledger = merged;
+          await writeFileAtomic(this.ledgerPath!, JSON.stringify(merged));
+        });
       });
     await this.ledgerWriteTail;
   }
@@ -3158,13 +3207,13 @@ export class WorkspaceCollector {
       this.appendTrace(state, "session.resumed", { session_segment: state.segment, previous_segment: previous?.segment ?? null });
     }
     this.ledger.sessions[state.id] = this.ledgerRecord(state);
-    await this.saveLedger();
+    await this.saveLedger(state.id);
   }
 
   private async persistSession(state: SessionState): Promise<void> {
     await this.ledgerReady;
     this.ledger.sessions[state.id] = this.ledgerRecord(state);
-    await this.saveLedger();
+    await this.saveLedger(state.id);
   }
 
   private async recordLedgerOutcome(sessionId: string, outcome: "success" | "failure"): Promise<void> {
@@ -3188,7 +3237,7 @@ export class WorkspaceCollector {
       record.lastFailureAt = now;
     }
     record.lastSeenAt = now;
-    await this.saveLedger();
+    await this.saveLedger(sessionId);
   }
 
   async sessionCheckpoint(sessionId: string): Promise<{ resumed: boolean; segment?: number; lastMessageId?: string }> {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omnirush",
-  "version": "0.8.1",
+  "version": "0.8.2",
   "description": "Omnirush \u2014 free daily tokens for the most powerful coding model on earth.",
   "license": "Apache-2.0",
   "type": "module",
@@ -41,4 +41,4 @@
     "minimatch": "^10.2.6",
     "zod": "^4.6.5"
   }
-}
+}

package/src/bin.js

@@ -577,7 +577,7 @@ async function cmdDoctor() {
     } else {
       console.log(
         `WARN agent core — installed core is v${coreVersion}, this omnirush expects v${own} ` +
-          "(stale install: pi.dev update banners, missing omnirush provider). Fix: omnirush update",
+          "(stale install: agent update banners, missing omnirush provider). Fix: omnirush update",
       );
     }
   }

package/src/lib.js

@@ -273,7 +273,7 @@ export function catalogFromGateway(payload, shipped = MODELS) {
 }
 
 /**
- * Prepend `--provider`/`--model` defaults for agent runs, without
+ * Prepend the product's provider/model/scope defaults for agent runs, without
  * duplicating flags the user already specified. Consumption rules mirror
  * pi's own parseArgs so a value token is never mistaken for a flag (e.g.
  * `omnirush -p "how do I use --model flags"` must not suppress defaults).
@@ -289,6 +289,7 @@ export function withModelDefaults(args, defaults) {
   }
   let hasProvider = false;
   let hasModel = false;
+  let hasModelsScope = false;
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
     if (arg === "--") break;
@@ -305,10 +306,17 @@ export function withModelDefaults(args, defaults) {
         hasModel = true;
         i++;
       }
+    } else if (arg === "--models") {
+      if (i + 1 < args.length) {
+        hasModelsScope = true;
+        i++;
+      }
     } else if (arg.startsWith("--provider=")) {
       hasProvider = true;
     } else if (arg.startsWith("--model=")) {
       hasModel = true;
+    } else if (arg.startsWith("--models=")) {
+      hasModelsScope = true;
     } else if (arg === "--print" || arg === "-p") {
       const next = args[i + 1];
       if (
@@ -334,6 +342,10 @@ export function withModelDefaults(args, defaults) {
     }
   }
   const out = [];
+  // The upstream core merges every configured provider into its registry.
+  // Keep BYOK configuration on disk, but scope this product's selector to
+  // Omnirush unless the caller explicitly opts into another scope.
+  if (!hasModelsScope) out.push("--models", `${DEFAULT_PROVIDER}/*`);
   if (!hasProvider) out.push("--provider", provider);
   if (!hasModel) out.push("--model", model);
   return [...out, ...args];