@astrosheep/square 0.3.62 → 0.3.64

package/dist/file-changes.js

@@ -1,25 +1,8 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { canonicalPath } from './canonical-path.js';
 /** Filesystem notifications are hints, never proof of a committed change. */
 const RECONCILE_MS = 2_000;
-export async function canonicalFilePath(value) {
-    let current = path.resolve(value);
-    const suffix = [];
-    for (;;) {
-        try {
-            return path.join(await fs.promises.realpath(current), ...suffix.reverse());
-        }
-        catch (error) {
-            if (error.code !== 'ENOENT')
-                return path.resolve(value);
-            const parent = path.dirname(current);
-            if (parent === current)
-                return path.resolve(value);
-            suffix.push(path.basename(current));
-            current = parent;
-        }
-    }
-}
 /** A local edge counter: register first, inspect state, then wait from that counter. */
 class Edges {
     version = 0;
@@ -144,7 +127,7 @@ async function abortable(promise, signal) {
 const versions = new Map();
 /** Shared only within this process. Durable state is always read at the storage boundary. */
 export async function observeFileVersion(filePath, kind, read) {
-    const file = await canonicalFilePath(filePath);
+    const file = await canonicalPath(filePath);
     const key = kind + '\0' + file;
     let shared = versions.get(key);
     if (shared === undefined) {

package/dist/harness-claude.js

@@ -27,10 +27,6 @@ function requireSuccess(result, operation, allowMissing = false) {
         return;
     throw new Error(`Claude ${operation} failed: ${result.stderr.trim() || result.stdout.trim() || `exit ${result.status}`}`);
 }
-function writeJson(file, value) {
-    fs.mkdirSync(path.dirname(file), { recursive: true });
-    fs.writeFileSync(file, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 });
-}
 export async function installClaudePlugin(homeDir, run = runClaude) {
     const marketplaceRoot = claudeMarketplaceRoot(homeDir);
     const staged = stageReplacement(marketplaceRoot, (stage) => {
@@ -39,11 +35,13 @@ export async function installClaudePlugin(homeDir, run = runClaude) {
         const skill = path.join(plugin, 'skills', 'square', 'SKILL.md');
         fs.mkdirSync(path.dirname(skill), { recursive: true });
         fs.copyFileSync(path.join(fileURLToPath(new URL('../skills/square/', import.meta.url)), 'SKILL.md'), skill);
-        writeJson(path.join(stage, '.claude-plugin', 'marketplace.json'), {
+        const manifestPath = path.join(stage, '.claude-plugin', 'marketplace.json');
+        fs.mkdirSync(path.dirname(manifestPath), { recursive: true });
+        fs.writeFileSync(manifestPath, `${JSON.stringify({
             name: CLAUDE_MARKETPLACE_NAME,
             owner: { name: 'Square' },
             plugins: [{ name: SQUARE_IDENTITY.pluginName, source: './plugins/square' }],
-        });
+        }, null, 2)}\n`, { mode: 0o600 });
     });
     try {
         const add = run(homeDir, ['plugin', 'marketplace', 'add', marketplaceRoot]);
@@ -73,5 +71,9 @@ export async function doctorClaudePlugin(homeDir, run = runClaude) {
     return [
         fs.existsSync(bundle) ? `✓ Square Claude plugin bundle ${root}` : `○ Square Claude plugin bundle missing ${root}`,
         installed ? `✓ ${CLAUDE_PLUGIN_ID} installed` : `○ ${CLAUDE_PLUGIN_ID} unavailable`,
+        `Claude native inbox: validated on macOS Claude Code 2.1.295 with a trusted, approved interactive mod.`,
+        `Installation or a socket alone does not prove receiver availability; absent/disabled mods, headless unapproved mods, other builds/platforms are unavailable.`,
+        `Queue admission is not model processing. Queued or held native messages cannot be retracted by Square cancellation.`,
+        `Live routes and admission/presentation evidence: square harness doctor delivery. No legacy fallback.`,
     ];
 }

package/dist/harness-codex.d.ts

@@ -1,5 +1,3 @@
-export declare const CODEX_HOOK_COMMAND: "square codex-hook";
-export declare const SQUARE_CODEX_MARKER: "square-codex-hook";
 export declare const CODEX_PLUGIN_ID: "square@astrosheep";
 export declare const CODEX_MARKETPLACE_NAME: "astrosheep";
 export interface CodexCommandResult {

package/dist/harness-codex.js

@@ -4,8 +4,6 @@ import { fileURLToPath } from 'node:url';
 import crossSpawn from 'cross-spawn';
 import { SQUARE_IDENTITY } from './identity.js';
 import { stageReplacement } from './harness-stage.js';
-export const CODEX_HOOK_COMMAND = SQUARE_IDENTITY.hookCommand;
-export const SQUARE_CODEX_MARKER = SQUARE_IDENTITY.hookMarker;
 export const CODEX_PLUGIN_ID = SQUARE_IDENTITY.pluginId;
 export const CODEX_MARKETPLACE_NAME = SQUARE_IDENTITY.marketplaceName;
 const LEGACY_MARKETPLACES = ['astrosheep-square'];

package/dist/harness-links.js

@@ -9,22 +9,21 @@ function packageRoot() {
     // Emitted modules live in dist; package assets are one level above them.
     return fileURLToPath(new URL('../', import.meta.url));
 }
-function lstatMaybe(target) {
-    try {
-        return fs.lstatSync(target);
-    }
-    catch (error) {
-        if (error.code === 'ENOENT')
-            return undefined;
-        throw error;
-    }
-}
 export function installHarnessLinks(links, force = false) {
     const prepared = links.map((link) => {
         if (!fs.existsSync(link.source)) {
             throw new Error(`Harness link source is missing: ${link.source}`);
         }
-        const existing = lstatMaybe(link.target);
+        const existing = (() => {
+            try {
+                return fs.lstatSync(link.target);
+            }
+            catch (error) {
+                if (error.code === 'ENOENT')
+                    return undefined;
+                throw error;
+            }
+        })();
         return {
             ...link,
             existing,
@@ -94,16 +93,13 @@ function runOpenCode(homeDir, args) {
         throw result.error;
     return { status: result.status ?? 1, stdout: result.stdout || '', stderr: result.stderr || '' };
 }
-function requireOpenCodeSuccess(result, action) {
-    if (result.status === 0)
-        return;
-    throw new Error(`OpenCode ${action} failed: ${result.stderr.trim() || result.stdout.trim() || `exit ${result.status}`}`);
-}
 export function installOpenCodePlugin(homeDir, force = false, run = runOpenCode) {
     const args = ['plugin', SQUARE_IDENTITY.packageName, '--global'];
     if (force)
         args.push('--force');
-    requireOpenCodeSuccess(run(homeDir, args), 'plugin install');
+    const result = run(homeDir, args);
+    if (result.status !== 0)
+        throw new Error(`OpenCode plugin install failed: ${result.stderr.trim() || result.stdout.trim() || `exit ${result.status}`}`);
     return [SQUARE_IDENTITY.packageName];
 }
 function configPath(homeDir) {

package/dist/harness.js

@@ -97,14 +97,10 @@ const TARGETS = [
 export function harnessTargets() {
     return TARGETS;
 }
-function requireHarnessCapability(target, action) {
-    const found = TARGETS.find((candidate) => candidate.name === target);
-    if (found === undefined || !found.capabilities.includes(action))
-        throw new Error(`Unsupported harness capability: ${action} ${target}`);
-    return found;
-}
 export async function executeHarnessTarget(targetName, action, context) {
-    const target = requireHarnessCapability(targetName, action);
+    const target = TARGETS.find((candidate) => candidate.name === targetName);
+    if (target === undefined || !target.capabilities.includes(action))
+        throw new Error(`Unsupported harness capability: ${action} ${targetName}`);
     const capability = target[action];
     if (capability === undefined)
         throw new Error(`Unsupported harness capability: ${action} ${targetName}`);

package/dist/help.js

@@ -17,9 +17,9 @@ const COMMANDS = [
         details: ['Options:', '  --last <N>  Show the last N public activities (default 10, maximum 100).', '  --kick      End the standing participant and reclaim the name for this session.'],
     },
     {
-        names: ['express'], usage: '--as <name> express [-f|--force] [--no-wait] (--mention <name>... | --no-mention | --bell) [--reply <activity-id>] <activity | ->', usesSquare: true, group: 'participant',
+        names: ['express'], usage: '--as <name> express [-f|--force] [--no-wait] (--mention <name>... | --no-mention | --bell | --reply <activity-id>) <activity | ->', usesSquare: true, group: 'participant',
         summary: 'Speak, gesture, or do both.',
-        details: ['Reach:', '  --mention <name>  Address one participant; repeat for multiple participants. The body stays unchanged.', '  --no-mention      Land a bare activity explicitly; @names stay plain text. listen opts someone into future bare delivery.', "  --bell            Call every participant's attention to this activity.", '  @name             An @name in the body also addresses that standing participant; `backticks` keep @text literal.', '', 'Options:', '  -f, --force       Express without first catching unread activity or attention etiquette.', '  --no-wait         If held or throttled, save a draft and return instead of waiting. A held wait gives up on its own after 10 minutes.', '  --reply <activity-id>   Mark this activity as a reply to an earlier activity (for example act/12).'],
+        details: ['Reach:', '  --mention <name>  Address one participant; repeat for multiple participants. The body stays unchanged.', '  --no-mention      Land a bare activity explicitly; @names stay plain text. listen opts someone into future bare delivery.', "  --bell            Call every participant's attention to this activity.", '  @name             An @name in the body also addresses that standing participant; `backticks` keep @text literal.', '', 'Options:', '  -f, --force       Express without first catching unread activity or attention etiquette.', '  --no-wait         If held or throttled, save a draft and return instead of waiting. A held wait gives up on its own after 10 minutes.', '  --reply <activity-id>   Mark this activity as a reply to an earlier activity (for example act/12); it reaches that activity\'s author.'],
     },
     { names: ['listen'], usage: '--as <name> listen <participant>', usesSquare: true, group: 'participant', summary: 'Turn an ear toward one participant\'s future bare says.' },
     { names: ['ignore'], usage: '--as <name> ignore <participant>', usesSquare: true, group: 'participant', summary: 'Ignore one participant\'s future mentions and bare says.' },
@@ -40,7 +40,8 @@ const COMMANDS = [
         summary: 'Inspect a bounded machine-local notification snapshot for a native session.',
         details: ['Options:', '  --for-session <id>  Required harness session id.', '  --limit <N>         Snapshot memberships (default 20, maximum 100).', '  --json              Emit the bounded snapshot as structured JSON.'],
     },
-    { names: ['claude-hook', 'codex-hook'], usage: '{command}', summary: 'Present pending attention at one native agent boundary.', hiddenFromIndex: true },
+    { names: ['codex-hook'], usage: '{command}', summary: 'Present pending attention at one native agent boundary.', hiddenFromIndex: true },
+    { names: ['claude-mod'], usage: '{command}', summary: 'Receive a structured operation from the loaded Claude mod.', hiddenFromIndex: true },
     {
         names: ['history'], usage: 'history [filters] [output]', usesSquare: true, group: 'participant',
         summary: 'Read or search the archive without changing what you have caught.',

package/dist/host-ledger-file-adapter.d.ts

@@ -1,13 +1,11 @@
 import { type VersionObserver } from './file-changes.js';
-import type { HostLedgerPort, PresenceRecord, PresenceKey, PresenceLookup, PresenceResult, PresenceClaimResult, EvidenceRecord, EvidenceClaim, EvidenceRelease, EvidenceLookup, EvidenceGc, ClaimResult, WakeDispatchClaim, WakeDispatchClaimInput, WakeDispatchReleaseInput, WakeDispatchTransitionInput, WakeAttemptLookup } from './host-ledger.js';
+import type { HostLedgerPort, PresenceRecord, PresenceKey, PresenceLookup, PresenceResult, PresenceClaimResult, EvidenceRecord, EvidenceClaim, EvidenceRelease, EvidenceLookup, EvidenceGc, ClaimResult, WakeAttemptClaim, WakeAttemptClaimInput, WakeAttemptLookup } from './host-ledger.js';
 export interface HostLedgerFileAdapterOptions {
     rootPath?: string;
-    claimsPath?: string;
     now?: () => number;
 }
 export declare class FileHostLedgerPort implements HostLedgerPort {
     private readonly root;
-    private readonly claims;
     private readonly clock;
     constructor(o?: HostLedgerFileAdapterOptions);
     private file;
@@ -18,20 +16,31 @@ export declare class FileHostLedgerPort implements HostLedgerPort {
     }>;
     /** Time can expire bindings/evidence even when their files do not change. */
     nextExpiry(session: string): Promise<number>;
+    /** The ownership claim critical section: the same lock as claimPresence and finalize. */
+    withClaimLock<T>(fn: () => Promise<T>, signal?: AbortSignal): Promise<T>;
     claimPresence(i: PresenceRecord, signal?: AbortSignal): Promise<PresenceClaimResult>;
     ensurePresence(i: PresenceRecord): Promise<PresenceResult>;
+    /** Local batch suppression is monotonic only for the captured host generation. */
+    suppressPresence(i: PresenceRecord, through: number): Promise<boolean>;
     removePresence(i: PresenceKey): Promise<void>;
     removePresenceIfUnchanged(i: PresenceRecord): Promise<boolean>;
     listPresence(i?: PresenceLookup): Promise<readonly PresenceRecord[]>;
-    claimWakeDispatch(i: WakeDispatchClaimInput): Promise<WakeDispatchClaim>;
-    transitionWakeDispatch(i: WakeDispatchTransitionInput): Promise<boolean>;
-    releaseWakeDispatch(i: WakeDispatchReleaseInput): Promise<void>;
+    /** One attempt row owns attention-wide exclusion and session-scoped history for a wake. */
+    claimWakeAttempt(i: WakeAttemptClaimInput): Promise<WakeAttemptClaim>;
+    /** One locked, token-fenced replacement; each operation owns its state condition. */
+    private updateWake;
     listWakeAttempts(i?: WakeAttemptLookup): Promise<readonly EvidenceRecord[]>;
-    appendWakeAttempt(i: EvidenceRecord & {
+    prepareNativeWake(i: EvidenceRecord & {
         readonly claimToken: string;
-    }): Promise<void>;
+        readonly routeKind: import('./model.js').WakeRouteKind;
+        readonly nativeDelivery: import('./host-ledger.js').NativeDeliveryEvidence;
+    }): Promise<boolean>;
+    confirmWakeAdmission(i: EvidenceRecord & {
+        readonly claimToken: string;
+    }): Promise<boolean>;
     claimEvidence(i: EvidenceClaim): Promise<ClaimResult>;
     releaseEvidence(i: EvidenceRelease): Promise<void>;
+    /** Token-fenced terminal write. A token may only finish the attempt it claimed. */
     appendEvidence(i: EvidenceRecord & {
         readonly claimToken: string;
     }): Promise<void>;

package/dist/host-ledger-file-adapter.js

@@ -1,12 +1,13 @@
 import { promises as fs } from 'node:fs';
-import fsSync from 'node:fs';
 import path from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { setTimeout as sleep } from 'node:timers/promises';
 import { withFileLock as acquireFileLock } from './file-lock.js';
 import { nameKey } from './model.js';
+import { formatActivityId } from './square-core.js';
 import { hostLedgerRoot } from './host-ledger-root.js';
 import { observeFileMetadata } from './file-changes.js';
+import { canonicalPath, canonicalPathSync } from './canonical-path.js';
 const LOCK = { retryMs: 10 };
 const RETENTION = 7 * 86400000;
 // Prepare before locking: lock databases and their journals are local runtime data too.
@@ -24,32 +25,12 @@ async function withFileLock(file, options, fn) {
     }
     return acquireFileLock(file, options, fn);
 }
-async function canon(value) { const absolute = path.resolve(value); try {
-    return await fs.realpath(absolute);
-}
-catch {
-    return absolute;
-} }
-function canonRoot(value) { let current = path.resolve(value), suffix = []; for (;;) {
-    try {
-        return path.join(fsSync.realpathSync.native(current), ...suffix.reverse());
-    }
-    catch (error) {
-        if (error.code !== 'ENOENT')
-            return path.resolve(value);
-        const parent = path.dirname(current);
-        if (parent === current)
-            return path.resolve(value);
-        suffix.push(path.basename(current));
-        current = parent;
-    }
-} }
 async function read(file, now, includeFuture = false) { try {
     return (await fs.readFile(file, 'utf8')).split('\n').flatMap(line => { try {
-        const row = JSON.parse(line);
+        const parsed = JSON.parse(line);
+        const row = decodeWakeRecord(parsed);
         const at = row.at ?? row.updatedAt;
-        const durableTerminal = row.kind === 'wake' && row.outcome === 'accepted';
-        return row.v === 1 && typeof at === 'number' && (durableTerminal || at >= now - RETENTION) && (includeFuture || at <= now) ? [row] : [];
+        return row.v === 1 && typeof at === 'number' && (durableWake(row) || at >= now - RETENTION) && (includeFuture || at <= now) ? [row] : [];
     }
     catch {
         return [];
@@ -89,21 +70,20 @@ async function write(file, rows, signal) {
     }
 }
 function k(v) { return JSON.stringify([v.location, nameKey(v.participant), v.session, v.channel, v.activity, v.kind]); }
-function evidenceKey(v) { return JSON.stringify([v.location, nameKey(v.participant), v.session, v.activity, v.kind, v.attemptN ?? null]); }
-async function readClaims(file, now) { try {
-    return (await fs.readFile(file, 'utf8')).split('\n').flatMap(line => { try {
-        const row = JSON.parse(line);
-        return row.v === 1 && typeof row.ts === 'number' && typeof row.attention_key === 'string' && typeof row.leaseId === 'string' && typeof row.expiresAt === 'number' && (row.phase === 'claimed' || row.phase === 'dispatching') && row.ts >= now - RETENTION ? [row] : [];
-    }
-    catch {
-        return [];
-    } });
+function durableWake(record) {
+    const row = record;
+    return row.kind === 'wake' && (row.outcome === 'accepted' || row.outcome === 'unknown' || row.outcome === 'dispatching');
+}
+function decodeWakeRecord(row) {
+    return row.kind === 'wake' && row.outcome === 'unknown' && row.unknownSource === undefined
+        ? { ...row, unknownSource: row.signature === 'worker_interrupted_during_dispatch' ? 'interrupted' : 'transport' } : row;
+}
+/** Keep identity and native receipt, never a completed attempt's lease. */
+function finishWake(current, outcome, details = {}) {
+    const { expiresAt: _expiresAt, ownerPid: _ownerPid, unknownSource: _unknownSource, ...rest } = current;
+    return { ...rest, ...details, kind: 'wake', outcome,
+        ...(outcome === 'unknown' ? { unknownSource: details.unknownSource ?? 'transport' } : {}) };
 }
-catch (e) {
-    if (e.code === 'ENOENT')
-        return [];
-    throw e;
-} }
 function processAlive(pid) { if (pid === undefined)
     return undefined; try {
     process.kill(pid, 0);
@@ -112,14 +92,11 @@ function processAlive(pid) { if (pid === undefined)
 catch (error) {
     return error.code === 'ESRCH' ? false : true;
 } }
-function writeClaims(file, rows) { return write(file, rows); }
 export class FileHostLedgerPort {
     root;
-    claims;
     clock;
     constructor(o = {}) {
-        this.root = canonRoot(o.rootPath ?? hostLedgerRoot());
-        this.claims = canonRoot(o.claimsPath ?? path.join(this.root, 'wake-claims.ndjsonl'));
+        this.root = canonicalPathSync(o.rootPath ?? hostLedgerRoot());
         this.clock = o.now ?? Date.now;
     }
     file(kind) { return path.join(this.root, `${kind}.ndjsonl`); }
@@ -145,7 +122,7 @@ export class FileHostLedgerPort {
             if (typeof at === 'number') {
                 if (at > now)
                     next = Math.min(next, at);
-                if (at + RETENTION + 1 > now && !('kind' in row && row.kind === 'wake' && row.outcome === 'accepted'))
+                if (at + RETENTION + 1 > now && !durableWake(row))
                     next = Math.min(next, at + RETENTION + 1);
             }
             if ('expiresAt' in row && typeof row.expiresAt === 'number' && row.expiresAt > now)
@@ -153,11 +130,15 @@ export class FileHostLedgerPort {
         }
         return next;
     }
+    /** The ownership claim critical section: the same lock as claimPresence and finalize. */
+    withClaimLock(fn, signal) {
+        return withFileLock(path.join(this.root, 'presence-claim.lock'), { ...LOCK, signal }, fn);
+    }
     async claimPresence(i, signal) {
-        const location = await canon(i.location);
+        const location = await canonicalPath(i.location);
         const record = { ...i, location, updatedAt: i.updatedAt ?? this.clock(), v: 1 };
         try {
-            return await withFileLock(path.join(this.root, 'presence-claim.lock'), { ...LOCK, signal }, async () => {
+            return await this.withClaimLock(async () => {
                 const file = this.file('presence');
                 // The authoritative read, ownership check, and write share the presence file lock:
                 // a concurrent ensurePresence/removePresence between them must never be overwritten
@@ -170,28 +151,47 @@ export class FileHostLedgerPort {
                     await write(file, [...rows, record], signal);
                     return { status: 'acquired', record };
                 });
-            });
+            }, signal);
         }
         catch (error) {
             return { status: 'degraded', record, error };
         }
     }
     async ensurePresence(i) {
-        const record = { ...i, location: await canon(i.location), updatedAt: i.updatedAt ?? this.clock(), v: 1 };
+        const record = { ...i, location: await canonicalPath(i.location), updatedAt: i.updatedAt ?? this.clock(), v: 1 };
         try {
-            await withFileLock(this.file('presence') + '.lock', LOCK, async () => write(this.file('presence'), [...(await read(this.file('presence'), this.clock(), true)).filter((row) => k(row) !== k(record)), record]));
+            await withFileLock(this.file('presence') + '.lock', LOCK, async () => {
+                const rows = await read(this.file('presence'), this.clock(), true);
+                const current = rows.findLast((row) => k(row) === k(record));
+                const sameEpoch = current?.epoch === record.epoch;
+                const cancelledThrough = sameEpoch ? Math.max(current?.cancelledThrough ?? -1, record.cancelledThrough ?? -1) : record.cancelledThrough ?? -1;
+                await write(this.file('presence'), [...rows.filter((row) => k(row) !== k(record)), { ...record, ...(cancelledThrough < 0 ? {} : { cancelledThrough }) }]);
+            });
             return { status: 'ensured', record };
         }
         catch (error) {
             return { status: 'degraded', record, error };
         }
     }
+    /** Local batch suppression is monotonic only for the captured host generation. */
+    async suppressPresence(i, through) {
+        const record = { ...i, location: await canonicalPath(i.location) };
+        const file = this.file('presence');
+        return withFileLock(file + '.lock', LOCK, async () => {
+            const rows = await read(file, this.clock(), true);
+            const current = rows.findLast((row) => k(row) === k(record) && row.epoch === record.epoch);
+            if (!current)
+                return false;
+            await write(file, rows.map((row) => row === current ? { ...row, cancelledThrough: Math.max(row.cancelledThrough ?? -1, through) } : row));
+            return true;
+        });
+    }
     async removePresence(i) {
-        const record = { ...i, location: await canon(i.location) };
+        const record = { ...i, location: await canonicalPath(i.location) };
         await withFileLock(this.file('presence') + '.lock', LOCK, async () => write(this.file('presence'), (await read(this.file('presence'), this.clock(), true)).filter((row) => k(row) !== k(record))));
     }
     async removePresenceIfUnchanged(i) {
-        const record = { ...i, location: await canon(i.location) };
+        const record = { ...i, location: await canonicalPath(i.location) };
         return withFileLock(this.file('presence') + '.lock', LOCK, async () => {
             const file = this.file('presence');
             const rows = await read(file, this.clock(), true);
@@ -206,43 +206,127 @@ export class FileHostLedgerPort {
         });
     }
     async listPresence(i = {}) {
-        const location = i.location === undefined ? undefined : await canon(i.location);
+        const location = i.location === undefined ? undefined : await canonicalPath(i.location);
         return (await read(this.file('presence'), i.now ?? this.clock())).filter((row) => (!location || row.location === location) && (!i.participant || nameKey(row.participant) === nameKey(i.participant)) && (!i.session || row.session === i.session)).map(({ scope: _scope, ...row }) => row);
     }
-    async claimWakeDispatch(i) { const location = await canon(i.attention.squarePath), key = JSON.stringify([location, nameKey(i.attention.recipient), i.attention.actIndex, 'wake']), at = i.at ?? this.clock(); return withFileLock(`${this.claims}.lock`, LOCK, async () => { const rows = await readClaims(this.claims, at), existing = rows.find((row) => row.attention_key === key); if (existing?.phase === 'dispatching') {
-        const alive = processAlive(existing.ownerPid);
-        if (existing.expiresAt <= at || alive === false)
-            return { type: 'ambiguous', lease: existing };
-        return { type: 'busy' };
-    } if (existing !== undefined && existing.expiresAt > at)
-        return { type: 'busy' }; const next = { v: 1, ts: at, attention_key: key, leaseId: i.leaseId, expiresAt: at + i.leaseMs, phase: 'claimed', ownerPid: process.pid, ...(i.session === undefined ? {} : { session: i.session }) }; await writeClaims(this.claims, [...rows.filter((row) => row.attention_key !== key), next]); return { type: 'acquired', leaseId: i.leaseId }; }); }
-    async transitionWakeDispatch(i) { const location = await canon(i.attention.squarePath), key = JSON.stringify([location, nameKey(i.attention.recipient), i.attention.actIndex, 'wake']), at = i.at ?? this.clock(); return withFileLock(`${this.claims}.lock`, LOCK, async () => { const rows = await readClaims(this.claims, at), current = rows.find((row) => { if (row.leaseId !== i.leaseId)
-        return false; try {
-        const parts = JSON.parse(row.attention_key);
-        return parts[0] === location && parts[1] === nameKey(i.attention.recipient) && parts[2] === i.attention.actIndex;
+    /** One attempt row owns attention-wide exclusion and session-scoped history for a wake. */
+    async claimWakeAttempt(i) {
+        const location = await canonicalPath(i.attention.squarePath);
+        const activity = formatActivityId(i.attention.actIndex);
+        const at = i.now ?? this.clock();
+        const file = this.file('evidence');
+        try {
+            return await withFileLock(file + '.lock', LOCK, async () => {
+                const all = await read(file, at, true);
+                const attention = all.filter((row) => row.kind === 'wake' && row.location === location && nameKey(row.participant) === nameKey(i.attention.recipient) && row.activity === activity);
+                const terminal = attention.findLast((row) => row.outcome === 'accepted') ?? attention.findLast((row) => row.outcome === 'unknown');
+                if (terminal)
+                    return { status: 'terminal', record: terminal };
+                const interrupted = attention.filter((row) => row.outcome === 'dispatching');
+                const busy = interrupted.find((row) => (row.expiresAt ?? 0) > at && processAlive(row.ownerPid) !== false);
+                if (busy)
+                    return { status: 'busy', record: busy };
+                const nextNumber = (session) => attention.filter((row) => row.session === session).reduce((highest, row) => Math.max(highest, row.attemptN ?? 0), 0) + 1;
+                // An abandoned attempt may already have been sent, so it blocks every route.
+                if (interrupted.length) {
+                    const recovered = interrupted.map((row) => ({ ...finishWake(row, 'unknown', {
+                            unknownSource: 'interrupted', signature: 'worker_interrupted_during_dispatch',
+                            message: 'The notification worker ended after dispatch began; transport acceptance is unknown.',
+                        }), routeKind: row.routeKind ?? i.routeKind, attemptN: row.attemptN ?? nextNumber(row.session), v: 1 }));
+                    const replacements = new Map(interrupted.map((row, index) => [row, recovered[index]]));
+                    await write(file, all.map((row) => replacements.get(row) ?? row));
+                    return { status: 'terminal', record: recovered[0] };
+                }
+                const attemptN = nextNumber(i.session), claimToken = `${process.pid}-${at}-${randomUUID()}`;
+                await write(file, [...all, { v: 1, at, location, participant: i.attention.recipient, session: i.session, activity,
+                        kind: 'wake', outcome: 'dispatching', routeKind: i.routeKind, attemptN, claimToken, ownerPid: process.pid, expiresAt: at + i.leaseMs }]);
+                return { status: 'acquired', claimToken, attemptN };
+            });
+        }
+        catch (error) {
+            return { status: 'degraded', error };
+        }
     }
-    catch {
-        return false;
-    } }); if (current === undefined)
-        return false; const next = { v: 1, ts: at, attention_key: key, leaseId: i.leaseId, expiresAt: at + i.leaseMs, phase: i.phase, ownerPid: current.ownerPid, ...(i.routeKind === undefined ? {} : { routeKind: i.routeKind }), ...(i.attemptN === undefined ? {} : { attemptN: i.attemptN }), ...(i.session === undefined ? {} : { session: i.session }) }; await writeClaims(this.claims, [...rows.filter((row) => row !== current), next]); return true; }); }
-    async releaseWakeDispatch(i) { const location = await canon(i.attention.squarePath), key = JSON.stringify([location, nameKey(i.attention.recipient), i.attention.actIndex, 'wake']), at = i.at ?? this.clock(); await withFileLock(`${this.claims}.lock`, LOCK, async () => { const rows = await readClaims(this.claims, at); await writeClaims(this.claims, rows.filter((row) => row.attention_key !== key || row.leaseId !== i.leaseId)); }); }
-    async listWakeAttempts(i = {}) { const attention = i.attention; return this.listEvidence({ kind: 'wake', ...(attention === undefined ? {} : { location: await canon(attention.squarePath), participant: attention.recipient, activity: `act/${attention.actIndex}` }), ...(i.session === undefined ? {} : { session: i.session }), now: i.now }); }
-    async appendWakeAttempt(i) { if (i.kind !== 'wake')
-        throw new Error('Wake attempt rows require wake evidence kind'); await this.appendEvidence(i); }
-    async claimEvidence(i) { const f = this.file('evidence'), at = i.now ?? this.clock(), { leaseMs, claimToken: requestedToken, ...claim } = i, r = { ...claim, location: await canon(i.location), outcome: 'dispatching', at, expiresAt: at + leaseMs, v: 1 }; try {
+    /** One locked, token-fenced replacement; each operation owns its state condition. */
+    async updateWake(input, update, at = this.clock()) {
+        if (!input.claimToken)
+            return false;
+        const location = await canonicalPath(input.location), file = this.file('evidence');
+        return withFileLock(file + '.lock', LOCK, async () => {
+            const all = await read(file, at, true);
+            const current = all.findLast((row) => row.kind === 'wake' && row.location === location && nameKey(row.participant) === nameKey(input.participant) && row.activity === input.activity && row.session === input.session && row.claimToken === input.claimToken);
+            const next = current && update(current);
+            if (!next)
+                return false;
+            if (next !== current)
+                await write(file, all.map((row) => row === current ? { ...next, v: 1 } : row));
+            return true;
+        });
+    }
+    async listWakeAttempts(i = {}) {
+        const attention = i.attention;
+        return this.listEvidence({ kind: 'wake', ...(attention === undefined ? {} : { location: await canonicalPath(attention.squarePath), participant: attention.recipient, activity: formatActivityId(attention.actIndex) }), session: i.session, now: i.now });
+    }
+    async prepareNativeWake(i) {
+        return this.updateWake(i, (current) => current.outcome === 'dispatching'
+            ? { ...current, nativeDelivery: i.nativeDelivery, routeKind: i.routeKind, attemptN: i.attemptN } : undefined);
+    }
+    async confirmWakeAdmission(i) {
+        return this.updateWake(i, (current) => {
+            if (!current.nativeDelivery || !['dispatching', 'unknown', 'accepted'].includes(current.outcome))
+                return undefined;
+            return current.outcome === 'accepted' ? current : finishWake(current, 'accepted', { signature: 'native_queue_confirmed', message: undefined, diagnostic: undefined });
+        });
+    }
+    async claimEvidence(i) { if (i.kind === 'wake')
+        return { status: 'degraded', error: new Error('wake attempts are claimed with claimWakeAttempt') }; const f = this.file('evidence'), at = i.now ?? this.clock(), { leaseMs, ...claim } = i, r = { ...claim, location: await canonicalPath(i.location), outcome: 'dispatching', at, expiresAt: at + leaseMs, v: 1 }; try {
         return await withFileLock(f + '.lock', LOCK, async () => { const all = await read(f, at, true), matching = all.filter(x => x.kind === r.kind && x.location === r.location && nameKey(x.participant) === nameKey(r.participant) && x.activity === r.activity && x.session === r.session), old = matching.findLast(x => x.outcome === 'dispatching'); if (old !== undefined && typeof old.expiresAt === 'number' && old.expiresAt > at)
-            return { status: 'busy', record: old }; const delivered = (r.kind === 'wake' && matching.some(x => x.outcome === 'accepted')) || (r.kind === 'presentation' && matching.some(x => x.outcome === 'presented')); if (delivered)
-            return { status: 'delivered', record: matching.findLast(x => x.outcome === 'accepted' || x.outcome === 'presented') }; const index = Number(r.activity.slice(4)), attentionKey = JSON.stringify([r.location, nameKey(r.participant), index, r.session ?? null, 'wake']), dispatchToken = r.kind === 'wake' && typeof requestedToken === 'string' && Number.isInteger(index) && (await readClaims(this.claims, at)).some((row) => row.leaseId === requestedToken && row.attention_key === attentionKey) ? requestedToken : undefined, claimToken = dispatchToken ?? `${process.pid}-${at}-${Math.random().toString(36).slice(2)}`, row = { ...r, claimToken }; await write(f, [...all.filter(x => !(x.kind === r.kind && x.location === r.location && nameKey(x.participant) === nameKey(r.participant) && x.activity === r.activity && x.session === r.session && (x.outcome === 'dispatching' || x.outcome === 'released'))), row]); return { status: 'acquired', claimToken }; });
+            return { status: 'busy', record: old }; if (r.kind === 'presentation' && matching.some(x => x.outcome === 'presented'))
+            return { status: 'delivered', record: matching.findLast(x => x.outcome === 'presented') }; const claimToken = `${process.pid}-${at}-${Math.random().toString(36).slice(2)}`, row = { ...r, claimToken }; await write(f, [...all.filter(x => !(x.kind === r.kind && x.location === r.location && nameKey(x.participant) === nameKey(r.participant) && x.activity === r.activity && x.session === r.session && (x.outcome === 'dispatching' || x.outcome === 'released'))), row]); return { status: 'acquired', claimToken }; });
     }
     catch (error) {
         return { status: 'degraded', error };
     } }
-    async releaseEvidence(i) { const f = this.file('evidence'), location = await canon(i.location), at = i.now ?? this.clock(); await withFileLock(f + '.lock', LOCK, async () => { const all = await read(f, at, true), same = (x) => x.kind === i.kind && x.location === location && nameKey(x.participant) === nameKey(i.participant) && x.activity === i.activity && x.session === i.session, current = all.findLast(x => same(x) && x.outcome === 'dispatching'); if (current === undefined || current.claimToken !== i.claimToken)
-        return; const tombstone = { ...current, outcome: 'released', at, ...(i.routeKind === undefined ? {} : { routeKind: i.routeKind }), ...(i.attemptN === undefined ? {} : { attemptN: i.attemptN }), ...(i.signature === undefined ? {} : { signature: i.signature }), ...(i.message === undefined ? {} : { message: i.message }), ...(i.diagnostic === undefined ? {} : { diagnostic: i.diagnostic }), expiresAt: undefined }; delete tombstone.expiresAt; await write(f, [...all.filter(x => x !== current), tombstone]); }); }
-    async appendEvidence(i) { const f = this.file('evidence'), r = { ...i, location: await canon(i.location), at: i.at ?? this.clock(), v: 1 }; const token = i.claimToken; if (typeof token !== 'string' || token.length === 0)
-        return; await withFileLock(f + '.lock', LOCK, async () => { const all = await read(f, r.at, true); const same = (x) => x.kind === r.kind && x.location === r.location && nameKey(x.participant) === nameKey(r.participant) && x.activity === r.activity && x.session === r.session; const current = all.findLast(x => same(x) && x.outcome === 'dispatching'); if (current === undefined || current.claimToken !== token)
-        return; const terminalKey = (x) => same(x) && x.attemptN === r.attemptN && x.outcome !== 'dispatching' && x.outcome !== 'released'; await write(f, [...all.filter(x => x !== current && !terminalKey(x)), r]); }); }
-    async listEvidence(i = {}) { const loc = i.location === undefined ? undefined : await canon(i.location); return (await read(this.file('evidence'), i.now ?? this.clock())).filter(r => (i.includeReleased === true || r.outcome !== 'released') && (!loc || r.location === loc) && (!i.participant || nameKey(r.participant) === nameKey(i.participant)) && (!i.session || r.session === i.session) && (!i.activity || r.activity === i.activity) && (!i.kind || r.kind === i.kind)); }
-    async gcEvidence(i) { const f = this.file('evidence'), pending = new Set(i.pendingWakeActivities ?? []); await withFileLock(f + '.lock', LOCK, async () => write(f, (await read(f, this.clock(), true)).filter(r => r.at >= i.before || r.kind === 'wake' && r.outcome === 'accepted' && pending.has(r.activity)))); }
+    async releaseEvidence(i) {
+        if (i.kind === 'wake') {
+            const { signature, message, diagnostic, routeKind, attemptN } = i;
+            const details = Object.fromEntries(Object.entries({ signature, message, diagnostic, routeKind, attemptN }).filter(([, value]) => value !== undefined));
+            await this.updateWake(i, (current) => current.outcome === 'dispatching'
+                ? finishWake(current, 'released', { ...details, at: i.now ?? this.clock() }) : undefined, i.now);
+            return;
+        }
+        const f = this.file('evidence'), location = await canonicalPath(i.location), at = i.now ?? this.clock();
+        await withFileLock(f + '.lock', LOCK, async () => { const all = await read(f, at, true), same = (x) => x.kind === i.kind && x.location === location && nameKey(x.participant) === nameKey(i.participant) && x.activity === i.activity && x.session === i.session, current = all.findLast(x => same(x) && x.outcome === 'dispatching'); if (current === undefined || current.claimToken !== i.claimToken)
+            return; const tombstone = { ...current, outcome: 'released', at, ...(i.routeKind === undefined ? {} : { routeKind: i.routeKind }), ...(i.attemptN === undefined ? {} : { attemptN: i.attemptN }), ...(i.signature === undefined ? {} : { signature: i.signature }), ...(i.message === undefined ? {} : { message: i.message }), ...(i.diagnostic === undefined ? {} : { diagnostic: i.diagnostic }), expiresAt: undefined }; delete tombstone.expiresAt; delete tombstone.ownerPid; await write(f, [...all.filter(x => x !== current), tombstone]); });
+    }
+    /** Token-fenced terminal write. A token may only finish the attempt it claimed. */
+    async appendEvidence(i) {
+        const f = this.file('evidence'), r = { ...i, location: await canonicalPath(i.location), at: i.at ?? this.clock(), v: 1 };
+        const token = i.claimToken;
+        if (typeof token !== 'string' || token.length === 0)
+            return;
+        if (i.kind === 'wake') {
+            if (r.outcome !== 'accepted' && r.outcome !== 'failed' && r.outcome !== 'unknown')
+                return;
+            const outcome = r.outcome;
+            await this.updateWake(r, (current) => {
+                if (current.outcome !== 'dispatching' && !(current.outcome === 'unknown' && current.unknownSource === 'interrupted' && outcome === 'accepted'))
+                    return undefined;
+                return finishWake(current, outcome, { at: r.at, routeKind: r.routeKind, attemptN: r.attemptN, signature: r.signature, message: r.message, diagnostic: r.diagnostic });
+            }, r.at);
+            return;
+        }
+        await withFileLock(f + '.lock', LOCK, async () => {
+            const all = await read(f, r.at, true);
+            const same = (x) => x.kind === r.kind && x.location === r.location && nameKey(x.participant) === nameKey(r.participant) && x.activity === r.activity && x.session === r.session;
+            const dispatching = all.findLast((x) => same(x) && x.outcome === 'dispatching');
+            const source = dispatching?.claimToken === token ? dispatching : undefined;
+            if (source === undefined)
+                return;
+            await write(f, [...all.filter((x) => x !== source && !(same(x) && x.attemptN === r.attemptN && x.outcome !== 'dispatching' && x.outcome !== 'released')), { ...r, ...(source.nativeDelivery === undefined ? {} : { nativeDelivery: source.nativeDelivery }) }]);
+        });
+    }
+    async listEvidence(i = {}) { const loc = i.location === undefined ? undefined : await canonicalPath(i.location); return (await read(this.file('evidence'), i.now ?? this.clock())).filter(r => (i.includeReleased === true || r.outcome !== 'released') && (!loc || r.location === loc) && (!i.participant || nameKey(r.participant) === nameKey(i.participant)) && (!i.session || r.session === i.session) && (!i.activity || r.activity === i.activity) && (!i.kind || r.kind === i.kind)); }
+    async gcEvidence(i) { const f = this.file('evidence'), pending = new Set(i.pendingWakeActivities ?? []); await withFileLock(f + '.lock', LOCK, async () => write(f, (await read(f, this.clock(), true)).filter(r => r.at >= i.before || durableWake(r) && pending.has(r.activity)))); }
 }
 export function createHostLedgerPort(o = {}) { return new FileHostLedgerPort(o); }