@backburner/cli 0.1.3 → 0.1.5

package/dist/src/agents/antigravity-launch.js

@@ -28,7 +28,7 @@ export function buildAntigravityCliArgs(options) {
     else {
         args.push("--dangerously-skip-permissions");
     }
-    args.push("--print", "-");
+    args.push("--print", options.promptText);
     return args;
 }
 export async function writeAntigravitySettings(settingsPath, options) {

package/dist/src/agents/antigravity.js

@@ -64,7 +64,8 @@ export class AntigravityCliAgent {
             ...(agentConfig.model ? { model: agentConfig.model } : {}),
             ...(resumeConversationId ? { conversationId: resumeConversationId } : {}),
             printTimeout: this.printTimeout,
-            logFilePath
+            logFilePath,
+            promptText
         });
         this.logger?.info(JSON.stringify({
             component: "antigravity-launch",
@@ -102,7 +103,6 @@ export class AntigravityCliAgent {
             }
             const result = await this.options.commandRunner.run(agentConfig.command, args, {
                 cwd,
-                input: promptText,
                 env: getAntigravityEnvOverrides(),
                 timeoutMs: this.timeoutMs
             });

package/dist/src/agents/codex.js

@@ -192,7 +192,9 @@ export class CodexCliAgent {
                 : {})
         };
         const parsedThreadId = extractThreadIdFromCodexOutput(stdout);
-        const providerLimitSignal = detectProviderLimit("codex", exitCode, stdout, stderr);
+        const providerLimitSignal = exitCode === 0
+            ? undefined
+            : detectProviderLimit("codex", exitCode, extractCodexProviderErrorText(stdout), stderr);
         return {
             taskStatus: execution.taskStatus,
             execution,
@@ -259,3 +261,61 @@ function extractCodexStreamJsonAssistantText(streamText) {
     }
     return undefined;
 }
+function extractCodexProviderErrorText(streamText) {
+    if (!streamText.trim()) {
+        return "";
+    }
+    const extractedErrors = [];
+    let sawJsonLine = false;
+    for (const line of streamText.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed) {
+            continue;
+        }
+        try {
+            const event = JSON.parse(trimmed);
+            sawJsonLine = true;
+            collectCodexErrorStrings(event, extractedErrors);
+        }
+        catch {
+            // Non-JSON Codex output is a direct process surface and can be scanned.
+            extractedErrors.push(trimmed);
+        }
+    }
+    return sawJsonLine ? extractedErrors.join("\n") : streamText;
+}
+function collectCodexErrorStrings(value, out) {
+    if (!value || typeof value !== "object") {
+        return;
+    }
+    const record = value;
+    const type = typeof record.type === "string" ? record.type : "";
+    const isErrorEvent = type.toLowerCase().includes("error");
+    if (isErrorEvent) {
+        for (const key of ["message", "error", "details"]) {
+            const text = stringifyCodexErrorField(record[key]);
+            if (text) {
+                out.push(text);
+            }
+        }
+    }
+    const errorText = stringifyCodexErrorField(record.error);
+    if (errorText && (isErrorEvent || record.status === "failed")) {
+        out.push(errorText);
+    }
+}
+function stringifyCodexErrorField(value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    if (value && typeof value === "object") {
+        const record = value;
+        if (typeof record.message === "string") {
+            return record.message;
+        }
+        if (typeof record.code === "string") {
+            return record.code;
+        }
+    }
+    return undefined;
+}

package/dist/src/agents/service.js

@@ -310,11 +310,12 @@ export async function dispatchPendingTasks(input) {
                 let providerLimitQueueProviders;
                 let providerLimitResetTime;
                 let swappedAfterProviderLimit = false;
-                if (result.providerLimitSignal) {
+                const actionableProviderLimitSignal = result.taskStatus === "completed" ? undefined : result.providerLimitSignal;
+                if (actionableProviderLimitSignal) {
                     try {
                         const limitState = await input.stateStore.load();
                         const providerLimits = [...(limitState.providerLimits ?? [])];
-                        const signal = result.providerLimitSignal;
+                        const signal = actionableProviderLimitSignal;
                         const existingIdx = providerLimits.findIndex(l => l.provider === signal.provider);
                         const newRecord = mapSignalToRecord(signal, now());
                         if (existingIdx !== -1) {
@@ -362,15 +363,15 @@ export async function dispatchPendingTasks(input) {
                     }
                     catch (err) {
                         input.logger?.warn(`[dispatch] Failed to persist provider limit updates: ${err}`);
-                        providerLimitQueueProviders = result.providerLimitSignal.provider;
-                        providerLimitResetTime = result.providerLimitSignal.resetTime;
+                        providerLimitQueueProviders = actionableProviderLimitSignal.provider;
+                        providerLimitResetTime = actionableProviderLimitSignal.resetTime;
                     }
                 }
-                const isProviderLimit = !!result.providerLimitSignal;
+                const isProviderLimit = !!actionableProviderLimitSignal;
                 const shouldQueueForProviderLimit = isProviderLimit && !swappedAfterProviderLimit;
                 const finalStatus = shouldQueueForProviderLimit ? "queued" : swappedAfterProviderLimit ? "pending" : result.taskStatus;
                 if (shouldQueueForProviderLimit && !preparingTask.context.notifiedQueued) {
-                    await safelyNotifyQueued(input.lifecycleNotifier, preparingTask, providerLimitQueueProviders ?? result.providerLimitSignal.provider, providerLimitResetTime, input.logger);
+                    await safelyNotifyQueued(input.lifecycleNotifier, preparingTask, providerLimitQueueProviders ?? actionableProviderLimitSignal.provider, providerLimitResetTime, input.logger);
                 }
                 tasks[index] = {
                     ...preparingTask,
@@ -395,12 +396,12 @@ export async function dispatchPendingTasks(input) {
                             }
                             : {})
                     },
-                    ...(shouldQueueForProviderLimit ? { waitingOnProvider: result.providerLimitSignal.provider } : { waitingOnProvider: undefined })
+                    ...(shouldQueueForProviderLimit ? { waitingOnProvider: actionableProviderLimitSignal.provider } : { waitingOnProvider: undefined })
                 };
                 await input.stateStore.writeExecutionState(executions);
                 await input.stateStore.writeTaskState(tasks);
                 if (shouldQueueForProviderLimit) {
-                    console.log(`🤖 Task ${preparingTask.id} has been queued (waiting on provider ${result.providerLimitSignal.provider} due to rate limit).`);
+                    console.log(`🤖 Task ${preparingTask.id} has been queued (waiting on provider ${actionableProviderLimitSignal.provider} due to rate limit).`);
                 }
                 if (assignmentResolution.mode === "pinned") {
                     try {

package/dist/src/tasks/derivation/handlers/plan-breakdown.js

@@ -11,7 +11,7 @@ export const planBreakdownHandler = {
     }
 };
 function derivePlanBreakdownTask(context, env) {
-    const { workstream, attention, issue, activePullRequest, repoConfig, repoSyncRecord } = context;
+    const { workstream, attention, issue, activePullRequest, activeWorktree, repoConfig, repoSyncRecord } = context;
     if (hasGeneratedPlanBreakdown(workstream)) {
         return undefined;
     }
@@ -23,6 +23,13 @@ function derivePlanBreakdownTask(context, env) {
     if (!source) {
         return undefined;
     }
+    const prWorktree = source.kind === "pull_request" &&
+        activeWorktree &&
+        activePullRequest &&
+        activePullRequest.id === source.id &&
+        activeWorktree.branchName === activePullRequest.headBranch
+        ? activeWorktree
+        : undefined;
     return buildTaskRecord(buildTaskId("plan_breakdown", source.id), "plan_breakdown", source, repoSyncRecord, {
         reason: `The "${repoConfig.labels.planBreakdownNeeded}" label is present, requesting a technical breakdown before implementation.`,
         summary: `Break down implementation for ${source.kind.replace("_", " ")} #${source.number}: ${source.title}`,
@@ -40,6 +47,16 @@ function derivePlanBreakdownTask(context, env) {
                 issueBody: source.body
             }
             : {}),
-        ...(repoSyncRecord?.localPath ? { localRepoPath: repoSyncRecord.localPath } : {})
+        ...(prWorktree
+            ? {
+                localRepoPath: prWorktree.path,
+                branchName: prWorktree.branchName,
+                planDocumentPath: prWorktree.planDocumentPath,
+                ...(prWorktree.productSpecDocumentPath ? { productSpecDocumentPath: prWorktree.productSpecDocumentPath } : {}),
+                logDocumentPath: prWorktree.logDocumentPath
+            }
+            : repoSyncRecord?.localPath
+                ? { localRepoPath: repoSyncRecord.localPath }
+                : {})
     }), workstream.id);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@backburner/cli",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "type": "module",
   "description": "Local GitHub-based agent orchestration CLI",
   "license": "MIT",