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

package/assets/integrations/skills/pappra/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: pappra
-description: Use Pappra workspace knowledge, checkpoint/resume, selected-repository code intelligence, and task-scoped cross-harness collaboration from any supported coding agent. Use when a task needs durable handoff context, workspace documents, bounded code navigation, or a visible/direct multi-agent collaboration workflow.
+description: Use Pappra workspace knowledge, checkpoint/resume, selected-repository code intelligence, and task-scoped cross-harness collaboration from any supported coding agent. Use before nontrivial repository work to reach the project's own skill and CodeGraph entry, when a task needs durable handoff context, workspace documents, or bounded code navigation, and when independent parallel implementation or independent review would reduce risk even if the user never names collaboration.
 ---
 
 # Pappra
@@ -74,6 +74,34 @@ No approval is auto-answered, no cancel is inferred from an acknowledgement, and
 arbitrary PID is adopted. Do not launch a model or real user session without
 the task's explicit authorization.
 
+## Role plans and host-agent role selection
+
+Choosing whether work needs independent implementation or an independent reviewer
+is the host agent's judgment from the user's objective and the actual change
+surface: complexity, dependency blast radius, disjoint write scopes, and risk.
+There is no backend role inferencer, no fixed participant count, and no repeated
+permission prompt once the user authorized the work.
+
+Use the installed commands in this order; roles never grant authority:
+
+- `pappra collab role-plan expand --request <abs role-plan.json> --json` expands
+  explicit participants, assignments and disjoint writer scopes into the existing
+  work-plan format. Save the returned `plan`.
+- `pappra collab plan --task-root <abs> --config <abs expanded-plan.json>` and
+  `pappra collab work-run --request <abs work-execution.json> [--apply]` keep
+  their existing admission, capability and dispatch requirements.
+- `pappra collab role-run --request <abs role-orchestration.json> [--apply]`
+  reads authoritative role/dependency state; `--apply` handles one bounded event
+  tick and reserves before dispatch. Neither infers acceptance.
+- `pappra collab role-plan aggregate --request <abs role-plan.json>` with
+  `--task-root <abs> --config <abs expanded-plan.json>` aggregates authoritative
+  results.
+
+Roles describe responsibility and scope only: they approve nothing and never
+synthesize a participant identity or capability card. Hooks record lifecycle
+observations only and never select roles or launch a model. Keep the manual path:
+a simple, reversible, local change needs no role plan.
+
 ## Recovery and parallel work
 
 Use `pappra collab work-run --request <abs-request.json>` for a read-only plan and add `--apply` only when the existing assignments, current capability cards, coordinator authority, resource claims and visible participant binding are ready. Work-run notifies only registered participants; it does not create sessions, merge, accept reports, or replay ambiguous delivery.

package/assets/integrations/skills/pappra/references/collaboration.md

@@ -200,6 +200,19 @@ evidence through the work-plan inspector. Rejected, unknown, missing and pending
 outcomes remain visible. A delivery acknowledgement never becomes acceptance.
 Neither command launches a model, claims resources or creates an assignment.
 
+`pappra collab role-run --request <abs role-orchestration.json> [--apply]
+[--watch] --json` advances the plan's recorded role/dependency events. Plan mode
+reads authoritative state with no effects; `--apply` handles one bounded event
+tick, reserves before dispatch and never infers acceptance; `--watch` requires
+`--apply`. Repeated or ambiguous effects are reconciled, and rejected work needs an
+authorized repair attempt. It notifies registered participants only and creates no
+session, assignment or claim of its own.
+
+Which roles exist, and how many writers or reviewers run, is the host agent's
+judgment of the actual objective and change surface, not a product default.
+Nothing here infers semantic roles: hooks record bounded lifecycle observations,
+the backend resolves protocol state, and no command launches a model from prose.
+
 ## Native capability evidence
 
 `pappra collab capabilities derive --harness <pi|codex|claude> --assignment <abs assignment.json> --template <abs card.declared.json> --execution <abs execution.json> [--session <abs pi-session.jsonl> | --events <abs events.jsonl>] [--json]`

package/assets/integrations/skills/pappra/references/environment.md

@@ -51,6 +51,13 @@ stays `process_affiliation: "not-established"`.
 Pick participants, roles, harness, and configuration from the task rather than a
 fixed agent count. Everyone can implement, review, or verify; assign by need.
 
+Which roles and how many participants are needed follows the real work split, and
+that choice belongs to the host agent reading the objective and change surface;
+neither the backend nor the hooks infer responsibilities or launch anyone.
+Authorization the user already gave for the task persists, so do not re-request the
+same delegation at every step, and never fabricate a participant identity,
+capability or claim to fill a role.
+
 Reuse an existing peer only when all of the following match what the task will
 bind: current agent name, pane, harness, cwd, native session (where the host
 reports one), and the capabilities the assignment will require. Otherwise, when

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

@@ -0,0 +1,50 @@
+import { type ManagedPiExecutionScope } from '../schemas/managed-pi-execution.js';
+import type { RolloverBundleRequest, RolloverIntentRequest } from './collab-rollover.js';
+export declare const COLLAB_SESSION_TRANSITION_REQUEST_SCHEMA = "pappra/collaboration-session-transition-request/1";
+export interface SessionTransitionRequest {
+    readonly schema: typeof COLLAB_SESSION_TRANSITION_REQUEST_SCHEMA;
+    readonly managed_execution_scope?: ManagedPiExecutionScope;
+    readonly task_root: string;
+    readonly transition_id: string;
+    readonly intent: RolloverIntentRequest;
+    readonly bundle: RolloverBundleRequest;
+    readonly bootstrap_request: {
+        readonly ref: string;
+        readonly digest: string;
+    };
+    readonly evidence: {
+        readonly ack_message_id: string | null;
+        readonly first_work_report_id: string | null;
+    };
+    readonly archive_mode: 'task-retirement';
+}
+export interface LoadedSessionTransitionRequest {
+    readonly request: SessionTransitionRequest;
+    readonly file: string;
+    readonly file_digest: string;
+    readonly immutable_digest: string;
+}
+export type SessionTransitionRequestResult = {
+    readonly ok: true;
+    readonly value: LoadedSessionTransitionRequest;
+} | {
+    readonly ok: false;
+    readonly kind: 'invalid';
+    readonly code: string;
+    readonly message: string;
+    readonly next_action: string | null;
+};
+/**
+ * The immutable digest deliberately excludes `evidence`: adding an ACK or a
+ * first-work REPORT pointer must not change a request's identity.
+ */
+export declare function immutableDigest(request: SessionTransitionRequest): string;
+export declare function validateSessionTransitionRequest(value: unknown): {
+    readonly ok: true;
+    readonly request: SessionTransitionRequest;
+} | {
+    readonly ok: false;
+    readonly code: string;
+    readonly message: string;
+};
+export declare function loadSessionTransitionRequest(file: string): SessionTransitionRequestResult;

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

@@ -2,12 +2,14 @@ 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 RolloverBundleRequest, type RolloverIntentRequest, type RolloverReport } from './collab-rollover.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 declare const COLLAB_SESSION_TRANSITION_REQUEST_SCHEMA = "pappra/collaboration-session-transition-request/1";
+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 {
@@ -38,39 +40,6 @@ export type SessionTransitionStatus = 'planned' | 'progressed' | 'waiting' | 'ne
 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 SessionTransitionRequest {
-    readonly schema: typeof COLLAB_SESSION_TRANSITION_REQUEST_SCHEMA;
-    readonly managed_execution_scope?: ManagedPiExecutionScope;
-    readonly task_root: string;
-    readonly transition_id: string;
-    readonly intent: RolloverIntentRequest;
-    readonly bundle: RolloverBundleRequest;
-    readonly bootstrap_request: {
-        readonly ref: string;
-        readonly digest: string;
-    };
-    readonly evidence: {
-        readonly ack_message_id: string | null;
-        readonly first_work_report_id: string | null;
-    };
-    readonly archive_mode: 'task-retirement';
-}
-export interface LoadedSessionTransitionRequest {
-    readonly request: SessionTransitionRequest;
-    readonly file: string;
-    readonly file_digest: string;
-    readonly immutable_digest: string;
-}
-export type SessionTransitionRequestResult = {
-    readonly ok: true;
-    readonly value: LoadedSessionTransitionRequest;
-} | {
-    readonly ok: false;
-    readonly kind: 'invalid';
-    readonly code: string;
-    readonly message: string;
-    readonly next_action: string | null;
-};
 export interface SessionTransitionQuiescenceProof {
     readonly adapter_id: 'pappra/pi-session-transition-host/1' | typeof MANAGED_PI_SCOPED_PROOF_ADAPTER_ID;
     readonly session_id: string;
@@ -207,15 +176,6 @@ export interface SessionTransitionJournal {
     readonly schema: 'pappra/session-transition-journal/1';
     readonly entries: readonly SessionTransitionJournalEntry[];
 }
-export declare function validateSessionTransitionRequest(value: unknown): {
-    readonly ok: true;
-    readonly request: SessionTransitionRequest;
-} | {
-    readonly ok: false;
-    readonly code: string;
-    readonly message: string;
-};
-export declare function loadSessionTransitionRequest(file: string): SessionTransitionRequestResult;
 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>;