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

package/dist/app/managed-pi-source-admission.js

@@ -0,0 +1,323 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { createHash } from 'node:crypto';
+import { isAssignment, isCard, } from '../collab/contracts.js';
+import { canonicalJson } from '../collab/envelope.js';
+import { transact } from '../collab/store.js';
+import { ManagedPiSdkSessionController } from '../hosts/pi/managed-sdk-session.js';
+import { validateSuccession } from './collab-route.js';
+import { readBoundedFile } from './bounded-file.js';
+import { openTaskStore, assertTaskStoreCurrent } from './collab-task-store.js';
+const FIELD = 'managed_pi_source_admissions';
+const object = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+const same = (a, b) => a.agent_id === b.agent_id &&
+    a.session_id === b.session_id &&
+    a.harness === b.harness;
+const samePath = (a, b) => path.resolve(a) === path.resolve(b);
+const digest = (text) => `sha256:${createHash('sha256').update(text).digest('hex')}`;
+function rows(record) {
+    const value = record[FIELD];
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value) ||
+        value.length > 32 ||
+        !value.every((row) => object(row) &&
+            row.schema === 'pappra/managed-source-admission/1' &&
+            object(row.actor) &&
+            object(row.scope) &&
+            Array.isArray(row.claims) &&
+            row.claims.length > 0 &&
+            row.claims.length <= 1024))
+        throw new Error('managed_source_admissions_invalid');
+    return value;
+}
+function origin(attempt) {
+    if (!attempt.assignment_ref || !attempt.assignment_digest)
+        throw new Error('managed_source_origin_missing');
+    const bytes = readBoundedFile(attempt.assignment_ref, 1024 * 1024);
+    if (!bytes.ok || bytes.digest !== attempt.assignment_digest)
+        throw new Error('managed_source_origin_changed');
+    const value = JSON.parse(bytes.text);
+    if (!isAssignment(value))
+        throw new Error('managed_source_origin_invalid');
+    return {
+        assignment: value,
+        digest: bytes.digest,
+        file: attempt.assignment_ref,
+    };
+}
+function predecessor(record, actor, handoffId) {
+    const matches = (record.successions ?? []).filter((entry) => entry.successor_native.agent_id === actor.agent_id &&
+        entry.successor_native.session_id === actor.session_id &&
+        (handoffId === undefined || entry.handoff_id === handoffId));
+    if (matches.length !== 1)
+        throw new Error('managed_source_succession_missing_or_ambiguous');
+    const checked = validateSuccession(record, matches[0]);
+    if (!checked.ok)
+        throw new Error('managed_source_succession_unverified');
+    return checked;
+}
+function derived(base, entry) {
+    if (base.task_id !== entry.task_id ||
+        base.attempt !== entry.attempt ||
+        base.coordinator.owner_epoch !== entry.owner_epoch ||
+        !samePath(base.assignee.cwd, entry.actor.cwd) ||
+        base.resources.length !== entry.claims.length)
+        throw new Error('managed_source_derivation_scope_mismatch');
+    return {
+        ...structuredClone(base),
+        assignee: { ...entry.actor },
+        resources: base.resources.map((resource) => {
+            const claims = entry.claims.filter((claim) => samePath(claim.path, resource.path) &&
+                claim.access === resource.access);
+            if (claims.length !== 1)
+                throw new Error('managed_source_derivation_claim_mismatch');
+            return { ...resource, resource_epoch: claims[0].resource_epoch };
+        }),
+    };
+}
+/** Original ASSIGN pins stay immutable. A completed succession permits a bounded current-source view. */
+export function readManagedSourceAssignment(record, attempt, actor = attempt.assignee) {
+    const base = origin(attempt);
+    if (same(base.assignment.assignee, actor))
+        return { ...base, originalDigest: base.digest };
+    const matches = rows(record).filter((entry) => same(entry.actor, actor) &&
+        entry.subtask_id === attempt.subtask_id &&
+        entry.attempt === attempt.attempt);
+    if (matches.length !== 1)
+        throw new Error('managed_source_admission_missing_or_ambiguous');
+    const entry = matches[0];
+    const lineage = predecessor(record, actor, entry.predecessor_handoff_id);
+    const runtime = record.managed_pi_runtime_registry;
+    if (!Array.isArray(runtime) ||
+        !runtime.some((row) => object(row) &&
+            row.session_id === actor.session_id &&
+            row.controller_run_id === entry.controller_run_id &&
+            canonicalJson(row.scope) === canonicalJson(entry.scope)) ||
+        entry.origin_ref !== base.file ||
+        entry.origin_digest !== base.digest ||
+        entry.task_id !== record.task_id ||
+        entry.input_revision !== attempt.input_revision ||
+        entry.owner_epoch !== attempt.owner_epoch ||
+        entry.predecessor_proof_digest !== lineage.exclusion.proof_digest ||
+        entry.claims.length !== lineage.intent.claims.length ||
+        !entry.claims.every((claim) => lineage.intent.claims.some((old) => old.claim_id === claim.claim_id &&
+            old.resource_epoch + 1 === claim.resource_epoch) &&
+            record.claims.some((stored) => stored.claim_id === claim.claim_id &&
+                stored.key === claim.key &&
+                stored.path !== null &&
+                stored.path !== undefined &&
+                samePath(stored.path, claim.path) &&
+                stored.access === claim.access)))
+        throw new Error('managed_source_admission_lineage_mismatch');
+    const file = readBoundedFile(entry.assignment_ref, 1024 * 1024);
+    if (!file.ok || file.digest !== entry.assignment_digest)
+        throw new Error('managed_source_assignment_changed');
+    const assignment = JSON.parse(file.text);
+    if (!isAssignment(assignment) ||
+        canonicalJson(assignment) !== canonicalJson(derived(base.assignment, entry)))
+        throw new Error('managed_source_assignment_derivation_mismatch');
+    return {
+        assignment,
+        digest: file.digest,
+        file: entry.assignment_ref,
+        originalDigest: base.digest,
+    };
+}
+function writeImmutable(file, value) {
+    const parent = fs.lstatSync(path.dirname(file));
+    if (!path.isAbsolute(file) ||
+        !parent.isDirectory() ||
+        parent.isSymbolicLink() ||
+        parent.mode & 0o077 ||
+        fs.realpathSync(path.dirname(file)) !== path.dirname(file))
+        throw new Error('managed_source_output_not_private');
+    const text = `${canonicalJson(value)}\n`;
+    if (fs.lstatSync(file, { throwIfNoEntry: false })) {
+        const old = readBoundedFile(file, 1024 * 1024);
+        if (!old.ok || old.digest !== digest(text))
+            throw new Error('managed_source_output_conflict');
+    }
+    else {
+        const fd = fs.openSync(file, 'wx', 0o600);
+        try {
+            fs.writeFileSync(fd, text);
+            fs.fsyncSync(fd);
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+        const directory = fs.openSync(path.dirname(file), 'r');
+        try {
+            fs.fsyncSync(directory);
+        }
+        finally {
+            fs.closeSync(directory);
+        }
+    }
+    return digest(text);
+}
+/** Called only inside the successor's owned SDK process after its real first work. */
+export async function admitManagedSourceAssignment(controller, scope, readiness) {
+    const native = controller.observe();
+    if (!(controller instanceof ManagedPiSdkSessionController) ||
+        controller.isDisposed ||
+        controller.snapshot().process.pid !== process.pid ||
+        native.native.sessionId !== scope.session_id ||
+        native.cwd !== scope.cwd ||
+        !native.native.agentId ||
+        !native.native.surface ||
+        !native.native.configurationId)
+        throw new Error('managed_source_runtime_not_owned');
+    const opened = await openTaskStore(scope.task_root);
+    if (!opened.ok)
+        throw new Error('managed_source_task_unavailable');
+    const record = opened.value.record;
+    const attempt = record.attempts.find((row) => row.subtask_id === scope.subtask_id && row.attempt === scope.attempt);
+    if (!attempt ||
+        attempt.assignee.session_id !== native.native.sessionId ||
+        attempt.assignee.agent_id !== native.native.agentId ||
+        attempt.assignee.harness !== 'pi' ||
+        attempt.owner_epoch !== scope.owner_epoch ||
+        record.coordinator?.owner_epoch !== scope.owner_epoch ||
+        !attempt.input_revision ||
+        !['assigned', 'accepted', 'running'].includes(attempt.state) ||
+        attempt.awaiting ||
+        attempt.cancel_requested_at)
+        throw new Error('managed_source_authority_changed');
+    const lineage = predecessor(record, attempt.assignee);
+    const base = origin(attempt);
+    const registered = Array.isArray(record.managed_pi_runtime_registry)
+        ? record.managed_pi_runtime_registry.filter((row) => object(row) &&
+            row.session_id === scope.session_id &&
+            canonicalJson(row.scope) === canonicalJson(scope))
+        : [];
+    if (registered.length !== 1 ||
+        !object(registered[0]) ||
+        typeof registered[0].controller_run_id !== 'string')
+        throw new Error('managed_source_runtime_unregistered');
+    const claims = scope.claim_epochs.map((pin) => {
+        const claim = record.claims.find((row) => row.claim_id === pin.claim_id &&
+            row.resource_epoch === pin.resource_epoch &&
+            !row.released_at &&
+            !row.cancel_pending &&
+            same(row.holder, attempt.assignee) &&
+            row.subtask_id === scope.subtask_id &&
+            row.attempt === scope.attempt);
+        if (!claim?.path)
+            throw new Error('managed_source_claim_changed');
+        return {
+            claim_id: claim.claim_id,
+            resource_epoch: claim.resource_epoch,
+            path: claim.path,
+            access: claim.access,
+            key: claim.key,
+        };
+    });
+    const entryBase = {
+        schema: 'pappra/managed-source-admission/1',
+        task_id: record.task_id,
+        subtask_id: scope.subtask_id,
+        attempt: scope.attempt,
+        input_revision: attempt.input_revision,
+        owner_epoch: scope.owner_epoch,
+        origin_ref: base.file,
+        origin_digest: base.digest,
+        assignment_ref: readiness.assignmentFile,
+        actor: {
+            ...attempt.assignee,
+            harness: 'pi',
+            cwd: native.cwd,
+            surface: native.native.surface,
+            configuration_id: native.native.configurationId,
+        },
+        scope,
+        controller_run_id: registered[0].controller_run_id,
+        predecessor_handoff_id: lineage.intent.handoff_id,
+        predecessor_proof_digest: lineage.exclusion.proof_digest,
+        claims,
+    };
+    const assignment = derived(base.assignment, {
+        ...entryBase,
+        assignment_digest: '',
+    });
+    const entry = {
+        ...entryBase,
+        assignment_digest: writeImmutable(readiness.assignmentFile, assignment),
+    };
+    // Reuse the approved parent catalog only as a declaration. The actual child SDK
+    // observation must independently promote every capability used by preflight.
+    if (!fs.existsSync(readiness.templateFile)) {
+        const launch = (record.launch_reservations ?? []).filter((row) => row.requested_session_id === scope.session_id);
+        const bootstrap = launch.length === 1 ? launch[0]?.bootstrap : null;
+        if (!object(bootstrap) || typeof bootstrap.request_file !== 'string')
+            throw new Error('managed_source_parent_request_missing');
+        const request = readBoundedFile(bootstrap.request_file, 64 * 1024);
+        if (!request.ok || request.digest !== bootstrap.request_digest)
+            throw new Error('managed_source_parent_request_changed');
+        const parsed = JSON.parse(request.text);
+        if (!object(parsed) ||
+            !object(parsed.admission) ||
+            typeof parsed.admission.capability_card_ref !== 'string')
+            throw new Error('managed_source_parent_card_missing');
+        const bytes = readBoundedFile(parsed.admission.capability_card_ref, 1024 * 1024);
+        if (!bytes.ok || bytes.digest !== parsed.admission.capability_card_digest)
+            throw new Error('managed_source_parent_card_changed');
+        const card = JSON.parse(bytes.text);
+        if (!isCard(card))
+            throw new Error('managed_source_parent_card_invalid');
+        const declare = (item) => {
+            const { evidence_ref: _evidence, ...rest } = item;
+            return { ...rest, state: 'declared' };
+        };
+        writeImmutable(readiness.templateFile, {
+            schema: 'harness-collab/capabilities/1',
+            ...entry.actor,
+            observed_at: new Date().toISOString(),
+            evidence_level: 'declared',
+            skills: card.skills.map(declare),
+            tools: card.tools.map(declare),
+        });
+    }
+    if (await assertTaskStoreCurrent(opened.value))
+        throw new Error('managed_source_task_namespace_changed');
+    const saved = transact(scope.task_root, {
+        actor: native.native.agentId,
+        purpose: 'record-managed-source-admission',
+        apply(current) {
+            const active = current.attempts.find((row) => row.subtask_id === scope.subtask_id && row.attempt === scope.attempt);
+            if (!active ||
+                !same(active.assignee, entry.actor) ||
+                active.owner_epoch !== scope.owner_epoch ||
+                active.input_revision !== entry.input_revision ||
+                !['assigned', 'accepted', 'running'].includes(active.state) ||
+                active.awaiting ||
+                active.cancel_requested_at ||
+                current.coordinator?.owner_epoch !== scope.owner_epoch ||
+                canonicalJson(predecessor(current, active.assignee, entry.predecessor_handoff_id)) !== canonicalJson(lineage) ||
+                !Array.isArray(current.managed_pi_runtime_registry) ||
+                canonicalJson(current.managed_pi_runtime_registry.filter((row) => object(row) &&
+                    row.session_id === scope.session_id &&
+                    canonicalJson(row.scope) === canonicalJson(scope))) !== canonicalJson(registered) ||
+                !claims.every((pin) => current.claims.some((row) => row.claim_id === pin.claim_id &&
+                    row.resource_epoch === pin.resource_epoch &&
+                    !row.released_at &&
+                    !row.cancel_pending &&
+                    same(row.holder, entry.actor))))
+                return { ok: false, reason: 'managed_source_admission_stale' };
+            const entries = rows(current);
+            const old = entries.find((row) => row.actor.session_id === entry.actor.session_id);
+            if (old && canonicalJson(old) !== canonicalJson(entry))
+                return { ok: false, reason: 'managed_source_admission_conflict' };
+            if (!old) {
+                if (entries.length >= 32)
+                    return { ok: false, reason: 'managed_source_admission_limit' };
+                entries.push(entry);
+            }
+            current[FIELD] = entries;
+            return { record: current, result: null };
+        },
+    });
+    if (!saved.ok)
+        throw new Error(saved.reason);
+}

package/dist/app/managed-pi-transition-host.d.ts

@@ -0,0 +1,36 @@
+import type { ManagedPiExecutionScope, SessionTransitionHost, SessionTransitionQuiescenceProof } from './collab-session-transition.js';
+import type { ManagedPiSdkRolloverInventory, ManagedPiSdkSessionSnapshot } from '../hosts/pi/managed-sdk-session.js';
+import type { RolloverFreezeController } from '../hosts/integration/pi-rollover-extension.js';
+export declare const MANAGED_PI_TRANSITION_HOST_ID: 'pappra/managed-pi-session-transition-host/2';
+export interface ManagedPiTransitionControllerPort {
+    readonly cwd?: string;
+    observe(): {
+        readonly native: {
+            readonly sessionId: string;
+            readonly paneId?: string | null;
+        };
+        readonly cwd: string;
+    };
+    snapshot(): ManagedPiSdkSessionSnapshot;
+    inventory(): Promise<ManagedPiSdkRolloverInventory>;
+    quiesce(reason?: string): Promise<ManagedPiSdkSessionSnapshot>;
+    fenceIngress(reason?: string): void;
+}
+export interface BoundManagedPiExecutionScope {
+    readonly scope: ManagedPiExecutionScope;
+}
+export interface BindManagedPiExecutionScopeInput {
+    readonly controller: ManagedPiTransitionControllerPort;
+    readonly scope: ManagedPiExecutionScope;
+}
+export interface CreateManagedPiTransitionHostInput {
+    readonly controller: ManagedPiTransitionControllerPort;
+    readonly freezeController: Pick<RolloverFreezeController, 'sessionId' | 'freeze' | 'status'>;
+    readonly binding: BoundManagedPiExecutionScope;
+}
+/** Bind the explicitly selected live SDK runtime to authoritative task pins before TUI startup. */
+export declare function bindManagedPiExecutionScope(input: BindManagedPiExecutionScopeInput): Promise<BoundManagedPiExecutionScope>;
+/** Build an in-process host whose v2 proof can only be minted from fresh live SDK snapshots. */
+export declare function createManagedPiTransitionHost(input: CreateManagedPiTransitionHostInput): SessionTransitionHost;
+/** Used by the guarded transition to reject serialized or caller-constructed v2 proof objects. */
+export declare function isTrustedManagedPiScopedProof(value: unknown): value is SessionTransitionQuiescenceProof;

package/dist/app/managed-pi-transition-host.js

@@ -0,0 +1,292 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import { createHash } from 'node:crypto';
+import { canonicalJson } from '../collab/envelope.js';
+import { findAttempt } from '../collab/lifecycle.js';
+import { openTaskStore } from './collab-task-store.js';
+export const MANAGED_PI_TRANSITION_HOST_ID = 'pappra/managed-pi-session-transition-host/2';
+const OWNED_SCOPE = 'pinned_pi_1_4_owned_runtime';
+const EXCLUDED_SCOPE = Object.freeze([
+    'arbitrary_external_writers',
+    'unowned_processes_and_descendants',
+]);
+const BINDINGS = new WeakSet();
+const LIVE_PROOFS = new WeakSet();
+function digest(value) {
+    return `sha256:${createHash('sha256').update(canonicalJson(value)).digest('hex')}`;
+}
+function samePath(left, right) {
+    try {
+        return fs.realpathSync(left) === fs.realpathSync(right);
+    }
+    catch {
+        return false;
+    }
+}
+function cloneScope(scope) {
+    return Object.freeze({
+        schema: scope.schema,
+        task_id: scope.task_id,
+        task_root: scope.task_root,
+        session_id: scope.session_id,
+        cwd: scope.cwd,
+        subtask_id: scope.subtask_id,
+        attempt: scope.attempt,
+        owner_epoch: scope.owner_epoch,
+        claim_epochs: Object.freeze(scope.claim_epochs.map((claim) => Object.freeze({
+            claim_id: claim.claim_id,
+            resource_epoch: claim.resource_epoch,
+        }))),
+    });
+}
+function validateScopeShape(scope) {
+    if (scope.schema !== 'pappra/managed-pi-execution-scope/1' ||
+        !scope.task_id ||
+        !path.isAbsolute(scope.task_root) ||
+        !scope.session_id ||
+        !path.isAbsolute(scope.cwd) ||
+        !scope.subtask_id ||
+        !Number.isSafeInteger(scope.attempt) ||
+        scope.attempt < 1 ||
+        !Number.isSafeInteger(scope.owner_epoch) ||
+        scope.owner_epoch <= 0 ||
+        !Array.isArray(scope.claim_epochs) ||
+        scope.claim_epochs.length === 0)
+        throw new TypeError('managed_pi_execution_scope_invalid');
+    const seen = new Set();
+    for (const claim of scope.claim_epochs) {
+        if (!claim.claim_id ||
+            !Number.isSafeInteger(claim.resource_epoch) ||
+            claim.resource_epoch <= 0 ||
+            seen.has(claim.claim_id))
+            throw new TypeError('managed_pi_execution_scope_claims_invalid');
+        seen.add(claim.claim_id);
+    }
+}
+/** Bind the explicitly selected live SDK runtime to authoritative task pins before TUI startup. */
+export async function bindManagedPiExecutionScope(input) {
+    const { controller, scope } = input;
+    validateScopeShape(scope);
+    if (path.basename(scope.task_root) !== scope.task_id)
+        throw new TypeError('managed_pi_execution_scope_task_mismatch');
+    const live = controller.observe();
+    const snapshot = controller.snapshot();
+    if (live.native.sessionId !== scope.session_id ||
+        !samePath(live.cwd, scope.cwd) ||
+        snapshot.session.sessionId !== scope.session_id)
+        throw new TypeError('managed_pi_execution_scope_runtime_mismatch');
+    assertCleanPrelaunchRuntime(snapshot);
+    const liveInventory = await controller.inventory();
+    if (liveInventory.completeness !== 'complete' ||
+        liveInventory.inflight.length !== 0 ||
+        liveInventory.pending_approvals.length !== 0 ||
+        (liveInventory.pending_messages?.length ?? -1) !== 0)
+        throw new TypeError('managed_pi_execution_scope_runtime_busy_or_unknown');
+    const opened = await openTaskStore(scope.task_root);
+    if (!opened.ok)
+        throw new TypeError(`managed_pi_execution_scope_task_unavailable:${opened.code}`);
+    const record = opened.value.record;
+    if (record.task_id !== scope.task_id ||
+        !samePath(record.task_root, scope.task_root))
+        throw new TypeError('managed_pi_execution_scope_task_mismatch');
+    if (!Number.isSafeInteger(scope.owner_epoch) ||
+        scope.owner_epoch <= 0 ||
+        record.coordinator?.owner_epoch !== scope.owner_epoch)
+        throw new TypeError('managed_pi_execution_scope_owner_epoch_stale');
+    const attempt = findAttempt(record, scope.subtask_id, scope.attempt);
+    const latestAttempt = (record.attempts ?? [])
+        .filter((candidate) => candidate.subtask_id === scope.subtask_id)
+        .reduce((latest, candidate) => Math.max(latest, candidate.attempt), 0);
+    if (attempt === null ||
+        latestAttempt !== scope.attempt ||
+        !['assigned', 'accepted', 'running'].includes(attempt.state) ||
+        attempt.owner_epoch !== scope.owner_epoch ||
+        attempt.assignee.harness !== 'pi' ||
+        attempt.assignee.session_id !== scope.session_id ||
+        (attempt.assignee.cwd !== undefined && attempt.assignee.cwd !== scope.cwd))
+        throw new TypeError('managed_pi_execution_scope_attempt_mismatch');
+    if (scope.claim_epochs.length === 0)
+        throw new TypeError('managed_pi_execution_scope_claims_empty');
+    const currentClaims = (record.claims ?? []).filter((claim) => scope.claim_epochs.some((pin) => pin.claim_id === claim.claim_id));
+    if (currentClaims.length !== scope.claim_epochs.length)
+        throw new TypeError('managed_pi_execution_scope_claim_set_mismatch');
+    for (const pin of scope.claim_epochs) {
+        const claim = currentClaims.find((candidate) => candidate.claim_id === pin.claim_id);
+        if (pin.resource_epoch <= 0 ||
+            claim === undefined ||
+            claim.released_at !== null ||
+            claim.subtask_id !== scope.subtask_id ||
+            claim.attempt !== scope.attempt ||
+            (claim.resource_epoch ?? 0) !== pin.resource_epoch ||
+            claim.holder.agent_id !== attempt.assignee.agent_id ||
+            claim.holder.session_id !== attempt.assignee.session_id ||
+            claim.holder.harness !== 'pi')
+            throw new TypeError('managed_pi_execution_scope_claim_epoch_stale');
+    }
+    const frozen = Object.freeze({ scope: cloneScope(scope) });
+    BINDINGS.add(frozen);
+    return frozen;
+}
+function assertCleanPrelaunchRuntime(snapshot) {
+    const { queues, work, extensionDialogs, builtInUiApprovals } = snapshot.ownedRuntime;
+    const internal = queues.internal;
+    const queueCounts = [
+        internal.pendingNextTurn?.length,
+        internal.pendingCustom?.length,
+        internal.pendingBash?.length,
+        internal.deferredSettledActionCount,
+        internal.pendingUserInputs?.length,
+        internal.compactionMessages?.length,
+        queues.steering.length,
+        queues.followUp.length,
+    ];
+    if (!snapshot.ingress.healthy ||
+        snapshot.ingress.state !== 'open' ||
+        snapshot.ownedRuntime.queues.pendingMessageCount !== 0 ||
+        queues.completeness !== 'complete' ||
+        work.observation !== 'complete' ||
+        extensionDialogs.completeness !== 'complete' ||
+        builtInUiApprovals.observation !== 'complete' ||
+        !work.isIdle ||
+        work.isStreaming ||
+        work.isCompacting ||
+        work.isBashRunning !== false ||
+        work.hasPendingBashMessages !== false ||
+        work.pendingToolCalls !== 0 ||
+        queueCounts.some((count) => count === null || count === undefined || count !== 0) ||
+        extensionDialogs.pending.length !== 0 ||
+        internal.extensionDialogCount !== 0 ||
+        internal.activeSelector !== false)
+        throw new TypeError('managed_pi_execution_scope_runtime_busy_or_unknown');
+}
+function isBound(binding) {
+    return (typeof binding === 'object' && binding !== null && BINDINGS.has(binding));
+}
+function deepFreeze(value) {
+    if (typeof value !== 'object' || value === null || Object.isFrozen(value))
+        return value;
+    for (const child of Object.values(value))
+        deepFreeze(child);
+    return Object.freeze(value);
+}
+function asRolloverInventory(value) {
+    return deepFreeze({
+        completeness: value.completeness,
+        inflight: [...value.inflight],
+        pending_approvals: [...value.pending_approvals],
+        pending_messages: value.pending_messages === undefined
+            ? undefined
+            : [...value.pending_messages],
+        partial_outputs: value.partial_outputs === undefined
+            ? undefined
+            : [...value.partial_outputs],
+    });
+}
+function freezeStatus(controller) {
+    return controller.status();
+}
+/** Build an in-process host whose v2 proof can only be minted from fresh live SDK snapshots. */
+export function createManagedPiTransitionHost(input) {
+    if (!isBound(input.binding))
+        throw new TypeError('managed_pi_execution_scope_binding_untrusted');
+    const scope = input.binding.scope;
+    if (input.freezeController.sessionId !== scope.session_id)
+        throw new TypeError('managed_pi_transition_freeze_session_mismatch');
+    let observationSequence = 0;
+    const identity = () => {
+        const observed = input.controller.observe();
+        const snapshot = input.controller.snapshot();
+        return { observed, snapshot };
+    };
+    return Object.freeze({
+        id: MANAGED_PI_TRANSITION_HOST_ID,
+        async observe() {
+            const { observed, snapshot } = identity();
+            if (observed.native.sessionId !== scope.session_id ||
+                !samePath(observed.cwd, scope.cwd) ||
+                snapshot.session.sessionId !== scope.session_id)
+                return {
+                    session_id: observed.native.sessionId ?? null,
+                    cwd: observed.cwd ?? null,
+                    pane_id: observed.native.paneId ?? null,
+                    proof_support: 'unavailable',
+                    proof: null,
+                    freeze_status: freezeStatus(input.freezeController),
+                    native_facts: null,
+                    unavailable_code: 'managed_pi_scope_runtime_mismatch',
+                    detail: 'The live SDK runtime no longer matches its pre-start task-owned binding.',
+                };
+            const status = freezeStatus(input.freezeController);
+            let proof = null;
+            if (status.frozen &&
+                status.token !== null &&
+                status.token.sessionId === scope.session_id) {
+                const inventory = await input.controller.inventory();
+                const fresh = input.controller.snapshot();
+                const sequence = Math.max(++observationSequence, fresh.ingress.sequence);
+                observationSequence = sequence;
+                const proofValue = deepFreeze({
+                    adapter_id: MANAGED_PI_TRANSITION_HOST_ID,
+                    session_id: fresh.session.sessionId,
+                    cwd: observed.cwd,
+                    observed_at: new Date().toISOString(),
+                    sequence,
+                    evidence_ref: `managed-pi-sdk://${scope.session_id}/${sequence}/${fresh.ingress.headDigest}`,
+                    freeze_token: Object.freeze({ ...status.token }),
+                    inventory: asRolloverInventory(inventory),
+                    scope: OWNED_SCOPE,
+                    execution_scope: scope,
+                    execution_scope_digest: digest(scope),
+                    excluded_scope: EXCLUDED_SCOPE,
+                    runtime_quiescent: fresh.scopedQuiescent,
+                    runtime_blockers: Object.freeze([...fresh.blockers]),
+                    controller_sequence: fresh.ingress.sequence,
+                    controller_head_digest: `sha256:${fresh.ingress.headDigest}`,
+                    controller_journal_healthy: fresh.ingress.healthy,
+                });
+                LIVE_PROOFS.add(proofValue);
+                proof = proofValue;
+            }
+            return {
+                session_id: observed.native.sessionId,
+                cwd: observed.cwd,
+                pane_id: observed.native.paneId ?? null,
+                proof_support: 'available',
+                proof,
+                freeze_status: status,
+                native_facts: null,
+                unavailable_code: null,
+                detail: null,
+            };
+        },
+        async freeze(token) {
+            if (token.sessionId !== scope.session_id ||
+                token.taskId !== scope.task_id ||
+                input.freezeController.sessionId !== token.sessionId)
+                return {
+                    ok: false,
+                    reason: 'wrong_session',
+                    detail: 'The freeze token does not match the bound task-owned SDK runtime.',
+                };
+            const { observed, snapshot } = identity();
+            if (observed.native.sessionId !== scope.session_id ||
+                !samePath(observed.cwd, scope.cwd) ||
+                snapshot.session.sessionId !== scope.session_id)
+                return {
+                    ok: false,
+                    reason: 'wrong_session',
+                    detail: 'Live SDK identity drifted from the bound task scope.',
+                };
+            const outcome = input.freezeController.freeze(token);
+            if (!outcome.ok)
+                return outcome;
+            // This is the live controller operation that closes ingress and waits for the pinned SDK runtime.
+            await input.controller.quiesce(`owned_native_takeover:${token.handoffId}:${token.generation}`);
+            return outcome;
+        },
+    });
+}
+/** Used by the guarded transition to reject serialized or caller-constructed v2 proof objects. */
+export function isTrustedManagedPiScopedProof(value) {
+    return typeof value === 'object' && value !== null && LIVE_PROOFS.has(value);
+}