@lumenflow/cli 2.17.0 → 2.18.1

package/dist/wu-claim.js

@@ -33,14 +33,16 @@ import { validateLaneCodePaths, logLaneValidationWarnings, } from '@lumenflow/co
 // WU-1574: parseBacklogFrontmatter/getSectionHeadings removed - state store replaces backlog parsing
 import { detectConflicts } from '@lumenflow/core/code-paths-overlap';
 import { getGitForCwd, createGitForPath } from '@lumenflow/core/git-adapter';
-import { die } from '@lumenflow/core/error-handler';
+import { die, getErrorMessage } from '@lumenflow/core/error-handler';
 import { createWUParser, WU_OPTIONS } from '@lumenflow/core/arg-parser';
 // WU-1491: Mode resolution for --cloud and flag combinations
 import { resolveClaimMode } from './wu-claim-mode.js';
+// WU-1590: Cloud claim helpers for branch-pr/cloud execution behavior
+import { shouldSkipBranchExistsCheck, resolveBranchClaimExecution } from './wu-claim-cloud.js';
 // WU-1495: Cloud auto-detection from config-driven env signals
-import { detectCloudMode } from '@lumenflow/core/cloud-detect';
+import { detectCloudMode, resolveEffectiveCloudActivation, CLOUD_ACTIVATION_SOURCE, } from '@lumenflow/core/cloud-detect';
 import { WU_PATHS, getStateStoreDirFromBacklog } from '@lumenflow/core/wu-paths';
-import { BRANCHES, REMOTES, WU_STATUS, CLAIMED_MODES, STATUS_SECTIONS, PATTERNS, toKebab, LOG_PREFIX, GIT_REFS, MICRO_WORKTREE_OPERATIONS, COMMIT_FORMATS, EMOJI, FILE_SYSTEM, STRING_LITERALS, LUMENFLOW_PATHS, } from '@lumenflow/core/wu-constants';
+import { BRANCHES, REMOTES, WU_STATUS, CLAIMED_MODES, STATUS_SECTIONS, PATTERNS, toKebab, LOG_PREFIX, GIT_REFS, MICRO_WORKTREE_OPERATIONS, COMMIT_FORMATS, EMOJI, FILE_SYSTEM, STRING_LITERALS, LUMENFLOW_PATHS, resolveWUStatus, } from '@lumenflow/core/wu-constants';
 import { withMicroWorktree } from '@lumenflow/core/micro-worktree';
 import { ensureOnMain, ensureMainUpToDate } from '@lumenflow/core/wu-helpers';
 import { emitWUFlowEvent } from '@lumenflow/core/telemetry';
@@ -58,6 +60,7 @@ import { getAssignedEmail } from '@lumenflow/core/wu-claim-helpers';
 import { symlinkNodeModules, symlinkNestedNodeModules } from '@lumenflow/core/worktree-symlink';
 // WU-1572: Import WUStateStore for event-sourced state tracking
 import { WUStateStore } from '@lumenflow/core/wu-state-store';
+import { SpawnRegistryStore } from '@lumenflow/core/spawn-registry-store';
 // WU-1574: Import backlog generator to replace BacklogManager
 import { generateBacklog, generateStatus } from '@lumenflow/core/backlog-generator';
 // WU-2411: Import resume helpers for agent handoff
@@ -90,7 +93,7 @@ async function surfaceUnreadSignalsForDisplay(baseDir) {
     }
     catch (err) {
         // WU-1473 AC4: Fail-open - never block claim on memory errors
-        console.warn(`${PREFIX} Warning: Could not surface unread signals: ${err.message}`);
+        console.warn(`${PREFIX} Warning: Could not surface unread signals: ${getErrorMessage(err)}`);
     }
 }
 async function ensureCleanOrClaimOnlyWhenNoAuto() {
@@ -116,6 +119,23 @@ async function ensureCleanOrClaimOnlyWhenNoAuto() {
     }
 }
 const PREFIX = LOG_PREFIX.CLAIM;
+/**
+ * Resolve branch-aware cloud activation for wu:claim.
+ *
+ * This preserves source attribution from detectCloudMode while enforcing
+ * protected-branch behavior for explicit vs env-signal activation.
+ */
+export function resolveCloudActivationForClaim(input) {
+    const detection = detectCloudMode({
+        cloudFlag: input.cloudFlag,
+        env: input.env,
+        config: input.config,
+    });
+    return resolveEffectiveCloudActivation({
+        detection,
+        currentBranch: input.currentBranch,
+    });
+}
 /**
  * WU-1508: Enforce tests.manual at claim time for non-doc/process WUs.
  * This is non-bypassable (independent of --allow-incomplete) to fail early.
@@ -133,6 +153,27 @@ export function validateManualTestsForClaim(doc, id) {
             `Add at least one manual verification step under tests.manual before claiming.`,
     };
 }
+export function resolveClaimStatus(status) {
+    return resolveWUStatus(status, WU_STATUS.READY);
+}
+/**
+ * Decide whether wu:claim should update canonical state on origin/main.
+ *
+ * Cloud branch-pr claims run on platform-managed branches and should not mutate
+ * canonical state on main during claim; they commit claim metadata on their own branch.
+ */
+export function shouldApplyCanonicalClaimUpdate(input) {
+    if (input.noPush) {
+        return false;
+    }
+    return !(input.isCloud && input.claimedMode === CLAIMED_MODES.BRANCH_PR);
+}
+/**
+ * Decide whether wu:claim should write claim metadata directly to the active branch.
+ */
+export function shouldPersistClaimMetadataOnBranch(input) {
+    return input.noPush === true || input.claimedMode === CLAIMED_MODES.BRANCH_PR;
+}
 /**
  * WU-1521: Build a rolled-back version of a WU YAML doc by stripping claim metadata.
  *
@@ -152,6 +193,7 @@ export function buildRollbackYamlDoc(doc) {
     rolled.status = WU_STATUS.READY;
     // Remove claim-specific metadata fields
     delete rolled.claimed_mode;
+    delete rolled.claimed_branch; // WU-1589: Clear claimed_branch on rollback
     delete rolled.claimed_at;
     delete rolled.worktree_path;
     delete rolled.baseline_main_sha;
@@ -159,6 +201,49 @@ export function buildRollbackYamlDoc(doc) {
     delete rolled.assigned_to;
     return rolled;
 }
+/**
+ * Returns true when a spawn record includes claim-time pickup evidence.
+ */
+export function hasClaimPickupEvidence(entry) {
+    const pickedUpAt = typeof entry?.pickedUpAt === 'string' && entry.pickedUpAt.trim().length > 0
+        ? entry.pickedUpAt
+        : '';
+    const pickedUpBy = typeof entry?.pickedUpBy === 'string' && entry.pickedUpBy.trim().length > 0
+        ? entry.pickedUpBy
+        : '';
+    return pickedUpAt.length > 0 && pickedUpBy.length > 0;
+}
+/**
+ * WU-1605: Record delegated pickup evidence at wu:claim time when a spawn/delegate
+ * provenance record already exists for this target WU.
+ */
+export async function recordClaimPickupEvidence(id, options = {}) {
+    const baseDir = options.baseDir ?? process.cwd();
+    const claimedBy = typeof options.claimedBy === 'string' && options.claimedBy.trim().length > 0
+        ? options.claimedBy.trim()
+        : 'unknown';
+    const store = new SpawnRegistryStore(path.join(baseDir, '.lumenflow', 'state'));
+    await store.load();
+    const spawnEntry = store.getByTarget(id);
+    if (!spawnEntry) {
+        return { matchedSpawn: false, recorded: false, alreadyRecorded: false };
+    }
+    if (hasClaimPickupEvidence(spawnEntry)) {
+        return {
+            matchedSpawn: true,
+            recorded: false,
+            alreadyRecorded: true,
+            spawnId: spawnEntry.id,
+        };
+    }
+    await store.recordPickup(spawnEntry.id, claimedBy);
+    return {
+        matchedSpawn: true,
+        recorded: true,
+        alreadyRecorded: false,
+        spawnId: spawnEntry.id,
+    };
+}
 /**
  * Pre-flight validation: Check WU file exists and is valid BEFORE any git operations
  * Prevents zombie worktrees when WU YAML is missing or malformed
@@ -181,7 +266,7 @@ function preflightValidateWU(WU_PATH, id) {
     }
     catch (e) {
         die(`Failed to parse WU YAML ${WU_PATH}\n\n` +
-            `YAML parsing error: ${e.message}\n\n` +
+            `YAML parsing error: ${getErrorMessage(e)}\n\n` +
             `Fix the YAML syntax errors before claiming.`);
     }
     // Validate ID matches
@@ -192,7 +277,7 @@ function preflightValidateWU(WU_PATH, id) {
             `Fix the id field in the WU YAML before claiming.`);
     }
     // Validate state transition is allowed
-    const currentStatus = doc.status || WU_STATUS.READY;
+    const currentStatus = resolveClaimStatus(doc.status);
     try {
         assertTransition(currentStatus, WU_STATUS.IN_PROGRESS, id);
     }
@@ -200,7 +285,7 @@ function preflightValidateWU(WU_PATH, id) {
         die(`Cannot claim ${id} - invalid state transition\n\n` +
             `Current status: ${currentStatus}\n` +
             `Attempted transition: ${currentStatus} → in_progress\n\n` +
-            `Reason: ${error.message}`);
+            `Reason: ${getErrorMessage(error)}`);
     }
     return doc;
 }
@@ -252,7 +337,7 @@ function validateYAMLSchema(WU_PATH, doc, args) {
 }
 // WU-1576: validateBacklogConsistency removed - repair now happens inside micro-worktree
 // See claimWorktreeMode() execute function for the new location
-async function updateWUYaml(WU_PATH, id, lane, claimedMode = 'worktree', worktreePath = null, sessionId = null, gitAdapter = null) {
+async function updateWUYaml(WU_PATH, id, lane, claimedMode = 'worktree', worktreePath = null, sessionId = null, gitAdapter = null, claimedBranch = null) {
     // Check file exists
     try {
         await access(WU_PATH);
@@ -270,7 +355,7 @@ async function updateWUYaml(WU_PATH, id, lane, claimedMode = 'worktree', worktre
     }
     catch (e) {
         die(`Failed to read WU file: ${WU_PATH}\n\n` +
-            `Error: ${e.message}\n\n` +
+            `Error: ${getErrorMessage(e)}\n\n` +
             `Options:\n` +
             `  1. Check file permissions: ls -la ${WU_PATH}\n` +
             `  2. Ensure you have read access to the repository`);
@@ -281,7 +366,7 @@ async function updateWUYaml(WU_PATH, id, lane, claimedMode = 'worktree', worktre
     }
     catch (e) {
         die(`Failed to parse YAML ${WU_PATH}\n\n` +
-            `Error: ${e.message}\n\n` +
+            `Error: ${getErrorMessage(e)}\n\n` +
             `Options:\n` +
             `  1. Validate YAML syntax: pnpm wu:validate --id ${id}\n` +
             `  2. Fix YAML errors manually and retry`);
@@ -293,12 +378,12 @@ async function updateWUYaml(WU_PATH, id, lane, claimedMode = 'worktree', worktre
             `  2. Verify you're claiming the right WU`);
     }
     // Validate state transition before updating
-    const currentStatus = doc.status || WU_STATUS.READY;
+    const currentStatus = resolveClaimStatus(doc.status);
     try {
         assertTransition(currentStatus, WU_STATUS.IN_PROGRESS, id);
     }
     catch (error) {
-        die(`State transition validation failed: ${error.message}`);
+        die(`State transition validation failed: ${getErrorMessage(error)}`);
     }
     // Update status and lane (lane only if provided and different)
     doc.status = WU_STATUS.IN_PROGRESS;
@@ -306,6 +391,11 @@ async function updateWUYaml(WU_PATH, id, lane, claimedMode = 'worktree', worktre
         doc.lane = lane;
     // Record claimed mode (worktree or branch-only)
     doc.claimed_mode = claimedMode;
+    // WU-1590: Persist claimed_branch for branch-pr cloud agents so downstream commands
+    // (wu:prep, wu:done, wu:cleanup) can resolve the actual branch via defaultBranchFrom()
+    if (claimedBranch) {
+        doc.claimed_branch = claimedBranch;
+    }
     // WU-1226: Record worktree path to prevent resolution failures if lane field changes
     if (worktreePath) {
         doc.worktree_path = worktreePath;
@@ -386,7 +476,7 @@ async function maybeProgressInitiativeStatus(worktreePath, initiativeRef, wuId)
     }
     catch (error) {
         // Non-fatal: log warning and continue
-        console.warn(`${PREFIX} ⚠️  Could not check initiative status progression: ${error.message}`);
+        console.warn(`${PREFIX} ⚠️  Could not check initiative status progression: ${getErrorMessage(error)}`);
         return { updated: false, initPath: null };
     }
 }
@@ -526,7 +616,8 @@ async function applyStagedChangesToMicroWorktree(worktreePath, stagedChanges) {
  * Ensures canonical state stays global while local main remains unchanged.
  */
 async function applyCanonicalClaimUpdate(ctx, sessionId) {
-    const { args, id, laneK, worktree, WU_PATH, STATUS_PATH, BACKLOG_PATH, claimedMode, fixableIssues, stagedChanges, } = ctx;
+    const { args, id, laneK, worktree, WU_PATH, STATUS_PATH, BACKLOG_PATH, claimedMode, fixableIssues, stagedChanges, currentBranchForCloud, // WU-1590: For persisting claimed_branch
+     } = ctx;
     const commitMsg = COMMIT_FORMATS.CLAIM(id.toLowerCase(), laneK);
     const worktreePathForYaml = claimedMode === CLAIMED_MODES.BRANCH_ONLY ? null : path.resolve(worktree);
     let updatedTitle = '';
@@ -554,7 +645,7 @@ async function applyCanonicalClaimUpdate(ctx, sessionId) {
                 }
                 const microGit = createGitForPath(worktreePath);
                 // WU-1211: updateWUYaml now returns {title, initiative}
-                const updateResult = await updateWUYaml(microWUPath, id, args.lane, claimedMode, worktreePathForYaml, sessionId, microGit);
+                const updateResult = await updateWUYaml(microWUPath, id, args.lane, claimedMode, worktreePathForYaml, sessionId, microGit, currentBranchForCloud || null);
                 updatedTitle = updateResult.title || updatedTitle;
                 await addOrReplaceInProgressStatus(microStatusPath, id, updatedTitle);
                 await removeFromReadyAndAddToInProgressBacklog(microBacklogPath, id, updatedTitle, args.lane);
@@ -790,7 +881,7 @@ function validateLaneFormatWithError(lane) {
         validateLaneFormat(lane);
     }
     catch (error) {
-        die(`Invalid lane format: ${error.message}\n\n` +
+        die(`Invalid lane format: ${getErrorMessage(error)}\n\n` +
             `Valid formats:\n` +
             `  - Parent-only: "Operations", "Intelligence", "Experience", etc.\n` +
             `  - Sub-lane: "Operations: Tooling", "Intelligence: Prompts", etc.\n\n` +
@@ -917,28 +1008,42 @@ async function validateBranchOnlyMode(STATUS_PATH, id) {
  * Execute branch-only mode claim workflow
  */
 async function claimBranchOnlyMode(ctx) {
-    const { args, id, laneK, title, branch, WU_PATH, STATUS_PATH, BACKLOG_PATH, claimedMode, sessionId, updatedTitle, } = ctx;
-    // Create branch and switch to it from origin/main (avoids local main mutation)
-    try {
-        await getGitForCwd().createBranch(branch, `${REMOTES.ORIGIN}/${BRANCHES.MAIN}`);
+    const { args, id, laneK, title, branch, WU_PATH, STATUS_PATH, BACKLOG_PATH, claimedMode, shouldCreateBranch, currentBranch, sessionId, updatedTitle, currentBranchForCloud, // WU-1590: For persisting claimed_branch
+     } = ctx;
+    if (shouldCreateBranch) {
+        // Create branch and switch to it from origin/main (avoids local main mutation)
+        try {
+            await getGitForCwd().createBranch(branch, `${REMOTES.ORIGIN}/${BRANCHES.MAIN}`);
+        }
+        catch (error) {
+            die(`Canonical claim state may be updated, but branch creation failed.\n\n` +
+                `Error: ${getErrorMessage(error)}\n\n` +
+                `Recovery:\n` +
+                `  1. Run: git fetch ${REMOTES.ORIGIN} ${BRANCHES.MAIN}\n` +
+                `  2. Retry: pnpm wu:claim --id ${id} --lane "${args.lane}"\n` +
+                `  3. If needed, delete local branch: git branch -D ${branch}`);
+        }
     }
-    catch (error) {
-        die(`Canonical claim state may be updated, but branch creation failed.\n\n` +
-            `Error: ${error.message}\n\n` +
-            `Recovery:\n` +
-            `  1. Run: git fetch ${REMOTES.ORIGIN} ${BRANCHES.MAIN}\n` +
-            `  2. Retry: pnpm wu:claim --id ${id} --lane "${args.lane}"\n` +
-            `  3. If needed, delete local branch: git branch -D ${branch}`);
+    else if (currentBranch !== branch) {
+        die(`Cloud branch-pr claim must run on the active branch.\n\n` +
+            `Current branch: ${currentBranch}\n` +
+            `Resolved branch: ${branch}\n\n` +
+            `Switch to ${branch} and retry, or omit conflicting --branch flags.`);
     }
     let finalTitle = updatedTitle || title;
     const msg = COMMIT_FORMATS.CLAIM(id.toLowerCase(), laneK);
-    if (args.noPush) {
+    const shouldPersistClaimMetadata = shouldPersistClaimMetadataOnBranch({
+        claimedMode,
+        noPush: Boolean(args.noPush),
+    });
+    if (shouldPersistClaimMetadata) {
         if (args.noAuto) {
             await ensureCleanOrClaimOnlyWhenNoAuto();
         }
         else {
             // WU-1211: updateWUYaml now returns {title, initiative}
-            const updateResult = await updateWUYaml(WU_PATH, id, args.lane, claimedMode, null, sessionId);
+            // WU-1590: Pass claimed_branch for branch-pr persistence
+            const updateResult = await updateWUYaml(WU_PATH, id, args.lane, claimedMode, null, sessionId, null, currentBranchForCloud || null);
             finalTitle = updateResult.title || finalTitle;
             await addOrReplaceInProgressStatus(STATUS_PATH, id, finalTitle);
             await removeFromReadyAndAddToInProgressBacklog(BACKLOG_PATH, id, finalTitle, args.lane);
@@ -950,9 +1055,11 @@ async function claimBranchOnlyMode(ctx) {
                     filesToAdd.push(initProgress.initPath);
                 }
             }
-            await getGitForCwd().add(filesToAdd.map((f) => JSON.stringify(f)).join(' '));
+            await getGitForCwd().add(filesToAdd);
         }
         await getGitForCwd().commit(msg);
+    }
+    if (args.noPush) {
         console.warn(`${PREFIX} Warning: --no-push enabled. Claim is local-only and NOT visible to other agents.`);
     }
     else {
@@ -1323,6 +1430,33 @@ async function main() {
     if (!PATTERNS.WU_ID.test(id))
         die(`Invalid WU id '${args.id}'. Expected format WU-123`);
     await ensureOnMain(getGitForCwd());
+    // WU-1609: Resolve branch-aware cloud activation at preflight so explicit
+    // protected-branch cloud requests fail before lane locking/state mutation.
+    const preflightBranch = await getGitForCwd().getCurrentBranch();
+    const preflightCloudEffective = resolveCloudActivationForClaim({
+        cloudFlag: Boolean(args.cloud),
+        env: process.env,
+        config: getConfig().cloud,
+        currentBranch: preflightBranch,
+    });
+    if (preflightCloudEffective.blocked) {
+        const sourceHint = preflightCloudEffective.source === CLOUD_ACTIVATION_SOURCE.FLAG
+            ? '--cloud'
+            : 'LUMENFLOW_CLOUD=1';
+        die(`Cloud mode blocked on protected branch "${preflightBranch}".\n\n` +
+            `Explicit cloud activation (${sourceHint}) is not allowed on main/master.\n` +
+            `Switch to a non-main branch for cloud mode, or run wu:claim without cloud activation on main/master.`);
+    }
+    if (preflightCloudEffective.suppressed) {
+        const signalSuffix = preflightCloudEffective.matchedSignal
+            ? ` (signal: ${preflightCloudEffective.matchedSignal})`
+            : '';
+        console.log(`${PREFIX} Cloud auto-detection suppressed on protected branch "${preflightBranch}"${signalSuffix}; continuing with standard claim flow.`);
+    }
+    else if (preflightCloudEffective.isCloud &&
+        preflightCloudEffective.source === CLOUD_ACTIVATION_SOURCE.ENV_SIGNAL) {
+        console.log(`${PREFIX} Cloud mode auto-detected (source: ${preflightCloudEffective.source}${preflightCloudEffective.matchedSignal ? `, signal: ${preflightCloudEffective.matchedSignal}` : ''})`);
+    }
     // WU-2411: Handle --resume flag for agent handoff
     if (args.resume) {
         await handleResumeMode(args, id);
@@ -1449,18 +1583,11 @@ async function main() {
         const title = (await readWUTitle(id)) || '';
         const branch = args.branch || `lane/${laneK}/${idK}`;
         const worktree = args.worktree || `worktrees/${laneK}-${idK}`;
-        // WU-1495: Cloud auto-detection from config-driven env signals
-        // Detection precedence: --cloud flag > LUMENFLOW_CLOUD=1 > env_signals (opt-in)
-        const config = getConfig();
-        const cloudDetection = detectCloudMode({
-            cloudFlag: Boolean(args.cloud),
-            env: process.env,
-            config: config.cloud,
-        });
-        const effectiveCloud = cloudDetection.isCloud;
-        if (cloudDetection.isCloud && !args.cloud) {
-            console.log(`${PREFIX} Cloud mode auto-detected (source: ${cloudDetection.source}${cloudDetection.matchedSignal ? `, signal: ${cloudDetection.matchedSignal}` : ''})`);
-        }
+        const currentBranch = preflightBranch;
+        const cloudEffective = preflightCloudEffective;
+        const effectiveCloud = cloudEffective.isCloud;
+        // WU-1590: Capture current branch for cloud claim metadata (before any branch switching)
+        const currentBranchForCloud = effectiveCloud ? currentBranch : undefined;
         // WU-1491: Resolve claimed mode from flag combination
         const modeResult = resolveClaimMode({
             branchOnly: args.branchOnly,
@@ -1476,11 +1603,24 @@ async function main() {
         if (!modeResult.skipBranchOnlySingletonGuard) {
             await validateBranchOnlyMode(STATUS_PATH, id);
         }
+        // WU-1590: Skip branch-exists checks in cloud mode (branch already exists by definition)
+        const branchExecution = resolveBranchClaimExecution({
+            claimedMode,
+            isCloud: effectiveCloud,
+            currentBranch,
+            requestedBranch: branch,
+        });
+        const effectiveBranch = branchExecution.executionBranch;
+        const skipBranchChecks = shouldSkipBranchExistsCheck({
+            isCloud: effectiveCloud,
+            currentBranch,
+            laneBranch: effectiveBranch,
+        });
         // Check if remote branch already exists (prevents duplicate global claims)
-        if (!args.noPush) {
-            const remoteExists = await getGitForCwd().remoteBranchExists(REMOTES.ORIGIN, branch);
+        if (!args.noPush && !skipBranchChecks) {
+            const remoteExists = await getGitForCwd().remoteBranchExists(REMOTES.ORIGIN, effectiveBranch);
             if (remoteExists) {
-                die(`Remote branch ${REMOTES.ORIGIN}/${branch} already exists. WU may already be claimed.\n\n` +
+                die(`Remote branch ${REMOTES.ORIGIN}/${effectiveBranch} already exists. WU may already be claimed.\n\n` +
                     `Options:\n` +
                     `  1. Coordinate with the owning agent or wait for completion\n` +
                     `  2. Choose a different WU\n` +
@@ -1488,14 +1628,16 @@ async function main() {
             }
         }
         // Check if branch already exists locally (prevents duplicate claims)
-        const branchAlreadyExists = await getGitForCwd().branchExists(branch);
-        if (branchAlreadyExists) {
-            die(`Branch ${branch} already exists. WU may already be claimed.\n\n` +
-                `Git branch existence = WU claimed (natural locking).\n\n` +
-                `Options:\n` +
-                `  1. Check git worktree list to see if worktree exists\n` +
-                `  2. Coordinate with the owning agent or wait for them to complete\n` +
-                `  3. Choose a different WU`);
+        if (!skipBranchChecks) {
+            const branchAlreadyExists = await getGitForCwd().branchExists(effectiveBranch);
+            if (branchAlreadyExists) {
+                die(`Branch ${effectiveBranch} already exists. WU may already be claimed.\n\n` +
+                    `Git branch existence = WU claimed (natural locking).\n\n` +
+                    `Options:\n` +
+                    `  1. Check git worktree list to see if worktree exists\n` +
+                    `  2. Coordinate with the owning agent or wait for them to complete\n` +
+                    `  3. Choose a different WU`);
+            }
         }
         // Layer 3 defense (WU-1476): Pre-flight orphan check
         // Clean up orphan directory if it exists at target worktree path
@@ -1508,7 +1650,7 @@ async function main() {
             }
             catch (err) {
                 die(`Failed to clean up orphan directory at ${worktree}\n\n` +
-                    `Error: ${err.message}\n\n` +
+                    `Error: ${getErrorMessage(err)}\n\n` +
                     `Manual cleanup: rm -rf ${absoluteWorktreePath}`);
             }
         }
@@ -1529,7 +1671,7 @@ async function main() {
         }
         catch (err) {
             // Non-blocking: session start failure should not block claim
-            console.warn(`${PREFIX} Warning: Could not start agent session: ${err.message}`);
+            console.warn(`${PREFIX} Warning: Could not start agent session: ${getErrorMessage(err)}`);
         }
         // Execute claim workflow
         const baseCtx = {
@@ -1537,18 +1679,26 @@ async function main() {
             id,
             laneK,
             title,
-            branch,
+            branch: effectiveBranch,
             worktree,
             WU_PATH,
             STATUS_PATH,
             BACKLOG_PATH,
             claimedMode,
+            shouldCreateBranch: branchExecution.shouldCreateBranch,
+            currentBranch,
             fixableIssues, // WU-1361: Pass fixable issues for worktree application
             stagedChanges,
+            currentBranchForCloud, // WU-1590: For persisting claimed_branch in branch-pr mode
         };
         let updatedTitle = title;
         claimTitle = title;
-        if (!args.noPush) {
+        const shouldApplyCanonicalUpdate = shouldApplyCanonicalClaimUpdate({
+            isCloud: effectiveCloud,
+            claimedMode,
+            noPush: Boolean(args.noPush),
+        });
+        if (shouldApplyCanonicalUpdate) {
             updatedTitle = (await applyCanonicalClaimUpdate(baseCtx, sessionId)) || updatedTitle;
             // WU-1521: Mark that canonical claim was pushed to origin/main
             // If claim fails after this point, the finally block will rollback
@@ -1557,6 +1707,9 @@ async function main() {
             // Refresh origin/main after push-only update so worktrees start from canonical state
             await getGitForCwd().fetch(REMOTES.ORIGIN, BRANCHES.MAIN);
         }
+        else if (!args.noPush && claimedMode === CLAIMED_MODES.BRANCH_PR) {
+            console.log(`${PREFIX} Skipping canonical claim update on origin/main for cloud branch-pr claim.`);
+        }
         const ctx = {
             ...baseCtx,
             sessionId,
@@ -1570,6 +1723,30 @@ async function main() {
         else {
             await claimWorktreeMode(ctx);
         }
+        // WU-1605: Record claim-time pickup evidence for delegation provenance.
+        // Non-blocking: this metadata should not block claim completion.
+        try {
+            let claimedBy = process.env.GIT_AUTHOR_EMAIL?.trim();
+            try {
+                claimedBy = await getAssignedEmail(getGitForCwd());
+            }
+            catch {
+                // Fall back to env/default when git email lookup fails in this context.
+            }
+            const pickupResult = await recordClaimPickupEvidence(id, {
+                baseDir: process.cwd(),
+                claimedBy,
+            });
+            if (pickupResult.recorded) {
+                console.log(`${PREFIX} ${EMOJI.SUCCESS} Recorded delegation pickup evidence (${pickupResult.spawnId})`);
+            }
+            else if (pickupResult.alreadyRecorded) {
+                console.log(`${PREFIX} ${EMOJI.INFO} Delegation pickup evidence already recorded (${pickupResult.spawnId})`);
+            }
+        }
+        catch (err) {
+            console.warn(`${PREFIX} Warning: Could not record delegation pickup evidence: ${getErrorMessage(err)}`);
+        }
         // Mark claim as successful - lock should remain for wu:done to release
         claimSucceeded = true;
     }