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

package/dist/features/owned-ui/settings-edits.js

@@ -0,0 +1,139 @@
+/**
+ * The settings screen's edits: values shown ahead of the source, and an undo history ordered by edit
+ * sequence. Undo requests drain one at a time so each restores against the result of the one before.
+ */
+export class SettingsEdits {
+    #session;
+    #openStructured;
+    #pending = new Map();
+    #history = [];
+    #sequence = 0;
+    #requests = 0;
+    #active = false;
+    #closed = false;
+    constructor(session, openStructured) {
+        this.#session = session;
+        this.#openStructured = openStructured;
+    }
+    /** The value a row shows: a pending edit, or the source's value. */
+    shown(entry) {
+        return this.#pending.get(pendingKey(entry)) ?? entry.value;
+    }
+    apply(entry, value) {
+        const key = pendingKey(entry);
+        const previous = this.shown(entry);
+        const sequence = ++this.#sequence;
+        // Invariant: shown immediately so the row never lags a keypress, and so the next press
+        // steps from here rather than from a value the source has not caught up to.
+        this.#pending.set(key, value);
+        void this.#session.change(entry.backend, entry.id, value).then(outcome => {
+            const failed = changeFailure(outcome) !== null;
+            if (!failed && previous !== null && previous !== value)
+                this.#record({ kind: "scalar", sequence, entry, previous });
+            // Concurrency: a later press may have moved on; only the last request clears itself.
+            if (this.#pending.get(key) === value)
+                this.#pending.delete(key);
+        });
+    }
+    /** Saves a structured dialog's record; `rollback` runs when the change fails. */
+    saveStructured(entry, previous, forward, rollback) {
+        const sequence = ++this.#sequence;
+        void this.#session.changeStructured(entry.backend, entry.id, structuredValue(entry, forward)).then(outcome => {
+            if (changeFailure(outcome) === null)
+                this.#record({ kind: "structured", sequence, entry, previous, forward });
+            else
+                rollback();
+        });
+    }
+    undo() {
+        this.#requests++;
+        this.#drain();
+    }
+    open() { this.#closed = false; }
+    /** Drops the history and queued requests; late results no longer record undo steps. */
+    close() {
+        this.#closed = true;
+        this.#history.length = 0;
+        this.#requests = 0;
+    }
+    #record(record) {
+        if (this.#closed)
+            return;
+        const after = this.#history.findIndex(candidate => candidate.sequence > record.sequence);
+        if (after < 0)
+            this.#history.push(record);
+        else
+            this.#history.splice(after, 0, record);
+    }
+    #drain() {
+        if (this.#active || this.#requests === 0)
+            return;
+        const record = this.#history.pop();
+        if (record === undefined) {
+            this.#requests = 0;
+            return;
+        }
+        this.#requests--;
+        this.#active = true;
+        if (record.kind === "scalar") {
+            const key = pendingKey(record.entry);
+            this.#pending.set(key, record.previous);
+            void this.#session.change(record.entry.backend, record.entry.id, record.previous).then(outcome => {
+                if (this.#pending.get(key) === record.previous)
+                    this.#pending.delete(key);
+                this.#finish(record, outcome);
+            });
+            return;
+        }
+        const open = this.#openStructured();
+        const target = open !== null && sameEntry(open.entry, record.entry) ? open : null;
+        if (target !== null)
+            replaceRecord(target.record, record.previous);
+        void this.#session.changeStructured(record.entry.backend, record.entry.id, structuredValue(record.entry, record.previous)).then(outcome => {
+            if (changeFailure(outcome) !== null && target !== null && this.#openStructured() === target && sameRecord(target.record, record.previous)) {
+                replaceRecord(target.record, record.forward);
+            }
+            this.#finish(record, outcome);
+        });
+    }
+    #finish(record, outcome) {
+        if (changeFailure(outcome) !== null)
+            this.#record(record);
+        this.#active = false;
+        this.#drain();
+    }
+}
+function pendingKey(entry) {
+    return `${entry.backend}:${entry.id}`;
+}
+/** The record the engine stores: a choice part at its fallback is unset, so the engine's default applies. */
+export function structuredValue(entry, record) {
+    return Object.fromEntries(Object.entries(record).filter(([key, value]) => {
+        const part = entry.flags.find(candidate => candidate.key === key);
+        return part?.choices === undefined || value !== part.fallback;
+    }));
+}
+export function sameRecord(left, right) {
+    const leftEntries = Object.entries(left);
+    const rightEntries = Object.entries(right);
+    return leftEntries.length === rightEntries.length
+        && leftEntries.every(([key, value]) => right[key] === value);
+}
+export function replaceRecord(target, source) {
+    for (const key of Object.keys(target))
+        delete target[key];
+    Object.assign(target, source);
+}
+/** Why a change did not take effect, or null when it did. */
+export function changeFailure(outcome) {
+    if (outcome.failure !== null)
+        return outcome.failure;
+    if (outcome.status === "failed")
+        return "the effect failed";
+    if (outcome.status === "unavailable")
+        return outcome.limitationReason ?? "the setting is unavailable";
+    return outcome.limitationReason;
+}
+function sameEntry(left, right) {
+    return left.backend === right.backend && left.id === right.id;
+}

package/dist/features/owned-ui/settings-scroll-rail.d.ts

@@ -0,0 +1,29 @@
+import { type PaneMouseEvent, type RailPosition, type ScrollbarGeometry, type ScrollbarPresentation, type ScrollbarPresentationInput } from "../../ui/components/index.js";
+/** Where the rail was painted in the last frame, with the list page it scrolls by. */
+export interface SettingsRailFrame {
+    readonly rail: RailPosition;
+    readonly geometry: ScrollbarGeometry;
+    readonly page: number;
+}
+/** How a pointer report landed on the rail: owned keeps it from the list, and `scroll` is the list's new offset. */
+export interface SettingsRailPointer {
+    readonly owned: boolean;
+    readonly changed: boolean;
+    readonly overRail: boolean;
+    readonly scroll?: number;
+}
+/** The settings list's scrollbar rail: hover, thumb drag, track paging, and the lingering highlight after a scroll. */
+export declare class SettingsScrollRail {
+    #private;
+    /** Notes the frame's scroll; a moved list keeps the rail lit and repaints once the highlight lapses. */
+    noteRenderedScroll(scroll: number, now: number, requestRender: () => void): void;
+    presentation(input: Omit<ScrollbarPresentationInput, "hovered" | "dragging" | "activeUntil">): ScrollbarPresentation;
+    /** Records where the rail was painted, or null when this frame has no rail. */
+    setFrame(frame: Omit<SettingsRailFrame, "rail"> & {
+        readonly rail: Omit<RailPosition, "key">;
+    } | null): void;
+    pointer(event: PaneMouseEvent, scroll: number): SettingsRailPointer;
+    /** Drops hover and any drag, as when a dialog takes the screen. */
+    clear(): void;
+    dispose(): void;
+}

package/dist/features/owned-ui/settings-scroll-rail.js

@@ -0,0 +1,79 @@
+import { scrollForTrackPage, scrollbarPresentation, ScrollbarRails, } from "../../ui/components/index.js";
+/** Identity of the settings list rail in the shared rail state. */
+const RAIL_KEY = "settings";
+// Compatibility: the transcript rail stays lit this long after a scroll, and repaints just after.
+const SCROLL_LINGER_MS = 900;
+const SCROLL_LINGER_REPAINT_MS = 925;
+/** The settings list's scrollbar rail: hover, thumb drag, track paging, and the lingering highlight after a scroll. */
+export class SettingsScrollRail {
+    #rails = new ScrollbarRails();
+    #frame = null;
+    #activeUntil = 0;
+    #activityTimer;
+    #renderedScroll;
+    /** Notes the frame's scroll; a moved list keeps the rail lit and repaints once the highlight lapses. */
+    noteRenderedScroll(scroll, now, requestRender) {
+        // Rationale: every way of scrolling ends in this frame, so a moved list is noticed here
+        // once rather than at each wheel, drag, key, and search branch.
+        if (this.#renderedScroll !== undefined && this.#renderedScroll !== scroll) {
+            this.#activeUntil = Math.max(this.#activeUntil, now + SCROLL_LINGER_MS);
+            this.#clearTimer();
+            this.#activityTimer = setTimeout(() => {
+                this.#activityTimer = undefined;
+                requestRender();
+            }, SCROLL_LINGER_REPAINT_MS);
+            this.#activityTimer.unref?.();
+        }
+        this.#renderedScroll = scroll;
+    }
+    presentation(input) {
+        return scrollbarPresentation({
+            ...input,
+            hovered: this.#rails.isHovered(RAIL_KEY),
+            dragging: this.#rails.isDragging(RAIL_KEY),
+            activeUntil: this.#activeUntil,
+        });
+    }
+    /** Records where the rail was painted, or null when this frame has no rail. */
+    setFrame(frame) {
+        this.#frame = frame === null ? null : { ...frame, rail: { ...frame.rail, key: RAIL_KEY } };
+    }
+    // Rationale: the rail takes its share of a pointer report first: hover, a thumb drag, or a
+    // track page. Owned means the list must not see the report; changed means the rail looks different.
+    pointer(event, scroll) {
+        const frame = this.#frame;
+        const wasHovered = this.#rails.isHovered(RAIL_KEY);
+        if (frame === null) {
+            this.#rails.clear();
+            return { owned: false, changed: wasHovered, overRail: false };
+        }
+        const pointer = { column: event.column, row: event.row - 1 };
+        if (this.#rails.isDragging(RAIL_KEY)) {
+            // Invariant: a drag keeps the pointer wherever it goes until the button comes up.
+            if (event.kind === "release") {
+                this.#rails.endDrag();
+                return { owned: true, changed: true, overRail: false };
+            }
+            const target = this.#rails.dragTo(frame.rail, frame.geometry, pointer);
+            return target === null ? { owned: true, changed: true, overRail: false } : { owned: true, changed: true, overRail: false, scroll: target };
+        }
+        const over = this.#rails.notePointer([frame.rail], pointer) !== null;
+        if (!over)
+            return { owned: false, changed: wasHovered, overRail: false };
+        if (event.kind === "press" && !this.#rails.beginDrag(frame.rail, frame.geometry, pointer)) {
+            return { owned: true, changed: true, overRail: true, scroll: scrollForTrackPage(frame.geometry, pointer.row - frame.rail.rowStart, scroll, frame.page) };
+        }
+        return { owned: true, changed: true, overRail: true };
+    }
+    /** Drops hover and any drag, as when a dialog takes the screen. */
+    clear() { this.#rails.clear(); }
+    dispose() {
+        this.#clearTimer();
+        this.#rails.clear();
+    }
+    #clearTimer() {
+        if (this.#activityTimer !== undefined)
+            clearTimeout(this.#activityTimer);
+        this.#activityTimer = undefined;
+    }
+}

package/dist/features/owned-ui/settings-search-input.d.ts

@@ -1,5 +1,5 @@
 import type { UiTheme } from "../../ui/components/index.js";
-export interface SettingsSearchPointerEvent {
+interface SettingsSearchPointerEvent {
     readonly kind: "press" | "motion" | "release";
     readonly button: number;
     readonly column: number;
@@ -27,3 +27,4 @@ export interface SettingsSearchInputFactory {
     create(options: SettingsSearchInputOptions): SettingsSearchInput;
     isTextInput(data: string): boolean;
 }
+export {};

package/dist/features/prompt-history/service.d.ts

@@ -1,8 +1,8 @@
 import type { Worker } from "node:worker_threads";
 import { type PromptHistoryFailure, type PromptHistoryPort, type PromptHistoryResult, type PromptHistorySnapshot, type PromptHistorySubmission } from "../../contracts/owned-ui/index.js";
 import { type PromptHistoryScope } from "./paths.js";
-export type HistoryRecoveryState = "starting" | "ready" | "recovering" | "blocked-storage" | "closing" | "closed";
-export interface HistoryClock {
+type HistoryRecoveryState = "starting" | "ready" | "recovering" | "blocked-storage" | "closing" | "closed";
+interface HistoryClock {
     now(): number;
     setTimeout(callback: () => void, milliseconds: number): ReturnType<typeof setTimeout>;
     clearTimeout(timer: ReturnType<typeof setTimeout> | undefined): void;
@@ -57,3 +57,4 @@ export declare class PromptHistoryService implements PromptHistoryPort {
     onFailure(listener: (code: PromptHistoryFailure) => void): () => void;
     close(): Promise<void>;
 }
+export {};

package/dist/foundation/launch-context/index.d.ts

@@ -6,12 +6,7 @@ export declare const PRIVATE_ENVIRONMENT: Readonly<{
     releaseDigest: "LAUNCH_CONTEXT_RELEASE_DIGEST";
     releaseLayers: "LAUNCH_CONTEXT_RELEASE_LAYERS";
     launchProfile: "LAUNCH_CONTEXT_PROFILE";
-    launchMode: "LAUNCH_CONTEXT_MODE";
-    updateVersion: "LAUNCH_CONTEXT_UPDATE_VERSION";
     immutableWarmup: "LAUNCH_CONTEXT_WARMUP";
-    residentRootExecutable: "LAUNCH_CONTEXT_RESIDENT_ROOT_EXECUTABLE";
-    residentRootArguments: "LAUNCH_CONTEXT_RESIDENT_ROOT_ARGUMENTS";
-    residentFallback: "LAUNCH_CONTEXT_RESIDENT_FALLBACK";
 }>;
 /**
  * Keys published by releases that predate the neutral cutover. They are read when
@@ -35,15 +30,8 @@ export interface LaunchContext {
     readonly releaseDigest?: string;
     readonly releaseLayers?: string;
     readonly launchProfile?: "a1" | "pi";
-    readonly launchMode?: "tabs" | "solo";
-    readonly updateVersion?: string;
     readonly immutableWarmup?: "1";
-    readonly residentRootExecutable?: string;
-    readonly residentRootArguments?: string;
-    readonly residentFallback?: string;
 }
-/** The Tabs settings configure resident tabs; a direct-route launch, by `a1 solo` or by a fallback, hides them. */
-export declare function hidesTabSettings(context: Pick<LaunchContext, "launchMode" | "residentFallback">): boolean;
 export type LaunchContextRequirement = "optional" | "profile" | "release" | "warmup";
 /** Read current keys, fall back to superseded keys per field, with bounded diagnostics. */
 export declare function readLaunchContext(environment: NodeJS.ProcessEnv, requirement?: LaunchContextRequirement, platform?: NodeJS.Platform): LaunchContext;

package/dist/foundation/launch-context/index.js

@@ -6,12 +6,7 @@ export const PRIVATE_ENVIRONMENT = Object.freeze({
     releaseDigest: "LAUNCH_CONTEXT_RELEASE_DIGEST",
     releaseLayers: "LAUNCH_CONTEXT_RELEASE_LAYERS",
     launchProfile: "LAUNCH_CONTEXT_PROFILE",
-    launchMode: "LAUNCH_CONTEXT_MODE",
-    updateVersion: "LAUNCH_CONTEXT_UPDATE_VERSION",
     immutableWarmup: "LAUNCH_CONTEXT_WARMUP",
-    residentRootExecutable: "LAUNCH_CONTEXT_RESIDENT_ROOT_EXECUTABLE",
-    residentRootArguments: "LAUNCH_CONTEXT_RESIDENT_ROOT_ARGUMENTS",
-    residentFallback: "LAUNCH_CONTEXT_RESIDENT_FALLBACK",
 });
 /**
  * Keys published by releases that predate the neutral cutover. They are read when
@@ -32,10 +27,6 @@ const SUPERSEDED_ENTRIES = Object.entries(SUPERSEDED_ENVIRONMENT);
 const PRIVATE_KEYS = new Set([...Object.values(PRIVATE_ENVIRONMENT), ...Object.values(SUPERSEDED_ENVIRONMENT)]);
 const LOGICAL_KEYS = new Map(PRIVATE_ENTRIES.map(([logical, key]) => [key, logical]));
 const SUPERSEDED_LOGICAL_KEYS = new Map(SUPERSEDED_ENTRIES.map(([logical, key]) => [key, logical]));
-/** The Tabs settings configure resident tabs; a direct-route launch, by `a1 solo` or by a fallback, hides them. */
-export function hidesTabSettings(context) {
-    return context.launchMode === "solo" || context.residentFallback !== undefined;
-}
 /** Read current keys, fall back to superseded keys per field, with bounded diagnostics. */
 export function readLaunchContext(environment, requirement = "optional", platform = process.platform) {
     const values = {};
@@ -70,25 +61,8 @@ export function readLaunchContext(environment, requirement = "optional", platfor
     if (values.launchProfile !== undefined && values.launchProfile !== "a1" && values.launchProfile !== "pi") {
         throw invalidContext("launchProfile", "unsupported profile");
     }
-    if (values.launchMode !== undefined && values.launchMode !== "tabs" && values.launchMode !== "solo") {
-        throw invalidContext("launchMode", "unsupported launch mode");
-    }
-    if (values.launchProfile === "pi" && values.launchMode === "tabs")
-        throw invalidContext("launchMode", "Pi comparison cannot use tabs");
     if (values.immutableWarmup !== undefined && values.immutableWarmup !== "1")
         throw invalidContext("immutableWarmup", "invalid permission flag");
-    if ((values.residentRootExecutable === undefined) !== (values.residentRootArguments === undefined))
-        throw invalidContext("residentRootExecutable", "resident root command is incomplete");
-    if (values.residentRootArguments !== undefined) {
-        try {
-            const argumentsValue = JSON.parse(values.residentRootArguments);
-            if (!Array.isArray(argumentsValue) || argumentsValue.some(value => typeof value !== "string"))
-                throw new Error("not string arguments");
-        }
-        catch {
-            throw invalidContext("residentRootArguments", "invalid JSON argument list");
-        }
-    }
     if (values.releaseDigest !== undefined && !/^[a-f0-9]{64}$/.test(values.releaseDigest))
         throw invalidContext("releaseDigest", "invalid digest");
     if (requirement === "profile")

package/dist/foundation/lifecycle/claim-gate.d.ts

@@ -0,0 +1,9 @@
+interface ClaimGateHandle {
+    release(): void;
+}
+/**
+ * Try once to hold the worktree mutation gate. The gate is a lock directory beside the authority
+ * file; contention returns null so the caller keeps its own bounded retry.
+ */
+export declare function tryAcquireClaimGate(path: string): ClaimGateHandle | null;
+export {};

package/dist/foundation/lifecycle/claim-gate.js

@@ -0,0 +1,37 @@
+import lockfile from "proper-lockfile";
+/** A stalled mutation loses the gate after this bound instead of holding it until the process ends. */
+const CLAIM_GATE_STALE_MS = 10_000;
+/**
+ * Try once to hold the worktree mutation gate. The gate is a lock directory beside the authority
+ * file; contention returns null so the caller keeps its own bounded retry.
+ */
+export function tryAcquireClaimGate(path) {
+    let release;
+    try {
+        release = lockfile.lockSync(path, {
+            realpath: false,
+            lockfilePath: `${path}.gate`,
+            stale: CLAIM_GATE_STALE_MS,
+            onCompromised: () => { },
+        });
+    }
+    catch (cause) {
+        if (cause instanceof Error && "code" in cause && cause.code === "ELOCKED")
+            return null;
+        throw Object.assign(new Error("cannot access the worktree mutation gate; check A1 data-directory permissions and filesystem availability", { cause }), {
+            code: "worktree-coordination-io",
+        });
+    }
+    let released = false;
+    return {
+        release() {
+            if (released)
+                return;
+            released = true;
+            try {
+                release();
+            }
+            catch { /* Compatibility: a reclaimed stale gate is already gone. */ }
+        },
+    };
+}

package/dist/foundation/lifecycle/index.d.ts

@@ -1,13 +1,9 @@
-export type { LaunchInstanceStopIntent, SupervisorCommand } from "./commands.js";
-export { assertLaunchInstance, assertLaunchInstanceOutcome, assertLaunchInstanceTransition, assertProcessContainmentIdentity } from "./launch-instance.js";
-export type { LaunchInstance, LaunchInstanceId, LaunchInstanceOutcome, LaunchInstanceShutdownPolicy, LaunchInstanceState, LaunchInstanceStopReason, ProcessContainmentIdentity, } from "./launch-instance.js";
-export { assertDimensions, assertLaunchProfileId, assertNativeProcessIdentity, assertTransparentTerminalLaunchProfile } from "./model.js";
-export type { CommandResult, DriverProfileId, GenerationId, LaunchProfileId, NativeProcessIdentity, RequestId, SupervisorSnapshot, TerminalDimensions, TransparentTerminalLaunchProfile, TransparentTerminalLifecycleOutcome, } from "./model.js";
-export { resolveCohortEndpoint, resolveProductPaths } from "./paths.js";
-export type { CohortEndpointPaths, ProductPaths } from "./paths.js";
+export { assertLaunchProfileId } from "./model.js";
+export type { LaunchProfileId, ProcessIdentity } from "./model.js";
+export { PID_LIVENESS_IDENTITY, inspectLiveProcess } from "./process-liveness.js";
+export { resolveProductPaths } from "./paths.js";
+export type { ProductPaths } from "./paths.js";
 export { parseSessionSelection, sessionSelectionArguments } from "./session-selection.js";
 export type { SessionSelection } from "./session-selection.js";
 export { PRIMARY_SESSION_AGENT_ID, activateSessionRepositoryContext, clearSessionRepositoryContext, listSessionRepositoryWorktrees, readSessionRepositoryContext, registerSessionRepositoryRuntime, releaseSessionRepositoryRuntime, setSessionRepositoryContext, } from "./session-repository-context.js";
 export type { SessionRepositoryContext, SessionRepositoryContextOptions, SessionRepositoryIdentity, SessionWorktreeInventoryEntry, SessionWorktreeStatus, } from "./session-repository-context.js";
-export { createSupervisorStartupAttempt, publishSupervisorStartupResult, readSupervisorStartupResult, supervisorStartupFailure, supervisorStartupReady, supervisorStartupResultPath, } from "./supervisor-startup.js";
-export type { SupervisorStartupAttemptIdentity, SupervisorStartupResult } from "./supervisor-startup.js";

package/dist/foundation/lifecycle/index.js

@@ -1,6 +1,5 @@
-export { assertLaunchInstance, assertLaunchInstanceOutcome, assertLaunchInstanceTransition, assertProcessContainmentIdentity } from "./launch-instance.js";
-export { assertDimensions, assertLaunchProfileId, assertNativeProcessIdentity, assertTransparentTerminalLaunchProfile } from "./model.js";
-export { resolveCohortEndpoint, resolveProductPaths } from "./paths.js";
+export { assertLaunchProfileId } from "./model.js";
+export { PID_LIVENESS_IDENTITY, inspectLiveProcess } from "./process-liveness.js";
+export { resolveProductPaths } from "./paths.js";
 export { parseSessionSelection, sessionSelectionArguments } from "./session-selection.js";
 export { PRIMARY_SESSION_AGENT_ID, activateSessionRepositoryContext, clearSessionRepositoryContext, listSessionRepositoryWorktrees, readSessionRepositoryContext, registerSessionRepositoryRuntime, releaseSessionRepositoryRuntime, setSessionRepositoryContext, } from "./session-repository-context.js";
-export { createSupervisorStartupAttempt, publishSupervisorStartupResult, readSupervisorStartupResult, supervisorStartupFailure, supervisorStartupReady, supervisorStartupResultPath, } from "./supervisor-startup.js";

package/dist/foundation/lifecycle/model.d.ts

@@ -1,64 +1,7 @@
 export type LaunchProfileId = "a1" | "pi";
-export type GenerationId = string;
-export type DriverProfileId = string;
-export type RequestId = string;
-export interface TerminalDimensions {
-    readonly columns: number;
-    readonly rows: number;
-}
-export interface TransparentTerminalLaunchProfile {
-    readonly id: DriverProfileId;
-    readonly terminalCapability: "transparent";
-    readonly executable: string;
-    readonly arguments: readonly string[];
-    readonly cwd: string;
-    readonly environment: Readonly<Record<string, string>>;
-    readonly terminalType: string;
-    readonly dimensions: TerminalDimensions;
-    readonly ownerDisconnect: "stop" | "detach";
-    readonly recovery: "detach-only" | "none";
-    readonly surface: "none";
-    readonly visualReconnection: "none";
-}
-export interface NativeProcessIdentity {
+/** A process as session coordination records it: a pid plus the identity its writer observed. */
+export interface ProcessIdentity {
     readonly pid: number;
     readonly startIdentity: string;
 }
-export type TransparentTerminalLifecycleOutcome = {
-    readonly kind: "exited";
-    readonly exitCode: number;
-} | {
-    readonly kind: "signaled";
-    readonly signal: string;
-} | {
-    readonly kind: "stopped";
-    readonly reason: "owner-disconnect" | "user-request" | "update";
-} | {
-    readonly kind: "detached";
-    readonly reason: "owner-disconnect";
-} | {
-    readonly kind: "spawn-error" | "broker-error";
-    readonly message: string;
-    readonly code: string | null;
-};
-export interface SupervisorSnapshot {
-    readonly revision: number;
-    readonly activeInstances: readonly {
-        readonly id: string;
-        readonly profileId: LaunchProfileId;
-        readonly state: "requested" | "active" | "stopping";
-    }[];
-}
-export interface CommandResult {
-    readonly requestId: RequestId;
-    readonly ok: boolean;
-    readonly revision: number;
-    readonly error?: {
-        readonly code: "invalid-command" | "not-found" | "stale-generation" | "capability-error" | "containment-unsupported" | "ownership-error" | "release-superseded" | "driver-error";
-        readonly message: string;
-    };
-}
 export declare function assertLaunchProfileId(value: unknown): asserts value is LaunchProfileId;
-export declare function assertDimensions(dimensions: TerminalDimensions): void;
-export declare function assertTransparentTerminalLaunchProfile(profile: TransparentTerminalLaunchProfile): void;
-export declare function assertNativeProcessIdentity(identity: NativeProcessIdentity): void;

package/dist/foundation/lifecycle/model.js

@@ -3,38 +3,3 @@ export function assertLaunchProfileId(value) {
     if (value !== "a1" && value !== "pi")
         throw new TypeError(PRODUCT_TEXT.diagnostic(`launch profile is invalid: ${String(value)}`));
 }
-export function assertDimensions(dimensions) {
-    if (!Number.isInteger(dimensions.columns) || dimensions.columns < 2 || dimensions.columns > 500) {
-        throw new RangeError("terminal columns must be an integer from 2 to 500");
-    }
-    if (!Number.isInteger(dimensions.rows) || dimensions.rows < 1 || dimensions.rows > 300) {
-        throw new RangeError("terminal rows must be an integer from 1 to 300");
-    }
-}
-export function assertTransparentTerminalLaunchProfile(profile) {
-    if (!profile.id || profile.terminalCapability !== "transparent")
-        throw new TypeError("invalid transparent terminal profile identity");
-    if (!profile.executable || profile.executable.includes("\0"))
-        throw new TypeError("transparent executable must be non-empty and contain no null byte");
-    if (!profile.cwd || profile.cwd.includes("\0"))
-        throw new TypeError("transparent working directory must be non-empty and contain no null byte");
-    if (profile.arguments.some(value => typeof value !== "string" || value.includes("\0")))
-        throw new TypeError("transparent arguments must contain no null byte");
-    if (Object.entries(profile.environment).some(([name, value]) => !name || name.includes("=") || name.includes("\0") || value.includes("\0"))) {
-        throw new TypeError("transparent environment contains an invalid name or value");
-    }
-    if (!profile.terminalType || profile.terminalType.includes("\0"))
-        throw new TypeError("transparent terminal type is invalid");
-    assertDimensions(profile.dimensions);
-    if (profile.surface !== "none" || profile.visualReconnection !== "none")
-        throw new TypeError("transparent profiles cannot declare a surface or visual reconnection");
-    if (profile.ownerDisconnect === "detach" && profile.recovery !== "detach-only")
-        throw new TypeError("transparent detach policy requires detach-only recovery");
-    if (profile.ownerDisconnect === "stop" && profile.recovery !== "none")
-        throw new TypeError("transparent stop policy requires no recovery claim");
-}
-export function assertNativeProcessIdentity(identity) {
-    if (!Number.isSafeInteger(identity.pid) || identity.pid <= 0 || !identity.startIdentity || identity.startIdentity.includes("\0")) {
-        throw new TypeError("invalid native process identity");
-    }
-}

package/dist/foundation/lifecycle/paths.d.ts

@@ -2,29 +2,5 @@ export interface ProductPaths {
     readonly configDir: string;
     readonly dataDir: string;
     readonly runtimeDir: string;
-    readonly databasePath: string;
-    /** The endpoint written by releases that predate cohort-scoped identity. */
-    readonly endpoint: string;
-    /** The metadata written by releases that predate cohort-scoped identity. */
-    readonly endpointMetadataPath: string;
-    readonly endpointsDir: string;
-    /** A short, A1-managed socket directory when the host imposes a small Unix-path limit. */
-    readonly endpointDirectory?: string | null;
-    readonly supervisorLogPath: string;
 }
-/** Where one cohort listens, and where it records that it is listening. */
-export interface CohortEndpointPaths {
-    readonly endpoint: string;
-    readonly endpointMetadataPath: string;
-}
-/**
- * Endpoint identity for one release cohort. Two cohorts can be live at once — an update
- * leaves a working session on the release it started on — so the name a supervisor listens
- * on has to name the release as well as the runtime directory, or the two contend for one
- * endpoint and replacing one means ending the other.
- *
- * An explicit endpoint override keeps its single endpoint: it is how an isolated run pins
- * the address it is going to talk to.
- */
-export declare function resolveCohortEndpoint(paths: ProductPaths, releaseId: string, environment?: NodeJS.ProcessEnv, hostPlatform?: NodeJS.Platform): CohortEndpointPaths;
 export declare function resolveProductPaths(environment?: NodeJS.ProcessEnv, hostPlatform?: NodeJS.Platform, fallbackHome?: string): ProductPaths;

package/dist/foundation/lifecycle/paths.js

@@ -1,27 +1,6 @@
-import { createHash } from "node:crypto";
 import { homedir, platform } from "node:os";
 import { posix, win32 } from "node:path";
 import { PRODUCT_IDENTITY } from "../../product-identity.js";
-/**
- * Endpoint identity for one release cohort. Two cohorts can be live at once — an update
- * leaves a working session on the release it started on — so the name a supervisor listens
- * on has to name the release as well as the runtime directory, or the two contend for one
- * endpoint and replacing one means ending the other.
- *
- * An explicit endpoint override keeps its single endpoint: it is how an isolated run pins
- * the address it is going to talk to.
- */
-export function resolveCohortEndpoint(paths, releaseId, environment = process.env, hostPlatform = platform()) {
-    if (environment[PRODUCT_IDENTITY.environment.endpoint]) {
-        return { endpoint: paths.endpoint, endpointMetadataPath: paths.endpointMetadataPath };
-    }
-    const path = hostPlatform === "win32" ? win32 : posix;
-    const token = createHash("sha256").update(releaseId).digest("hex").slice(0, 16);
-    const endpoint = hostPlatform === "win32"
-        ? `${paths.endpoint}-${token}`
-        : path.join(paths.endpointDirectory ?? paths.runtimeDir, `${token}-${PRODUCT_IDENTITY.endpoint.unixSocketFilename}`);
-    return { endpoint, endpointMetadataPath: path.join(paths.endpointsDir, `${token}.json`) };
-}
 export function resolveProductPaths(environment = process.env, hostPlatform = platform(), fallbackHome = homedir()) {
     const windows = hostPlatform === "win32";
     const path = windows ? win32 : posix;
@@ -29,8 +8,6 @@ export function resolveProductPaths(environment = process.env, hostPlatform = pl
     const configOverride = environment[PRODUCT_IDENTITY.environment.configDir];
     const dataOverride = environment[PRODUCT_IDENTITY.environment.dataDir];
     const runtimeOverride = environment[PRODUCT_IDENTITY.environment.runtimeDir];
-    const databaseOverride = environment[PRODUCT_IDENTITY.environment.databasePath];
-    const endpointOverride = environment[PRODUCT_IDENTITY.environment.endpoint];
     const configDir = path.resolve(configOverride
         ?? (windows
             ? path.join(environment.APPDATA ?? home, PRODUCT_IDENTITY.state.windowsControlDirectory)
@@ -45,26 +22,9 @@ export function resolveProductPaths(environment = process.env, hostPlatform = pl
             : environment.XDG_RUNTIME_DIR
                 ? path.join(environment.XDG_RUNTIME_DIR, PRODUCT_IDENTITY.state.unixControlDirectory)
                 : path.join(dataDir, "runtime")));
-    const namespace = createHash("sha256").update(runtimeDir.toLowerCase()).digest("hex").slice(0, 20);
-    // Platform: Darwin limits Unix-domain socket paths to roughly 104 bytes. Runtime roots
-    // under /var/folders can exceed that before the cohort suffix is added, so only socket
-    // files use a short owned namespace while metadata remains under the selected runtime.
-    const endpointDirectory = !endpointOverride && hostPlatform === "darwin"
-        ? posix.join("/tmp", `${PRODUCT_IDENTITY.state.unixControlDirectory}-${namespace}`)
-        : null;
-    const endpoint = endpointOverride
-        ?? (windows
-            ? `\\\\.\\pipe\\${PRODUCT_IDENTITY.endpoint.windowsPipeStem}-${namespace}`
-            : path.join(endpointDirectory ?? runtimeDir, PRODUCT_IDENTITY.endpoint.unixSocketFilename));
     return {
         configDir,
         dataDir,
         runtimeDir,
-        databasePath: path.resolve(databaseOverride ?? path.join(dataDir, PRODUCT_IDENTITY.endpoint.databaseFilename)),
-        endpoint,
-        endpointMetadataPath: path.join(runtimeDir, PRODUCT_IDENTITY.endpoint.metadataFilename),
-        endpointsDir: path.join(runtimeDir, "endpoints"),
-        endpointDirectory,
-        supervisorLogPath: path.join(runtimeDir, PRODUCT_IDENTITY.endpoint.supervisorLogFilename),
     };
 }

package/dist/foundation/lifecycle/process-liveness.d.ts

@@ -0,0 +1,8 @@
+import type { ProcessIdentity } from "./model.js";
+/**
+ * The identity every record written by this build carries. Liveness is a pid probe, so the
+ * identity only distinguishes records this build wrote from records an older build left.
+ */
+export declare const PID_LIVENESS_IDENTITY = "pid-liveness";
+/** Observe whether a process is running; a permission refusal still proves the pid exists. */
+export declare function inspectLiveProcess(pid: number): Promise<ProcessIdentity | null>;