@clipboard-health/groundcrew 4.52.12 → 4.53.0

package/dist/commands/setupWorkspace.js

@@ -4,7 +4,7 @@ import { inferAgentCommandName, workerEnvironmentForTask } from "../lib/launchCo
 import { createBoard } from "../lib/board.js";
 import { buildSources, sourcesFromConfig } from "../lib/buildSources.js";
 import { resolveRepositoryPreparationCommands } from "../lib/repositoryHooks.js";
-import { recordRunState } from "../lib/runState.js";
+import { readRunState, recordRunState } from "../lib/runState.js";
 import { seedLaunchWorkspaceTrust } from "../lib/seedLaunchWorkspaceTrust.js";
 import { sourceSupportsMarkDone } from "../lib/sourceCapabilities.js";
 import { removeStagedPrompt, stageBuildSecretsForLaunch, stagePromptFromTemplate, stageWorkspaceLaunchCommand, } from "../lib/stagedLaunch.js";
@@ -42,25 +42,16 @@ export async function setupWorkspace(config, options, runOptions = {}) {
         purpose: "runs",
         ...(signal === undefined ? {} : { signal }),
     });
+    // Captured before preflightProvisioningGate stamps its own "provisioning"
+    // row (which carries options.baseBranch forward) — otherwise the reattach
+    // guard inside worktrees.create() would compare the just-requested
+    // baseBranch against itself and never fire. See
+    // StackedBaseBranchMismatchError's doc comment in worktrees.ts.
+    const recordedBaseBranch = readRunState(config, task)?.baseBranch;
     await preflightProvisioningGate({ config, options, signal });
-    const spec = { repository, task };
-    const createdPromise = signal === undefined ? worktrees.create(config, spec) : worktrees.create(config, spec, signal);
+    const createdPromise = beginWorktreeCreate({ config, options, signal, recordedBaseBranch });
     const readinessPromise = startLaunchReadiness(ensureReady);
-    let created;
-    try {
-        created = await createdPromise;
-    }
-    catch (error) {
-        // Roll the pre-flight `provisioning` row forward; the outer catch only
-        // fires post-create and the dispatcher just logs and moves on.
-        recordFailedToLaunch({
-            config,
-            options,
-            paths: worktrees.predictedEntry(config, repository, task),
-            error,
-        });
-        throw error;
-    }
+    const created = await createdPromise;
     const { branchName, dir: worktreeDir } = created;
     const launchDir = resolveLaunchDir(config, repository, worktreeDir);
     const worktreeName = `${repository}-${task}`;
@@ -130,6 +121,8 @@ export async function setupWorkspace(config, options, runOptions = {}) {
             workerEnvironment: workerEnvironmentForTask({
                 taskId: completionTaskId,
                 markDoneSupported: completionMarkDoneSupported,
+                remote: config.git.remote,
+                ...(options.baseBranch === undefined ? {} : { baseBranch: options.baseBranch }),
             }),
             taskSourceWritePaths,
             safehouse: config.local.safehouse,
@@ -161,6 +154,8 @@ export async function setupWorkspace(config, options, runOptions = {}) {
             title: taskDetails.title,
             completionTaskId,
             ...(taskDetails.url === undefined ? {} : { url: taskDetails.url }),
+            ...(options.baseBranch === undefined ? {} : { baseBranch: options.baseBranch }),
+            ...(options.parentTask === undefined ? {} : { parentTask: options.parentTask }),
         });
         log(`${okMark()} "${task}" launched (${agent})  worktree ${worktreeName}`);
         debug(`  Worktree: ${launchDir}`);
@@ -176,6 +171,34 @@ export async function setupWorkspace(config, options, runOptions = {}) {
         throw error;
     }
 }
+/**
+ * Starts the task's worktree create call, synchronously, so it kicks off
+ * before the concurrent launch-readiness check (some tests assert
+ * `worktrees.create` is invoked ahead of the safehouse clearance probe).
+ * Rolls the pre-flight "provisioning" run state row forward into
+ * "failed-to-launch" on failure — the outer catch in `setupWorkspace` only
+ * fires post-create, and the dispatcher just logs and moves on otherwise.
+ */
+async function beginWorktreeCreate(arguments_) {
+    const { config, options, signal, recordedBaseBranch } = arguments_;
+    const { task, repository } = options;
+    const spec = {
+        repository,
+        task,
+        ...(options.baseBranch === undefined ? {} : { baseBranch: options.baseBranch }),
+        ...(recordedBaseBranch === undefined ? {} : { recordedBaseBranch }),
+    };
+    const createdPromise = signal === undefined ? worktrees.create(config, spec) : worktrees.create(config, spec, signal);
+    return await createdPromise.catch((error) => {
+        recordFailedToLaunch({
+            config,
+            options,
+            paths: worktrees.predictedEntry(config, repository, task),
+            error,
+        });
+        throw error;
+    });
+}
 function resolveTaskPreparationCommands(arguments_) {
     if (!arguments_.shouldPrepareWorktree) {
         return {
@@ -220,6 +243,8 @@ async function preflightProvisioningGate(arguments_) {
         title: options.details.title,
         completionTaskId: options.completionTaskId ?? task,
         ...(options.details.url === undefined ? {} : { url: options.details.url }),
+        ...(options.baseBranch === undefined ? {} : { baseBranch: options.baseBranch }),
+        ...(options.parentTask === undefined ? {} : { parentTask: options.parentTask }),
     });
 }
 function recordFailedToLaunch(arguments_) {
@@ -238,6 +263,12 @@ function recordFailedToLaunch(arguments_) {
         title: options.details.title,
         completionTaskId: options.completionTaskId ?? task,
         ...(options.details.url === undefined ? {} : { url: options.details.url }),
+        // A failed dispatch never got a worktree, so any baseBranch/parentTask
+        // recorded moments earlier by preflightProvisioningGate's "provisioning"
+        // row must not survive into this terminal state — otherwise the parent's
+        // branch would look permanently referenced (worktreeRunState.ts's
+        // isReferencedAsStackParent) even though no child ever came to exist.
+        clearStackingFields: true,
     });
 }
 async function startLaunchReadiness(ensureReady) {
@@ -284,6 +315,12 @@ function renderWorkspaceContinuationInstruction(accessHint) {
     }
     return `Include this workspace continuation note in the output: Workspace attach: \`${accessHint.command}\`.`;
 }
+const STACKING_RUN_STATE_FIELDS = [
+    "baseBranch",
+    "parentTask",
+    "needsRebase",
+    "stackRegistered",
+];
 function recordRunStateBestEffort(arguments_) {
     try {
         recordRunState({
@@ -300,6 +337,11 @@ function recordRunStateBestEffort(arguments_) {
                 completionTaskId: arguments_.completionTaskId,
                 ...(arguments_.detail === undefined ? {} : { detail: arguments_.detail }),
                 ...(arguments_.url === undefined ? {} : { url: arguments_.url }),
+                ...(arguments_.baseBranch === undefined ? {} : { baseBranch: arguments_.baseBranch }),
+                ...(arguments_.parentTask === undefined ? {} : { parentTask: arguments_.parentTask }),
+                ...(arguments_.clearStackingFields === true
+                    ? { clearFields: STACKING_RUN_STATE_FIELDS }
+                    : {}),
             },
         });
     }

package/dist/commands/stackRetarget.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Per-tick pass that keeps a stacked child's PR base and branch in sync with
+ * its parent, per the stacked-PRs design (spec section 5). Runs from within
+ * the reviewer, once per task whose run state carries `baseBranch`:
+ *
+ * - Parent still open, child PR based on something other than the parent →
+ *   `gh pr edit --base <parent>`.
+ * - Parent merged (a PR on the parent's branch has state `merged` — the
+ *   parent issue's canonical `done` status is never on its own proof of a
+ *   merge: a ticket closed as duplicate, or completed via `crew task done`
+ *   with an unmerged/closed PR, is `done` but not merged) and the child PR
+ *   is still based on the parent (or GitHub already moved it to the default
+ *   branch itself) → `gh pr edit --base <default>`, then rebase onto the
+ *   default branch and force-push when the worktree is clean, or flag
+ *   `needsRebase` when it isn't. A successful rebase also tries to reclaim
+ *   the parent's now-unreferenced branch (spec section 6) — `worktrees.teardown`
+ *   only checks this at the moment the parent's own worktree is torn down,
+ *   which is usually before this rebase runs.
+ * - Parent not merged, and the parent issue is done (or its worktree is
+ *   gone) — the parent will never merge, so retargeting onto or rebasing
+ *   onto a branch that is about to vanish would be wrong. Leave the child
+ *   untouched (`parent_done_unmerged`).
+ *
+ * A task with no `baseBranch` in run state, or no open PR yet, is left
+ * alone — there is nothing to correct. Every git/gh failure is caught,
+ * logged, and left for the next tick; one task's failure never blocks
+ * another's.
+ */
+import type { ResolvedConfig } from "../lib/config.ts";
+import { type StacksClient } from "../lib/githubStacks.ts";
+import { type CountMergeCommits } from "../lib/pullRequests.ts";
+import { type BoardState } from "../lib/taskSource.ts";
+import { type WorktreeEntry } from "../lib/worktrees.ts";
+import type { FindPullRequests } from "./reviewer.ts";
+export type RunGitCommand = (arguments_: {
+    cwd: string;
+    args: readonly string[];
+    signal?: AbortSignal;
+}) => Promise<string>;
+export type RunGhCommand = (arguments_: {
+    cwd: string;
+    args: readonly string[];
+    signal?: AbortSignal;
+}) => Promise<string>;
+export interface StackRetargetDeps {
+    findPullRequests: FindPullRequests;
+    runGit?: RunGitCommand;
+    runGh?: RunGhCommand;
+    stacks?: StacksClient;
+    countMergeCommits?: CountMergeCommits;
+}
+interface StackRetargetArguments {
+    config: ResolvedConfig;
+    state: BoardState;
+    worktreeEntries: readonly WorktreeEntry[];
+    dryRun: boolean;
+    signal?: AbortSignal;
+}
+export interface StackRetarget {
+    runOnce: (arguments_: StackRetargetArguments) => Promise<void>;
+}
+export declare function createStackRetarget(deps: StackRetargetDeps): StackRetarget;
+export {};
+//# sourceMappingURL=stackRetarget.d.ts.map

package/dist/commands/stackRetarget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stackRetarget.d.ts","sourceRoot":"","sources":["../../src/commands/stackRetarget.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,EAIL,KAAK,YAAY,EAClB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,KAAK,iBAAiB,EAGvB,MAAM,wBAAwB,CAAC;AAOhC,OAAO,EACL,KAAK,UAAU,EAGhB,MAAM,sBAAsB,CAAC;AAG9B,OAAO,EAIL,KAAK,aAAa,EACnB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AA8CtD,MAAM,MAAM,aAAa,GAAG,CAAC,UAAU,EAAE;IACvC,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;IACxB,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;AAEtB,MAAM,MAAM,YAAY,GAAG,CAAC,UAAU,EAAE;IACtC,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;IACxB,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;AAQtB,MAAM,WAAW,iBAAiB;IAChC,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,MAAM,CAAC,EAAE,aAAa,CAAC;IACvB,KAAK,CAAC,EAAE,YAAY,CAAC;IACrB,MAAM,CAAC,EAAE,YAAY,CAAC;IACtB,iBAAiB,CAAC,EAAE,iBAAiB,CAAC;CACvC;AAED,UAAU,sBAAsB;IAC9B,MAAM,EAAE,cAAc,CAAC;IACvB,KAAK,EAAE,UAAU,CAAC;IAClB,eAAe,EAAE,SAAS,aAAa,EAAE,CAAC;IAC1C,MAAM,EAAE,OAAO,CAAC;IAChB,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,CAAC,UAAU,EAAE,sBAAsB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CAChE;AAgyBD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,iBAAiB,GAAG,aAAa,CAuD1E"}