@timurproko/a1 0.2.7-dev.1249 → 0.2.7-dev.1255

package/dist/foundation/resident-tabs/protocol.js

@@ -1,195 +0,0 @@
-const MAX_FRAME_BYTES = 2 * 1024 * 1024;
-const MAX_DEPTH = 64;
-/** Generation-1 MessagePack named-map codec. It intentionally supports only bridge-safe values. */
-export function encodeResidentFrame(value) {
-    const payload = Buffer.from(encodeValue(value, 0));
-    if (payload.length > MAX_FRAME_BYTES)
-        throw new Error("resident frame exceeds 2 MiB");
-    const frame = Buffer.allocUnsafe(payload.length + 4);
-    frame.writeUInt32LE(payload.length, 0);
-    payload.copy(frame, 4);
-    return frame;
-}
-export function decodeResidentPayload(payload) {
-    if (payload.byteLength > MAX_FRAME_BYTES)
-        throw new Error("resident frame exceeds 2 MiB");
-    const state = { bytes: payload, offset: 0 };
-    const value = decodeValue(state, 0);
-    if (state.offset !== payload.byteLength || !isRecord(value) || typeof value.type !== "string" || !isRecord(value.body)) {
-        throw new Error("invalid resident envelope");
-    }
-    return value;
-}
-export class ResidentFrameDecoder {
-    #buffer = Buffer.alloc(0);
-    push(chunk) {
-        this.#buffer = Buffer.concat([this.#buffer, chunk]);
-        const messages = [];
-        while (this.#buffer.length >= 4) {
-            const length = this.#buffer.readUInt32LE(0);
-            if (length > MAX_FRAME_BYTES)
-                throw new Error("resident frame exceeds 2 MiB");
-            if (this.#buffer.length < length + 4)
-                break;
-            messages.push(decodeResidentPayload(this.#buffer.subarray(4, length + 4)));
-            this.#buffer = this.#buffer.subarray(length + 4);
-        }
-        return messages;
-    }
-}
-function encodeValue(value, depth) {
-    if (depth > MAX_DEPTH)
-        throw new Error("resident value exceeds nesting limit");
-    if (value === null)
-        return [0xc0];
-    if (value === false)
-        return [0xc2];
-    if (value === true)
-        return [0xc3];
-    if (typeof value === "number" && Number.isSafeInteger(value))
-        return encodeInteger(value);
-    if (typeof value === "string") {
-        const bytes = [...Buffer.from(value, "utf8")];
-        if (bytes.length < 32)
-            return [0xa0 | bytes.length, ...bytes];
-        if (bytes.length <= 0xff)
-            return [0xd9, bytes.length, ...bytes];
-        if (bytes.length <= 0xffff)
-            return [0xda, bytes.length >>> 8, bytes.length & 0xff, ...bytes];
-        return [0xdb, ...u32(bytes.length), ...bytes];
-    }
-    if (value instanceof Uint8Array) {
-        const bytes = [...value];
-        if (bytes.length <= 0xff)
-            return [0xc4, bytes.length, ...bytes];
-        if (bytes.length <= 0xffff)
-            return [0xc5, bytes.length >>> 8, bytes.length & 0xff, ...bytes];
-        return [0xc6, ...u32(bytes.length), ...bytes];
-    }
-    if (Array.isArray(value)) {
-        const head = value.length < 16 ? [0x90 | value.length] : value.length <= 0xffff ? [0xdc, value.length >>> 8, value.length & 0xff] : [0xdd, ...u32(value.length)];
-        return [...head, ...value.flatMap(entry => encodeValue(entry, depth + 1))];
-    }
-    if (isRecord(value)) {
-        const entries = Object.entries(value).filter(([, child]) => child !== undefined);
-        const head = entries.length < 16 ? [0x80 | entries.length] : entries.length <= 0xffff ? [0xde, entries.length >>> 8, entries.length & 0xff] : [0xdf, ...u32(entries.length)];
-        return [...head, ...entries.flatMap(([key, child]) => [...encodeValue(key, depth + 1), ...encodeValue(child, depth + 1)])];
-    }
-    throw new Error(`unsupported resident value: ${typeof value}`);
-}
-function encodeInteger(value) {
-    if (value >= 0 && value <= 0x7f)
-        return [value];
-    if (value < 0 && value >= -32)
-        return [0x100 + value];
-    if (value >= 0 && value <= 0xff)
-        return [0xcc, value];
-    if (value >= 0 && value <= 0xffff)
-        return [0xcd, value >>> 8, value & 0xff];
-    if (value >= -0x80 && value < 0)
-        return [0xd0, value & 0xff];
-    if (value >= -0x8000 && value < 0)
-        return [0xd1, (value >>> 8) & 0xff, value & 0xff];
-    if (value >= 0 && value <= 0xffffffff)
-        return [0xce, ...u32(value)];
-    return [0xd3, ...i64(value)];
-}
-function decodeValue(state, depth) {
-    if (depth > MAX_DEPTH)
-        throw new Error("resident value exceeds nesting limit");
-    const marker = byte(state);
-    if (marker <= 0x7f)
-        return marker;
-    if (marker >= 0xe0)
-        return marker - 0x100;
-    if ((marker & 0xe0) === 0xa0)
-        return string(state, marker & 0x1f);
-    if ((marker & 0xf0) === 0x90)
-        return array(state, marker & 0x0f, depth);
-    if ((marker & 0xf0) === 0x80)
-        return map(state, marker & 0x0f, depth);
-    switch (marker) {
-        case 0xc0: return null;
-        case 0xc2: return false;
-        case 0xc3: return true;
-        case 0xc4: return binary(state, uint(state, 1));
-        case 0xc5: return binary(state, uint(state, 2));
-        case 0xc6: return binary(state, uint(state, 4));
-        case 0xcc: return uint(state, 1);
-        case 0xcd: return uint(state, 2);
-        case 0xce: return uint(state, 4);
-        case 0xcf: return safeInteger(state, false);
-        case 0xd0: return signed(state, 1);
-        case 0xd1: return signed(state, 2);
-        case 0xd2: return signed(state, 4);
-        case 0xd3: return safeInteger(state, true);
-        case 0xd9: return string(state, uint(state, 1));
-        case 0xda: return string(state, uint(state, 2));
-        case 0xdb: return string(state, uint(state, 4));
-        case 0xdc: return array(state, uint(state, 2), depth);
-        case 0xdd: return array(state, uint(state, 4), depth);
-        case 0xde: return map(state, uint(state, 2), depth);
-        case 0xdf: return map(state, uint(state, 4), depth);
-        default: throw new Error(`unsupported resident MessagePack marker 0x${marker.toString(16)}`);
-    }
-}
-function byte(state) {
-    const value = state.bytes[state.offset++];
-    if (value === undefined)
-        throw new Error("incomplete resident value");
-    return value;
-}
-function uint(state, width) {
-    let value = 0;
-    for (let index = 0; index < width; index++)
-        value = value * 256 + byte(state);
-    return value;
-}
-function signed(state, width) {
-    const value = uint(state, width);
-    return value >= 2 ** (width * 8 - 1) ? value - 2 ** (width * 8) : value;
-}
-function safeInteger(state, signedValue) {
-    const high = uint(state, 4);
-    const low = uint(state, 4);
-    const value = high * 0x1_0000_0000 + low;
-    const resolved = signedValue && high >= 0x80000000 ? value - 0x1_0000_0000_0000_0000 : value;
-    if (!Number.isSafeInteger(resolved))
-        throw new Error("resident integer exceeds JavaScript safe range");
-    return resolved;
-}
-function string(state, length) {
-    return Buffer.from(binary(state, length)).toString("utf8");
-}
-function binary(state, length) {
-    const end = state.offset + length;
-    if (end > state.bytes.byteLength)
-        throw new Error("incomplete resident value");
-    const value = state.bytes.slice(state.offset, end);
-    state.offset = end;
-    return value;
-}
-function array(state, length, depth) {
-    if (length > 65_536)
-        throw new Error("resident collection exceeds limit");
-    return Array.from({ length }, () => decodeValue(state, depth + 1));
-}
-function map(state, length, depth) {
-    if (length > 65_536)
-        throw new Error("resident collection exceeds limit");
-    const value = {};
-    for (let index = 0; index < length; index++) {
-        const key = decodeValue(state, depth + 1);
-        if (typeof key !== "string" || Object.hasOwn(value, key))
-            throw new Error("invalid resident map key");
-        value[key] = decodeValue(state, depth + 1);
-    }
-    return value;
-}
-function u32(value) { return [(value >>> 24) & 0xff, (value >>> 16) & 0xff, (value >>> 8) & 0xff, value & 0xff]; }
-function i64(value) {
-    const integer = BigInt(value);
-    const encoded = integer < 0 ? (1n << 64n) + integer : integer;
-    return Array.from({ length: 8 }, (_, index) => Number((encoded >> BigInt((7 - index) * 8)) & 0xffn));
-}
-function isRecord(value) { return typeof value === "object" && value !== null && !Array.isArray(value); }

package/dist/foundation/resident-tabs/recovery.d.ts

@@ -1,26 +0,0 @@
-import { ResidentTabFaultInjection } from "./fault-injection.js";
-import { type PromptSubmission, type SessionJournalEntry, type SubmittedPromptRecord } from "./prompt-journal.js";
-export interface ResidentTabRecoveredInput {
-    readonly prompts: readonly SubmittedPromptRecord[];
-    readonly draft: string | null;
-}
-export interface ResidentTabAdmission extends Omit<PromptSubmission, "fileExisted" | "incarnation"> {
-    readonly incarnation: number;
-}
-export declare class ResidentTabRecovery {
-    #private;
-    constructor(dataDir: string, options?: {
-        readonly faults?: ResidentTabFaultInjection;
-        readonly onDegraded?: (degraded: boolean) => void;
-    });
-    get recovered(): ResidentTabRecoveredInput;
-    initialize(currentSessionFile?: string | null, currentSessionId?: string | null): Promise<ResidentTabRecoveredInput>;
-    admit(input: ResidentTabAdmission, timeoutMs?: number): Promise<SubmittedPromptRecord>;
-    dispatched(): void;
-    correlated(submissionId: string, entryId: string): Promise<void>;
-    checkpoint(text: string): void;
-    settled(sessionFile: string | null): Promise<void>;
-    gracefulStop(sessionFile: string | null): Promise<void>;
-}
-/** Reconcile only durable user/assistant ancestry; a torn final JSONL record is not authority. */
-export declare function readSessionJournal(path: string): Promise<readonly SessionJournalEntry[]>;

package/dist/foundation/resident-tabs/recovery.js

@@ -1,205 +0,0 @@
-import { readFile, readdir, stat } from "node:fs/promises";
-import { dirname, join, resolve } from "node:path";
-import { DraftCheckpointer } from "./draft-checkpoint.js";
-import { ResidentTabFaultInjection } from "./fault-injection.js";
-import { PromptJournal } from "./prompt-journal.js";
-import { SettledTurnSynchronizer, synchronizeSessionFile } from "./session-sync.js";
-export class ResidentTabRecovery {
-    #journal;
-    #draft;
-    #synchronizer;
-    #faults;
-    #onDegraded;
-    #active = [];
-    #recovered = { prompts: [], draft: null };
-    constructor(dataDir, options = {}) {
-        const faults = options.faults ?? new ResidentTabFaultInjection();
-        this.#faults = faults;
-        this.#onDegraded = options.onDegraded ?? (() => { });
-        this.#journal = new PromptJournal(join(dataDir, "journal.jsonl"), { faults });
-        this.#draft = new DraftCheckpointer(join(dataDir, "draft.json"), { faults, onDegraded: this.#onDegraded });
-        this.#synchronizer = new SettledTurnSynchronizer(this.#journal, faults);
-    }
-    get recovered() { return this.#recovered; }
-    async initialize(currentSessionFile = null, currentSessionId = null) {
-        await this.#journal.initialize();
-        await adoptHistoricalJournals(dirname(dirname(this.#journal.path)), this.#journal, currentSessionFile, currentSessionId);
-        const records = await this.#journal.read();
-        const sessionFiles = new Set(records.flatMap(record => record.type === "submitted" && record.sessionFile !== null ? [record.sessionFile] : []));
-        if (currentSessionFile !== null)
-            sessionFiles.add(currentSessionFile);
-        const sessionEntries = (await Promise.all([...sessionFiles].map(readSessionJournal))).flat();
-        const [pending, draft] = await Promise.all([
-            this.#journal.pending(sessionEntries),
-            this.#draft.restore(),
-        ]);
-        this.#recovered = { prompts: pending.map(value => value.submitted), draft: draft?.text ?? null };
-        return this.#recovered;
-    }
-    async admit(input, timeoutMs = 2_000) {
-        const fileExisted = input.sessionFile === null ? false : await stat(input.sessionFile).then(() => true, error => {
-            if (error.code === "ENOENT")
-                return false;
-            throw error;
-        });
-        let timer;
-        try {
-            return await Promise.race([
-                this.#journal.submit({ ...input, fileExisted }),
-                new Promise((_, reject) => {
-                    timer = setTimeout(() => reject(new Error("resident prompt journal admission timed out")), timeoutMs);
-                    timer.unref();
-                }),
-            ]);
-        }
-        finally {
-            if (timer !== undefined)
-                clearTimeout(timer);
-        }
-    }
-    dispatched() { this.#faults.at("journal-after-dispatch"); }
-    async correlated(submissionId, entryId) {
-        await this.#journal.correlate(submissionId, entryId);
-        this.#active.push({ id: submissionId, entryId });
-    }
-    checkpoint(text) { this.#draft.change(text); }
-    async settled(sessionFile) {
-        const active = this.#active.splice(0);
-        if (active.length === 0 || sessionFile === null)
-            return;
-        await this.#synchronizer.settleMany(sessionFile, active);
-        for (const entry of active)
-            await this.#journal.retire(entry.id);
-        await this.#journal.compactIfRetired();
-    }
-    async gracefulStop(sessionFile) {
-        await this.#draft.flush();
-        if (sessionFile !== null)
-            await synchronizeSessionFile(sessionFile);
-        await this.#synchronizer.flush();
-    }
-}
-const MAX_SESSION_RECONCILE_BYTES = 64 * 1024 * 1024;
-const MAX_ADOPTION_AGE_MS = 7 * 24 * 60 * 60 * 1_000;
-async function adoptHistoricalJournals(profileTabsRoot, target, currentSessionFile, currentSessionId) {
-    if (currentSessionFile === null && currentSessionId === null)
-        return;
-    const history = join(profileTabsRoot, "registry-history");
-    const names = await readdir(history).catch(() => []);
-    for (const name of names.filter(value => /^tabset-.+\.json$/.test(value)).sort().reverse()) {
-        const path = join(history, name);
-        const metadata = await stat(path).catch(() => null);
-        if (metadata === null || Date.now() - metadata.mtimeMs > MAX_ADOPTION_AGE_MS)
-            continue;
-        let document;
-        try {
-            document = JSON.parse(await readFile(path, "utf8"));
-        }
-        catch {
-            continue;
-        }
-        const tabs = typeof document === "object" && document !== null && Array.isArray(document.tabs)
-            ? document.tabs : [];
-        for (const value of tabs) {
-            if (typeof value !== "object" || value === null)
-                continue;
-            const tab = value;
-            if (typeof tab.tabId !== "string")
-                continue;
-            const fileMatches = currentSessionFile !== null && typeof tab.sessionFile === "string"
-                && resolve(tab.sessionFile) === resolve(currentSessionFile);
-            const sourcePath = join(profileTabsRoot, tab.tabId, "journal.jsonl");
-            if (resolve(sourcePath) === resolve(target.path))
-                continue;
-            if (!await stat(sourcePath).then(() => true, () => false))
-                continue;
-            const source = new PromptJournal(sourcePath);
-            await source.initialize();
-            const records = await source.read();
-            const submitted = records.filter((record) => record.type === "submitted");
-            const idMatches = currentSessionId !== null && submitted.some(record => record.sessionId === currentSessionId);
-            if (!fileMatches && !idMatches)
-                continue;
-            const pending = await source.pending(currentSessionFile === null ? [] : await readSessionJournal(currentSessionFile));
-            for (const entry of pending) {
-                await target.adopt(entry.submitted);
-                await source.retire(entry.submitted.id);
-            }
-        }
-    }
-}
-/** Reconcile only durable user/assistant ancestry; a torn final JSONL record is not authority. */
-export async function readSessionJournal(path) {
-    let text;
-    try {
-        const metadata = await stat(path);
-        if (metadata.size > MAX_SESSION_RECONCILE_BYTES)
-            throw new Error("resident session exceeds the recovery scan limit");
-        text = await readFile(path, "utf8");
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return [];
-        throw error;
-    }
-    const raw = [];
-    const lines = text.split("\n");
-    for (let index = 0; index < lines.length; index += 1) {
-        const line = lines[index];
-        if (line.length === 0)
-            continue;
-        let value;
-        try {
-            value = JSON.parse(line);
-        }
-        catch (error) {
-            if (index === lines.length - 1 && !text.endsWith("\n"))
-                break;
-            throw error;
-        }
-        if (typeof value !== "object" || value === null)
-            continue;
-        const record = value;
-        const message = typeof record.message === "object" && record.message !== null
-            ? record.message
-            : null;
-        if (record.type !== "message" || typeof record.id !== "string" || message === null
-            || typeof message.role !== "string")
-            continue;
-        const content = message.content;
-        const promptText = typeof content === "string" ? content : Array.isArray(content)
-            ? content.flatMap(part => typeof part === "object" && part !== null
-                && part.type === "text"
-                && typeof part.text === "string"
-                ? [part.text] : []).join("")
-            : "";
-        raw.push({
-            id: record.id,
-            parentId: typeof record.parentId === "string" ? record.parentId : null,
-            role: message.role,
-            text: promptText,
-        });
-    }
-    const byId = new Map(raw.map(record => [record.id, record]));
-    const settled = new Set();
-    for (const record of raw) {
-        if (record.role !== "assistant")
-            continue;
-        let parent = record.parentId;
-        const visited = new Set();
-        while (parent !== null && !visited.has(parent)) {
-            visited.add(parent);
-            const ancestor = byId.get(parent);
-            if (ancestor === undefined)
-                break;
-            if (ancestor.role === "user") {
-                settled.add(ancestor.id);
-                break;
-            }
-            parent = ancestor.parentId;
-        }
-    }
-    return raw
-        .filter(record => record.role === "user")
-        .map(record => ({ entryId: record.id, text: record.text, settled: settled.has(record.id) }));
-}

package/dist/foundation/resident-tabs/release-holds.d.ts

@@ -1,28 +0,0 @@
-import { type TerminalHostCommand } from "./ensure-terminal-host.js";
-export interface ResidentReleaseHoldReport {
-    /** False when any resident record or identity could not be verified; callers then keep every release. */
-    readonly complete: boolean;
-    readonly releaseRoots: readonly string[];
-    readonly uncertain: readonly string[];
-}
-export interface ResidentReleaseHoldOptions {
-    readonly dataDir: string;
-    /** Installed release roots whose terminal host may answer, in preference order. */
-    readonly releaseRoots: readonly string[];
-    readonly platform?: NodeJS.Platform;
-    readonly architecture?: string;
-    readonly timeoutMs?: number;
-    readonly verify?: (addon: string, platform: NodeJS.Platform, architecture: string) => Promise<unknown>;
-    readonly run?: (command: TerminalHostCommand, arguments_: readonly string[], timeoutMs: number) => Promise<{
-        readonly code: number;
-        readonly stdout: string;
-    }>;
-}
-/**
- * Reports the releases that live resident processes run from, read-only. The verified terminal
- * host inspects its own records, so pid reuse and identity formats are judged exactly as the
- * server judges them. No records means nothing to hold; any doubt yields an incomplete report.
- */
-export declare function readResidentReleaseHolds(options: ResidentReleaseHoldOptions): Promise<ResidentReleaseHoldReport>;
-/** The largest release-hold report accepted from the terminal host. */
-export declare const MAX_RELEASE_HOLD_REPORT_BYTES: number;

package/dist/foundation/resident-tabs/release-holds.js

@@ -1,78 +0,0 @@
-import { readdir } from "node:fs/promises";
-import { resolve } from "node:path";
-import { PRODUCT_IDENTITY } from "../../product-identity.js";
-import { runBoundedHostCommand } from "./bounded-host-command.js";
-import { resolveTerminalHostEntryPath, resolveTerminalHostPath } from "./ensure-terminal-host.js";
-import { verifyTerminalHostArtifact } from "./terminal-host-artifact.js";
-const COMPLETE_EMPTY = Object.freeze({ complete: true, releaseRoots: Object.freeze([]), uncertain: Object.freeze([]) });
-/**
- * Reports the releases that live resident processes run from, read-only. The verified terminal
- * host inspects its own records, so pid reuse and identity formats are judged exactly as the
- * server judges them. No records means nothing to hold; any doubt yields an incomplete report.
- */
-export async function readResidentReleaseHolds(options) {
-    if (!await hasResidentRecords(options.dataDir))
-        return COMPLETE_EMPTY;
-    const platform = options.platform ?? process.platform;
-    const architecture = options.architecture ?? process.arch;
-    const verify = options.verify ?? verifyTerminalHostArtifact;
-    let command;
-    for (const root of options.releaseRoots) {
-        const candidate = resolveTerminalHostPath(root, {}, platform, architecture);
-        try {
-            await verify(candidate, platform, architecture);
-            command = { executable: process.execPath, entry: resolveTerminalHostEntryPath(root) };
-            break;
-        }
-        catch {
-            // Rationale: an older release may predate the packaged host; another retained release may still carry it.
-        }
-    }
-    if (!command)
-        return incomplete("no verified terminal host is installed to inspect resident records");
-    try {
-        const result = await (options.run ?? runHost)(command, ["release-holds", "--data-dir", options.dataDir], options.timeoutMs ?? 5_000);
-        const report = JSON.parse(result.stdout.trim().split(/\r?\n/u).at(-1) ?? "");
-        if (result.code !== 0 || report.schema !== "a1-resident-release-holds-v1" || typeof report.complete !== "boolean"
-            || !isStringArray(report.releaseRoots) || !isStringArray(report.uncertain)) {
-            return incomplete("terminal host returned no valid release-hold report");
-        }
-        return { complete: report.complete, releaseRoots: report.releaseRoots, uncertain: report.uncertain };
-    }
-    catch {
-        return incomplete("terminal host release-hold inspection failed");
-    }
-}
-async function hasResidentRecords(dataDir) {
-    for (const directory of ["tabs", "resident-workspaces"]) {
-        try {
-            // Invariant: native inspection, not a following stat, judges unknown or linked entries.
-            if ((await readdir(resolve(dataDir, directory))).length > 0)
-                return true;
-        }
-        catch (error) {
-            if (!(error instanceof Error && "code" in error && error.code === "ENOENT"))
-                return true;
-        }
-    }
-    return false;
-}
-function incomplete(reason) {
-    return { complete: false, releaseRoots: [], uncertain: [reason] };
-}
-function isStringArray(value) {
-    return Array.isArray(value) && value.every(item => typeof item === "string");
-}
-/** The largest release-hold report accepted from the terminal host. */
-export const MAX_RELEASE_HOLD_REPORT_BYTES = 1024 * 1024;
-async function runHost(command, arguments_, timeoutMs) {
-    const environment = { ...process.env };
-    delete environment[PRODUCT_IDENTITY.environment.developmentInstanceId];
-    delete environment[PRODUCT_IDENTITY.environment.terminalHostPath];
-    return await runBoundedHostCommand(command, arguments_, {
-        environment,
-        maxStdoutBytes: MAX_RELEASE_HOLD_REPORT_BYTES,
-        timeoutMs,
-        label: "terminal host release-hold inspection",
-    });
-}

package/dist/foundation/resident-tabs/routes.d.ts

@@ -1,5 +0,0 @@
-/** The owned screens the server opens in a utility tab; each names its tab id stem, `<route>-…`. */
-export type ResidentTabRoute = "settings" | "changelog";
-export declare const RESIDENT_TAB_ROUTES: readonly ResidentTabRoute[];
-/** The utility route whose screen is the resident tab `tabId`, or `null` for an Agent tab. */
-export declare function residentUtilityRoute(tabId: string): ResidentTabRoute | null;

package/dist/foundation/resident-tabs/routes.js

@@ -1,5 +0,0 @@
-export const RESIDENT_TAB_ROUTES = ["settings", "changelog"];
-/** The utility route whose screen is the resident tab `tabId`, or `null` for an Agent tab. */
-export function residentUtilityRoute(tabId) {
-    return RESIDENT_TAB_ROUTES.find(route => tabId.startsWith(`${route}-`)) ?? null;
-}

package/dist/foundation/resident-tabs/routing.d.ts

@@ -1,11 +0,0 @@
-import type { EnsureTerminalHostResult } from "./ensure-terminal-host.js";
-export interface ResidentHostSelectionOptions {
-    readonly profileId: "a1" | "pi";
-    readonly currentLaunchContract: boolean;
-    readonly solo: boolean;
-    /** Both standard input and standard output are terminals the attach client can own. */
-    readonly interactive: boolean;
-    readonly ensureHost: () => Promise<EnsureTerminalHostResult>;
-}
-/** Invariant: comparison, solo, and superseded launches stay outside resident discovery and startup. */
-export declare function selectResidentHost(options: ResidentHostSelectionOptions): Promise<EnsureTerminalHostResult | null>;

package/dist/foundation/resident-tabs/routing.js

@@ -1,10 +0,0 @@
-/** Invariant: comparison, solo, and superseded launches stay outside resident discovery and startup. */
-export async function selectResidentHost(options) {
-    if (options.profileId !== "a1" || options.solo || !options.currentLaunchContract)
-        return null;
-    // Platform: the attach client reads the outer terminal's size and owns its raw input, so piped
-    // or redirected launches run the direct UI, which already serves non-terminal streams.
-    if (!options.interactive)
-        return { status: "fallback", reason: "no interactive terminal" };
-    return await options.ensureHost();
-}

package/dist/foundation/resident-tabs/runtime-control.d.ts

@@ -1,38 +0,0 @@
-import { type MaintenanceOptions, type MaintenanceReport } from "./maintenance.js";
-/** Mandatory native control semantics; optional methods never establish source authority. */
-export declare const RUNTIME_CONTROL_API = "resident-control-v1";
-export declare const RUNTIME_CONTROL_CORE: readonly ["attach", "tab.list", "tab.view", "input", "resize", "detach", "controller-boundary"];
-export interface RuntimeControlIdentity {
-    readonly releaseId: string;
-    readonly scope: string;
-    readonly epoch: number;
-    readonly bootId: string;
-    readonly osSessionId: string;
-}
-export interface RuntimeControlDescription extends RuntimeControlIdentity {
-    readonly api: typeof RUNTIME_CONTROL_API;
-    readonly generation: 1;
-    readonly core: readonly string[];
-    readonly frameLimit: number;
-    readonly inputLimit: number;
-    readonly retryInput: false;
-}
-export type RuntimeControlVerdict = {
-    readonly status: "compatible";
-    readonly contract: RuntimeControlDescription;
-} | {
-    readonly status: "blocked";
-    readonly reason: "unavailable" | "invalid-contract" | "unsupported-api" | "source-mismatch" | "stale-epoch" | "missing-core";
-};
-/**
- * Validates an authenticated source's descriptor against separately verified source custody.
- * This is not an activation verdict: the caller must also reconcile every live tab and fence
- * changes to that topology before committing a client selection.
- */
-export declare function assessRuntimeControl(value: unknown, expected: RuntimeControlIdentity): RuntimeControlVerdict;
-export interface ReadRuntimeControlOptions extends Omit<MaintenanceOptions, "action" | "tabId"> {
-    readonly expected: RuntimeControlIdentity;
-    readonly maintain?: (options: MaintenanceOptions) => Promise<MaintenanceReport>;
-}
-/** A bounded read-only authenticated exchange; it never starts a host or substitutes a release. */
-export declare function readRuntimeControl(options: ReadRuntimeControlOptions): Promise<RuntimeControlVerdict>;