@timurproko/a1 0.1.1-dev.5 → 0.1.1-dev.7

package/dist/src/foundation/supervision/server.js

@@ -2,8 +2,9 @@ import { randomUUID } from "node:crypto";
 import { mkdir, rename, rm, writeFile } from "node:fs/promises";
 import { createConnection, createServer } from "node:net";
 import { platform } from "node:os";
-import { assertNativeProcessIdentity, assertTransparentTerminalLaunchProfile, } from "../lifecycle/index.js";
+import { assertLaunchInstanceOutcome, assertNativeProcessIdentity, assertProcessContainmentIdentity, } from "../lifecycle/index.js";
 import { encodeFrame, isCommandMessage, isControlHello, LineFrameDecoder, localControlHello, MAX_CONTROL_FRAME_BYTES, negotiateControlFeatures } from "../protocol/index.js";
+import { processIsAlive } from "../release/index.js";
 import { ControlStore } from "../storage/index.js";
 import { resolveProductPaths } from "./paths.js";
 import { PRODUCT_IDENTITY, PRODUCT_TEXT } from "../../product-identity.js";
@@ -11,27 +12,45 @@ export class SupervisorServer {
     store;
     release;
     terminateProcess;
+    reconciliationDeadlineMs;
+    shutdownDeadlineMs;
     id = randomUUID();
     bootNonce;
     pidStartIdentity = `${process.pid}:${Math.floor(Date.now() - process.uptime() * 1_000)}`;
     startedAt = new Date().toISOString();
     paths;
     #server = null;
-    #foregroundLease;
+    #instances = new Map();
+    #instanceOwners = new Map();
+    #clientIds = new Map();
+    #clientInstances = new Map();
+    #uncertainInstances = new Set();
+    #reconciliations = new Map();
     #revision = 0;
     #clients = new Set();
     #results = new Map();
     #metadataWrites = Promise.resolve();
-    constructor(store, paths = resolveProductPaths(), release, bootNonce = randomUUID(), terminateProcess = code => process.exit(code)) {
+    #closing = false;
+    constructor(store, paths = resolveProductPaths(), release, bootNonce = randomUUID(), terminateProcess = code => process.exit(code), reconciliationDeadlineMs = 3_000, shutdownDeadlineMs = 1_500) {
         this.store = store;
         this.release = release;
         this.terminateProcess = terminateProcess;
+        this.reconciliationDeadlineMs = reconciliationDeadlineMs;
+        this.shutdownDeadlineMs = shutdownDeadlineMs;
         this.bootNonce = bootNonce;
         this.paths = paths;
-        this.#foregroundLease = store.loadLiveForegroundTerminalLease();
+        for (const instance of store.loadActiveLaunchInstances())
+            this.#instances.set(instance.id, instance);
     }
     snapshot() {
-        return { revision: this.#revision };
+        return {
+            revision: this.#revision,
+            activeInstances: [...this.#instances.values()].flatMap(instance => {
+                if (instance.state !== "requested" && instance.state !== "active" && instance.state !== "stopping")
+                    return [];
+                return [{ id: instance.id, profileId: instance.profileId, state: instance.state }];
+            }),
+        };
     }
     async listen() {
         if (this.#server)
@@ -54,8 +73,10 @@ export class SupervisorServer {
         await this.#writeEndpointMetadata();
     }
     async close(stopAgents = false) {
-        if (stopAgents && this.#foregroundLease)
-            this.#releaseForegroundLeaseForUpdate();
+        if (stopAgents && !await this.#drainInstances("update", this.shutdownDeadlineMs)) {
+            throw new Error("active launch instances did not release ownership within the shutdown deadline");
+        }
+        this.#closing = true;
         for (const client of this.#clients)
             client.destroy();
         if (this.#server)
@@ -86,13 +107,13 @@ export class SupervisorServer {
                         if (isMessageType(value, "release-idle-ownership")) {
                             const request = value;
                             const identityMatches = request.bootNonce === this.bootNonce && typeof request.candidateReleaseId === "string";
-                            const released = identityMatches && this.#foregroundLease === null;
+                            const released = identityMatches && this.#instances.size === 0;
                             this.#send(socket, {
                                 type: "release-ownership-result",
                                 released,
                                 reason: released ? "idle cohort released ownership"
-                                    : identityMatches ? "foreground terminal lease is still live" : "boot nonce or candidate release mismatch",
-                                liveGenerationIds: this.#liveGenerationIds(),
+                                    : identityMatches ? "launch instances are still active" : "boot nonce or candidate release mismatch",
+                                liveInstanceIds: this.#liveInstanceIds(),
                             });
                             if (released)
                                 setTimeout(() => void this.closeForReleaseReplacement(false), 25);
@@ -100,15 +121,7 @@ export class SupervisorServer {
                         }
                         if (isMessageType(value, "release-update-ownership")) {
                             const request = value;
-                            const accepted = request.bootNonce === this.bootNonce && typeof request.targetVersion === "string";
-                            this.#send(socket, {
-                                type: "release-update-result",
-                                accepted,
-                                reason: accepted ? `verified ${PRODUCT_TEXT.displayName} owner accepted immediate update shutdown` : "boot nonce or target version mismatch",
-                                liveGenerationIds: this.#liveGenerationIds(),
-                            });
-                            if (accepted)
-                                setTimeout(() => void this.closeForReleaseReplacement(true), 25);
+                            void this.#handleUpdateRelease(socket, request);
                             continue;
                         }
                         if (!isControlHello(value)) {
@@ -125,6 +138,8 @@ export class SupervisorServer {
                         }
                         welcomed = true;
                         this.#clients.add(socket);
+                        this.#clientIds.set(socket, value.clientId);
+                        this.#clientInstances.set(socket, new Set());
                         this.#send(socket, { type: "server-hello", ...serverHello, releaseId: this.release.releaseId, supervisorId: this.id, bootNonce: this.bootNonce, pidStartIdentity: this.pidStartIdentity, negotiatedFeatures: negotiation.negotiatedFeatures, snapshot: this.snapshot() });
                     }
                     else if (isCommandMessage(value)) {
@@ -137,25 +152,35 @@ export class SupervisorServer {
                 socket.destroy();
             }
         });
-        socket.on("close", () => this.#clients.delete(socket));
-        socket.on("error", () => this.#clients.delete(socket));
+        socket.on("close", () => this.#onSocketClosed(socket));
+        socket.on("error", () => this.#onSocketClosed(socket));
     }
     async #execute(command, socket) {
-        const recorded = this.#results.get(command.requestId);
+        const clientId = this.#clientIds.get(socket);
+        if (!clientId) {
+            this.#send(socket, { type: "protocol-error", code: "unauthenticated-command", message: "launch-instance commands require an authenticated client" });
+            return;
+        }
+        const resultKey = `${clientId}:${command.requestId}`;
+        const recorded = this.#results.get(resultKey);
         if (recorded) {
             this.#send(socket, { type: "command-result", result: recorded });
             return;
         }
         let result;
         try {
-            if (command.type === "acquire-foreground-terminal-lease")
-                this.#acquireForegroundLease(command);
-            if (command.type === "activate-foreground-terminal-lease")
-                this.#activateForegroundLease(command);
-            if (command.type === "heartbeat-foreground-terminal-lease")
-                this.#heartbeatForegroundLease(command);
-            if (command.type === "release-foreground-terminal-lease")
-                this.#releaseForegroundLease(command);
+            if (command.type === "create-launch-instance")
+                this.#createLaunchInstance(command, socket, clientId);
+            if (command.type === "activate-launch-instance")
+                this.#activateLaunchInstance(command, socket, clientId);
+            if (command.type === "begin-launch-instance-stop")
+                this.#beginLaunchInstanceStop(command, socket, clientId);
+            if (command.type === "complete-launch-instance")
+                this.#completeLaunchInstance(command, socket, clientId);
+            if (command.type === "reconcile-launch-instance") {
+                this.#ownedInstance(command.instanceId, socket, clientId);
+                await this.#reconcileLaunchInstance(command.instanceId);
+            }
             if (command.type === "resynchronize")
                 this.#send(socket, { type: "snapshot", snapshot: this.snapshot() });
             await this.#metadataWrites;
@@ -163,75 +188,210 @@ export class SupervisorServer {
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
-            const code = /not found/i.test(message) ? "not-found" : "driver-error";
+            const code = /not found/i.test(message) ? "not-found" : /owner|ownership|authenticated/i.test(message) ? "ownership-error" : "driver-error";
             result = { requestId: command.requestId, ok: false, revision: this.#revision, error: { code, message } };
         }
-        this.#results.set(command.requestId, result);
+        this.#results.set(resultKey, result);
         this.#send(socket, { type: "command-result", result });
     }
-    #acquireForegroundLease(command) {
-        if (!command.leaseId || !command.ownerId)
-            throw new Error("foreground lease and owner identities are required");
-        assertTransparentTerminalLaunchProfile(command.profile);
-        const lease = {
-            id: command.leaseId,
-            ownerId: command.ownerId,
-            profile: command.profile,
+    #createLaunchInstance(command, socket, clientId) {
+        assertNativeProcessIdentity(command.guardianIdentity);
+        const existing = this.store.loadLaunchInstance(command.instanceId);
+        if (existing) {
+            if (existing.ownerClientId !== clientId
+                || existing.profileId !== command.profileId
+                || existing.shutdownPolicy !== command.shutdownPolicy
+                || !sameProcessIdentity(existing.guardianIdentity, command.guardianIdentity)) {
+                throw new Error("launch instance already exists with different authenticated ownership");
+            }
+            if (existing.state === "completed" || existing.state === "interrupted")
+                throw new Error("launch instance already has a terminal outcome");
+            this.#instances.set(existing.id, existing);
+            this.#bindOwner(existing.id, socket);
+            return;
+        }
+        const instance = {
+            id: command.instanceId,
+            ownerClientId: clientId,
+            profileId: command.profileId,
             state: "requested",
-            generationId: null,
-            processIdentity: null,
-            acquiredAt: new Date().toISOString(),
-            heartbeatAt: null,
-            releasedAt: null,
+            shutdownPolicy: command.shutdownPolicy,
+            guardianIdentity: command.guardianIdentity,
+            rootIdentity: null,
+            containmentIdentity: null,
+            createdAt: new Date().toISOString(),
+            activatedAt: null,
+            stoppingAt: null,
+            completedAt: null,
             outcome: null,
         };
-        this.store.acquireForegroundTerminalLease(lease);
-        this.#foregroundLease = lease;
-        void this.#writeEndpointMetadata();
+        this.store.createLaunchInstance(instance);
+        this.#instances.set(instance.id, instance);
+        this.#bindOwner(instance.id, socket);
+        this.#mutated();
     }
-    #activateForegroundLease(command) {
-        assertNativeProcessIdentity(command.processIdentity);
-        if (!this.#foregroundLease || this.#foregroundLease.id !== command.leaseId || this.#foregroundLease.state !== "requested")
-            throw new Error("foreground terminal lease not found or is not requested");
-        const heartbeatAt = new Date().toISOString();
-        if (!this.store.activateForegroundTerminalLease(command.leaseId, command.generationId, command.processIdentity, heartbeatAt))
-            throw new Error("foreground terminal lease activation was rejected");
-        this.#foregroundLease = { ...this.#foregroundLease, state: "active", generationId: command.generationId, processIdentity: command.processIdentity, heartbeatAt };
-        void this.#writeEndpointMetadata();
+    #activateLaunchInstance(command, socket, clientId) {
+        assertNativeProcessIdentity(command.rootIdentity);
+        assertProcessContainmentIdentity(command.containmentIdentity);
+        const instance = this.#ownedInstance(command.instanceId, socket, clientId);
+        if (instance.state === "active"
+            && sameProcessIdentity(instance.rootIdentity, command.rootIdentity)
+            && sameContainmentIdentity(instance.containmentIdentity, command.containmentIdentity))
+            return;
+        if (instance.state !== "requested")
+            throw new Error("launch instance is not requested");
+        const activatedAt = new Date().toISOString();
+        if (!this.store.activateLaunchInstance(instance.id, clientId, command.rootIdentity, command.containmentIdentity, activatedAt)) {
+            throw new Error("launch instance activation ownership mismatch");
+        }
+        this.#instances.set(instance.id, { ...instance, state: "active", rootIdentity: command.rootIdentity, containmentIdentity: command.containmentIdentity, activatedAt });
+        this.#mutated();
     }
-    #heartbeatForegroundLease(command) {
-        assertNativeProcessIdentity(command.processIdentity);
-        if (!this.#foregroundLease || this.#foregroundLease.id !== command.leaseId || this.#foregroundLease.state !== "active")
-            throw new Error("active foreground terminal lease not found");
-        const heartbeatAt = new Date().toISOString();
-        if (!this.store.heartbeatForegroundTerminalLease(command.leaseId, command.processIdentity, heartbeatAt))
-            throw new Error("foreground terminal lease ownership mismatch");
-        this.#foregroundLease = { ...this.#foregroundLease, heartbeatAt };
+    #beginLaunchInstanceStop(command, socket, clientId) {
+        const instance = this.#ownedInstance(command.instanceId, socket, clientId);
+        if (instance.state === "stopping")
+            return;
+        if (instance.state !== "active")
+            throw new Error("active launch instance not found");
+        const stoppingAt = new Date().toISOString();
+        if (!this.store.beginLaunchInstanceStop(instance.id, clientId, stoppingAt))
+            throw new Error("launch instance stop ownership mismatch");
+        this.#instances.set(instance.id, { ...instance, state: "stopping", stoppingAt });
+        this.#mutated();
     }
-    #releaseForegroundLease(command) {
-        if (command.processIdentity)
-            assertNativeProcessIdentity(command.processIdentity);
-        if (!this.#foregroundLease || this.#foregroundLease.id !== command.leaseId)
-            throw new Error("foreground terminal lease not found");
-        const releasedAt = new Date().toISOString();
-        if (!this.store.releaseForegroundTerminalLease(command.leaseId, command.processIdentity, command.outcome, releasedAt))
-            throw new Error("foreground terminal lease ownership mismatch");
-        this.#foregroundLease = null;
-        void this.#writeEndpointMetadata();
+    #completeLaunchInstance(command, socket, clientId) {
+        assertLaunchInstanceOutcome(command.outcome);
+        const stored = this.store.loadLaunchInstance(command.instanceId);
+        if (!stored)
+            throw new Error("launch instance not found");
+        if (stored.ownerClientId !== clientId || this.#instanceOwners.get(stored.id) !== socket)
+            throw new Error("launch instance ownership mismatch");
+        if (stored.state === "completed" || stored.state === "interrupted") {
+            if (stored.state === command.terminalState && JSON.stringify(stored.outcome) === JSON.stringify(command.outcome))
+                return;
+            throw new Error("launch instance already has a different terminal outcome");
+        }
+        const completedAt = new Date().toISOString();
+        if (!this.store.completeLaunchInstance(stored.id, clientId, command.terminalState, command.outcome, completedAt)) {
+            throw new Error("launch instance completion ownership mismatch");
+        }
+        this.#instances.delete(stored.id);
+        this.#uncertainInstances.delete(stored.id);
+        this.#unbindOwner(stored.id, socket);
+        this.#mutated();
+    }
+    #ownedInstance(instanceId, socket, clientId) {
+        const instance = this.#instances.get(instanceId) ?? this.store.loadLaunchInstance(instanceId);
+        if (!instance || instance.state === "completed" || instance.state === "interrupted")
+            throw new Error("active launch instance not found");
+        if (instance.ownerClientId !== clientId || this.#instanceOwners.get(instanceId) !== socket)
+            throw new Error("launch instance ownership mismatch");
+        return instance;
+    }
+    #bindOwner(instanceId, socket) {
+        const current = this.#instanceOwners.get(instanceId);
+        if (current && current !== socket)
+            throw new Error("launch instance already belongs to another authenticated connection");
+        this.#instanceOwners.set(instanceId, socket);
+        this.#clientInstances.get(socket)?.add(instanceId);
+    }
+    #unbindOwner(instanceId, socket) {
+        this.#instanceOwners.delete(instanceId);
+        this.#clientInstances.get(socket)?.delete(instanceId);
+    }
+    #onSocketClosed(socket) {
+        if (!this.#clients.delete(socket) && !this.#clientIds.has(socket))
+            return;
+        const instanceIds = [...(this.#clientInstances.get(socket) ?? [])];
+        this.#clientInstances.delete(socket);
+        this.#clientIds.delete(socket);
+        for (const instanceId of instanceIds) {
+            if (this.#instanceOwners.get(instanceId) === socket)
+                this.#instanceOwners.delete(instanceId);
+            if (!this.#closing)
+                void this.#reconcileLaunchInstance(instanceId);
+        }
+    }
+    #reconcileLaunchInstance(instanceId) {
+        const existing = this.#reconciliations.get(instanceId);
+        if (existing)
+            return existing;
+        const reconciliation = this.#performReconciliation(instanceId).finally(() => this.#reconciliations.delete(instanceId));
+        this.#reconciliations.set(instanceId, reconciliation);
+        return reconciliation;
     }
-    #releaseForegroundLeaseForUpdate() {
-        const lease = this.#foregroundLease;
-        if (!lease)
+    async #performReconciliation(instanceId) {
+        const instance = this.#instances.get(instanceId);
+        if (!instance)
+            return;
+        const deadline = Date.now() + this.reconciliationDeadlineMs;
+        while (instance.rootIdentity && processIsAlive(instance.rootIdentity.pid) && Date.now() < deadline) {
+            await new Promise(resolvePromise => setTimeout(resolvePromise, 25));
+        }
+        if (instance.state === "requested" || (instance.rootIdentity && !processIsAlive(instance.rootIdentity.pid))) {
+            const outcome = { kind: "interrupted", reason: "owner-disconnect", message: "launch instance owner disconnected before reporting a terminal outcome" };
+            if (this.store.completeLaunchInstance(instance.id, instance.ownerClientId, "interrupted", outcome, new Date().toISOString())) {
+                this.#instances.delete(instance.id);
+                this.#uncertainInstances.delete(instance.id);
+                this.#mutated();
+            }
+            return;
+        }
+        this.#uncertainInstances.add(instance.id);
+        await this.#writeEndpointMetadata();
+    }
+    async #handleUpdateRelease(socket, request) {
+        const identityMatches = request.bootNonce === this.bootNonce && typeof request.targetVersion === "string";
+        if (!identityMatches) {
+            this.#send(socket, {
+                type: "release-update-result",
+                accepted: false,
+                reason: "boot nonce or target version mismatch",
+                liveInstanceIds: this.#liveInstanceIds(),
+            });
             return;
-        const outcome = { kind: "stopped", reason: "update" };
-        if (!this.store.releaseForegroundTerminalLease(lease.id, lease.processIdentity, outcome, new Date().toISOString()))
-            throw new Error("foreground terminal lease update shutdown was rejected");
-        this.#foregroundLease = null;
+        }
+        const released = await this.#drainInstances("update", this.shutdownDeadlineMs);
+        this.#send(socket, {
+            type: "release-update-result",
+            accepted: released,
+            reason: released
+                ? `verified ${PRODUCT_TEXT.displayName} owner drained all launch instances for immediate update shutdown`
+                : "one or more launch instances did not release verified ownership within the update deadline",
+            liveInstanceIds: this.#liveInstanceIds(),
+        });
+        if (released)
+            setTimeout(() => void this.closeForReleaseReplacement(false), 25);
+    }
+    async #drainInstances(reason, timeoutMs) {
+        if (this.#instances.size === 0)
+            return true;
+        this.#requestStopAll(reason);
+        const deadline = Date.now() + timeoutMs;
+        while (Date.now() < deadline) {
+            if (this.#instances.size === 0) {
+                // Let the terminal command result flush before closing owner sockets.
+                await new Promise(resolvePromise => setTimeout(resolvePromise, 25));
+                return this.#instances.size === 0;
+            }
+            await new Promise(resolvePromise => setTimeout(resolvePromise, 25));
+        }
+        return this.#instances.size === 0;
     }
-    #liveGenerationIds() {
-        return this.#foregroundLease?.generationId ? [this.#foregroundLease.generationId] : [];
+    #requestStopAll(reason) {
+        for (const [instanceId, socket] of this.#instanceOwners) {
+            this.#send(socket, { type: "stop-launch-instance", requestId: randomUUID(), instanceId, reason });
+        }
+    }
+    #mutated() {
+        this.#revision += 1;
+        void this.#writeEndpointMetadata();
+    }
+    #liveInstanceIds() {
+        return [...this.#instances.keys()];
     }
     #writeEndpointMetadata() {
+        const liveInstanceIds = this.#liveInstanceIds();
         const metadata = {
             schema: PRODUCT_IDENTITY.protocol.supervisorSchema,
             ...localControlHello(this.release.releaseId),
@@ -246,9 +406,10 @@ export class SupervisorServer {
             releaseRoot: this.release.releaseRoot,
             contentDigest: this.release.contentDigest,
             ownership: {
-                state: this.#foregroundLease ? "busy" : "idle",
-                liveGenerationIds: this.#liveGenerationIds(),
-                nonResumableGenerationIds: this.#liveGenerationIds(),
+                state: this.#uncertainInstances.size > 0 ? "blocked" : liveInstanceIds.length > 0 ? "busy" : "idle",
+                liveInstanceIds,
+                nonResumableInstanceIds: liveInstanceIds,
+                uncertainInstanceIds: [...this.#uncertainInstances],
             },
         };
         const temporary = `${this.paths.endpointMetadataPath}.${process.pid}.tmp`;
@@ -270,6 +431,12 @@ export class SupervisorServer {
         socket.write(frame);
     }
 }
+function sameProcessIdentity(left, right) {
+    return left !== null && left.pid === right.pid && left.startIdentity === right.startIdentity;
+}
+function sameContainmentIdentity(left, right) {
+    return left !== null && left.provider === right.provider && left.token === right.token;
+}
 function isMessageType(value, type) {
     return typeof value === "object" && value !== null && "type" in value && value.type === type;
 }

package/dist/src/foundation/transparent-terminal/command-resolution.js

@@ -1,5 +1,5 @@
 import { access, readFile } from "node:fs/promises";
-import { delimiter, extname, isAbsolute, resolve } from "node:path";
+import { extname, isAbsolute, resolve } from "node:path";
 /** Resolve a command without invoking a command interpreter. */
 export async function resolveTransparentCommand(executable, arguments_, options) {
     const platform = options.platform ?? process.platform;
@@ -17,7 +17,7 @@ async function resolveWindowsCommand(command, commandArguments, options) {
 }
 async function resolveWindowsPathCommand(executable, cwd, environment) {
     const hasPath = isAbsolute(executable) || executable.includes("/") || executable.includes("\\");
-    const roots = hasPath ? [cwd] : windowsPath(environment).split(delimiter).filter(Boolean);
+    const roots = hasPath ? [cwd] : windowsPath(environment).split(";").filter(Boolean);
     const extension = extname(executable);
     const extensions = extension ? [""] : windowsExecutableExtensions(environment);
     for (const root of roots) {
@@ -56,7 +56,10 @@ function windowsPath(environment) {
 }
 function windowsExecutableExtensions(environment) {
     const source = environment.PATHEXT ?? ".COM;.EXE;.BAT;.CMD";
-    return source.split(";").filter(Boolean).map(value => value.startsWith(".") ? value : `.${value}`);
+    return [...new Set(source.split(";").filter(Boolean).flatMap(value => {
+            const extension = value.startsWith(".") ? value : `.${value}`;
+            return [extension, extension.toLowerCase()];
+        }))];
 }
 async function isFile(path) {
     try {

package/dist/src/foundation/transparent-terminal/foreground-broker.d.ts

@@ -1,7 +1,4 @@
-import type { CommandResult, ForegroundTerminalLeaseId, GenerationId, NativeProcessIdentity, RequestId, SupervisorCommand, TransparentTerminalLaunchProfile, TransparentTerminalLifecycleOutcome } from "../lifecycle/index.js";
-export interface ForegroundLeaseControl {
-    command(command: SupervisorCommand): Promise<CommandResult>;
-}
+import type { NativeProcessIdentity, TransparentTerminalLaunchProfile, TransparentTerminalLifecycleOutcome } from "../lifecycle/index.js";
 export type TransparentStopReason = "owner-disconnect" | "user-request" | "update";
 export interface TransparentChildHandle {
     readonly processIdentity: NativeProcessIdentity;
@@ -12,21 +9,16 @@ export interface TransparentNativeLauncher {
     launch(profile: TransparentTerminalLaunchProfile): Promise<TransparentChildHandle>;
 }
 export interface ForegroundBrokerRequest {
-    readonly leaseId: ForegroundTerminalLeaseId;
-    readonly generationId: GenerationId;
-    readonly ownerId: string;
     readonly profile: TransparentTerminalLaunchProfile;
     readonly stopRequested?: Promise<TransparentStopReason>;
 }
 export interface ForegroundBrokerResult {
-    readonly leaseId: ForegroundTerminalLeaseId;
-    readonly generationId: GenerationId;
     readonly processIdentity: NativeProcessIdentity | null;
     readonly outcome: TransparentTerminalLifecycleOutcome;
 }
 /**
- * Coordinates ownership around one natively attached child. Ordinary terminal
- * data never enters this object: the launcher owns native attachment and this
- * broker observes only process identity and the final lifecycle outcome.
+ * Waits for one directly attached child. Launch-instance registration and
+ * process-tree containment belong to the outer profile-neutral guardian.
+ * Ordinary terminal data never enters this object.
  */
-export declare function runForegroundBroker(request: ForegroundBrokerRequest, control: ForegroundLeaseControl, launcher: TransparentNativeLauncher, createRequestId: () => RequestId): Promise<ForegroundBrokerResult>;
+export declare function runForegroundBroker(request: ForegroundBrokerRequest, launcher: TransparentNativeLauncher): Promise<ForegroundBrokerResult>;

package/dist/src/foundation/transparent-terminal/foreground-broker.js

@@ -1,83 +1,26 @@
 import { assertNativeProcessIdentity, assertTransparentTerminalLaunchProfile } from "../lifecycle/index.js";
 /**
- * Coordinates ownership around one natively attached child. Ordinary terminal
- * data never enters this object: the launcher owns native attachment and this
- * broker observes only process identity and the final lifecycle outcome.
+ * Waits for one directly attached child. Launch-instance registration and
+ * process-tree containment belong to the outer profile-neutral guardian.
+ * Ordinary terminal data never enters this object.
  */
-export async function runForegroundBroker(request, control, launcher, createRequestId) {
-    assertRequest(request);
-    await requireAccepted(control, {
-        type: "acquire-foreground-terminal-lease",
-        requestId: createRequestId(),
-        leaseId: request.leaseId,
-        ownerId: request.ownerId,
-        profile: request.profile,
-    });
+export async function runForegroundBroker(request, launcher) {
+    assertTransparentTerminalLaunchProfile(request.profile);
     let handle;
     try {
         handle = await launcher.launch(request.profile);
         assertNativeProcessIdentity(handle.processIdentity);
     }
     catch (error) {
-        const outcome = {
-            kind: "spawn-error",
-            message: errorMessage(error),
-            code: errorCode(error),
-        };
-        await requireAccepted(control, {
-            type: "release-foreground-terminal-lease",
-            requestId: createRequestId(),
-            leaseId: request.leaseId,
+        return {
             processIdentity: null,
-            outcome,
-        });
-        return { leaseId: request.leaseId, generationId: request.generationId, processIdentity: null, outcome };
-    }
-    try {
-        await requireAccepted(control, {
-            type: "activate-foreground-terminal-lease",
-            requestId: createRequestId(),
-            leaseId: request.leaseId,
-            generationId: request.generationId,
-            processIdentity: handle.processIdentity,
-        });
-        const outcome = request.stopRequested
-            ? await Promise.race([handle.outcome, request.stopRequested.then(async (reason) => await handle.stop(reason))])
-            : await handle.outcome;
-        await requireAccepted(control, {
-            type: "release-foreground-terminal-lease",
-            requestId: createRequestId(),
-            leaseId: request.leaseId,
-            processIdentity: handle.processIdentity,
-            outcome,
-        });
-        return { leaseId: request.leaseId, generationId: request.generationId, processIdentity: handle.processIdentity, outcome };
-    }
-    catch (error) {
-        const outcome = {
-            kind: "broker-error",
-            message: errorMessage(error),
-            code: errorCode(error),
+            outcome: { kind: "spawn-error", message: errorMessage(error), code: errorCode(error) },
         };
-        await control.command({
-            type: "release-foreground-terminal-lease",
-            requestId: createRequestId(),
-            leaseId: request.leaseId,
-            processIdentity: handle.processIdentity,
-            outcome,
-        }).catch(() => undefined);
-        throw error;
     }
-}
-function assertRequest(request) {
-    if (!request.leaseId || !request.generationId || !request.ownerId)
-        throw new TypeError("foreground broker identities are required");
-    assertTransparentTerminalLaunchProfile(request.profile);
-}
-async function requireAccepted(control, command) {
-    const result = await control.command(command);
-    if (!result.ok)
-        throw new Error(result.error?.message ?? `supervisor rejected ${command.type}`);
+    const outcome = request.stopRequested
+        ? await Promise.race([handle.outcome, request.stopRequested.then(async (reason) => await handle.stop(reason))])
+        : await handle.outcome;
+    return { processIdentity: handle.processIdentity, outcome };
 }
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);

package/dist/src/foundation/transparent-terminal/main.js

@@ -2,22 +2,16 @@ import { randomUUID } from "node:crypto";
 import { realpath } from "node:fs/promises";
 import { resolve } from "node:path";
 import { assertLaunchProfileId } from "../lifecycle/index.js";
-import { SupervisorClient } from "../protocol/index.js";
-import { resolveProductPaths } from "../supervision/index.js";
 import { runForegroundBroker } from "./foreground-broker.js";
 import { createPlatformTransparentLauncher } from "./native-launcher.js";
 export async function runTransparentForeground(options) {
     const environment = { ...(options.environment ?? process.env) };
     const profileId = options.profileId ?? environment.A1_LAUNCH_PROFILE ?? "a1";
     assertLaunchProfileId(profileId);
-    const paths = resolveProductPaths(environment);
-    const client = new SupervisorClient(environment.A1_RELEASE_ID);
-    await client.connect(paths.endpoint);
-    const ownerId = `foreground-broker-${randomUUID()}`;
     const profile = await launchProfile(environment, options, profileId);
     const stop = stopSignal();
     try {
-        const result = await runForegroundBroker({ leaseId: randomUUID(), generationId: randomUUID(), ownerId, profile, stopRequested: stop.requested }, client, createPlatformTransparentLauncher(), randomUUID);
+        const result = await runForegroundBroker({ profile, stopRequested: stop.requested }, createPlatformTransparentLauncher());
         if (result.outcome.kind === "exited")
             return result.outcome.exitCode;
         if (result.outcome.kind === "signaled")
@@ -28,7 +22,6 @@ export async function runTransparentForeground(options) {
     }
     finally {
         stop.dispose();
-        client.close();
     }
 }
 async function launchProfile(environment, options, profileId) {