@phyzess/pappra 0.1.0-beta.14 → 0.1.0-beta.19

package/dist/app/collab-session-transition-request.js

@@ -0,0 +1,339 @@
+import path from 'node:path';
+import { object as isRecord } from '../infra/validation.js';
+import { canonicalJson } from '../collab/envelope.js';
+import { MANAGED_PI_EXECUTION_SCOPE_SCHEMA, } from '../schemas/managed-pi-execution.js';
+import { readBoundedFile } from './bounded-file.js';
+import { digestText, isDigest, isNonNegativeInt, isPositiveInt, isSafeId, isText, safePathEqual, sameIdentity, } from './collab-session-transition-validation.js';
+export const COLLAB_SESSION_TRANSITION_REQUEST_SCHEMA = 'pappra/collaboration-session-transition-request/1';
+const MAX_REQUEST_BYTES = 64 * 1024;
+function hasOnlyKeys(value, keys) {
+    const allowed = new Set(keys);
+    return Object.keys(value).every((key) => allowed.has(key));
+}
+/**
+ * The immutable digest deliberately excludes `evidence`: adding an ACK or a
+ * first-work REPORT pointer must not change a request's identity.
+ */
+export function immutableDigest(request) {
+    return digestText(canonicalJson({
+        schema: request.schema,
+        task_root: request.task_root,
+        transition_id: request.transition_id,
+        intent: request.intent,
+        bundle: request.bundle,
+        bootstrap_request: request.bootstrap_request,
+        archive_mode: request.archive_mode,
+        ...(request.managed_execution_scope === undefined
+            ? {}
+            : { managed_execution_scope: request.managed_execution_scope }),
+    }));
+}
+function parseIdentity(value) {
+    if (!isRecord(value) ||
+        !hasOnlyKeys(value, ['agent_id', 'session_id', 'harness', 'cwd']))
+        return null;
+    if (!isText(value['agent_id'], 128) || !isText(value['session_id'], 256))
+        return null;
+    if (value['harness'] !== 'pi')
+        return null;
+    if (!isText(value['cwd'], 4096) || !path.isAbsolute(value['cwd']))
+        return null;
+    return {
+        agent_id: value['agent_id'],
+        session_id: value['session_id'],
+        harness: 'pi',
+        cwd: value['cwd'],
+    };
+}
+function parseIntent(value) {
+    if (!isRecord(value) ||
+        !hasOnlyKeys(value, [
+            'intent_id',
+            'generation',
+            'handoff_id',
+            'subtask_id',
+            'attempt',
+            'input_revision',
+            'from',
+            'to',
+            'claims',
+            'coordinator_epoch',
+        ]))
+        return null;
+    const from = parseIdentity(value['from']);
+    const to = parseIdentity(value['to']);
+    const claims = value['claims'];
+    if (!isSafeId(value['intent_id']) ||
+        !isPositiveInt(value['generation']) ||
+        !isSafeId(value['handoff_id']) ||
+        !isSafeId(value['subtask_id']) ||
+        !isPositiveInt(value['attempt']) ||
+        !isDigest(value['input_revision']) ||
+        from === null ||
+        to === null ||
+        !isPositiveInt(value['coordinator_epoch']) ||
+        !Array.isArray(claims) ||
+        claims.length === 0 ||
+        claims.length > 64 ||
+        sameIdentity(from, to))
+        return null;
+    const parsedClaims = [];
+    const seen = new Set();
+    for (const claim of claims) {
+        if (!isRecord(claim) ||
+            !hasOnlyKeys(claim, ['claim_id', 'resource_epoch']) ||
+            !isSafeId(claim['claim_id']) ||
+            !isNonNegativeInt(claim['resource_epoch']) ||
+            seen.has(claim['claim_id']))
+            return null;
+        seen.add(claim['claim_id']);
+        parsedClaims.push({
+            claim_id: claim['claim_id'],
+            resource_epoch: claim['resource_epoch'],
+        });
+    }
+    return {
+        intent_id: value['intent_id'],
+        generation: value['generation'],
+        handoff_id: value['handoff_id'],
+        subtask_id: value['subtask_id'],
+        attempt: value['attempt'],
+        input_revision: value['input_revision'],
+        from,
+        to,
+        claims: parsedClaims,
+        coordinator_epoch: value['coordinator_epoch'],
+    };
+}
+function parseManagedPiExecutionScope(value) {
+    if (!isRecord(value) ||
+        !hasOnlyKeys(value, [
+            'schema',
+            'task_id',
+            'task_root',
+            'session_id',
+            'cwd',
+            'subtask_id',
+            'attempt',
+            'owner_epoch',
+            'claim_epochs',
+        ]) ||
+        value['schema'] !== MANAGED_PI_EXECUTION_SCOPE_SCHEMA ||
+        !isSafeId(value['task_id']) ||
+        !isText(value['task_root'], 4096) ||
+        !path.isAbsolute(value['task_root']) ||
+        !isText(value['session_id'], 256) ||
+        !isText(value['cwd'], 4096) ||
+        !path.isAbsolute(value['cwd']) ||
+        !isSafeId(value['subtask_id']) ||
+        !isPositiveInt(value['attempt']) ||
+        !isPositiveInt(value['owner_epoch']) ||
+        !Array.isArray(value['claim_epochs']) ||
+        value['claim_epochs'].length === 0 ||
+        value['claim_epochs'].length > 64)
+        return null;
+    const claim_epochs = [];
+    const seen = new Set();
+    for (const raw of value['claim_epochs']) {
+        if (!isRecord(raw) ||
+            !hasOnlyKeys(raw, ['claim_id', 'resource_epoch']) ||
+            !isSafeId(raw['claim_id']) ||
+            !isPositiveInt(raw['resource_epoch']) ||
+            seen.has(raw['claim_id']))
+            return null;
+        seen.add(raw['claim_id']);
+        claim_epochs.push({
+            claim_id: raw['claim_id'],
+            resource_epoch: raw['resource_epoch'],
+        });
+    }
+    return {
+        schema: MANAGED_PI_EXECUTION_SCOPE_SCHEMA,
+        task_id: value['task_id'],
+        task_root: value['task_root'],
+        session_id: value['session_id'],
+        cwd: value['cwd'],
+        subtask_id: value['subtask_id'],
+        attempt: value['attempt'],
+        owner_epoch: value['owner_epoch'],
+        claim_epochs,
+    };
+}
+export function validateSessionTransitionRequest(value) {
+    if (!isRecord(value) ||
+        !hasOnlyKeys(value, [
+            'schema',
+            'task_root',
+            'transition_id',
+            'intent',
+            'bundle',
+            'bootstrap_request',
+            'evidence',
+            'archive_mode',
+            'managed_execution_scope',
+        ]))
+        return {
+            ok: false,
+            code: 'request_shape_invalid',
+            message: 'Session-transition request must use only documented fields.',
+        };
+    if (value['schema'] !== COLLAB_SESSION_TRANSITION_REQUEST_SCHEMA)
+        return {
+            ok: false,
+            code: 'request_schema_invalid',
+            message: `request.schema must be ${COLLAB_SESSION_TRANSITION_REQUEST_SCHEMA}.`,
+        };
+    if (!isText(value['task_root'], 4096) || !path.isAbsolute(value['task_root']))
+        return {
+            ok: false,
+            code: 'task_root_invalid',
+            message: 'task_root must be an absolute task-root path.',
+        };
+    const intent = parseIntent(value['intent']);
+    if (intent === null)
+        return {
+            ok: false,
+            code: 'intent_invalid',
+            message: 'intent must pin exact source/successor identities, attempt, input, epoch and claims.',
+        };
+    if (value['transition_id'] !== intent.intent_id)
+        return {
+            ok: false,
+            code: 'transition_id_mismatch',
+            message: 'transition_id must equal intent.intent_id.',
+        };
+    const bundleValue = value['bundle'];
+    if (!isRecord(bundleValue) ||
+        !hasOnlyKeys(bundleValue, [
+            'root',
+            'continuity_task_id',
+            'bundle_id',
+            'digest',
+        ]) ||
+        !isText(bundleValue['root'], 4096) ||
+        !path.isAbsolute(bundleValue['root']) ||
+        !isSafeId(bundleValue['continuity_task_id']) ||
+        !isSafeId(bundleValue['bundle_id']) ||
+        !isDigest(bundleValue['digest']))
+        return {
+            ok: false,
+            code: 'bundle_invalid',
+            message: 'bundle must name one absolute workspace root and exact linked bundle digest.',
+        };
+    const bootstrapValue = value['bootstrap_request'];
+    if (!isRecord(bootstrapValue) ||
+        !hasOnlyKeys(bootstrapValue, ['ref', 'digest']) ||
+        !isText(bootstrapValue['ref'], 4096) ||
+        !path.isAbsolute(bootstrapValue['ref']) ||
+        !isDigest(bootstrapValue['digest']))
+        return {
+            ok: false,
+            code: 'bootstrap_request_invalid',
+            message: 'bootstrap_request must pin one absolute bounded request file and raw digest.',
+        };
+    const evidenceValue = value['evidence'];
+    if (!isRecord(evidenceValue) ||
+        !hasOnlyKeys(evidenceValue, ['ack_message_id', 'first_work_report_id']))
+        return {
+            ok: false,
+            code: 'evidence_invalid',
+            message: 'evidence must contain only the optional registered ACK and REPORT ids.',
+        };
+    const ack = evidenceValue['ack_message_id'];
+    const report = evidenceValue['first_work_report_id'];
+    if ((ack !== null && !isSafeId(ack)) ||
+        (report !== null && !isSafeId(report)))
+        return {
+            ok: false,
+            code: 'evidence_id_invalid',
+            message: 'Evidence ids must be null or safe registered message ids.',
+        };
+    if (value['archive_mode'] !== 'task-retirement')
+        return {
+            ok: false,
+            code: 'archive_mode_invalid',
+            message: 'Only the reversible task-retirement marker is supported; native archive is unavailable.',
+        };
+    const scopeValue = value['managed_execution_scope'];
+    const managedExecutionScope = scopeValue === undefined ? null : parseManagedPiExecutionScope(scopeValue);
+    if (scopeValue !== undefined &&
+        (managedExecutionScope === null ||
+            managedExecutionScope.task_id !== path.basename(value['task_root']) ||
+            !safePathEqual(managedExecutionScope.task_root, value['task_root']) ||
+            managedExecutionScope.session_id !== intent.from.session_id ||
+            !safePathEqual(managedExecutionScope.cwd, intent.from.cwd ?? '') ||
+            managedExecutionScope.subtask_id !== intent.subtask_id ||
+            managedExecutionScope.attempt !== intent.attempt ||
+            managedExecutionScope.owner_epoch !== intent.coordinator_epoch ||
+            managedExecutionScope.claim_epochs.length !== intent.claims.length ||
+            managedExecutionScope.claim_epochs.some((pin, index) => pin.claim_id !== intent.claims[index]?.claim_id ||
+                pin.resource_epoch !== intent.claims[index]?.resource_epoch)))
+        return {
+            ok: false,
+            code: 'managed_execution_scope_mismatch',
+            message: 'Managed execution scope must exactly match task, source session, attempt, owner epoch and claim pins.',
+        };
+    return {
+        ok: true,
+        request: {
+            schema: COLLAB_SESSION_TRANSITION_REQUEST_SCHEMA,
+            task_root: value['task_root'],
+            transition_id: value['transition_id'],
+            intent,
+            bundle: {
+                root: bundleValue['root'],
+                continuity_task_id: bundleValue['continuity_task_id'],
+                bundle_id: bundleValue['bundle_id'],
+                digest: bundleValue['digest'],
+            },
+            bootstrap_request: {
+                ref: bootstrapValue['ref'],
+                digest: bootstrapValue['digest'],
+            },
+            evidence: {
+                ack_message_id: typeof ack === 'string' ? ack : null,
+                first_work_report_id: typeof report === 'string' ? report : null,
+            },
+            archive_mode: 'task-retirement',
+            ...(managedExecutionScope === null
+                ? {}
+                : { managed_execution_scope: managedExecutionScope }),
+        },
+    };
+}
+export function loadSessionTransitionRequest(file) {
+    const read = readBoundedFile(file, MAX_REQUEST_BYTES);
+    if (!read.ok)
+        return {
+            ok: false,
+            kind: 'invalid',
+            code: 'request_unreadable',
+            message: `Request must be an absolute bounded regular file (${read.code}).`,
+            next_action: 'Pass a regular JSON request file; no task mutation was attempted.',
+        };
+    let parsed;
+    try {
+        parsed = JSON.parse(read.text);
+    }
+    catch {
+        return {
+            ok: false,
+            kind: 'invalid',
+            code: 'request_invalid_json',
+            message: 'Session-transition request is not valid JSON.',
+            next_action: 'Fix the request document and retry explicitly.',
+        };
+    }
+    const validated = validateSessionTransitionRequest(parsed);
+    if (!validated.ok)
+        return { ...validated, kind: 'invalid', next_action: null };
+    return {
+        ok: true,
+        value: {
+            request: validated.request,
+            file,
+            file_digest: read.digest,
+            immutable_digest: immutableDigest(validated.request),
+        },
+    };
+}

package/dist/app/collab-session-transition-validation.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Primitive guards shared by the session-transition request parser and the
+ * orchestrator. They live below both so neither has to import the other's
+ * parsing module for a predicate.
+ */
+export declare function digestText(bytes: string | Buffer): string;
+export declare function isText(value: unknown, max?: number): value is string;
+export declare function isPositiveInt(value: unknown): value is number;
+export declare function isNonNegativeInt(value: unknown): value is number;
+export declare function isDigest(value: unknown): value is string;
+export declare function isSafeId(value: unknown): value is string;
+export declare function sameIdentity(left: {
+    readonly agent_id?: string | null;
+    readonly session_id?: string | null;
+} | null | undefined, right: {
+    readonly agent_id: string;
+    readonly session_id: string;
+}): boolean;
+export declare function safePathEqual(left: string, right: string): boolean;

package/dist/app/collab-session-transition-validation.js

@@ -0,0 +1,44 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+const DIGEST = /^sha256:[0-9a-f]{64}$/;
+const SAFE_ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+/**
+ * Primitive guards shared by the session-transition request parser and the
+ * orchestrator. They live below both so neither has to import the other's
+ * parsing module for a predicate.
+ */
+export function digestText(bytes) {
+    return `sha256:${crypto.createHash('sha256').update(bytes).digest('hex')}`;
+}
+export function isText(value, max = 2048) {
+    return (typeof value === 'string' &&
+        value.length > 0 &&
+        value.length <= max &&
+        !value.includes('\u0000'));
+}
+export function isPositiveInt(value) {
+    return Number.isSafeInteger(value) && value > 0;
+}
+export function isNonNegativeInt(value) {
+    return Number.isSafeInteger(value) && value >= 0;
+}
+export function isDigest(value) {
+    return typeof value === 'string' && DIGEST.test(value);
+}
+export function isSafeId(value) {
+    return typeof value === 'string' && SAFE_ID.test(value);
+}
+export function sameIdentity(left, right) {
+    return (left !== null &&
+        left !== undefined &&
+        left.agent_id === right.agent_id &&
+        left.session_id === right.session_id);
+}
+export function safePathEqual(left, right) {
+    try {
+        return fs.realpathSync(left) === fs.realpathSync(right);
+    }
+    catch {
+        return false;
+    }
+}

package/dist/app/collab-session-transition.d.ts

@@ -0,0 +1,181 @@
+import * as rollover from '../collab/rollover.js';
+import type { FreezeOutcome, FreezeStatus, FreezeToken } from '../hosts/integration/pi-rollover-extension.js';
+import type { NativeFactsSnapshot } from '../hosts/integration/pi-native-events.js';
+import { type LoadedVisibleBootstrapRequest, type VisibleBootstrapDependencies, type VisibleBootstrapReport } from './collab-bootstrap.js';
+import { type RolloverReport } from './collab-rollover.js';
+import { type HerdrBootstrapOps } from './collab-bootstrap-transport.js';
+import { MANAGED_PI_EXECUTION_SCOPE_SCHEMA, type ManagedPiExecutionScope } from '../schemas/managed-pi-execution.js';
+export { MANAGED_PI_EXECUTION_SCOPE_SCHEMA };
+export type { ManagedPiExecutionScope };
+export { COLLAB_SESSION_TRANSITION_REQUEST_SCHEMA, loadSessionTransitionRequest, validateSessionTransitionRequest, } from './collab-session-transition-request.js';
+export type { LoadedSessionTransitionRequest, SessionTransitionRequest, SessionTransitionRequestResult, } from './collab-session-transition-request.js';
+import { type LoadedSessionTransitionRequest, type SessionTransitionRequest } from './collab-session-transition-request.js';
+export declare const COLLAB_SESSION_TRANSITION_REPORT_SCHEMA = "pappra/collaboration-session-transition/1";
+export declare const SESSION_TRANSITION_ARCHIVE_SCHEMA = "pappra/session-transition-archive/1";
+export interface SessionTransitionRetirementMarker {
+    readonly schema: typeof SESSION_TRANSITION_ARCHIVE_SCHEMA;
+    readonly mode: 'task-retirement';
+    readonly task_id: string;
+    readonly task_root: string;
+    readonly transition_id: string;
+    readonly intent_id: string;
+    readonly handoff_id: string;
+    readonly generation: number;
+    readonly recorded_at: string;
+    readonly first_work: {
+        readonly message_id: string;
+        readonly digest: string;
+    };
+    readonly successor_route_binding: {
+        readonly ref: string;
+        readonly digest: string;
+    };
+    readonly native_archive: 'unavailable';
+    readonly original_transcript: 'retained-in-place';
+    readonly reversible: true;
+}
+export declare const SESSION_TRANSITION_JOURNAL_KEY = "session_transition_journal";
+export type SessionTransitionAction = 'plan' | 'apply';
+export type SessionTransitionStatus = 'planned' | 'progressed' | 'waiting' | 'needs_input' | 'reconcile_required' | 'unknown' | 'invalid';
+export type SessionTransitionStage = 'not_started' | 'intent_created' | 'awaiting_quiescence' | 'prepared' | 'successor_bootstrap' | 'awaiting_receiver_ack' | 'receiver_confirmed' | 'ownership_transferred' | 'awaiting_first_work' | 'first_work_recorded' | 'task_retired' | 'unknown';
+export declare const MANAGED_PI_SCOPED_PROOF_ADAPTER_ID = "pappra/managed-pi-session-transition-host/2";
+export declare const MANAGED_PI_SCOPED_RECEIPT_SCHEMA = "pappra/session-transition-quiescence-receipt/2";
+export interface SessionTransitionQuiescenceProof {
+    readonly adapter_id: 'pappra/pi-session-transition-host/1' | typeof MANAGED_PI_SCOPED_PROOF_ADAPTER_ID;
+    readonly session_id: string;
+    readonly cwd: string;
+    readonly observed_at: string;
+    readonly sequence: number;
+    readonly evidence_ref: string;
+    readonly freeze_token: FreezeToken;
+    readonly inventory: rollover.RolloverInventory;
+    readonly scope?: 'pinned_pi_1_4_owned_runtime';
+    readonly execution_scope?: ManagedPiExecutionScope;
+    readonly execution_scope_digest?: string;
+    readonly excluded_scope?: readonly [
+        'arbitrary_external_writers',
+        'unowned_processes_and_descendants'
+    ];
+    readonly runtime_quiescent?: boolean;
+    readonly runtime_blockers?: readonly string[];
+    readonly controller_sequence?: number;
+    readonly controller_head_digest?: string;
+    readonly controller_journal_healthy?: boolean;
+}
+export interface SessionTransitionQuiescenceReceipt {
+    readonly schema: 'pappra/session-transition-quiescence-receipt/1' | typeof MANAGED_PI_SCOPED_RECEIPT_SCHEMA;
+    readonly adapter_id: 'pappra/pi-session-transition-host/1' | typeof MANAGED_PI_SCOPED_PROOF_ADAPTER_ID;
+    readonly session_id: string;
+    readonly cwd: string;
+    readonly observed_at: string;
+    readonly sequence: number;
+    readonly evidence_ref: string;
+    readonly freeze_token: FreezeToken;
+    readonly inventory_digest: string;
+    readonly execution_scope_digest?: string;
+}
+export interface SessionTransitionHostObservation {
+    readonly session_id: string | null;
+    readonly cwd: string | null;
+    readonly pane_id: string | null;
+    readonly proof_support: 'available' | 'unavailable';
+    readonly proof: SessionTransitionQuiescenceProof | null;
+    readonly freeze_status: FreezeStatus | null;
+    readonly native_facts: NativeFactsSnapshot | null;
+    readonly unavailable_code: string | null;
+    readonly detail: string | null;
+}
+/**
+ * In-process adapter supplied only by the opt-in Pi extension. The installed producer currently
+ * cannot return a complete quiescence proof; its production adapter must report that boundary
+ * rather than promote idle, settled, or a freeze latch to stop proof.
+ */
+export interface SessionTransitionHost {
+    readonly id: string;
+    observe(): Promise<SessionTransitionHostObservation>;
+    freeze(token: FreezeToken): Promise<FreezeOutcome>;
+}
+export interface SessionTransitionBootstrapExecutor {
+    plan(request: LoadedVisibleBootstrapRequest): Promise<VisibleBootstrapReport>;
+    apply(request: LoadedVisibleBootstrapRequest): Promise<VisibleBootstrapReport>;
+}
+export interface SessionTransitionDependencies {
+    readonly host?: SessionTransitionHost;
+    readonly bootstrap?: SessionTransitionBootstrapExecutor;
+    readonly bootstrapDependencies?: VisibleBootstrapDependencies;
+    readonly herdr?: HerdrBootstrapOps;
+    readonly clock?: () => number;
+    readonly signal?: AbortSignal;
+}
+export interface SessionTransitionStep {
+    readonly step: string;
+    readonly status: string;
+    readonly code: string | null;
+    readonly detail: string | null;
+}
+export interface SessionTransitionReport {
+    readonly schema: typeof COLLAB_SESSION_TRANSITION_REPORT_SCHEMA;
+    readonly action: SessionTransitionAction;
+    readonly ok: boolean;
+    readonly status: SessionTransitionStatus;
+    readonly code: string | null;
+    readonly message: string | null;
+    readonly next_action: string | null;
+    readonly task_id: string | null;
+    readonly task_root: string;
+    readonly state_revision: number | null;
+    readonly transition_id: string;
+    readonly cause_ref: string;
+    readonly stage: SessionTransitionStage;
+    readonly intent: Record<string, unknown> | null;
+    readonly handoff: Record<string, unknown> | null;
+    readonly rollover: RolloverReport | null;
+    readonly bootstrap: VisibleBootstrapReport | null;
+    readonly receiver_ack: Record<string, unknown> | null;
+    readonly transfer: Record<string, unknown> | null;
+    readonly first_work: Record<string, unknown> | null;
+    readonly route_transfer: Record<string, unknown> | null;
+    readonly archive: Record<string, unknown> | null;
+    readonly host: Record<string, unknown> | null;
+    readonly steps: readonly SessionTransitionStep[];
+    readonly capabilities: {
+        readonly record_reducer: 'available';
+        readonly bootstrap: 'available';
+        readonly pi_host_extension: 'available' | 'not_loaded';
+        readonly supported_quiescence: 'available' | 'unavailable' | 'unknown';
+        readonly native_session_archive: 'unavailable';
+        readonly task_retirement_archive: 'available';
+        readonly task_route_transfer: 'available';
+        readonly notification_route_exclusion: 'active' | 'pending' | 'excluded' | 'unknown';
+    };
+    readonly limits: readonly string[];
+}
+export interface SessionTransitionEffectReceipt {
+    readonly state: 'pending' | 'completed' | 'unknown' | 'failed';
+    readonly intent_at: string;
+    readonly outcome_at?: string;
+    readonly code?: string;
+    readonly digest?: string;
+    readonly ref?: string;
+}
+export interface SessionTransitionJournalEntry {
+    readonly transition_id: string;
+    readonly request_digest: string;
+    readonly bootstrap_request_digest: string;
+    readonly created_at: string;
+    readonly updated_at: string;
+    readonly effects: Readonly<Record<string, SessionTransitionEffectReceipt>>;
+    readonly route_binding_ref?: string | null;
+    readonly route_binding_digest?: string | null;
+    readonly archive_ref?: string | null;
+    readonly archive_digest?: string | null;
+    readonly source_quiescence_receipt?: SessionTransitionQuiescenceReceipt;
+    readonly transfer_quiescence_receipt?: SessionTransitionQuiescenceReceipt;
+}
+export interface SessionTransitionJournal {
+    readonly schema: 'pappra/session-transition-journal/1';
+    readonly entries: readonly SessionTransitionJournalEntry[];
+}
+export type SessionTransitionEffectName = 'source-freeze' | 'successor-route-binding' | 'task-retirement-marker';
+export declare function planSessionTransition(input: LoadedSessionTransitionRequest | SessionTransitionRequest, dependencies?: SessionTransitionDependencies): Promise<SessionTransitionReport>;
+export declare function applySessionTransition(input: LoadedSessionTransitionRequest | SessionTransitionRequest, dependencies?: SessionTransitionDependencies): Promise<SessionTransitionReport>;