@clearlysh/beehaven 0.8.33 → 0.8.35

package/dist/agent-attribution.js

@@ -62,6 +62,21 @@ export const BOOTSTRAP_ACTIONS = new Set([
     // The workspace-scoped predecessors, kept so an older flow still bootstraps.
     'agent-mint-token', 'agent-create', 'agent-list',
 ]);
+/**
+ * ⚠⚠ SPT-13 — `agent-create` ESTABLISHES AN IDENTITY ONLY WHEN IT CREATES THE ONE SIGNED IN.
+ *
+ * Unwrapped, it runs as the account owner. That is right for the bootstrap it exists for — the
+ * signed-in agent creating ITSELF in a workspace that has no row for it yet. It was wrong for every
+ * other agent: a signed-in agent whose matrix says `agents.create = false` minted `ss41-probe`
+ * because the call left as its owner. Creating ANOTHER agent is ordinary work, so it is wrapped and
+ * the capability gate decides.
+ */
+function createsAnotherAgent(action, input, active) {
+    if (action !== 'agent-create' || !active || active.expired)
+        return false;
+    // Without an `id` the server mints a random one, so the new agent cannot be the signed-in one.
+    return String(input?.id ?? '').trim() !== active.agentId;
+}
 /**
  * ⚠⚠ ACTIONS THE DAEMON ANSWERS ITSELF — THEY NEVER REACH A WORKSPACE, SO THEY CANNOT BE WRAPPED.
  *
@@ -165,7 +180,7 @@ export function alreadyAttributed(action, input) {
 export function activeAgentWrap(action, input, values) {
     if (alreadyAttributed(action, input))
         return { action, input };
-    if (BOOTSTRAP_ACTIONS.has(action) || DAEMON_LOCAL_ACTIONS.has(action))
+    if (DAEMON_LOCAL_ACTIONS.has(action))
         return { action, input };
     let active = null;
     try {
@@ -174,6 +189,8 @@ export function activeAgentWrap(action, input, values) {
     catch {
         return { action, input };
     }
+    if (BOOTSTRAP_ACTIONS.has(action) && !createsAnotherAgent(action, input, active))
+        return { action, input };
     if (!active || active.expired)
         return { action, input };
     return {
@@ -182,7 +199,8 @@ export function activeAgentWrap(action, input, values) {
             agentId: active.agentId,
             action,
             input,
-            ...(active.record.sessionId ? { sessionId: active.record.sessionId } : {}),
+            // This session's own work session (AWO-394), not the record every terminal shares.
+            ...(active.sessionId ? { sessionId: active.sessionId } : {}),
             // ⚠ WHICH DOOR — `cli:call` vs `cli:ticket` vs … See `cliDoor()` and
             // `agent_activity.source`. Set here, at the ONE wrap every CLI path shares, so a new
             // verb is labelled without its author having to know this exists.

package/dist/agent-scope.js

@@ -29,9 +29,43 @@
  * `cd` is recorded.
  */
 export function deriveAgentScope(env = process.env) {
+    /**
+     * ⚠⚠ A HARNESS SESSION ID OUTRANKS `BEEHAVEN_AGENT` (AWO-394). The env var names WHO — and
+     * `activeAgentName` still reads it first for that — but it is not a per-session handle: the
+     * daemon spawns every desktop Claude session with `BEEHAVEN_AGENT=<desktop principal>`, so they
+     * all derived ONE scope and shared one cursor and one work session. The session id is what
+     * tells two conversations of one agent apart.
+     */
+    const harness = harnessScope(env);
+    if (harness && harness !== 'claude')
+        return harness;
     const explicit = (env.BEEHAVEN_AGENT || '').trim();
     if (explicit)
-        return explicit; // an explicit choice always wins
+        return explicit; // an explicit choice, absent a session id
+    if (harness)
+        return harness;
+    /**
+     * ⚠ NO MARKER AND NO TTY IS STILL NOT A PERSON. Key on the PARENT pid — stable for the
+     * life of one process tree, different for a concurrent one. Not perfect (pids are reused
+     * eventually), but the failure mode of a collision here is two runs of the SAME tool,
+     * which is far milder than the shared-file failure it replaces: two DIFFERENT agents.
+     */
+    if (!process.stdin.isTTY && !process.stdout.isTTY)
+        return `pid-${process.ppid}`;
+    /**
+     * ⚠ A TERMINAL TAB IS ITS OWN SCOPE WHEN THE TERMINAL SAYS WHICH TAB (AWO-394). Every human
+     * terminal used to derive `''`, so one `agent login` in any tab made EVERY tab that agent — and
+     * the login's own advice ("other terminals: export BEEHAVEN_AGENT") was moot. These ids are set
+     * per tab/pane by the terminal itself. Without one, `''` keeps the old shared behaviour.
+     *
+     * ⚠ A HUMAN WHO HAS NOT LOGGED IN AS AN AGENT STILL SHARES `target.json` — `cli-state`
+     * maps an unbound `term-*` scope back to the shared cursor, so nobody's `cd` moves.
+     */
+    const tab = terminalTabId(env);
+    return tab ? `term-${tab}` : ''; // a human at a terminal
+}
+/** The harness session scope (`claude-…`, `codex-…`, `gemini-…`), or '' — see `deriveAgentScope`. */
+function harnessScope(env) {
     // Claude Code — its own marker (`daemon-omni.ts` already relies on it: "the SDK refuses to
     // start when CLAUDECODE=1 is set … it's how it refuses to recurse"), plus a per-session id.
     if (env.CLAUDECODE || env.CLAUDE_CODE_ENTRYPOINT) {
@@ -45,15 +79,26 @@ export function deriveAgentScope(env = process.env) {
     if (env.GEMINI_CLI_SESSION_ID) {
         return `gemini-${String(env.GEMINI_CLI_SESSION_ID).replace(/[^A-Za-z0-9]/g, '').slice(0, 12)}`;
     }
-    /**
-     * ⚠ NO MARKER AND NO TTY IS STILL NOT A PERSON. Key on the PARENT pid — stable for the
-     * life of one process tree, different for a concurrent one. Not perfect (pids are reused
-     * eventually), but the failure mode of a collision here is two runs of the SAME tool,
-     * which is far milder than the shared-file failure it replaces: two DIFFERENT agents.
-     */
-    if (!process.stdin.isTTY && !process.stdout.isTTY)
-        return `pid-${process.ppid}`;
-    return ''; // a human at a terminal
+    return '';
+}
+/**
+ * Which terminal tab or pane this is, from the id the terminal itself exports — or ''.
+ * macOS Terminal / iTerm2 (`TERM_SESSION_ID`, `ITERM_SESSION_ID`), Windows Terminal, tmux, kitty,
+ * WezTerm. Hashed to a short token: some carry paths or GUIDs, and it lands in a filename.
+ */
+export function terminalTabId(env = process.env) {
+    const raw = env.TMUX_PANE && env.TMUX ? `tmux${env.TMUX}${env.TMUX_PANE}`
+        : env.ITERM_SESSION_ID || env.TERM_SESSION_ID || env.WT_SESSION
+            || (env.KITTY_WINDOW_ID ? `kitty${env.KITTY_WINDOW_ID}` : '')
+            || (env.WEZTERM_PANE ? `wezterm${env.WEZTERM_PANE}` : '');
+    if (!raw)
+        return '';
+    let h = 2166136261; // FNV-1a — stable, dependency-free
+    for (let i = 0; i < raw.length; i++) {
+        h ^= raw.charCodeAt(i);
+        h = Math.imul(h, 16777619);
+    }
+    return (h >>> 0).toString(36);
 }
 export function principalKind(input) {
     const now = input.now ?? Date.now();

package/dist/agent-state.js

@@ -11,6 +11,7 @@
  * (`agent:mint`) and the CLI just stores the resulting record.
  */
 import { deriveAgentScope } from './agent-scope.js';
+import { readSessionBinding } from './session-binding.js';
 import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync, unlinkSync, renameSync, chmodSync, } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
@@ -230,6 +231,17 @@ export function bindAgentScope(name, scope, opts = {}) {
     }
     catch { /* binding is a convenience; a failed write must not fail the login */ }
 }
+/** Forget that `scope` was logged in as `name` — `agent logout` in that session (AWO-394). */
+export function unbindAgentScope(name, scope) {
+    try {
+        const rec = loadAgent(name);
+        const prev = Array.isArray(rec?.boundScopes) ? rec.boundScopes : [];
+        if (!rec || !prev.includes(scope))
+            return;
+        saveAgent(name, { ...rec, boundScopes: prev.filter((s) => s !== scope) });
+    }
+    catch { /* best-effort */ }
+}
 /**
  * The stable half of a process scope — the TOOL rather than the conversation.
  *
@@ -240,6 +252,9 @@ export function bindAgentScope(name, scope, opts = {}) {
 export function scopeFamilyKey(scope) {
     if (!scope)
         return 'family:terminal';
+    // A terminal TAB (AWO-394) inherits nothing: one tab's login must not become another tab's identity.
+    if (scope.startsWith('term-'))
+        return null;
     const m = /^(claude|codex|gemini)-/.exec(scope);
     if (m)
         return `family:${m[1]}`;
@@ -254,6 +269,14 @@ export function scopeFamilyKey(scope) {
  */
 export function agentForScope(scope = '') {
     try {
+        /**
+         * ⚠ THE SESSION BINDING WINS (AWO-394). `agent login` writes `sessions/<scope>.json`, and that
+         * exact record — not a list on a record shared by every terminal using the name — is what this
+         * session is. `boundScopes` below stays for sessions bound before it existed and for the family.
+         */
+        const session = scope ? readSessionBinding(scope) : null;
+        if (session && loadAgent(session.agent))
+            return session.agent;
         const all = listAgents();
         const boundTo = (key) => all
             .filter(({ record }) => Array.isArray(record.boundScopes)
@@ -369,6 +392,18 @@ export function activeAgentName(values) {
         return null;
     }
 }
+/** The session binding of THIS process, when it belongs to `name` (or to whoever is active). */
+export function activeSessionBinding(name) {
+    try {
+        const b = readSessionBinding(deriveAgentScope());
+        if (!b)
+            return null;
+        return !name || b.agent === name ? b : null;
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Resolve the active agent identity for this invocation, or null when no
  * agent is selected. Used by the call path to attach the token + route the
@@ -381,6 +416,13 @@ export function resolveActiveAgent(values) {
     const record = loadAgent(name);
     if (!record)
         return null;
+    const session = activeSessionBinding(name);
+    /**
+     * ⚠ THE SESSION'S OWN WORK SESSION, NOT THE SHARED RECORD'S (AWO-394). `record.sessionId` is one
+     * field for every terminal using this name, so a second terminal's login replaced the first's and
+     * both then wrote under it. A session bound by `agent login` carries its own.
+     */
+    const sessionId = session ? session.sessionId : record.sessionId;
     return {
         name,
         token: record.token,
@@ -389,6 +431,8 @@ export function resolveActiveAgent(values) {
         avatarId: record.avatarId,
         record,
         expired: typeof record.expiresAt === 'number' && record.expiresAt <= Date.now(),
+        ...(sessionId ? { sessionId } : {}),
+        ...(session ? { session } : {}),
     };
 }
 /**

package/dist/agents-md-text.js

@@ -1,64 +1,80 @@
 /**
  * agents-md-text — the Clearly block for a PROJECT's AGENTS.md, as `beehaven agents-md` writes it
- * (CAN2-66).
+ * (CAN2-66, AWO-401).
  *
  * ⚠⚠ A COPY, PINNED. The source of truth is the monorepo's `lib/connections/agentsMd.ts`, which the
- * Integrations page, each agent's details and the MCP `clearly-agents-md` prompt render. This
- * package cannot import it (it ships on its own), so the text is repeated here and the monorepo's
- * `lib/__tests__/agentsMdCliParity.test.mjs` compares the two OUTPUTS, name argument included.
- * Change both or the test fails — a stale copy does not render wrong, it instructs wrong.
+ * Integrations page, each agent's details, the /cli and /mcp guides and the MCP `clearly-agents-md`
+ * prompt render. This package cannot import it (it ships on its own), so the text is repeated here
+ * and the monorepo's `lib/__tests__/agentsMdCliParity.test.mjs` compares the two OUTPUTS, name
+ * argument included. Change both or the test fails — a stale copy does not render wrong, it
+ * instructs wrong.
+ *
+ * ⚠ ONE TRACKED BLOCK FOR MCP AND THE CLI (founder 2026-10-28): every task is tracked in Clearly,
+ * and each step names the MCP tool and the CLI command. The per-route blocks before it are removed
+ * when this one is written (`LEGACY_BLOCK_MARKERS`).
  *
  * ⚠ NO IMPORTS, so that test can load this file directly.
  */
-export const CLI_BLOCK_START = '<!-- clearly:cli:start -->';
-export const CLI_BLOCK_END = '<!-- clearly:cli:end -->';
-export const MCP_BLOCK_START = '<!-- clearly:mcp:start -->';
-export const MCP_BLOCK_END = '<!-- clearly:mcp:end -->';
+export const AGENTS_MD_START = '<!-- clearly:start -->';
+export const AGENTS_MD_END = '<!-- clearly:end -->';
+/** The per-route markers used before AWO-401. Writers remove these blocks; nothing writes them. */
+export const LEGACY_BLOCK_MARKERS = [
+    ['<!-- clearly:cli:start -->', '<!-- clearly:cli:end -->'],
+    ['<!-- clearly:mcp:start -->', '<!-- clearly:mcp:end -->'],
+];
+/** How Claude Code runs the MCP server's `clearly-agents-md` prompt, which writes the block. */
+export const MCP_AGENTS_MD_SLASH = '/mcp__clearly__clearly-agents-md';
 /** What goes in CLAUDE.md so Claude Code reads the AGENTS.md block too. */
 export const CLAUDE_MD_IMPORT = '@AGENTS.md';
-/** The block for agents that use the `beehaven` CLI. */
-export function agentsMdCliBlock(agentName) {
+/** Where the block goes, said once for every surface. */
+export const AGENTS_MD_HOW = 'Every agent that opens the repository reads AGENTS.md, so the block makes each session track its work in Clearly. Claude Code reads CLAUDE.md — give it one line.';
+/** The MCP tools the block names. Each must be on the server's `tools/list` (a Worker test pins it). */
+export const MCP_BLOCK_TOOLS = ['clearly_catalog', 'clearly_read', 'clearly_grep', 'clearly_create', 'clearly_edit', 'clearly_comment'];
+/**
+ * The block. `agentName` personalises the CLI sign-in line for one agent (its details view);
+ * without it the agent is told to use its own name.
+ */
+export function agentsMdBlock(agentName) {
     const name = (agentName ?? '').trim();
     const login = name
-        ? `\`beehaven agent login ${name} --label "<what you are doing>"\` — you are ${name} in this workspace.`
-        : '`beehaven agent login <name> --label "<what you are doing>"`, using your own name (claude, codex, gemini).';
+        ? `\`beehaven agent login ${name} --label "<the task>"\` — you are ${name} in this workspace —`
+        : '`beehaven agent login <your-name> --label "<the task>"` (claude, codex, gemini…)';
     return [
-        CLI_BLOCK_START,
-        '<!-- managed-by: clearly. Run `beehaven agents-md` to update; edit outside this block. -->',
+        AGENTS_MD_START,
+        '<!-- managed-by: clearly. Run `beehaven agents-md` or the `clearly-agents-md` MCP prompt to update; edit outside this block. -->',
         '',
-        '## Clearly workspace',
+        '## Clearly workspace: track every task',
         '',
-        'This project keeps its documents, plans, boards and tickets in Clearly. Use the `beehaven` CLI',
-        'for anything the team should see, not files in this repo.',
+        "This project's plans, tickets, documents and designs live in Clearly. Track every task there,",
+        'even when the person does not ask. Use whichever route this session has: the `clearly_*` MCP tools,',
+        "or the `beehaven` CLI (`beehaven actions` lists actions; `beehaven call <action> '<json>'` runs one).",
         '',
-        `- Sign in once per session: ${login}`,
+        '### Start of every session',
+        '',
+        `- CLI: sign in first with ${login} and read the brief it prints.`,
         '  If it says the daemon is not running: `beehaven start --headless`.',
-        '- Read the `clearly-agent` skill before anything else, and `clearly-canvas` before design work',
-        '  (`beehaven skills install` puts them in place).',
-        '- `beehaven actions` lists what you can call; `beehaven call <action> \'<json>\'` calls it.',
-        '- Search before you create, file work in the project it belongs to, and end the session with',
-        '  `beehaven agent handoff "what you did · what is next"` so the next one starts there.',
-        CLI_BLOCK_END,
-    ].join('\n');
-}
-/** The block for agents connected over MCP (the `clearly` server). */
-export function agentsMdMcpBlock() {
-    return [
-        MCP_BLOCK_START,
-        '<!-- managed-by: clearly-mcp. Re-run the `clearly-agents-md` prompt to update; edit outside this block. -->',
+        '  MCP: you are already signed in as the agent chosen when Clearly was connected.',
+        "- Read this project's open tickets and its latest handoff before starting (`clearly_grep` /",
+        '  `clearly_read`, or the brief).',
+        '',
+        '### Every task has a ticket',
+        '',
+        '1. Search first (`clearly_grep`, `clearly_catalog`, or `beehaven call ticket-list`). Reuse the project,',
+        '   board and ticket that already own the work; create a board only if the project has none.',
+        '2. Create the ticket before changing code or files (`clearly_create` with `type: "ticket"` and',
+        '   `fields.boardId`, or `beehaven call ticket-create`). Say in its body what done means.',
+        '3. Move it to in-progress when work begins (`clearly_edit`, or `beehaven call ticket-update`).',
+        '4. File what you make (documents, designs, notes) into the project and link it from the ticket.',
+        '   Record decisions, open questions and progress as comments (`clearly_comment`).',
+        '5. Mark it done only after verifying the result, with the resolution and any remaining risk.',
         '',
-        '## Clearly workspace (connected over MCP as `clearly`)',
+        '### End of every session',
         '',
-        'This project keeps its documents, plans, boards and tickets in Clearly. Use the `clearly_*`',
-        'tools, not files in this repo, for anything the team should see.',
+        '- Leave a handoff: what you did and what is next. CLI: `beehaven agent handoff "<done · next>"`.',
+        '  MCP: a comment on the work ticket.',
         '',
-        '- Start with `clearly_catalog` to see what exists; search with `clearly_grep` / `clearly_glob`.',
-        '- Read with `clearly_read`, make new work with `clearly_create`, change it with `clearly_edit`,',
-        '  and discuss it with `clearly_comment`. They take a `target`: a path (`~/Q1/Plan.md`), a key',
-        '  (`CLR-42`), an id or an exact title. The extension names the type (`.md` document, `.csv`',
-        '  sheet, `.board.json` board); a trailing slash means a project.',
-        '- Search before you write, and write decisions back so the next session inherits them.',
-        '- If a job is not covered by a listed tool, say so rather than guessing an action name.',
-        MCP_BLOCK_END,
+        'If this session has neither the `clearly_*` tools nor `beehaven`, stop and ask the person to connect',
+        'Clearly (clearly.sh/docs/mcp or clearly.sh/docs/cli). Do not skip the tracking.',
+        AGENTS_MD_END,
     ].join('\n');
 }

package/dist/build-channel.js

@@ -53,9 +53,9 @@ export const PUBLIC_BUILD = true;
  * ⚠ REWRITTEN IN `dist/` AT BUILD TIME, like `PUBLIC_BUILD`. `unstamped` is what a source checkout
  * carries and what `tsx`/`vitest` see, and it is honest: nothing has stamped them.
  */
-export const BUILD_SHA = '8f7eef9e12ce';
+export const BUILD_SHA = 'f866489dd2f1';
 /** ISO-8601 minute precision, UTC. Rewritten in `dist/` by `scripts/stamp-build-channel.mjs`. */
-export const BUILD_TIME = '2026-10-15T07:24Z';
+export const BUILD_TIME = '2026-10-28T16:02Z';
 /**
  * The build identity as one short string, for `--version`.
  *

package/dist/cli-state.js

@@ -41,7 +41,8 @@
  * target is what stops the inheritance. Pin it, or pass `--building` per call.
  */
 import { deriveAgentScope } from './agent-scope.js';
-import { agentForScope } from './agent-state.js';
+import { agentForScope, loadAgent } from './agent-state.js';
+import { readSessionBinding, scopeKey } from './session-binding.js';
 import { existsSync, readFileSync, writeFileSync, unlinkSync, mkdirSync, renameSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
@@ -92,14 +93,55 @@ export function effectiveScope() {
     const raw = deriveAgentScope();
     if (!raw)
         return ''; // a human — the shared file
+    /**
+     * ⚠⚠ A SESSION BOUND BY `agent login` HAS ITS OWN CURSOR (AWO-394) — keyed on the session, not
+     * the agent name. Keyed on the name, two terminals logged in as one agent shared a workspace:
+     * one `connect` moved both. The workspace a NEW session starts in is chosen at login (the
+     * identity's last workspace, or `--workspace`), which keeps what the name key was for.
+     */
+    if (readSessionBinding(raw))
+        return raw;
     try {
+        // A session bound before session bindings existed keeps its agent-keyed cursor until it logs in again.
         const bound = agentForScope(raw);
-        if (bound)
-            return bound;
+        if (bound && !raw.startsWith('term-')) {
+            // …but only an EXACT binding. A session that merely inherited the family's identity starts
+            // at home in its own cursor — it must not inherit someone else's workspace with the name.
+            const rec = loadAgent(bound);
+            if (Array.isArray(rec?.boundScopes) && rec.boundScopes.includes(raw))
+                return bound;
+        }
     }
     catch { /* no agents dir, or a bad record — fall back to the process scope */ }
+    // A terminal tab nobody logged in from is the human: the shared cursor, exactly as before.
+    if (raw.startsWith('term-'))
+        return '';
     return raw;
 }
+/** The cursor file of a given session scope — `agent login` seeds a NEW session's cursor here. */
+export function writeTargetForScope(scope, address, kind) {
+    const key = scopeKey(scope);
+    if (!key)
+        return;
+    ensureStateDir();
+    const file = join(STATE_DIR, `target-${key}.json`);
+    const tmp = `${file}.tmp-${process.pid}`;
+    writeFileSync(tmp, JSON.stringify({ address, connectedAt: Date.now(), kind: kind ?? inferKind(address) }, null, 2), { mode: 0o600 });
+    renameSync(tmp, file);
+}
+/** Read the cursor of a given scope without making it this process's (the legacy agent-keyed file). */
+export function readTargetForKey(key) {
+    try {
+        const safe = scopeKey(key);
+        if (!safe)
+            return null;
+        const parsed = JSON.parse(readFileSync(join(STATE_DIR, `target-${safe}.json`), 'utf-8'));
+        return typeof parsed?.address === 'string' && parsed.address ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
 function targetFileFor(agent = effectiveScope()) {
     const safe = (agent || '').trim().replace(/[^A-Za-z0-9_-]/g, '');
     return join(STATE_DIR, safe ? `target-${safe}.json` : 'target.json');

package/dist/cli.js

@@ -849,48 +849,9 @@ async function printStatus() {
  * One function, because four hand-written copies is how one missing `else` became four.
  */
 async function resolveTargetBuilding(values) {
-    if (values.building)
-        return; // an explicit flag always wins
-    const { getTarget, isHomeAddress } = await import('./cli-state.js');
-    const t = getTarget();
-    if (t?.address?.includes('/')) {
-        const [bType, ...bIdParts] = t.address.split('/');
-        values.building = `${bType}:${bIdParts.join('/')}`;
-        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) {
-        /**
-         * ⚠ NO TARGET EVER SET — inherit the daemon's connection. The machine-global fallback
-         * `cli-state.ts` warns about: another room, the Mac app or a human's terminal can set
-         * it, so an agent that never runs `connect` inherits someone else's cursor. Kept for
-         * back-compat; `connect home` is what opts out, and this fix makes that opt-out real.
-         */
-        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 */ }
-    }
+    // ⚠ ONE resolver for every verb, typed or raw (AWO-393/394) — see session-target.ts.
+    const { resolveTargetBuilding: resolve } = await import('./session-target.js');
+    await resolve(values);
 }
 /**
  * ⚠⚠ AN IDENTIFIABLE AGENT MUST LOG IN BEFORE IT ACTS.
@@ -1103,8 +1064,10 @@ async function requireAgentSession(command, values) {
         cfg = {};
     }
     // ⚠ ONE DECISION, EXECUTED BY A GUARD (`principalKind`). This branch does nothing but act on it.
+    const { activeSessionBinding: sessionForGate } = await import('./agent-state.js');
     const who = principalKind({
-        agentSessionId: rec?.sessionId,
+        // This session's own work session first (AWO-394); the shared record's for sessions bound before it.
+        agentSessionId: sessionForGate(name)?.sessionId ?? rec?.sessionId,
         agentExpiresAt: rec?.expiresAt,
         agentRuntime: isAgentRuntime(),
         accountUserId: cfg.userId,
@@ -1377,7 +1340,7 @@ async function run() {
             state: { type: 'string' },
             goal: { type: 'string' },
             remove: { type: 'boolean', default: false },
-            // `agents-md`: the MCP block instead of the CLI one; print it instead of writing it (CAN2-66).
+            // `agents-md`: `--mcp` is accepted for older instructions (one block since AWO-401); `--print` prints it.
             mcp: { type: 'boolean', default: false },
             print: { type: 'boolean', default: false },
             /**
@@ -2237,6 +2200,14 @@ async function run() {
             // workspace via daemonRpc('shell:exec', …) — see
             // commands/shell.ts:resolveDefaultBuilding + execRemote.
             const { HOME_ADDRESSES: HOME_ADDRS, CANONICAL_HOME_ADDRESS } = await import('./cli-state.js');
+            /**
+             * ⚠⚠ A SIGNED-IN SESSION MOVES ONLY ITSELF (AWO-394). The daemon's focus is ONE variable for
+             * the machine, so `connect` used to re-point every other terminal that had no cursor of its
+             * own — agent A connecting to a Shopify store moved agent B. A session's own cursor file is
+             * the whole of its routing; the daemon is not told.
+             */
+            const { activeSessionBinding: sessionOf } = await import('./agent-state.js');
+            const ownSession = sessionOf();
             if (HOME_ADDRS.has(target)) {
                 const { setTarget } = await import('./cli-state.js');
                 // Canonical label is 'workspace' (no "home DO" — the daemon's relay is to the
@@ -2247,7 +2218,11 @@ async function run() {
                 setTarget(CANONICAL_HOME_ADDRESS, 'cloud');
                 // Best-effort daemon-side cleanup of any prior connect()
                 // focus — we want home to be the default routing target.
-                if (daemonUp) {
+                if (ownSession) {
+                    const { moveAgentSession } = await import('./commands/agent.js');
+                    await moveAgentSession(CANONICAL_HOME_ADDRESS);
+                }
+                else if (daemonUp) {
                     try {
                         await daemonDisconnect();
                     }
@@ -2290,6 +2265,15 @@ async function run() {
                 // where we meant to be, and we can retry without a re-`cd`.
                 const { setTarget } = await import('./cli-state.js');
                 setTarget(`${bType}/${bId}`, 'cloud');
+                if (ownSession) {
+                    const { moveAgentSession } = await import('./commands/agent.js');
+                    await moveAgentSession(`${bType}/${bId}`);
+                    if (bType === 'shopifyStore' || bType === 'store') {
+                        console.log(color.dim(`  Store DOs take operator calls through: beehaven admin do ${bType}/${bId} <action> '<json>'  (platform admins)`));
+                    }
+                    console.log(`  ${color.green('✓')} This session → ${color.green(`${bType}/${bId}`)}`);
+                    break;
+                }
                 try {
                     await daemonConnect(bType, bId);
                 }
@@ -2399,7 +2383,13 @@ async function run() {
             const { clearTarget: clearDisconn } = await import('./cli-state.js');
             clearDisconn();
             const { isDaemonRunning: isDaemonRunningDisc, daemonDisconnect: daemonDisconnectDisc } = await import('./daemon-client.js');
-            if (await isDaemonRunningDisc()) {
+            const { activeSessionBinding: sessionOfDisc } = await import('./agent-state.js');
+            if (sessionOfDisc()) {
+                // AWO-394 — a signed-in session goes home alone; the machine-wide focus is someone else's.
+                const { moveAgentSession } = await import('./commands/agent.js');
+                await moveAgentSession('workspace');
+            }
+            else if (await isDaemonRunningDisc()) {
                 try {
                     await daemonDisconnectDisc();
                 }
@@ -2457,7 +2447,22 @@ async function run() {
                     // ⚠ `values` HERE TOO — `beehaven status --agent alice` must report who that call would
                     //   run as, not who the shell happens to be bound to. See `requireAgentSession`.
                     const who = activeAgentName(values);
-                    if (who && eff === who) {
+                    const { activeSessionBinding } = await import('./agent-state.js');
+                    const { describeAddress, currentEnvName } = await import('./session-binding.js');
+                    const bound = activeSessionBinding(who);
+                    if (who && bound) {
+                        // AWO-394 — one session: identity + workspace + env, owned by this scope.
+                        const { loadAgent } = await import('./agent-state.js');
+                        const r = loadAgent(who);
+                        const gone = typeof r?.expiresAt === 'number' && r.expiresAt <= Date.now();
+                        const envNow = currentEnvName();
+                        console.log(gone
+                            ? `  Agent:  ${color.green(who)}  ${'\x1b[31m'}TOKEN EXPIRED\x1b[0m${color.dim(' — calls are refused until `beehaven agent login ' + who + '`')}`
+                            : `  Agent:  ${color.green(who)}${color.dim('  (this session — every call here runs as this agent)')}`);
+                        console.log(`  Session: ${color.green(bound.scope)}${color.dim(`  work session ${bound.sessionId ? bound.sessionId.slice(0, 8) : 'none'} · in ${describeAddress(bound.workspace)}`)}`);
+                        console.log(`  Env:    ${bound.env === envNow ? color.green(bound.env) : `\x1b[31m${bound.env} — daemon is on ${envNow}; calls are refused\x1b[0m`}`);
+                    }
+                    else if (who && eff === who) {
                         // Identity, workspace session and cursor are one handle.
                         const { loadAgent } = await import('./agent-state.js');
                         const r = loadAgent(who);
@@ -2472,6 +2477,11 @@ async function run() {
                             : `  Agent:  ${color.green(who)}${color.dim('  (logged in — calls run as this agent)')}`);
                         console.log(`  Scope:  ${color.green(eff)}${color.dim('  (cursor follows the agent, not the session)')}`);
                     }
+                    else if (raw.startsWith('term-')) {
+                        // AWO-394 — a tab nobody signed in from is the person, on the shared cursor.
+                        console.log(`  Scope:  ${color.green(raw)}${color.dim('  (this tab — `beehaven agent login <name>` here signs in THIS tab only)')}`);
+                        console.log(`  Agent:  ${color.dim('none — calls run as you, on the cursor your other terminals share')}`);
+                    }
                     else if (raw) {
                         console.log(`  Scope:  ${color.green(raw)}${color.dim('  (private cursor — concurrent agents cannot clobber it)')}`);
                         console.log(`  Agent:  ${color.dim('none — calls run as you. `beehaven agent login <name>` to act as an agent')}`);

package/dist/commands/agent-skills.js

@@ -236,14 +236,25 @@ export function installAgentSkills() {
                  * ⚠ NO STAMP ⇒ TREATED AS UNTOUCHED. Every skill installed before stamping existed has
                  * none, and assuming an edit there would freeze them permanently — updates would silently
                  * stop landing, which is the failure mode this whole change exists to remove.
+                 *
+                 * ⚠ IDENTICAL TO WHAT SHIPS ⇒ CURRENT, WHATEVER THE STAMP SAYS (PPO-476). The Mac app writes
+                 * these same files on every launch, and a copy can only equal the release by coming from
+                 * it. Asked first, a stale stamp called every skill "edited locally" and none was ever
+                 * re-stamped, so the next real update never landed either.
                  */
                 if (existing) {
+                    const local = localSha(destDir, skillFiles);
+                    if (entry?.sha && local === entry.sha) {
+                        stamp(destDir, skillFiles, warnings);
+                        steps.push(`${agent}/${name}=current`);
+                        continue;
+                    }
                     let stamped = '';
                     try {
                         stamped = JSON.parse(fs.readFileSync(path.join(destDir, STAMP), 'utf8')).sha ?? '';
                     }
                     catch { /* unstamped */ }
-                    if (stamped && localSha(destDir, skillFiles) !== stamped) {
+                    if (stamped && local !== stamped) {
                         warnings.push(`${agent}/${name}: edited locally — left alone (delete it to take the shipped copy)`);
                         steps.push(`${agent}/${name}=locally-modified`);
                         continue;