@backburner/cli 0.1.2 → 0.1.4

package/README.md

@@ -124,7 +124,7 @@ Useful `init` flags:
 
 If either file already exists, onboarding asks before overwriting it. With `--yes`, defaults are accepted non-interactively, including selecting existing discovered repositories, enabling every discovered provider, creating strong and cheap agents for each one, and creating or updating labels on selected repositories. `--yes` does not create a private demo repository.
 
-Repository setup first asks whether to select existing repositories, create a private Backburner demo repository, or skip repository setup for now. Before choosing existing repositories, onboarding tells you that Backburner will create or update its labels on those repositories. In an interactive terminal, repository and provider selection use a checkbox picker: arrow keys move, space toggles, and enter confirms. Non-TTY sessions fall back to text input and accept comma-separated numbers. If you are authenticated with GitHub but do not want to onboard an existing local clone yet, onboarding can explicitly create a private `backburner-demo` repository and clone it under the configured code root.
+Repository setup first asks whether to create a private Backburner demo repository, select existing repositories, or skip repository setup for now. When GitHub authentication is available, the private demo repository is the interactive default. Before choosing existing repositories, onboarding tells you that Backburner will create or update its labels on those repositories. In an interactive terminal, repository and provider selection use a checkbox picker: arrow keys move, space toggles, and enter confirms. Non-TTY sessions fall back to text input and accept comma-separated numbers. If you are authenticated with GitHub but do not want to onboard an existing local clone yet, onboarding can explicitly create a private `backburner-demo` repository and clone it under the configured code root.
 
 Label creation is best-effort. If GitHub rejects a label write because of permissions or repository policy, onboarding continues and prints the repository labels URL plus the exact label names to create manually. The final summary prints the next `backburner run` command, a prefilled GitHub issue URL for the first configured repository, and a terminal QR code for opening that repository's issues page from a phone.
 

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/cli/init.js

@@ -58,7 +58,7 @@ export async function runInit(options) {
         new CheckRequirementsStep(commandRunner),
         new CheckGitHubAuthStep(commandRunner),
         new DiscoverReposStep(commandRunner, ctx.codeRoot),
-        new SelectReposStep(new DemoRepoCreator(commandRunner)),
+        new SelectReposStep(new DemoRepoCreator(commandRunner), nonInteractive ? "existing" : "demo"),
         new ConfigurePathsStep(),
         new DiscoverProvidersStep(commandRunner),
         new ConfigureModelsStep(),

package/dist/src/onboarding/steps/select-repos.js

@@ -1,10 +1,12 @@
 import { defaultDemoRepoName } from "../services/demo-repo.js";
 export class SelectReposStep {
     demoRepoCreator;
+    defaultSetupChoice;
     name = "select-repos";
     description = "Select repositories to manage";
-    constructor(demoRepoCreator) {
+    constructor(demoRepoCreator, defaultSetupChoice = "demo") {
         this.demoRepoCreator = demoRepoCreator;
+        this.defaultSetupChoice = defaultSetupChoice;
     }
     async run(ctx, prompter) {
         const { discoveredRepos } = ctx;
@@ -55,36 +57,52 @@ export class SelectReposStep {
     }
     async promptSetupChoice(ctx, prompter) {
         const hasDiscoveredRepos = ctx.discoveredRepos.length > 0;
-        const options = [
-            hasDiscoveredRepos
-                ? "Select existing repositories (Backburner will create/update its labels on them)"
-                : "Enter an existing repository manually",
-            ...(ctx.githubUser !== undefined ? ["Create a private Backburner demo repo"] : []),
-            "Skip repository setup for now"
-        ];
-        const choice = await prompter.choose("How do you want to set up repositories?", options, 0);
+        const existingLabel = hasDiscoveredRepos
+            ? "Select existing repositories (Backburner will create/update its labels on them)"
+            : "Enter an existing repository manually";
+        const hasDemoOption = ctx.githubUser !== undefined;
+        const options = hasDemoOption
+            ? ["Create a private Backburner demo repo", existingLabel, "Skip repository setup for now"]
+            : [existingLabel, "Skip repository setup for now"];
+        const defaultIndex = hasDemoOption && this.defaultSetupChoice === "existing" ? 1 : 0;
+        const choice = await prompter.choose("How do you want to set up repositories?", options, defaultIndex);
+        if (hasDemoOption) {
+            if (choice === 0) {
+                return "demo";
+            }
+            if (choice === 1) {
+                return "existing";
+            }
+            return "skip";
+        }
         if (choice === 0) {
             return "existing";
         }
-        if (ctx.githubUser !== undefined && choice === 1) {
-            return "demo";
-        }
         return "skip";
     }
     async promptNoSelection(ctx, prompter) {
-        const options = [
-            "Add an existing repository manually",
-            ...(ctx.githubUser !== undefined ? ["Create a private Backburner demo repo"] : []),
-            "Skip repository setup for now"
-        ];
+        const hasDemoOption = ctx.githubUser !== undefined;
+        const options = hasDemoOption
+            ? [
+                "Create a private Backburner demo repo",
+                "Add an existing repository manually",
+                "Skip repository setup for now"
+            ]
+            : ["Add an existing repository manually", "Skip repository setup for now"];
         const defaultIndex = 0;
         const choice = await prompter.choose("No repositories selected. How do you want to continue?", options, defaultIndex);
+        if (hasDemoOption) {
+            if (choice === 0) {
+                return await this.promptCreateDemoRepo(ctx, prompter);
+            }
+            if (choice === 1) {
+                return await this.promptManualEntry(ctx, prompter);
+            }
+            return this.noRepositoryWarning();
+        }
         if (choice === 0) {
             return await this.promptManualEntry(ctx, prompter);
         }
-        if (ctx.githubUser !== undefined && choice === 1) {
-            return await this.promptCreateDemoRepo(ctx, prompter);
-        }
         return this.noRepositoryWarning();
     }
     async promptCreateDemoRepo(ctx, prompter) {
@@ -106,7 +124,7 @@ export class SelectReposStep {
                 details: ["Repository names can contain letters, numbers, dots, underscores, and hyphens."]
             };
         }
-        const confirmed = await prompter.confirm(`Create private GitHub repository ${ctx.githubUser}/${repoName} and clone it under ${ctx.codeRoot}?`, false);
+        const confirmed = await prompter.confirm(`Create private GitHub repository ${ctx.githubUser}/${repoName} and clone it under ${ctx.codeRoot}?`, true);
         if (!confirmed) {
             return this.noRepositoryWarning();
         }

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.2",
+  "version": "0.1.4",
   "type": "module",
   "description": "Local GitHub-based agent orchestration CLI",
   "license": "MIT",