@timurproko/a1 0.1.0 → 0.1.1-dev.10

package/dist/src/foundation/release/update.d.ts

@@ -1,5 +1,5 @@
 import { type UpdateTransaction, type UpdateTransactionPhase } from "./update-transaction.js";
-export declare const ADDONE_PACKAGE = "@timurproko/a1";
+export declare const PRODUCT_PACKAGE: string;
 export type UpdateChannel = "stable" | "next";
 export interface ProcessRequest {
     captureStdout: boolean;
@@ -18,6 +18,18 @@ export interface UpdateOutput {
     stdout(message: string): void;
     stderr(message: string): void;
 }
+export type UpdateMeasuredPhase = "package-version" | "target-resolution" | "global-root" | "ownership-release" | "npm-install" | "materialized" | "certified" | "active-reference-committed" | "supervisor-verified" | "transaction-complete";
+export interface UpdatePhaseTimingEvent {
+    readonly phase: UpdateMeasuredPhase;
+    readonly durationMs: number;
+}
+export interface UpdatePerformanceEvidence {
+    readonly fileCount: number;
+    readonly sourceReads: number;
+    readonly candidateWrites: number;
+    readonly verificationReads: number;
+    readonly postNpmDurationMs: number;
+}
 export interface SelfUpdateOptions {
     packageRoot: string;
     channel?: UpdateChannel;
@@ -27,14 +39,18 @@ export interface SelfUpdateOptions {
     runner?: UpdateProcessRunner;
     lifecycle?: UpdateLifecycleCoordinator;
     transactionStore?: UpdateTransactionJournal;
+    progress?: boolean;
+    onPhaseTiming?: (event: UpdatePhaseTimingEvent) => void;
+    now?: () => number;
 }
+export type UpdateActivationPhase = Extract<UpdateTransactionPhase, "materialized" | "certified" | "active-reference-committed">;
 export interface UpdateLifecycleCoordinator {
     targetIsActive(targetVersion: string): Promise<boolean>;
     shutdownVerifiedOwners(targetVersion: string): Promise<{
         priorActiveVersion: string | null;
     }>;
     verifyPackageUnlocked(packageRoot: string): Promise<void>;
-    activateInstalled(packageRoot: string, targetVersion: string, phase: (phase: UpdateTransactionPhase) => Promise<void>): Promise<void>;
+    activateInstalled(packageRoot: string, targetVersion: string, phase: (phase: UpdateActivationPhase) => Promise<void>): Promise<void>;
 }
 export interface UpdateTransactionJournal {
     readonly path: string;
@@ -50,6 +66,6 @@ export interface UpdateTransactionJournal {
     clearCompleted(): Promise<void>;
 }
 export declare function createNpmProcessRunner(platform?: NodeJS.Platform): UpdateProcessRunner;
-export declare function createUpdateLifecycleCoordinator(environment?: NodeJS.ProcessEnv, fileSystem?: UpdateFileSystem): UpdateLifecycleCoordinator;
+export declare function createUpdateLifecycleCoordinator(environment?: NodeJS.ProcessEnv, fileSystem?: UpdateFileSystem, output?: UpdateOutput): UpdateLifecycleCoordinator;
 export declare function runSelfUpdate(options: SelfUpdateOptions): Promise<number>;
-//# sourceMappingURL=update.d.ts.map
+export declare function assertUpdatePerformanceBudget(evidence: UpdatePerformanceEvidence, maximumPostNpmDurationMs?: number): void;

package/dist/src/foundation/release/update.js

@@ -4,14 +4,15 @@ import { connect } from "node:net";
 import { isAbsolute, relative, resolve, sep } from "node:path";
 import crossSpawn from "cross-spawn";
 import { valid as validSemver } from "semver";
+import { PRODUCT_IDENTITY, PRODUCT_TEXT } from "../../product-identity.js";
 import { certifyMaterializedRelease, probeOwnership, readEndpointMetadata, removeEndpointArtifacts, startSupervisor, waitForProcessExit, waitForVerifiedEndpoint, } from "./bootstrap.js";
-import { resolveAddOnePaths } from "../lifecycle/index.js";
+import { resolveProductPaths } from "../lifecycle/index.js";
 import { encodeFrame, LineFrameDecoder } from "../protocol/index.js";
 import { CohortStateStore } from "./cohort-state.js";
 import { cleanupVerifiedOwner, processIsAlive } from "./process-cleanup.js";
 import { materializeRelease, readMaterializedRelease } from "./release-store.js";
 import { UpdateTransactionStore } from "./update-transaction.js";
-export const ADDONE_PACKAGE = "@timurproko/a1";
+export const PRODUCT_PACKAGE = PRODUCT_TEXT.packageName;
 const UPDATE_DIST_TAGS = { stable: "latest", next: "next" };
 const defaultFileSystem = {
     async readFile(path) { return await readFile(path, "utf8"); },
@@ -39,8 +40,8 @@ export function createNpmProcessRunner(platform = process.platform) {
         } });
     });
 }
-export function createUpdateLifecycleCoordinator(environment = process.env, fileSystem = defaultFileSystem) {
-    const paths = resolveAddOnePaths(environment);
+export function createUpdateLifecycleCoordinator(environment = process.env, fileSystem = defaultFileSystem, output = defaultOutput) {
+    const paths = resolveProductPaths(environment);
     const stateStore = new CohortStateStore(paths.dataDir);
     return {
         async targetIsActive(targetVersion) {
@@ -59,7 +60,7 @@ export function createUpdateLifecycleCoordinator(environment = process.env, file
                 return { priorActiveVersion };
             const ownership = await probeOwnership(endpoint);
             if (ownership !== "live-verified" && ownership !== "dead") {
-                throw new Error(`AddOne refused update shutdown because supervisor ownership is ${ownership}`);
+                throw new Error(PRODUCT_TEXT.diagnostic(`refused update shutdown because supervisor ownership is ${ownership}`));
             }
             const immutableRoot = await canonicalImmutableRoot(paths.dataDir, endpoint.releaseRoot);
             const legacyMutableInstall = ownership === "live-verified" && !immutableRoot;
@@ -70,20 +71,20 @@ export function createUpdateLifecycleCoordinator(environment = process.env, file
                 // Explicit update consent permits bounded cleanup of an authenticated
                 // older owner that predates the update-shutdown message.
                 const cleanup = await cleanupVerifiedOwner(endpoint, {
-                    allowLiveGenerations: true,
+                    allowLiveInstances: true,
                     reason: legacyMutableInstall ? "legacy-mutable-install" : "explicit-update",
                 });
                 if (!cleanup.terminated)
-                    throw new Error(`verified AddOne owner ${endpoint.pid} rejected shutdown and could not be terminated: ${identity.reason}`);
+                    throw new Error(`verified ${PRODUCT_TEXT.displayName} owner ${endpoint.pid} rejected shutdown and could not be terminated: ${identity.reason}`);
             }
             else if (identity.accepted) {
                 await waitForProcessExit(endpoint.pid, 3_000).catch(async () => {
                     const cleanup = await cleanupVerifiedOwner(endpoint, {
-                        allowLiveGenerations: true,
+                        allowLiveInstances: true,
                         reason: legacyMutableInstall ? "legacy-mutable-install" : "explicit-update",
                     });
                     if (!cleanup.terminated)
-                        throw new Error(`verified AddOne owner ${endpoint.pid} did not terminate`);
+                        throw new Error(`verified ${PRODUCT_TEXT.displayName} owner ${endpoint.pid} did not terminate`);
                 });
             }
             await removeEndpointArtifacts(paths.endpointMetadataPath, paths.endpoint);
@@ -92,7 +93,7 @@ export function createUpdateLifecycleCoordinator(environment = process.env, file
         async verifyPackageUnlocked(packageRoot) {
             if (fileSystem.access)
                 await fileSystem.access(packageRoot);
-            const probe = `${packageRoot}.addone-unlock-probe`;
+            const probe = `${packageRoot}.${PRODUCT_IDENTITY.filesystem.slug}-unlock-probe`;
             const { rename } = await import("node:fs/promises");
             try {
                 await rename(packageRoot, probe);
@@ -101,13 +102,13 @@ export function createUpdateLifecycleCoordinator(environment = process.env, file
             catch (error) {
                 // Best-effort rollback if the first rename succeeded and the second did not.
                 await rename(probe, packageRoot).catch(() => { });
-                throw new Error(`AddOne package remains locked after verified shutdown: ${errorMessage(error)}`);
+                throw new Error(PRODUCT_TEXT.diagnostic(`package remains locked after verified shutdown: ${errorMessage(error)}`));
             }
         },
         async activateInstalled(packageRoot, targetVersion, phase) {
             const candidate = await materializeRelease(packageRoot, paths.dataDir);
             if (candidate.packageVersion !== targetVersion)
-                throw new Error(`installed AddOne version ${candidate.packageVersion} does not match target ${targetVersion}`);
+                throw new Error(`installed ${PRODUCT_TEXT.displayName} version ${candidate.packageVersion} does not match target ${targetVersion}`);
             await stateStore.recordCandidate(candidate);
             await phase("materialized");
             const diagnostics = await certifyMaterializedRelease(candidate, paths.dataDir);
@@ -120,38 +121,116 @@ export function createUpdateLifecycleCoordinator(environment = process.env, file
         },
     };
 }
+const PROGRESS_BAR_WIDTH = 39;
+const PROGRESS_TICK_MS = 200;
+const ACTIVATION_PROGRESS = {
+    materialized: { at: 85, creepTo: 90 },
+    certified: { at: 90, creepTo: 95 },
+    "active-reference-committed": { at: 95, creepTo: 99 },
+};
+function renderProgressBar(percent) {
+    const bounded = Math.min(100, Math.max(0, Math.round(percent)));
+    const filled = Math.round((bounded / 100) * PROGRESS_BAR_WIDTH);
+    return `${"█".repeat(filled)}${"░".repeat(PROGRESS_BAR_WIDTH - filled)} ${bounded}%`;
+}
+function createUpdateProgress(output, enabled) {
+    let visible = false;
+    let current = 0;
+    let shown = -1;
+    let timer = null;
+    const draw = () => {
+        const rounded = Math.round(current);
+        if (rounded === shown)
+            return;
+        shown = rounded;
+        visible = true;
+        output.stdout(`\r${renderProgressBar(rounded)}`);
+    };
+    const stopCreep = () => {
+        if (timer !== null) {
+            clearInterval(timer);
+            timer = null;
+        }
+    };
+    return {
+        set(percent, creepTo = percent) {
+            if (!enabled)
+                return;
+            stopCreep();
+            current = Math.max(current, percent);
+            shown = -1;
+            draw();
+            if (creepTo <= current)
+                return;
+            // Creep asymptotically toward (but never reach) the next milestone so
+            // long opaque phases such as npm install still show visible motion.
+            timer = setInterval(() => {
+                current = Math.min(creepTo - 0.5, current + (creepTo - current) * 0.04);
+                draw();
+            }, PROGRESS_TICK_MS);
+            timer.unref?.();
+        },
+        finish() {
+            stopCreep();
+            if (!visible)
+                return;
+            output.stdout(`\r${renderProgressBar(100)}\n`);
+            visible = false;
+        },
+        clear() {
+            stopCreep();
+            if (!visible)
+                return;
+            output.stdout(`\r${" ".repeat(PROGRESS_BAR_WIDTH + 6)}\r`);
+            visible = false;
+            shown = -1;
+        },
+    };
+}
 export async function runSelfUpdate(options) {
     const fileSystem = options.fileSystem ?? defaultFileSystem;
     const output = options.output ?? defaultOutput;
     const runner = options.runner ?? createNpmProcessRunner();
     const channel = options.channel ?? "stable";
     const distTag = UPDATE_DIST_TAGS[channel];
+    const now = options.now ?? (() => performance.now());
+    const measure = async (phase, operation) => {
+        const startedAt = now();
+        try {
+            return await operation();
+        }
+        finally {
+            options.onPhaseTiming?.({ phase, durationMs: Math.max(0, now() - startedAt) });
+        }
+    };
     let runningVersion;
     try {
-        const packageJson = JSON.parse(await fileSystem.readFile(resolve(options.packageRoot, "package.json")));
+        const packageJson = JSON.parse(await measure("package-version", async () => await fileSystem.readFile(resolve(options.packageRoot, "package.json"))));
         const parsedVersion = typeof packageJson.version === "string" ? validSemver(packageJson.version) : null;
         if (parsedVersion === null)
             throw new Error("package.json does not contain a valid semantic version");
         runningVersion = parsedVersion;
     }
     catch (error) {
-        output.stderr(`AddOne could not read its running package version: ${errorMessage(error)}\n`);
+        output.stderr(`${PRODUCT_TEXT.diagnostic(`could not read its running package version: ${errorMessage(error)}`)}\n`);
         return 1;
     }
-    const targetLookup = await runNpm(runner, ["view", `${ADDONE_PACKAGE}@${distTag}`, "version"], true, output, `query the npm ${distTag} channel`);
+    const targetLookup = await measure("target-resolution", async () => await runNpm(runner, ["view", `${PRODUCT_PACKAGE}@${distTag}`, "version"], true, output, `query the npm ${distTag} channel`));
     if (targetLookup.result === null)
         return targetLookup.exitCode;
     const targetVersion = validSemver(targetLookup.result.stdout.trim());
     if (targetVersion === null) {
-        output.stderr(`AddOne received a malformed ${distTag} version from npm: ${JSON.stringify(targetLookup.result.stdout.trim())}.\n`);
+        output.stderr(`${PRODUCT_TEXT.diagnostic(`received a malformed ${distTag} version from npm: ${JSON.stringify(targetLookup.result.stdout.trim())}.`)}\n`);
         return 1;
     }
-    output.stdout(`AddOne update (${channel}): ${runningVersion} → ${targetVersion}.\n`);
-    const rootLookup = await runNpm(runner, ["root", "--global"], true, output, "resolve npm's global package root");
+    output.stdout(`${PRODUCT_TEXT.commandName} update (${channel}): ${runningVersion} → ${targetVersion}.\n`);
+    const progress = createUpdateProgress(output, options.progress ?? (options.output === undefined && process.stdout.isTTY === true));
+    progress.set(3, 15);
+    const rootLookup = await measure("global-root", async () => await runNpm(runner, ["root", "--global"], true, output, "resolve npm's global package root"));
     if (rootLookup.result === null)
         return rootLookup.exitCode;
     if (rootLookup.result.stdout.trim().length === 0) {
-        output.stderr("AddOne could not verify its installation because npm returned an empty global package root.\n");
+        output.stderr(`${PRODUCT_TEXT.diagnostic("could not verify its installation because npm returned an empty global package root.")}\n`);
         return 1;
     }
     let packageRoot;
@@ -160,16 +239,16 @@ export async function runSelfUpdate(options) {
         [packageRoot, globalRoot] = await Promise.all([fileSystem.realpath(options.packageRoot), fileSystem.realpath(rootLookup.result.stdout.trim())]);
     }
     catch (error) {
-        output.stderr(`AddOne could not canonicalize the running and global npm paths: ${errorMessage(error)}\n`);
+        output.stderr(`${PRODUCT_TEXT.diagnostic(`could not canonicalize the running and global npm paths: ${errorMessage(error)}`)}\n`);
         return 1;
     }
     if (!isContainedBy(globalRoot, packageRoot)) {
-        output.stderr(`AddOne refused to update automatically because ${packageRoot} is not managed beneath npm's global package root ${globalRoot}.\n`);
+        output.stderr(`${PRODUCT_TEXT.diagnostic(`refused to update automatically because ${packageRoot} is not managed beneath npm's global package root ${globalRoot}.`)}\n`);
         return 1;
     }
     const environment = options.environment ?? process.env;
-    const paths = resolveAddOnePaths(environment);
-    const lifecycle = options.lifecycle ?? createUpdateLifecycleCoordinator(environment, fileSystem);
+    const paths = resolveProductPaths(environment);
+    const lifecycle = options.lifecycle ?? createUpdateLifecycleCoordinator(environment, fileSystem, output);
     const transactionStore = options.transactionStore ?? new UpdateTransactionStore(paths.dataDir);
     let transaction = await transactionStore.read();
     try {
@@ -179,7 +258,8 @@ export async function runSelfUpdate(options) {
                 await transactionStore.finish("completed");
             }
             await transactionStore.clearCompleted();
-            output.stdout("AddOne is already current and active for this channel; no installation was changed.\n");
+            progress.clear();
+            output.stdout(`${PRODUCT_TEXT.commandName} is already current and active for this channel.\n`);
             return 0;
         }
         const cohortState = await new CohortStateStore(paths.dataDir).read();
@@ -190,37 +270,74 @@ export async function runSelfUpdate(options) {
             priorActiveReleaseId: cohortState.references.active,
         });
         if (phaseBefore(transaction.phase, "ownership-released")) {
-            await lifecycle.shutdownVerifiedOwners(targetVersion);
-            await lifecycle.verifyPackageUnlocked(packageRoot);
+            await measure("ownership-release", async () => {
+                await lifecycle.shutdownVerifiedOwners(targetVersion);
+                await lifecycle.verifyPackageUnlocked(packageRoot);
+            });
             transaction = await transactionStore.advance("ownership-released");
         }
+        progress.set(15, 70);
         if (phaseBefore(transaction.phase, "package-installed")) {
-            output.stdout(`AddOne is installing ${ADDONE_PACKAGE}@${targetVersion}.\n`);
-            const installation = await runNpm(runner, ["install", "--global", `${ADDONE_PACKAGE}@${targetVersion}`], false, output, "start the global npm installation", false);
+            const installation = await measure("npm-install", async () => await runNpm(runner, ["install", "--global", "--loglevel=error", "--no-fund", "--no-audit", `${PRODUCT_PACKAGE}@${targetVersion}`], true, output, "start the global npm installation", false));
             if (installation.result === null)
                 throw new UpdateFailure(installation.exitCode, "npm process failed");
-            if (installation.result.code !== 0)
+            if (installation.result.code !== 0) {
+                if (installation.result.stdout.trim().length > 0)
+                    output.stderr(`${installation.result.stdout.trimEnd()}\n`);
                 throw new UpdateFailure(unsuccessfulCode(installation.result.code), `npm exited with status ${formatExitCode(installation.result.code)}`);
+            }
             transaction = await transactionStore.advance("package-installed");
         }
-        await lifecycle.activateInstalled(packageRoot, targetVersion, async (phase) => { transaction = await transactionStore.advance(phase); });
+        progress.set(70, 75);
+        // Ownership can be reacquired after an interrupted installation (for
+        // example, if bare A1 is launched before the update is resumed). Recheck
+        // immediately before activation so recovery cannot start a second cohort.
+        await measure("ownership-release", async () => { await lifecycle.shutdownVerifiedOwners(targetVersion); });
+        progress.set(75, 85);
+        let activationPhaseStartedAt = now();
+        await lifecycle.activateInstalled(packageRoot, targetVersion, async (phase) => {
+            options.onPhaseTiming?.({ phase, durationMs: Math.max(0, now() - activationPhaseStartedAt) });
+            transaction = await transactionStore.advance(phase);
+            progress.set(ACTIVATION_PROGRESS[phase].at, ACTIVATION_PROGRESS[phase].creepTo);
+            activationPhaseStartedAt = now();
+        });
+        options.onPhaseTiming?.({ phase: "supervisor-verified", durationMs: Math.max(0, now() - activationPhaseStartedAt) });
+        const transactionStartedAt = now();
         await transactionStore.advance("supervisor-verified");
         await transactionStore.finish("completed");
         await transactionStore.clearCompleted();
-        output.stdout(`AddOne updated successfully: ${targetVersion} (${channel}).\n`);
+        options.onPhaseTiming?.({ phase: "transaction-complete", durationMs: Math.max(0, now() - transactionStartedAt) });
+        progress.finish();
+        output.stdout(`${PRODUCT_TEXT.commandName} updated successfully: ${targetVersion} (${channel}).\n`);
         return 0;
     }
     catch (error) {
+        progress.clear();
         const message = errorMessage(error);
         const rollback = options.lifecycle
             ? "previous test lifecycle retained"
             : await rollbackPriorCohort(paths.dataDir, environment, transaction?.priorActiveReleaseId ?? null).catch(rollbackError => `rollback failed: ${errorMessage(rollbackError)}`);
         if (transaction)
             await transactionStore.finish(rollback === "rolled back" ? "rolled-back" : "failed", `${message}; ${rollback}`);
-        output.stderr(`AddOne update failed: ${message}. ${rollback}. Diagnostics: ${transactionStore.path}\n`);
+        output.stderr(`${PRODUCT_TEXT.diagnostic(`update failed: ${message}. ${rollback}. Diagnostics: ${transactionStore.path}`)}\n`);
         return error instanceof UpdateFailure ? error.exitCode : 1;
     }
 }
+export function assertUpdatePerformanceBudget(evidence, maximumPostNpmDurationMs = 30_000) {
+    const failures = [];
+    if (evidence.fileCount < 1)
+        failures.push("fixture contains no payload files");
+    if (evidence.sourceReads !== evidence.fileCount)
+        failures.push(`source payload read count is ${evidence.sourceReads} for ${evidence.fileCount} files`);
+    if (evidence.candidateWrites !== evidence.fileCount)
+        failures.push(`candidate payload write count is ${evidence.candidateWrites} for ${evidence.fileCount} files`);
+    if (evidence.verificationReads > 0)
+        failures.push(`fresh certification reread ${evidence.verificationReads} candidate files`);
+    if (evidence.postNpmDurationMs > maximumPostNpmDurationMs)
+        failures.push(`post-npm activation took ${Math.round(evidence.postNpmDurationMs)}ms; budget is ${maximumPostNpmDurationMs}ms`);
+    if (failures.length > 0)
+        throw new Error(`update performance budget failed: ${failures.join("; ")}`);
+}
 async function requestUpdateShutdown(metadata, targetVersion, timeoutMs) {
     if (!processIsAlive(metadata.pid))
         return { accepted: false, reason: "recorded owner is dead" };
@@ -256,11 +373,11 @@ async function runNpm(runner, arguments_, captureStdout, output, action, reportN
         result = await runner("npm", arguments_, { captureStdout });
     }
     catch (error) {
-        output.stderr(`AddOne could not execute npm to ${action}: ${errorMessage(error)}\n`);
+        output.stderr(`${PRODUCT_TEXT.diagnostic(`could not execute npm to ${action}: ${errorMessage(error)}`)}\n`);
         return { result: null, exitCode: 1 };
     }
     if (result.code !== 0 && reportNonzero) {
-        output.stderr(`AddOne could not ${action}; npm exited with status ${formatExitCode(result.code)}. Review npm's diagnostics above.\n`);
+        output.stderr(`${PRODUCT_TEXT.diagnostic(`could not ${action}; npm exited with status ${formatExitCode(result.code)}. Review npm's diagnostics above.`)}\n`);
         return { result: null, exitCode: unsuccessfulCode(result.code) };
     }
     return { result, exitCode: 0 };
@@ -280,7 +397,7 @@ async function rollbackPriorCohort(dataDir, environment, priorReleaseId) {
             throw new Error(`prior release ${priorReleaseId} is not the recorded rollback cohort`);
     }
     const release = await readMaterializedRelease(prior.releaseRoot);
-    const paths = resolveAddOnePaths(environment);
+    const paths = resolveProductPaths(environment);
     await startSupervisor(release, environment);
     await waitForVerifiedEndpoint(paths.endpointMetadataPath, release, 8_000);
     return "rolled back";
@@ -313,4 +430,3 @@ function isContainedBy(parent, child) {
 function unsuccessfulCode(code) { return code === null || code === 0 ? 1 : code; }
 function formatExitCode(code) { return code === null ? "unknown" : String(code); }
 function errorMessage(error) { return error instanceof Error ? error.message : String(error); }
-//# sourceMappingURL=update.js.map

package/dist/src/foundation/storage/control-store.d.ts

@@ -1,6 +1,6 @@
 import { DatabaseSync } from "node:sqlite";
 import type { ManagedAgentDescriptor, PaneId, AgentRecoveryAuthority, RecoveryReferenceId, TerminalSessionLaunch, TerminalTopologySnapshot } from "../workspace-contracts/index.js";
-import type { ForegroundTerminalLease, ForegroundTerminalLeaseId, GenerationId, NativeProcessIdentity, TransparentTerminalLifecycleOutcome } from "../lifecycle/index.js";
+import type { LaunchInstance, LaunchInstanceId, LaunchInstanceOutcome, NativeProcessIdentity, ProcessContainmentIdentity } from "../lifecycle/index.js";
 export declare const DEFAULT_WORKSPACE_ID = "workspace-default";
 export interface WorkspaceAgentPresentation {
     readonly unreadActivity: number;
@@ -21,12 +21,13 @@ export declare class ControlStore {
     constructor(path: string, bootNonce?: string | null);
     migrate(): void;
     reconcilePriorBootGenerations(bootNonce: string): number;
-    acquireForegroundTerminalLease(lease: ForegroundTerminalLease): void;
-    activateForegroundTerminalLease(leaseId: ForegroundTerminalLeaseId, generationId: GenerationId, processIdentity: NativeProcessIdentity, heartbeatAt: string): boolean;
-    heartbeatForegroundTerminalLease(leaseId: ForegroundTerminalLeaseId, processIdentity: NativeProcessIdentity, heartbeatAt: string): boolean;
-    releaseForegroundTerminalLease(leaseId: ForegroundTerminalLeaseId, processIdentity: NativeProcessIdentity | null, outcome: TransparentTerminalLifecycleOutcome, releasedAt: string): boolean;
-    loadLiveForegroundTerminalLease(): ForegroundTerminalLease | null;
-    reconcilePriorBootForegroundTerminalLeases(bootNonce: string, reconciledAt?: string): number;
+    createLaunchInstance(instance: LaunchInstance): void;
+    activateLaunchInstance(instanceId: LaunchInstanceId, ownerClientId: string, rootIdentity: NativeProcessIdentity, containmentIdentity: ProcessContainmentIdentity, activatedAt: string): boolean;
+    beginLaunchInstanceStop(instanceId: LaunchInstanceId, ownerClientId: string, stoppingAt: string): boolean;
+    completeLaunchInstance(instanceId: LaunchInstanceId, ownerClientId: string, terminalState: "completed" | "interrupted", outcome: LaunchInstanceOutcome, completedAt: string): boolean;
+    loadActiveLaunchInstances(): LaunchInstance[];
+    loadLaunchInstance(instanceId: LaunchInstanceId): LaunchInstance | null;
+    reconcilePriorBootLaunchInstances(bootNonce: string, reconciledAt?: string): number;
     persistWorkspaceAgent(agent: ManagedAgentDescriptor, updatedAt?: string): void;
     persistWorkspaceAgentRecord(record: StoredWorkspaceAgent, updatedAt?: string): void;
     replaceWorkspaceAgentRecords(records: readonly StoredWorkspaceAgent[], selectedAgentId: string | null, revision: number, updatedAt?: string): void;
@@ -58,4 +59,3 @@ export declare class ControlStore {
     } | null;
     close(): void;
 }
-//# sourceMappingURL=control-store.d.ts.map