@clearlysh/beehaven 0.8.32 → 0.8.34

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/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`);
         }

package/dist/session-binding.js

@@ -0,0 +1,135 @@
+/**
+ * session-binding — ONE AGENT SESSION = one identity + one workspace + one env (AWO-394).
+ *
+ * `agent login` used to scatter a session across three places with three different keys:
+ *   · the identity        — `agents/<name>.json`, shared by every terminal using that name
+ *   · the work session id — a field on that SAME shared record, so a second terminal's login
+ *                           ended the first terminal's session and both then wrote under the new one
+ *   · the cursor          — `target-<name>.json`, so two terminals as one agent shared a workspace,
+ *                           and an agent that never connected inherited the daemon's machine-global focus
+ *
+ * Founder, 2026-10-24: "If agent A is working in workspace1 and agent B is working in workspace1
+ * and agent A connects to shopify DO, would that be isolated" — it was not, reliably. This file is
+ * the per-session record that makes it so: keyed on the PROCESS SCOPE (`deriveAgentScope()`: a
+ * Claude/Codex/Gemini session, a terminal tab, or an explicit `BEEHAVEN_AGENT`), written by
+ * `agent login`, moved only by `connect` in that same session, and read by every verb.
+ *
+ * ⚠ A LEAF MODULE, LIKE `agent-scope.ts`. `agent-state` (identity) and `cli-state` (cursor) both
+ * read it, so it may import neither — that is the cycle `agent-scope.ts` documents.
+ *
+ * ⚠ THE ENV IS PART OF THE SESSION. One daemon dials one relay; `beehaven env prod` in any
+ * terminal re-points every session on the machine. A session remembers the env it was opened on so
+ * a call after such a switch is refused with the fix, instead of landing in another environment's
+ * workspace under the same name.
+ */
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { resolveRelaySelection } from './relay-presets.js';
+const SESSIONS_DIR = join(homedir(), '.beehaven', 'sessions');
+/** Filesystem key for a scope — the same sanitising rule the cursor file uses. */
+export function scopeKey(scope) {
+    return String(scope || '').trim().replace(/[^A-Za-z0-9_-]/g, '');
+}
+function fileFor(scope) {
+    const key = scopeKey(scope);
+    return key ? join(SESSIONS_DIR, `${key}.json`) : null;
+}
+export function readSessionBinding(scope) {
+    try {
+        const file = fileFor(scope);
+        if (!file || !existsSync(file))
+            return null;
+        const b = JSON.parse(readFileSync(file, 'utf8'));
+        if (!b || typeof b.agent !== 'string' || !b.agent || typeof b.workspace !== 'string')
+            return null;
+        return { ...b, scope };
+    }
+    catch {
+        return null;
+    }
+}
+export function writeSessionBinding(binding) {
+    const file = fileFor(binding.scope);
+    if (!file)
+        throw new Error('This process has no scope to bind a session to — set BEEHAVEN_AGENT=<name>.');
+    mkdirSync(SESSIONS_DIR, { recursive: true, mode: 0o700 });
+    const tmp = `${file}.tmp-${process.pid}`;
+    writeFileSync(tmp, JSON.stringify(binding, null, 2), { mode: 0o600 });
+    renameSync(tmp, file);
+}
+export function updateSessionBinding(scope, patch) {
+    const cur = readSessionBinding(scope);
+    if (!cur)
+        return null;
+    const next = { ...cur, ...patch, scope };
+    writeSessionBinding(next);
+    return next;
+}
+export function clearSessionBinding(scope) {
+    try {
+        const file = fileFor(scope);
+        if (file && existsSync(file))
+            unlinkSync(file);
+    }
+    catch { /* already gone */ }
+}
+/** Every session bound on this machine — `agent list` shows them, `logout --all` ends them. */
+export function listSessionBindings() {
+    try {
+        if (!existsSync(SESSIONS_DIR))
+            return [];
+        return readdirSync(SESSIONS_DIR)
+            .filter((f) => f.endsWith('.json'))
+            .map((f) => readSessionBinding(f.slice(0, -5)))
+            .filter((b) => !!b);
+    }
+    catch {
+        return [];
+    }
+}
+/** The env this machine's daemon dials right now (`beehaven env`). */
+export function currentEnvName() {
+    try {
+        const p = join(homedir(), '.beehaven', 'config.json');
+        const cfg = existsSync(p) ? JSON.parse(readFileSync(p, 'utf8')) : {};
+        return resolveRelaySelection(cfg).envName;
+    }
+    catch {
+        return 'prod';
+    }
+}
+/**
+ * Why this session must not run here, or null. A session opened on staging is refused after
+ * someone switched the daemon to prod — the same workspace address names different data there.
+ */
+export function envMismatch(binding, now = currentEnvName()) {
+    if (!binding?.env || binding.env === now)
+        return null;
+    return `This session (${binding.agent}) was opened on ${binding.env}, but the daemon is now on ${now}.\n`
+        + `  Switch back:  beehaven env ${binding.env}\n`
+        + `  Or start a ${now} session here:  beehaven agent login ${binding.agent}`;
+}
+/** `workspace` / `team/<id>` / a bare 64-hex id → the address a cursor stores. */
+export function normalizeWorkspaceAddress(input) {
+    const v = String(input || '').trim();
+    if (!v)
+        return null;
+    if (['home', 'me', 'workspace'].includes(v))
+        return 'workspace';
+    if (/^[0-9a-f]{64}$/i.test(v))
+        return `workspace/${v.toLowerCase()}`;
+    if (/^[A-Za-z][A-Za-z0-9]*\/[A-Za-z0-9._:-]{1,200}$/.test(v))
+        return v;
+    return null;
+}
+/** Human label for an address — `home`, `team bld_…`, `shopifyStore clearly-demo`. */
+export function describeAddress(address) {
+    if (!address || ['workspace', 'home', 'me'].includes(address))
+        return 'home (your default workspace)';
+    const i = address.indexOf('/');
+    if (i < 0)
+        return address;
+    const id = address.slice(i + 1);
+    return `${address.slice(0, i)} ${id.length > 20 ? `${id.slice(0, 12)}…` : id}`;
+}

package/dist/session-target.js

@@ -0,0 +1,91 @@
+/**
+ * session-target — THE ONE ANSWER TO "WHERE DOES THIS CALL LAND?" (CLR-1161, AWO-393, AWO-394).
+ *
+ * `call`, `actions`, `batch`, `explain`, `code-run` and `watch git` resolved the cursor here (it
+ * lived inline in cli.ts); the typed verbs — `ticket`, `sheet`, `slides`, `design`, `mention`,
+ * `trash` — went through `agentRpc`, which never asked. So an agent connected to a team workspace
+ * ran `beehaven call ticket-create` in the team and `beehaven ticket create` in its home, in one
+ * terminal, with no warning (AWO-393). Every verb now resolves through this function.
+ *
+ * ⚠⚠ AN AGENT SESSION NEVER READS OR MOVES THE DAEMON'S FOCUS. The daemon's `connectedBuilding` is
+ * one variable for the whole machine: any terminal's `connect` sets it and any `connect home`
+ * clears it. A human with no cursor file still inherits it (that is the long-standing behaviour a
+ * person can see and correct); an agent with no cursor is at HOME, full stop — that is what makes
+ * agent A connecting to a Shopify store invisible to agent B in the same workspace.
+ *
+ * ⚠ THE SESSION'S ENV IS CHECKED HERE TOO, so every verb that routes also refuses a session opened
+ * on another environment (see `envMismatch`).
+ */
+import { getTarget, isHomeAddress } from './cli-state.js';
+import { activeAgentName, activeSessionBinding } from './agent-state.js';
+import { isAgentRuntime } from './agent-scope.js';
+import { envMismatch } from './session-binding.js';
+/** Is this invocation an agent's (a signed-in identity, or a harness that must sign in)? */
+export function isAgentInvocation(values = {}) {
+    try {
+        return !!activeAgentName(values) || isAgentRuntime();
+    }
+    catch {
+        return isAgentRuntime();
+    }
+}
+/** Why this session must not run (another env), or null. */
+export function sessionRefusal(values = {}) {
+    try {
+        return envMismatch(activeSessionBinding(activeAgentName(values)));
+    }
+    catch {
+        return null;
+    }
+}
+export async function resolveTargetBuilding(values) {
+    const refusal = sessionRefusal(values);
+    if (refusal) {
+        console.error(`  ${refusal}`);
+        process.exit(1);
+    }
+    if (values.building)
+        return; // an explicit flag always wins
+    const t = getTarget();
+    if (t?.address?.includes('/')) {
+        const [bType, ...bIdParts] = t.address.split('/');
+        values.building = `${bType}:${bIdParts.join('/')}`;
+        return;
+    }
+    // ⚠ An agent: no file, or a home file, both mean HOME — never the machine-global focus, and an
+    // agent's call never clears the focus a person in another terminal set.
+    if (isAgentInvocation(values))
+        return;
+    if (t && isHomeAddress(t.address)) {
+        /**
+         * ⚠ HOME IS A POSITIVE STATEMENT, NOT AN ABSENCE. The daemon's focus is a routing
+         * optimisation; the file is where the user said to be. If they disagree the daemon is
+         * stale — drop it, so the call lands where `pwd` says it will, and SAY so.
+         */
+        try {
+            const { daemonGetConnection, daemonDisconnect } = await import('./daemon-client.js');
+            const conn = await daemonGetConnection();
+            if (conn?.buildingId) {
+                await daemonDisconnect();
+                console.error(`\x1b[2m  (dropped a stale daemon focus on ${conn.buildingType}/${conn.buildingId}`
+                    + ` — your target is home)\x1b[0m`);
+            }
+        }
+        catch { /* no daemon, or it refused — home is the default route anyway */ }
+        return;
+    }
+    if (!t) {
+        /**
+         * ⚠ A PERSON WITH NO TARGET EVER SET inherits the daemon's connection — kept for back-compat
+         * with terminals that `connect` through the daemon and never wrote a file. Agents are handled
+         * above and never reach this.
+         */
+        try {
+            const { daemonGetConnection } = await import('./daemon-client.js');
+            const conn = await daemonGetConnection();
+            if (conn)
+                values.building = `${conn.buildingType}:${conn.buildingId}`;
+        }
+        catch { /* fall through to home */ }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clearlysh/beehaven",
-  "version": "0.8.32",
+  "version": "0.8.34",
   "description": "Beehaven CLI — command your Clearly workspace, agents, and canvas from the terminal",
   "private": false,
   "type": "module",
@@ -53,7 +53,7 @@
     }
   },
   "optionalDependencies": {
-    "better-sqlite3": "11.0.0",
+    "better-sqlite3": "13.0.3",
     "node-pty": "1.0.0",
     "open": "10.1.0"
   },