@astrosheep/square 0.3.9 → 0.3.11

package/dist/paseo-timeline.js

@@ -1,4 +1,5 @@
 import { setTimeout as sleep } from 'node:timers/promises';
+import { connectPaseoDaemon } from './paseo-connection.js';
 async function waitSnapshots(agentId, read, opts) {
     const initial = await read(agentId);
     if (initial.agentStatus === 'idle')
@@ -24,53 +25,42 @@ async function waitSnapshots(agentId, read, opts) {
     }
     return false;
 }
-function paseoUrl() {
-    const value = process.env.SQUARE_PASEO_WS_URL?.trim() || process.env.PASEO_LISTEN?.trim();
-    if (!value)
-        return 'ws://127.0.0.1:6767/ws';
-    if (/^wss?:\/\//i.test(value))
-        return value.replace(/\/$/, '') + (value.endsWith('/ws') ? '' : '/ws');
-    if (/^\d+$/.test(value))
-        return `ws://127.0.0.1:${value}/ws`;
-    return `ws://${value.replace(/\/$/, '')}/ws`;
-}
-async function remoteSnapshot(agentId) {
-    const socket = new WebSocket(paseoUrl());
-    await new Promise((resolve, reject) => {
-        const timer = setTimeout(() => { socket.close(); reject(new Error('Paseo timeline connection timed out.')); }, 3000);
-        socket.addEventListener('open', () => { clearTimeout(timer); resolve(); }, { once: true });
-        socket.addEventListener('error', () => { clearTimeout(timer); reject(new Error('Paseo timeline unavailable.')); }, { once: true });
-    });
-    return await new Promise((resolve, reject) => {
-        const timer = setTimeout(() => { socket.close(); reject(new Error('Paseo timeline request timed out.')); }, 3000);
-        const requestId = `${process.pid}-${Date.now()}`;
-        socket.addEventListener('message', (event) => {
-            try {
-                const outer = JSON.parse(String(event.data));
-                const payload = outer?.message?.payload;
-                if (outer?.message?.type !== 'fetch_agent_timeline_response' || payload?.requestId !== requestId)
-                    return;
-                clearTimeout(timer);
-                socket.close();
-                const tools = new Map();
-                for (const entry of payload.entries ?? []) {
-                    const item = entry?.item;
-                    if (item?.type === 'tool_call' && typeof item.callId === 'string' && ['running', 'completed', 'failed'].includes(item.status))
-                        tools.set(item.callId, item.status);
-                }
-                resolve({ agentStatus: typeof payload.agent?.status === 'string' ? payload.agent.status : 'unknown', toolCalls: [...tools].map(([callId, status]) => ({ callId, status })) });
-            }
-            catch { /* ignore unrelated frames */ }
-        });
-        socket.send(JSON.stringify({ type: 'hello', clientId: `square-${process.pid}`, clientType: 'cli', protocolVersion: 1 }));
-        socket.send(JSON.stringify({ type: 'session', message: { type: 'fetch_agent_timeline_request', agentId, requestId, direction: 'tail', limit: 200, projection: 'projected' } }));
-    });
+function snapshotFromPayload(payload) {
+    const tools = new Map();
+    for (const entry of payload.entries ?? []) {
+        const item = entry.item;
+        if (item.type === 'tool_call' && ['running', 'completed', 'failed'].includes(item.status)) {
+            tools.set(item.callId, item.status);
+        }
+    }
+    return {
+        agentStatus: payload.agent?.status ?? 'unknown',
+        toolCalls: [...tools].map(([callId, status]) => ({ callId, status })),
+    };
 }
 export async function waitForPaseoToolBoundary(agentId, opts = {}) {
+    if (opts.readSnapshot !== undefined) {
+        try {
+            return await waitSnapshots(agentId, opts.readSnapshot, opts);
+        }
+        catch {
+            return false;
+        }
+    }
+    let client;
     try {
-        return await waitSnapshots(agentId, opts.readSnapshot ?? remoteSnapshot, opts);
+        client = await connectPaseoDaemon();
+        return await waitSnapshots(agentId, async (id) => snapshotFromPayload(await client.fetchAgentTimeline(id, {
+            direction: 'tail',
+            limit: 200,
+            projection: 'projected',
+            timeout: 3_000,
+        })), opts);
     }
     catch {
         return false;
     }
+    finally {
+        await client?.close().catch(() => { });
+    }
 }

package/dist/presentation.js

@@ -31,10 +31,10 @@ export function quoteShell(value) {
     return `'${value.replace(/'/g, `'\\''`)}'`;
 }
 export function commandPrefix(squarePath) {
-    return `square --square-path ${quoteShell(squarePath)}`;
+    return `square --location ${quoteShell(squarePath)}`;
 }
 export function participantCommandPrefix(squarePath, name) {
-    return `square --square-path ${quoteShell(path.resolve(squarePath))} --as ${quoteShell(name)}`;
+    return `square --location ${quoteShell(path.resolve(squarePath))} --as ${quoteShell(name)}`;
 }
 function formatAge(ms) {
     if (ms === undefined)

package/dist/presented.js

@@ -2,13 +2,12 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { createHash } from 'node:crypto';
+import { withFileLockSync } from './file-lock.js';
 import { canonicalSquarePath, lookupParticipant, lookupSessionBindings } from './registry.js';
 import { sameName } from './model.js';
 const RETENTION_MS = 7 * 24 * 60 * 60 * 1000;
 const LOCK_STALE_MS = 5 * 60_000;
 const LOCK_RETRY_MS = 10;
-const lockWait = new Int32Array(new SharedArrayBuffer(4));
-const heldLocks = new Set();
 export function presentedPath(env = process.env) {
     return env.SQUARE_PRESENTED || path.join(os.homedir(), '.square', 'presented.ndjsonl');
 }
@@ -33,7 +32,7 @@ function readRows(filePath, now = Date.now()) {
         try {
             const parsed = JSON.parse(line);
             if (parsed.v !== 2 ||
-                typeof parsed.ts !== 'number' ||
+                typeof parsed.ts !== 'number' || !Number.isFinite(parsed.ts) ||
                 typeof parsed.owner_id !== 'string' ||
                 typeof parsed.square_path !== 'string' ||
                 typeof parsed.name !== 'string' ||
@@ -57,67 +56,6 @@ function writeRows(filePath, rows) {
     });
     fs.renameSync(temp, filePath);
 }
-function lockOwnerState(lockPath) {
-    let pid;
-    try {
-        pid = Number.parseInt(fs.readFileSync(lockPath, 'utf8').split('\n')[0], 10);
-    }
-    catch {
-        return 'unknown';
-    }
-    if (!Number.isSafeInteger(pid) || pid <= 0)
-        return 'unknown';
-    try {
-        process.kill(pid, 0);
-        return 'alive';
-    }
-    catch (error) {
-        return error.code === 'ESRCH' ? 'dead' : 'alive';
-    }
-}
-function withFileLock(lockPath, fn) {
-    if (heldLocks.has(lockPath))
-        throw new Error(`Reentrant presented lock: ${lockPath}`);
-    fs.mkdirSync(path.dirname(lockPath), { recursive: true });
-    while (true) {
-        let acquired = false;
-        try {
-            const fd = fs.openSync(lockPath, 'wx', 0o600);
-            try {
-                fs.writeFileSync(fd, `${process.pid}\n${Date.now()}\n`, 'utf8');
-            }
-            finally {
-                fs.closeSync(fd);
-            }
-            acquired = true;
-            heldLocks.add(lockPath);
-            return fn();
-        }
-        catch (error) {
-            const errno = error;
-            if (acquired || errno.code !== 'EEXIST')
-                throw error;
-            try {
-                const stat = fs.statSync(lockPath);
-                if (lockOwnerState(lockPath) === 'dead' || Date.now() - stat.mtimeMs > LOCK_STALE_MS) {
-                    fs.unlinkSync(lockPath);
-                    continue;
-                }
-            }
-            catch { }
-            Atomics.wait(lockWait, 0, 0, LOCK_RETRY_MS);
-        }
-        finally {
-            if (acquired) {
-                heldLocks.delete(lockPath);
-                try {
-                    fs.unlinkSync(lockPath);
-                }
-                catch { }
-            }
-        }
-    }
-}
 function membershipKey(membership) {
     return `${canonicalSquarePath(membership.squarePath)}\u0000${membership.name.toLocaleLowerCase()}`;
 }
@@ -130,7 +68,7 @@ function withAttentionLocks(filePath, inbox, fn) {
     function acquire(index) {
         if (index >= lockPaths.length)
             return fn();
-        return withFileLock(lockPaths[index], () => acquire(index + 1));
+        return withFileLockSync(lockPaths[index], { retryMs: LOCK_RETRY_MS, staleMs: LOCK_STALE_MS }, () => acquire(index + 1));
     }
     return acquire(0);
 }
@@ -154,24 +92,24 @@ function selectUnpresented(sessionId, inbox, rows) {
             : [{ membership: { ...membership, notifications }, ownerId }];
     });
 }
-export function hasPresentedForOwner(ownerId, squarePath, name, actIndex, env = process.env) {
+export function hasPresentedForOwner(ownerId, squarePath, name, actIndex, env = process.env, now = Date.now()) {
     const resolved = canonicalSquarePath(squarePath);
-    return readRows(presentedPath(env)).some((row) => row.owner_id === ownerId &&
+    return readRows(presentedPath(env), now).some((row) => row.owner_id === ownerId &&
         canonicalSquarePath(row.square_path) === resolved &&
         sameName(row.name, name) &&
         row.act_index === actIndex);
 }
 /** True when any current participant owner has already received this attention. */
-export function hasPresentedAttention(squarePath, name, actIndex, env = process.env) {
-    const ownerIds = new Set(lookupParticipant(squarePath, name).map((binding) => binding.ownerId));
+export function hasPresentedAttention(squarePath, name, actIndex, env = process.env, now = Date.now()) {
+    const ownerIds = new Set(lookupParticipant(squarePath, name, now).map((binding) => binding.ownerId));
     if (ownerIds.size === 0)
         return false;
-    return [...ownerIds].some((ownerId) => hasPresentedForOwner(ownerId, squarePath, name, actIndex, env));
+    return [...ownerIds].some((ownerId) => hasPresentedForOwner(ownerId, squarePath, name, actIndex, env, now));
 }
 /**
  * Serialize presentation only for the affected participants. Delivery runs
  * outside the short ledger-write lock, so unrelated owners never wait on an
- * adapter. A throwing callback leaves no row and remains retryable.
+ * adapter. A throwing callback leaves no row and remains unpresented.
  */
 export function presentOnce(sessionId, lookup, deliver, env = process.env, at = Date.now()) {
     const filePath = presentedPath(env);
@@ -185,7 +123,7 @@ export function presentOnce(sessionId, lookup, deliver, env = process.env, at =
         if (selected.length === 0)
             return undefined;
         const result = deliver(selected.map(({ membership }) => membership));
-        withFileLock(`${filePath}.lock`, () => {
+        withFileLockSync(`${filePath}.lock`, { retryMs: LOCK_RETRY_MS, staleMs: LOCK_STALE_MS }, () => {
             const rows = readRows(filePath, at);
             const known = new Set(rows.map(rowKey));
             for (const { membership, ownerId } of selected) {

package/dist/registry.js

@@ -9,9 +9,9 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { homedir } from 'node:os';
 import { randomUUID } from 'node:crypto';
-import { loadSquare } from './artifact.js';
 import { nameKey, sameName } from './model.js';
 import { isCurrentlyJoined } from './runtime.js';
+import { publishWakeRoutes, retireOwnerWakeRoutes } from './routes.js';
 const MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
 const COMPACT_BYTES = 64 * 1024;
 const COMPACT_LINES = 1000;
@@ -231,19 +231,11 @@ export function localParticipantOwner(squarePath, name, env = process.env, now =
         return undefined;
     return lookupParticipant(squarePath, name, now).find((binding) => sessionIds.has(binding.sessionId))?.ownerId;
 }
-function bindingIsProvablyObsolete(binding) {
-    if (!fs.existsSync(binding.squarePath))
-        return true;
-    try {
-        return !isCurrentlyJoined(loadSquare(binding.squarePath).acts, binding.name);
-    }
-    catch {
-        // A temporarily unreadable artifact is uncertain, so preserve its binding.
-        return false;
-    }
+function bindingIsProvablyObsolete(binding, acts) {
+    return acts !== undefined && !isCurrentlyJoined(acts, binding.name);
 }
 /** Compact the registry and remove only bindings disproved by their authoritative artifact. */
-export function pruneRegistry(now = Date.now()) {
+export function pruneRegistry(readActs, now = Date.now()) {
     const filePath = registryPath();
     let raw;
     try {
@@ -255,7 +247,7 @@ export function pruneRegistry(now = Date.now()) {
         throw error;
     }
     const active = foldRegistry(raw, now);
-    const kept = active.filter((binding) => !bindingIsProvablyObsolete(binding));
+    const kept = active.filter((binding) => !bindingIsProvablyObsolete(binding, readActs(binding.squarePath)));
     writeRegistryBindings(filePath, kept);
     return { removed: active.length - kept.length, kept: kept.length };
 }
@@ -280,25 +272,29 @@ export function hasAutomaticDeliveryIdentity(env = process.env) {
 export function recordLocalJoin(name, squarePath, env = process.env) {
     const at = Date.now();
     const identities = localSessionIdentities(env);
-    const identityIds = new Set(identities.map((identity) => identity.sessionId));
     const current = lookupParticipant(squarePath, name, at);
-    const ownerId = current.find((binding) => identityIds.has(binding.sessionId))?.ownerId ?? nextOwnerId();
+    const ownerId = nextOwnerId();
+    for (const binding of current) {
+        recordDone(binding.sessionId, binding.name, binding.squarePath, {
+            channel: binding.channel,
+            child: binding.child,
+            ...(binding.paseoAgentId ? { paseoAgentId: binding.paseoAgentId } : {}),
+            at,
+        });
+    }
     for (const identity of identities) {
         recordJoin(identity.sessionId, name, squarePath, { ...identity, at, ownerId });
     }
+    publishWakeRoutes(ownerId, { at, env });
+    for (const previousOwnerId of new Set(current.map((binding) => binding.ownerId))) {
+        if (previousOwnerId !== ownerId)
+            retireOwnerWakeRoutes(previousOwnerId, { at, env });
+    }
 }
 export function recordLocalDone(name, squarePath, env = process.env) {
     const at = Date.now();
-    const identities = localSessionIdentities(env);
-    const identityIds = new Set(identities.map((identity) => identity.sessionId));
     const current = lookupParticipant(squarePath, name, at);
-    const ownerId = current.find((binding) => identityIds.has(binding.sessionId))?.ownerId;
-    if (ownerId === undefined) {
-        for (const identity of identities)
-            recordDone(identity.sessionId, name, squarePath, { ...identity, at });
-        return;
-    }
-    for (const binding of current.filter((candidate) => candidate.ownerId === ownerId)) {
+    for (const binding of current) {
         recordDone(binding.sessionId, binding.name, binding.squarePath, {
             channel: binding.channel,
             child: binding.child,
@@ -306,4 +302,7 @@ export function recordLocalDone(name, squarePath, env = process.env) {
             at,
         });
     }
+    for (const ownerId of new Set(current.map((binding) => binding.ownerId))) {
+        retireOwnerWakeRoutes(ownerId, { at, env });
+    }
 }

package/dist/routes.js

@@ -0,0 +1,153 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { WAKE_ROUTE_KINDS, isWakeRouteKind } from './model.js';
+export { isWakeRouteKind, WAKE_ROUTE_KINDS } from './model.js';
+const RETENTION_MS = 7 * 24 * 60 * 60 * 1000;
+export const ROUTE_FRESH_MS = 24 * 60 * 60 * 1000;
+/**
+ * Dispatch priority doubles as the kind declaration order: native kinds
+ * precede paseo. Within one kind, the freshest route wins.
+ */
+const ROUTE_KIND_PRIORITY = new Map(WAKE_ROUTE_KINDS.map((kind, index) => [kind, index]));
+export function routesPath(env = process.env) {
+    return env.SQUARE_ROUTES || path.join(os.homedir(), '.square', 'routes.ndjsonl');
+}
+function routeKey(ownerId, kind) {
+    return `${ownerId}\0${kind}`;
+}
+function stringRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value) &&
+        Object.values(value).every((item) => typeof item === 'string');
+}
+function parseRow(raw, now) {
+    let value;
+    try {
+        value = JSON.parse(raw);
+    }
+    catch {
+        return undefined;
+    }
+    if (value === null || typeof value !== 'object')
+        return undefined;
+    const row = value;
+    if (row.v !== 1 ||
+        (row.op !== 'upsert' && row.op !== 'retire') ||
+        typeof row.ts !== 'number' || !Number.isFinite(row.ts) || row.ts > now || now - row.ts > RETENTION_MS ||
+        typeof row.owner_id !== 'string' || row.owner_id === '' ||
+        typeof row.session_id !== 'string' || row.session_id === '' ||
+        !isWakeRouteKind(row.kind))
+        return undefined;
+    if (row.op === 'upsert' && !stringRecord(row.address))
+        return undefined;
+    return row;
+}
+function readRows(env, now) {
+    let raw;
+    try {
+        raw = fs.readFileSync(routesPath(env), 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return [];
+        throw error;
+    }
+    return raw.split('\n').filter(Boolean).map((line) => parseRow(line, now)).filter((row) => row !== undefined);
+}
+export function readWakeRoutes(opts = {}) {
+    const now = opts.now ?? Date.now();
+    const state = new Map();
+    for (const row of readRows(opts.env ?? process.env, now)) {
+        const key = routeKey(row.owner_id, row.kind);
+        const current = state.get(key);
+        if (current === undefined || row.ts >= current.ts)
+            state.set(key, row);
+    }
+    return [...state.values()]
+        .filter((row) => row.op === 'upsert')
+        .map((row) => ({
+        ownerId: row.owner_id,
+        sessionId: row.session_id,
+        kind: row.kind,
+        address: row.address,
+        updatedAt: row.ts,
+    }))
+        .filter((route) => opts.ownerId === undefined || route.ownerId === opts.ownerId)
+        .filter((route) => opts.freshOnly !== true || now - route.updatedAt < ROUTE_FRESH_MS)
+        .sort((a, b) => (ROUTE_KIND_PRIORITY.get(a.kind) ?? 0) - (ROUTE_KIND_PRIORITY.get(b.kind) ?? 0) ||
+        b.updatedAt - a.updatedAt);
+}
+function appendRouteRow(row, env) {
+    const file = routesPath(env);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.appendFileSync(file, `${JSON.stringify(row)}\n`, { mode: 0o600 });
+}
+export function upsertWakeRoute(route, opts = {}) {
+    const at = opts.at ?? Date.now();
+    appendRouteRow({
+        v: 1,
+        ts: at,
+        op: 'upsert',
+        owner_id: route.ownerId,
+        session_id: route.sessionId,
+        kind: route.kind,
+        address: route.address,
+    }, opts.env ?? process.env);
+}
+export function retireOwnerWakeRoutes(ownerId, opts = {}) {
+    const at = opts.at ?? Date.now();
+    const env = opts.env ?? process.env;
+    for (const route of readWakeRoutes({ ownerId, now: at, env })) {
+        appendRouteRow({
+            v: 1,
+            ts: at,
+            op: 'retire',
+            owner_id: ownerId,
+            session_id: route.sessionId,
+            kind: route.kind,
+        }, env);
+    }
+}
+/** Publication requires a non-blank session and a non-empty address of non-blank values. */
+function completeRouteEvidence(value) {
+    if (value === undefined || value === null)
+        return false;
+    if (typeof value.sessionId !== 'string' || value.sessionId.trim() === '')
+        return false;
+    const address = value.address;
+    if (address === null || typeof address !== 'object' || Array.isArray(address))
+        return false;
+    const entries = Object.entries(address);
+    return entries.length > 0 && entries.every(([key, item]) => key.trim() !== '' && typeof item === 'string' && item.trim() !== '');
+}
+/**
+ * One probe per kind. A probe publishes only when its provider's complete
+ * endpoint evidence is present; session identity alone never publishes. The
+ * four native transports have no endpoint lifecycle in this delivery, so
+ * their probes publish nothing until those transports land.
+ */
+export const WAKE_ROUTE_PROBES = {
+    'opencode-server': () => undefined,
+    'codex-app-server': () => undefined,
+    'claude-native': () => undefined,
+    'pi-extension': () => undefined,
+    paseo: (env) => {
+        const agentId = env.PASEO_AGENT_ID?.trim();
+        return agentId ? { sessionId: agentId, address: { agentId } } : undefined;
+    },
+};
+/** The kind-neutral publication loop; probes supply complete evidence per kind. */
+export function publishWakeRoutesFrom(ownerId, probes, opts = {}) {
+    const at = opts.at ?? Date.now();
+    const env = opts.env ?? process.env;
+    for (const kind of WAKE_ROUTE_KINDS) {
+        const evidence = probes[kind](env);
+        if (!completeRouteEvidence(evidence))
+            continue;
+        upsertWakeRoute({ ownerId, sessionId: evidence.sessionId, kind, address: evidence.address }, { at, env });
+    }
+}
+/** Publication boundary: every route written is complete provider evidence. */
+export function publishWakeRoutes(ownerId, opts = {}) {
+    publishWakeRoutesFrom(ownerId, WAKE_ROUTE_PROBES, opts);
+}

package/dist/square-application.js

@@ -1,56 +1,15 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { setTimeout as sleep } from 'node:timers/promises';
 import { emptyRuntimeState, loadRuntimeSidecar, loadSquare, mergeRuntimeState, renderArtifactAct, renderSquare, renderSquareDoc, saveRuntimeSidecar } from './artifact.js';
 import { coreCompact, coreDone, coreHold, coreResume, decideAct, decideJoin, resolveKnownName } from './decisions.js';
-import { dispatchActNotifications } from './notifications.js';
 import { planRepair } from './doctor.js';
+import { withFileLock } from './file-lock.js';
 import { stageReplacement } from './harness-stage.js';
 import { SquareError } from './model.js';
 import { advanceCursor, freshWatchLease, LOCK_RETRY_MS, LOCK_STALE_MS, removeWatchLease, touchPresenceCursor, watchLease, writeWatchLease } from './runtime.js';
 /** The only persistence primitive: one per-square lock, one Markdown write, one sidecar write. */
 export async function withSquareLock(squarePath, fn) {
-    const lockPath = `${squarePath}.lock`;
-    fs.mkdirSync(path.dirname(lockPath), { recursive: true });
-    while (true) {
-        let fd;
-        try {
-            fd = fs.openSync(lockPath, 'wx');
-            fs.writeFileSync(fd, `${process.pid}\n${Date.now()}\n`, 'utf8');
-        }
-        catch (error) {
-            if (fd !== undefined) {
-                try {
-                    fs.closeSync(fd);
-                }
-                catch { }
-                try {
-                    fs.unlinkSync(lockPath);
-                }
-                catch { }
-            }
-            const errno = error;
-            if (errno.code !== 'EEXIST')
-                throw error;
-            try {
-                if (Date.now() - fs.statSync(lockPath).mtimeMs > LOCK_STALE_MS)
-                    fs.unlinkSync(lockPath);
-            }
-            catch { }
-            await sleep(LOCK_RETRY_MS);
-            continue;
-        }
-        fs.closeSync(fd);
-        try {
-            return await fn();
-        }
-        finally {
-            try {
-                fs.unlinkSync(lockPath);
-            }
-            catch { }
-        }
-    }
+    return withFileLock(`${squarePath}.lock`, { retryMs: LOCK_RETRY_MS, staleMs: LOCK_STALE_MS }, fn);
 }
 export function writeSquareDoc(squarePath, doc) {
     const temporary = path.join(path.dirname(squarePath), `.${path.basename(squarePath)}.${process.pid}.${Date.now()}.tmp`);
@@ -136,6 +95,50 @@ function plan(doc, intent) {
                 mutateRuntime: (nextDoc) => { removeWatchLease(nextDoc, name, intent.leaseId); },
             };
         }
+        case 'claim-notify': {
+            const current = doc.runtime.notifyLeases[intent.key];
+            if (current !== undefined && current.expiresAt > intent.at)
+                return { result: { type: 'busy' }, acts: [] };
+            if (current?.phase === 'dispatching')
+                return { result: { type: 'ambiguous', lease: current }, acts: [] };
+            return {
+                result: { type: 'acquired', leaseId: intent.leaseId },
+                acts: [],
+                mutateRuntime: (nextDoc) => {
+                    nextDoc.runtime.notifyLeases[intent.key] = {
+                        leaseId: intent.leaseId,
+                        expiresAt: intent.expiresAt,
+                        phase: 'claimed',
+                    };
+                },
+            };
+        }
+        case 'transition-notify': {
+            if (doc.runtime.notifyLeases[intent.key]?.leaseId !== intent.leaseId)
+                return { result: { updated: false }, acts: [] };
+            return {
+                result: { updated: true },
+                acts: [],
+                mutateRuntime: (nextDoc) => {
+                    nextDoc.runtime.notifyLeases[intent.key] = {
+                        leaseId: intent.leaseId,
+                        expiresAt: intent.expiresAt,
+                        phase: intent.phase,
+                        ...(intent.attemptN === undefined ? {} : { attemptN: intent.attemptN }),
+                        ...(intent.routeKind === undefined ? {} : { routeKind: intent.routeKind }),
+                    };
+                },
+            };
+        }
+        case 'release-notify': {
+            if (doc.runtime.notifyLeases[intent.key]?.leaseId !== intent.leaseId)
+                return { result: { released: false }, acts: [] };
+            return {
+                result: { released: true },
+                acts: [],
+                mutateRuntime: (nextDoc) => { delete nextDoc.runtime.notifyLeases[intent.key]; },
+            };
+        }
         case 'consume': {
             const name = resolveKnownName(doc, intent.name);
             return {
@@ -199,15 +202,10 @@ function commitPlan(squarePath, doc, planned) {
 }
 /** The one mutation pipeline shared by package and CLI adapters. */
 export async function execute(squarePath, intent) {
-    const committed = await withSquareLock(squarePath, () => {
+    return withSquareLock(squarePath, () => {
         const doc = loadSquare(squarePath);
         return commitPlan(squarePath, doc, plan(doc, intent));
     });
-    for (const act of committed.acts) {
-        if (act.kind === 'say')
-            await dispatchActNotifications(squarePath, act);
-    }
-    return committed;
 }
 /** Application-owned artifact creation; adapters provide validated options and stdin text only. */
 export async function createSquare(squarePath, options, snippet) {

package/dist/stream.js

@@ -45,6 +45,6 @@ export async function cmdStreamNdjson(squarePath, recipient) {
 }
 export async function cmdStream(squarePath) {
     process.stderr.write('✕ interactive stream was removed\n');
-    process.stderr.write(`» square --square-path ${quoteShell(path.resolve(squarePath))} stream --ndjson\n`);
+    process.stderr.write(`» square --location ${quoteShell(path.resolve(squarePath))} stream --ndjson\n`);
     process.exitCode = 2;
 }