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

package/dist/hosts/integration/pi-rollover-extension.js

@@ -0,0 +1,431 @@
+/**
+ * Opt-in in-session Pi managed-tool freeze (rollover prerequisite).
+ *
+ * A separately opt-in Pi extension/controller: a later explicit integration calls
+ * `registerPiRolloverFreeze(pi, …)` inside a managed interactive session. This module does NOT
+ * activate in the current session, install itself, change default lifecycle hooks or touch user
+ * settings. It is self-contained: no subprocess, model, network, transcript, file watcher, timer,
+ * automatic handoff or successor launch, and no imports of the rollover orchestrator.
+ *
+ * What it is: a fail-closed managed Pi tool barrier. While latched it BLOCKS every tool except an
+ * explicit, vetted native read allowlist. Only tools in a fixed vetted read-tool universe can be
+ * allow-listed; bash/write/edit and every unknown/custom tool are blocked regardless of
+ * configuration. It never parses shell commands or tool paths and never calls a shell.
+ *
+ * What it is NOT: an OS sandbox, a stop proof, or an authority control. Pre-existing/background
+ * processes and external writers are outside it. A freeze latch alone is not "confirmed stopped".
+ * Native settled/queue/in-flight/approval facts are caller-supplied, UNAUTHENTICATED observations,
+ * never host-verified; any unknown/busy/pending condition and any session change or tool activity
+ * yield not-ready. Each readiness snapshot must be a complete coherent observation; absent facts are
+ * unknown, never an inherited historical all-clear. The latch is memory-only: a restart/reload loses
+ * it. There is intentionally NO thaw: recovery/release is a later, separately scoped,
+ * authority-checked integration.
+ *
+ * Installed Pi 1.3.0 API pinned from the installed example extensions (the package ships no .d.ts):
+ *   permission-gate.ts (sha256:e32086ba9dd9b4ba0fd308b65241d9affa0b5ecd3f90ef7ea1b9f2b30cab8cc1),
+ *   protected-paths.ts (sha256:9ca66b1f3b1b9a61cc5ddc660f92cca2ea66c4264a1bdb6b00e0da5844399fe2),
+ *   commands.ts        (sha256:36716b53da169936c7e1360a4fde1e2fc0c3356a6505f177235f09c5538c6e4f),
+ *   docs/extensions.md (sha256:a2b5ff0f95e7e470ed0846d7c4fbfc5781fe7e694b8e7f51ea08859f3ad7325d):
+ *   `pi.on("tool_call", async (event, ctx) => { … return { block: true, reason }; }` [allow: return
+ *   undefined] with `event.toolName: string` and `event.input: Record<string, unknown>`;
+ *   `pi.registerCommand(name, { description, handler })`; and the running session is read from
+ *   `ctx.sessionManager.getSessionId()`. The narrow structural `PiFreezeHost` interface matches that
+ *   shape. Structural compatibility checks are NOT a shipped-declaration or live-load proof.
+ */
+export const PI_ROLLOVER_FREEZE_STATUS_SCHEMA = 'pappra/pi-rollover-freeze-status/1';
+/**
+ * The fixed vetted native read-tool universe. Only these may ever be allow-listed while latched.
+ * Pi 1.3.0 built-in tools are read/bash/edit/write; `read` is the only read-only one. `bash` can
+ * read but also write, so it is deliberately excluded; write/edit/unknown/custom are never allowed.
+ */
+export const VETTED_NATIVE_READ_TOOLS = Object.freeze([
+    'read',
+]);
+/** Default allowlist (the full vetted read universe). A caller may only narrow within the vetted set. */
+export const DEFAULT_READ_TOOL_ALLOWLIST = Object.freeze([
+    ...VETTED_NATIVE_READ_TOOLS,
+]);
+const MAX_ID_LENGTH = 256;
+const MAX_OBSERVED_COUNT = 1_000_000;
+const LIMITATIONS = Object.freeze([
+    'memory_only_latch_lost_on_restart_or_reload',
+    'managed_pi_tool_barrier_not_os_sandbox',
+    'preexisting_or_background_or_external_writers_not_fenced',
+    'observations_caller_supplied_unauthenticated_not_a_native_stop_proof',
+    'readiness_from_persistent_caller_data_is_not_live_quiescence_revalidation_required',
+    'freeze_latch_alone_is_not_confirmed_stopped',
+    'no_thaw_recovery_pending_separate_authority_checked_integration',
+]);
+function isSafeId(value) {
+    return (typeof value === 'string' &&
+        value.length > 0 &&
+        value.length <= MAX_ID_LENGTH);
+}
+function isSafeGeneration(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0;
+}
+function isValidToken(value) {
+    if (value === null || typeof value !== 'object')
+        return false;
+    const t = value;
+    return (isSafeId(t['sessionId']) &&
+        isSafeId(t['taskId']) &&
+        isSafeId(t['handoffId']) &&
+        isSafeGeneration(t['generation']));
+}
+function isSafeCount(value) {
+    return (typeof value === 'number' &&
+        Number.isSafeInteger(value) &&
+        value >= 0 &&
+        value <= MAX_OBSERVED_COUNT);
+}
+function sameToken(a, b) {
+    return (a.sessionId === b.sessionId &&
+        a.taskId === b.taskId &&
+        a.handoffId === b.handoffId &&
+        a.generation === b.generation);
+}
+function copyToken(token) {
+    return Object.freeze({
+        sessionId: token.sessionId,
+        taskId: token.taskId,
+        handoffId: token.handoffId,
+        generation: token.generation,
+    });
+}
+function unknownNative() {
+    return {
+        settled: 'unknown',
+        queuedMessages: 'unknown',
+        inFlightTools: 'unknown',
+        pendingApprovals: 'unknown',
+        observedSequence: null,
+    };
+}
+/**
+ * In-memory, no-I/O freeze controller. One instance per managed session; the `pi` registration
+ * wires it to `tool_call` and the freeze/status commands. A fresh instance starts UNPROVEN
+ * (not frozen, not ready). There is no thaw.
+ */
+export class RolloverFreezeController {
+    #sessionId;
+    #allow;
+    #active = null;
+    #native = unknownNative();
+    /** Monotonic last-accepted observation sequence: the replay fence. Readiness invalidation,
+     * tool activity, a session mismatch and an idempotent freeze reuse never reset it. */
+    #lastAcceptedSequence = null;
+    constructor(options) {
+        if (!isSafeId(options.sessionId)) {
+            throw new RangeError('RolloverFreezeController requires a non-empty session id');
+        }
+        this.#sessionId = options.sessionId;
+        // Vet the allowlist against the fixed read universe; unsafe names are dropped.
+        const requested = options.readAllowlist ?? DEFAULT_READ_TOOL_ALLOWLIST;
+        const vetted = new Set(VETTED_NATIVE_READ_TOOLS);
+        this.#allow = new Set(requested.filter((name) => vetted.has(name)));
+    }
+    get sessionId() {
+        return this.#sessionId;
+    }
+    get frozen() {
+        return this.#active !== null;
+    }
+    freeze(token) {
+        if (!isValidToken(token)) {
+            return {
+                ok: false,
+                reason: 'invalid_token',
+                detail: 'token fields are invalid',
+            };
+        }
+        if (token.sessionId !== this.#sessionId) {
+            return {
+                ok: false,
+                reason: 'wrong_session',
+                detail: `token session ${token.sessionId} is not the bound session ${this.#sessionId}`,
+            };
+        }
+        if (this.#active) {
+            if (sameToken(this.#active, token)) {
+                return {
+                    ok: true,
+                    state: 'already_frozen',
+                    idempotent: true,
+                    token: copyToken(this.#active),
+                };
+            }
+            if (token.handoffId === this.#active.handoffId &&
+                token.generation < this.#active.generation) {
+                return {
+                    ok: false,
+                    reason: 'stale_generation',
+                    detail: `generation ${token.generation} is older than active ${this.#active.generation}`,
+                };
+            }
+            return {
+                ok: false,
+                reason: 'conflicting_freeze',
+                detail: `an active freeze (${this.#active.handoffId}#${this.#active.generation}) already holds this session`,
+            };
+        }
+        this.#active = copyToken(token);
+        this.#native = unknownNative();
+        this.#lastAcceptedSequence = null;
+        return {
+            ok: true,
+            state: 'frozen',
+            idempotent: false,
+            token: copyToken(this.#active),
+        };
+    }
+    /**
+     * The fail-closed tool barrier, revalidating the live session on every call. A wrong/missing/
+     * changed context session invalidates readiness and fails closed while latched; any tool activity
+     * invalidates a prior all-clear so it cannot be reused without a fresh observation.
+     */
+    decideToolCall(toolName, contextSessionId) {
+        if (contextSessionId !== this.#sessionId) {
+            this.invalidateReadiness();
+            if (this.#active) {
+                return {
+                    block: true,
+                    reason: `rollover freeze active (${this.#active.handoffId}#${this.#active.generation}): blocked (context session ${contextSessionId ?? 'missing'} != bound ${this.#sessionId})`,
+                };
+            }
+            return { block: false, reason: null };
+        }
+        if (!this.#active)
+            return { block: false, reason: null };
+        // Any tool activity means the session is not settled; invalidate prior readiness.
+        this.invalidateReadiness();
+        if (typeof toolName === 'string' && this.#allow.has(toolName)) {
+            return { block: false, reason: null };
+        }
+        const name = typeof toolName === 'string' ? toolName : 'unknown-tool';
+        return {
+            block: true,
+            reason: `rollover freeze active (${this.#active.handoffId}#${this.#active.generation}): ${name} blocked until ownership transfer`,
+        };
+    }
+    /** Reset readiness to unknown (on session change or activity). Does not clear the latch. */
+    invalidateReadiness() {
+        this.#native = unknownNative();
+    }
+    /**
+     * Apply one caller-supplied, unauthenticated complete native snapshot correlated to the active
+     * freeze. Validates the full token and every field type; a malformed or stale observation never
+     * changes readiness. Omitted fields become unknown (no inherited all-clear).
+     */
+    observe(observation) {
+        if (!this.#active) {
+            return {
+                ok: false,
+                reason: 'not_frozen',
+                detail: 'no active freeze to correlate against',
+            };
+        }
+        if (observation === null ||
+            typeof observation !== 'object' ||
+            !isValidToken(observation.token)) {
+            return {
+                ok: false,
+                reason: 'invalid_observation',
+                detail: 'observation token is malformed',
+            };
+        }
+        if (!sameToken(this.#active, observation.token)) {
+            return {
+                ok: false,
+                reason: 'token_mismatch',
+                detail: 'observation token does not fully match the active freeze',
+            };
+        }
+        if (!isSafeGeneration(observation.sequence)) {
+            return {
+                ok: false,
+                reason: 'invalid_observation',
+                detail: 'sequence is not a safe non-negative integer',
+            };
+        }
+        if (observation.settled !== undefined &&
+            typeof observation.settled !== 'boolean') {
+            return {
+                ok: false,
+                reason: 'invalid_observation',
+                detail: 'settled must be a boolean',
+            };
+        }
+        for (const count of [
+            observation.queuedMessages,
+            observation.inFlightTools,
+            observation.pendingApprovals,
+        ]) {
+            if (count !== undefined && !isSafeCount(count)) {
+                return {
+                    ok: false,
+                    reason: 'invalid_observation',
+                    detail: 'counts must be safe non-negative bounded integers',
+                };
+            }
+        }
+        if (this.#lastAcceptedSequence !== null &&
+            observation.sequence <= this.#lastAcceptedSequence) {
+            return {
+                ok: false,
+                reason: 'stale_sequence',
+                detail: 'observation sequence is not newer than the last accepted',
+            };
+        }
+        this.#native = {
+            settled: observation.settled === undefined
+                ? 'unknown'
+                : observation.settled
+                    ? 'yes'
+                    : 'no',
+            queuedMessages: observation.queuedMessages === undefined
+                ? 'unknown'
+                : observation.queuedMessages,
+            inFlightTools: observation.inFlightTools === undefined
+                ? 'unknown'
+                : observation.inFlightTools,
+            pendingApprovals: observation.pendingApprovals === undefined
+                ? 'unknown'
+                : observation.pendingApprovals,
+            observedSequence: observation.sequence,
+        };
+        this.#lastAcceptedSequence = observation.sequence;
+        return { ok: true };
+    }
+    /** A defensive, frozen in-memory status snapshot; mutating it cannot change the controller. */
+    status() {
+        const blockers = [];
+        if (!this.#active)
+            blockers.push('not_frozen');
+        if (this.#native.settled !== 'yes') {
+            blockers.push(this.#native.settled === 'unknown' ? 'settled_unknown' : 'not_settled');
+        }
+        if (this.#native.queuedMessages !== 0) {
+            blockers.push(this.#native.queuedMessages === 'unknown'
+                ? 'queue_unknown'
+                : 'queue_nonempty');
+        }
+        if (this.#native.inFlightTools !== 0) {
+            blockers.push(this.#native.inFlightTools === 'unknown'
+                ? 'inflight_unknown'
+                : 'inflight_present');
+        }
+        if (this.#native.pendingApprovals !== 0) {
+            blockers.push(this.#native.pendingApprovals === 'unknown'
+                ? 'approvals_unknown'
+                : 'approvals_pending');
+        }
+        return Object.freeze({
+            schema: PI_ROLLOVER_FREEZE_STATUS_SCHEMA,
+            sessionId: this.#sessionId,
+            frozen: this.#active !== null,
+            token: this.#active ? copyToken(this.#active) : null,
+            native: Object.freeze({ ...this.#native }),
+            lastAcceptedSequence: this.#lastAcceptedSequence,
+            ready: blockers.length === 0,
+            readyBlockers: Object.freeze(blockers),
+            observationSource: 'caller-supplied-unauthenticated',
+            readinessIsNativeStopProof: false,
+            thawSupported: false,
+            limitations: LIMITATIONS,
+        });
+    }
+}
+/** Pinned installed API: the running session id is read from `ctx.sessionManager.getSessionId()`. */
+function getContextSessionId(context) {
+    if (typeof context !== 'object' || context === null)
+        return null;
+    const manager = context.sessionManager;
+    if (typeof manager === 'object' &&
+        manager !== null &&
+        'getSessionId' in manager &&
+        typeof manager.getSessionId === 'function') {
+        const value = manager.getSessionId();
+        return typeof value === 'string' ? value : null;
+    }
+    return null;
+}
+function notify(context, message) {
+    if (typeof context === 'object' &&
+        context !== null &&
+        'ui' in context &&
+        typeof context.ui === 'object' &&
+        context.ui !== null) {
+        const ui = context.ui;
+        if (typeof ui.notify === 'function') {
+            ui.notify(message, 'info');
+        }
+    }
+}
+function parseFreezeToken(args) {
+    let raw;
+    try {
+        raw = JSON.parse(args);
+    }
+    catch {
+        return { ok: false, detail: 'freeze argument must be a JSON token object' };
+    }
+    if (!isValidToken(raw)) {
+        return {
+            ok: false,
+            detail: 'freeze token requires sessionId, taskId, handoffId and an integer generation',
+        };
+    }
+    return { ok: true, token: copyToken(raw) };
+}
+/**
+ * Concrete registration entry for a later explicit integration. Wires the controller to the Pi
+ * `tool_call` barrier (revalidating the live session on every call) and to validated
+ * `/rollover-freeze` and `/rollover-status` commands. There is intentionally NO thaw command.
+ * Returns the controller (the no-I/O orchestration surface). It only touches the supplied `pi`.
+ */
+export function registerPiRolloverFreeze(pi, options) {
+    if (options.controller &&
+        options.controller.sessionId !== options.sessionId) {
+        throw new RangeError('injected controller session does not match the registration session');
+    }
+    const controller = options.controller ?? new RolloverFreezeController(options);
+    pi.on('tool_call', async (event, context) => {
+        const decision = controller.decideToolCall(event.toolName, getContextSessionId(context));
+        if (decision.block && decision.reason !== null) {
+            return { block: true, reason: decision.reason };
+        }
+        return undefined;
+    });
+    pi.registerCommand('rollover-freeze', {
+        description: 'Latch a managed-tool freeze for a rollover handoff (JSON token: sessionId, taskId, handoffId, generation).',
+        handler: (args, context) => {
+            const parsed = parseFreezeToken(args);
+            if (!parsed.ok) {
+                notify(context, `rollover-freeze rejected: ${parsed.detail}`);
+                return;
+            }
+            const contextSession = getContextSessionId(context);
+            if (contextSession !== controller.sessionId ||
+                contextSession !== parsed.token.sessionId) {
+                controller.invalidateReadiness();
+                notify(context, `rollover-freeze rejected: session mismatch (context ${contextSession ?? 'missing'})`);
+                return;
+            }
+            const outcome = controller.freeze(parsed.token);
+            notify(context, outcome.ok
+                ? `rollover-freeze ${outcome.state}${outcome.idempotent ? ' (idempotent)' : ''}`
+                : `rollover-freeze rejected: ${outcome.reason} (${outcome.detail})`);
+        },
+    });
+    pi.registerCommand('rollover-status', {
+        description: 'Report the in-memory managed-tool freeze and advisory readiness status.',
+        handler: (_args, context) => {
+            if (getContextSessionId(context) !== controller.sessionId) {
+                controller.invalidateReadiness();
+            }
+            notify(context, JSON.stringify(controller.status()));
+        },
+    });
+    return controller;
+}

package/dist/hosts/integration/recovery-config.d.ts

@@ -0,0 +1,48 @@
+import type { Identity } from '../../collab/types.js';
+export declare const PI_RECOVERY_CONFIG_SCHEMA: 'pappra/pi-recovery-config/1';
+/** Bound for the sibling `recovery.json`; bundle export pins the same limit. */
+export declare const PI_RECOVERY_MAX_CONFIG_BYTES: number;
+export type PiRecoveryRole = 'writer' | 'coordinator' | 'reviewer';
+export type PiRecoveryMode = 'plan' | 'apply';
+export interface PiRecoveryPolicy {
+    readonly role: PiRecoveryRole;
+    /** When present, only these subtask ids are projected; everything else is ignored. */
+    readonly authorizedSubtasks?: readonly string[];
+}
+export interface PiRecoveryExpected {
+    readonly session_id: string;
+    readonly cwd: string;
+    readonly binding_ref: string;
+    readonly binding_digest: string;
+    readonly pane_id: string;
+    readonly harness: string;
+}
+export interface PiRecoveryConfig {
+    readonly schema: typeof PI_RECOVERY_CONFIG_SCHEMA;
+    readonly taskRoot: string;
+    readonly planFile: string;
+    readonly self: Identity;
+    readonly policy: PiRecoveryPolicy;
+    readonly expected: PiRecoveryExpected;
+    readonly mode: PiRecoveryMode;
+    readonly target: {
+        readonly agent: string;
+    };
+    readonly requestId: string;
+}
+export type PiRecoveryConfigLoad = {
+    readonly ok: true;
+    readonly config: PiRecoveryConfig;
+    readonly digest: string;
+} | {
+    readonly ok: false;
+    readonly code: string;
+    readonly message: string;
+};
+/**
+ * Strict shape check for one recovery configuration document. Unknown fields are
+ * rejected by construction: every accepted field is read explicitly below.
+ */
+export declare function validatePiRecoveryConfig(parsed: unknown): PiRecoveryConfig | null;
+/** Read and validate the sibling recovery configuration through the bounded no-follow reader. */
+export declare function readPiRecoveryConfig(file: string): PiRecoveryConfigLoad;

package/dist/hosts/integration/recovery-config.js

@@ -0,0 +1,117 @@
+// Lower-layer recovery configuration contract.
+//
+// The opt-in Pi recovery bundle is validated here rather than in the
+// orchestration layer: `bundle-export` runs inside `src/hosts` and must read,
+// validate and pin the exact configuration bytes without importing `src/app`,
+// and the adapter that composes the Pi extension reuses this same reader, so
+// the format has exactly one definition.
+//
+// Role and mode are declared structurally. The orchestration layer keeps its own
+// enums (`RecoveryRole`, `RecoveryExecutionMode`) and accepts these shapes as-is,
+// which is why this module must stay free of application imports.
+import path from 'node:path';
+import { readBoundedFile } from '../../infra/bounded-file.js';
+export const PI_RECOVERY_CONFIG_SCHEMA = 'pappra/pi-recovery-config/1';
+/** Bound for the sibling `recovery.json`; bundle export pins the same limit. */
+export const PI_RECOVERY_MAX_CONFIG_BYTES = 64 * 1024;
+function isIdentity(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        typeof value.agent_id === 'string' &&
+        typeof value.session_id === 'string' &&
+        (typeof value.harness === 'string' ||
+            value.harness === null));
+}
+/**
+ * Strict shape check for one recovery configuration document. Unknown fields are
+ * rejected by construction: every accepted field is read explicitly below.
+ */
+export function validatePiRecoveryConfig(parsed) {
+    if (typeof parsed !== 'object' || parsed === null)
+        return null;
+    const raw = parsed;
+    if (raw.schema !== PI_RECOVERY_CONFIG_SCHEMA)
+        return null;
+    if (typeof raw.taskRoot !== 'string' || typeof raw.planFile !== 'string')
+        return null;
+    if (!isIdentity(raw.self))
+        return null;
+    const policy = raw.policy;
+    if (typeof policy !== 'object' ||
+        policy === null ||
+        (policy.role !== 'writer' &&
+            policy.role !== 'coordinator' &&
+            policy.role !== 'reviewer'))
+        return null;
+    const expected = raw.expected;
+    if (typeof expected !== 'object' ||
+        expected === null ||
+        Object.keys(expected).sort().join('|') !==
+            'binding_digest|binding_ref|cwd|harness|pane_id|session_id' ||
+        typeof expected.session_id !== 'string' ||
+        expected.session_id.length === 0 ||
+        typeof expected.cwd !== 'string' ||
+        !path.isAbsolute(expected.cwd) ||
+        typeof expected.binding_ref !== 'string' ||
+        !path.isAbsolute(expected.binding_ref) ||
+        typeof expected.binding_digest !== 'string' ||
+        !/^sha256:[0-9a-f]{64}$/.test(expected.binding_digest) ||
+        typeof expected.pane_id !== 'string' ||
+        !/^[A-Za-z0-9]+:p[A-Za-z0-9]+$/.test(expected.pane_id) ||
+        typeof expected.harness !== 'string' ||
+        expected.harness.length === 0)
+        return null;
+    if (raw.mode !== 'plan' && raw.mode !== 'apply')
+        return null;
+    const target = raw.target;
+    if (typeof target !== 'object' ||
+        target === null ||
+        typeof target.agent !== 'string')
+        return null;
+    if (typeof raw.requestId !== 'string' || raw.requestId.length === 0)
+        return null;
+    return {
+        schema: PI_RECOVERY_CONFIG_SCHEMA,
+        taskRoot: raw.taskRoot,
+        planFile: raw.planFile,
+        self: {
+            agent_id: raw.self.agent_id,
+            session_id: raw.self.session_id,
+            harness: raw.self.harness,
+        },
+        policy: {
+            role: policy.role,
+            ...(Array.isArray(policy.authorizedSubtasks)
+                ? { authorizedSubtasks: [...policy.authorizedSubtasks] }
+                : {}),
+        },
+        expected: {
+            session_id: expected.session_id,
+            cwd: expected.cwd,
+            binding_ref: expected.binding_ref,
+            binding_digest: expected.binding_digest,
+            pane_id: expected.pane_id,
+            harness: expected.harness,
+        },
+        mode: raw.mode,
+        target: { agent: target.agent },
+        requestId: raw.requestId,
+    };
+}
+/** Read and validate the sibling recovery configuration through the bounded no-follow reader. */
+export function readPiRecoveryConfig(file) {
+    const read = readBoundedFile(file, PI_RECOVERY_MAX_CONFIG_BYTES);
+    if (!read.ok)
+        return { ok: false, code: `config_${read.code}`, message: file };
+    let parsed;
+    try {
+        parsed = JSON.parse(read.text);
+    }
+    catch {
+        return { ok: false, code: 'config_unparseable', message: file };
+    }
+    const config = validatePiRecoveryConfig(parsed);
+    if (config === null)
+        return { ok: false, code: 'config_invalid', message: file };
+    return { ok: true, config, digest: read.digest };
+}

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

@@ -1,5 +1,6 @@
-import type { HostCapabilities, HostInstallManifest, HostIntegrationPlan, HostIntegrationResult, HostName, HostVerification } from '../../schemas/host.js';
+import type { HostCapabilities, HostInstallManifest, HostIntegrationPlan, HostIntegrationResult, HostName, HostVerification, HostUninstallResult } from '../../schemas/host.js';
 export interface HostIntegrationOptions {
+    readonly versionProbe?: (host: HostName) => string | null;
     readonly root: string;
     readonly homeDir: string;
     readonly pathEnv: string;
@@ -36,6 +37,10 @@ export declare class HostIntegrationService {
         readonly apply: boolean;
     }): Promise<HostIntegrationResult>;
     verify(host: HostName, options?: HostTargetOptions): Promise<HostVerification>;
+    uninstall(host: HostName, options: HostTargetOptions & {
+        readonly apply: boolean;
+        readonly force?: boolean;
+    }): Promise<HostUninstallResult>;
     readManifest(hostRoot: string): Promise<HostInstallManifest | null>;
 }
 export declare class HostAdapter {