@astrosheep/square 0.3.4 → 0.3.6

package/codex-plugin/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "square",
-  "version": "0.3.4",
+  "version": "0.3.6",
   "description": "Shared Square activity with reliable participant attention at Codex boundaries.",
   "author": {
     "name": "Square"
@@ -15,7 +15,8 @@
   "interface": {
     "displayName": "Square",
     "shortDescription": "Join and coordinate through a shared square",
-    "longDescription": "Participate in a shared activity stream and receive addressed Square activity at Codex boundaries.",
+    "longDescription": "Participate in a shared square and receive addressed activity at Codex boundaries.",
+    "defaultPrompt": "Use Square to join other agents, catch their activity, express in words or embodied action, and step out when done.",
     "developerName": "Square",
     "category": "Developer Tools",
     "capabilities": [

package/dist/activity-feed.js

@@ -1,36 +1,44 @@
 import { sameName } from './model.js';
-import { actStableIndex, advanceCursor, latestIndexedActIndex } from './runtime.js';
-import { matchesCatchFilter } from './delivery.js';
-export function indexedDelta(acts, cursor) {
-    return acts
-        .map((act) => ({ act, index: actStableIndex(act) }))
-        .filter((item) => item.index > cursor);
+import { advanceCursor, latestActIndex, readCursor } from './runtime.js';
+import { deriveDeliveryModel, matchesCatchFilter } from './delivery.js';
+export function actDelta(acts, cursor) {
+    return acts.filter((act) => act.index > cursor);
+}
+/** Public cursor changes plus directed receipts that remain pending behind it. */
+export function deliveryDelta(doc, name) {
+    const items = actDelta(doc.acts, readCursor(doc, name));
+    const seen = new Set(items.map((act) => act.index));
+    for (const notification of deriveDeliveryModel(doc).pendingFor(name)) {
+        if (!seen.has(notification.item.index))
+            items.push(notification.item);
+    }
+    return items.sort((a, b) => a.index - b.index);
 }
 export function peerRoomChanges(delta, name) {
-    return delta.filter((item) => item.act.actor !== undefined && !sameName(item.act.actor, name) && item.act.kind !== 'say' && item.act.kind !== 'read');
+    return delta.filter((act) => act.actor !== undefined && !sameName(act.actor, name) && act.kind !== 'say' && act.kind !== 'read');
 }
 export function peerPublicActs(delta, name) {
-    return delta.filter((item) => item.act.actor !== undefined && !sameName(item.act.actor, name) && (item.act.kind === 'say' || item.act.kind === 'done'));
+    return delta.filter((act) => act.actor !== undefined && !sameName(act.actor, name) && (act.kind === 'say' || act.kind === 'done'));
 }
-function matchesParticipants(item, participants) {
-    return participants === undefined || (item.act.actor !== undefined && participants.some((participant) => sameName(participant, item.act.actor)));
+function matchesParticipants(act, participants) {
+    return participants === undefined || (act.actor !== undefined && participants.some((participant) => sameName(participant, act.actor)));
 }
-export function matchesFeedFilter(item, filter) {
-    if (item.act.kind === 'say') {
-        return matchesCatchFilter({ actor: item.act.actor, body: item.act.body, bell: item.act.reach === 'bell' }, filter);
+export function matchesFeedFilter(act, filter) {
+    if (act.kind === 'say') {
+        return matchesCatchFilter({ actor: act.actor, body: act.body, reach: act.reach }, filter);
     }
-    return filter.mention === undefined && matchesParticipants(item, filter.participants);
+    return filter.mention === undefined && matchesParticipants(act, filter.participants);
 }
 export function filteredPeerActivities(delta, name, filter) {
     return peerPublicActs(delta, name)
-        .filter((item) => item.act.kind === 'say')
-        .filter((item) => matchesFeedFilter(item, filter));
+        .filter((act) => act.kind === 'say')
+        .filter((act) => matchesFeedFilter(act, filter));
 }
 export function filteredRoomChanges(delta, name, filter) {
     if (filter.mention !== undefined)
         return [];
-    return peerRoomChanges(delta, name).filter((item) => matchesParticipants(item, filter.participants));
+    return peerRoomChanges(delta, name).filter((act) => matchesParticipants(act, filter.participants));
 }
 export function ackPeerDelta(doc, name, delta) {
-    return advanceCursor(doc, name, latestIndexedActIndex([...peerPublicActs(delta, name), ...peerRoomChanges(delta, name)]), 'watch');
+    return advanceCursor(doc, name, latestActIndex([...peerPublicActs(delta, name), ...peerRoomChanges(delta, name)]));
 }

package/dist/activity.js

@@ -4,10 +4,10 @@ import path from 'node:path';
 import { setTimeout as sleep } from 'node:timers/promises';
 import { loadSquare } from './artifact.js';
 import { SquareError, validateName } from './model.js';
-import { dispatchActNotifications } from './notifications.js';
-import { actHintLine, renderActivityBlocked, renderActivityLimit, renderActNoWait, renderActWaiting, renderPendingFeed, withActivityNextOutput, } from './presentation.js';
-import { appendAct, currentHold, inSquareCount, nowMs, SLEEP_MS, withSquareLock, resolveRosterName } from './runtime.js';
-import { decideAct, resolveKnownName } from './decisions.js';
+import { expressHintLine, renderActivityBlocked, renderActivityLimit, renderExpressNoWait, renderExpressWaiting, renderPendingFeed, withPathOutput, } from './presentation.js';
+import { currentHold, inSquareCount, nowMs, SLEEP_MS, resolveRosterName } from './runtime.js';
+import { resolveKnownName } from './decisions.js';
+import { execute } from './square-application.js';
 import { formatTimestamp } from './time.js';
 function draftDirFor(squarePath) {
     return path.join(path.dirname(squarePath), 'drafts');
@@ -68,24 +68,25 @@ export async function cmdActivity(squarePath, name, activity, resolveBody, opts)
             : { beside: resolveKnownName(doc, opts.reach.beside) };
     let announcedWait;
     while (true) {
-        const { decision, sent, headerCount, held } = await withSquareLock(squarePath, () => {
-            const freshDoc = loadSquare(squarePath);
-            const d = decideAct(freshDoc, { name, body, force, now: nowMs(), reach });
-            if (d.type === 'sent') {
-                const appended = appendAct(squarePath, freshDoc, d.act);
-                return { decision: d, sent: { act: appended, index: appended.index }, headerCount: inSquareCount(freshDoc), held: currentHold(freshDoc.acts).active };
-            }
-            return { decision: d, sent: undefined, headerCount: inSquareCount(freshDoc), held: currentHold(freshDoc.acts).active };
+        const committed = await execute(squarePath, {
+            type: 'say',
+            name,
+            body,
+            force,
+            now: nowMs(),
+            ...(reach === undefined ? {} : { reach }),
         });
+        const decision = committed.result;
+        const freshDoc = loadSquare(squarePath);
+        const headerCount = inSquareCount(freshDoc);
+        const held = currentHold(freshDoc.acts).active;
         switch (decision.type) {
             case 'sent': {
-                if (sent)
-                    await dispatchActNotifications(squarePath, sent);
                 const hasPending = decision.pendingPublic.length > 0 || decision.pendingRoomChanges.length > 0;
-                const pending = hasPending ? `\n\n${renderPendingFeed(decision.pendingPublic, decision.pendingRoomChanges)}` : '';
-                const hint = actHintLine(decision.ownActCount);
+                const pending = hasPending ? `\n\n${renderPendingFeed(freshDoc.acts, decision.pendingPublic, decision.pendingRoomChanges)}` : '';
+                const hint = expressHintLine(decision.ownActCount);
                 const withHint = hint ? `${decision.confirmation}\n${hint}` : decision.confirmation;
-                process.stdout.write(withActivityNextOutput(squarePath, withHint + pending, { participantCount: headerCount, held }));
+                process.stdout.write(withPathOutput(squarePath, withHint + pending, { participantCount: headerCount, held }));
                 return;
             }
             case 'blocked': {
@@ -119,11 +120,11 @@ export async function cmdActivity(squarePath, name, activity, resolveBody, opts)
             case 'throttled': {
                 if (noWait) {
                     const draftPath = saveActivityDraft(squarePath, name, rawInput);
-                    process.stdout.write(renderActNoWait({ squarePath, name: knownName, reason: 'throttled', delayMs: decision.delayMs, draftPath, participantCount: headerCount, held }));
+                    process.stdout.write(renderExpressNoWait({ squarePath, name: knownName, reason: 'throttled', delayMs: decision.delayMs, draftPath, participantCount: headerCount, held }));
                     process.exit(1);
                 }
                 if (announcedWait !== 'throttled') {
-                    process.stdout.write(renderActWaiting({ reason: 'throttled', delayMs: decision.delayMs }) + '\n');
+                    process.stdout.write(renderExpressWaiting({ reason: 'throttled', delayMs: decision.delayMs }) + '\n');
                     announcedWait = 'throttled';
                 }
                 await sleep(decision.delayMs);
@@ -132,18 +133,18 @@ export async function cmdActivity(squarePath, name, activity, resolveBody, opts)
             case 'held': {
                 if (noWait) {
                     const draftPath = saveActivityDraft(squarePath, name, rawInput);
-                    process.stdout.write(renderActNoWait({ squarePath, name: knownName, reason: 'held', holdReason: decision.reason, draftPath, participantCount: headerCount, held }));
+                    process.stdout.write(renderExpressNoWait({ squarePath, name: knownName, reason: 'held', holdReason: decision.reason, draftPath, participantCount: headerCount, held }));
                     process.exit(1);
                 }
                 if (announcedWait !== 'held') {
-                    process.stdout.write(renderActWaiting({ reason: 'held' }) + '\n');
+                    process.stdout.write(renderExpressWaiting({ reason: 'held' }) + '\n');
                     announcedWait = 'held';
                 }
                 await sleep(SLEEP_MS);
                 break;
             }
             case 'bell_quota': {
-                process.stdout.write(withActivityNextOutput(squarePath, [`✕ the bell stays quiet for now`, `  · you can ring it again at ${formatTimestamp(decision.nextAt)}`].join('\n'), { participantCount: headerCount, held }));
+                process.stdout.write(withPathOutput(squarePath, [`✕ the bell stays quiet for now`, `  · you can ring it again at ${formatTimestamp(decision.nextAt)}`].join('\n'), { participantCount: headerCount, held }));
                 process.exit(1);
             }
         }

package/dist/artifact.js

@@ -1,7 +1,6 @@
 import fs from 'node:fs';
 import { ACTIVITIES_HEADING, ACTIVITIES_MARKER, ACT_MARKER_PREFIX, WARMUP_HEADING, WARMUP_MARKER, SquareError, CURRENT_FORMAT_VERSION, formatHardCap, sameName, } from './model.js';
 import { formatTimestamp, parseTimestamp } from './time.js';
-const V1_EVENT_MARKER_PREFIX = '<!-- square:event';
 const V2_KINDS = new Set(['say', 'join', 'done', 'hold', 'resume']);
 export function quoteBody(body) {
     const normalized = body.replace(/\r\n/g, '\n').trim();
@@ -61,9 +60,8 @@ export function emptyRuntimeState(nextActIndex = 0) {
     return {
         version: 2,
         nextActIndex,
-        firstActIndex: 0,
         cursors: {},
-        mentionReceipts: {},
+        deliveryReceipts: {},
         leases: {},
     };
 }
@@ -117,25 +115,75 @@ export function renderSquare(opts, snippet) {
 function sidecarPath(squarePath) {
     return `${squarePath}.runtime.json`;
 }
-function loadRuntimeSidecar(squarePath) {
+function invalidRuntimeSidecar(squarePath, detail) {
+    return new SquareError('invalid_args', `Invalid square runtime sidecar ${sidecarPath(squarePath)}: ${detail}`);
+}
+function validateRuntimeSidecar(squarePath, value) {
+    if (!isObject(value))
+        throw invalidRuntimeSidecar(squarePath, 'expected a JSON object.');
+    if (value.version !== 2)
+        throw invalidRuntimeSidecar(squarePath, 'unsupported or missing version.');
+    if (typeof value.nextActIndex !== 'number' || !Number.isInteger(value.nextActIndex) || value.nextActIndex < 0) {
+        throw invalidRuntimeSidecar(squarePath, 'nextActIndex must be a non-negative integer.');
+    }
+    if (!isObject(value.cursors) || !Object.values(value.cursors).every(isReadCursor)) {
+        throw invalidRuntimeSidecar(squarePath, 'cursors contains an invalid read cursor.');
+    }
+    if (!isObject(value.deliveryReceipts) || !Object.values(value.deliveryReceipts).every(isDeliveryReceiptMap)) {
+        throw invalidRuntimeSidecar(squarePath, 'deliveryReceipts contains an invalid receipt map.');
+    }
+    if (!isObject(value.leases) || !Object.values(value.leases).every(isWatchLease)) {
+        throw invalidRuntimeSidecar(squarePath, 'leases contains an invalid watch lease.');
+    }
+    return {
+        version: 2,
+        nextActIndex: value.nextActIndex,
+        cursors: value.cursors,
+        deliveryReceipts: value.deliveryReceipts,
+        leases: value.leases,
+    };
+}
+export function loadRuntimeSidecar(squarePath, fallbackRuntime) {
     const sp = sidecarPath(squarePath);
     try {
         const raw = fs.readFileSync(sp, 'utf8');
-        const parsed = JSON.parse(raw);
-        if (!isObject(parsed) || typeof parsed.nextActIndex !== 'number' || !Number.isInteger(parsed.nextActIndex)) {
-            throw new Error('corrupt sidecar');
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            throw invalidRuntimeSidecar(squarePath, 'malformed JSON.');
         }
-        return parsed;
+        return validateRuntimeSidecar(squarePath, parsed);
     }
     catch (err) {
         if (err.code === 'ENOENT') {
-            return emptyRuntimeState(0);
+            return fallbackRuntime;
         }
         throw err;
     }
 }
+export function mergeRuntimeState(markdownRuntime, sidecarRuntime) {
+    return {
+        ...sidecarRuntime,
+        nextActIndex: Math.max(markdownRuntime.nextActIndex, sidecarRuntime.nextActIndex),
+    };
+}
 export function saveRuntimeSidecar(squarePath, runtime) {
-    fs.writeFileSync(sidecarPath(squarePath), JSON.stringify(runtime, null, 2));
+    const target = sidecarPath(squarePath);
+    const normalized = validateRuntimeSidecar(squarePath, runtime);
+    const temporary = `${target}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`;
+    try {
+        fs.writeFileSync(temporary, JSON.stringify(normalized, null, 2));
+        fs.renameSync(temporary, target);
+    }
+    catch (error) {
+        try {
+            fs.unlinkSync(temporary);
+        }
+        catch { }
+        throw error;
+    }
 }
 export function renderSquareDoc(doc) {
     const warmup = renderWarmupSection(doc.warmup);
@@ -182,25 +230,6 @@ function parseFrontmatter(text) {
         throw new SquareError('invalid_args', 'Invalid square: missing frontmatter.');
     return match[1];
 }
-export function parseStateBlock(frontmatter) {
-    const lines = frontmatter.split('\n');
-    const start = lines.findIndex((line) => /^mind_square_state:\s*\|\s*$/.test(line));
-    if (start < 0)
-        return undefined;
-    const body = [];
-    for (let i = start + 1; i < lines.length; i++) {
-        const line = lines[i];
-        if (!line.startsWith(' ') && !line.startsWith('\t') && /^[A-Za-z_][A-Za-z0-9_-]*:/.test(line))
-            break;
-        if (line.startsWith('  '))
-            body.push(line.slice(2));
-        else if (line.trim() === '')
-            body.push('');
-        else
-            break;
-    }
-    return body.join('\n').trim();
-}
 export function isObject(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
@@ -211,13 +240,12 @@ export function isReadCursor(value) {
         Number.isInteger(value.consumedThroughIndex) &&
         value.consumedThroughIndex >= -1 &&
         typeof value.updatedAt === 'number' &&
-        Number.isFinite(value.updatedAt) &&
-        (value.source === 'join' || value.source === 'watch' || value.source === 'api'));
+        Number.isFinite(value.updatedAt));
 }
-export function isMentionReceipt(value) {
+export function isDeliveryReceipt(value) {
     if (!isObject(value))
         return false;
-    if (value.status !== 'delivered' && value.status !== 'presented')
+    if (value.status !== 'delivered')
         return false;
     if (typeof value.at !== 'number' || !Number.isFinite(value.at))
         return false;
@@ -229,14 +257,16 @@ export function isMentionReceipt(value) {
         return false;
     return true;
 }
-export function isMentionReceiptMap(value) {
-    return isObject(value) && Object.entries(value).every(([id, receipt]) => /^act_\d+$/.test(id) && isMentionReceipt(receipt));
+export function isDeliveryReceiptMap(value) {
+    return isObject(value) && Object.entries(value).every(([id, receipt]) => /^act_\d+$/.test(id) && isDeliveryReceipt(receipt));
 }
 export function isWatchLease(value) {
     if (!isObject(value))
         return false;
     if (typeof value.leaseId !== 'string' || value.leaseId === '')
         return false;
+    if (value.ownerId !== undefined && (typeof value.ownerId !== 'string' || value.ownerId === ''))
+        return false;
     if (typeof value.heartbeatAt !== 'number' || !Number.isFinite(value.heartbeatAt))
         return false;
     if (typeof value.expiresAt !== 'number' || !Number.isFinite(value.expiresAt))
@@ -293,9 +323,8 @@ export function parseFormatVersion(text) {
 export function parseSquare(text) {
     parseFormatVersion(text);
     const runtime = emptyRuntimeState(0);
-    const parsedActs = parseActs(text, 0);
+    const parsedActs = parseActs(text);
     runtime.nextActIndex = parsedActs.nextActIndex;
-    runtime.firstActIndex = parsedActs.firstActIndex;
     return {
         hardCap: parseCap(text),
         throttlePerMinute: parseThrottle(text),
@@ -317,12 +346,12 @@ export function loadSquare(squarePath) {
         throw err;
     }
     const doc = parseSquare(text);
-    const sidecar = loadRuntimeSidecar(squarePath);
-    doc.runtime = sidecar;
-    if (sidecar.nextActIndex > doc.runtime.nextActIndex) {
-        doc.runtime.nextActIndex = sidecar.nextActIndex;
-    }
-    doc.runtime.firstActIndex = sidecar.firstActIndex;
+    const markdownRuntime = doc.runtime;
+    const sidecar = loadRuntimeSidecar(squarePath, markdownRuntime);
+    // Markdown owns the activity history; runtime state owns delivery metadata.
+    // Preserve whichever history boundary is furthest ahead so a missing or
+    // stale sidecar can never cause an index to be reused.
+    doc.runtime = mergeRuntimeState(markdownRuntime, sidecar);
     return doc;
 }
 function isSquareMarker(line) {
@@ -427,7 +456,32 @@ export function parseActLine(line, actor) {
 function isActSeparator(lines, index) {
     return lines[index]?.trim().startsWith(ACT_MARKER_PREFIX) === true;
 }
-function parseActs(text, _firstActIndex) {
+function parseActBlock(blockLines) {
+    let i = 0;
+    const marker = parseActMarker(blockLines[i]?.trim());
+    if (!marker)
+        throw new SquareError('invalid_args', `Invalid square: expected act marker, got: ${blockLines[i] ?? ''}`);
+    i++;
+    const actor = parseParticipantHeading(blockLines[i] ?? '');
+    if (!actor)
+        throw new SquareError('invalid_args', `Invalid square: expected participant heading, got: ${blockLines[i] ?? ''}`);
+    i++;
+    if (blockLines[i] === '')
+        i++;
+    const head = parseActLine(blockLines[i] ?? '', actor);
+    if (!head)
+        throw new SquareError('invalid_args', `Invalid square: expected act line, got: ${blockLines[i] ?? ''}`);
+    i++;
+    const meta = normalizeActMeta(marker, head.kind, actor, head);
+    let body = '';
+    if (head.kind === 'say' || head.kind === 'done' || head.kind === 'hold') {
+        if (blockLines[i] === '')
+            i++;
+        body = unquoteBody(blockLines.slice(i));
+    }
+    return { ...head, body, index: meta.index, ...(meta.reach !== undefined ? { reach: meta.reach } : {}) };
+}
+function parseActs(text) {
     const lines = activitiesSourceLines(text);
     const acts = [];
     const indexes = new Set();
@@ -438,37 +492,18 @@ function parseActs(text, _firstActIndex) {
             i++;
             continue;
         }
-        const marker = parseActMarker(lines[i]?.trim());
-        if (!marker)
-            throw new SquareError('invalid_args', `Invalid square: expected act marker, got: ${lines[i]}`);
-        i++;
-        const actor = parseParticipantHeading(lines[i]);
-        if (!actor)
-            throw new SquareError('invalid_args', `Invalid square: expected participant heading, got: ${lines[i]}`);
-        i++;
-        if (lines[i] === '')
-            i++;
-        const head = parseActLine(lines[i], actor);
-        if (!head)
-            throw new SquareError('invalid_args', `Invalid square: expected act line, got: ${lines[i] ?? ''}`);
-        i++;
-        const meta = normalizeActMeta(marker, head.kind, actor, head);
+        let end = i + 1;
+        while (end < lines.length && !isActSeparator(lines, end))
+            end++;
+        const act = parseActBlock(lines.slice(i, end));
         if (detectedFirst === -1)
-            detectedFirst = meta.index;
-        if (indexes.has(meta.index))
-            throw new SquareError('invalid_args', `Invalid square: duplicate act index ${meta.index}.`);
-        indexes.add(meta.index);
-        maxIndex = Math.max(maxIndex, meta.index);
-        let body = '';
-        if (head.kind === 'say' || head.kind === 'done' || head.kind === 'hold') {
-            if (lines[i] === '')
-                i++;
-            const bodyStart = i;
-            while (i < lines.length && !isActSeparator(lines, i))
-                i++;
-            body = unquoteBody(lines.slice(bodyStart, i));
-        }
-        acts.push({ ...head, body, index: meta.index, ...(meta.reach !== undefined ? { reach: meta.reach } : {}) });
+            detectedFirst = act.index;
+        if (indexes.has(act.index))
+            throw new SquareError('invalid_args', `Invalid square: duplicate act index ${act.index}.`);
+        indexes.add(act.index);
+        maxIndex = Math.max(maxIndex, act.index);
+        acts.push(act);
+        i = end;
     }
     if (indexes.size > 0) {
         const first = detectedFirst;
@@ -476,7 +511,7 @@ function parseActs(text, _firstActIndex) {
             throw new SquareError('invalid_args', 'Invalid square: act indexes must be contiguous from the first retained index.');
         }
     }
-    return { acts, nextActIndex: indexes.size > 0 ? maxIndex + 1 : 0, firstActIndex: detectedFirst >= 0 ? detectedFirst : 0 };
+    return { acts, nextActIndex: indexes.size > 0 ? maxIndex + 1 : 0 };
 }
 function isDivider(line) {
     return line.trim() === '---';
@@ -490,137 +525,40 @@ function trimSection(lines) {
 function unfixableResult(reason) {
     return {
         unfixable: reason,
-        legacyParticipants: [],
         problems: [],
         hardCap: null,
         preamble: [],
         warmup: [],
         acts: [],
         quarantined: [],
-        runtimeRaw: undefined,
     };
 }
-function parseLegacyEventMarker(line) {
-    if (line === undefined || !line.startsWith(V1_EVENT_MARKER_PREFIX))
-        return null;
-    const match = line.match(/^<!-- square:event\s+(\{.*\})\s*-->$/);
-    if (!match)
-        return null;
-    let parsed;
-    try {
-        parsed = JSON.parse(match[1]);
-    }
-    catch {
-        return null;
-    }
-    if (!isObject(parsed) || typeof parsed.index !== 'number' || !Number.isInteger(parsed.index) || parsed.index < 0)
-        return null;
-    return {
-        index: parsed.index,
-        ...(typeof parsed.type === 'string' ? { type: parsed.type } : {}),
-        ...(typeof parsed.name === 'string' ? { name: parsed.name } : {}),
-        ...(typeof parsed.at === 'number' && Number.isFinite(parsed.at) ? { at: parsed.at } : {}),
-    };
-}
-function parseLegacyEventLine(line, actor) {
-    let match = line.match(/^_activity (\d+) · ([^_]+)_\s*$/);
-    if (match) {
-        const at = parseTimestamp(match[2]);
-        return Number.isFinite(at) ? { type: 'activity', actor, at, number: parseInt(match[1], 10) } : null;
-    }
-    match = line.match(/^_(joined|done|hold|resume) · ([^_]+)_\s*$/);
-    if (!match)
-        return null;
-    const at = parseTimestamp(match[2]);
-    if (!Number.isFinite(at))
-        return null;
-    const type = match[1] === 'joined' ? 'join' : match[1];
-    return { type, actor, at };
-}
-function normalizeLegacyActor(name) {
-    if (name === undefined || sameName(name, 'system'))
-        return 'unknown';
-    return name;
-}
-function mapLegacyEventToAct(marker, head, body) {
-    if (marker.type === undefined || marker.name === undefined)
-        return null;
-    if (marker.type !== head.type || !sameName(marker.name, head.actor))
-        return null;
-    switch (head.type) {
-        case 'activity':
-            return { kind: 'say', actor: head.actor, at: head.at, body, index: marker.index };
-        case 'join':
-            return { kind: 'join', actor: head.actor, at: head.at, body: '', index: marker.index };
-        case 'done':
-            return { kind: 'done', actor: head.actor, at: head.at, body, index: marker.index };
-        case 'hold':
-            return { kind: 'hold', actor: normalizeLegacyActor(head.actor), at: head.at, body, index: marker.index };
-        case 'resume':
-            return { kind: 'resume', actor: normalizeLegacyActor(head.actor), at: head.at, body: '', index: marker.index };
-        default:
-            return null;
-    }
-}
 function tryParseV2ActBlock(blockLines) {
     try {
-        let i = 0;
-        const marker = parseActMarker(blockLines[i]?.trim());
+        const marker = parseActMarker(blockLines[0]?.trim());
         if (!marker || marker.kind === undefined || marker.actor === undefined)
             return { ok: false, reason: 'act marker is missing kind/actor metadata.' };
-        i++;
-        const actor = parseParticipantHeading(blockLines[i] ?? '');
+        const actor = parseParticipantHeading(blockLines[1] ?? '');
         if (!actor)
-            return { ok: false, reason: `act block missing participant heading, got: ${blockLines[i] ?? ''}` };
-        i++;
-        if (blockLines[i] === '')
-            i++;
-        const head = parseActLine(blockLines[i] ?? '', actor);
-        if (!head)
-            return { ok: false, reason: `act block missing or malformed timestamp line, got: ${blockLines[i] ?? ''}` };
-        i++;
-        normalizeActMeta(marker, head.kind, actor, head);
-        let body = '';
-        if (head.kind === 'say' || head.kind === 'done' || head.kind === 'hold') {
-            if (blockLines[i] === '')
-                i++;
-            body = unquoteBody(blockLines.slice(i));
-        }
-        return { ok: true, act: { ...head, body, index: marker.index, ...(marker.reach !== undefined ? { reach: marker.reach } : {}) } };
+            return { ok: false, reason: `act block missing participant heading, got: ${blockLines[1] ?? ''}` };
+        const headLine = blockLines[2] === '' ? blockLines[3] : blockLines[2];
+        if (!parseActLine(headLine ?? '', actor))
+            return { ok: false, reason: `act block missing or malformed timestamp line, got: ${headLine ?? ''}` };
+        return { ok: true, act: parseActBlock(blockLines) };
     }
     catch {
         return { ok: false, reason: 'malformed act block.' };
     }
 }
-function tryParseV1EventBlock(blockLines) {
-    const marker = parseLegacyEventMarker(blockLines[0]?.trim());
-    if (!marker)
-        return { ok: false, reason: `expected event marker, got: ${blockLines[0] ?? ''}` };
-    let i = 1;
-    const actor = parseParticipantHeading(blockLines[i] ?? '');
-    if (!actor)
-        return { ok: false, reason: `event block missing participant heading, got: ${blockLines[i] ?? ''}` };
-    i++;
-    if (blockLines[i] === '')
-        i++;
-    const head = parseLegacyEventLine(blockLines[i] ?? '', actor);
-    if (!head)
-        return { ok: false, reason: `event block missing or malformed timestamp line, got: ${blockLines[i] ?? ''}` };
-    i++;
-    if (blockLines[i] === '')
-        i++;
-    const body = unquoteBody(blockLines.slice(i));
-    const act = mapLegacyEventToAct(marker, head, body);
-    return act ? { ok: true, act } : { ok: false, reason: 'legacy event metadata does not match its body.' };
-}
 function detectBlockParser(line) {
     const trimmed = line.trim();
     if (trimmed.startsWith(ACT_MARKER_PREFIX))
         return tryParseV2ActBlock;
-    if (trimmed.startsWith(V1_EVENT_MARKER_PREFIX))
-        return tryParseV1EventBlock;
     return null;
 }
+function isActBlockStart(line) {
+    return line.trim().startsWith('<!-- square:');
+}
 function diagnoseActs(text, problems) {
     const lines = activitiesSourceLines(text);
     const acts = [];
@@ -635,13 +573,16 @@ function diagnoseActs(text, problems) {
         const parseBlock = detectBlockParser(lines[i]);
         if (!parseBlock) {
             problems.push({ kind: 'act_block', message: `expected act marker, got: ${lines[i]}` });
-            quarantined.push({ raw: lines[i], reason: 'expected act marker' });
-            i++;
+            let j = i + 1;
+            while (j < lines.length && !isActBlockStart(lines[j]))
+                j++;
+            quarantined.push({ raw: lines.slice(i, j).join('\n'), reason: 'expected current-format act marker' });
+            i = j;
             continue;
         }
         const blockStart = i;
         let j = i + 1;
-        while (j < lines.length && detectBlockParser(lines[j]) === null)
+        while (j < lines.length && !isActBlockStart(lines[j]))
             j++;
         const blockLines = lines.slice(blockStart, j);
         const outcome = parseBlock(blockLines);
@@ -684,10 +625,6 @@ export function diagnoseSquare(text) {
         return unfixableResult('missing format_version in frontmatter. Create a new square with `square build`.');
     if (formatVersion !== CURRENT_FORMAT_VERSION)
         return unfixableResult(`format_version ${formatVersion} is no longer supported. Create a new square with \`square build\`.`);
-    const legacyParticipantsMatch = frontmatter.match(/^participants:[^\S\r\n]*(.*?)[^\S\r\n]*$/m);
-    const legacyParticipants = legacyParticipantsMatch
-        ? legacyParticipantsMatch[1].split(',').map((name) => name.trim()).filter(Boolean)
-        : [];
     let hardCap = null;
     const hcMatch = frontmatter.match(/^hard_cap:\s*(-1|\d+)\s*$/m);
     if (!hcMatch)
@@ -698,17 +635,6 @@ export function diagnoseSquare(text) {
     const tMatch = frontmatter.match(/^throttle_per_minute:\s*(\d+)\s*$/m);
     if (tMatch)
         throttlePerMinute = parseInt(tMatch[1], 10);
-    let runtimeRaw;
-    // V3: runtime state is in the sidecar file, not in markdown.
-    const rawState = parseStateBlock(frontmatter);
-    if (rawState !== undefined && rawState !== '') {
-        try {
-            runtimeRaw = JSON.parse(rawState);
-        }
-        catch {
-            problems.push({ kind: 'runtime_state', message: 'malformed legacy mind_square_state JSON in frontmatter.' });
-        }
-    }
     let preamble = [];
     try {
         preamble = parsePreamble(text);
@@ -726,7 +652,6 @@ export function diagnoseSquare(text) {
     const { acts, quarantined } = diagnoseActs(text, problems);
     return {
         formatVersion,
-        legacyParticipants,
         problems,
         hardCap,
         throttlePerMinute,
@@ -734,6 +659,5 @@ export function diagnoseSquare(text) {
         warmup,
         acts,
         quarantined,
-        runtimeRaw,
     };
 }