beehaven 0.8.33 → 0.8.35

package/dist/commands/agent.js

@@ -91,6 +91,60 @@ async function endWorkspaceSession(record, summary) {
         return false;
     }
 }
+/** `team/<id>` → the `--building` form `resolveBuilding` takes; home → undefined. */
+function buildingFor(address) {
+    if (!address || !address.includes('/'))
+        return undefined;
+    const i = address.indexOf('/');
+    return `${address.slice(0, i)}:${address.slice(i + 1)}`;
+}
+/** Workspace DOs hold agent work sessions; a store or a local app does not. */
+function holdsWorkSessions(address) {
+    return !address.includes('/') || /^(team|workspace)\//.test(address);
+}
+/**
+ * Run an action in a given workspace (AWO-394) — the session lives in the workspace it works in,
+ * not in whichever one the daemon happens to dial. Home goes direct; others through the proxy.
+ */
+async function rpcIn(address, action, input, timeout) {
+    const { resolveBuilding } = await import('./workspace.js');
+    const routed = resolveBuilding(action, input, buildingFor(address));
+    return rpcOnce(routed.action, routed.input, timeout);
+}
+/**
+ * "hive2 (workspace/98bef9…)" rather than a bare id — what an agent reads to know where it is.
+ * Best-effort: the account roster (`workspace:list`), falling back to the address itself.
+ */
+async function workspaceLabel(address) {
+    const { describeAddress } = await import('../session-binding.js');
+    const plain = describeAddress(address);
+    if (address.includes('/') && !/^(team|workspace)\//.test(address))
+        return plain;
+    try {
+        const { daemonRpc } = await import('../daemon-client.js');
+        const res = await Promise.race([daemonRpc('workspace:list', {}), new Promise((r) => setTimeout(() => r(null), 4_000))]);
+        const inner = res?.result ?? res;
+        const id = address.includes('/') ? address.slice(address.indexOf('/') + 1) : String(inner?.current ?? '');
+        const hit = (inner?.workspaces ?? []).find((w) => String(w?.id ?? '') === id);
+        if (hit?.name)
+            return address.includes('/') ? `${hit.name}  (${plain})` : `${hit.name} — home (your default workspace)`;
+    }
+    catch { /* the roster is a nicety */ }
+    return plain;
+}
+/** End one work session where it lives. Best-effort, like `endWorkspaceSession`. */
+async function endSessionIn(address, sessionId, agentId, summary) {
+    try {
+        const r = await rpcIn(address, 'agent-session-end', {
+            id: sessionId, agentId, ...(summary?.trim() ? { summary: summary.trim() } : {}),
+        }, 5_000);
+        const result = r?.result ?? r;
+        return result?.ok !== false && !result?.error;
+    }
+    catch {
+        return false;
+    }
+}
 const dim = (s) => `\x1b[2m${s}\x1b[0m`;
 const green = (s) => `\x1b[32m${s}\x1b[0m`;
 const bold = (s) => `\x1b[1m${s}\x1b[0m`;
@@ -701,7 +755,38 @@ async function agentLogin(args, values) {
      * actually began. `existingRecord` is read before the write for exactly this.
      */
     const birthday = existingRecord?.birthday ?? new Date().toISOString();
-    const previousSessionEnded = await endWorkspaceSession(existingRecord);
+    /**
+     * ⚠⚠ ONE SESSION = THIS PROCESS SCOPE (AWO-394). A re-login replaces the session THIS scope had,
+     * and nothing else: it used to end `record.sessionId` — one field shared by every terminal using
+     * the name — so logging in from a second terminal closed the first terminal's session and both
+     * then wrote under the new one.
+     */
+    const { deriveAgentScope } = await import('../agent-scope.js');
+    const { readSessionBinding, writeSessionBinding, currentEnvName, normalizeWorkspaceAddress, describeAddress, } = await import('../session-binding.js');
+    const { writeTargetForScope, readTargetForKey } = await import('../cli-state.js');
+    const scope = deriveAgentScope();
+    const priorBinding = scope ? readSessionBinding(scope) : null;
+    if (priorBinding?.sessionId)
+        await endSessionIn(priorBinding.workspace, priorBinding.sessionId, minted.agentId);
+    /**
+     * WHERE THIS SESSION WORKS: `--workspace`, else where this identity last worked, else home. The
+     * identity's last workspace is what keeps a durable agent from losing its place each conversation
+     * — the reason the cursor used to be keyed on the agent name — without letting one live session
+     * move another.
+     */
+    const requestedWorkspace = typeof values.workspace === 'string' ? values.workspace.trim() : '';
+    const normalizedRequest = requestedWorkspace ? normalizeWorkspaceAddress(requestedWorkspace) : null;
+    if (requestedWorkspace && !normalizedRequest) {
+        console.error(`  Unrecognised workspace "${requestedWorkspace}".`);
+        console.error('  Use: home · team/<id> · workspace/<id> · a 64-character workspace id   (beehaven workspaces lists them)');
+        process.exit(1);
+    }
+    const legacyCursor = readTargetForKey(name)?.address;
+    const chosenWorkspace = normalizedRequest
+        || existingRecord?.lastWorkspace
+        || (legacyCursor ? normalizeWorkspaceAddress(legacyCursor) : null)
+        || 'workspace';
+    const sessionEnv = currentEnvName();
     /**
      * ⚠⚠ FILL THE LIFETIME FIELDS FROM THE TOKEN — the cloud mint path does not
      * return them and a record without `expiresAt` can never be seen as expired.
@@ -740,8 +825,9 @@ async function agentLogin(args, values) {
          * resuming is least recoverable.
          */
         ...(existingRecord?.boundScopes ? { boundScopes: existingRecord.boundScopes } : {}),
-        ...(!previousSessionEnded && existingRecord?.sessionId ? { sessionId: existingRecord.sessionId } : {}),
+        ...(existingRecord?.sessionId ? { sessionId: existingRecord.sessionId } : {}),
         ...(existingRecord?.lastLoginAt ? { lastLoginAt: existingRecord.lastLoginAt } : {}),
+        lastWorkspace: chosenWorkspace,
     };
     saveAgent(name, record);
     /**
@@ -754,10 +840,14 @@ async function agentLogin(args, values) {
      * instead of silently replaced. The family (what un-logged-in sessions inherit) is claimed
      * below, only once a session actually starts.
      */
-    const { deriveAgentScope } = await import('../agent-scope.js');
     const { bindAgentScope, agentForScope, loginSessionOutcome } = await import('../agent-state.js');
-    const scope = deriveAgentScope();
     bindAgentScope(name, scope, { family: false });
+    // The session record: identity + workspace + env, owned by this scope alone. Written before the
+    // workspace answers for the same reason the binding is — a refused login must still own its scope.
+    if (scope) {
+        writeSessionBinding({ scope, agent: name, workspace: chosenWorkspace, env: sessionEnv, boundAt: Date.now() });
+        writeTargetForScope(scope, chosenWorkspace, chosenWorkspace === 'workspace' ? 'cloud' : undefined);
+    }
     // Sync to Electron store if present
     try {
         const p = join(homedir(), 'Library', 'Application Support', 'clearly-desktop', 'config.json');
@@ -821,18 +911,36 @@ async function agentLogin(args, values) {
     // `loginSessionOutcome` — and is reported, never swallowed.
     let started;
     let thrown;
-    try {
-        started = await rpcOnce('agent-session-start', {
-            agentId: record.agentId,
-            client: String(values.client ?? 'cli').trim() || 'cli',
-            label: String(values.label ?? '').trim() || undefined,
-            expiresAt: record.expiresAt,
-        }, 15_000);
+    const sessionInput = {
+        agentId: record.agentId,
+        client: String(values.client ?? 'cli').trim() || 'cli',
+        label: String(values.label ?? '').trim() || undefined,
+        expiresAt: record.expiresAt,
+    };
+    if (holdsWorkSessions(chosenWorkspace)) {
+        try {
+            // ⚠ IN THE SESSION'S WORKSPACE (AWO-394) — it used to open in the daemon's default
+            // workspace whatever the cursor said, and that id then rode on calls to other workspaces.
+            started = await rpcIn(chosenWorkspace, 'agent-session-start', sessionInput, 15_000);
+            const first = loginSessionOutcome(started);
+            // An identity is the ACCOUNT's; each workspace admits it once. Same self-heal `call` does.
+            if (first.kind === 'refused' && chosenWorkspace !== 'workspace' && /unknown agent|not admitted|unknown-agent/i.test(`${first.scope} ${first.reason}`)) {
+                const admitted = await rpcIn(chosenWorkspace, 'agent-admit', { agentId: record.agentId }, 20_000).catch(() => null);
+                if ((admitted?.result ?? admitted)?.ok)
+                    started = await rpcIn(chosenWorkspace, 'agent-session-start', sessionInput, 15_000);
+            }
+        }
+        catch (err) {
+            thrown = err ?? new Error('agent-session-start failed');
+        }
     }
-    catch (err) {
-        thrown = err ?? new Error('agent-session-start failed');
+    const outcome = holdsWorkSessions(chosenWorkspace)
+        ? loginSessionOutcome(started, thrown)
+        : { kind: 'unreachable', reason: 'a store keeps no agent work sessions' };
+    if (outcome.kind === 'started' && scope) {
+        const { updateSessionBinding } = await import('../session-binding.js');
+        updateSessionBinding(scope, { sessionId: outcome.sessionId });
     }
-    const outcome = loginSessionOutcome(started, thrown);
     if (outcome.kind === 'started') {
         saveAgentSession(name, outcome.sessionId);
         /**
@@ -876,8 +984,11 @@ async function agentLogin(args, values) {
         if (scope) {
             const resolved = agentForScope(scope);
             if (resolved === name) {
-                console.log(`  ${green('✓')} Bound to this session (${cyan(scope)}) — every call here now runs as ${cyan(name)}.`);
-                console.log(dim('    Other terminals: export BEEHAVEN_AGENT=' + name));
+                console.log(`  This session  ${cyan(scope)}`);
+                console.log(`    Agent       ${cyan(name)}${dim('   every beehaven command here runs as this agent — nothing to pass per call')}`);
+                console.log(`    Workspace   ${cyan(await workspaceLabel(chosenWorkspace))}${dim('   switch: beehaven connect <workspace>')}`);
+                console.log(`    Env         ${cyan(sessionEnv)}${dim('   calls are refused if the daemon moves to another env')}`);
+                console.log(dim('  Other sessions and terminal tabs keep their own agent and workspace.'));
             }
             else {
                 console.error(`  ${yellow('⚠')} Could not bind this session (${scope}) to ${name}; calls resolve to ${resolved ?? 'nobody'}.`);
@@ -886,9 +997,10 @@ async function agentLogin(args, values) {
             }
         }
         else {
-            console.log('  Activate in THIS terminal:');
+            // No per-session handle: a terminal that does not say which tab it is.
+            console.log('  This terminal has no session id, so the sign-in is shared by every such terminal.');
+            console.log('  To keep it to THIS terminal:');
             console.log(`    ${cyan(`eval "$(beehaven agent use ${name})"`)}`);
-            console.log(dim(`  or: export BEEHAVEN_AGENT=${name}`));
         }
     }
     console.log('');
@@ -1159,6 +1271,14 @@ function agentWhoami(values) {
     console.log(`    birthday:    ${r.birthday ? formatBirthday(r.birthday) : 'unknown (created before birthdays)'}`);
     console.log(`    voice:       ${r.voice?.provider ? (r.voice.voiceId ? `${r.voice.provider}:${r.voice.voiceId}` : `${r.voice.provider} (base voice)`) : 'unbound — speak picks whatever is reachable'}`);
     console.log(`    expires:     ${formatRemaining(r.expiresAt)}`);
+    if (active.session) {
+        console.log(`    session:     ${active.session.scope}  (work session ${active.session.sessionId ? active.session.sessionId.slice(0, 8) : 'none'})`);
+        console.log(`    workspace:   ${active.session.workspace}`);
+        console.log(`    env:         ${active.session.env}`);
+    }
+    else {
+        console.log(dim('    session:     none bound here — `beehaven agent login ' + active.name + '` binds this session'));
+    }
     if (active.expired)
         console.log(dim(`    refresh: beehaven agent login ${active.name}`));
     console.log('');
@@ -1184,6 +1304,53 @@ async function agentStatus(args, values) {
     }
     console.log(`  ${green('✓')} ${cyan(name)} status: ${String(result.message ?? message)}`);
 }
+// ── connect, for a signed-in session ─────────────────
+/**
+ * `beehaven connect <address>` in a signed-in session (AWO-394): move THIS session — its cursor,
+ * its work session and its binding — and nothing else. The cursor file is already this session's;
+ * this moves the work session to the workspace it now works in (a session lives in one workspace's
+ * DO, and its id used to ride on calls to others), and remembers the workspace on the identity so
+ * the next login starts there.
+ */
+export async function moveAgentSession(address) {
+    const { activeSessionBinding } = await import('../agent-state.js');
+    const { updateSessionBinding, describeAddress } = await import('../session-binding.js');
+    const bound = activeSessionBinding();
+    if (!bound)
+        return;
+    const record = loadAgent(bound.agent);
+    if (!record)
+        return;
+    if (bound.workspace === address)
+        return;
+    if (bound.sessionId)
+        await endSessionIn(bound.workspace, bound.sessionId, record.agentId);
+    let sessionId;
+    if (holdsWorkSessions(address)) {
+        const input = { agentId: record.agentId, client: 'cli', expiresAt: record.expiresAt };
+        const { loginSessionOutcome } = await import('../agent-state.js');
+        try {
+            let r = await rpcIn(address, 'agent-session-start', input, 15_000);
+            let o = loginSessionOutcome(r);
+            if (o.kind === 'refused' && address !== 'workspace' && /unknown agent|not admitted|unknown-agent/i.test(`${o.scope} ${o.reason}`)) {
+                const admitted = await rpcIn(address, 'agent-admit', { agentId: record.agentId }, 20_000).catch(() => null);
+                if ((admitted?.result ?? admitted)?.ok) {
+                    console.error(dim(`  ${bound.agent} joined this workspace.`));
+                    r = await rpcIn(address, 'agent-session-start', input, 15_000);
+                    o = loginSessionOutcome(r);
+                }
+            }
+            if (o.kind === 'started')
+                sessionId = o.sessionId;
+            else if (o.kind === 'refused')
+                console.error(`  ${yellow('⚠')} ${bound.agent} has no work session here: ${o.reason}`);
+        }
+        catch { /* unreachable — calls still route; the next login opens a session */ }
+    }
+    updateSessionBinding(bound.scope, { workspace: address, sessionId });
+    saveAgent(bound.agent, { ...record, lastWorkspace: address });
+    console.log(dim(`  Session ${bound.scope} (${bound.agent}) now works in ${await workspaceLabel(address)}${sessionId ? ` · work session ${sessionId.slice(0, 8)}` : ''}. Other sessions are unaffected.`));
+}
 // ── handoff ──────────────────────────────────────────
 /**
  * End the current work session WITH a note — the one thing the next login (this agent's, or the
@@ -1203,6 +1370,22 @@ async function agentHandoff(args, values) {
         process.exit(1);
     }
     const record = loadAgent(name);
+    const { activeSessionBinding } = await import('../agent-state.js');
+    const bound = activeSessionBinding(name);
+    if (bound?.sessionId && record) {
+        // AWO-394 — hand off THIS session, where it lives; other sessions of the name are untouched.
+        if (!await endSessionIn(bound.workspace, bound.sessionId, record.agentId, summary)) {
+            console.error(`  ${yellow('⚠')} The workspace did not accept the handoff; the session is still open.`);
+            process.exitCode = 1;
+            return;
+        }
+        const { updateSessionBinding } = await import('../session-binding.js');
+        updateSessionBinding(bound.scope, { sessionId: undefined });
+        if (record.sessionId === bound.sessionId)
+            clearAgentSessionId(name);
+        console.log(`  ${green('✓')} Handed off session ${cyan(bound.sessionId.slice(0, 8))} — the next login for ${cyan(name)} reads this first.`);
+        return;
+    }
     if (!record?.sessionId) {
         console.error(`  ${yellow('⚠')} ${cyan(name)} has no open work session on this device.`);
         console.error(dim(`    Start one with: beehaven agent login ${name} --label "<work>" --client cli`));
@@ -1236,18 +1419,42 @@ async function agentLogout(args, values) {
     // it stays in the workspace (source of truth) AND on this device, so you can
     // log back in. To remove the current workspace projection use `agent delete <name>`;
     // to remove the portable account identity use `agent delete <name> --account --yes`.
-    await endWorkspaceSession(record);
-    try {
-        await rpcOnce('agent:disconnect', { agentId: record.agentId ?? name }, 5_000);
-    }
-    catch {
-        /* daemon down — nothing to close */
+    /**
+     * ⚠ AWO-394 — signing out ends THIS session (its binding, its work session, its cursor) and
+     * leaves every other session signed in as the same name running. It used to clear the shared
+     * record's session, which locked every other terminal using the name out at once.
+     */
+    const { activeSessionBinding, unbindAgentScope } = await import('../agent-state.js');
+    const { clearSessionBinding, listSessionBindings } = await import('../session-binding.js');
+    const bound = activeSessionBinding(name);
+    if (bound) {
+        if (bound.sessionId)
+            await endSessionIn(bound.workspace, bound.sessionId, record.agentId);
+        clearSessionBinding(bound.scope);
+        // …and this scope stops resolving to the name, or the next call here would still act as it.
+        unbindAgentScope(name, bound.scope);
+        if (record.sessionId && record.sessionId === bound.sessionId)
+            clearAgentSessionId(name);
+    }
+    else {
+        await endWorkspaceSession(record);
+        clearAgentSession(name);
+    }
+    const others = listSessionBindings().filter((b) => b.agent === name);
+    if (!others.length) {
+        try {
+            await rpcOnce('agent:disconnect', { agentId: record.agentId ?? name }, 5_000);
+        }
+        catch {
+            /* daemon down — nothing to close */
+        }
     }
-    clearAgentSession(name);
-    console.log(`  ${green('✓')} Signed out agent "${name}" — session ended, identity kept.`);
+    console.log(`  ${green('✓')} Signed out agent "${name}" ${bound ? 'in this session' : ''} — session ended, identity kept.`);
+    if (others.length)
+        console.log(dim(`  ${others.length} other session${others.length === 1 ? ' is' : 's are'} still signed in as ${name}.`));
     console.log(dim(`  Log back in: beehaven agent login ${name}   ·   workspace remove: beehaven agent delete ${name}`));
-    if (activeAgentName(values) === name && !values.agent) {
-        console.log(dim(`  This was your active agent — run: unset BEEHAVEN_AGENT`));
+    if (process.env.BEEHAVEN_AGENT === name && !values.agent) {
+        console.log(dim(`  BEEHAVEN_AGENT still names ${name} in this shell — run: unset BEEHAVEN_AGENT`));
     }
 }
 // ── delete (destructive — removes the identity from the workspace + device) ──

package/dist/commands/agents-md.js

@@ -8,17 +8,81 @@
  * is its own command the person (or their agent, asked first) runs, not a side effect of install.
  *
  * ⚠ THE MARKERS ARE THE UPDATE MECHANISM, as on every other surface (lib/connections/agentsMd.ts):
- * re-running replaces only what lies between our markers and leaves the rest byte for byte. The
- * CLI and MCP blocks have their own markers, so a repo used both ways keeps both.
+ * re-running replaces only what lies between our markers and leaves the rest byte for byte.
+ *
+ * ⚠ ONE TRACKED BLOCK FOR BOTH ROUTES (AWO-401). The block names the MCP tool and the CLI command
+ * for each step, so `--mcp` is kept only so older instructions still work; it writes the same block.
+ * Writing it removes the per-route blocks earlier versions wrote (`LEGACY_BLOCK_MARKERS`), so a repo
+ * that had both converges on one.
  *
  * ⚠ AGENTS.md IS THE FILE; CLAUDE.md POINTS AT IT with one `@AGENTS.md` line — one copy to keep
  * current. An existing CLAUDE.md gains the line only if it lacks it; nothing else in it is touched.
+ * The project's `.claude/settings.json` gains `CLAUDE_BASH_RULE` the same way (AWO-401).
  */
-import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'fs';
 import { join, resolve } from 'path';
 import { execFileSync } from 'child_process';
 import { color } from '../spinner.js';
-import { CLI_BLOCK_START, CLI_BLOCK_END, MCP_BLOCK_START, MCP_BLOCK_END, CLAUDE_MD_IMPORT, agentsMdCliBlock, agentsMdMcpBlock, } from '../agents-md-text.js';
+import { AGENTS_MD_START, AGENTS_MD_END, LEGACY_BLOCK_MARKERS, CLAUDE_MD_IMPORT, agentsMdBlock } from '../agents-md-text.js';
+/**
+ * The Claude Code permission that lets an agent run `beehaven` without a prompt per call (AWO-401).
+ * The tracked block makes several calls a task; a prompt on each one pushes people to turn tracking
+ * off. Written to the PROJECT's `.claude/settings.json` (committed with AGENTS.md, so it is the
+ * team's rule, not a change to anyone's user-wide settings). Claude Code matches each part of a
+ * chained command separately, so the rule never approves `beehaven … && something-else`.
+ */
+export const CLAUDE_BASH_RULE = 'Bash(beehaven:*)';
+/**
+ * Settings text with the rule added (or removed). `null` text means no file. A file that is not a
+ * JSON object is left alone (`skipped`) — never rewritten from a guess.
+ */
+export function editClaudeSettings(text, remove = false) {
+    if (text === null) {
+        if (remove)
+            return { next: null, change: 'absent' };
+        return { next: JSON.stringify({ permissions: { allow: [CLAUDE_BASH_RULE] } }, null, 2) + '\n', change: 'created' };
+    }
+    let data;
+    try {
+        data = JSON.parse(text);
+    }
+    catch {
+        return { next: text, change: 'skipped' };
+    }
+    if (!data || typeof data !== 'object' || Array.isArray(data))
+        return { next: text, change: 'skipped' };
+    const perms = data.permissions && typeof data.permissions === 'object' && !Array.isArray(data.permissions) ? data.permissions : null;
+    const allow = perms && Array.isArray(perms.allow) ? perms.allow : [];
+    if (remove) {
+        if (!allow.includes(CLAUDE_BASH_RULE))
+            return { next: text, change: 'absent' };
+        perms.allow = allow.filter((r) => r !== CLAUDE_BASH_RULE);
+        if (!perms.allow.length)
+            delete perms.allow;
+        if (!Object.keys(perms).length)
+            delete data.permissions;
+        return { next: Object.keys(data).length ? JSON.stringify(data, null, 2) + '\n' : null, change: 'removed' };
+    }
+    if (allow.includes(CLAUDE_BASH_RULE))
+        return { next: text, change: 'current' };
+    if (perms && perms.allow !== undefined && !Array.isArray(perms.allow))
+        return { next: text, change: 'skipped' };
+    data.permissions = { ...(perms ?? {}), allow: [...allow, CLAUDE_BASH_RULE] };
+    return { next: JSON.stringify(data, null, 2) + '\n', change: 'updated' };
+}
+/** Apply `editClaudeSettings` to `<root>/.claude/settings.json`. */
+function writeClaudeSettings(root, remove) {
+    const path = join(root, '.claude', 'settings.json');
+    const before = existsSync(path) ? readFileSync(path, 'utf8') : null;
+    const { next, change } = editClaudeSettings(before, remove);
+    if (next === null && before !== null)
+        rmSync(path);
+    else if (next !== null && next !== before) {
+        mkdirSync(join(root, '.claude'), { recursive: true });
+        writeFileSync(path, next);
+    }
+    return { path, change };
+}
 /** Our block replaced between its markers, or appended after one blank line. Keeps CRLF files CRLF. */
 export function spliceBlock(text, block, start, end) {
     const eol = text.includes('\r\n') ? '\r\n' : '\n';
@@ -57,22 +121,42 @@ export function projectRoot(dir) {
     }
 }
 /** Write (or remove) the block in `<root>/AGENTS.md` and make CLAUDE.md import it. */
+/** The text with every per-route block from before AWO-401 taken out. */
+export function removeLegacyBlocks(text) {
+    return LEGACY_BLOCK_MARKERS.reduce((t, [start, end]) => removeBlock(t, start, end), text);
+}
+/**
+ * The block written into `text`: in place of our current block, else in place of the first legacy
+ * block (so a migrated repo keeps its layout), else appended. Any other legacy block is removed.
+ */
+export function upsertAgentsMdBlock(text, block) {
+    if (text.includes(AGENTS_MD_START))
+        return spliceBlock(removeLegacyBlocks(text), block, AGENTS_MD_START, AGENTS_MD_END);
+    const legacy = LEGACY_BLOCK_MARKERS.find(([start, end]) => {
+        const i = text.indexOf(start);
+        return i >= 0 && text.indexOf(end, i) >= 0;
+    });
+    if (legacy)
+        return removeLegacyBlocks(spliceBlock(text, block, legacy[0], legacy[1]));
+    return spliceBlock(text, block, AGENTS_MD_START, AGENTS_MD_END);
+}
+/** `mcp` is accepted for older instructions and changes nothing: there is one block (AWO-401). */
 export function writeProjectAgentsMd(opts) {
     const root = projectRoot(resolve(opts.dir));
-    const [start, end] = opts.mcp ? [MCP_BLOCK_START, MCP_BLOCK_END] : [CLI_BLOCK_START, CLI_BLOCK_END];
     const agentsPath = join(root, 'AGENTS.md');
     const claudePath = join(root, 'CLAUDE.md');
     const files = [];
     const had = existsSync(agentsPath);
     const before = had ? readFileSync(agentsPath, 'utf8') : '';
     if (opts.remove) {
-        const next = removeBlock(before, start, end);
+        const next = removeLegacyBlocks(removeBlock(before, AGENTS_MD_START, AGENTS_MD_END));
         if (next !== before)
             writeFileSync(agentsPath, next);
         files.push({ path: agentsPath, change: next !== before ? 'removed' : 'absent' });
+        files.push(writeClaudeSettings(root, true));
         return { root, files };
     }
-    const next = spliceBlock(before, opts.mcp ? agentsMdMcpBlock() : agentsMdCliBlock(), start, end);
+    const next = upsertAgentsMdBlock(before, agentsMdBlock());
     if (next !== before)
         writeFileSync(agentsPath, next);
     files.push({ path: agentsPath, change: !had ? 'created' : next !== before ? 'updated' : 'current' });
@@ -89,11 +173,12 @@ export function writeProjectAgentsMd(opts) {
     else {
         files.push({ path: claudePath, change: 'current' });
     }
+    files.push(writeClaudeSettings(root, false));
     return { root, files };
 }
 export function cmdAgentsMd(dir, opts) {
     if (opts.print) {
-        process.stdout.write((opts.mcp ? agentsMdMcpBlock() : agentsMdCliBlock()) + '\n');
+        process.stdout.write(agentsMdBlock() + '\n');
         return 0;
     }
     let r;
@@ -106,10 +191,11 @@ export function cmdAgentsMd(dir, opts) {
     }
     console.log('');
     for (const f of r.files) {
-        const mark = f.change === 'current' || f.change === 'absent' ? color.dim('·') : color.green('✓');
-        console.log(`  ${mark} ${f.path}  ${color.dim(f.change)}`);
+        const mark = f.change === 'current' || f.change === 'absent' ? color.dim('·') : f.change === 'skipped' ? color.yellow('!') : color.green('✓');
+        const note = f.change === 'skipped' ? ` — not valid JSON, so left unchanged; add "${CLAUDE_BASH_RULE}" to permissions.allow yourself` : '';
+        console.log(`  ${mark} ${f.path}  ${color.dim(f.change)}${note}`);
     }
-    const changed = r.files.some((f) => f.change !== 'current' && f.change !== 'absent');
+    const changed = r.files.some((f) => f.change !== 'current' && f.change !== 'absent' && f.change !== 'skipped');
     if (changed && !opts.remove) {
         console.log(color.dim(`\n  Commit ${r.files.map((f) => f.path.slice(r.root.length + 1)).join(' and ')} so every agent that opens this project knows the workspace.`));
     }

package/dist/commands/help.js

@@ -414,23 +414,26 @@ const PAGES = {
         related: ['login', 'guide'],
     },
     'agents-md': {
-        synopsis: 'beehaven agents-md [dir] [--mcp] [--print] [--remove]',
+        synopsis: 'beehaven agents-md [dir] [--print] [--remove]',
         description: `Add the Clearly block to this project's AGENTS.md, so every agent that opens the
-    repository — a teammate's Codex or Claude Code, a cloud agent, CI — knows the workspace and how
-    to reach it. Writes at the git root (or the directory given), and makes CLAUDE.md import it with
-    one \`@AGENTS.md\` line. Needs no login.
-
-    The block sits between Clearly's markers: run it again to update the block, and everything
-    else in the file stays as it was. \`beehaven login\` already teaches the agents on THIS machine
-    (their global instruction files); this is the shared, committed copy for everyone else.`,
+    repository — a teammate's Codex or Claude Code, a cloud agent, CI — tracks its work in the
+    workspace: sign in, a ticket for every task, a handoff at the end. One block serves agents on
+    the CLI and over MCP. Writes at the git root (or the directory given), and makes CLAUDE.md
+    import it with one \`@AGENTS.md\` line, and lets Claude Code run \`beehaven\` without a prompt per
+    call (\`Bash(beehaven:*)\` in the project's .claude/settings.json). Needs no login.
+
+    The block sits between Clearly's markers: run it again to update it, and everything else in
+    the file stays as it was. Older per-route Clearly blocks are replaced. \`beehaven login\`
+    already points the agents on THIS machine at Clearly (their global instruction files); this is
+    the shared, committed copy for everyone who opens the repository.`,
         flags: [
-            { name: '--mcp', desc: 'Write the block for agents connected over MCP instead of the CLI' },
             { name: '--print', desc: 'Print the block and write nothing' },
             { name: '--remove', desc: 'Take the block out again' },
+            { name: '--mcp', desc: 'Accepted for older instructions; the block is the same for MCP and the CLI' },
         ],
         examples: [
-            { cmd: 'beehaven agents-md', note: 'AGENTS.md + CLAUDE.md at the repository root' },
-            { cmd: 'beehaven agents-md --mcp', note: 'for a team that connects over MCP' },
+            { cmd: 'beehaven agents-md', note: 'AGENTS.md, CLAUDE.md and .claude/settings.json at the repository root' },
+            { cmd: 'beehaven agents-md --print', note: 'see the block without writing it' },
         ],
         related: ['skills', 'login'],
     },

package/dist/commands/workspace.js

@@ -725,8 +725,18 @@ export { activeAgentWrap, setCliDoor, cliDoor, alreadyAttributed, BOOTSTRAP_ACTI
  * ambient identity and is correct for every verb that does not offer that flag.
  */
 export async function agentRpc(action, input, timeout, values = {}) {
-    const wrapped = activeAgentWrap(action, input, values);
-    return rpcOnce(wrapped.action, wrapped.input, timeout);
+    /**
+     * ⚠⚠ THE TYPED VERBS FOLLOW THE SESSION'S WORKSPACE, LIKE `call` (AWO-393). This sent a bare
+     * `rpcOnce` to the daemon's default workspace: after `connect team/<id>`, `beehaven call
+     * ticket-create` filed in the team and `beehaven ticket create` filed at home. Same resolver,
+     * same order as `cmdCall` — wrap as the agent first, then the building envelope around it.
+     */
+    const routed = { ...values };
+    const { resolveTargetBuilding } = await import('../session-target.js');
+    await resolveTargetBuilding(routed);
+    const wrapped = activeAgentWrap(action, input, routed);
+    const resolved = resolveBuilding(wrapped.action, wrapped.input, routed.building);
+    return rpcOnce(resolved.action, resolved.input, timeout);
 }
 /**
  * Does this result payload represent a failure? Mirrors `isFailurePayload` in the worker's
@@ -1260,7 +1270,13 @@ function printCallErrorHints(msg, action, values) {
     if (!values.json) {
         console.error('');
         console.error('\x1b[2m  Try:\x1b[0m');
-        if (s.includes('unknown action') || s.includes('404')) {
+        if (/admin:(store|team|workspace)-rpc/.test(s) && s.includes('not allowed')) {
+            // A store/team target is reached through an admin:*-rpc proxy, which the workspace refuses
+            // to members over the daemon. Platform admins have the HTTP door instead (PPO-444).
+            console.error(`\x1b[2m    beehaven admin do shopifyStore/<id> ${action} '<json>'   # platform admins: the operator door\x1b[0m`);
+            console.error(`\x1b[2m    beehaven admin dashboard shopifyStore/<id>         # state, logs, snapshots\x1b[0m`);
+        }
+        else if (s.includes('unknown action') || s.includes('404')) {
             console.error(`\x1b[2m    beehaven actions --search <name>  # find the mounted action\x1b[0m`);
             console.error(`\x1b[2m    beehaven pwd                      # confirm you\'re on the right DO\x1b[0m`);
         }