@telora/daemon 0.21.134 → 0.21.146

package/dist/git/merge-strategies.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Git merge strategy + worktree-recovery mechanics.
+ *
+ * The low-level merge dispatch (fast-forward / rebase / merge-commit / squash)
+ * and the failed-merge worktree recovery primitives. Split out of git/merge.ts
+ * (file-size limit); this is the LEAF of the git-merge module family -- it calls
+ * nothing in git/merge.ts, so merge.ts and git/merge-to-main.ts both import from
+ * here without a cycle. Focus-level merge ORCHESTRATION stays in merge/.
+ */
+import { type MergeResult, type MergeStrategy } from './types.js';
+/**
+ * Extract the list of conflicted files from git status.
+ * Returns an empty array if the command fails or there are no conflicts.
+ */
+export declare function extractConflictedFiles(repoPath: string): string[];
+/**
+ * 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.
+ */
+export declare function recoverDirtyMergeWorktree(repoPath: string): {
+    clean: boolean;
+    residue?: string;
+};
+/**
+ * Attempt a fast-forward-only merge.
+ * Returns a MergeResult; on failure, no abort is needed (ff-only is atomic).
+ */
+export declare function tryFastForwardMerge(repoPath: string, sourceBranch: string): MergeResult;
+/**
+ * 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).
+ */
+export declare function restoreWorktreeAfterFailedMerge(repoPath: string): void;
+/**
+ * Attempt a merge-commit merge (--no-ff).
+ * On conflict, aborts the merge and returns conflicted file details.
+ */
+export declare function tryMergeCommit(repoPath: string, sourceBranch: string, commitMessage: string): MergeResult;
+/**
+ * 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;
+//# sourceMappingURL=merge-strategies.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"merge-strategies.d.ts","sourceRoot":"","sources":["../../src/git/merge-strategies.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAc,KAAK,WAAW,EAAE,KAAK,aAAa,EAAE,MAAM,YAAY,CAAC;AAK9E;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,CAMjE;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,MAAM,GAAG;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,CA0BhG;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,MAAM,GACnB,WAAW,CASb;AAwBD;;;;;;;;;;;;GAYG;AACH,wBAAgB,+BAA+B,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAStE;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,MAAM,EACpB,aAAa,EAAE,MAAM,GACpB,WAAW,CAgCb;AAED;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,MAAM,EACpB,aAAa,EAAE,MAAM,GACpB,WAAW,CAoDb;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,aAAa,GACtB,WAAW,CAmBb"}

package/dist/git/merge-strategies.js

@@ -0,0 +1,218 @@
+/**
+ * Git merge strategy + worktree-recovery mechanics.
+ *
+ * The low-level merge dispatch (fast-forward / rebase / merge-commit / squash)
+ * and the failed-merge worktree recovery primitives. Split out of git/merge.ts
+ * (file-size limit); this is the LEAF of the git-merge module family -- it calls
+ * nothing in git/merge.ts, so merge.ts and git/merge-to-main.ts both import from
+ * here without a cycle. Focus-level merge ORCHESTRATION stays in merge/.
+ */
+import { runGitSync } from './types.js';
+import { createLogger } from '../shell/log.js';
+const log = createLogger({ module: 'CI' });
+/**
+ * Extract the list of conflicted files from git status.
+ * Returns an empty array if the command fails or there are no conflicts.
+ */
+export function extractConflictedFiles(repoPath) {
+    const statusResult = runGitSync(['diff', '--name-only', '--diff-filter=U'], repoPath);
+    if (!statusResult.success) {
+        return [];
+    }
+    return statusResult.output.split('\n').filter(Boolean);
+}
+/**
+ * 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.
+ */
+export 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).
+ */
+export 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).
+ */
+export 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.
+ */
+export 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}`);
+}
+//# sourceMappingURL=merge-strategies.js.map

package/dist/git/merge-strategies.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-strategies.js","sourceRoot":"","sources":["../../src/git/merge-strategies.ts"],"names":[],"mappings":"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"}

package/dist/git/merge-to-main.d.ts

@@ -0,0 +1,76 @@
+/**
+ * The integration -> main merge (the single write-to-main point).
+ *
+ * Split out of git/merge.ts (file-size limit). mergeIntegrationToMain is the one
+ * place refs/heads/main advances, so the fail-closed CI green-wait gate lives
+ * here. Pure CONSUMER of the git-merge family: it imports the strategy mechanics
+ * from git/merge-strategies.ts and the shared primitives from git/merge.ts, and
+ * nothing in either imports back -> no cycle.
+ */
+import type { DaemonConfig } from '../types/index.js';
+import { type MergeResult, type MergeStrategy } from './types.js';
+import { type CiStatusReader, type CiMergeGateDecision } from '../ci/ci-status.js';
+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;
+}>;
+//# sourceMappingURL=merge-to-main.d.ts.map

package/dist/git/merge-to-main.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-to-main.d.ts","sourceRoot":"","sources":["../../src/git/merge-to-main.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,EAAc,KAAK,WAAW,EAAE,KAAK,aAAa,EAAwB,MAAM,YAAY,CAAC;AAIpG,OAAO,EAGL,KAAK,cAAc,EAEnB,KAAK,mBAAmB,EACzB,MAAM,oBAAoB,CAAC;AAU5B,MAAM,WAAW,4BAA4B;IAC3C,MAAM,EAAE,YAAY,CAAC;IACrB,+DAA+D;IAC/D,OAAO,EAAE,MAAM,CAAC;IAChB,8CAA8C;IAC9C,SAAS,EAAE,MAAM,CAAC;IAClB,gDAAgD;IAChD,YAAY,EAAE,OAAO,CAAC;IACtB;;;;;OAKG;IACH,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B;;;;;;;;;;;;OAYG;IACH,WAAW,EAAE,cAAc,GAAG,SAAS,CAAC;CACzC;AAED;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC/B,2CAA2C;IAC3C,IAAI,EAAE,MAAM,CAAC;IACb,4CAA4C;IAC5C,GAAG,EAAE,MAAM,CAAC;CACb;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,4BAA4B,GACnC,OAAO,CAAC,WAAW,GAAG;IAAE,QAAQ,CAAC,EAAE,gBAAgB,CAAC;IAAC,MAAM,CAAC,EAAE,mBAAmB,CAAA;CAAE,CAAC,CAoPtF"}

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

@@ -0,0 +1,256 @@
+/**
+ * The integration -> main merge (the single write-to-main point).
+ *
+ * Split out of git/merge.ts (file-size limit). mergeIntegrationToMain is the one
+ * place refs/heads/main advances, so the fail-closed CI green-wait gate lives
+ * here. Pure CONSUMER of the git-merge family: it imports the strategy mechanics
+ * from git/merge-strategies.ts and the shared primitives from git/merge.ts, and
+ * nothing in either imports back -> no cycle.
+ */
+import { runGitSync, getMergeWorktreePath } from './types.js';
+import { withMergeLock } from './merge-lock.js';
+import { getDefaultBranch } from './branch.js';
+import { resolveRef } from './utils.js';
+import { resolveCiMergeGate, classifyCiMergeWait, } from '../ci/ci-status.js';
+import { describeWaitReachability } from '../delivery/wait-reachability.js';
+import { createLogger } from '../shell/log.js';
+import { applyMergeStrategy, recoverDirtyMergeWorktree } from './merge-strategies.js';
+import { hasOriginRemote, worktreesWithBranchCheckedOut, hasTrackedChanges, handlePushFailureWithRollback } from './merge.js';
+const log = createLogger({ module: 'CI' });
+/**
+ * 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}`);
+}
+//# sourceMappingURL=merge-to-main.js.map