@telora/daemon 0.21.134 → 0.21.144

package/dist/git/merge-to-main.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-to-main.js","sourceRoot":"","sources":["../../src/git/merge-to-main.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,EAAE,UAAU,EAAwC,oBAAoB,EAAE,MAAM,YAAY,CAAC;AACpG,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,EACL,kBAAkB,EAClB,mBAAmB,GAIpB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,wBAAwB,EAAE,MAAM,kCAAkC,CAAC;AAC5E,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,kBAAkB,EAAE,yBAAyB,EAAE,MAAM,uBAAuB,CAAC;AACtF,OAAO,EAAE,eAAe,EAAE,6BAA6B,EAAE,iBAAiB,EAAE,6BAA6B,EAAE,MAAM,YAAY,CAAC;AAE9H,MAAM,GAAG,GAAG,YAAY,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC;AA+C3C;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,sBAAsB,CACpC,MAAoC;IAEpC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,YAAY,EAAE,aAAa,GAAG,cAAc,EAAE,WAAW,EAAE,GAAG,MAAM,CAAC;IAEhG,OAAO,aAAa,CAAC,KAAK,IAAI,EAAE;QAC9B,MAAM,GAAG,GAAG,oBAAoB,CAAC,MAAM,CAAC,CAAC;QACzC,MAAM,UAAU,GAAG,gBAAgB,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QACrD,8EAA8E;QAC9E,yEAAyE;QACzE,qEAAqE;QACrE,MAAM,QAAQ,GAAG,yBAAyB,CAAC,GAAG,CAAC,CAAC;QAChD,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC;YACpB,OAAO;gBACL,OAAO,EAAE,KAAK;gBACd,KAAK,EACH,8DAA8D,MAAM,CAAC,iBAAiB,QAAQ;oBAC9F,GAAG,UAAU,gCAAgC,QAAQ,CAAC,OAAO,IAAI,SAAS,EAAE;gBAC9E,YAAY,EAAE,MAAM,CAAC,iBAAiB;gBACtC,YAAY,EAAE,UAAU;aACzB,CAAC;QACJ,CAAC;QACD,MAAM,UAAU,GAAG,eAAe,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QAEpD,uEAAuE;QACvE,uEAAuE;QACvE,qEAAqE;QACrE,uDAAuD;QACvD,IAAI,YAAY,IAAI,CAAC,UAAU,EAAE,CAAC;YAChC,OAAO;gBACL,OAAO,EAAE,KAAK;gBACd,KAAK,EAAE,8DAA8D;gBACrE,YAAY,EAAE,MAAM,CAAC,iBAAiB;gBACtC,YAAY,EAAE,UAAU;aACzB,CAAC;QACJ,CAAC;QAED,oBAAoB;QACpB,IAAI,UAAU,EAAE,CAAC;YACf,UAAU,CAAC,CAAC,OAAO,EAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC;QACnD,CAAC;QAED,uEAAuE;QACvE,uEAAuE;QACvE,2EAA2E;QAC3E,wEAAwE;QACxE,0EAA0E;QAC1E,yEAAyE;QACzE,2EAA2E;QAC3E,2EAA2E;QAC3E,IAAI,WAAW,EAAE,CAAC;YAChB,IAAI,SAAS,GAAG,EAAE,CAAC;YACnB,IAAI,CAAC;gBACH,4DAA4D;gBAC5D,qEAAqE;gBACrE,uEAAuE;gBACvE,gDAAgD;gBAChD,SAAS,GAAG,UAAU,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM,CAAC,iBAAiB,CAAC,IAAI,EAAE,CAAC;YAC1E,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,GAAG,CAAC,IAAI,CAAC,0DAA2D,GAAa,CAAC,OAAO,EAAE,CAAC,CAAC;YAC/F,CAAC;YACD,IAAI,SAAS,EAAE,CAAC;gBACd,IAAI,MAAM,GAAgB,SAAS,CAAC;gBACpC,IAAI,CAAC;oBACH,MAAM,GAAG,MAAM,WAAW,CAAC,EAAE,GAAG,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,CAAC,iBAAiB,EAAE,MAAM,EAAE,CAAC,CAAC;gBACtG,CAAC;gBAAC,OAAO,GAAG,EAAE,CAAC;oBACb,GAAG,CAAC,IAAI,CAAC,6BAA6B,SAAS,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,KAAM,GAAa,CAAC,OAAO,EAAE,CAAC,CAAC;gBAC7F,CAAC;gBACD,MAAM,IAAI,GAAG,kBAAkB,CAAC,MAAM,CAAC,CAAC;gBACxC,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;oBAClB,qEAAqE;oBACrE,oEAAoE;oBACpE,qEAAqE;oBACrE,uEAAuE;oBACvE,2DAA2D;oBAC3D,MAAM,IAAI,GAAG,mBAAmB,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;oBACpD,MAAM,MAAM,GAAG,wBAAwB,CAAC,IAAI,CAAC,CAAC;oBAC9C,GAAG,CAAC,IAAI,CACN,WAAW,MAAM,CAAC,iBAAiB,KAAK,UAAU,SAAS,SAAS,MAAM,IAAI,CAAC,MAAM,GAAG;wBACxF,QAAQ,SAAS,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,MAAM,IAAI,CAC/C,CAAC;oBACF,OAAO;wBACL,OAAO,EAAE,KAAK;wBACd,MAAM,EAAE,EAAE,GAAG,IAAI,EAAE,SAAS,EAAE,IAAI,CAAC,SAAS,EAAE,kBAAkB,EAAE,MAAM,EAAE;wBAC1E,YAAY,EAAE,MAAM,CAAC,iBAAiB;wBACtC,YAAY,EAAE,UAAU;qBACzB,CAAC;gBACJ,CAAC;gBACD,GAAG,CAAC,IAAI,CAAC,uBAAuB,SAAS,MAAM,IAAI,CAAC,MAAM,SAAS,SAAS,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC;YACjG,CAAC;QACH,CAAC;QAED,2EAA2E;QAC3E,6EAA6E;QAC7E,4EAA4E;QAC5E,2EAA2E;QAC3E,6EAA6E;QAC7E,qEAAqE;QACrE,uEAAuE;QACvE,8EAA8E;QAC9E,wEAAwE;QACxE,0EAA0E;QAC1E,qEAAqE;QACrE,MAAM,aAAa,GAAG,UAAU,CAAC,CAAC,WAAW,EAAE,UAAU,CAAC,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC;QAC7E,MAAM,aAAa,GAAG,6BAA6B,CAAC,MAAM,CAAC,QAAQ,EAAE,UAAU,EAAE,GAAG,CAAC,CAAC;QACtF,MAAM,uBAAuB,GAAG,aAAa,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,iBAAiB,CAAC,EAAE,CAAC,CAAC,CAAC;QACnF,MAAM,yBAAyB,GAAG,aAAa,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC,iBAAiB,CAAC,EAAE,CAAC,CAAC,CAAC;QAEpF,yEAAyE;QACzE,0EAA0E;QAC1E,0EAA0E;QAC1E,2EAA2E;QAC3E,mEAAmE;QACnE,yCAAyC;QACzC,MAAM,cAAc,GAAG,UAAU,CAAC,CAAC,UAAU,EAAE,UAAU,EAAE,UAAU,CAAC,EAAE,GAAG,CAAC,CAAC;QAC7E,IAAI,CAAC,cAAc,CAAC,OAAO,EAAE,CAAC;YAC5B,OAAO;gBACL,OAAO,EAAE,KAAK;gBACd,KAAK,EAAE,sBAAsB,UAAU,KAAK,cAAc,CAAC,KAAK,EAAE;gBAClE,YAAY,EAAE,MAAM,CAAC,iBAAiB;gBACtC,YAAY,EAAE,UAAU;aACzB,CAAC;QACJ,CAAC;QAED,yEAAyE;QACzE,yEAAyE;QACzE,2EAA2E;QAC3E,IAAI,UAAU,EAAE,CAAC;YACf,UAAU,CAAC,CAAC,OAAO,EAAE,WAAW,EAAE,UAAU,UAAU,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC;QAClE,CAAC;QAED,oCAAoC;QACpC,MAAM,WAAW,GAAG,UAAU,CAAC,CAAC,WAAW,EAAE,MAAM,CAAC,EAAE,GAAG,CAAC,CAAC;QAE3D,0EAA0E;QAC1E,yEAAyE;QACzE,yDAAyD;QACzD,IAAI,MAAM,GAAG,kBAAkB,CAC7B,GAAG,EACH,MAAM,CAAC,iBAAiB,EACxB,UAAU,EACV,aAAa,CACd,CAAC;QAEF,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;YACpB,OAAO;gBACL,GAAG,MAAM;gBACT,KAAK,EAAE,GAAG,MAAM,CAAC,KAAK,IAAI,eAAe,aAAa,MAAM,CAAC,iBAAiB,SAAS,UAAU,QAAQ,aAAa,GAAG;gBACzH,YAAY,EAAE,MAAM,CAAC,iBAAiB;gBACtC,YAAY,EAAE,UAAU;aACzB,CAAC;QACJ,CAAC;QAED,2BAA2B;QAC3B,MAAM,SAAS,GAAG,UAAU,CAAC,CAAC,WAAW,EAAE,MAAM,CAAC,EAAE,GAAG,CAAC,CAAC;QACzD,IAAI,CAAC,MAAM,CAAC,SAAS,IAAI,SAAS,CAAC,OAAO,EAAE,CAAC;YAC3C,MAAM,GAAG,EAAE,GAAG,MAAM,EAAE,SAAS,EAAE,SAAS,CAAC,MAAM,EAAE,CAAC;QACtD,CAAC;QACD,MAAM,UAAU,GAAG,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC;QAE3E,2EAA2E;QAC3E,4EAA4E;QAC5E,2EAA2E;QAC3E,2BAA2B;QAC3B,IAAI,UAAU,EAAE,CAAC;YACf,MAAM,SAAS,GAAG,UAAU,CAAC,CAAC,YAAY,EAAE,cAAc,UAAU,EAAE,EAAE,UAAU,CAAC,EAAE,GAAG,CAAC,CAAC;YAC1F,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,CAAC;gBACvB,OAAO;oBACL,OAAO,EAAE,KAAK;oBACd,KAAK,EAAE,qBAAqB,UAAU,yBAAyB,SAAS,CAAC,KAAK,EAAE;oBAChF,YAAY,EAAE,MAAM,CAAC,iBAAiB;oBACtC,YAAY,EAAE,UAAU;iBACzB,CAAC;YACJ,CAAC;QACH,CAAC;QAED,4CAA4C;QAC5C,IAAI,QAAsC,CAAC;QAC3C,IAAI,UAAU,IAAI,YAAY,EAAE,CAAC;YAC/B,MAAM,UAAU,GAAG,UAAU,CAAC,CAAC,MAAM,EAAE,QAAQ,EAAE,UAAU,CAAC,EAAE,GAAG,CAAC,CAAC;YAEnE,IAAI,CAAC,UAAU,CAAC,OAAO,EAAE,CAAC;gBACxB,mEAAmE;gBACnE,qEAAqE;gBACrE,yBAAyB;gBACzB,IAAI,aAAa,CAAC,OAAO,EAAE,CAAC;oBAC1B,UAAU,CAAC,CAAC,YAAY,EAAE,cAAc,UAAU,EAAE,EAAE,aAAa,CAAC,MAAM,CAAC,EAAE,GAAG,CAAC,CAAC;gBACpF,CAAC;gBACD,IAAI,WAAW,CAAC,OAAO,EAAE,CAAC;oBACxB,OAAO,6BAA6B,CAAC;wBACnC,QAAQ,EAAE,GAAG;wBACb,MAAM,EAAE,UAAU;wBAClB,WAAW,EAAE,WAAW,CAAC,MAAM;wBAC/B,SAAS,EAAE,UAAU,CAAC,KAAK;wBAC3B,YAAY,EAAE,MAAM,CAAC,iBAAiB;wBACtC,YAAY,EAAE,UAAU;qBACzB,CAAC,CAAC;gBACL,CAAC;gBACD,OAAO;oBACL,OAAO,EAAE,KAAK;oBACd,KAAK,EAAE,gDAAgD,UAAU,CAAC,KAAK,EAAE;oBACzE,YAAY,EAAE,MAAM,CAAC,iBAAiB;oBACtC,YAAY,EAAE,UAAU;iBACzB,CAAC;YACJ,CAAC;YAED,MAAM,SAAS,GAAG,UAAU,CAAC,CAAC,QAAQ,EAAE,SAAS,EAAE,QAAQ,CAAC,EAAE,GAAG,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,CAAC;YACzF,QAAQ,GAAG,EAAE,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC;QAChF,CAAC;QAED,6EAA6E;QAC7E,4EAA4E;QAC5E,4EAA4E;QAC5E,+DAA+D;QAC/D,IAAI,UAAU,EAAE,CAAC;YACf,KAAK,MAAM,EAAE,IAAI,uBAAuB,EAAE,CAAC;gBACzC,MAAM,KAAK,GAAG,UAAU,CAAC,CAAC,OAAO,EAAE,QAAQ,EAAE,UAAU,CAAC,EAAE,EAAE,CAAC,CAAC;gBAC9D,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC;oBACnB,GAAG,CAAC,IAAI,CACN,iBAAiB,UAAU,mCAAmC,EAAE,KAAK,KAAK,CAAC,KAAK,EAAE,CACnF,CAAC;gBACJ,CAAC;YACH,CAAC;YACD,yEAAyE;YACzE,0EAA0E;YAC1E,qEAAqE;YACrE,qDAAqD;YACrD,KAAK,MAAM,EAAE,IAAI,yBAAyB,EAAE,CAAC;gBAC3C,GAAG,CAAC,IAAI,CACN,iBAAiB,UAAU,OAAO,UAAU,iBAAiB,EAAE,mBAAmB;oBAClF,+EAA+E;oBAC/E,GAAG,UAAU,wEAAwE;oBACrF,gBAAgB,EAAE,iBAAiB,UAAU,iBAAiB,CAC/D,CAAC;YACJ,CAAC;QACH,CAAC;QAED,MAAM,MAAM,GAAG,YAAY,CAAC,CAAC,CAAC,mBAAmB,CAAC,CAAC,CAAC,QAAQ,CAAC;QAC7D,GAAG,CAAC,IAAI,CAAC,gBAAgB,MAAM,IAAI,MAAM,CAAC,iBAAiB,SAAS,UAAU,EAAE,CAAC,CAAC;QAClF,OAAO;YACL,OAAO,EAAE,IAAI;YACb,SAAS,EAAE,MAAM,CAAC,SAAS;YAC3B,WAAW,EAAE,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS;YACjE,QAAQ;SACT,CAAC;IACJ,CAAC,EAAE,0BAA0B,SAAS,EAAE,CAAC,CAAC;AAC5C,CAAC"}

package/dist/git/merge.d.ts

@@ -5,9 +5,8 @@
  * push failure handling with rollback, and stash management.
  */
 import type { DaemonConfig, MergeBackResult } from '../types/index.js';
-import { type MergeResult, type MergeStrategy } from './types.js';
+import { type MergeResult } from './types.js';
 import { type CorruptionDetails } from './merge-lock.js';
-import { type CiStatusReader, type CiMergeGateDecision } from '../ci/ci-status.js';
 /**
  * Classify the post-merge sha observation for a merge that already succeeded.
  * Given whether a commit sha was already captured (e.g. from a --no-ff merge),
@@ -32,6 +31,32 @@ export declare function classifyMergeShaObservation(alreadyHasCommitSha: boolean
     commitSha?: string;
     shaUnobserved?: boolean;
 };
+/**
+ * Returns true if the repo at repoPath has an 'origin' remote configured.
+ * Used to gate all network operations so the daemon works in remote-less repos.
+ */
+export declare function hasOriginRemote(repoPath: string): boolean;
+/**
+ * Parse `git worktree list --porcelain` to find worktrees -- other than
+ * `excludePath` -- that currently have `branch` ATTACHED (a non-detached
+ * checkout). Returns absolute worktree paths.
+ *
+ * Used by the integration->main merge to locate any worktree that holds
+ * `main` (typically the daemon's primary repoPath, where a developer keeps
+ * main checked out) so it can be re-synced after the ref is advanced
+ * out-of-band.
+ */
+export declare function worktreesWithBranchCheckedOut(repoPath: string, branch: string, excludePath: string): string[];
+/**
+ * True when a worktree has uncommitted TRACKED changes (staged or unstaged
+ * modifications/additions/deletions). Untracked files (porcelain "?? ") do NOT
+ * count: `git reset --hard` preserves untracked files, so a worktree whose only
+ * dirt is untracked scratch is still safe to re-sync after an out-of-band ref
+ * advance -- and MUST be, because a dev box almost always carries stray
+ * untracked files, and skipping the re-sync leaves main advanced over a stale
+ * working tree (the phantom diff that confuses downstream tooling like /sync).
+ */
+export declare function hasTrackedChanges(worktreePath: string): boolean;
 interface PushFailureRollbackParams {
     repoPath: string;
     branch: string;
@@ -77,22 +102,6 @@ export declare function handlePushFailureWithRollback(params: PushFailureRollbac
  * became a pathspec).
  */
 export declare function handleUntrackedFilesBlockingMerge(repoPath: string, errorOutput: string): boolean;
-/**
- * Attempt a squash merge: stages all changes from the source branch as a
- * single commit on the current branch.
- *
- * 1. `git merge --squash <sourceBranch>` -- stages all diffs without committing
- * 2. `git commit -m <commitMessage>` -- creates a single squashed commit
- * 3. Captures the resulting commit SHA via `git rev-parse HEAD`
- *
- * On conflict, aborts the merge and returns conflicted file details.
- */
-export declare function trySquashMerge(repoPath: string, sourceBranch: string, commitMessage: string): MergeResult;
-/**
- * Dispatch to the appropriate merge strategy helper.
- * For 'merge-commit', tries fast-forward first, then falls back to --no-ff.
- */
-export declare function applyMergeStrategy(repoPath: string, sourceBranch: string, targetBranch: string, strategy: MergeStrategy): MergeResult;
 export interface MergeToIntegrationParams {
     config: DaemonConfig;
     branchName: string;
@@ -114,69 +123,6 @@ export interface MergeToIntegrationParams {
  * Serialized via the merge lock to prevent concurrent checkout races.
  */
 export declare function mergeToIntegration(params: MergeToIntegrationParams): Promise<MergeResult>;
-export interface MergeIntegrationToMainParams {
-    config: DaemonConfig;
-    /** Focus ID for log attribution / push-failure escalations. */
-    focusId: string;
-    /** Focus name for logging/commit messages. */
-    focusName: string;
-    /** Whether to also push main to remote (CD). */
-    pushToRemote: boolean;
-    /**
-     * Merge strategy honored when integrating into main. Defaults to
-     * `merge-commit` (which itself attempts fast-forward first, then falls
-     * back to `--no-ff`) so legacy callers that omit the field get the
-     * pre-existing behavior.
-     */
-    mergeStrategy?: MergeStrategy;
-    /**
-     * The green-wait CI status reader, evaluated at THIS write point -- the single
-     * place `refs/heads/main` is advanced -- so the gate governs every daemon route
-     * to main identically, not whichever call path performed the merge. REQUIRED so
-     * no caller can advance main without making the CI decision explicit:
-     *   - a reader (`resolveCiStatusReader()`) => the merged SHA's status is read
-     *     and `resolveCiMergeGate` decides; pending/red/unknown HOLD (fail-closed),
-     *     green proceeds. On a hold the ref is NOT advanced and the result carries
-     *     `ciHeld` (not an error -- nothing was written, nothing to roll back).
-     *   - `undefined` => an explicit, visible opt-out (used by tests and legacy
-     *     callers with no CI source); the gate is skipped and the merge proceeds
-     *     exactly as before.
-     */
-    getCiStatus: CiStatusReader | undefined;
-}
-/**
- * Resolved remote name + URL describing the push target for a CD push.
- * Exported only so the focus-completion / focus-team-lifecycle log lines
- * can surface the remote without re-querying git.
- */
-export interface PushedRemoteInfo {
-    /** Remote name (always `origin` today). */
-    name: string;
-    /** Remote URL as configured in the repo. */
-    url: string;
-}
-/**
- * Merge the integration branch into the default (main) branch.
- *
- * Called when a focus completes with CI enabled. Optionally pushes
- * to remote when CD is also enabled. The push step is gated by
- * `pushToRemote` and only runs when an `origin` remote is configured.
- *
- * Uses the merge worktree and merge lock (same as mergeToIntegration)
- * to avoid concurrent merge conflicts. The merge worktree checks main out
- * DETACHED and advances refs/heads/main via `git update-ref`, so the merge
- * completes even when main is attached in the daemon's primary worktree
- * (where `git checkout main` would fail with "'main' is already used by
- * worktree"). Clean worktrees holding main are re-synced afterward.
- *
- * The result's `pushedTo` field is set only when CD push happened and
- * succeeded. Callers can read it to emit a focus-attributed log line
- * with the resolved remote name + URL.
- */
-export declare function mergeIntegrationToMain(params: MergeIntegrationToMainParams): Promise<MergeResult & {
-    pushedTo?: PushedRemoteInfo;
-    ciHeld?: CiMergeGateDecision;
-}>;
 export interface MergeBackFromIntegrationParams {
     /** Path to the focus/delivery worktree. */
     worktreePath: string;

package/dist/git/merge.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"merge.d.ts","sourceRoot":"","sources":["../../src/git/merge.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"merge.d.ts","sourceRoot":"","sources":["../../src/git/merge.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACvE,OAAO,EAAc,KAAK,WAAW,EAAwB,MAAM,YAAY,CAAC;AAChF,OAAO,EAAyC,KAAK,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAahG;;;;;;;;;;;;;GAaG;AACH,wBAAgB,2BAA2B,CACzC,mBAAmB,EAAE,OAAO,EAC5B,SAAS,EAAE;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,EAC/C,WAAW,EAAE;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAChD;IAAE,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,aAAa,CAAC,EAAE,OAAO,CAAA;CAAE,CAOjD;AAID;;;GAGG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAEzD;AAED;;;;;;;;;GASG;AACH,wBAAgB,6BAA6B,CAC3C,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,GAClB,MAAM,EAAE,CAoBV;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAI/D;AAYD,UAAU,yBAAyB;IACjC,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,iBAAiB,CAAC,EAAE,CAAC,OAAO,EAAE,iBAAiB,KAAK,IAAI,CAAC;CAC1D;AAED;;;GAGG;AACH,wBAAgB,6BAA6B,CAAC,MAAM,EAAE,yBAAyB,GAAG,WAAW,CAoD5F;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,iCAAiC,CAC/C,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,GAClB,OAAO,CAmCT;AAKD,MAAM,WAAW,wBAAwB;IACvC,MAAM,EAAE,YAAY,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,iBAAiB,CAAC,EAAE,CAAC,OAAO,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,oBAAoB,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAC;CAC9G;AAED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,wBAAwB,GAC/B,OAAO,CAAC,WAAW,CAAC,CAyKtB;AAKD,MAAM,WAAW,8BAA8B;IAC7C,2CAA2C;IAC3C,YAAY,EAAE,MAAM,CAAC;IACrB,4DAA4D;IAC5D,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,wBAAwB,CAC5C,MAAM,EAAE,8BAA8B,GACrC,OAAO,CAAC,eAAe,CAAC,CAgE1B"}

package/dist/git/merge.js

@@ -8,12 +8,9 @@ import { resolve } from 'node:path';
 import { existsSync } from 'node:fs';
 import { runGitSync, getMergeWorktreePath } from './types.js';
 import { withMergeLock, markIntegrationCorrupt } from './merge-lock.js';
-import { getDefaultBranch } from './branch.js';
-import { resolveRef } from './utils.js';
 import { withRetry, healthEvents } from '@telora/daemon-core';
-import { resolveCiMergeGate, classifyCiMergeWait, } from '../ci/ci-status.js';
-import { describeWaitReachability } from '../delivery/wait-reachability.js';
 import { createLogger } from '../shell/log.js';
+import { extractConflictedFiles, recoverDirtyMergeWorktree, tryFastForwardMerge, tryMergeCommit, } from './merge-strategies.js';
 const log = createLogger({ module: 'CI' });
 /**
  * Classify the post-merge sha observation for a merge that already succeeded.
@@ -43,7 +40,7 @@ export function classifyMergeShaObservation(alreadyHasCommitSha, shaResult, preM
  * Returns true if the repo at repoPath has an 'origin' remote configured.
  * Used to gate all network operations so the daemon works in remote-less repos.
  */
-function hasOriginRemote(repoPath) {
+export function hasOriginRemote(repoPath) {
     return runGitSync(['remote', 'get-url', 'origin'], repoPath, { timeoutMs: 3_000 }).success;
 }
 /**
@@ -56,7 +53,7 @@ function hasOriginRemote(repoPath) {
  * main checked out) so it can be re-synced after the ref is advanced
  * out-of-band.
  */
-function worktreesWithBranchCheckedOut(repoPath, branch, excludePath) {
+export function worktreesWithBranchCheckedOut(repoPath, branch, excludePath) {
     const list = runGitSync(['worktree', 'list', '--porcelain'], repoPath);
     if (!list.success)
         return [];
@@ -89,23 +86,12 @@ function worktreesWithBranchCheckedOut(repoPath, branch, excludePath) {
  * untracked files, and skipping the re-sync leaves main advanced over a stale
  * working tree (the phantom diff that confuses downstream tooling like /sync).
  */
-function hasTrackedChanges(worktreePath) {
+export function hasTrackedChanges(worktreePath) {
     const st = runGitSync(['status', '--porcelain'], worktreePath);
     if (!st.success)
         return true; // can't determine -> treat as unsafe to reset
     return st.output.split('\n').some(line => line.trim() !== '' && !line.startsWith('??'));
 }
-/**
- * Extract the list of conflicted files from git status.
- * Returns an empty array if the command fails or there are no conflicts.
- */
-function extractConflictedFiles(repoPath) {
-    const statusResult = runGitSync(['diff', '--name-only', '--diff-filter=U'], repoPath);
-    if (!statusResult.success) {
-        return [];
-    }
-    return statusResult.output.split('\n').filter(Boolean);
-}
 /**
  * Hard-reset the current branch to a given ref.
  * Returns whether the rollback succeeded.
@@ -220,200 +206,6 @@ export function handleUntrackedFilesBlockingMerge(repoPath, errorOutput) {
     }
     return true;
 }
-/**
- * Recover a merge worktree left dirty by an EARLIER failed merge, BEFORE the next
- * merge runs, so an already-wedged worktree heals itself with no operator. The
- * residue is detected by a non-empty `git status --porcelain` (staged / unstaged
- * / untracked) -- deliberately NOT by MERGE_HEAD: the 2026-08-18 wedge held 85
- * staged files with MERGE_HEAD already cleared and AUTO_MERGE present, so a
- * MERGE_HEAD probe would miss it. Any residue is discarded via
- * restoreWorktreeAfterFailedMerge, which moves no branch ref -- focus-branch
- * commits are untouched. Merge-worktree only; idempotent (a clean worktree is a
- * no-op).
- *
- * CONFIRMS the outcome rather than recovering-and-hoping: it re-reads
- * `git status --porcelain` AFTER any recovery and reports whether the worktree
- * is now clean. `clean` is true only when the worktree is empty at exit -- it
- * was already clean, or the recovery restored it. It is false when residue
- * survived the recovery attempt, or when status itself could not be read (so
- * cleanliness cannot be vouched for). A merge must REFUSE to run when this
- * returns clean:false: running against an unconfirmed worktree is exactly the
- * wedge this guard exists to prevent.
- */
-function recoverDirtyMergeWorktree(repoPath) {
-    const status = runGitSync(['status', '--porcelain'], repoPath);
-    if (!status.success) {
-        // Can't read status -> can't confirm clean. Treat as unsafe to merge.
-        return { clean: false, residue: `git status failed: ${status.error}` };
-    }
-    if (status.output.trim().length === 0) {
-        return { clean: true };
-    }
-    log.warn(`[merge] Merge worktree was left dirty by an earlier failed merge ` +
-        `(git status --porcelain non-empty); recovering it before the next merge ` +
-        `so an already-wedged worktree does not require an operator.`);
-    restoreWorktreeAfterFailedMerge(repoPath);
-    // Confirm the recovery actually cleaned the worktree before we let a merge run.
-    const after = runGitSync(['status', '--porcelain'], repoPath);
-    if (after.success && after.output.trim().length === 0) {
-        return { clean: true };
-    }
-    return {
-        clean: false,
-        residue: after.success ? after.output.trim() : `git status failed: ${after.error}`,
-    };
-}
-/**
- * Attempt a fast-forward-only merge.
- * Returns a MergeResult; on failure, no abort is needed (ff-only is atomic).
- */
-function tryFastForwardMerge(repoPath, sourceBranch) {
-    const ffResult = runGitSync(['merge', '--ff-only', sourceBranch], repoPath);
-    if (ffResult.success) {
-        return { success: true };
-    }
-    return {
-        success: false,
-        error: `Fast-forward merge not possible: ${ffResult.error}`,
-    };
-}
-/**
- * Attempt a rebase merge.
- * On conflict, aborts the rebase and returns conflicted file details.
- */
-function tryRebaseMerge(repoPath, sourceBranch) {
-    const rebaseResult = runGitSync(['rebase', sourceBranch], repoPath);
-    if (rebaseResult.success) {
-        return { success: true };
-    }
-    const conflictedFiles = extractConflictedFiles(repoPath);
-    runGitSync(['rebase', '--abort'], repoPath);
-    return {
-        success: false,
-        error: `Rebase failed: ${conflictedFiles.length} file(s) conflicted`,
-        conflictedFiles,
-    };
-}
-/**
- * Restore the merge worktree to the clean commit + index it had before a failed
- * merge attempt. The conflict branches abort explicitly; this covers EVERY OTHER
- * failure -- a commit-msg hook rejection (leaves MERGE_HEAD set + staged), a
- * squash that staged changes with no MERGE_HEAD, or an unrecognised error --
- * which git otherwise leaves as a staged, uncommitted merge that NOTHING clears.
- * Because the merge worktree is shared by every focus in the product, that
- * residue would fail the next focus's merge too; clearing it here contains one
- * focus's failure to that focus. It discards ONLY the failed-merge residue --
- * `git merge --abort` (or, when no merge is in progress, `reset --hard HEAD`)
- * moves no branch ref, so commits on any focus branch are untouched. Only ever
- * called against the merge worktree (never a developer checkout).
- */
-function restoreWorktreeAfterFailedMerge(repoPath) {
-    // MERGE_HEAD present (a --no-ff merge that stopped, e.g. hook-rejected) aborts
-    // cleanly. --squash stages changes WITHOUT a MERGE_HEAD, so abort is a no-op
-    // there; fall back to a hard reset + untracked clean to drop the staged residue.
-    const abort = runGitSync(['merge', '--abort'], repoPath);
-    if (!abort.success) {
-        runGitSync(['reset', '--hard', 'HEAD'], repoPath);
-        runGitSync(['clean', '-fd'], repoPath);
-    }
-}
-/**
- * Attempt a merge-commit merge (--no-ff).
- * On conflict, aborts the merge and returns conflicted file details.
- */
-function tryMergeCommit(repoPath, sourceBranch, commitMessage) {
-    const mergeResult = runGitSync(['merge', sourceBranch, '--no-ff', '-m', commitMessage], repoPath);
-    if (mergeResult.success) {
-        return { success: true };
-    }
-    const isConflict = mergeResult.error.includes('CONFLICT') ||
-        mergeResult.error.includes('Automatic merge failed') ||
-        mergeResult.output.includes('CONFLICT');
-    if (isConflict) {
-        const conflictedFiles = extractConflictedFiles(repoPath);
-        runGitSync(['merge', '--abort'], repoPath);
-        return {
-            success: false,
-            error: `Merge conflict: ${conflictedFiles.length} file(s) conflicted`,
-            conflictedFiles,
-        };
-    }
-    // Non-conflict failure (hook rejection / unrecognised error) still leaves a
-    // staged, uncommitted merge behind -- restore the worktree so it does not
-    // poison the next focus's merge.
-    restoreWorktreeAfterFailedMerge(repoPath);
-    return {
-        success: false,
-        error: `Merge failed: ${mergeResult.error}`,
-    };
-}
-/**
- * Attempt a squash merge: stages all changes from the source branch as a
- * single commit on the current branch.
- *
- * 1. `git merge --squash <sourceBranch>` -- stages all diffs without committing
- * 2. `git commit -m <commitMessage>` -- creates a single squashed commit
- * 3. Captures the resulting commit SHA via `git rev-parse HEAD`
- *
- * On conflict, aborts the merge and returns conflicted file details.
- */
-export function trySquashMerge(repoPath, sourceBranch, commitMessage) {
-    const squashResult = runGitSync(['merge', '--squash', sourceBranch], repoPath);
-    if (!squashResult.success) {
-        const isConflict = squashResult.error.includes('CONFLICT') ||
-            squashResult.error.includes('Automatic merge failed') ||
-            squashResult.output.includes('CONFLICT');
-        if (isConflict) {
-            const conflictedFiles = extractConflictedFiles(repoPath);
-            runGitSync(['merge', '--abort'], repoPath);
-            return {
-                success: false,
-                error: `Squash merge conflict: ${conflictedFiles.length} file(s) conflicted`,
-                conflictedFiles,
-            };
-        }
-        // Non-conflict squash failure leaves the staged squash residue behind
-        // (no MERGE_HEAD) -- restore so it does not poison the next focus's merge.
-        restoreWorktreeAfterFailedMerge(repoPath);
-        return {
-            success: false,
-            error: `Squash merge failed: ${squashResult.error}`,
-        };
-    }
-    // Commit the squashed changes
-    const commitResult = runGitSync(['commit', '-m', commitMessage], repoPath);
-    if (!commitResult.success) {
-        // The squash staged everything; a failed commit (e.g. a rejecting hook)
-        // leaves it staged. Restore so the residue does not wedge the next merge.
-        restoreWorktreeAfterFailedMerge(repoPath);
-        return {
-            success: false,
-            error: `Squash merge commit failed: ${commitResult.error}`,
-        };
-    }
-    // Capture the resulting commit SHA
-    const shaResult = runGitSync(['rev-parse', 'HEAD'], repoPath);
-    const commitSha = shaResult.success ? shaResult.output : undefined;
-    return { success: true, commitSha };
-}
-/**
- * Dispatch to the appropriate merge strategy helper.
- * For 'merge-commit', tries fast-forward first, then falls back to --no-ff.
- */
-export function applyMergeStrategy(repoPath, sourceBranch, targetBranch, strategy) {
-    if (strategy === 'fast-forward') {
-        return tryFastForwardMerge(repoPath, sourceBranch);
-    }
-    if (strategy === 'rebase') {
-        return tryRebaseMerge(repoPath, sourceBranch);
-    }
-    // 'merge-commit': try ff first, fall back to --no-ff
-    const ffResult = tryFastForwardMerge(repoPath, sourceBranch);
-    if (ffResult.success) {
-        return ffResult;
-    }
-    return tryMergeCommit(repoPath, sourceBranch, `Advance ${targetBranch} to ${sourceBranch}`);
-}
 /**
  * Merge an agent branch into the integration branch.
  *
@@ -566,242 +358,6 @@ export function mergeToIntegration(params) {
         };
     }, `mergeToIntegration:${deliveryName}`);
 }
-/**
- * Merge the integration branch into the default (main) branch.
- *
- * Called when a focus completes with CI enabled. Optionally pushes
- * to remote when CD is also enabled. The push step is gated by
- * `pushToRemote` and only runs when an `origin` remote is configured.
- *
- * Uses the merge worktree and merge lock (same as mergeToIntegration)
- * to avoid concurrent merge conflicts. The merge worktree checks main out
- * DETACHED and advances refs/heads/main via `git update-ref`, so the merge
- * completes even when main is attached in the daemon's primary worktree
- * (where `git checkout main` would fail with "'main' is already used by
- * worktree"). Clean worktrees holding main are re-synced afterward.
- *
- * The result's `pushedTo` field is set only when CD push happened and
- * succeeded. Callers can read it to emit a focus-attributed log line
- * with the resolved remote name + URL.
- */
-export function mergeIntegrationToMain(params) {
-    const { config, focusName, pushToRemote, mergeStrategy = 'merge-commit', getCiStatus } = params;
-    return withMergeLock(async () => {
-        const mwt = getMergeWorktreePath(config);
-        const mainBranch = getDefaultBranch(config.repoPath);
-        // Same self-heal as mergeToIntegration: this route shares the merge worktree,
-        // so an earlier failed merge's residue would break the detached checkout
-        // below. REFUSE if the worktree cannot be CONFIRMED clean afterward.
-        const recovery = recoverDirtyMergeWorktree(mwt);
-        if (!recovery.clean) {
-            return {
-                success: false,
-                error: `Merge worktree could not be confirmed clean before merging ${config.integrationBranch} into ` +
-                    `${mainBranch}; residue survived recovery: ${recovery.residue ?? 'unknown'}`,
-                sourceBranch: config.integrationBranch,
-                targetBranch: mainBranch,
-            };
-        }
-        const withRemote = hasOriginRemote(config.repoPath);
-        // Fail early when a CD push was requested but no remote is configured.
-        // Returning a push-failure result (rather than silently skipping) lets
-        // the caller's shouldFileCdPushEscalation check fire so the operator
-        // sees a visible escalation instead of a silent no-op.
-        if (pushToRemote && !withRemote) {
-            return {
-                success: false,
-                error: 'Push failed: no origin remote configured for this repository',
-                sourceBranch: config.integrationBranch,
-                targetBranch: mainBranch,
-            };
-        }
-        // Fetch latest refs
-        if (withRemote) {
-            runGitSync(['fetch', 'origin'], config.repoPath);
-        }
-        // ── Green-wait gate (the single write-to-main point) ────────────────
-        // This is the ONE place refs/heads/main advances, so the CI verdict is
-        // evaluated HERE -- not in whichever completion/eager code path called us.
-        // Every daemon route to main inherits the same fail-closed gate. With a
-        // reader wired, the SHA about to reach main (the integration tip) must be
-        // GREEN; pending/red/unknown HOLD without advancing the ref (nothing was
-        // written -- no rollback, and the caller reports a hold, never an error or
-        // an escalation). An explicit `undefined` reader skips the gate (opt-out).
-        if (getCiStatus) {
-            let mergedSha = '';
-            try {
-                // resolveRef checks the git exit status, so an unresolvable
-                // integrationBranch yields null rather than git's stdout echo of the
-                // branch NAME -- which would otherwise reach the CI gate as if it were
-                // a commit SHA (echo-into-SHA-field bug class).
-                mergedSha = resolveRef(config.repoPath, config.integrationBranch) ?? '';
-            }
-            catch (err) {
-                log.warn(`Could not resolve integration tip SHA for the CI gate: ${err.message}`);
-            }
-            if (mergedSha) {
-                let status = 'unknown';
-                try {
-                    status = await getCiStatus({ sha: mergedSha, integrationBranch: config.integrationBranch, config });
-                }
-                catch (err) {
-                    log.warn(`CI status read failed for ${mergedSha.slice(0, 12)}: ${err.message}`);
-                }
-                const gate = resolveCiMergeGate(status);
-                if (!gate.proceed) {
-                    // Classify whether this hold can still fire: a settled RED result on
-                    // this (unchanged) sha never re-evaluates without a NEW commit -- a
-                    // stall that reads as patience -- whereas a pending run can still be
-                    // finished by the CI runner. Record the distinction on the hold and in
-                    // the log so a stall is legible from the daemon log alone.
-                    const wait = classifyCiMergeWait(status, mergedSha);
-                    const marker = describeWaitReachability(wait);
-                    log.info(`Holding ${config.integrationBranch}->${mainBranch} for "${focusName}": ${gate.reason} ` +
-                        `(sha ${mergedSha.slice(0, 12)}) [${marker}].`);
-                    return {
-                        success: false,
-                        ciHeld: { ...gate, reachable: wait.reachable, reachabilityReason: marker },
-                        sourceBranch: config.integrationBranch,
-                        targetBranch: mainBranch,
-                    };
-                }
-                log.info(`CI gate passed for "${focusName}": ${gate.reason} (sha ${mergedSha.slice(0, 12)}).`);
-            }
-        }
-        // Record where main was BEFORE we touch anything, so push failure can roll
-        // the ref back, and classify any worktrees that currently have main attached
-        // (the daemon's primary repoPath usually keeps main checked out). Advancing
-        // the ref out-of-band leaves such a worktree with a stale tree, so after a
-        // successful merge we re-sync every worktree that has NO tracked uncommitted
-        // changes -- `git reset --hard` restores tracked files and preserves
-        // untracked ones, so a worktree dirty only with untracked scratch (the
-        // common dev-box state) is still safe to sync. Worktrees with tracked WIP are
-        // left untouched (never clobber a developer's edits) but flagged loudly
-        // afterward. Classification MUST happen before the advance: afterward the
-        // phantom diff masquerades as tracked changes and defeats the check.
-        const mainRefBefore = runGitSync(['rev-parse', mainBranch], config.repoPath);
-        const mainWorktrees = worktreesWithBranchCheckedOut(config.repoPath, mainBranch, mwt);
-        const resyncableMainWorktrees = mainWorktrees.filter(wt => !hasTrackedChanges(wt));
-        const trackedDirtyMainWorktrees = mainWorktrees.filter(wt => hasTrackedChanges(wt));
-        // Detached checkout of main's tip in the merge worktree. We deliberately
-        // do NOT attach the main branch (`git checkout main`): main is frequently
-        // checked out in the daemon's primary worktree, and git refuses to attach
-        // the same branch in two worktrees ("'main' is already used by worktree").
-        // Detaching lets us build the merge result and advance the ref via
-        // update-ref, which bypasses that guard.
-        const checkoutResult = runGitSync(['checkout', '--detach', mainBranch], mwt);
-        if (!checkoutResult.success) {
-            return {
-                success: false,
-                error: `Failed to checkout ${mainBranch}: ${checkoutResult.error}`,
-                sourceBranch: config.integrationBranch,
-                targetBranch: mainBranch,
-            };
-        }
-        // Bring the detached HEAD up to the latest remote main (best-effort ff).
-        // If remote main has diverged, a later push would be rejected and rolled
-        // back; we don't merge it here to keep the integration->main result clean.
-        if (withRemote) {
-            runGitSync(['merge', '--ff-only', `origin/${mainBranch}`], mwt);
-        }
-        // Save pre-merge state for rollback
-        const preMergeRef = runGitSync(['rev-parse', 'HEAD'], mwt);
-        // Dispatch to the requested strategy. The strategy helpers operate on the
-        // merge worktree's current HEAD (here a detached HEAD at main's tip), so
-        // they work identically whether or not main is attached.
-        let result = applyMergeStrategy(mwt, config.integrationBranch, mainBranch, mergeStrategy);
-        if (!result.success) {
-            return {
-                ...result,
-                error: `${result.error ?? 'Unknown error'} (merging ${config.integrationBranch} into ${mainBranch} via ${mergeStrategy})`,
-                sourceBranch: config.integrationBranch,
-                targetBranch: mainBranch,
-            };
-        }
-        // Capture merge commit SHA
-        const shaResult = runGitSync(['rev-parse', 'HEAD'], mwt);
-        if (!result.commitSha && shaResult.success) {
-            result = { ...result, commitSha: shaResult.output };
-        }
-        const newMainSha = shaResult.success ? shaResult.output : result.commitSha;
-        // Advance refs/heads/main out-of-band to the merge result. update-ref is a
-        // plumbing command without the checked-out-branch guard that `git checkout`
-        // and `git branch -f` enforce, so this succeeds even when main is attached
-        // in the primary worktree.
-        if (newMainSha) {
-            const updateRef = runGitSync(['update-ref', `refs/heads/${mainBranch}`, newMainSha], mwt);
-            if (!updateRef.success) {
-                return {
-                    success: false,
-                    error: `Failed to advance ${mainBranch} ref to merge result: ${updateRef.error}`,
-                    sourceBranch: config.integrationBranch,
-                    targetBranch: mainBranch,
-                };
-            }
-        }
-        // Push main to remote (gated on CD opt-in).
-        let pushedTo;
-        if (withRemote && pushToRemote) {
-            const pushResult = runGitSync(['push', 'origin', mainBranch], mwt);
-            if (!pushResult.success) {
-                // Roll the main ref back to its pre-merge value before the generic
-                // rollback (which resets the detached HEAD and marks corruption on a
-                // failed rollback) runs.
-                if (mainRefBefore.success) {
-                    runGitSync(['update-ref', `refs/heads/${mainBranch}`, mainRefBefore.output], mwt);
-                }
-                if (preMergeRef.success) {
-                    return handlePushFailureWithRollback({
-                        repoPath: mwt,
-                        branch: mainBranch,
-                        preMergeRef: preMergeRef.output,
-                        pushError: pushResult.error,
-                        sourceBranch: config.integrationBranch,
-                        targetBranch: mainBranch,
-                    });
-                }
-                return {
-                    success: false,
-                    error: `Push failed (no pre-merge ref for rollback): ${pushResult.error}`,
-                    sourceBranch: config.integrationBranch,
-                    targetBranch: mainBranch,
-                };
-            }
-            const urlResult = runGitSync(['remote', 'get-url', 'origin'], mwt, { timeoutMs: 3_000 });
-            pushedTo = { name: 'origin', url: urlResult.success ? urlResult.output : '' };
-        }
-        // Re-sync worktrees that held main and had no tracked changes before the ref
-        // advance, so the out-of-band update leaves no phantom diff. `reset --hard`
-        // restores tracked files to the new main and leaves untracked files intact,
-        // so this is safe for both clean and untracked-only worktrees.
-        if (newMainSha) {
-            for (const wt of resyncableMainWorktrees) {
-                const reset = runGitSync(['reset', '--hard', newMainSha], wt);
-                if (!reset.success) {
-                    log.warn(`[CI] Advanced ${mainBranch} but failed to re-sync worktree ${wt}: ${reset.error}`);
-                }
-            }
-            // Worktrees with tracked WIP can't be reset without clobbering work, but
-            // leaving them silently stale is exactly what confused downstream tooling
-            // (the /sync that committed a stale tree). Flag each loudly with the
-            // recovery command so the staleness is never silent.
-            for (const wt of trackedDirtyMainWorktrees) {
-                log.warn(`[CI] Advanced ${mainBranch} to ${newMainSha} but worktree ${wt} has uncommitted ` +
-                    `TRACKED changes -- left unsynced to avoid clobbering work. Its tree now lags ` +
-                    `${mainBranch} and will show a phantom diff (e.g. to /sync). Commit or stash there, ` +
-                    `then 'git -C ${wt} reset --hard ${mainBranch}' to reconcile.`);
-            }
-        }
-        const action = pushToRemote ? 'merged and pushed' : 'merged';
-        log.info(`Successfully ${action} ${config.integrationBranch} into ${mainBranch}`);
-        return {
-            success: true,
-            commitSha: result.commitSha,
-            preMergeRef: preMergeRef.success ? preMergeRef.output : undefined,
-            pushedTo,
-        };
-    }, `mergeIntegrationToMain:${focusName}`);
-}
 /**
  * Merge the latest integration HEAD into the current branch of a worktree.
  *