@loucompanion/forge-bridge 0.1.3-dev.b6be5e7f9668 → 0.1.3-dev.ba7d36726eda

package/dist/cli/local-config.d.ts

@@ -7,6 +7,8 @@ export interface BridgeLocalConfig {
     readonly deviceName?: string;
     readonly defaultRepoRoot?: string;
     readonly cleanupWorktrees?: boolean;
+    readonly dockerEnabled?: boolean;
+    readonly allowOpenPublicSandbox?: boolean;
     readonly cliProviders?: readonly string[];
     readonly providerStatuses?: Readonly<Record<string, BridgeProviderStatus>>;
     readonly projectLabels?: readonly string[];
@@ -17,6 +19,8 @@ export interface BridgeLocalConfig {
     readonly supportsManagedForgeArtifacts?: boolean;
     readonly supportsRunnerAuthoredPhaseArtifacts?: boolean;
     readonly supportsDraftRunOnce?: boolean;
+    readonly supportsDraftAttachments?: boolean;
+    readonly supportsDraftImageAttachments?: boolean;
 }
 export interface LocalRepoMapping extends BridgeRepoMapping {
     readonly label: string;
@@ -32,4 +36,6 @@ export declare function removeRepoMapping(label: string): Promise<{
     readonly config: BridgeLocalConfig;
     readonly removed: boolean;
 }>;
+export declare function setServerUrl(serverUrl: string): Promise<BridgeLocalConfig>;
+export declare function setSandboxPolicy(dockerEnabled: boolean, allowOpenPublicSandbox: boolean): Promise<BridgeLocalConfig>;
 export declare function providerStatusesFor(providers: readonly string[]): Readonly<Record<string, BridgeProviderStatus>>;

package/dist/cli/local-config.js

@@ -45,6 +45,12 @@ export function applyLocalConfigDefaults(config, local) {
         deviceName: process.env.FORGE_DEVICE_NAME ?? local.deviceName ?? config.deviceName,
         defaultRepoRoot: process.env.FORGE_REPO_ROOT ?? local.defaultRepoRoot ?? config.defaultRepoRoot,
         cleanupWorktrees: local.cleanupWorktrees ?? config.cleanupWorktrees,
+        dockerEnabled: process.env.FORGE_DOCKER_SANDBOX === undefined
+            ? local.dockerEnabled ?? config.dockerEnabled
+            : config.dockerEnabled,
+        allowOpenPublicSandbox: process.env.FORGE_ALLOW_OPEN_PUBLIC_SANDBOX === undefined
+            ? local.allowOpenPublicSandbox ?? config.allowOpenPublicSandbox
+            : config.allowOpenPublicSandbox,
         cliProviders,
         providerStatuses: normalizeProviderStatuses(local.providerStatuses) ?? providerStatusesFor(cliProviders),
         projectLabels: local.projectLabels ?? config.projectLabels,
@@ -54,7 +60,9 @@ export function applyLocalConfigDefaults(config, local) {
         supportsManagedWorktrees: local.supportsManagedWorktrees ?? config.supportsManagedWorktrees,
         supportsManagedForgeArtifacts: local.supportsManagedForgeArtifacts ?? config.supportsManagedForgeArtifacts,
         supportsRunnerAuthoredPhaseArtifacts: local.supportsRunnerAuthoredPhaseArtifacts ?? config.supportsRunnerAuthoredPhaseArtifacts,
-        supportsDraftRunOnce: local.supportsDraftRunOnce ?? config.supportsDraftRunOnce
+        supportsDraftRunOnce: local.supportsDraftRunOnce ?? config.supportsDraftRunOnce,
+        supportsDraftAttachments: local.supportsDraftAttachments ?? config.supportsDraftAttachments,
+        supportsDraftImageAttachments: local.supportsDraftImageAttachments ?? config.supportsDraftImageAttachments
     };
 }
 export async function addRepoMapping(label, repoPath) {
@@ -86,6 +94,19 @@ export async function removeRepoMapping(label) {
     await writeLocalConfig(next);
     return { config: next, removed: after.length !== before.length };
 }
+export async function setServerUrl(serverUrl) {
+    const normalized = normalizeServerUrl(serverUrl);
+    const current = await readLocalConfig();
+    const next = normalizeLocalConfig({ ...current, serverUrl: normalized });
+    await writeLocalConfig(next);
+    return next;
+}
+export async function setSandboxPolicy(dockerEnabled, allowOpenPublicSandbox) {
+    const current = await readLocalConfig();
+    const next = normalizeLocalConfig({ ...current, dockerEnabled, allowOpenPublicSandbox });
+    await writeLocalConfig(next);
+    return next;
+}
 export function providerStatusesFor(providers) {
     return Object.fromEntries(providers.map((provider) => [provider, { signedIn: true, version: "", models: configuredModelsFor(provider) }]));
 }
@@ -104,6 +125,8 @@ function normalizeLocalConfig(config) {
         deviceName: cleanString(config.deviceName),
         defaultRepoRoot: cleanString(config.defaultRepoRoot),
         cleanupWorktrees: config.cleanupWorktrees,
+        dockerEnabled: config.dockerEnabled,
+        allowOpenPublicSandbox: config.allowOpenPublicSandbox,
         cliProviders: cleanList(config.cliProviders),
         providerStatuses: normalizeProviderStatuses(config.providerStatuses),
         projectLabels: cleanList(config.projectLabels),
@@ -113,7 +136,9 @@ function normalizeLocalConfig(config) {
         supportsManagedWorktrees: config.supportsManagedWorktrees,
         supportsManagedForgeArtifacts: config.supportsManagedForgeArtifacts,
         supportsRunnerAuthoredPhaseArtifacts: config.supportsRunnerAuthoredPhaseArtifacts,
-        supportsDraftRunOnce: config.supportsDraftRunOnce
+        supportsDraftRunOnce: config.supportsDraftRunOnce,
+        supportsDraftAttachments: config.supportsDraftAttachments,
+        supportsDraftImageAttachments: config.supportsDraftImageAttachments
     };
 }
 function emptyConfig() {
@@ -207,6 +232,24 @@ function cleanString(value) {
     const clean = value?.trim();
     return clean ? clean : undefined;
 }
+function normalizeServerUrl(value) {
+    const clean = value.trim();
+    let parsed;
+    try {
+        parsed = new URL(clean);
+    }
+    catch {
+        throw new Error(`Invalid Forge server URL: ${value}`);
+    }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        throw new Error("Forge server URL must use http or https.");
+    }
+    if (parsed.username || parsed.password || parsed.search || parsed.hash) {
+        throw new Error("Forge server URL cannot include credentials, a query string, or a fragment.");
+    }
+    parsed.pathname = parsed.pathname.replace(/\/+$/u, "") || "/";
+    return parsed.toString().replace(/\/$/u, "");
+}
 function cleanList(values) {
     const clean = [...new Set((values ?? []).map((value) => value.trim()).filter(Boolean))];
     return clean.length > 0 ? clean : undefined;

package/dist/runtime/attempt-node-runtime-launcher.d.ts

@@ -0,0 +1,15 @@
+import type { AttemptProcessChildHandle, AttemptProcessSupervisor } from "./attempt-process-supervisor.js";
+import type { HostPortLeaseOwner } from "./host-port-broker.js";
+import { HostListenerInspector } from "./host-listener-inspector.js";
+import type { HostListenerOwnership, NodeRuntimeCommandLauncher, NodeRuntimeLaunchRequest } from "./node-host-runtime-adapter.js";
+/** Launches one explicitly configured HTTP project beneath the attempt coordinator. */
+export declare class AttemptNodeRuntimeLauncher implements NodeRuntimeCommandLauncher<AttemptProcessChildHandle> {
+    private readonly supervisor;
+    private readonly owner;
+    private readonly logDirectory;
+    private readonly listenerInspector;
+    constructor(supervisor: AttemptProcessSupervisor, owner: HostPortLeaseOwner, logDirectory: string, listenerInspector?: HostListenerInspector);
+    launch(request: NodeRuntimeLaunchRequest, signal?: AbortSignal): Promise<AttemptProcessChildHandle>;
+    inspectListener(child: AttemptProcessChildHandle, request: NodeRuntimeLaunchRequest): Promise<HostListenerOwnership>;
+    stop(child: AttemptProcessChildHandle): Promise<void>;
+}

package/dist/runtime/attempt-node-runtime-launcher.js

@@ -0,0 +1,50 @@
+import { createHash } from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { HostListenerInspector } from "./host-listener-inspector.js";
+/** Launches one explicitly configured HTTP project beneath the attempt coordinator. */
+export class AttemptNodeRuntimeLauncher {
+    supervisor;
+    owner;
+    logDirectory;
+    listenerInspector;
+    constructor(supervisor, owner, logDirectory, listenerInspector = new HostListenerInspector()) {
+        this.supervisor = supervisor;
+        this.owner = owner;
+        this.logDirectory = logDirectory;
+        this.listenerInspector = listenerInspector;
+    }
+    async launch(request, signal) {
+        const childName = projectChildName(request.port.name);
+        const stdoutPath = path.join(this.logDirectory, `${childName}.stdout.log`);
+        const stderrPath = path.join(this.logDirectory, `${childName}.stderr.log`);
+        const child = await this.supervisor.startChild(childName, {
+            command: request.command,
+            args: request.args,
+            cwd: request.cwd,
+            env: request.environment,
+            captureOutput: false,
+        }, {
+            onStdoutLine: async (line) => await appendLine(stdoutPath, line),
+            onStderrLine: async (line) => await appendLine(stderrPath, line),
+        }, signal);
+        await child.ready;
+        return child;
+    }
+    async inspectListener(child, request) {
+        return await this.listenerInspector.inspect(child, request.port, this.owner);
+    }
+    async stop(child) {
+        await child.stop(this.owner.fencingToken);
+    }
+}
+function projectChildName(portName) {
+    const candidate = `project-${portName}`;
+    if (/^[a-z][a-z0-9_-]{0,31}$/u.test(candidate))
+        return candidate;
+    const digest = createHash("sha256").update(portName).digest("hex").slice(0, 16);
+    return `project-${digest}`;
+}
+async function appendLine(target, line) {
+    await fs.appendFile(target, `${line}\n`, { encoding: "utf8", mode: 0o600 });
+}

package/dist/runtime/attempt-process-supervisor-registry.d.ts

@@ -0,0 +1,20 @@
+import type { ProviderProcessHandlers, ProviderProcessRunRequest, ProviderProcessRunner, ProviderProcessRunResult } from "../session/provider-cli/provider-cli.process.js";
+import { AttemptProcessSupervisor, type AttemptProcessSupervisorIdentity, type AttemptProcessSupervisorOptions } from "./attempt-process-supervisor.js";
+/** Runner-local authority for active host attempt process coordinators. */
+export declare class AttemptProcessSupervisorRegistry {
+    private readonly active;
+    register(identity: AttemptProcessSupervisorIdentity, runner: ProviderProcessRunner, options?: AttemptProcessSupervisorOptions): AttemptProcessSupervisor;
+    require(dispatchAttemptId: string, fencingToken: string): AttemptProcessSupervisor;
+    unregister(dispatchAttemptId: string, fencingToken: string): boolean;
+    has(dispatchAttemptId: string): boolean;
+}
+/**
+ * Routes managed-host provider commands through the attempt's named provider
+ * child while retaining the raw runner for Docker and unmanaged execution.
+ */
+export declare class AttemptCoordinatedProviderProcessRunner implements ProviderProcessRunner {
+    private readonly registry;
+    private readonly rawRunner;
+    constructor(registry: AttemptProcessSupervisorRegistry, rawRunner: ProviderProcessRunner);
+    run(request: ProviderProcessRunRequest, handlers?: ProviderProcessHandlers, signal?: AbortSignal): Promise<ProviderProcessRunResult>;
+}

package/dist/runtime/attempt-process-supervisor-registry.js

@@ -0,0 +1,64 @@
+import { AttemptProcessSupervisor, } from "./attempt-process-supervisor.js";
+/** Runner-local authority for active host attempt process coordinators. */
+export class AttemptProcessSupervisorRegistry {
+    active = new Map();
+    register(identity, runner, options = {}) {
+        const existing = this.active.get(identity.dispatchAttemptId);
+        if (existing) {
+            if (existing.fencingToken !== identity.fencingToken) {
+                throw new Error("attempt_process_registry_conflict: dispatch attempt is registered under a different fence.");
+            }
+            return existing.supervisor;
+        }
+        const supervisor = new AttemptProcessSupervisor(identity, runner, options);
+        this.active.set(identity.dispatchAttemptId, { fencingToken: identity.fencingToken, supervisor });
+        return supervisor;
+    }
+    require(dispatchAttemptId, fencingToken) {
+        const registered = this.active.get(dispatchAttemptId);
+        if (!registered) {
+            throw new Error("attempt_process_registry_missing: no process coordinator owns this dispatch attempt.");
+        }
+        if (registered.fencingToken !== fencingToken) {
+            throw new Error("attempt_process_registry_fenced: process coordinator fence does not match the dispatch.");
+        }
+        return registered.supervisor;
+    }
+    unregister(dispatchAttemptId, fencingToken) {
+        const registered = this.active.get(dispatchAttemptId);
+        if (!registered || registered.fencingToken !== fencingToken)
+            return false;
+        return this.active.delete(dispatchAttemptId);
+    }
+    has(dispatchAttemptId) {
+        return this.active.has(dispatchAttemptId);
+    }
+}
+/**
+ * Routes managed-host provider commands through the attempt's named provider
+ * child while retaining the raw runner for Docker and unmanaged execution.
+ */
+export class AttemptCoordinatedProviderProcessRunner {
+    registry;
+    rawRunner;
+    constructor(registry, rawRunner) {
+        this.registry = registry;
+        this.rawRunner = rawRunner;
+    }
+    async run(request, handlers, signal) {
+        if (request.env?.FORGE_RUNTIME_MODE !== "host") {
+            return await this.rawRunner.run(request, handlers, signal);
+        }
+        const dispatchAttemptId = requiredEnvironment(request, "FORGE_DISPATCH_ATTEMPT_ID");
+        const fencingToken = requiredEnvironment(request, "FORGE_FENCING_TOKEN");
+        const supervisor = this.registry.require(dispatchAttemptId, fencingToken);
+        const child = await supervisor.startChild("provider", request, handlers, signal);
+        return await child.result;
+    }
+}
+function requiredEnvironment(request, name) {
+    const value = request.env?.[name]?.trim();
+    if (!value)
+        throw new Error(`attempt_process_registry_invalid: ${name} is required for managed-host execution.`);
+    return value;
+}

package/dist/runtime/attempt-process-supervisor.d.ts

@@ -0,0 +1,74 @@
+import type { ProviderProcessHandlers, ProviderProcessRunRequest, ProviderProcessRunner, ProviderProcessRunResult } from "../session/provider-cli/provider-cli.process.js";
+export type AttemptProcessChildStatus = "starting" | "running" | "stopping" | "exited" | "failed";
+export type AttemptProcessSupervisorStatus = "active" | "stopping" | "stopped" | "degraded";
+export interface AttemptProcessSupervisorIdentity {
+    readonly processSupervisorId: string;
+    readonly dispatchAttemptId: string;
+    readonly executionLeaseId: string;
+    readonly fencingToken: string;
+    readonly logDirectory: string;
+}
+export interface AttemptProcessChildLedgerEntry {
+    readonly name: string;
+    readonly generation: number;
+    readonly childId: string;
+    readonly processSupervisorId: string;
+    readonly metadataPath: string;
+    readonly status: AttemptProcessChildStatus;
+    readonly startedAt: string;
+    readonly settledAt?: string;
+    readonly exitCode?: number;
+    readonly failure?: string;
+}
+export interface AttemptProcessSupervisorLedger {
+    readonly schemaVersion: 1;
+    readonly attemptSupervisorId: string;
+    readonly dispatchAttemptId: string;
+    readonly executionLeaseId: string;
+    readonly status: AttemptProcessSupervisorStatus;
+    readonly updatedAt: string;
+    readonly children: readonly AttemptProcessChildLedgerEntry[];
+}
+export interface AttemptProcessChildHandle {
+    readonly name: string;
+    readonly generation: number;
+    readonly childId: string;
+    readonly processSupervisorId: string;
+    readonly metadataPath: string;
+    readonly ready: Promise<void>;
+    readonly result: Promise<ProviderProcessRunResult>;
+    stop(fencingToken: string): Promise<ProviderProcessRunResult>;
+}
+export interface AttemptProcessSupervisorOptions {
+    readonly metadataReadyTimeoutMs?: number;
+    readonly signal?: AbortSignal;
+}
+/**
+ * Owns the independently supervised process trees that belong to one host
+ * dispatch attempt. Each named child gets a distinct Windows Job Object or
+ * Unix process group through the existing process runner, while this
+ * coordinator supplies shared fencing, cancellation, and a durable ledger.
+ */
+export declare class AttemptProcessSupervisor {
+    private readonly runner;
+    readonly ledgerPath: string;
+    private readonly identity;
+    private readonly metadataReadyTimeoutMs;
+    private readonly records;
+    private readonly currentByName;
+    private readonly attemptController;
+    private status;
+    private persistTail;
+    private persistenceFailure;
+    private stopOperation;
+    constructor(identity: AttemptProcessSupervisorIdentity, runner: ProviderProcessRunner, options?: AttemptProcessSupervisorOptions);
+    startChild(name: string, request: ProviderProcessRunRequest, handlers?: ProviderProcessHandlers, signal?: AbortSignal): Promise<AttemptProcessChildHandle>;
+    stopChild(name: string, generation: number, fencingToken: string, reason?: unknown): Promise<ProviderProcessRunResult>;
+    stopAll(fencingToken: string, reason?: unknown): Promise<void>;
+    private performStopAll;
+    snapshot(): AttemptProcessSupervisorLedger;
+    private observeChildReady;
+    private settleChild;
+    private assertFence;
+    private persist;
+}

package/dist/runtime/attempt-process-supervisor.js

@@ -0,0 +1,290 @@
+import { createHash } from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+const terminalChildStatuses = new Set(["exited", "failed"]);
+/**
+ * Owns the independently supervised process trees that belong to one host
+ * dispatch attempt. Each named child gets a distinct Windows Job Object or
+ * Unix process group through the existing process runner, while this
+ * coordinator supplies shared fencing, cancellation, and a durable ledger.
+ */
+export class AttemptProcessSupervisor {
+    runner;
+    ledgerPath;
+    identity;
+    metadataReadyTimeoutMs;
+    records = [];
+    currentByName = new Map();
+    attemptController = new AbortController();
+    status = "active";
+    persistTail = Promise.resolve();
+    persistenceFailure;
+    stopOperation = null;
+    constructor(identity, runner, options = {}) {
+        this.runner = runner;
+        this.identity = validateIdentity(identity);
+        this.metadataReadyTimeoutMs = boundedInteger(options.metadataReadyTimeoutMs ?? 10_000, 100, 120_000, "metadataReadyTimeoutMs");
+        this.ledgerPath = path.join(this.identity.logDirectory, "attempt-process-supervisor.json");
+        if (options.signal?.aborted) {
+            this.status = "stopping";
+            this.attemptController.abort(options.signal.reason);
+        }
+        else {
+            options.signal?.addEventListener("abort", () => {
+                void this.stopAll(this.identity.fencingToken, options.signal?.reason).catch(error => {
+                    this.persistenceFailure ??= error;
+                });
+            }, { once: true });
+        }
+    }
+    async startChild(name, request, handlers = {}, signal) {
+        assertChildName(name);
+        if (this.status !== "active" || this.attemptController.signal.aborted) {
+            throw new Error("attempt_process_supervisor_closed: the attempt no longer accepts child processes.");
+        }
+        if (signal?.aborted)
+            throw cancellationError(signal);
+        const existing = this.currentByName.get(name);
+        if (existing && !terminalChildStatuses.has(existing.status)) {
+            throw new Error(`attempt_process_supervisor_conflict: child '${name}' is already active.`);
+        }
+        const generation = (existing?.generation ?? 0) + 1;
+        const childId = `${name}:${generation}`;
+        const processSupervisorId = childProcessSupervisorId(this.identity.processSupervisorId, childId);
+        const metadataPath = path.join(this.identity.logDirectory, `process-supervisor.${name}.${generation}.json`);
+        const controller = new AbortController();
+        const combinedSignal = signal
+            ? AbortSignal.any([this.attemptController.signal, controller.signal, signal])
+            : AbortSignal.any([this.attemptController.signal, controller.signal]);
+        const childRequest = {
+            ...request,
+            env: {
+                ...request.env,
+                FORGE_RUNTIME_MODE: "host",
+                FORGE_RESOURCE_LEASE_ID: this.identity.executionLeaseId,
+                FORGE_EXECUTION_LEASE_ID: this.identity.executionLeaseId,
+                FORGE_DISPATCH_ATTEMPT_ID: this.identity.dispatchAttemptId,
+                FORGE_FENCING_TOKEN: this.identity.fencingToken,
+                FORGE_LOG_DIR: this.identity.logDirectory,
+                FORGE_PROCESS_SUPERVISOR_ID: processSupervisorId,
+                FORGE_PROCESS_SUPERVISOR_METADATA_PATH: metadataPath,
+                FORGE_PROCESS_CHILD_ID: childId,
+                FORGE_PROCESS_CHILD_NAME: name,
+                FORGE_PROCESS_CHILD_GENERATION: String(generation),
+            },
+        };
+        const startedAt = new Date().toISOString();
+        const record = {
+            name,
+            generation,
+            childId,
+            processSupervisorId,
+            metadataPath,
+            controller,
+            startedAt,
+            status: "starting",
+            result: Promise.resolve({ exitCode: 1, stdout: "", stderr: "not started" }),
+        };
+        this.records.push(record);
+        this.currentByName.set(name, record);
+        const result = this.runner.run(childRequest, handlers, combinedSignal);
+        record.result = result;
+        void result.then(value => this.settleChild(record, "exited", value.exitCode), error => this.settleChild(record, "failed", undefined, error));
+        try {
+            await this.persist();
+        }
+        catch (error) {
+            controller.abort("Attempt process ledger could not be persisted.");
+            await result.catch(() => undefined);
+            throw error;
+        }
+        const ready = this.observeChildReady(record);
+        void ready.catch(() => undefined);
+        return {
+            name,
+            generation,
+            childId,
+            processSupervisorId,
+            metadataPath,
+            ready,
+            result,
+            stop: async (fencingToken) => await this.stopChild(name, generation, fencingToken),
+        };
+    }
+    async stopChild(name, generation, fencingToken, reason = "Forge stopped the supervised child.") {
+        this.assertFence(fencingToken);
+        const record = this.currentByName.get(name);
+        if (!record || record.generation !== generation) {
+            throw new Error(`attempt_process_supervisor_stale: child '${name}' generation ${generation} is no longer current.`);
+        }
+        if (!terminalChildStatuses.has(record.status)) {
+            record.status = "stopping";
+            record.controller.abort(reason);
+            await this.persist();
+        }
+        return await record.result;
+    }
+    async stopAll(fencingToken, reason = "Forge stopped the supervised attempt.") {
+        this.assertFence(fencingToken);
+        if (this.status === "stopped")
+            return;
+        if (!this.stopOperation) {
+            const operation = this.performStopAll(reason);
+            this.stopOperation = operation;
+            void operation.catch(() => undefined).finally(() => {
+                if (this.stopOperation === operation && this.status !== "stopped")
+                    this.stopOperation = null;
+            });
+        }
+        return await this.stopOperation;
+    }
+    async performStopAll(reason) {
+        this.status = "stopping";
+        this.attemptController.abort(reason);
+        const active = [...this.currentByName.values()].filter(record => !terminalChildStatuses.has(record.status));
+        for (const record of active)
+            record.status = "stopping";
+        await this.persist();
+        const results = await Promise.allSettled(active.map(record => record.result));
+        const rejected = results.filter((result) => result.status === "rejected");
+        this.status = rejected.length > 0 || this.persistenceFailure !== undefined ? "degraded" : "stopped";
+        await this.persist();
+        if (rejected.length > 0) {
+            throw new AggregateError(rejected.map(result => result.reason), "attempt_process_supervisor_cleanup_degraded");
+        }
+        if (this.persistenceFailure !== undefined)
+            throw this.persistenceFailure;
+    }
+    snapshot() {
+        return {
+            schemaVersion: 1,
+            attemptSupervisorId: this.identity.processSupervisorId,
+            dispatchAttemptId: this.identity.dispatchAttemptId,
+            executionLeaseId: this.identity.executionLeaseId,
+            status: this.status,
+            updatedAt: new Date().toISOString(),
+            children: this.records.map(record => ({
+                name: record.name,
+                generation: record.generation,
+                childId: record.childId,
+                processSupervisorId: record.processSupervisorId,
+                metadataPath: record.metadataPath,
+                status: record.status,
+                startedAt: record.startedAt,
+                ...(record.settledAt ? { settledAt: record.settledAt } : {}),
+                ...(record.exitCode === undefined ? {} : { exitCode: record.exitCode }),
+                ...(record.failure ? { failure: record.failure } : {}),
+            })),
+        };
+    }
+    async observeChildReady(record) {
+        const deadline = Date.now() + this.metadataReadyTimeoutMs;
+        while (Date.now() <= deadline) {
+            if (await fileExists(record.metadataPath)) {
+                if (record.status === "starting") {
+                    record.status = "running";
+                    await this.persist();
+                }
+                return;
+            }
+            if (terminalChildStatuses.has(record.status)) {
+                throw new Error(`attempt_process_supervisor_start_failed: child '${record.childId}' exited before supervision metadata was produced.`);
+            }
+            await wait(25);
+        }
+        record.controller.abort("Supervised child metadata was not produced before the readiness deadline.");
+        throw new Error(`attempt_process_supervisor_start_timeout: child '${record.childId}' did not become supervised.`);
+    }
+    async settleChild(record, status, exitCode, failure) {
+        record.status = status;
+        record.settledAt = new Date().toISOString();
+        record.exitCode = exitCode;
+        record.failure = failure === undefined ? undefined : boundedFailure(failure);
+        await this.persist().catch(error => {
+            this.persistenceFailure ??= error;
+            this.status = "degraded";
+        });
+    }
+    assertFence(fencingToken) {
+        if (fencingToken !== this.identity.fencingToken) {
+            throw new Error("attempt_process_supervisor_fenced: fencing token does not own this attempt.");
+        }
+    }
+    persist() {
+        const snapshot = this.snapshot();
+        const operation = this.persistTail.then(async () => {
+            await ensurePrivateDirectory(this.identity.logDirectory);
+            const temporary = `${this.ledgerPath}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`;
+            try {
+                const handle = await fs.open(temporary, "wx", 0o600);
+                try {
+                    await handle.writeFile(`${JSON.stringify(snapshot)}\n`);
+                    await handle.sync();
+                }
+                finally {
+                    await handle.close();
+                }
+                await fs.rename(temporary, this.ledgerPath);
+            }
+            catch (error) {
+                await fs.rm(temporary, { force: true }).catch(() => undefined);
+                throw error;
+            }
+        });
+        this.persistTail = operation.catch(() => undefined);
+        return operation;
+    }
+}
+function validateIdentity(identity) {
+    if (!/^[A-Za-z0-9][A-Za-z0-9_.-]{0,127}$/u.test(identity.processSupervisorId)) {
+        throw new Error("attempt_process_supervisor_invalid: process supervisor id is invalid.");
+    }
+    assertUuid(identity.dispatchAttemptId, "dispatch attempt");
+    assertUuid(identity.executionLeaseId, "execution lease");
+    assertUuid(identity.fencingToken, "fencing token");
+    if (!path.isAbsolute(identity.logDirectory)) {
+        throw new Error("attempt_process_supervisor_invalid: log directory must be absolute.");
+    }
+    return { ...identity, logDirectory: path.resolve(identity.logDirectory) };
+}
+function assertChildName(name) {
+    if (!/^[a-z][a-z0-9_-]{0,31}$/u.test(name)) {
+        throw new Error("attempt_process_supervisor_invalid: child name must be a safe lowercase identifier.");
+    }
+}
+function childProcessSupervisorId(attemptSupervisorId, childId) {
+    const digest = createHash("sha256")
+        .update(JSON.stringify([attemptSupervisorId, childId]))
+        .digest("hex")
+        .slice(0, 32);
+    return `host-${digest}`;
+}
+function assertUuid(value, label) {
+    if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu.test(value)) {
+        throw new Error(`attempt_process_supervisor_invalid: ${label} id must be a UUID.`);
+    }
+}
+function boundedInteger(value, minimum, maximum, name) {
+    if (!Number.isSafeInteger(value) || value < minimum || value > maximum) {
+        throw new Error(`attempt_process_supervisor_invalid: ${name} must be between ${minimum} and ${maximum}.`);
+    }
+    return value;
+}
+function boundedFailure(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return message.replaceAll(/[\r\n\t]+/gu, " ").slice(0, 512);
+}
+function cancellationError(signal) {
+    return new Error(String(signal.reason ?? "Supervised child launch was cancelled."));
+}
+async function ensurePrivateDirectory(directory) {
+    await fs.mkdir(directory, { recursive: true, mode: 0o700 });
+    if (process.platform !== "win32")
+        await fs.chmod(directory, 0o700);
+}
+async function fileExists(target) {
+    return await fs.stat(target).then(() => true, () => false);
+}
+function wait(milliseconds) {
+    return new Promise(resolve => setTimeout(resolve, milliseconds));
+}

package/dist/runtime/host-listener-inspector.d.ts

@@ -0,0 +1,28 @@
+import type { AttemptProcessChildHandle } from "./attempt-process-supervisor.js";
+import type { HostPortLeaseOwner, HostPortReservation } from "./host-port-broker.js";
+import type { HostListenerOwnership } from "./node-host-runtime-adapter.js";
+export interface HostInspectionCommandResult {
+    readonly exitCode: number;
+    readonly stdout: string;
+    readonly stderr: string;
+    readonly errorCode?: string;
+}
+export interface HostInspectionCommandRunner {
+    run(command: string, args: readonly string[]): Promise<HostInspectionCommandResult>;
+}
+/** Proves that a loopback listener belongs to one exact supervised child. */
+export declare class HostListenerInspector {
+    private readonly commands;
+    private readonly platform;
+    constructor(commands?: HostInspectionCommandRunner, platform?: NodeJS.Platform);
+    inspect(child: AttemptProcessChildHandle, reservation: HostPortReservation, owner: HostPortLeaseOwner): Promise<HostListenerOwnership>;
+    private inspectWindows;
+    private inspectUnix;
+}
+export declare class ExecFileInspectionCommandRunner implements HostInspectionCommandRunner {
+    run(command: string, args: readonly string[]): Promise<HostInspectionCommandResult>;
+}
+export declare function parseWindowsListenerPids(output: string, port: number): readonly number[];
+export declare function parseLsofPids(output: string): readonly number[];
+export declare function parseSsPids(output: string, port: number): readonly number[];
+export declare function parseProcessGroups(output: string): ReadonlyMap<number, number>;