@clearlysh/beehaven 0.8.33 → 0.8.35

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.33",
+  "version": "0.8.35",
   "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"
   },

package/skills/clearly-agent/SKILL.md

@@ -5,14 +5,30 @@ description: Needs a terminal with the beehaven CLI (Claude Code, Codex, Gemini
 
 # clearly-agent — who you are, and what that makes your work
 
-## Select the workspace, then sign in once
+## Sign in once — this session is then you, in one workspace
 
 ```bash
-beehaven env
-beehaven connect home
-beehaven agent login <name> --label "what I am here to do" --client cli
+beehaven env                                   # staging or prod: the session remembers it
+beehaven agent login <name> --label "what I am here to do" --client cli [--workspace <ws>]
 ```
 
+After login **every** `beehaven` command in this session runs as `<name>`, in its workspace — no
+`--agent`, no export, nothing per call. The login prints the session, the agent, the workspace (by
+name) and the env. `--workspace` takes `home`, `workspace/<id>`, `team/<id>` or a bare 64-character
+id (`beehaven workspaces` lists them); without it a session starts where this identity last worked.
+
+**One session = one identity + one workspace + one env (AWO-394).** A session is a Claude/Codex/
+Gemini conversation, or a terminal tab. Each has its own:
+- workspace — `beehaven connect <ws>` moves THIS session only (and moves its work session there);
+  another agent, or another conversation signed in as the same name, stays where it is;
+- work session — a second login under the same name no longer ends the first one's;
+- env — if someone switches the daemon (`beehaven env prod`), calls from a staging session are
+  refused with the fix instead of landing in the other environment.
+
+Typed verbs (`ticket`, `sheet`, `slides`, `design`, `mention`, `trash`) follow the session's
+workspace exactly like `call` (AWO-393). A Shopify store is an operator target:
+`beehaven admin do shopifyStore/<id> <action> '<json>'` (platform admins).
+
 ## Personal workspace means a private layer, not another DO
 
 Every human and every agent in the selected workspace has a **personal workspace layer**: its own
@@ -38,13 +54,14 @@ steps. CI gets a real identity for one command: `beehaven agent login ci`.
 | 2 | `BEEHAVEN_AGENT=<name>` | a script, or another terminal |
 | 3 | the **scope binding** from `agent login` | this session, no flag needed |
 
-⚠ **The binding needs no cooperation.** `agent login` records the calling process's scope —
-`claude-<sessionId>`, `codex-…`, `gemini-…`, or `pid-<ppid>` for a non-TTY — on the identity. So
-two harness sessions are two agents concurrently with no env var, and **two agents on one scope is
-refused rather than guessed** (that can only happen if you logged in twice from one session).
+⚠ **The binding needs no cooperation.** `agent login` writes `~/.beehaven/sessions/<scope>.json` for
+the calling process's scope — `claude-<sessionId>`, `codex-…`, `gemini-…`, `term-<tab>` for a
+terminal tab that says which tab it is (macOS Terminal, iTerm2, Windows Terminal, tmux, kitty,
+WezTerm), or `pid-<ppid>` for a non-TTY. Two harness sessions or two tabs are two agents
+concurrently with no env var; logging in twice from one session means the second login.
 
-⚠ The workspace **cursor** is scoped the same way, so two identities can be `connect`ed to
-different workspaces at once. What is NOT concurrent: one daemon, one relay, one `beehaven env`.
+⚠ What is still machine-wide: one daemon, one relay, one `beehaven env` (sessions refuse a mismatch
+rather than follow it). `agent logout` ends this session only.
 
 ## Identity ≠ session
 

package/skills/clearly-canvas/authoring.md

@@ -147,11 +147,12 @@ deliverable requires them, with content order and hierarchy reconsidered for the
 
 The same rules the in-app assistant works to (canvas-catalog returns them as `technique`).
 
-- AUTO-LAYOUT: rows, stacks and grids are a frame whose children you create in reading order, then canvas.auto-layout { id, direction: "h" | "v" | "grid", gap, padding, align, justify, hug }. hug:false keeps the frame size; justify "space-between" | "space-around" | "space-evenly" are the Auto gaps; align:"baseline" lines up text in a row. Grids take columns, rows, columnGap, rowGap, columnSizes / rowSizes ("fill", "2fr", "hug", px). wrap:true flows into new rows; give Fill cards a minW so they wrap where you mean. Child settings go on the child via canvas.update-nodes: layoutSizingH/V "fill" | "hug" | "fixed", minW / maxW / minH / maxH, gridColumn / gridRow / gridColumnSpan, layoutPositioning:"absolute". The frame stays live: children created into it (parentId) flow in. Spacing variables: canvas.variable { op: "bind", ids, field, name }.
+- AUTO-LAYOUT: build every row, stack, card and grid AS an auto-layout frame from the start: frame.create (or canvas.create-node type "frame") { name, parentId, autoLayout: { direction: "h" | "v" | "grid", gap, padding, align, justify, hug } }, then create its children with parentId and NO x/y; they flow in creation order and the frame stays live. canvas.auto-layout { id, … } changes the settings; with only { id } it converts a hand-positioned frame, reading direction, gap and padding off the children so nothing moves, and review reports any stack left positioned by hand. hug:false keeps the frame size; justify "space-between" | "space-around" | "space-evenly" are the Auto gaps; align:"baseline" lines up text in a row. Grids take columns, rows, columnGap, rowGap, columnSizes / rowSizes ("fill", "2fr", "hug", px). wrap:true flows into new rows; give Fill cards a minW so they wrap where you mean. Child settings go on the child via canvas.update-nodes: layoutSizingH/V "fill" | "hug" | "fixed", minW / maxW / minH / maxH, gridColumn / gridRow / gridColumnSpan, layoutPositioning:"absolute".
+- VARIABLES: use the brand by name, not by value: in canvas.create-node and frame.create write fill: "brand/accent", stroke: "brand/line", radius: "brand/radius", autoLayout: { gap: "brand/spacing", padding: "brand/spacing" }, and on text textStyle: "brand/heading" (or "brand/body"), which sets family, weight, size, line height and letter spacing together from the brand's type role. Each binds, so the layer follows the canvas brand and a switch of brand; "var/<name>" reaches a workspace variable (text: "var/product/name", visible: "var/flags/promo"). A dark version of a frame is variableModes: { brand: "dark" } on it, not new colours. canvas.variable binds existing layers (op "bind", "apply-style", "set-mode"); op "list" shows every variable and style. A typed value detaches.
 - GRADIENTS: gradient { kind, angle, stops: [{ offset, color }] } replaces the solid fill. angle is the direction the colour travels: 0 = left to right, 90 = top to bottom, 45 = top-left to bottom-right (not CSS degrees). Use two or three stops from the brand palette, and keep text off a busy gradient or check its contrast in canvas.review.
 - SHADOWS AND BLUR: effects on any node. A soft card shadow is { type: "drop-shadow", x: 0, y: 4, blur: 16, spread: 0, color: "#0000001F" }; frosted glass is { type: "background-blur", blur: 16 }. Never fake a shadow with an extra rectangle.
-- DRAWING: build every mark, icon, illustration and diagram shape from native layers, as a designer does in Figma, never as one generated SVG file. Primitives are canvas.create-node rect and ellipse; curves are pen paths, vector.create { name, parentId, points: [{ x, y, hIn?: { x, y }, hOut?: { x, y } }], closed, fill or stroke, strokeWidth }, where hIn/hOut are absolute control points: use few anchors with smooth handles. It also takes d (SVG path data, converted to native editable points) or shape: petal|circle|polygon|star|arc|spiral with cx, cy and sizes; strokeCap/strokeJoin apply. Reshape in place with canvas.update-nodes { ids, patch: { points | d | shape } }. Draw a repeated part once: canvas.repeat { id, count, around | cx, cy } turns one petal into a flower; canvas.rotate { ids, angle, cx, cy }; canvas.boolean { ids, op: "union" | "subtract" | "intersect" | "exclude" } (exact, editable operands). Work back to front: ground, big silhouettes in flat brand colours, then features, then details and highlights; check the silhouette in canvas.review before detailing. Name layers by part ("fox/ear-left"), group each figure with canvas.group { ids, name } and set overlap with canvas.order { ids, op }. Keep one stroke weight per drawing. Photographic or painterly imagery is a placed raster. Raw SVG stays supported but is never the default: when an SVG is asked for, write the markup yourself as an svg node, canvas.create-node { type: "svg", name, w, h, svg } with <svg viewBox="0 0 W H"> matching w and h, or import existing markup the same way; never an SVG generation pipeline.
-- COMPUTED GEOMETRY: shapes from math (radial petals, spirals, grids) are computed and drawn in ONE call: canvas-act { compositionId, script } runs JavaScript with geo.petal/circle/arc/star/polygon/spiral/smooth/rotate/radial/grid/bounds (degrees, 0 = 3 o'clock, clockwise) and a read-only scene list, then applies the { action, args } steps it returns. Never copy numbers from one tool result into another call.
+- DRAWING: build every mark, icon, illustration and diagram shape from native layers, as a designer does in Figma, never as one generated SVG file. Primitives are canvas.create-node rect and ellipse; curves are pen paths, vector.create { name, parentId, d, fill or stroke, strokeWidth }: write d as SVG path data (M, C, Z), native editable points in far fewer tokens than points: [{ x, y, hIn?, hOut? }] (hIn/hOut are absolute control points); few anchors, smooth curves. It also takes shape: petal|circle|polygon|star|arc|spiral with cx, cy and sizes; strokeCap/strokeJoin apply. Reshape in place with canvas.update-nodes { ids, patch: { points | d | shape } }. Draw a repeated part once: canvas.repeat { id, count, around | cx, cy } turns one petal into a flower; canvas.rotate { ids, angle, cx, cy }; canvas.boolean { ids, op: "union" | "subtract" | "intersect" | "exclude" } (exact, editable operands). Work back to front: ground, big silhouettes in flat brand colours, then features, then details and highlights; check the silhouette in canvas.review before detailing. Name layers by part ("fox/ear-left"), group each figure with canvas.group { ids, name } and set overlap with canvas.order { ids, op }. Keep one stroke weight per drawing. Photographic or painterly imagery is a placed raster. Raw SVG stays supported but is never the default: when an SVG is asked for, write the markup yourself as an svg node, canvas.create-node { type: "svg", name, w, h, svg } with <svg viewBox="0 0 W H"> matching w and h, or import existing markup the same way; never an SVG generation pipeline.
+- COMPUTED GEOMETRY: shapes from math (radial petals, spirals, grids) are computed and drawn in ONE call: canvas-act { compositionId, script } runs JavaScript with geo.petal/circle/arc/star/polygon/spiral/smooth/rotate/radial/grid/bounds (degrees, 0 = 3 o'clock, clockwise) and a read-only scene list, then applies the { action, args } steps it returns. Never copy numbers from one tool result into another call. A new top-level artboard goes beside or below what scene already holds (or leave out both x and y), never at 0,0 over an existing one.
 - SHEETS: several concepts or variants go on canvas.sheet { name, title, subtitle, cards or count, cols, cardW, cardH }: a live wrap grid of card frames that own their captions, so rows never overlap. Draw into a card with parentId = its id.
 - MEASURE: answer spacing, overlap and alignment questions with canvas.measure { frame } or { ids } and quote its numbers, never from memory or a preview.
 - PLACEHOLDERS: until real imagery exists, draw a native placeholder at the final size in a muted brand tone, never a flat accent block: a rect with the slot radius plus a simple motif (an ellipse sun, a vector.create mountain), grouped with canvas.group and named "<section> image placeholder", with any label in its own text node.

package/skills/index.json

@@ -17,7 +17,7 @@
       "project-plans.md",
       "review.mjs"
     ],
-    "sha": "5daf296f2bdf65e6"
+    "sha": "e23e25bd46b02d9c"
   },
   {
     "name": "agent-home",
@@ -82,7 +82,7 @@
     "files": [
       "SKILL.md"
     ],
-    "sha": "c20b255224221342"
+    "sha": "11505106cb1dd287"
   },
   {
     "name": "visualize",