edsger 0.55.1 → 0.55.3

package/dist/api/cross-product.d.ts

@@ -24,8 +24,3 @@ export declare function listProducts(verbose?: boolean): Promise<ProductSummary[
  * Iterates through all accessible products and collects their issues
  */
 export declare function listAllReadyIssues(verbose?: boolean): Promise<IssueWithProduct[]>;
-/**
- * Claim a specific issue for processing
- * Unlike the product-level claim, this claims a specific issue by ID
- */
-export declare function claimIssueById(issueId: string, productId: string, verbose?: boolean): Promise<IssueInfo | null>;

package/dist/api/cross-product.js

@@ -83,29 +83,3 @@ export async function listAllReadyIssues(verbose) {
         throw error;
     }
 }
-/**
- * Claim a specific issue for processing
- * Unlike the product-level claim, this claims a specific issue by ID
- */
-export async function claimIssueById(issueId, productId, verbose) {
-    if (verbose) {
-        logInfo(`Claiming issue: ${issueId}`);
-    }
-    try {
-        const result = (await callMcpEndpoint('issues/claim', {
-            product_id: productId,
-            issue_id: issueId,
-        }));
-        if (result.issue) {
-            if (verbose) {
-                logInfo(`Claimed issue: ${result.issue.name}`);
-            }
-            return result.issue;
-        }
-        return null;
-    }
-    catch (error) {
-        logError(`Failed to claim issue: ${error instanceof Error ? error.message : String(error)}`);
-        return null;
-    }
-}

package/dist/api/issues/issue-utils.d.ts

@@ -1,14 +1,16 @@
 import { type IssueInfo } from '../../types/issues.js';
 /**
  * Claim the next available ready_for_ai issue for processing.
- * Uses database-level locking (FOR UPDATE SKIP LOCKED) to prevent
- * race conditions between multiple workers.
+ * Uses database-level locking (FOR UPDATE SKIP LOCKED) inside the RPC to
+ * prevent race conditions between multiple workers.
  *
- * @param productId - The product ID to claim an issue from
+ * @param productId - Optional product ID to scope the claim. When omitted,
+ *                    claims the next ready issue assigned to this worker
+ *                    across any product (cross-product agent mode).
  * @param verbose - Whether to log verbose output
  * @returns The claimed issue or null if no issues available
  */
-export declare function claimNextIssue(productId: string, verbose?: boolean): Promise<IssueInfo | null>;
+export declare function claimNextIssue(productId?: string, verbose?: boolean): Promise<IssueInfo | null>;
 /**
  * Filter issues by status
  */

package/dist/api/issues/issue-utils.js

@@ -2,21 +2,23 @@ import { logError, logInfo } from '../../utils/logger.js';
 import { callMcpEndpoint } from '../mcp-client.js';
 /**
  * Claim the next available ready_for_ai issue for processing.
- * Uses database-level locking (FOR UPDATE SKIP LOCKED) to prevent
- * race conditions between multiple workers.
+ * Uses database-level locking (FOR UPDATE SKIP LOCKED) inside the RPC to
+ * prevent race conditions between multiple workers.
  *
- * @param productId - The product ID to claim an issue from
+ * @param productId - Optional product ID to scope the claim. When omitted,
+ *                    claims the next ready issue assigned to this worker
+ *                    across any product (cross-product agent mode).
  * @param verbose - Whether to log verbose output
  * @returns The claimed issue or null if no issues available
  */
 export async function claimNextIssue(productId, verbose) {
     if (verbose) {
-        logInfo(`Attempting to claim next ready_for_ai issue for product: ${productId}`);
+        logInfo(productId
+            ? `Attempting to claim next ready_for_ai issue for product: ${productId}`
+            : 'Attempting to claim next ready_for_ai issue across all products');
     }
     try {
-        const result = (await callMcpEndpoint('issues/claim', {
-            product_id: productId,
-        }));
+        const result = (await callMcpEndpoint('issues/claim', productId ? { product_id: productId } : {}));
         if (result.issue) {
             if (verbose) {
                 logInfo(`✅ Claimed issue: ${result.issue.name} (${result.issue.id})`);

package/dist/commands/agent-workflow/processor.d.ts

@@ -44,9 +44,38 @@ export declare class AgentWorkflowProcessor {
     private processNextIssues;
     /**
      * Start a child process worker for a single issue.
-     * Handles: GitHub config lookup, repo cloning, then forks the worker.
+     * Handles: atomic claim, GitHub config lookup, repo cloning, then forks
+     * the worker.
+     *
+     * The candidate `issue` here comes from the listed ready_for_ai pool but is
+     * advisory — between list time and claim time another agent (or another
+     * process) may have grabbed it. We re-claim atomically per product. The
+     * RPC returns whichever ready issue is next in that product (most often
+     * the same one we listed, but not guaranteed); we operate on what claim
+     * actually returns. If claim returns null, someone else won the race —
+     * skip this slot for this cycle.
      */
     private startIssueWorker;
+    /**
+     * After a successful claim moved the issue ready_for_ai → assigned_to_ai,
+     * any post-claim setup failure (GitHub config, clone, fork) leaves the
+     * issue stuck at assigned_to_ai with no worker — an orphan that the user
+     * can't fix from the UI. Push it forward to 'failed' so it shows up in
+     * the failed bucket and can be inspected / re-set to ready_for_ai by a
+     * human.
+     *
+     * Status guard: only force-progress if the issue is still at
+     * assigned_to_ai or in_progress. A worker may have already advanced the
+     * status to shipped / failed via a separate code path before we got the
+     * non-success IPC signal; clobbering those would lose real outcome data.
+     * STATUS_PROGRESSION_ORDER classifies shipped→failed as a forward move
+     * (so updateIssueStatus wouldn't reject it), which is why this guard
+     * lives here rather than at the RPC layer.
+     *
+     * Errors are swallowed: if the status fetch or update fails the issue
+     * stays orphaned but logging is the most we can do here.
+     */
+    private releaseClaim;
     private handleWorkerResult;
     getStats(): WorkflowStats;
     getActiveWorkerCount(): number;

package/dist/commands/agent-workflow/processor.js

@@ -12,6 +12,8 @@ import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
 import { listAllReadyIssues, } from '../../api/cross-product.js';
 import { getGitHubConfig } from '../../api/github.js';
+import { claimNextIssue, getIssue } from '../../api/issues/index.js';
+import { callMcpEndpoint } from '../../api/mcp-client.js';
 import { WorkerTimeoutError } from '../../errors/index.js';
 import { sendHeartbeat, shouldProcess } from '../../system/session-manager.js';
 import { logError, logInfo, logSuccess, logWarning, } from '../../utils/logger.js';
@@ -255,9 +257,41 @@ export class AgentWorkflowProcessor {
     }
     /**
      * Start a child process worker for a single issue.
-     * Handles: GitHub config lookup, repo cloning, then forks the worker.
+     * Handles: atomic claim, GitHub config lookup, repo cloning, then forks
+     * the worker.
+     *
+     * The candidate `issue` here comes from the listed ready_for_ai pool but is
+     * advisory — between list time and claim time another agent (or another
+     * process) may have grabbed it. We re-claim atomically per product. The
+     * RPC returns whichever ready issue is next in that product (most often
+     * the same one we listed, but not guaranteed); we operate on what claim
+     * actually returns. If claim returns null, someone else won the race —
+     * skip this slot for this cycle.
      */
-    async startIssueWorker(issue) {
+    async startIssueWorker(candidate) {
+        // In-process dedup runs BEFORE the claim. If we already have a worker
+        // for the listed candidate, skipping here avoids successfully claiming
+        // an issue we'd then refuse to start — which would leave it stuck at
+        // assigned_to_ai with no worker (an orphan, since the claim has no
+        // release path). Cross-process races are still handled by the DB.
+        if (this.activeWorkers.has(candidate.id)) {
+            return;
+        }
+        // Atomic claim transitions ready_for_ai → assigned_to_ai inside the RPC
+        // (FOR UPDATE SKIP LOCKED), so concurrent workers never share the same
+        // issue. Scoped to the candidate's product so a race within one product
+        // resolves locally instead of pulling work from elsewhere.
+        const claimResult = await claimNextIssue(candidate.product_id, this.options.verbose);
+        if (!claimResult) {
+            if (this.options.verbose) {
+                logInfo(`No claimable issue in product ${candidate.product_name ?? candidate.product_id} (raced or no longer ready)`);
+            }
+            return;
+        }
+        const issue = {
+            ...claimResult,
+            product_name: candidate.product_name,
+        };
         const issueId = issue.id;
         // Update state to processing
         this.processedIssues = updateIssueState(this.processedIssues, issueId, (currentState) => createProcessingState(issueId, currentState));
@@ -276,6 +310,7 @@ export class AgentWorkflowProcessor {
                 !githubConfig.repo) {
                 logWarning(`GitHub not configured for issue: ${issue.name}. ${githubConfig.message || ''}`);
                 this.processedIssues = updateIssueState(this.processedIssues, issueId, (currentState) => createFailedState(issueId, currentState));
+                await this.releaseClaim(issueId, issue.name);
                 return;
             }
             // Step 2: Clone or reuse repo
@@ -403,6 +438,42 @@ export class AgentWorkflowProcessor {
             this.activeWorkers.delete(issueId);
             this.processedIssues = updateIssueState(this.processedIssues, issueId, (currentState) => createFailedState(issueId, currentState));
             logError(`Issue error: ${issue.name} - ${error instanceof Error ? error.message : String(error)}`);
+            await this.releaseClaim(issueId, issue.name);
+        }
+    }
+    /**
+     * After a successful claim moved the issue ready_for_ai → assigned_to_ai,
+     * any post-claim setup failure (GitHub config, clone, fork) leaves the
+     * issue stuck at assigned_to_ai with no worker — an orphan that the user
+     * can't fix from the UI. Push it forward to 'failed' so it shows up in
+     * the failed bucket and can be inspected / re-set to ready_for_ai by a
+     * human.
+     *
+     * Status guard: only force-progress if the issue is still at
+     * assigned_to_ai or in_progress. A worker may have already advanced the
+     * status to shipped / failed via a separate code path before we got the
+     * non-success IPC signal; clobbering those would lose real outcome data.
+     * STATUS_PROGRESSION_ORDER classifies shipped→failed as a forward move
+     * (so updateIssueStatus wouldn't reject it), which is why this guard
+     * lives here rather than at the RPC layer.
+     *
+     * Errors are swallowed: if the status fetch or update fails the issue
+     * stays orphaned but logging is the most we can do here.
+     */
+    async releaseClaim(issueId, issueName) {
+        try {
+            const current = await getIssue(issueId, false);
+            if (current.status !== 'assigned_to_ai' &&
+                current.status !== 'in_progress') {
+                return;
+            }
+            await callMcpEndpoint('issues/update', {
+                issue_id: issueId,
+                status: 'failed',
+            });
+        }
+        catch (releaseError) {
+            logWarning(`Failed to release claim on ${issueName} (${issueId}); issue may be orphaned at assigned_to_ai: ${releaseError instanceof Error ? releaseError.message : String(releaseError)}`);
         }
     }
     handleWorkerResult(issueId, issueName, success, error) {
@@ -419,6 +490,15 @@ export class AgentWorkflowProcessor {
         else {
             this.processedIssues = updateIssueState(this.processedIssues, issueId, (currentState) => createFailedState(issueId, currentState));
             logError(`Issue failed: ${issueName}${error ? ` - ${error}` : ''}`);
+            // No releaseClaim here: this path runs after the worker reported a
+            // non-success result, but the worker may still have been mid-way
+            // through writing its own status (e.g. setting 'shipped' or 'failed'
+            // before exiting). A read-then-write release would race with the
+            // worker's final DB write. Worker code is responsible for advancing
+            // the lifecycle status before it exits; a worker that crashes
+            // without doing so leaves the issue at assigned_to_ai, which is a
+            // separate, pre-existing orphan class outside the scope of the
+            // pre-fork cleanup that releaseClaim handles.
             // Only notify chat on first failure to avoid flooding with duplicate messages
             const failedState = this.processedIssues.get(issueId);
             if (failedState && failedState.retryCount <= 1) {

package/dist/services/skill-resolver.js

@@ -12,6 +12,7 @@
 import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 import matter from 'gray-matter';
 import { logDebug } from '../utils/logger.js';
 import { loadSkillFile } from './phase-hooks/plugin-loader.js';
@@ -23,9 +24,10 @@ let _bundledSkillsDir = null;
 function getBundledSkillsDir() {
     if (!_bundledSkillsDir) {
         // dist/services/skill-resolver.js → dist/skills/
-        const thisDir = path.dirname(
-        // @ts-ignore -- import.meta.url is available in ESM
-        new URL(import.meta.url).pathname);
+        // Use fileURLToPath, not URL.pathname — the latter is percent-encoded,
+        // which breaks fs.readFile when the install path contains spaces (e.g.
+        // macOS `~/Library/Application Support/edsger-desktop/...`).
+        const thisDir = path.dirname(fileURLToPath(import.meta.url));
         _bundledSkillsDir = path.resolve(thisDir, '..', 'skills');
     }
     return _bundledSkillsDir;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "edsger",
-  "version": "0.55.1",
+  "version": "0.55.3",
   "type": "module",
   "bin": {
     "edsger": "dist/index.js"