brainclaw 1.11.1 → 1.13.0

package/dist/commands/mcp.js

@@ -7,14 +7,14 @@ import { fileURLToPath } from 'node:url';
 import { Worker } from 'node:worker_threads';
 import { generatedSchemas } from './mcp-schemas.generated.js';
 import { getTriggeredItems, renderTriggeredItems } from '../core/lifecycle.js';
-import { resolveCrossProjectWritableTarget, resolveProjectCwd, writeCrossProjectSignal } from '../core/cross-project.js';
+import { resolveCrossProjectLinks, resolveCrossProjectWritableTarget, resolveProjectCwd, writeCrossProjectSignal } from '../core/cross-project.js';
 import { buildContext, renderContextMarkdown, renderContextPromptTemplate, renderContextBriefing } from '../core/context.js';
 import { buildCoordinationSnapshot } from '../core/coordination.js';
 import { checkBrainclawInstallableUpdate, getInstalledBrainclawVersion, readDiskBrainclawVersion, renderBrainclawInstallableUpdateNotice } from '../core/brainclaw-version.js';
 import { loadConfig } from '../core/config.js';
 import { collectLoadValidationWarnings, findLoadValidationWarning, loadState, persistState, saveState } from '../core/state.js';
 import { generateIdWithLabel } from '../core/ids.js';
-import { memoryExists } from '../core/io.js';
+import { memoryExists, MEMORY_DIR } from '../core/io.js';
 import { generateCandidateIdWithLabel, loadCandidate, saveCandidate } from '../core/candidates.js';
 import { createEntity, getEntity, listEntities, boundListResult, DEFAULT_FIND_CHAR_BUDGET, removeEntity, transitionEntity, updateEntity, } from '../core/entity-operations.js';
 import { relocateEntity } from '../core/operations/relocate.js';
@@ -31,16 +31,18 @@ import { rejectCandidate } from './reject.js';
 import { startSession } from './session-start.js';
 import { endSession } from './session-end.js';
 import { applyHandoffUpdates } from './update-handoff.js';
-import { AgentIdentityResolutionError, AgentTrustError, findAgentIdentityById, findAgentIdentityByName, hasMinimumTrustLevel, normalizeAgentName, requireMinimumTrustLevel, requireRegisteredAgentIdentity, resolveCurrentAgentIdentity, resolveCurrentModel, ensureAgentRegisteredForDispatch, } from '../core/agent-registry.js';
+import { AgentIdentityResolutionError, AgentTrustError, findAgentIdentityById, findAgentIdentityByName, hasMinimumTrustLevel, normalizeAgentName, requireMinimumTrustLevel, requireRegisteredAgentIdentity, resolveCurrentAgentIdentity, resolveCurrentModel, ensureAgentRegisteredForDispatch, resolveOrAutoRegisterAgentIdentity, } from '../core/agent-registry.js';
 import { appendAuditEntry } from '../core/audit.js';
 import { nowISO, generateId } from '../core/ids.js';
-import { buildOperationalIdentity, loadAllSessions, loadSessionById } from '../core/identity.js';
+import { buildOperationalIdentity, loadAllSessions, loadCurrentSession, loadSessionById, saveCurrentSession } from '../core/identity.js';
 import { validateMcpInput, validateMcpField } from '../core/input-validation.js';
 import { createCapability, createTool as createRegistryTool } from '../core/registries.js';
 import { detectAiAgent } from '../core/ai-agent-detection.js';
+import { isObserverMode } from '../core/observer-mode.js';
 import { checkGitPresence, scanGitRepos, parseRoots, parseRepoSelection, parseAgentSelection, getDetectedSetupAgentNames, getInstalledAgentNames, runGlobalInstall, initReposAndConfigureAgents, readSetupState, ALL_KNOWN_AGENTS, } from './setup.js';
 import { buildAgentInventory } from '../core/agent-inventory.js';
-import { resolveEffectiveCwd, resolveEffectiveCwdInfo, resolveProjectRef, resolveTargetStore } from '../core/store-resolution.js';
+import { findOutermostBrainclawRoot, resolveEffectiveCwd, resolveEffectiveCwdInfo, resolveProjectRef, resolveTargetStore } from '../core/store-resolution.js';
+import { switchProject } from './switch.js';
 import { assessBootstrapNeed, probeForQuickSetup, buildQuickSetupProbeResponse, buildOnboardingPreview, resolveEmptyMemoryRecommendation } from '../core/setup-flow.js';
 import { ensureUserStore, resolveHomeDir } from '../core/setup-state.js';
 import { createPlan, addStep as addStepOp, completeStep as completeStepOp, updateStep as updateStepOp, deleteStep as deleteStepOp, deletePlan as deletePlanOp } from '../core/operations/plan.js';
@@ -655,13 +657,17 @@ const MCP_WRITE_TOOLS = [
     },
     {
         name: 'bclaw_release_claim',
-        description: 'Release a work claim.',
+        description: 'Release a work claim. Callers own their own claims; a trusted+ coordinator releasing another agent\'s claim MUST pass coordinator_override:true (audited).',
         annotations: { tier: 'standard', category: 'coordination', headlessApproval: 'auto' },
         inputSchema: {
             type: 'object',
             properties: {
                 id: { type: 'string', description: 'Claim ID to release.' },
                 planStatus: { type: 'string', description: 'Optional: update linked plan status.' },
+                coordinator_override: {
+                    type: 'boolean',
+                    description: 'Opt-in override for a trusted+ caller releasing a claim they do NOT own (cross-agent teardown, ghost-claim cleanup). Rejected for contributor-level callers; audited when used. trp#928.',
+                },
             },
             required: ['id'],
         },
@@ -1187,7 +1193,7 @@ const MCP_WRITE_TOOLS = [
             type: 'object',
             properties: {
                 entity: { type: 'string', description: 'Entity name: plan | decision | constraint | trap | handoff | runtime_note | candidate | sequence | claim | action | assignment | agent_run | cross_project_link. Others not yet wired.' },
-                filter: { type: 'object', description: 'Filter keys: status, tag (single tag), tags (array, any-match), author, plan_id, source, auto_generated, limit, offset, includeLegacy (bool, default false), minAutoReflectConfidence (0-1, default 0.6). entity=agent_run also accepts assignment_id, claim_id, message_id.' },
+                filter: { type: 'object', description: 'Filter keys (ANY entity): status, tag (single tag), tags (array, any-match), author, plan_id, source, auto_generated, limit, offset, includeLegacy (bool, default false), minAutoReflectConfidence (0-1, default 0.6). ENTITY-SCOPED keys (rejected with a validation_error if used with any other entity): assignment_id, claim_id, message_id — ONLY for entity="agent_run". Unknown/mis-scoped keys are rejected loudly.' },
                 project: { type: 'string', description: 'Optional: name (or path/basename) of a linked project to query. Defaults to the current project. Only cross_project_links (config.yaml) and workspace store-chain children are accepted — list with `brainclaw link list`.' },
                 budget_tokens: { type: 'number', description: 'Optional token budget for the page payload (~4 chars/token). Tightens the default size cap; pagination metadata (has_more/next_offset) still applies.' },
             },
@@ -1255,7 +1261,7 @@ const MCP_WRITE_TOOLS = [
     },
     {
         name: 'bclaw_transition',
-        description: 'Transition an entity to a new status. Validated against EntityRegistry.transitions. Returns the triggered side-effect tags. Pass `project` to transition an entity in a linked project instead of the current one.',
+        description: 'Transition an entity to a new status. Validated against EntityRegistry.transitions. Returns the triggered side-effect tags. Pass `project` to transition an entity in a linked project instead of the current one. For entity="claim": released/stale transitions are ownership-checked — non-owners must pass coordinator_override:true (trusted+ trust level required).',
         annotations: { tier: 'standard', category: 'memory', headlessApproval: 'prompt' },
         inputSchema: {
             type: 'object',
@@ -1265,6 +1271,7 @@ const MCP_WRITE_TOOLS = [
                 to: { type: 'string', description: 'Target status.' },
                 reason: { type: 'string', description: 'Optional free-text reason, audited alongside the transition.' },
                 project: { type: 'string', description: 'Optional: name of a linked project to transition the entity in. Defaults to the current project.' },
+                coordinator_override: { type: 'boolean', description: 'entity="claim" only: opt-in override for a trusted+ caller releasing/staling a claim they do NOT own. Audited when used. trp#928.' },
             },
             required: ['entity', 'id', 'to'],
         },
@@ -1828,10 +1835,22 @@ function ensureTrust(args, fields, level, cwd, sessionId) {
  * missing field — which would then be silently GC'd by the state sync loop
  * (see fix plan pln_5f44426c).
  *
- * pln#562 step 3 — resolution failure is a HARD error. The old fallback to
- * author:'unknown' produced records that passed creation but were schema-
- * invalid on read and silently GC'd: a write that lies about succeeding.
- * Callers map the throw to a validation_error tool response.
+ * pln#562 step 3 — a write that would create a record with a missing/'unknown'
+ * author must never be silent (that produced records that passed creation but
+ * were schema-invalid on read and silently GC'd from disk).
+ *
+ * pln#608 — extended with auto-repair: when the caller has no session but a
+ * derivable agent name (arg / $BRAINCLAW_AGENT_NAME / detected AI agent),
+ * fall through to `resolveOrAutoRegisterAgentIdentity` and materialize the
+ * session via `buildOperationalIdentity({ persistImplicitSession: true })`
+ * (same mechanic as switchProject:86-106 and session-start). The freshly-
+ * created session is tagged `auto_created` so aggressive harvesting can
+ * distinguish it from operator sessions (pln#602). The caller receives
+ * `auto_repair` and surfaces it as a warning — never silent.
+ *
+ * KEEP (still a hard error, doctrine boundary): the identity is ambiguous
+ * (no name in args, no env signal, no detectable agent). We do not invent
+ * an identity — invoke intent is unclear and the write would misattribute.
  */
 function resolveCanonicalAuthor(args, cwd, connectionSessionId) {
     const resolved = resolveMutationIdentity(args, { nameField: 'agent', idField: 'agentId' }, cwd, connectionSessionId);
@@ -1841,9 +1860,92 @@ function resolveCanonicalAuthor(args, cwd, connectionSessionId) {
             agent_id: resolved.identity.agent_id,
         };
     }
-    const detail = 'error' in resolved && resolved.error ? resolved.error.message : 'no registered agent identity resolved';
-    throw new Error(`cannot resolve mutation author: ${detail} `
-        + 'Start a session (bclaw_session_start) or pass a registered agent before writing.');
+    const strictError = 'error' in resolved && resolved.error ? resolved.error : undefined;
+    // KEEP (doctrine boundary): a pinned principal that rejected the caller args
+    // is a SPOOF/MISMATCH, not an ambiguous first-write. Never auto-repair over
+    // it — silently re-attributing would defeat pln#562 step 3. The strict error
+    // already carries the pointer to a curator override.
+    if (resolveConnectionPrincipal(cwd, connectionSessionId)) {
+        throw new Error(`cannot resolve mutation author: ${strictError?.message ?? 'principal mismatch'}`);
+    }
+    // Observer processes are read-only dashboards/inspectors. Even when an env
+    // variable leaks an agent name into the observer process, canonical writes
+    // must not use the auto-repair path because it can mint identity/session
+    // state as a side effect.
+    if (isObserverMode()) {
+        throw new Error(`cannot resolve mutation author: ${strictError?.message ?? 'observer mode cannot auto-repair identity/session state'}`);
+    }
+    const explicitName = typeof args.agent === 'string' ? args.agent : undefined;
+    const explicitId = typeof args.agentId === 'string' ? args.agentId : undefined;
+    // resolveOrAutoRegisterAgentIdentity's fall-through helper only reads
+    // BRAINCLAW_AGENT / OPENCLAW_AGENT. resolveCurrentAgentIdentity also honors
+    // BRAINCLAW_AGENT_NAME, and dispatched workers set both. Normalize here so
+    // an env-declared name is a first-class signal to the auto-repair path.
+    const envAgentName = explicitName
+        ?? (process.env.BRAINCLAW_AGENT_NAME?.trim() || undefined)
+        ?? (process.env.BRAINCLAW_AGENT?.trim() || undefined);
+    let identity;
+    let autoRegistered;
+    try {
+        const outcome = resolveOrAutoRegisterAgentIdentity({
+            agentName: envAgentName,
+            agentId: explicitId,
+            cwd,
+            allowCurrent: true,
+            allowEnv: true,
+        });
+        identity = outcome.identity;
+        autoRegistered = outcome.auto_registered;
+    }
+    catch (err) {
+        // Genuine ambiguity — no derivable name. Stays a hard error (KEEP: doctrine
+        // boundary is "ambiguous intent → refuse with next_action", not silence).
+        const detail = err instanceof Error ? err.message : (strictError?.message ?? String(err));
+        throw new Error(`cannot resolve mutation author: ${detail} `
+            + 'Pass a registered agent, set $BRAINCLAW_AGENT_NAME, '
+            + 'or register with `brainclaw register-agent <name>` before writing.', { cause: err });
+    }
+    const explicitSessionId = connectionSessionId?.trim() || explicitSessionIdFromEnv();
+    const hadSessionBefore = explicitSessionId
+        ? Boolean(loadSessionById(explicitSessionId, cwd))
+        : Boolean(loadCurrentSession(cwd));
+    let sessionAutoCreated;
+    try {
+        const opIdentity = buildOperationalIdentity(identity.agent_name, cwd, {
+            agentId: identity.agent_id,
+            sessionId: explicitSessionId,
+            persistImplicitSession: true,
+        });
+        if (!hadSessionBefore && opIdentity.session_id) {
+            sessionAutoCreated = opIdentity.session_id;
+            const session = loadSessionById(opIdentity.session_id, cwd);
+            if (session && !session.auto_created) {
+                saveCurrentSession({ ...session, auto_created: true }, cwd);
+            }
+        }
+    }
+    catch { /* best-effort — write can still proceed without a persisted session */ }
+    const autoRepair = (autoRegistered || sessionAutoCreated)
+        ? {
+            ...(autoRegistered ? { agent_auto_registered: true } : {}),
+            ...(sessionAutoCreated ? { session_auto_created: sessionAutoCreated } : {}),
+        }
+        : undefined;
+    return {
+        agent_name: identity.agent_name,
+        agent_id: identity.agent_id,
+        ...(autoRepair ? { auto_repair: autoRepair } : {}),
+    };
+}
+function renderAutoRepairWarning(auto_repair, agent_name) {
+    const parts = [];
+    if (auto_repair.agent_auto_registered) {
+        parts.push(`agent '${agent_name}' auto-registered (first use). Run \`brainclaw register-agent ${agent_name}\` to set capabilities and trust level.`);
+    }
+    if (auto_repair.session_auto_created) {
+        parts.push(`session ${auto_repair.session_auto_created} auto-created for this write.`);
+    }
+    return `⚠️ auto-repair: ${parts.join(' ')}`;
 }
 function explicitSessionIdFromEnv() {
     return process.env.BRAINCLAW_SESSION_ID?.trim()
@@ -2647,6 +2749,100 @@ function blockCrossProjectExecution(entity, args) {
         return createToolErrorResponse('validation_error', error instanceof Error ? error.message : String(error));
     }
 }
+function matchesCrossProjectLink(ref, cwd) {
+    const trimmed = ref.trim();
+    if (!trimmed)
+        return false;
+    const linkRoots = new Set([path.resolve(cwd), path.resolve(resolveWorkspaceAnchor(cwd))]);
+    for (const root of linkRoots) {
+        for (const link of resolveCrossProjectLinks(root)) {
+            if (link.projectName === trimmed
+                || link.name === trimmed
+                || link.path === trimmed
+                || link.absolutePath === trimmed
+                || path.basename(link.absolutePath) === trimmed) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Resolve the destination store for an execution-entity write (plan / claim and
+ * their sub-objects: steps).
+ *
+ * The signaling-only boundary (cnd cross_project_signaling_vs_execution) forbids
+ * driving execution entities into ANOTHER project — but that rule is about
+ * FEDERATION (cross_project_links / other machines), not about workspace siblings
+ * in the same monorepo. Switching into a sibling and creating a plan there is a
+ * purely local operation, and the one the agent actually wants.
+ *
+ * So when `project=X` resolves to a workspace store-chain child (resolveProjectRef
+ * hits — it only matches projects reachable WITHIN this workspace, never a
+ * federated link), we AUTO-LOCALIZE: open a session + session-scoped switch into X
+ * (sticky, per-agent — switchProject auto-creates the session if missing), then
+ * write locally in X. Federated links and unknown names stay blocked.
+ *
+ * DGX dogfood 2026-06-27: without this an agent on the /srv monorepo cannot
+ * `bclaw_create(entity=plan, project=<child>)` — it was rejected as cross-project —
+ * so plans silently fell back to the default project instead.
+ */
+function resolveExecutionWriteTarget(entity, args, cwd, connectionSessionId) {
+    const targetProject = getCrossProjectArg(args, 'targetProject', 'target_project', 'crossProject', 'cross_project', 'project');
+    if (!targetProject) {
+        return { targetCwd: cwd, autoSwitched: false };
+    }
+    if (matchesCrossProjectLink(targetProject, cwd)) {
+        const block = blockCrossProjectExecution(entity, args);
+        return {
+            block: block ?? createToolErrorResponse('validation_error', `Cross-project execution write blocked: ${targetProject}`),
+            targetCwd: cwd,
+            autoSwitched: false,
+        };
+    }
+    // Workspace store-chain child (or the workspace root / the current project)?
+    const wsHit = resolveProjectRef(targetProject, cwd);
+    if (wsHit) {
+        // Same-workspace → auto-localize. Switch the session into X (sticky,
+        // session-scoped) so subsequent un-qualified writes follow, and persist the
+        // session under the workspace anchor where resolveEffectiveCwd probes for it
+        // — NOT the effective child cwd, or stickiness would be invisible on the next
+        // call. The switch is best-effort: the write still localizes to wsHit below.
+        let autoSwitched = false;
+        try {
+            const anchor = resolveWorkspaceAnchor(cwd);
+            const sessionId = connectionSessionId ?? explicitSessionIdFromEnv();
+            switchProject(targetProject, { cwd: anchor, sessionOnly: true, sessionId });
+            autoSwitched = true;
+        }
+        catch {
+            /* sticky switch is best-effort */
+        }
+        return { targetCwd: wsHit, autoSwitched, resolvedProject: projectInfoForCwd(wsHit) };
+    }
+    // Not a workspace child → federated link or unknown name. The signaling-only
+    // boundary stands: execution entities never cross a federation boundary.
+    const block = blockCrossProjectExecution(entity, args);
+    return {
+        block: block ?? createToolErrorResponse('validation_error', `Unknown project: ${targetProject}`),
+        targetCwd: cwd,
+        autoSwitched: false,
+    };
+}
+/**
+ * Workspace anchor for persisting a session switch — mirrors resolveEffectiveCwd's
+ * anchor selection (BRAINCLAW_CWD when it is a real store, else the outermost
+ * store walking up from cwd) so an auto-switch is found on the next resolution.
+ */
+function resolveWorkspaceAnchor(cwd) {
+    const env = process.env.BRAINCLAW_CWD?.trim();
+    if (env) {
+        const resolved = path.resolve(env);
+        if (fs.existsSync(path.join(resolved, MEMORY_DIR, 'config.yaml')))
+            return resolved;
+    }
+    return findOutermostBrainclawRoot(cwd) ?? cwd;
+}
 // Read handlers moved to mcp-read-handlers.ts
 import { handleMcpReadToolCall } from './mcp-read-handlers.js';
 export { handleMcpReadToolCall };
@@ -3300,21 +3496,17 @@ async function _executeMcpToolCallInner(payload) {
             }
         }
         if (name === 'bclaw_claim') {
-            const crossProjectError = blockCrossProjectExecution('claim', args);
-            if (crossProjectError) {
-                return { response: crossProjectError };
-            }
-            // Resolve project-scoped cwd before store resolution (fixes worktree in wrong project)
-            let effectiveClaimCwd = cwd;
-            const claimProjectArg = args.project;
-            if (claimProjectArg) {
-                const resolvedProject = resolveProjectRef(claimProjectArg, cwd);
-                if (resolvedProject)
-                    effectiveClaimCwd = resolvedProject;
-            }
+            // project=X naming a workspace sibling auto-localizes (session+switch then
+            // claim locally); federated links / unknown names stay blocked.
+            const claimLoc = resolveExecutionWriteTarget('claim', args, cwd, connectionSessionId);
+            if (claimLoc.block) {
+                return { response: claimLoc.block };
+            }
+            const effectiveClaimCwd = claimLoc.targetCwd;
+            const claimAutoSwitched = claimLoc.autoSwitched;
             const storeTarget = args.store ?? 'local';
             const claimCwd = resolveTargetStore(effectiveClaimCwd, storeTarget);
-            const resolved = ensureTrust(args, { nameField: 'agent', idField: 'agentId' }, 'contributor', claimCwd, connectionSessionId);
+            const resolved = ensureTrust(args, { nameField: 'agent', idField: 'agentId' }, 'contributor', cwd, connectionSessionId);
             if (resolved.error) {
                 return { response: createToolErrorResponse(resolved.error.kind, resolved.error.message, resolved.error.details) };
             }
@@ -3329,10 +3521,13 @@ async function _executeMcpToolCallInner(payload) {
                 return { response: createToolErrorResponse('validation_error', descCheck.message) };
             }
             const resolvedIdentity = resolved.identity;
-            const identity = buildOperationalIdentity(resolvedIdentity.agent_name, claimCwd, {
-                agentId: resolvedIdentity.agent_id,
-                sessionId: connectionSessionId,
-            });
+            const identity = {
+                ...buildOperationalIdentity(resolvedIdentity.agent_name, cwd, {
+                    agentId: resolvedIdentity.agent_id,
+                    sessionId: connectionSessionId,
+                }),
+                project_id: loadConfig(claimCwd).project_id,
+            };
             const claimId = generateClaimId();
             let worktreePath;
             let worktreeWarn = '';
@@ -3438,7 +3633,8 @@ async function _executeMcpToolCallInner(payload) {
             const worktreeNote = worktreePath ? `\n  Worktree: ${worktreePath}` : '';
             const expiryNote = claimExpiresAt ? `\n  Expires: ${claimExpiresAt.slice(0, 16).replace('T', ' ')} UTC` : '';
             const handoffNote = handoffMode ? `\n  Handoff: ${handoffMode} (another agent will review and merge)` : '';
-            const claimText = `✔ Claimed scope [${claimId}]${worktreeNote}${expiryNote}${handoffNote}${noPlanWarn}${worktreeWarn}${branchWarn}${staleBranchWarn}${policyWarn}${postClaimText ? `\n${postClaimText}` : ''}`;
+            const autoSwitchNote = claimAutoSwitched ? `\n  Auto-switched → ${projectInfoForCwd(effectiveClaimCwd).name ?? effectiveClaimCwd}` : '';
+            const claimText = `✔ Claimed scope [${claimId}]${worktreeNote}${expiryNote}${handoffNote}${autoSwitchNote}${noPlanWarn}${worktreeWarn}${branchWarn}${staleBranchWarn}${policyWarn}${postClaimText ? `\n${postClaimText}` : ''}`;
             return {
                 response: appendLegacyMcpToolWarning(toolResponse({
                     content: [{ type: 'text', text: claimText }],
@@ -3446,6 +3642,7 @@ async function _executeMcpToolCallInner(payload) {
                     session_id: identity.session_id,
                     worktree_path: worktreePath,
                     triggered_items: postClaimItems,
+                    ...(claimAutoSwitched ? { auto_switched: true, resolved_project: projectInfoForCwd(effectiveClaimCwd) } : {}),
                 }), name),
                 nextConnectionSessionId: explicitSessionIdFromEnv() ? undefined : identity.session_id,
             };
@@ -3465,18 +3662,43 @@ async function _executeMcpToolCallInner(payload) {
             catch {
                 return { response: createToolErrorResponse('not_found', `Claim not found: ${claimId}`) };
             }
-            // pln#562 step 5 — release is ownership-checked like acquisition and
-            // adoption. The resolved principal must own the claim; trusted+ callers
-            // (coordinators) may release others' claims, with an audit entry.
+            // pln#562 step 5 + trp#928 — release is ownership-checked like acquisition
+            // and adoption. Under the trp#928 tightening the coordinator override is
+            // OPT-IN via coordinator_override:true (implicit "trusted+ = always
+            // override" was too magic — a coordinator releasing a worker's claim
+            // should be a visible act, not a silent side-effect of trust). The
+            // ownership check still enforces:
+            //   - owner-of-claim releases (identity matches): allowed, no override needed
+            //   - non-owner releases without coordinator_override: rejected loudly (the
+            //     error message points the caller at coordinator_override so it is
+            //     executable — pln#607 rule).
+            //   - non-owner releases with coordinator_override:true but not trusted+:
+            //     trust_error (privilege escalation prevention).
+            //   - non-owner releases with coordinator_override:true and trusted+:
+            //     allowed, audited (auditReleaseOverride).
             const releaseIdentity = resolveMutationIdentity(args, { nameField: 'agent', idField: 'agentId' }, cwd, connectionSessionId);
-            const releaseAuth = 'identity' in releaseIdentity && releaseIdentity.identity
-                ? {
-                    agent: releaseIdentity.identity.agent_name,
-                    agent_id: releaseIdentity.identity.agent_id,
-                    session_id: connectionSessionId,
-                    override: hasMinimumTrustLevel(releaseIdentity.identity.trust_level ?? 'contributor', 'trusted'),
+            if ('error' in releaseIdentity && releaseIdentity.error) {
+                const { kind, message, details } = releaseIdentity.error;
+                return { response: createToolErrorResponse(kind, message, details) };
+            }
+            if (!('identity' in releaseIdentity) || !releaseIdentity.identity) {
+                return { response: createToolErrorResponse('identity_error', 'No registered agent identity resolved for bclaw_release_claim.') };
+            }
+            const coordinatorOverrideRequested = args.coordinator_override === true;
+            if (coordinatorOverrideRequested) {
+                const trustLevel = releaseIdentity.identity.trust_level ?? 'contributor';
+                if (!hasMinimumTrustLevel(trustLevel, 'trusted')) {
+                    return {
+                        response: createToolErrorResponse('trust_error', `coordinator_override:true requires trust_level 'trusted' or higher — caller is '${trustLevel}'. Ask a curator to elevate the agent, or have the claim owner release it.`),
+                    };
                 }
-                : undefined;
+            }
+            const releaseAuth = {
+                agent: releaseIdentity.identity.agent_name,
+                agent_id: releaseIdentity.identity.agent_id,
+                session_id: connectionSessionId,
+                override: coordinatorOverrideRequested,
+            };
             let cascadeResult;
             try {
                 cascadeResult = releaseClaimWithCascade(claimId, {
@@ -3971,6 +4193,39 @@ async function _executeMcpToolCallInner(payload) {
                     actor: callerAgent,
                     actor_id: resolved.identity.agent_id,
                 }, cwd);
+                // trp#928 — cascade-release the assignment's linked claim on completion.
+                // Before this landing an obedient worker had to make TWO calls to close
+                // the loop (bclaw_assignment_update status=completed AND
+                // bclaw_release_claim); dispatch briefs enumerate both, but not every
+                // sandboxed worker gets through both, and the coordinator's harvest path
+                // only releases on --integrate — so contributor-driven completions left
+                // claims active. The worker's own identity owns the claim (session
+                // adoption), so ownership matches and no coordinator_override is needed.
+                // Silent success/failure is unacceptable: log per-claim outcome.
+                if (status === 'completed' && assignment.claim_id) {
+                    try {
+                        const { releaseClaimsCascade, logCascadeReleaseResult } = await import('../core/claims.js');
+                        const cascade = releaseClaimsCascade([assignment.claim_id], {
+                            cwd,
+                            planStatus: 'done',
+                            auth: {
+                                agent: callerAgent,
+                                agent_id: resolved.identity.agent_id,
+                                session_id: effectiveSessionId,
+                                override: false,
+                            },
+                        });
+                        logCascadeReleaseResult({
+                            actor: callerAgent,
+                            trigger: 'assignment_completed',
+                            assignment_id: assignmentId,
+                            claim_id: assignment.claim_id,
+                            cascade,
+                            cwd,
+                        });
+                    }
+                    catch { /* never block the update on cascade release */ }
+                }
                 // When accepted: auto-acknowledge the inbox message (replaces bclaw_ack_message)
                 if (status === 'accepted' && assignment.message_id) {
                     try {
@@ -4232,9 +4487,9 @@ async function _executeMcpToolCallInner(payload) {
             }
         }
         if (name === 'bclaw_add_step') {
-            const crossProjectError = blockCrossProjectExecution('plan', args);
-            if (crossProjectError) {
-                return { response: crossProjectError };
+            const stepLoc = resolveExecutionWriteTarget('plan', args, cwd, connectionSessionId);
+            if (stepLoc.block) {
+                return { response: stepLoc.block };
             }
             const resolved = ensureTrust(args, { nameField: 'agent', idField: 'agentId' }, 'contributor', cwd, connectionSessionId);
             if (resolved.error) {
@@ -4256,7 +4511,7 @@ async function _executeMcpToolCallInner(payload) {
                 return { response: createToolErrorResponse('validation_error', 'Missing required argument: planId') };
             if (!stepText)
                 return { response: createToolErrorResponse('validation_error', 'Missing required argument: data.text') };
-            const stepTargetCwd = resolveProjectCwd(args.project, cwd);
+            const stepTargetCwd = stepLoc.targetCwd;
             try {
                 const result = addStepOp({ planId: stepPlanId, text: stepText, assignee: stepAssignee, estimatedEffort: stepEstimated, actualEffort: stepActual }, stepTargetCwd);
                 return {
@@ -4277,9 +4532,9 @@ async function _executeMcpToolCallInner(payload) {
             }
         }
         if (name === 'bclaw_complete_step') {
-            const crossProjectError = blockCrossProjectExecution('plan', args);
-            if (crossProjectError) {
-                return { response: crossProjectError };
+            const csLoc = resolveExecutionWriteTarget('plan', args, cwd, connectionSessionId);
+            if (csLoc.block) {
+                return { response: csLoc.block };
             }
             const resolved = ensureTrust(args, { nameField: 'agent', idField: 'agentId' }, 'contributor', cwd, connectionSessionId);
             if (resolved.error) {
@@ -4291,7 +4546,7 @@ async function _executeMcpToolCallInner(payload) {
                 return { response: createToolErrorResponse('validation_error', 'Missing required argument: planId') };
             if (!csStepId)
                 return { response: createToolErrorResponse('validation_error', 'Missing required argument: stepId') };
-            const csTargetCwd = resolveProjectCwd(args.project, cwd);
+            const csTargetCwd = csLoc.targetCwd;
             try {
                 const result = completeStepOp({ planId: csPlanId, stepId: csStepId }, csTargetCwd);
                 return {
@@ -4313,9 +4568,9 @@ async function _executeMcpToolCallInner(payload) {
             }
         }
         if (name === 'bclaw_update_step') {
-            const crossProjectError = blockCrossProjectExecution('plan', args);
-            if (crossProjectError) {
-                return { response: crossProjectError };
+            const usLoc = resolveExecutionWriteTarget('plan', args, cwd, connectionSessionId);
+            if (usLoc.block) {
+                return { response: usLoc.block };
             }
             const resolved = ensureTrust(args, { nameField: 'agent', idField: 'agentId' }, 'contributor', cwd, connectionSessionId);
             if (resolved.error) {
@@ -4331,7 +4586,7 @@ async function _executeMcpToolCallInner(payload) {
             if (args.status && !validStatuses.includes(String(args.status))) {
                 return { response: createToolErrorResponse('validation_error', `Invalid status: ${args.status}. Valid: ${validStatuses.join(', ')}`) };
             }
-            const usTargetCwd = resolveProjectCwd(args.project, cwd);
+            const usTargetCwd = usLoc.targetCwd;
             try {
                 const result = updateStepOp({
                     planId: usPlanId,
@@ -4372,9 +4627,9 @@ async function _executeMcpToolCallInner(payload) {
             }
         }
         if (name === 'bclaw_delete_step') {
-            const crossProjectError = blockCrossProjectExecution('plan', args);
-            if (crossProjectError) {
-                return { response: crossProjectError };
+            const dsLoc = resolveExecutionWriteTarget('plan', args, cwd, connectionSessionId);
+            if (dsLoc.block) {
+                return { response: dsLoc.block };
             }
             const resolved = ensureTrust(args, { nameField: 'agent', idField: 'agentId' }, 'contributor', cwd, connectionSessionId);
             if (resolved.error) {
@@ -4386,7 +4641,7 @@ async function _executeMcpToolCallInner(payload) {
                 return { response: createToolErrorResponse('validation_error', 'Missing required argument: planId') };
             if (!dsStepId)
                 return { response: createToolErrorResponse('validation_error', 'Missing required argument: stepId') };
-            const dsTargetCwd = resolveProjectCwd(args.project, cwd);
+            const dsTargetCwd = dsLoc.targetCwd;
             try {
                 const result = deleteStepOp({ planId: dsPlanId, stepId: dsStepId }, dsTargetCwd);
                 return {
@@ -4407,10 +4662,11 @@ async function _executeMcpToolCallInner(payload) {
             }
         }
         if (name === 'bclaw_delete_plan') {
-            const crossProjectError = blockCrossProjectExecution('plan', args);
-            if (crossProjectError) {
-                return { response: crossProjectError };
+            const dpLoc = resolveExecutionWriteTarget('plan', args, cwd, connectionSessionId);
+            if (dpLoc.block) {
+                return { response: dpLoc.block };
             }
+            const dpTargetCwd = dpLoc.targetCwd;
             const resolved = ensureTrust(args, { nameField: 'agent', idField: 'agentId' }, 'trusted', cwd, connectionSessionId);
             if (resolved.error) {
                 return { response: createToolErrorResponse(resolved.error.kind, resolved.error.message, resolved.error.details) };
@@ -4419,7 +4675,7 @@ async function _executeMcpToolCallInner(payload) {
             if (!dpId)
                 return { response: createToolErrorResponse('validation_error', 'Missing required argument: id') };
             try {
-                const result = deletePlanOp(dpId, cwd);
+                const result = deletePlanOp(dpId, dpTargetCwd);
                 return {
                     response: toolResponse({
                         content: [{ type: 'text', text: `✔ Plan deleted: [${result.id}] ${result.text.slice(0, 80)}` }],
@@ -6418,17 +6674,38 @@ async function _executeMcpToolCallInner(payload) {
                 // only checks known keys), letting the caller believe the filter had
                 // applied when it hadn't. Under the new contract, an unknown key is
                 // a validation_error listing the keys actually honored.
+                // trp#928 — the entity-scoping error is now first-class: the doc says
+                // assignment_id/claim_id/message_id are entity='agent_run' only, but
+                // before this the rejection message called them 'unknown', misleading
+                // callers who'd cross-reference the description. Now the message names
+                // the constraint AND the entity that DOES accept the key so the user
+                // can fix the call without hunting through docs. (pln#599 docs-vs-facts.)
                 const KNOWN_FILTER_KEYS = new Set([
                     'status', 'tag', 'tags', 'author', 'plan_id', 'source', 'auto_generated',
                     'assignment_id', 'claim_id', 'message_id',
                     'limit', 'offset', 'includeLegacy', 'minAutoReflectConfidence',
                 ]);
                 const agentRunOnlyFilterKeys = new Set(['assignment_id', 'claim_id', 'message_id']);
-                const unknownKeys = Object.keys(filter).filter((k) => !KNOWN_FILTER_KEYS.has(k) || (agentRunOnlyFilterKeys.has(k) && entity !== 'agent_run'));
-                if (unknownKeys.length > 0) {
+                const providedKeys = Object.keys(filter);
+                const unknownKeys = providedKeys.filter((k) => !KNOWN_FILTER_KEYS.has(k));
+                const misScopedKeys = providedKeys.filter((k) => agentRunOnlyFilterKeys.has(k) && entity !== 'agent_run');
+                if (unknownKeys.length > 0 || misScopedKeys.length > 0) {
+                    const parts = [];
+                    if (unknownKeys.length > 0) {
+                        parts.push(`Unknown filter key(s): ${unknownKeys.map((k) => `"${k}"`).join(', ')}. Accepted keys: ${[...KNOWN_FILTER_KEYS].sort().join(', ')}.`);
+                    }
+                    if (misScopedKeys.length > 0) {
+                        parts.push(`Filter key(s) ${misScopedKeys.map((k) => `"${k}"`).join(', ')} are only valid for entity="agent_run" `
+                            + `(this call used entity="${entity}"). `
+                            + `Retry with entity="agent_run", or drop the ${misScopedKeys.join('/')} filter.`);
+                    }
                     return {
-                        response: createToolErrorResponse('validation_error', `Unknown filter key(s): ${unknownKeys.map((k) => `"${k}"`).join(', ')}. ` +
-                            `Accepted keys: ${[...KNOWN_FILTER_KEYS].sort().join(', ')}.`, { unknown_keys: unknownKeys, accepted_keys: [...KNOWN_FILTER_KEYS].sort() }),
+                        response: createToolErrorResponse('validation_error', parts.join(' '), {
+                            unknown_keys: unknownKeys,
+                            mis_scoped_keys: misScopedKeys,
+                            accepted_keys: [...KNOWN_FILTER_KEYS].sort(),
+                            agent_run_only_keys: [...agentRunOnlyFilterKeys],
+                        }),
                     };
                 }
                 const result = listEntities(entity, targetCwd, filter);
@@ -6537,15 +6814,22 @@ async function _executeMcpToolCallInner(payload) {
         if (name === 'bclaw_create') {
             try {
                 const entity = String(args.entity ?? '');
-                // Execution entities stay local: the signaling-only cross-project
-                // boundary applies to the canonical verbs too, not just legacy tools.
+                // Execution entities (plan/claim) auto-localize into a workspace sibling
+                // when project=X names one: session+switch then write locally. Only
+                // federated links / unknown names are blocked (signaling-only boundary).
+                let targetCwd;
+                let autoSwitched = false;
                 if (entity === 'claim' || entity === 'plan') {
-                    const crossProjectError = blockCrossProjectExecution(entity, args);
-                    if (crossProjectError)
-                        return { response: crossProjectError };
+                    const loc = resolveExecutionWriteTarget(entity, args, cwd, connectionSessionId);
+                    if (loc.block)
+                        return { response: loc.block };
+                    targetCwd = loc.targetCwd;
+                    autoSwitched = loc.autoSwitched;
+                }
+                else {
+                    targetCwd = resolveProjectCwd(args.project, cwd);
                 }
                 const rawData = (args.data ?? {});
-                const targetCwd = resolveProjectCwd(args.project, cwd);
                 const targetScope = scopeMetadataForTarget(args, targetCwd, scopeInfo);
                 // Auto-fill identity fields. Without this, a caller who omits author/agent
                 // creates a schema-invalid record that is silently dropped on read and
@@ -6560,28 +6844,36 @@ async function _executeMcpToolCallInner(payload) {
                 const data = { ...rawData };
                 let actor = typeof data.author === 'string' ? data.author : undefined;
                 let actorId = typeof data.agent_id === 'string' ? data.agent_id : undefined;
+                let autoRepair;
                 if (data.author === undefined) {
-                    const { agent_name, agent_id } = resolveCanonicalAuthor(args, cwd, connectionSessionId);
-                    data.author = agent_name;
+                    const author = resolveCanonicalAuthor(args, cwd, connectionSessionId);
+                    data.author = author.agent_name;
                     if (data.agent === undefined)
-                        data.agent = agent_name;
-                    if (data.agent_id === undefined && agent_id)
-                        data.agent_id = agent_id;
-                    actor = agent_name;
-                    actorId = agent_id;
+                        data.agent = author.agent_name;
+                    if (data.agent_id === undefined && author.agent_id)
+                        data.agent_id = author.agent_id;
+                    actor = author.agent_name;
+                    actorId = author.agent_id;
+                    autoRepair = author.auto_repair;
                 }
                 else if (data.agent === undefined) {
                     data.agent = data.author;
                 }
                 const result = createEntity(entity, data, targetCwd);
                 appendAuditEntry({ actor: actor ?? 'unknown', ...(actorId ? { actor_id: actorId } : {}), action: 'create', item_id: result.id, item_type: entity }, targetCwd);
+                const createText = `✔ created ${entity} ${result.id}${autoSwitched ? ` (auto-switched → ${targetScope.resolved_project.name ?? targetScope.resolved_project.path})` : ''}`;
+                const createContent = autoRepair
+                    ? [{ type: 'text', text: createText }, { type: 'text', text: renderAutoRepairWarning(autoRepair, actor ?? 'unknown') }]
+                    : [{ type: 'text', text: createText }];
                 return {
                     response: toolResponse({
-                        content: [{ type: 'text', text: `✔ created ${entity} ${result.id}` }],
+                        content: createContent,
                         structuredContent: {
                             ...result,
                             resolved_project: targetScope.resolved_project,
-                            active_source: targetScope.active_source,
+                            active_source: autoSwitched ? 'auto_switch' : targetScope.active_source,
+                            ...(autoSwitched ? { auto_switched: true } : {}),
+                            ...(autoRepair ? { auto_repair: autoRepair } : {}),
                         },
                     }),
                 };
@@ -6597,16 +6889,21 @@ async function _executeMcpToolCallInner(payload) {
                 const patch = (args.patch ?? {});
                 const targetCwd = resolveProjectCwd(args.project, cwd);
                 const targetScope = scopeMetadataForTarget(args, targetCwd, scopeInfo);
-                const { agent_name, agent_id } = resolveCanonicalAuthor(args, cwd, connectionSessionId);
+                const { agent_name, agent_id, auto_repair } = resolveCanonicalAuthor(args, cwd, connectionSessionId);
                 const result = updateEntity(entity, id, patch, targetCwd);
                 appendAuditEntry({ actor: agent_name, ...(agent_id ? { actor_id: agent_id } : {}), action: 'update', item_id: id, item_type: entity }, targetCwd);
+                const updateText = `✔ updated ${entity} ${id}`;
+                const updateContent = auto_repair
+                    ? [{ type: 'text', text: updateText }, { type: 'text', text: renderAutoRepairWarning(auto_repair, agent_name) }]
+                    : [{ type: 'text', text: updateText }];
                 return {
                     response: toolResponse({
-                        content: [{ type: 'text', text: `✔ updated ${entity} ${id}` }],
+                        content: updateContent,
                         structuredContent: {
                             ...result,
                             resolved_project: targetScope.resolved_project,
                             active_source: targetScope.active_source,
+                            ...(auto_repair ? { auto_repair } : {}),
                         },
                     }),
                 };
@@ -6622,16 +6919,21 @@ async function _executeMcpToolCallInner(payload) {
                 const purge = args.purge === true;
                 const targetCwd = resolveProjectCwd(args.project, cwd);
                 const targetScope = scopeMetadataForTarget(args, targetCwd, scopeInfo);
-                const { agent_name, agent_id } = resolveCanonicalAuthor(args, cwd, connectionSessionId);
+                const { agent_name, agent_id, auto_repair } = resolveCanonicalAuthor(args, cwd, connectionSessionId);
                 const result = removeEntity(entity, id, targetCwd, purge);
                 appendAuditEntry({ actor: agent_name, ...(agent_id ? { actor_id: agent_id } : {}), action: 'delete', item_id: id, item_type: entity, reason: purge ? 'purged' : 'archived' }, targetCwd);
+                const removeText = `✔ removed ${entity} ${id}`;
+                const removeContent = auto_repair
+                    ? [{ type: 'text', text: removeText }, { type: 'text', text: renderAutoRepairWarning(auto_repair, agent_name) }]
+                    : [{ type: 'text', text: removeText }];
                 return {
                     response: toolResponse({
-                        content: [{ type: 'text', text: `✔ removed ${entity} ${id}` }],
+                        content: removeContent,
                         structuredContent: {
                             ...result,
                             resolved_project: targetScope.resolved_project,
                             active_source: targetScope.active_source,
+                            ...(auto_repair ? { auto_repair } : {}),
                         },
                     }),
                 };
@@ -6647,13 +6949,20 @@ async function _executeMcpToolCallInner(payload) {
                 const toProject = String(args.to_project ?? '');
                 const fromProject = typeof args.from_project === 'string' ? args.from_project : undefined;
                 const force = args.force === true;
-                const { agent_name, agent_id } = resolveCanonicalAuthor(args, cwd, connectionSessionId);
+                const { agent_name, agent_id, auto_repair } = resolveCanonicalAuthor(args, cwd, connectionSessionId);
                 const result = relocateEntity({ entity, id, toProject, fromProject, force, cwd, actor: agent_name, actorId: agent_id });
                 const warn = result.warnings.length ? ` (${result.warnings.length} warning(s))` : '';
+                const moveText = `✔ moved ${entity} ${id} → ${result.to}${warn}`;
+                const moveContent = auto_repair
+                    ? [{ type: 'text', text: moveText }, { type: 'text', text: renderAutoRepairWarning(auto_repair, agent_name) }]
+                    : [{ type: 'text', text: moveText }];
                 return {
                     response: toolResponse({
-                        content: [{ type: 'text', text: `✔ moved ${entity} ${id} → ${result.to}${warn}` }],
-                        structuredContent: { ...result },
+                        content: moveContent,
+                        structuredContent: {
+                            ...result,
+                            ...(auto_repair ? { auto_repair } : {}),
+                        },
                     }),
                 };
             }
@@ -6664,28 +6973,67 @@ async function _executeMcpToolCallInner(payload) {
         if (name === 'bclaw_transition') {
             try {
                 const entity = String(args.entity ?? '');
-                // Same signaling-only boundary as bclaw_create: no remote lifecycle
-                // driving of execution entities through the canonical grammar.
+                // Same auto-localize as bclaw_create: a workspace sibling named by
+                // project=X is switched into and transitioned locally; only federated
+                // links / unknown names are blocked (signaling-only boundary).
+                let targetCwd;
+                let autoSwitched = false;
                 if (entity === 'claim' || entity === 'plan') {
-                    const crossProjectError = blockCrossProjectExecution(entity, args);
-                    if (crossProjectError)
-                        return { response: crossProjectError };
+                    const loc = resolveExecutionWriteTarget(entity, args, cwd, connectionSessionId);
+                    if (loc.block)
+                        return { response: loc.block };
+                    targetCwd = loc.targetCwd;
+                    autoSwitched = loc.autoSwitched;
+                }
+                else {
+                    targetCwd = resolveProjectCwd(args.project, cwd);
                 }
                 const id = String(args.id ?? '');
                 const to = String(args.to ?? '');
                 const reason = args.reason;
-                const targetCwd = resolveProjectCwd(args.project, cwd);
                 const targetScope = scopeMetadataForTarget(args, targetCwd, scopeInfo);
-                const { agent_name, agent_id } = resolveCanonicalAuthor(args, cwd, connectionSessionId);
-                const result = transitionEntity(entity, id, to, targetCwd, reason);
+                const { agent_name, agent_id, auto_repair } = resolveCanonicalAuthor(args, cwd, connectionSessionId);
+                // trp#928 — claim transitions consume the ReleaseClaimAuth ownership
+                // check (released/stale both mutate a claim owned by SOME agent). Reuse
+                // the same coordinator_override opt-in as bclaw_release_claim so both
+                // paths have identical trust semantics and the same executable error.
+                let transitionAuth;
+                if (entity === 'claim') {
+                    const transitionIdentity = resolveMutationIdentity(args, { nameField: 'agent', idField: 'agentId' }, targetCwd, connectionSessionId);
+                    const coordinatorOverrideRequested = args.coordinator_override === true;
+                    if (coordinatorOverrideRequested) {
+                        const identity = 'identity' in transitionIdentity ? transitionIdentity.identity : undefined;
+                        const trustLevel = identity?.trust_level ?? 'contributor';
+                        if (!hasMinimumTrustLevel(trustLevel, 'trusted')) {
+                            return {
+                                response: createToolErrorResponse('trust_error', `coordinator_override:true requires trust_level 'trusted' or higher — caller is '${trustLevel}'.`),
+                            };
+                        }
+                    }
+                    transitionAuth = 'identity' in transitionIdentity && transitionIdentity.identity
+                        ? {
+                            agent: transitionIdentity.identity.agent_name,
+                            agent_id: transitionIdentity.identity.agent_id,
+                            session_id: connectionSessionId,
+                            override: coordinatorOverrideRequested,
+                        }
+                        : undefined;
+                }
+                const result = transitionEntity(entity, id, to, targetCwd, reason, transitionAuth);
                 appendAuditEntry({ actor: agent_name, ...(agent_id ? { actor_id: agent_id } : {}), action: 'update', item_id: id, item_type: entity, reason: `transition ${result.from} → ${to}${reason ? ` (${reason})` : ''}` }, targetCwd);
+                const transitionText = `✔ ${entity} ${id}: ${result.from} → ${to}${autoSwitched ? ` (auto-switched → ${targetScope.resolved_project.name ?? targetScope.resolved_project.path})` : ''}`;
+                const transitionContent = auto_repair
+                    ? [{ type: 'text', text: transitionText }, { type: 'text', text: renderAutoRepairWarning(auto_repair, agent_name) }]
+                    : [{ type: 'text', text: transitionText }];
                 return {
                     response: toolResponse({
-                        content: [{ type: 'text', text: `✔ ${entity} ${id}: ${result.from} → ${to}` }],
+                        content: transitionContent,
                         structuredContent: {
                             ...result,
                             resolved_project: targetScope.resolved_project,
-                            active_source: targetScope.active_source,
+                            active_source: autoSwitched ? 'auto_switch' : targetScope.active_source,
+                            ...(autoSwitched ? { auto_switched: true } : {}),
+                            ...(auto_repair ? { auto_repair } : {}),
                         },
                     }),
                 };