@astrosheep/square 0.3.10 → 0.3.12

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/runtime.js

@@ -1,4 +1,4 @@
-import { fold } from './square-core.js';
+import { audienceIncludes, audienceOf, fold, formatActivityId } from './square-core.js';
 import { SquareError, findParticipantName, nameKey, sameName, } from './model.js';
 function parseIntegerEnvValue(name, raw, fallback) {
     if (raw === undefined)
@@ -51,27 +51,12 @@ export function nowMs() {
     }
     return value;
 }
-export function extractMentions(body) {
-    const matches = [];
-    const re = /@([\p{L}\p{N}_-]+)/gu;
-    let match;
-    while ((match = re.exec(body)) !== null)
-        matches.push(match[1]);
-    return matches;
-}
-/** Pure directed-activity filter. Broadcast bodies (no @) match any named viewer. */
+/** Pure directed-activity filter. Bell matches every viewer; mentions match by audience. */
 export function matchesMentionTarget(act, mention) {
-    if (act.reach === 'bell')
-        return true;
-    if (act.reach !== undefined) {
-        return mention === true || sameName(act.reach.beside, mention);
-    }
-    const mentions = extractMentions(act.body);
+    const audience = audienceOf(act);
     if (mention === true)
-        return mentions.length > 0;
-    if (mentions.length === 0)
-        return true;
-    return mentions.some((name) => sameName(name, mention));
+        return audience.kind === 'bell' || audience.names.length > 0;
+    return audienceIncludes(audience, mention);
 }
 export function foldedState(doc) {
     return fold(doc.acts);
@@ -131,7 +116,7 @@ export function actStableIndex(act) {
 }
 export function actId(actOrIndex) {
     const index = typeof actOrIndex === 'number' ? actOrIndex : actStableIndex(actOrIndex);
-    return `act_${index}`;
+    return formatActivityId(index);
 }
 export function getReadState(doc, name) {
     return doc.runtime.cursors[name] ?? Object.entries(doc.runtime.cursors).find(([participant]) => sameName(participant, name))?.[1];

package/dist/square-application.js

@@ -1,62 +1,16 @@
 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 { createSquareDoc, loadArchive, loadSquare, writeArchiveFile, writeSquareFile } 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. */
+/** The only mutation boundary: one per-square lock around one complete snapshot commit. */
 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`);
-    fs.writeFileSync(temporary, renderSquareDoc(doc));
-    fs.renameSync(temporary, squarePath);
-    saveRuntimeSidecar(squarePath, doc.runtime);
+    writeSquareFile(squarePath, doc);
 }
 export function appendAct(squarePath, doc, act) {
     const stored = applyActs(doc, [act])[0];
@@ -76,13 +30,11 @@ function applyActs(doc, acts, mutateRuntime) {
     mutateRuntime?.(doc);
     return stored;
 }
-/**
- * Publish a dependent persistence file before the Square document. A retained
- * backup lets a failed document commit restore the prior file exactly.
- */
-function prepareAppend(filePath, block, existing = fs.existsSync(filePath) ? fs.readFileSync(filePath, 'utf8') : '') {
+/** Publish a dependent archive before the main snapshot, retaining rollback evidence. */
+function prepareArchive(filePath, acts) {
+    const existing = fs.existsSync(filePath) ? loadArchive(filePath) : [];
     return stageReplacement(filePath, (stage) => {
-        fs.writeFileSync(stage, `${existing}${existing === '' ? '' : '\n'}${block}\n`);
+        writeArchiveFile(stage, [...existing, ...acts]);
     });
 }
 function plan(doc, intent) {
@@ -136,6 +88,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 {
@@ -153,27 +149,9 @@ function plan(doc, intent) {
                 replaceDoc: result.doc,
                 preparePersistence: archive.length === 0
                     ? undefined
-                    : () => {
-                        const existing = fs.existsSync(intent.archivePath) ? fs.readFileSync(intent.archivePath, 'utf8') : '';
-                        const block = archive
-                            .map((act, index) => renderArtifactAct(act, { first: existing === '' && index === 0 }))
-                            .join('\n');
-                        return prepareAppend(intent.archivePath, block, existing);
-                    },
+                    : () => prepareArchive(intent.archivePath, archive),
             };
         }
-        case 'repair':
-            return {
-                result: undefined,
-                acts: [],
-                replaceDoc: intent.doc,
-                preparePersistence: intent.quarantine === undefined || intent.quarantine.blocks.length === 0
-                    ? undefined
-                    : () => {
-                        const block = intent.quarantine.blocks.join('\n\n');
-                        return prepareAppend(intent.quarantine.path, block);
-                    },
-            };
     }
 }
 function commitPlan(squarePath, doc, planned) {
@@ -199,15 +177,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) {
@@ -215,50 +188,6 @@ export async function createSquare(squarePath, options, snippet) {
         if (fs.existsSync(squarePath) && !options.force) {
             throw new SquareError('conflict', `Refusing to overwrite existing square: ${squarePath}\nPass -f to overwrite.`);
         }
-        const temporary = path.join(path.dirname(squarePath), `.${path.basename(squarePath)}.${process.pid}.${Date.now()}.tmp`);
-        fs.mkdirSync(path.dirname(squarePath), { recursive: true });
-        fs.writeFileSync(temporary, renderSquare(options, snippet));
-        fs.renameSync(temporary, squarePath);
-        saveRuntimeSidecar(squarePath, emptyRuntimeState(0));
-    });
-}
-/** Keep artifact repair planning and dependent quarantine persistence inside the application boundary. */
-export async function repairSquare(squarePath) {
-    const result = await withSquareLock(squarePath, () => {
-        let text;
-        try {
-            text = fs.readFileSync(squarePath, 'utf8');
-        }
-        catch (error) {
-            if (error.code === 'ENOENT')
-                throw new SquareError('not_found', `square file not found: ${squarePath}`);
-            throw error;
-        }
-        const repair = planRepair(text);
-        if (repair.diagnosis.unfixable || repair.repaired === undefined)
-            return { repair };
-        // Repair changes Markdown only. Keep the sidecar's runtime metadata and
-        // merge history boundaries so a doctor run cannot erase delivery state or
-        // reuse a stable activity index.
-        const sidecarRuntime = loadRuntimeSidecar(squarePath, repair.repaired.doc.runtime);
-        const indexesPreserved = repair.diagnosis.acts.every(({ act }, index) => repair.repaired.doc.acts[index]?.index === act.index);
-        if (indexesPreserved) {
-            repair.repaired.doc.runtime = mergeRuntimeState(repair.repaired.doc.runtime, sidecarRuntime);
-        }
-        else {
-            repair.repaired.doc.runtime = emptyRuntimeState(Math.max(repair.repaired.doc.runtime.nextActIndex, sidecarRuntime.nextActIndex));
-            repair.repaired.actions.push({ message: 'reset runtime delivery metadata because act indexes changed' });
-        }
-        const quarantinePath = squarePath.replace(/\.md$/, '') + '.quarantine.md';
-        const intent = {
-            type: 'repair',
-            doc: repair.repaired.doc,
-            ...(repair.repaired.quarantinedBlocks.length === 0
-                ? {}
-                : { quarantine: { path: quarantinePath, blocks: repair.repaired.quarantinedBlocks } }),
-        };
-        commitPlan(squarePath, repair.repaired.doc, plan(repair.repaired.doc, intent));
-        return { repair };
+        writeSquareFile(squarePath, createSquareDoc(options, snippet));
     });
-    return result.repair;
 }