spexcode 0.6.7 → 0.6.8

package/node_modules/@spexcode/spec-cli/dist/session-runtime-adapter.d.ts

@@ -0,0 +1,44 @@
+export interface GovernedRuntimeIdentity {
+    protocolSessionId: string;
+    harnessId: string;
+    harnessSessionId: string;
+    nativeStartToken: string;
+    metadata?: Record<string, unknown>;
+}
+export interface GovernedRuntimeBindingOptions {
+    expectedGeneration?: number;
+    now?: number;
+}
+export interface GovernedRuntimeBinding {
+    namespace: string;
+    protocolSessionId: string;
+    runtimeKind: string;
+    nativeSessionId: string;
+    nativeStartToken: string;
+    bindingGeneration: number;
+    status: 'bound' | 'unbound';
+    boundAtMs: number;
+    unboundAtMs: number | null;
+    metadata: Record<string, unknown>;
+}
+export interface GovernedProtocolTransactionHost<Transaction = unknown> {
+    withTransaction<T>(body: (transaction: Transaction) => T): T;
+}
+export interface GovernedRuntimeBindingStore<Transaction = unknown> {
+    bind(transaction: Transaction, protocolSessionId: string, identity: {
+        namespace: string;
+        runtimeKind: string;
+        nativeSessionId: string;
+        nativeStartToken: string;
+        metadata?: Record<string, unknown>;
+    }, options?: GovernedRuntimeBindingOptions): GovernedRuntimeBinding;
+    resolve(namespace: string, protocolSessionId: string, transaction?: Transaction): GovernedRuntimeBinding | null;
+    unbind(transaction: Transaction, namespace: string, protocolSessionId: string, options?: GovernedRuntimeBindingOptions): GovernedRuntimeBinding;
+}
+/**
+ * Bind an identity whose storage and native start token were already established by Spex composition.
+ * Database placement, locality, launch, and legacy record publication deliberately remain outside this seam.
+ */
+export declare function bindSpexGovernedRuntime<Transaction>(protocol: GovernedProtocolTransactionHost<Transaction>, bindings: GovernedRuntimeBindingStore<Transaction>, identity: GovernedRuntimeIdentity, options?: GovernedRuntimeBindingOptions): GovernedRuntimeBinding;
+export declare function resolveSpexGovernedRuntime<Transaction>(bindings: GovernedRuntimeBindingStore<Transaction>, protocolSessionId: string, transaction?: Transaction): GovernedRuntimeBinding | null;
+export declare function unbindSpexGovernedRuntime<Transaction>(protocol: GovernedProtocolTransactionHost<Transaction>, bindings: GovernedRuntimeBindingStore<Transaction>, protocolSessionId: string, options?: GovernedRuntimeBindingOptions): GovernedRuntimeBinding;

package/node_modules/@spexcode/spec-cli/dist/session-runtime-adapter.js

@@ -0,0 +1,37 @@
+const SPEX_GOVERNED_NAMESPACE = 'spex-governed';
+function requireNonempty(value, field) {
+    if (typeof value !== 'string' || !value.trim()) {
+        throw new TypeError(`Spex governed runtime binding requires ${field}`);
+    }
+}
+/**
+ * Bind an identity whose storage and native start token were already established by Spex composition.
+ * Database placement, locality, launch, and legacy record publication deliberately remain outside this seam.
+ */
+export function bindSpexGovernedRuntime(protocol, bindings, identity, options = {}) {
+    requireNonempty(identity.protocolSessionId, 'protocolSessionId');
+    requireNonempty(identity.harnessId, 'harnessId');
+    requireNonempty(identity.harnessSessionId, 'harnessSessionId');
+    requireNonempty(identity.nativeStartToken, 'nativeStartToken');
+    if (!protocol || typeof protocol.withTransaction !== 'function') {
+        throw new TypeError('Spex governed runtime binding requires an open protocol transaction host');
+    }
+    if (!bindings || typeof bindings.bind !== 'function') {
+        throw new TypeError('Spex governed runtime binding requires an open runtime binding store');
+    }
+    return protocol.withTransaction(transaction => bindings.bind(transaction, identity.protocolSessionId, {
+        namespace: SPEX_GOVERNED_NAMESPACE,
+        runtimeKind: identity.harnessId,
+        nativeSessionId: identity.harnessSessionId,
+        nativeStartToken: identity.nativeStartToken,
+        metadata: identity.metadata,
+    }, options));
+}
+export function resolveSpexGovernedRuntime(bindings, protocolSessionId, transaction) {
+    requireNonempty(protocolSessionId, 'protocolSessionId');
+    return bindings.resolve(SPEX_GOVERNED_NAMESPACE, protocolSessionId, transaction);
+}
+export function unbindSpexGovernedRuntime(protocol, bindings, protocolSessionId, options = {}) {
+    requireNonempty(protocolSessionId, 'protocolSessionId');
+    return protocol.withTransaction(transaction => bindings.unbind(transaction, SPEX_GOVERNED_NAMESPACE, protocolSessionId, options));
+}

package/node_modules/@spexcode/spec-cli/dist/session-timeline.d.ts

@@ -1,6 +1,28 @@
 import { type SessionLifecycle, type SessionProposal } from '@spexcode/spec-core';
-import { type TimelineEvent } from '@spexcode/session-core';
-export * from '@spexcode/session-core';
+export type TimelineEvent = {
+    ts: string;
+    kind: 'status';
+    status: SessionLifecycle;
+    proposal: SessionProposal | null;
+    note: string | null;
+    display?: string;
+} | {
+    ts: string;
+    kind: 'sent';
+    mid: string;
+    text: string;
+    from: string | null;
+    replyVia?: 'note';
+};
+export declare const timelineEvents: (id: string) => TimelineEvent[];
+export declare const timelineStamp: (id: string) => string | null;
+export declare const timelineTail: (id: string, limit?: number) => TimelineEvent[];
+export declare const lastHumanSendVia: (id: string) => "note" | null;
+export declare const currentHumanTurn: (id: string) => {
+    token: string;
+    acceptedAt: string;
+} | null;
+export declare const recordStatus: (id: string, status: SessionLifecycle, proposal: SessionProposal | null, note: string | null) => void;
 type DisplayWord = 'working' | 'idle' | 'review' | 'done' | 'close-pending' | 'parked' | 'error' | 'asking' | 'queued';
 export declare const timelineDisplay: (event: {
     status: SessionLifecycle;
@@ -9,3 +31,4 @@ export declare const timelineDisplay: (event: {
 export declare function readTimeline(id: string, limit?: number): {
     events: TimelineEvent[];
 } | null;
+export {};

package/node_modules/@spexcode/spec-cli/dist/session-timeline.js

@@ -1,20 +1,77 @@
 import { readAliasedRawRecord } from '@spexcode/spec-core';
-import { timelineTail } from '@spexcode/session-core';
-export * from '@spexcode/session-core';
+import { decodeEventJson } from '@spexcode/session-events';
+import { MIGRATED_MESSAGE_EVENT, MIGRATED_STATE_EVENT } from '@spexcode/session-application';
+import { configuredSessionApplicationIfCutover } from './session-application.js';
+// The timeline is a history: events read in occurrence order (sequence breaks ties). Migrated legacy history
+// lands after the live events in sequence but before them in time, and it is shown where it happened.
+const canonicalSessionId = (id) => readAliasedRawRecord(id)?.session_id ?? id;
+const canonicalTimelineEvents = (id) => {
+    const canonicalId = canonicalSessionId(id);
+    const application = configuredSessionApplicationIfCutover();
+    if (!application || !application.readState(canonicalId))
+        return null;
+    const ordered = [...application.readEvents(canonicalId)].sort((a, b) => a.occurredAtMs - b.occurredAtMs || a.eventSeq - b.eventSeq);
+    return ordered.flatMap((event) => {
+        const decoded = decodeEventJson(event.payload);
+        if (!decoded || typeof decoded !== 'object' || Array.isArray(decoded))
+            return [];
+        const payload = decoded;
+        if (event.type === 'session.state.changed.v1' || event.type === MIGRATED_STATE_EVENT)
+            return [{
+                    ts: new Date(event.occurredAtMs).toISOString(),
+                    kind: 'status',
+                    status: String(payload.status),
+                    proposal: payload.proposal === null || payload.proposal === undefined ? null : String(payload.proposal),
+                    note: payload.note === null || payload.note === undefined ? null : String(payload.note),
+                }];
+        if (event.type === 'session.message.sent.v1' || event.type === MIGRATED_MESSAGE_EVENT)
+            return [{
+                    ts: new Date(event.occurredAtMs).toISOString(),
+                    kind: 'sent',
+                    mid: String(payload.messageId),
+                    text: String(payload.text),
+                    from: payload.from === null || payload.from === undefined ? null : String(payload.from),
+                    ...(payload.replyVia === 'note' ? { replyVia: 'note' } : {}),
+                }];
+        return [];
+    });
+};
+export const timelineEvents = (id) => canonicalTimelineEvents(id) ?? [];
+export const timelineStamp = (id) => {
+    const canonicalId = canonicalSessionId(id);
+    const application = configuredSessionApplicationIfCutover();
+    if (application?.readState(canonicalId)) {
+        const events = application.readEvents(canonicalId);
+        return events.length === 0 ? null : String(events.at(-1).eventSeq);
+    }
+    return null;
+};
+export const timelineTail = (id, limit = 500) => timelineEvents(id).slice(-Math.max(1, limit));
+export const lastHumanSendVia = (id) => {
+    const events = timelineEvents(id);
+    const sent = [...events].reverse().find((event) => event.kind === 'sent' && event.from === null);
+    return sent?.replyVia ?? null;
+};
+export const currentHumanTurn = (id) => {
+    const sent = [...timelineEvents(id)].reverse().find((event) => event.kind === 'sent' && event.from === null);
+    return sent ? { token: sent.mid, acceptedAt: sent.ts } : null;
+};
+export const recordStatus = (id, status, proposal, note) => {
+    const application = configuredSessionApplicationIfCutover();
+    if (!application?.readState(id))
+        throw new Error(`cannot record status for unknown canonical session ${id}`);
+    application.transitionSession(id, { status, proposal, note, reason: 'cli-status' });
+};
 const PROPOSAL_DISPLAY = { merge: 'review', nothing: 'done', close: 'close-pending' };
 export const timelineDisplay = (event) => event.status === 'awaiting' ? (PROPOSAL_DISPLAY[event.proposal ?? 'nothing'] ?? 'done')
     : event.status === 'active' ? 'working' : event.status;
 // The HTTP projection remains a SpexCode concern: it resolves aliases, hides unmanaged records, and adds the
 // board's display vocabulary. The package beneath it only reads the durable file protocol.
 export function readTimeline(id, limit = 500) {
-    let raw;
-    try {
-        raw = readAliasedRawRecord(id);
+    const application = configuredSessionApplicationIfCutover();
+    const canonicalId = canonicalSessionId(id);
+    if (application && application.readState(canonicalId)) {
+        return { events: canonicalTimelineEvents(id).slice(-Math.max(1, limit)).map((event) => event.kind === 'status' ? { ...event, display: timelineDisplay(event) } : event) };
     }
-    catch {
-        return null;
-    }
-    if (!raw || !raw.governed)
-        return null;
-    return { events: timelineTail(raw.session_id, limit).map((event) => event.kind === 'status' ? { ...event, display: timelineDisplay(event) } : event) };
+    return null;
 }

package/node_modules/@spexcode/spec-cli/dist/session-web.js

@@ -1,7 +1,7 @@
 import { createHash } from 'node:crypto';
 import { readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
-import { readRecordEntry, sessionArtifactPath, sessionStoreDir } from '@spexcode/spec-core';
+import { readRecordEntry, sessionArtifactPath, sessionRecordPath } from '@spexcode/spec-core';
 import { projectRuntimeRoot } from '@spexcode/spec-core';
 export class SessionWebError extends Error {
     status;
@@ -15,8 +15,8 @@ const webPath = (id, projectRoot) => projectRoot
     ? join(projectRuntimeRoot(join(projectRoot, '.git')), 'sessions', id, 'web.json')
     : sessionArtifactPath(id, 'web.json');
 const recordPath = (id, projectRoot) => projectRoot
-    ? join(projectRuntimeRoot(join(projectRoot, '.git')), 'sessions', id, 'session.json')
-    : join(sessionStoreDir(id), 'session.json');
+    ? join(projectRuntimeRoot(join(projectRoot, '.git')), 'sessions', id, 'runtime.json')
+    : sessionRecordPath(id);
 function validSessionId(id) {
     return /^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(id);
 }
@@ -104,7 +104,7 @@ export function listSessionWebs(id, projectRoot) {
     requireSession(id, projectRoot);
     return readSessionWebs(id, projectRoot);
 }
-// Session projections already hold a parsed record; re-checking session.json here would make an in-memory
+// Session projections already hold a parsed runtime envelope; re-checking it here would make an in-memory
 // projection depend on the public route's existence guard. The route-facing list keeps that guard above.
 export function readSessionWebs(id, projectRoot) {
     return readWebs(id, projectRoot).map(toWeb);

package/node_modules/@spexcode/spec-cli/dist/sessions.d.ts

@@ -1,15 +1,18 @@
 import { type ReviewDiffFile } from '@spexcode/spec-core';
 import { type ConfigPreset, type SpecLite } from '@spexcode/spec-core';
-import { type Harness, type TurnFailure, type DispatchResult, type PaneProbe, type ProcTable } from './harness.js';
+import { type AdapterLoadedReferenceState, type Harness, type TurnFailure, type DispatchResult, type PaneProbe, type ProcTable } from './harness.js';
 import { envSessionId, type RawRecord, type SessionLifecycle, type SessionProposal } from '@spexcode/spec-core';
 import { type SessionWeb } from './session-web.js';
-import { type MessageIdempotency } from '@spexcode/session-core';
+import { type ProductionSessionApplication } from '@spexcode/session-application';
 export declare const TMUX_SOCK: string;
+/** Start the one process-local serial reaper and resume any crash leftovers. */
+export declare function startWorktreeTrashReaper(): void;
 export type { DispatchResult };
 export type Lifecycle = SessionLifecycle;
 export type Proposal = SessionProposal;
 export type DisplayStatus = 'working' | 'idle' | 'offline' | 'starting' | 'review' | 'done' | 'close-pending' | 'parked' | 'error' | 'asking' | 'queued' | 'unknown' | 'corrupt' | 'retired';
 export type Liveness = 'online' | 'starting' | 'offline' | 'unknown';
+export declare function displayStatusForProposal(proposal: Proposal | null | undefined): DisplayStatus;
 export type Session = {
     id: string;
     node: string | null;
@@ -34,6 +37,7 @@ export type Session = {
     liveness: Liveness;
     note: string | null;
     archived: boolean;
+    closedAt: string | null;
     archiveHazard?: string | null;
     prompt: string | null;
     promptPreview: string | null;
@@ -50,11 +54,6 @@ export type CloseSource = {
 } | {
     kind: 'user';
 };
-export type SessionClosure = {
-    id: string;
-    closedAt: string;
-};
-export declare function findSessionClosure(selector: string): SessionClosure | null;
 export declare const HEADLINE_PREVIEW_COLUMNS = 60;
 export declare const deriveLabel: (r: {
     name?: string | null;
@@ -104,20 +103,34 @@ export type SessRec = {
     createdAt: number;
     harness: string;
     harnessSessionId: string | null;
+    runtimeStartToken: string | null;
     stopped: boolean;
     archived: boolean;
+    closedAt: string | null;
     coldProof?: string | null;
     adapterRecovery?: string | null;
     launcher: string | null;
     launchCmd: string | null;
     launchOwner: string | null;
+    launchReadinessStartedAt?: number | null;
     createRequestId?: string | null;
     createPayloadHash?: string | null;
     zcodeChildSessionIds?: string[];
     base?: string | null;
+    forkCommit?: string | null;
+    diffComments?: DiffComment[];
     launchReadinessPending?: LaunchReadinessPending | null;
 };
-type LaunchReadinessOriginal = Pick<SessRec, 'status' | 'proposal' | 'note' | 'stopped' | 'archived' | 'coldProof' | 'adapterRecovery'>;
+export type DiffComment = {
+    id: string;
+    filePath: string;
+    lineStart: number;
+    lineEnd: number;
+    body: string;
+    diffIdentity: string;
+    sentAt: string | null;
+};
+type LaunchReadinessOriginal = Pick<SessRec, 'status' | 'proposal' | 'note' | 'stopped' | 'archived' | 'closedAt' | 'coldProof' | 'adapterRecovery'>;
 type LaunchReadinessPending = {
     version: 1;
     startedAt: number;
@@ -136,7 +149,6 @@ export declare class SessionRecordUnusable extends Error {
     constructor(code: 'corrupt' | 'retired', session: string, message: string);
 }
 export declare function withSessionRecordLockSync<T>(id: string, body: () => T): T;
-export declare function withSessionInputLock<T>(id: string, body: () => T): T | null;
 export declare function fromRaw(raw: RawRecord & {
     launch_owner?: string;
 }): SessRec;
@@ -185,6 +197,13 @@ export type ReviewIdentity = {
     label: string;
 };
 export declare function reviewIdentity(id: string): ReviewIdentity | null;
+export type SessionHookState = {
+    governed: boolean;
+    status: Lifecycle;
+    proposal: Proposal | null;
+    note: string | null;
+};
+export declare function sessionHookState(id: string): SessionHookState | null;
 export declare function toSession(rec: SessRec, status: DisplayStatus, lv: Liveness, activity?: string | null): Session;
 export type ZCodeChildSessionLink = {
     sessionId: string;
@@ -195,6 +214,17 @@ export declare function linkZCodeChildSession(sessionId: string, childSessionId:
 export declare function renameSession(id: string, name: string): Promise<boolean>;
 export declare function setSessionSort(id: string, key: number | null): Promise<boolean>;
 export declare function sessionPrompt(id: string): Promise<string | null>;
+export type ArchiveSessionIndexRow = {
+    id: string;
+    title: string;
+    label: string;
+    closedAt: string | null;
+    node: string | null;
+};
+export type ArchiveSessionIndexProbe = {
+    promptReads?: number;
+};
+export declare function listArchivedSessionIndex(probe?: ArchiveSessionIndexProbe): Promise<ArchiveSessionIndexRow[]>;
 export declare function listSessions(includeArchived?: boolean): Promise<Session[]>;
 export type ApiBaseSource = 'flag' | 'worker-env' | 'record' | 'env-fallback' | 'default';
 export type ApiBaseInfo = {
@@ -238,7 +268,22 @@ export type LaunchBlock = {
     message: string;
 };
 export declare function launchPreflight(rec: SessRec): LaunchBlock | null;
+export declare function launchShellCommand(file: string): string;
 export declare function launchScript(id: string, tail: string, harness?: Harness, cmd?: string): string;
+export declare function canonicalWatchRecipients(application: Pick<ProductionSessionApplication, 'topology'>, sessionId: string, status: string): string[];
+export declare function sessionHasPendingDelivery(id: string, application?: Pick<ProductionSessionApplication, 'readPendingMessages'> & Partial<Pick<ProductionSessionApplication, 'resolveRuntime'>> | null): boolean;
+export declare function canonicalRecordProjection<T extends Pick<SessRec, 'status' | 'stopped' | 'archived'>>(rec: T, canonical: {
+    status: string;
+    proposal: string | null;
+    note: string | null;
+    parentSessionId: string | null;
+} | null | undefined): T & {
+    status: Lifecycle;
+    proposal: Proposal | null;
+    note: string | null;
+    parent: string | null;
+};
+export declare function adapterResidentLiveness(rec: SessRec, resident: AdapterLoadedReferenceState | undefined): Liveness;
 export declare const drainQueue: () => Promise<void>;
 export declare function superviseQueue(intervalMs?: number): void;
 export declare function superviseDelivery(intervalMs?: number): void;
@@ -260,6 +305,7 @@ type SessionCreateRequestOptions = {
     requestKey?: string;
     signal?: AbortSignal;
     timeoutMs?: number;
+    onPublished?: (session: Session) => void | Promise<void>;
 };
 export type SessionCreateRequestResult = {
     status: 201;
@@ -274,6 +320,7 @@ export declare function sessionCreateTimeoutMs(env?: NodeJS.ProcessEnv): number;
 export declare function sessionIdForCreateKey(key: string): string;
 export declare function sessionCreateRequest(body: unknown, options?: SessionCreateRequestOptions): Promise<SessionCreateRequestResult>;
 export declare function createSession(prompt: string, launcher?: string, name?: string, base?: string): Promise<Session>;
+export declare function projectCreatedSession(session: Session): void;
 export declare function spawnerClause(p: SessRec | null): string;
 export declare function pendingSessionCreateWorktreePaths(): Set<string>;
 export declare function bootstrapMaterialize(rec: SessRec, doMaterialize?: (proj: string) => unknown): void;
@@ -292,10 +339,11 @@ export declare function markState(status: Lifecycle, opts?: {
     note?: string;
     sessionId?: string;
 }): boolean;
+export declare function markHumanPromptActive(sessionId: string): boolean;
 export declare const markDone: (proposal?: Proposal, sessionId?: string, note?: string) => boolean;
-export declare const markError: (sessionId?: string) => boolean;
 export declare function markTurnFailure(sessionId: string | undefined, note: string): boolean;
 export declare function markHeadlessTurnFailure(sessionId: string, harness: string, exitCode: string): boolean;
+export declare function existingHarnessLaunchTarget(id: string): string | null;
 export declare function stageHarnessLaunchProof(sessionId: string | undefined, harnessSessionId: string | undefined, launchPayload: string): boolean;
 export declare function markHarnessSessionId(sessionId: string | undefined, harnessSessionId: string | undefined): boolean;
 export declare function markIdle(sessionId?: string): boolean;
@@ -312,7 +360,7 @@ export type ReviewEvalFacts = {
 export type ReviewEvalGate = ({
     phase: 'ready';
 } & ReviewEvalFacts) | {
-    phase: 'unavailable' | 'loading' | 'updating' | 'error';
+    phase: 'unavailable' | 'loading' | 'updating' | 'error' | 'dormant';
 };
 export type ReviewGates = {
     conflictsWithMain: boolean;
@@ -335,14 +383,47 @@ export type ReviewPayload = {
         note: string | null;
     };
 };
+export type SessionDiffFile = ReviewDiffFile & {
+    patch: string;
+    diffIdentity: string;
+};
+export type DiffScope = 'branch' | 'working';
+export type BranchState = 'no-commits' | 'merged' | 'open';
+export type SessionDiffPayload = {
+    id: string;
+    scope: 'branch';
+    branch: string;
+    baseRef: string;
+    base: string;
+    head: string;
+    mergeBase: string;
+    branchState: BranchState;
+    commitUrl: string | null;
+    files: SessionDiffFile[];
+    working: {
+        readable: boolean;
+        files: SessionDiffFile[];
+    };
+    comments: DiffComment[];
+};
+export declare function commitUrlForRemote(remote: string, commit: string): string | null;
+export declare function sessionDiff(id: string, filePath?: string, offset?: number, limit?: number, scope?: DiffScope): Promise<SessionDiffPayload | null>;
+export declare function saveDiffComment(id: string, input: Omit<DiffComment, 'id' | 'sentAt'> & {
+    id?: string;
+}): Promise<DiffComment | null>;
+export declare function retractDiffComment(id: string, commentId: string): Promise<DiffComment | null>;
+export declare function sendDiffComments(id: string, ids?: string[]): Promise<{
+    ok: boolean;
+    sentAt?: string;
+    count?: number;
+    error?: string;
+}>;
 export declare function reviewPayload(id: string): Promise<ReviewPayload | null>;
 export type MergeSessionResult = {
     dispatched: true;
 } | {
     dispatched: false;
     reason: string;
-    code?: 'session_merge_not_proposed';
-    status?: 409;
 };
 export declare function mergeSession(id: string): Promise<MergeSessionResult>;
 export type SessionLeafReceipt = {
@@ -366,7 +447,6 @@ export type SessionLeafProcessProbe = Readonly<{
 }>;
 export declare function installSessionLeafProcessProbeForTest(probe: SessionLeafProcessProbe): () => void;
 export declare const stopSession: (id: string) => Promise<boolean>;
-export declare const archiveSession: (id: string, on?: boolean) => Promise<boolean>;
 export declare const closeSession: (id: string, rawSource?: unknown) => Promise<boolean>;
 export type CorruptRecordQuarantineWitness = {
     adapter: string;
@@ -415,19 +495,32 @@ export type SessionTableScope = {
     parent: string;
 };
 export declare function formatTable(sessions: Session[], color?: boolean, scope?: SessionTableScope): string;
+type MessageIdempotency = {
+    operation: string;
+    requestDigest: string;
+    payloadHash: string;
+};
 type DispatchIdempotency = MessageIdempotency;
-type DispatchAcceptCode = 'dispatch_key_reused' | 'session_merge_not_proposed';
+type DispatchAcceptCode = 'dispatch_key_reused';
+export declare const EMPTY_PROMPT_ERROR = "empty prompt \u2014 nothing to dispatch";
 type AcceptedDispatch = DispatchResult & {
     replayed?: boolean;
     code?: DispatchAcceptCode;
+    delivery?: 'accepted' | 'queued' | 'deferred';
 };
 type SendTextOptions = {
     replyVia?: 'note';
     idempotency?: DispatchIdempotency;
+    deliveryKey?: string;
     acceptGuard?: (record: SessRec) => Promise<void>;
     deferDrain?: boolean;
+    allowStranded?: boolean;
 };
 export declare function sendText(id: string, text: string, from?: string, opts?: SendTextOptions): Promise<AcceptedDispatch>;
 export declare function drainSession(id: string): Promise<void>;
+export declare function canonicalMessageText(message: {
+    kind: string;
+    body: Uint8Array;
+}, recipient: SessRec): string;
 export declare function interruptSession(id: string): Promise<DispatchResult>;
 export declare function rawKey(id: string, key: string | string[]): Promise<boolean>;