dorfl 0.14.2 → 0.15.0

package/src/start.ts

@@ -5,8 +5,10 @@ import type {SurfaceToNeedsAttentionResult} from './needs-attention.js';
 import {
 	branchAheadOfArbiter,
 	rebaseContinuedBranchOntoMain,
-	pushContinuedBranchWithStaleLeaseRetry,
+	continueRebaseSentence,
+	type ContinueRebaseFailure,
 } from './continue-branch.js';
+import {refWrite} from './ref-write.js';
 import {runAsync, type RunResult} from './git.js';
 import {workFolderRel} from './work-layout.js';
 import {workBranchRef, parseWorkBranchRef} from './slug-namespace.js';
@@ -368,7 +370,14 @@ async function startFromBacklog(params: {
 	// includes the claim).
 	const switched = await switchToWorkBranch({slug, arbiter, cwd, env, note});
 	if (switched.rebaseConflict) {
-		return continueConflictResult({slug, arbiter, cwd, env, note});
+		return continueConflictResult({
+			slug,
+			arbiter,
+			cwd,
+			failure: switched.rebaseFailure,
+			env,
+			note,
+		});
 	}
 	if (switched.pushFailure !== undefined) {
 		return continuePushFailureResult({
@@ -396,6 +405,7 @@ async function continueConflictResult(params: {
 	slug: string;
 	arbiter: string;
 	cwd: string;
+	failure: ContinueRebaseFailure | undefined;
 	env: NodeJS.ProcessEnv | undefined;
 	note: (m: string) => void;
 }): Promise<StartResult> {
@@ -405,7 +415,8 @@ async function continueConflictResult(params: {
 	}
 	const message =
 		`Could not continue '${params.slug}': the kept work branch did not rebase ` +
-		`cleanly onto ${params.arbiter}/main; marked stuck on its per-item lock ` +
+		`cleanly onto ${params.arbiter}/main ` +
+		`(${continueRebaseSentence(workBranchRef('task', params.slug), params.failure)}); marked stuck on its per-item lock ` +
 		'(surfaced by status). Resolve against the latest main, or `requeue --reset` ' +
 		'to discard and start fresh.';
 	return {
@@ -479,7 +490,14 @@ async function startFromNeedsAttention(params: {
 
 	const switched = await switchToWorkBranch({slug, arbiter, cwd, env, note});
 	if (switched.rebaseConflict) {
-		return continueConflictResult({slug, arbiter, cwd, env, note});
+		return continueConflictResult({
+			slug,
+			arbiter,
+			cwd,
+			failure: switched.rebaseFailure,
+			env,
+			note,
+		});
 	}
 	if (switched.pushFailure !== undefined) {
 		return continuePushFailureResult({
@@ -531,7 +549,14 @@ async function startFromInProgress(params: {
 
 	const switched = await switchToWorkBranch({slug, arbiter, cwd, env, note});
 	if (switched.rebaseConflict) {
-		return continueConflictResult({slug, arbiter, cwd, env, note});
+		return continueConflictResult({
+			slug,
+			arbiter,
+			cwd,
+			failure: switched.rebaseFailure,
+			env,
+			note,
+		});
 	}
 	if (switched.pushFailure !== undefined) {
 		return continuePushFailureResult({
@@ -557,10 +582,13 @@ interface SwitchResult {
 	/** True iff we CONTINUED from a kept arbiter `work/<slug>` (not a fresh cut). */
 	continued: boolean;
 	/**
-	 * True iff a CONTINUE rebase onto fresh main CONFLICTED (and was aborted,
-	 * never auto-resolved). The caller routes the item to needs-attention (§10).
+	 * True iff a CONTINUE rebase onto fresh main did not apply (a conflict or any
+	 * other rebase failure; aborted, never auto-resolved). The caller routes the
+	 * item to needs-attention (§10), naming {@link rebaseFailure}.
 	 */
 	rebaseConflict: boolean;
+	/** Why the continue rebase did not apply (set exactly when {@link rebaseConflict} is). */
+	rebaseFailure?: ContinueRebaseFailure;
 	/**
 	 * Set iff the CONTINUE reconcile push to the arbiter FAILED TERMINALLY (the
 	 * stale-lease retry cap was exhausted, or a non-connectivity rejection such as
@@ -673,8 +701,13 @@ async function continueFromKeptBranch(params: {
 	// REBASE onto the freshly-fetched main at onboard-time (§10: rebase, not
 	// merge) so the agent builds on a CURRENT base. Conflict → aborted + reported.
 	const rebase = rebaseContinuedBranchOntoMain(cwd, `${arbiter}/main`, env);
-	if (rebase.kind === 'conflict') {
-		return {branch, continued: true, rebaseConflict: true};
+	if (rebase.kind !== 'clean') {
+		return {
+			branch,
+			continued: true,
+			rebaseConflict: true,
+			rebaseFailure: rebase,
+		};
 	}
 
 	// The arbiter `work/<slug>` tip the fetch above brought down, READ AFTER the
@@ -702,7 +735,7 @@ async function continueFromKeptBranch(params: {
 	// needs-attention rather than leaving the committed kept work silently
 	// in-progress.
 	try {
-		const pushed = pushContinuedBranchWithStaleLeaseRetry({
+		const pushed = refWrite.pushContinuedBranch({
 			cwd,
 			branch,
 			arbiter,
@@ -711,8 +744,13 @@ async function continueFromKeptBranch(params: {
 			env,
 			note,
 		});
-		if (pushed.kind === 'conflict') {
-			return {branch, continued: true, rebaseConflict: true};
+		if (pushed.kind !== 'pushed') {
+			return {
+				branch,
+				continued: true,
+				rebaseConflict: true,
+				rebaseFailure: pushed,
+			};
 		}
 	} catch (err) {
 		const message = err instanceof Error ? err.message : String(err);
@@ -737,7 +775,7 @@ async function continueFromKeptBranch(params: {
 }
 
 /**
- * Discriminate the THROW from {@link pushContinuedBranchWithStaleLeaseRetry} at
+ * Discriminate the THROW from `pushContinuedBranchWithStaleLeaseRetry` (via `refWrite.pushContinuedBranch`) at
  * the `start` continue-push site: is it a TOLERATED offline/unreachable-arbiter
  * outage (the existing best-effort case — `complete` pushes later), or a REAL
  * terminal failure that must SURFACE (the stale-lease retry cap exhausted, or a
@@ -807,13 +845,14 @@ async function routeContinueConflict(params: {
 	slug: string;
 	arbiter: string;
 	cwd: string;
+	failure: ContinueRebaseFailure | undefined;
 	env: NodeJS.ProcessEnv | undefined;
 	note: (m: string) => void;
 }): Promise<SurfaceToNeedsAttentionResult> {
-	const {slug, arbiter, cwd, env, note} = params;
+	const {slug, arbiter, cwd, failure, env, note} = params;
 	const reason =
-		`continuing the kept ${arbiter}/${workBranchRef('task', slug)}: rebase onto ` +
-		`${arbiter}/main conflicted (aborted, never auto-resolved) — run ` +
+		`continuing the kept ${arbiter}/${workBranchRef('task', slug)}: ` +
+		`${continueRebaseSentence(workBranchRef('task', slug), failure)} — run ` +
 		'`requeue --reconcile` to non-destructively re-sync the mirror and retry ' +
 		'the rebase (keeps the work). Last resort: `requeue --reset` ' +
 		'DESTRUCTIVELY discards the branch and starts fresh.';

package/src/status.ts

@@ -4,7 +4,7 @@ import {resolveHarness, type Harness} from './harness.js';
 // harness registry so `resolveHarness` dispatches pi jobs' liveness to it.
 import './pi-harness.js';
 import {type JobState} from './workspace.js';
-import {fetchMirrorMainOrWarn} from './repo-mirror.js';
+import {createMirrorRefresher, mirrorInReconcileScope} from './repo-mirror.js';
 import {formatArbiterStatus, type ArbiterStatusReport} from './arbiter.js';
 import {
 	listItemLockEntries,
@@ -204,6 +204,18 @@ export interface StatusOptions {
 	 * "drain them now" lever.
 	 */
 	reconcileLocks?: boolean;
+	/**
+	 * ARBITER SCOPE of the {@link StatusOptions.reconcileLocks} write (task
+	 * `reconcile-locks-stays-within-the-current-arbiter`, mirroring `gc`'s
+	 * arbiter-scoped default). When set, ONLY the registered mirror whose arbiter
+	 * hub key ({@link encodeRepoKey} of its `origin` URL) equals this key has its
+	 * stale locks RELEASED; every other mirror is merely classified and REPORTED,
+	 * exactly as without `reconcileLocks`, so a drain run from repo A never reaches
+	 * repo B's arbiter. `undefined` reconciles EVERY mirror: the CLI passes it
+	 * undefined only behind the explicit `--all-arbiters`, never by default.
+	 * Ignored when `reconcileLocks` is not `true`.
+	 */
+	reconcileArbiterKey?: string;
 	/**
 	 * Sink for the fetch-first fall-back warning (ADR §5/§6): when a mirror's `main`
 	 * cannot be fetched, `status` warns through this and reads that mirror's
@@ -265,11 +277,17 @@ export async function status(options: StatusOptions): Promise<StatusReport> {
 	const lockHeld: RepoLockEntries[] = [];
 	const staleLocks: RepoStaleLocks[] = [];
 	const ledgerDuplicates: RepoLedgerDuplicates[] = [];
+	// Dead LOCAL arbiters are summarised on one line after the loop (see
+	// `createMirrorRefresher`), not warned once per mirror.
+	const refresher = createMirrorRefresher({
+		warn: options.warn,
+		env: options.env,
+	});
 	for (const mirrorPath of options.mirrorPaths ?? []) {
 		// Fetch-first (ADR §5/§6): refresh this mirror's `main` so the duplicate lint
 		// reflects the remote truth. Never fatal — a failed fetch WARNS and falls back
 		// to the mirror's last-known `main`.
-		fetchMirrorMainOrWarn({mirrorPath, warn: options.warn, env: options.env});
+		refresher.refresh(mirrorPath);
 		// CLASSIFY the mirror's held locks against its `main` (fix for the propose-path
 		// lock leak; observation
 		// `every-completed-task-leaves-its-lock-ref-reporting-in-progress`). A
@@ -294,7 +312,14 @@ export async function status(options: StatusOptions): Promise<StatusReport> {
 		const MIRROR_MAIN = {mainRef: 'main'};
 		let staleEntries: string[] = [];
 		let entries: LockEntry[];
-		if (options.reconcileLocks === true) {
+		if (
+			options.reconcileLocks === true &&
+			mirrorInReconcileScope(
+				mirrorPath,
+				options.reconcileArbiterKey,
+				options.env,
+			)
+		) {
 			const reconciled = await reconcileTerminalItemLocks(
 				mirrorPath,
 				'origin',
@@ -350,6 +375,7 @@ export async function status(options: StatusOptions): Promise<StatusReport> {
 			ledgerDuplicates.push({repoPath: mirrorPath, duplicates: dups});
 		}
 	}
+	refresher.flush();
 	lockHeld.sort((a, b) => a.repoPath.localeCompare(b.repoPath));
 	staleLocks.sort((a, b) => a.repoPath.localeCompare(b.repoPath));
 	ledgerDuplicates.sort((a, b) => a.repoPath.localeCompare(b.repoPath));