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

package/dist/hosts/integration/support.d.ts

@@ -36,6 +36,13 @@ export declare const HOST_SUPPORT: {
 };
 export declare function nativeEventFor(host: HostName, event: HostLifecycleEvent): string | null;
 export declare function isSupportedVersion(host: HostName, version: string | null): boolean;
+/** Only versions with bounded local event/loader evidence are admitted here.
+ * The owned SDK adapter has a separate exact version/private-source contract. */
+export declare const HOST_EVENT_VERSIONS: {
+    readonly pi: readonly ['1.3.0', '1.4.0'];
+    readonly codex: readonly ['0.163.0', '0.164.0'];
+    readonly claude: readonly ['2.1.292', '2.1.308'];
+};
 export declare function surfaceFor(host: HostName): (typeof HOST_SUPPORT)[HostName]['surface'];
 /**
  * Observed plugin-hook support. `verified` means a real host session produced a

package/dist/hosts/integration/support.js

@@ -39,8 +39,16 @@ export function nativeEventFor(host, event) {
     return HOST_SUPPORT[host].events[event];
 }
 export function isSupportedVersion(host, version) {
-    return version === HOST_SUPPORT[host].version;
+    return (version !== null &&
+        HOST_EVENT_VERSIONS[host].some((observed) => observed === version));
 }
+/** Only versions with bounded local event/loader evidence are admitted here.
+ * The owned SDK adapter has a separate exact version/private-source contract. */
+export const HOST_EVENT_VERSIONS = {
+    pi: ['1.3.0', '1.4.0'],
+    codex: ['0.163.0', '0.164.0'],
+    claude: ['2.1.292', '2.1.308'],
+};
 export function surfaceFor(host) {
     return HOST_SUPPORT[host].surface;
 }

package/dist/hosts/integration/templates.d.ts

@@ -1,11 +1,14 @@
 import type { HostName, HostLifecycleEvent } from '../../schemas/host.js';
 export declare const PAPPRA_MANAGED_MARKER = "pappra-managed";
+export declare const MIN_HOOK_TIMEOUT_SECONDS = 5;
 export interface RenderedHostTemplate {
     readonly path: string;
     readonly bytes: Buffer;
     readonly kind: 'extension' | 'hook';
 }
 export declare function renderHookCommand(host: HostName, event: HostLifecycleEvent, hookExpression: string): string;
+/** Recognizes only our exact script/host/event/marker suffix and a Node runner. */
+export declare function isManagedHookCommand(command: string, expectedCommands: ReadonlySet<string>): boolean;
 interface HookEntry {
     readonly hooks: readonly {
         readonly type: 'command';

package/dist/hosts/integration/templates.js

@@ -1,5 +1,7 @@
-import { basename } from 'node:path';
+import { basename, isAbsolute } from 'node:path';
 export const PAPPRA_MANAGED_MARKER = 'pappra-managed';
+// Covers bounded stdin collection plus lifecycle work and process startup.
+export const MIN_HOOK_TIMEOUT_SECONDS = 5;
 function shellQuote(value) {
     return `'${value.replaceAll("'", "'\\''")}'`;
 }
@@ -11,7 +13,28 @@ function pathExpression(value) {
     return value.includes('${') ? `"${value}"` : shellQuote(value);
 }
 export function renderHookCommand(host, event, hookExpression) {
-    return `${shellQuote(process.execPath)} ${pathExpression(hookExpression)} ${shellQuote(host)} ${shellQuote(event)} # ${PAPPRA_MANAGED_MARKER}`;
+    return `node ${pathExpression(hookExpression)} ${shellQuote(host)} ${shellQuote(event)} # ${PAPPRA_MANAGED_MARKER}`;
+}
+/** Recognizes only our exact script/host/event/marker suffix and a Node runner. */
+export function isManagedHookCommand(command, expectedCommands) {
+    for (const expected of expectedCommands) {
+        if (command === expected)
+            return true;
+        const suffix = expected.slice('node'.length);
+        if (!command.endsWith(suffix))
+            continue;
+        const runner = command.slice(0, -suffix.length);
+        // Previous packages single-quoted process.execPath. Recognize that one
+        // shell word without interpreting arbitrary shell syntax or user commands.
+        if (!/^'(?:[^']|'\\'')*'$/.test(runner))
+            continue;
+        const executable = runner.slice(1, -1).replaceAll("'\\''", "'");
+        if (isAbsolute(executable) &&
+            ['node', 'node.exe'].includes(basename(executable))) {
+            return true;
+        }
+    }
+    return false;
 }
 export function renderHookConfigPatch(host, hookExpression) {
     const entry = (event) => ({
@@ -19,7 +42,7 @@ export function renderHookConfigPatch(host, hookExpression) {
             {
                 type: 'command',
                 command: renderHookCommand(host, event, hookExpression),
-                timeout: 1,
+                timeout: MIN_HOOK_TIMEOUT_SECONDS,
             },
         ],
     });

package/dist/hosts/pi/managed-host-identity.d.ts

@@ -0,0 +1,2 @@
+/** A PID is meaningful only within this OS boot and PID namespace. Never use hostname as proof. */
+export declare function managedPiHostIdentity(): string | null;

package/dist/hosts/pi/managed-host-identity.js

@@ -0,0 +1,40 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import { spawnSync } from 'node:child_process';
+let cached;
+/** A PID is meaningful only within this OS boot and PID namespace. Never use hostname as proof. */
+export function managedPiHostIdentity() {
+    if (cached !== undefined)
+        return cached;
+    try {
+        let boot;
+        let namespace = 'native';
+        if (process.platform === 'linux') {
+            boot = fs.readFileSync('/proc/sys/kernel/random/boot_id', 'utf8').trim();
+            namespace = fs.readlinkSync('/proc/self/ns/pid');
+            if (!/^pid:\[[0-9]+\]$/.test(namespace))
+                return (cached = null);
+        }
+        else if (process.platform === 'darwin') {
+            // Absolute OS utility, direct argv, no shell/config/PATH interpretation.
+            const result = spawnSync('/usr/sbin/sysctl', ['-n', 'kern.bootsessionuuid'], {
+                encoding: 'utf8',
+                timeout: 2000,
+                maxBuffer: 1024,
+                shell: false,
+            });
+            if (result.error || result.status !== 0)
+                return (cached = null);
+            boot = result.stdout.trim();
+        }
+        else
+            return (cached = null);
+        if (!/^[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}$/i.test(boot))
+            return (cached = null);
+        cached = `sha256:${crypto.createHash('sha256').update(`pappra/managed-host/1\0${process.platform}\0${boot.toLowerCase()}\0${namespace}`).digest('hex')}`;
+        return cached;
+    }
+    catch {
+        return (cached = null);
+    }
+}

package/dist/hosts/pi/managed-provider-diagnostics.d.ts

@@ -0,0 +1,6 @@
+export type ManagedProviderDiagnosticSink = (kind: string, fields: Readonly<Record<string, unknown>>) => void;
+/** Never serialize errors: messages, URLs, headers and arbitrary custom fields may contain secrets. */
+export declare function managedProviderErrorCauses(error: unknown): readonly Record<string, unknown>[];
+export declare function managedProviderResponseId(value: unknown): string | null;
+/** Per-call observation only: preserve the caller fetch, options, signal, response and errors. */
+export declare function withManagedProviderDiagnostics(options: unknown, model: unknown, providerCallId: string, sink: ManagedProviderDiagnosticSink): Readonly<Record<string, unknown>>;

package/dist/hosts/pi/managed-provider-diagnostics.js

@@ -0,0 +1,184 @@
+import { randomUUID } from 'node:crypto';
+const names = new Set([
+    'Error',
+    'TypeError',
+    'AggregateError',
+    'AbortError',
+    'TimeoutError',
+    'APIConnectionError',
+    'APIConnectionTimeoutError',
+    'APIError',
+]);
+const syscalls = new Set([
+    'getaddrinfo',
+    'connect',
+    'read',
+    'write',
+    'recv',
+    'send',
+    'SSL_connect',
+]);
+const codes = new Set([
+    'ENOTFOUND',
+    'EAI_AGAIN',
+    'ETIMEDOUT',
+    'ECONNREFUSED',
+    'ECONNRESET',
+    'EHOSTUNREACH',
+    'ENETUNREACH',
+    'EPIPE',
+    'EPROTO',
+    'ECANCELED',
+    'ECONNABORTED',
+    'ENOTCONN',
+    'EHOSTDOWN',
+    'ENETDOWN',
+    'ENETRESET',
+    'EADDRINUSE',
+    'EADDRNOTAVAIL',
+    'ENOMEM',
+    'EACCES',
+    'EPERM',
+    'EMFILE',
+    'ENFILE',
+    'EAGAIN',
+    'EWOULDBLOCK',
+    'ESHUTDOWN',
+    'ABORT_ERR',
+    'UND_ERR_CONNECT_TIMEOUT',
+    'UND_ERR_HEADERS_TIMEOUT',
+    'UND_ERR_BODY_TIMEOUT',
+    'UND_ERR_SOCKET',
+    'UND_ERR_ABORTED',
+    'ERR_ABORTED',
+    'ERR_TLS_CERT_ALTNAME_INVALID',
+    'ERR_TLS_HANDSHAKE_TIMEOUT',
+    'ERR_SSL_WRONG_VERSION_NUMBER',
+    'ERR_SSL_TLSV1_ALERT_INTERNAL_ERROR',
+    'CERT_HAS_EXPIRED',
+    'CERT_NOT_YET_VALID',
+    'DEPTH_ZERO_SELF_SIGNED_CERT',
+    'SELF_SIGNED_CERT_IN_CHAIN',
+    'UNABLE_TO_VERIFY_LEAF_SIGNATURE',
+    'UNABLE_TO_GET_ISSUER_CERT_LOCALLY',
+]);
+const object = (value) => typeof value === 'object' && value !== null;
+/** Never serialize errors: messages, URLs, headers and arbitrary custom fields may contain secrets. */
+export function managedProviderErrorCauses(error) {
+    const causes = [];
+    const seen = new Set();
+    const inspect = (value) => {
+        if (!object(value) || seen.has(value) || causes.length >= 4)
+            return;
+        seen.add(value);
+        try {
+            const code = typeof value.code === 'string' && codes.has(value.code)
+                ? value.code
+                : null;
+            causes.push({
+                name: typeof value.name === 'string' && names.has(value.name)
+                    ? value.name
+                    : 'Error',
+                code,
+                errno: Number.isSafeInteger(value.errno) &&
+                    Math.abs(Number(value.errno)) <= 65535
+                    ? value.errno
+                    : null,
+                syscall: typeof value.syscall === 'string' && syscalls.has(value.syscall)
+                    ? value.syscall
+                    : null,
+            });
+            inspect(value.cause);
+            if (value instanceof AggregateError)
+                for (const nested of value.errors.slice(0, 2))
+                    inspect(nested);
+        }
+        catch {
+            // An exotic error getter must not mask the original provider error.
+        }
+    };
+    inspect(error);
+    return causes;
+}
+export function managedProviderResponseId(value) {
+    return typeof value === 'string' &&
+        /^[A-Za-z0-9][A-Za-z0-9_.:-]{0,127}$/.test(value) &&
+        !/^(?:sk-|bearer|basic|token|(?:api[_-]?)?key)/i.test(value)
+        ? value
+        : null;
+}
+function requestId(response) {
+    for (const header of [
+        'x-request-id',
+        'request-id',
+        'x-openrouter-request-id',
+    ]) {
+        const value = managedProviderResponseId(response.headers.get(header));
+        if (value)
+            return value;
+    }
+    return null;
+}
+/** Per-call observation only: preserve the caller fetch, options, signal, response and errors. */
+export function withManagedProviderDiagnostics(options, model, providerCallId, sink) {
+    const original = object(options) ? options : {};
+    if (original.fetch !== undefined && typeof original.fetch !== 'function')
+        return original;
+    const fetcher = (original.fetch ?? globalThis.fetch);
+    const observedModel = object(model) ? model : {};
+    const metadata = {
+        provider_call_id: providerCallId,
+        provider: typeof observedModel.provider === 'string' &&
+            /^[a-z][a-z0-9-]{0,63}$/.test(observedModel.provider)
+            ? observedModel.provider
+            : 'unknown',
+        model: typeof observedModel.id === 'string' &&
+            /^[A-Za-z0-9][A-Za-z0-9._/-]{0,127}$/.test(observedModel.id)
+            ? observedModel.id
+            : 'unknown',
+    };
+    const emit = (kind, fields) => {
+        try {
+            sink(kind, { ...metadata, ...fields });
+        }
+        catch {
+            /* Diagnostic failure never masks an admitted effect. */
+        }
+    };
+    const observedFetch = async (input, init) => {
+        const fetchId = randomUUID();
+        const started = performance.now();
+        const elapsed = () => Math.round(Math.max(0, performance.now() - started) * 1000) / 1000;
+        emit('sdk_provider_fetch_started', { fetch_id: fetchId });
+        try {
+            const response = await fetcher(input, init);
+            try {
+                emit('sdk_provider_fetch_response', {
+                    fetch_id: fetchId,
+                    status: response.status,
+                    request_id: requestId(response),
+                    headers_elapsed_ms: elapsed(),
+                });
+            }
+            catch {
+                /* An unreadable diagnostic header must not change the response. */
+            }
+            return response;
+        }
+        catch (error) {
+            try {
+                emit('sdk_provider_fetch_failed', {
+                    fetch_id: fetchId,
+                    elapsed_ms: elapsed(),
+                    signal_aborted: init?.signal?.aborted ?? false,
+                    causes: managedProviderErrorCauses(error),
+                });
+            }
+            catch {
+                /* An exotic signal getter must not replace the original error. */
+            }
+            throw error;
+        }
+    };
+    return { ...original, fetch: observedFetch };
+}

package/dist/hosts/pi/managed-sdk-session.d.ts

@@ -0,0 +1,335 @@
+import type { ManagedPiExecutionScope } from '../../schemas/managed-pi-execution.js';
+import { type ManagedPiSdkResumeAuthorization } from './resume-capability.js';
+import { type ManagedPiJournal } from './managed-session.js';
+export declare const MANAGED_PI_SDK_PRIVATE_SOURCE_HASHES: {
+    readonly 'dist/core/compaction/compaction.js': 'f51e78ef1da66b5803fc91e185f07b968f8f989ab9326b7744958416aad3f6f6';
+    readonly 'dist/core/agent-session.js': '436e8be3bbab2db475ce30bb5d0bb30f0046b19a3476f8cd57b8133e68891162';
+    readonly 'dist/modes/interactive/interactive-mode.js': '633000038a8a9c60111fc9b32481c4015285fe530685277068bc5ed74f77dafa';
+};
+declare const SDK_SESSION_SCHEMA = "harness-collab/pi-managed-sdk-session/1";
+export interface ManagedPiSdkInputEvent {
+    readonly text: string;
+    readonly images?: readonly unknown[];
+    readonly source?: string;
+    readonly streamingBehavior?: string;
+}
+export interface ManagedPiSdkFence {
+    readonly fenced: boolean;
+    fence(reason: string): void;
+    invalidateResumeCheckpoint(reason: string): void;
+}
+/** Shared fence used by the SDK extension and the lifecycle controller. */
+export declare class ManagedPiSdkIngressFence implements ManagedPiSdkFence {
+    private readonly journal;
+    private isFenced;
+    constructor(journal: ManagedPiJournal);
+    private checkpointRevisionValue;
+    get checkpointRevision(): number;
+    invalidateResumeCheckpoint(reason: string): void;
+    get fenced(): boolean;
+    fence(reason: string): void;
+}
+/** Inline Pi extension factory: journals semantic ingress and blocks new tools after fencing. */
+export declare function createManagedPiSdkLifecycleExtension(fence: ManagedPiSdkFence, journal: ManagedPiJournal, metadataPath: string, canExecute?: () => boolean): (pi: unknown) => void;
+export interface ManagedPiSdkContextUsage {
+    readonly tokens: number | null;
+    readonly contextWindow: number;
+    readonly percent: number | null;
+}
+export interface ManagedPiSdkAgentState {
+    readonly pendingToolCalls?: ReadonlySet<string>;
+    readonly isStreaming?: boolean;
+}
+export interface ManagedPiSdkAgent {
+    state: ManagedPiSdkAgentState;
+    streamFunction: (...args: never[]) => unknown;
+}
+/** Structural view of public Pi 1.4 AgentSession APIs used by the lifecycle controller. */
+export interface ManagedPiSdkSessionPort {
+    readonly agent: ManagedPiSdkAgent;
+    readonly sessionId: string;
+    readonly model: {
+        readonly id: string;
+        readonly provider: string;
+    } | undefined;
+    readonly thinkingLevel?: string;
+    readonly sessionFile: string | undefined;
+    readonly isStreaming: boolean;
+    readonly isCompacting: boolean;
+    readonly isIdle: boolean;
+    readonly isBashRunning?: boolean;
+    readonly hasPendingBashMessages?: boolean;
+    readonly pendingMessageCount: number;
+    readonly state: ManagedPiSdkAgentState;
+    getSteeringMessages(): readonly string[];
+    getFollowUpMessages(): readonly string[];
+    getContextUsage(): ManagedPiSdkContextUsage | undefined;
+    compact(customInstructions?: string): Promise<unknown>;
+    subscribe(listener: (event: unknown) => void): () => void;
+    abort(): Promise<void>;
+    waitForIdle(): Promise<void>;
+}
+export interface ManagedPiSdkInteractiveModePort {
+    init(): Promise<void>;
+    run(): Promise<void>;
+    stop(): void;
+}
+export interface ManagedPiSdkRuntimePort {
+    readonly session: ManagedPiSdkSessionPort;
+    readonly cwd: string;
+    setRebindSession(callback?: (session: ManagedPiSdkSessionPort) => Promise<void>): void;
+    dispose(): Promise<void>;
+}
+export interface ManagedPiSdkPendingDialog {
+    readonly id: string;
+    readonly kind: 'confirm' | 'select' | 'input' | 'unclassified';
+    readonly startedAt: string;
+}
+export interface ManagedPiSdkSessionSnapshot {
+    readonly schema: typeof SDK_SESSION_SCHEMA;
+    readonly process: {
+        readonly pid: number;
+        readonly exit: 'not_owned';
+    };
+    readonly session: {
+        readonly sessionId: string;
+        readonly sessionFile: string | null;
+    };
+    readonly contextUsage: ManagedPiSdkContextUsage | null;
+    readonly ingress: {
+        readonly state: 'open' | 'fenced';
+        readonly journalPath: string;
+        readonly sequence: number;
+        readonly headDigest: string;
+        readonly healthy: boolean;
+    };
+    readonly ownedRuntime: {
+        readonly scope: 'pi_agent_session';
+        readonly queues: {
+            readonly observedScope: 'pinned_pi_1_4_owned_runtime';
+            readonly completeness: 'complete' | 'unknown';
+            readonly steering: readonly string[];
+            readonly followUp: readonly string[];
+            readonly pendingMessageCount: number;
+            readonly internal: {
+                readonly pendingNextTurn: readonly unknown[] | null;
+                readonly pendingCustom: readonly unknown[] | null;
+                readonly pendingBash: readonly unknown[] | null;
+                readonly deferredSettledActionCount: number | null;
+                readonly pendingUserInputs: readonly string[] | null;
+                readonly compactionMessages: readonly unknown[] | null;
+                readonly extensionDialogCount: number | null;
+                readonly activeSelector: boolean | null;
+            };
+        };
+        readonly work: {
+            readonly observation: 'complete' | 'unknown';
+            readonly isIdle: boolean;
+            readonly isStreaming: boolean;
+            readonly isCompacting: boolean;
+            readonly isBashRunning: boolean | null;
+            readonly hasPendingBashMessages: boolean | null;
+            readonly pendingToolCalls: number | null;
+        };
+        readonly extensionDialogs: {
+            readonly observedScope: 'InteractiveMode_extension_confirm_select_input';
+            readonly completeness: 'complete' | 'unknown';
+            readonly pending: readonly ManagedPiSdkPendingDialog[];
+        };
+        readonly builtInUiApprovals: {
+            readonly observation: 'complete' | 'unknown';
+            readonly uncoveredPaths: readonly string[];
+        };
+    };
+    readonly externalWriters: 'outside_runtime_scope';
+    readonly descendants: 'not_owned_by_sdk_runtime';
+    readonly scopedQuiescent: boolean;
+    readonly blockers: readonly string[];
+}
+export interface ManagedPiSdkStopReceipt {
+    readonly status: 'runtime_disposed';
+    readonly process: {
+        readonly pid: number;
+        readonly exit: 'not_owned';
+    };
+    readonly sessionId: string;
+    readonly finalSnapshot: ManagedPiSdkSessionSnapshot;
+}
+export interface ManagedPiSdkSummaryCapture {
+    /** The unmodified native CompactionResult returned by AgentSession.compact(). */
+    readonly result: unknown;
+    readonly sessionId: string;
+    readonly sessionFile: string | null;
+    readonly contextUsage: ManagedPiSdkContextUsage | null;
+}
+export interface ManagedPiSdkRolloverInventory {
+    readonly scope: 'pinned_pi_1_4_owned_runtime';
+    readonly completeness: 'complete' | 'partial' | 'unknown';
+    readonly inflight: readonly unknown[];
+    readonly pending_approvals: readonly unknown[];
+    readonly pending_messages?: readonly unknown[];
+    readonly partial_outputs?: readonly unknown[];
+    readonly outside_scope: readonly string[];
+}
+export interface ManagedPiSdkNativeIdentity {
+    readonly agentId: string | null;
+    readonly paneId: string | null;
+    readonly surface: string | null;
+    readonly configurationId: string | null;
+}
+export interface ManagedPiSdkSessionOptions {
+    readonly cwd: string;
+    /** Model ID within OpenRouter, for example `openai/gpt-6-luna`. */
+    readonly model: string;
+    readonly journalPath: string;
+    /** Fresh UUID for new sessions; resume requires the root-issued authorization below. */
+    readonly sessionId?: string;
+    readonly quiesceTimeoutMs?: number;
+    /** Exact immediate task binding, required when reopening a transcript. */
+    readonly executionScope?: ManagedPiExecutionScope;
+    /** Opaque, root-issued admission; never accepted from serialized launch config. */
+    readonly resumeAuthorization?: ManagedPiSdkResumeAuthorization;
+    /** Absolute path to the exact SDK module entrypoint; no ambient or global fallback is used. */
+    readonly sdkModulePath: string;
+    readonly nativeIdentity?: ManagedPiSdkNativeIdentity;
+    /** Explicit default-deny successor extension; normal daily resources are retained. */
+    readonly bootstrapExtensionPath?: string;
+    readonly thinkingLevel?: 'off' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max';
+    /** Trusted application binding before the TUI can admit task input. Never read from JSON. */
+    readonly beforeInteractiveStart?: (controller: ManagedPiSdkSessionController) => Promise<void>;
+    /** Trusted application gate, rechecked for semantic input, provider runs and tools. */
+    readonly canExecute?: () => boolean;
+}
+interface ManagedPiSdkServices {
+    readonly modelRuntime: {
+        getModel(provider: string, model: string): unknown;
+    };
+    readonly diagnostics: readonly unknown[];
+    readonly settingsManager?: {
+        isProjectTrusted(): boolean;
+        getCompactionSettings?(model: unknown): unknown;
+    };
+    readonly resourceLoader?: {
+        getSkills(): {
+            readonly skills: readonly unknown[];
+            readonly diagnostics: readonly unknown[];
+        };
+        getExtensions(): {
+            readonly extensions: readonly {
+                readonly path: string;
+            }[];
+            readonly errors: readonly unknown[];
+        };
+    };
+}
+/** Read-only compatibility gate: never create a session or freeze a source. */
+export declare function verifyManagedPiSdkInstallation(sdkModulePath: string): void;
+/**
+ * Lifecycle wrapper around the controller-owned SDK AgentSession and native InteractiveMode.
+ * The public start function builds both from the explicitly selected SDK module.
+ */
+export declare class ManagedPiSdkSessionController {
+    private readonly input;
+    private disposed;
+    private readonly summaryProviderRun;
+    private readonly originalStreams;
+    private readonly unsubscribers;
+    private readonly pendingDialogs;
+    private readonly lifecycleListeners;
+    private terminalStopped;
+    private readonly originalSessionMethods;
+    private readonly activeBashPromises;
+    private interactiveRun;
+    private session;
+    private nativeIdentity;
+    private initialized;
+    private resourceFingerprint;
+    private resourceUpdatePending;
+    private readonly submittedInputs;
+    private resumeCheckpointScope;
+    private lastAgentEndCheckpointSafe;
+    private readonly providerCalls;
+    constructor(input: {
+        readonly runtime: ManagedPiSdkRuntimePort;
+        readonly interactiveMode: ManagedPiSdkInteractiveModePort;
+        readonly fence: ManagedPiSdkIngressFence;
+        readonly journal: ManagedPiJournal;
+        readonly model: string;
+        readonly executionScope?: ManagedPiExecutionScope;
+        readonly nativeIdentity: ManagedPiSdkNativeIdentity | undefined;
+        readonly quiesceTimeoutMs: number;
+        readonly metadataPath?: string;
+        readonly resources?: () => ManagedPiSdkServices | undefined;
+        readonly canCompact?: () => boolean;
+        readonly canExecute?: () => boolean;
+        readonly resumeAuthorization?: ManagedPiSdkResumeAuthorization;
+    });
+    private onDialogStart;
+    private onDialogEnd;
+    private wrapSessionExtensionBindings;
+    private bindSession;
+    private scheduleResourceObservation;
+    private wrapSessionOperations;
+    subscribe(listener: (event: unknown, snapshot: ManagedPiSdkSessionSnapshot) => void): () => void;
+    private notifyLifecycleListeners;
+    private observeSessionEvent;
+    /** Called by AgentSessionRuntime's native replacement callback wrapper. */
+    replaceSession(session: ManagedPiSdkSessionPort): void;
+    fenceIngress(reason?: string): void;
+    snapshot(): ManagedPiSdkSessionSnapshot;
+    getContextUsage(): ManagedPiSdkContextUsage | null;
+    observe(): {
+        native: {
+            harness: 'pi';
+            sessionId: string;
+            agentId: string | null;
+            paneId: string | null;
+            surface: string;
+            configurationId: string | null;
+            modelObservation: {
+                model: string;
+                provider: string;
+                reasoning: string | null;
+            };
+        };
+        cwd: string;
+        contextPercent: number | null;
+    };
+    inventory(): Promise<ManagedPiSdkRolloverInventory>;
+    canCaptureSummary(): boolean;
+    captureSummary(causeId: string): Promise<{
+        summary: string;
+        complete: false;
+        sessionFile: string;
+    }>;
+    private stopTerminalIngress;
+    quiesce(reason?: string): Promise<ManagedPiSdkSessionSnapshot>;
+    stopOwnedRuntime(): Promise<ManagedPiSdkStopReceipt>;
+    get isDisposed(): boolean;
+    cleanupAfterStartupFailure(): Promise<boolean>;
+    private closeObservers;
+    bindResumeCheckpointScope(scope: ManagedPiExecutionScope): void;
+    recordInitialResumeCheckpoint(): boolean;
+    private appendResumeCheckpoint;
+    initializeInteractiveMode(): Promise<void>;
+    get runPromise(): Promise<void> | undefined;
+    /** Admits one durable semantic input, without waiting for or claiming model success. */
+    submitInput(requestId: string, text: string): {
+        status: string;
+        request_id: string;
+        duplicate: boolean;
+        session_id: string;
+    };
+    importHandoffContext(content: string): Promise<void>;
+    /** The app binds logical assignment identity; native UUID/cwd/model remain SDK observations. */
+    bindNativeIdentity(identity: ManagedPiSdkNativeIdentity): void;
+    /** Resource availability after real initialization, without a fabricated model turn. */
+    get metadataFile(): string | null;
+    publishResourcesReady(force?: boolean): boolean;
+}
+/**
+ * Start Pi 1.4.0's controller-owned SDK runtime and the native interactive TUI.
+ * The module path is explicit; this function never falls back to a global/installed SDK.
+ */
+export declare function startManagedPiSdkSession(options: ManagedPiSdkSessionOptions): Promise<ManagedPiSdkSessionController>;
+export {};