@timurproko/a1 0.1.0 → 0.1.1-dev.10

package/dist/src/foundation/storage/control-store.js

@@ -1,7 +1,9 @@
 import { DatabaseSync } from "node:sqlite";
 import { mkdirSync } from "node:fs";
 import { dirname } from "node:path";
+import { PRODUCT_IDENTITY } from "../../product-identity.js";
 import { assertManagedAgentDescriptor, assertRecoveryAuthority, assertTerminalSessionLaunch, assertTerminalTopologySnapshot, } from "../workspace-contracts/index.js";
+import { assertLaunchInstance, assertLaunchInstanceOutcome, assertNativeProcessIdentity, assertProcessContainmentIdentity, } from "../lifecycle/index.js";
 export const DEFAULT_WORKSPACE_ID = "workspace-default";
 const INITIAL_WORKSPACE_ID = DEFAULT_WORKSPACE_ID;
 export class ControlStore {
@@ -11,19 +13,27 @@ export class ControlStore {
         this.bootNonce = bootNonce;
         mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
         this.database = new DatabaseSync(path);
-        this.database.exec("PRAGMA journal_mode = WAL");
-        this.database.exec("PRAGMA foreign_keys = ON");
-        this.migrate();
-        if (bootNonce !== null) {
-            this.reconcilePriorBootGenerations(bootNonce);
-            this.reconcilePriorBootForegroundTerminalLeases(bootNonce);
+        try {
+            this.database.exec("PRAGMA journal_mode = WAL");
+            this.database.exec("PRAGMA foreign_keys = ON");
+            this.migrate();
+            if (bootNonce !== null) {
+                this.reconcilePriorBootGenerations(bootNonce);
+                this.reconcilePriorBootLaunchInstances(bootNonce);
+            }
+        }
+        catch (error) {
+            this.database.close();
+            throw error;
         }
     }
     migrate() {
         const versionRow = this.database.prepare("PRAGMA user_version").get();
         const version = versionRow.user_version;
-        if (version > 4)
-            throw new Error(`control database version ${version} is newer than supported version 4`);
+        if (version > 5)
+            throw new Error(`control database version ${version} is newer than supported version 5`);
+        if (version !== 0)
+            this.#assertCurrentControlSchema();
         if (version === 0) {
             this.database.exec(`
         BEGIN IMMEDIATE;
@@ -165,6 +175,54 @@ export class ControlStore {
         COMMIT;
       `);
         }
+        if (version <= 4) {
+            this.database.exec(`
+        BEGIN IMMEDIATE;
+        UPDATE foreground_terminal_leases
+          SET state = 'interrupted',
+              released_at = COALESCE(released_at, strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+              outcome_json = '{"kind":"interrupted","reason":"legacy-migration","message":"legacy foreground ownership cannot prove current launch-instance liveness"}'
+          WHERE state IN ('requested', 'active');
+        DROP INDEX IF EXISTS idx_one_live_foreground_lease;
+        CREATE TABLE launch_instances (
+          id TEXT PRIMARY KEY,
+          owner_client_id TEXT NOT NULL,
+          profile_id TEXT NOT NULL CHECK (profile_id IN ('a1', 'pi', 'sandbox')),
+          state TEXT NOT NULL CHECK (state IN ('requested', 'active', 'stopping', 'completed', 'interrupted')),
+          shutdown_policy TEXT NOT NULL CHECK (shutdown_policy = 'terminate-tree-on-close'),
+          guardian_identity_json TEXT NOT NULL CHECK (json_valid(guardian_identity_json)),
+          root_identity_json TEXT CHECK (root_identity_json IS NULL OR json_valid(root_identity_json)),
+          containment_identity_json TEXT CHECK (containment_identity_json IS NULL OR json_valid(containment_identity_json)),
+          created_at TEXT NOT NULL,
+          activated_at TEXT,
+          stopping_at TEXT,
+          completed_at TEXT,
+          outcome_json TEXT CHECK (outcome_json IS NULL OR json_valid(outcome_json)),
+          owner_boot_nonce TEXT NOT NULL,
+          CHECK ((state = 'requested' AND root_identity_json IS NULL AND containment_identity_json IS NULL AND activated_at IS NULL AND stopping_at IS NULL AND completed_at IS NULL AND outcome_json IS NULL)
+            OR (state = 'active' AND root_identity_json IS NOT NULL AND containment_identity_json IS NOT NULL AND activated_at IS NOT NULL AND stopping_at IS NULL AND completed_at IS NULL AND outcome_json IS NULL)
+            OR (state = 'stopping' AND root_identity_json IS NOT NULL AND containment_identity_json IS NOT NULL AND activated_at IS NOT NULL AND stopping_at IS NOT NULL AND completed_at IS NULL AND outcome_json IS NULL)
+            OR (state IN ('completed', 'interrupted') AND completed_at IS NOT NULL AND outcome_json IS NOT NULL))
+        );
+        CREATE INDEX idx_launch_instances_owner ON launch_instances(owner_client_id, state);
+        CREATE INDEX idx_launch_instances_boot ON launch_instances(owner_boot_nonce, state);
+        PRAGMA user_version = 5;
+        COMMIT;
+      `);
+        }
+        if (version === 0) {
+            this.database.exec("CREATE TABLE product_identity (schema TEXT PRIMARY KEY NOT NULL)");
+            this.database.prepare("INSERT INTO product_identity (schema) VALUES (?)").run(PRODUCT_IDENTITY.protocol.controlStoreSchema);
+        }
+    }
+    #assertCurrentControlSchema() {
+        const table = this.database.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'product_identity'").get();
+        if (!table)
+            throw new Error("control database has no A1 product schema; legacy state is unsupported");
+        const identity = this.database.prepare("SELECT schema FROM product_identity").get();
+        if (identity?.schema !== PRODUCT_IDENTITY.protocol.controlStoreSchema) {
+            throw new Error(`control database schema ${String(identity?.schema)} is unsupported; expected ${PRODUCT_IDENTITY.protocol.controlStoreSchema}`);
+        }
     }
     reconcilePriorBootGenerations(bootNonce) {
         const now = new Date().toISOString();
@@ -177,61 +235,70 @@ export class ControlStore {
             return Number(result.changes);
         });
     }
-    acquireForegroundTerminalLease(lease) {
+    createLaunchInstance(instance) {
         if (this.bootNonce === null)
-            throw new Error("foreground lease storage requires a supervisor boot identity");
-        if (lease.state !== "requested" || lease.generationId !== null || lease.processIdentity !== null || lease.releasedAt !== null || lease.outcome !== null) {
-            throw new Error("new foreground lease must be requested and unactivated");
-        }
-        try {
-            this.database.prepare(`INSERT INTO foreground_terminal_leases
-        (id, owner_id, profile_json, state, generation_id, process_identity_json, acquired_at, heartbeat_at, released_at, outcome_json, owner_boot_nonce)
-        VALUES (?, ?, ?, 'requested', NULL, NULL, ?, NULL, NULL, NULL, ?)`)
-                .run(lease.id, lease.ownerId, JSON.stringify(lease.profile), lease.acquiredAt, this.bootNonce);
-        }
-        catch (error) {
-            if (error instanceof Error && /UNIQUE constraint failed/i.test(error.message))
-                throw new Error("an exclusive foreground terminal lease is already live");
-            throw error;
-        }
+            throw new Error("launch instance storage requires a supervisor boot identity");
+        assertLaunchInstance(instance);
+        if (instance.state !== "requested")
+            throw new Error("new launch instance must be requested");
+        this.database.prepare(`INSERT INTO launch_instances
+      (id, owner_client_id, profile_id, state, shutdown_policy, guardian_identity_json, root_identity_json, containment_identity_json,
+       created_at, activated_at, stopping_at, completed_at, outcome_json, owner_boot_nonce)
+      VALUES (?, ?, ?, 'requested', ?, ?, NULL, NULL, ?, NULL, NULL, NULL, NULL, ?)`)
+            .run(instance.id, instance.ownerClientId, instance.profileId, instance.shutdownPolicy, JSON.stringify(instance.guardianIdentity), instance.createdAt, this.bootNonce);
     }
-    activateForegroundTerminalLease(leaseId, generationId, processIdentity, heartbeatAt) {
+    activateLaunchInstance(instanceId, ownerClientId, rootIdentity, containmentIdentity, activatedAt) {
         if (this.bootNonce === null)
-            throw new Error("foreground lease storage requires a supervisor boot identity");
-        const result = this.database.prepare(`UPDATE foreground_terminal_leases
-      SET state = 'active', generation_id = ?, process_identity_json = ?, heartbeat_at = ?
-      WHERE id = ? AND state = 'requested' AND owner_boot_nonce = ?`)
-            .run(generationId, JSON.stringify(processIdentity), heartbeatAt, leaseId, this.bootNonce);
+            throw new Error("launch instance storage requires a supervisor boot identity");
+        assertNativeProcessIdentity(rootIdentity);
+        assertProcessContainmentIdentity(containmentIdentity);
+        const result = this.database.prepare(`UPDATE launch_instances
+      SET state = 'active', root_identity_json = ?, containment_identity_json = ?, activated_at = ?
+      WHERE id = ? AND owner_client_id = ? AND owner_boot_nonce = ? AND state = 'requested'`)
+            .run(JSON.stringify(rootIdentity), JSON.stringify(containmentIdentity), activatedAt, instanceId, ownerClientId, this.bootNonce);
         return Number(result.changes) === 1;
     }
-    heartbeatForegroundTerminalLease(leaseId, processIdentity, heartbeatAt) {
+    beginLaunchInstanceStop(instanceId, ownerClientId, stoppingAt) {
         if (this.bootNonce === null)
-            throw new Error("foreground lease storage requires a supervisor boot identity");
-        const result = this.database.prepare(`UPDATE foreground_terminal_leases SET heartbeat_at = ?
-      WHERE id = ? AND state = 'active' AND owner_boot_nonce = ? AND process_identity_json = ?`)
-            .run(heartbeatAt, leaseId, this.bootNonce, JSON.stringify(processIdentity));
+            throw new Error("launch instance storage requires a supervisor boot identity");
+        const result = this.database.prepare(`UPDATE launch_instances SET state = 'stopping', stopping_at = ?
+      WHERE id = ? AND owner_client_id = ? AND owner_boot_nonce = ? AND state = 'active'`)
+            .run(stoppingAt, instanceId, ownerClientId, this.bootNonce);
         return Number(result.changes) === 1;
     }
-    releaseForegroundTerminalLease(leaseId, processIdentity, outcome, releasedAt) {
+    completeLaunchInstance(instanceId, ownerClientId, terminalState, outcome, completedAt) {
         if (this.bootNonce === null)
-            throw new Error("foreground lease storage requires a supervisor boot identity");
-        const expectedIdentity = processIdentity === null ? null : JSON.stringify(processIdentity);
-        const result = this.database.prepare(`UPDATE foreground_terminal_leases
-      SET state = 'released', released_at = ?, outcome_json = ?
-      WHERE id = ? AND state IN ('requested', 'active') AND owner_boot_nonce = ?
-        AND ((process_identity_json IS NULL AND ? IS NULL) OR process_identity_json = ?)`)
-            .run(releasedAt, JSON.stringify(outcome), leaseId, this.bootNonce, expectedIdentity, expectedIdentity);
+            throw new Error("launch instance storage requires a supervisor boot identity");
+        assertLaunchInstanceOutcome(outcome);
+        if (terminalState === "completed" && outcome.kind === "interrupted")
+            throw new Error("completed launch instance cannot carry an interrupted outcome");
+        if (terminalState === "interrupted" && outcome.kind !== "interrupted" && outcome.kind !== "cleanup-error") {
+            throw new Error("interrupted launch instance requires an interrupted or cleanup-error outcome");
+        }
+        const result = this.database.prepare(`UPDATE launch_instances
+      SET state = ?, completed_at = ?, outcome_json = ?
+      WHERE id = ? AND owner_client_id = ? AND owner_boot_nonce = ? AND state IN ('requested', 'active', 'stopping')`)
+            .run(terminalState, completedAt, JSON.stringify(outcome), instanceId, ownerClientId, this.bootNonce);
         return Number(result.changes) === 1;
     }
-    loadLiveForegroundTerminalLease() {
-        const row = this.database.prepare("SELECT * FROM foreground_terminal_leases WHERE state IN ('requested', 'active') LIMIT 1").get();
-        return row ? foregroundLeaseFromRow(row) : null;
+    loadActiveLaunchInstances() {
+        return this.database.prepare(`SELECT * FROM launch_instances
+      WHERE state IN ('requested', 'active', 'stopping') ORDER BY created_at, id`).all()
+            .map(launchInstanceFromRow);
+    }
+    loadLaunchInstance(instanceId) {
+        const row = this.database.prepare("SELECT * FROM launch_instances WHERE id = ?").get(instanceId);
+        return row ? launchInstanceFromRow(row) : null;
     }
-    reconcilePriorBootForegroundTerminalLeases(bootNonce, reconciledAt = new Date().toISOString()) {
-        const outcome = { kind: "broker-error", message: "foreground lease owner ended before a terminal outcome", code: "stale-owner-boot" };
-        const result = this.database.prepare(`UPDATE foreground_terminal_leases
-      SET state = 'released', released_at = ?, outcome_json = ?
-      WHERE state IN ('requested', 'active') AND owner_boot_nonce <> ?`)
+    reconcilePriorBootLaunchInstances(bootNonce, reconciledAt = new Date().toISOString()) {
+        const outcome = {
+            kind: "interrupted",
+            reason: "supervisor-disconnect",
+            message: "launch instance ownership ended with a prior supervisor boot",
+        };
+        const result = this.database.prepare(`UPDATE launch_instances
+      SET state = 'interrupted', completed_at = ?, outcome_json = ?
+      WHERE state IN ('requested', 'active', 'stopping') AND owner_boot_nonce <> ?`)
             .run(reconciledAt, JSON.stringify(outcome), bootNonce);
         return Number(result.changes);
     }
@@ -442,18 +509,22 @@ function assertWorkspaceAgentPresentation(presentation) {
         }
     }
 }
-function foregroundLeaseFromRow(row) {
-    return {
+function launchInstanceFromRow(row) {
+    const instance = {
         id: row.id,
-        ownerId: row.owner_id,
-        profile: JSON.parse(row.profile_json),
+        ownerClientId: row.owner_client_id,
+        profileId: row.profile_id,
         state: row.state,
-        generationId: row.generation_id,
-        processIdentity: row.process_identity_json ? JSON.parse(row.process_identity_json) : null,
-        acquiredAt: row.acquired_at,
-        heartbeatAt: row.heartbeat_at,
-        releasedAt: row.released_at,
+        shutdownPolicy: row.shutdown_policy,
+        guardianIdentity: JSON.parse(row.guardian_identity_json),
+        rootIdentity: row.root_identity_json ? JSON.parse(row.root_identity_json) : null,
+        containmentIdentity: row.containment_identity_json ? JSON.parse(row.containment_identity_json) : null,
+        createdAt: row.created_at,
+        activatedAt: row.activated_at,
+        stoppingAt: row.stopping_at,
+        completedAt: row.completed_at,
         outcome: row.outcome_json ? JSON.parse(row.outcome_json) : null,
     };
+    assertLaunchInstance(instance);
+    return instance;
 }
-//# sourceMappingURL=control-store.js.map

package/dist/src/foundation/storage/index.d.ts

@@ -1,2 +1 @@
 export * from "./control-store.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/src/foundation/storage/index.js

@@ -1,2 +1 @@
 export * from "./control-store.js";
-//# sourceMappingURL=index.js.map

package/dist/src/foundation/structured-agent-runtime/backpressure.d.ts

@@ -44,4 +44,3 @@ export declare class StructuredBackpressureController {
     leaseCount(): number;
     replayExhausted(): boolean;
 }
-//# sourceMappingURL=backpressure.d.ts.map

package/dist/src/foundation/structured-agent-runtime/backpressure.js

@@ -116,4 +116,3 @@ function isPositiveSafeInteger(value) {
 function isSafeNonNegativeInteger(value) {
     return Number.isSafeInteger(value) && value >= 0;
 }
-//# sourceMappingURL=backpressure.js.map

package/dist/src/foundation/structured-agent-runtime/commands.d.ts

@@ -50,4 +50,3 @@ export declare class StructuredCommandTracker {
     activeCount(): number;
     terminalCount(): number;
 }
-//# sourceMappingURL=commands.d.ts.map

package/dist/src/foundation/structured-agent-runtime/commands.js

@@ -162,4 +162,3 @@ function stableJson(value) {
         throw new TypeError("structured payload must be JSON serializable");
     return encoded;
 }
-//# sourceMappingURL=commands.js.map

package/dist/src/foundation/structured-agent-runtime/handshake.d.ts

@@ -1,10 +1,10 @@
 import { type AdapterId, type StructuredCapabilityContract, type StructuredFlowLimits } from "../workspace-contracts/index.js";
-export declare const STRUCTURED_ADAPTER_ENVELOPE: "addone-structured-adapter";
+export declare const STRUCTURED_ADAPTER_ENVELOPE: string;
 export declare const STRUCTURED_ADAPTER_ENVELOPE_REVISION: 1;
 export declare const REQUIRED_STRUCTURED_FEATURES: readonly ["identity.adapter.v1", "commands.correlated.v1", "events.typed.v1", "flow-control.limits.v1"];
 export declare const OPTIONAL_STRUCTURED_FEATURES: readonly ["snapshots.authoritative.v1", "resume.position.v1", "resume.snapshot.v1", "commands.cancellable.v1", "attachments.typed.v1"];
 export type StructuredProtocolFeature = typeof REQUIRED_STRUCTURED_FEATURES[number] | typeof OPTIONAL_STRUCTURED_FEATURES[number];
-export declare const ADDONE_STRUCTURED_FLOW_LIMITS: StructuredFlowLimits;
+export declare const STRUCTURED_FLOW_LIMITS: StructuredFlowLimits;
 export interface StructuredAdapterHello {
     readonly envelope: typeof STRUCTURED_ADAPTER_ENVELOPE;
     readonly envelopeRevision: typeof STRUCTURED_ADAPTER_ENVELOPE_REVISION;
@@ -39,4 +39,3 @@ export interface StructuredHandshakeRejected {
 export type StructuredHandshakeResult = StructuredHandshakeAccepted | StructuredHandshakeRejected;
 export declare function localStructuredAdapterHello(): StructuredAdapterPeerHello;
 export declare function negotiateStructuredAdapter(value: unknown, server?: StructuredAdapterPeerHello): StructuredHandshakeResult;
-//# sourceMappingURL=handshake.d.ts.map

package/dist/src/foundation/structured-agent-runtime/handshake.js

@@ -1,5 +1,6 @@
 import { WORKSPACE_CONTRACT_VERSION, assertStructuredCapability, } from "../workspace-contracts/index.js";
-export const STRUCTURED_ADAPTER_ENVELOPE = "addone-structured-adapter";
+import { PRODUCT_IDENTITY, PRODUCT_TEXT } from "../../product-identity.js";
+export const STRUCTURED_ADAPTER_ENVELOPE = PRODUCT_IDENTITY.protocol.structuredAgentSchema;
 export const STRUCTURED_ADAPTER_ENVELOPE_REVISION = 1;
 export const REQUIRED_STRUCTURED_FEATURES = [
     "identity.adapter.v1",
@@ -14,7 +15,7 @@ export const OPTIONAL_STRUCTURED_FEATURES = [
     "commands.cancellable.v1",
     "attachments.typed.v1",
 ];
-export const ADDONE_STRUCTURED_FLOW_LIMITS = Object.freeze({
+export const STRUCTURED_FLOW_LIMITS = Object.freeze({
     maxEventBytes: 64 * 1024,
     maxSnapshotBytes: 1024 * 1024,
     maxAttachmentBytes: 2 * 1024 * 1024,
@@ -28,7 +29,7 @@ export function localStructuredAdapterHello() {
         envelopeRevision: STRUCTURED_ADAPTER_ENVELOPE_REVISION,
         requiredFeatures: REQUIRED_STRUCTURED_FEATURES,
         optionalFeatures: OPTIONAL_STRUCTURED_FEATURES,
-        flowLimits: ADDONE_STRUCTURED_FLOW_LIMITS,
+        flowLimits: STRUCTURED_FLOW_LIMITS,
     };
 }
 export function negotiateStructuredAdapter(value, server = localStructuredAdapterHello()) {
@@ -36,7 +37,7 @@ export function negotiateStructuredAdapter(value, server = localStructuredAdapte
         return reject("invalid-message", [], [], "adapter hello is malformed or omits required identity, feature, or capability fields");
     }
     if (value.envelope !== server.envelope || value.envelopeRevision !== server.envelopeRevision) {
-        return reject("unsupported-version", [], [], `structured adapter envelope mismatch: adapter ${String(value.envelope)}/${String(value.envelopeRevision)}; AddOne ${server.envelope}/${server.envelopeRevision}`);
+        return reject("unsupported-version", [], [], `structured adapter envelope mismatch: adapter ${String(value.envelope)}/${String(value.envelopeRevision)}; ${PRODUCT_TEXT.displayName} ${server.envelope}/${server.envelopeRevision}`);
     }
     if (!isValidIdentityText(value.adapterId) || !isValidBuildId(value.buildId)) {
         return reject("invalid-identity", [], [], "adapter identity and build identity must be bounded non-empty values");
@@ -62,7 +63,7 @@ export function negotiateStructuredAdapter(value, server = localStructuredAdapte
     const missingFromAdapter = server.requiredFeatures.filter(feature => !advertised.features.has(feature)).sort();
     const missingFromServer = [...adapterRequired].filter(feature => !serverFeatures.has(feature)).sort();
     if (missingFromAdapter.length > 0 || missingFromServer.length > 0) {
-        return reject("incompatible-features", missingFromAdapter, missingFromServer, `required structured features are unavailable; adapter missing [${missingFromAdapter.join(", ")}], AddOne missing [${missingFromServer.join(", ")}]`);
+        return reject("incompatible-features", missingFromAdapter, missingFromServer, `required structured features are unavailable; adapter missing [${missingFromAdapter.join(", ")}], ${PRODUCT_TEXT.displayName} missing [${missingFromServer.join(", ")}]`);
     }
     const capabilityFeatures = requiredFeaturesForCapability(value.capability);
     const undeclared = capabilityFeatures.filter(feature => !advertised.features.has(feature));
@@ -97,14 +98,14 @@ function requiredFeaturesForCapability(capability) {
         features.push("attachments.typed.v1");
     return features;
 }
-function negotiateFlow(adapter, addone) {
+function negotiateFlow(adapter, server) {
     return Object.freeze({
-        maxEventBytes: Math.min(adapter.maxEventBytes, addone.maxEventBytes),
-        maxSnapshotBytes: Math.min(adapter.maxSnapshotBytes, addone.maxSnapshotBytes),
-        maxAttachmentBytes: Math.min(adapter.maxAttachmentBytes, addone.maxAttachmentBytes),
-        maxQueuedEvents: Math.min(adapter.maxQueuedEvents, addone.maxQueuedEvents),
-        maxConcurrentCommands: Math.min(adapter.maxConcurrentCommands, addone.maxConcurrentCommands),
-        maxReconnectEvents: Math.min(adapter.maxReconnectEvents, addone.maxReconnectEvents),
+        maxEventBytes: Math.min(adapter.maxEventBytes, server.maxEventBytes),
+        maxSnapshotBytes: Math.min(adapter.maxSnapshotBytes, server.maxSnapshotBytes),
+        maxAttachmentBytes: Math.min(adapter.maxAttachmentBytes, server.maxAttachmentBytes),
+        maxQueuedEvents: Math.min(adapter.maxQueuedEvents, server.maxQueuedEvents),
+        maxConcurrentCommands: Math.min(adapter.maxConcurrentCommands, server.maxConcurrentCommands),
+        maxReconnectEvents: Math.min(adapter.maxReconnectEvents, server.maxReconnectEvents),
     });
 }
 function isStructuredAdapterHello(value) {
@@ -148,4 +149,3 @@ function isRecord(value) {
 function isStringArray(value) {
     return Array.isArray(value) && value.every(item => typeof item === "string");
 }
-//# sourceMappingURL=handshake.js.map

package/dist/src/foundation/structured-agent-runtime/index.d.ts

@@ -3,4 +3,3 @@ export * from "./commands.js";
 export * from "./handshake.js";
 export * from "./reconnection.js";
 export * from "./state.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/src/foundation/structured-agent-runtime/index.js

@@ -3,4 +3,3 @@ export * from "./commands.js";
 export * from "./handshake.js";
 export * from "./reconnection.js";
 export * from "./state.js";
-//# sourceMappingURL=index.js.map

package/dist/src/foundation/structured-agent-runtime/reconnection.d.ts

@@ -35,4 +35,3 @@ export declare class StructuredReconnectionManager {
     constructor(capability: StructuredCapabilityContract);
     resume(authorityValue: AgentRecoveryAuthority, proof: StructuredResumeProof, reducer?: StructuredEventReducer | null): StructuredReconnectionResult;
 }
-//# sourceMappingURL=reconnection.d.ts.map

package/dist/src/foundation/structured-agent-runtime/reconnection.js

@@ -127,4 +127,3 @@ function payloadBytes(payload) {
 function rejected(code, error) {
     return { kind: "rejected", code, diagnostic: error instanceof Error ? error.message : String(error) };
 }
-//# sourceMappingURL=reconnection.js.map

package/dist/src/foundation/structured-agent-runtime/state.d.ts

@@ -54,4 +54,3 @@ export declare class StructuredEventReducer {
     nextEventPosition(): number;
     view(): StructuredRuntimeView;
 }
-//# sourceMappingURL=state.d.ts.map

package/dist/src/foundation/structured-agent-runtime/state.js

@@ -116,4 +116,3 @@ function rejected(code, error) {
 function payloadBytes(payload) {
     return new TextEncoder().encode(JSON.stringify(payload)).byteLength;
 }
-//# sourceMappingURL=state.js.map

package/dist/src/foundation/supervision/index.d.ts

@@ -1,4 +1,3 @@
 export * from "./main.js";
 export * from "./server.js";
-export { resolveAddOnePaths, type AddOnePaths } from "../lifecycle/index.js";
-//# sourceMappingURL=index.d.ts.map
+export { resolveProductPaths, type ProductPaths } from "../lifecycle/index.js";

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

@@ -1,4 +1,3 @@
 export * from "./main.js";
 export * from "./server.js";
-export { resolveAddOnePaths } from "../lifecycle/index.js";
-//# sourceMappingURL=index.js.map
+export { resolveProductPaths } from "../lifecycle/index.js";

package/dist/src/foundation/supervision/main.d.ts

@@ -1,2 +1 @@
 export declare function runSupervisor(): Promise<void>;
-//# sourceMappingURL=main.d.ts.map

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

@@ -1,19 +1,21 @@
 import { randomUUID } from "node:crypto";
 import { appendFileSync, mkdirSync } from "node:fs";
-import { assertImmutableExecutionRoot, readMaterializedRelease } from "../release/index.js";
+import { resolve } from "node:path";
+import { assertImmutableExecutionRoot, readCertifiedReleaseManifest } from "../release/index.js";
 import { ControlStore } from "../storage/index.js";
-import { resolveAddOnePaths } from "./paths.js";
+import { resolveProductPaths } from "./paths.js";
 import { SupervisorServer } from "./server.js";
+import { PRODUCT_IDENTITY, PRODUCT_TEXT } from "../../product-identity.js";
 export async function runSupervisor() {
-    const paths = resolveAddOnePaths();
+    const paths = resolveProductPaths();
     mkdirSync(paths.runtimeDir, { recursive: true, mode: 0o700 });
     const log = (message) => appendFileSync(paths.supervisorLogPath, `${new Date().toISOString()} ${message}\n`);
-    const releaseRoot = process.env.ADDONE_RELEASE_ROOT;
-    if (!releaseRoot)
-        throw new Error("supervisor must be launched from a verified immutable AddOne release");
-    const release = await readMaterializedRelease(releaseRoot);
-    if (process.env.ADDONE_RELEASE_ID !== release.releaseId)
-        throw new Error("selected AddOne release identity does not match its verified manifest");
+    const releaseRoot = process.env[PRODUCT_IDENTITY.environment.releaseRoot];
+    const releaseId = process.env[PRODUCT_IDENTITY.environment.releaseId];
+    const contentDigest = process.env[PRODUCT_IDENTITY.environment.releaseDigest];
+    if (!releaseRoot || !releaseId || !contentDigest)
+        throw new Error(PRODUCT_TEXT.diagnostic("supervisor must be launched from a verified immutable release"));
+    const release = await readCertifiedReleaseManifest({ releaseRoot, releaseId, contentDigest }, resolve(paths.dataDir, "releases"));
     await assertImmutableExecutionRoot(release, paths.dataDir);
     const bootNonce = randomUUID();
     const store = new ControlStore(paths.databasePath, bootNonce);
@@ -37,4 +39,3 @@ export async function runSupervisor() {
     });
     process.on("unhandledRejection", error => log(`unhandled rejection: ${String(error)}`));
 }
-//# sourceMappingURL=main.js.map

package/dist/src/foundation/supervision/paths.d.ts

@@ -1,2 +1 @@
-export { resolveAddOnePaths, type AddOnePaths } from "../lifecycle/index.js";
-//# sourceMappingURL=paths.d.ts.map
+export { resolveProductPaths, type ProductPaths } from "../lifecycle/index.js";

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

@@ -1,2 +1 @@
-export { resolveAddOnePaths } from "../lifecycle/index.js";
-//# sourceMappingURL=paths.js.map
+export { resolveProductPaths } from "../lifecycle/index.js";

package/dist/src/foundation/supervision/server.d.ts

@@ -1,21 +1,22 @@
 import { type SupervisorSnapshot } from "../lifecycle/index.js";
-import type { MaterializedRelease } from "../release/index.js";
+import { type MaterializedRelease } from "../release/index.js";
 import { ControlStore } from "../storage/index.js";
-import { type AddOnePaths } from "./paths.js";
+import { type ProductPaths } from "./paths.js";
 export declare class SupervisorServer {
     #private;
     readonly store: ControlStore;
     readonly release: MaterializedRelease;
     readonly terminateProcess: (code: number) => void;
+    readonly reconciliationDeadlineMs: number;
+    readonly shutdownDeadlineMs: number;
     readonly id: `${string}-${string}-${string}-${string}-${string}`;
     readonly bootNonce: string;
     readonly pidStartIdentity: string;
     readonly startedAt: string;
-    readonly paths: AddOnePaths;
-    constructor(store: ControlStore, paths: AddOnePaths | undefined, release: MaterializedRelease, bootNonce?: string, terminateProcess?: (code: number) => void);
+    readonly paths: ProductPaths;
+    constructor(store: ControlStore, paths: ProductPaths | undefined, release: MaterializedRelease, bootNonce?: string, terminateProcess?: (code: number) => void, reconciliationDeadlineMs?: number, shutdownDeadlineMs?: number);
     snapshot(): SupervisorSnapshot;
     listen(): Promise<void>;
     close(stopAgents?: boolean): Promise<void>;
     closeForReleaseReplacement(stopAgents: boolean): Promise<void>;
 }
-//# sourceMappingURL=server.d.ts.map