@timurproko/a1 0.1.0 → 0.1.1-dev.2

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;
@@ -74,7 +75,7 @@ export function createUpdateLifecycleCoordinator(environment = process.env, file
                     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 () => {
@@ -83,7 +84,7 @@ export function createUpdateLifecycleCoordinator(environment = process.env, file
                         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,15 @@ 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);
+            const candidate = await materializeRelease(packageRoot, paths.dataDir, {
+                onProgress: progress => output.stdout(`${PRODUCT_TEXT.diagnostic(`preparing ${progress.fileCount} installed release files; this one-time activation may take a moment.`)}\n`),
+            });
             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);
@@ -135,23 +138,23 @@ export async function runSelfUpdate(options) {
         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 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`);
+    output.stdout(`${PRODUCT_TEXT.diagnostic(`update (${channel}): ${runningVersion} → ${targetVersion}.`)}\n`);
     const rootLookup = 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 +163,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 +182,7 @@ 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");
+            output.stdout(`${PRODUCT_TEXT.diagnostic("is already current and active for this channel; no installation was changed.")}\n`);
             return 0;
         }
         const cohortState = await new CohortStateStore(paths.dataDir).read();
@@ -195,8 +198,8 @@ export async function runSelfUpdate(options) {
             transaction = await transactionStore.advance("ownership-released");
         }
         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);
+            output.stdout(`${PRODUCT_TEXT.diagnostic(`is installing ${PRODUCT_TEXT.packageName}@${targetVersion}.`)}\n`);
+            const installation = await runNpm(runner, ["install", "--global", `${PRODUCT_PACKAGE}@${targetVersion}`], false, output, "start the global npm installation", false);
             if (installation.result === null)
                 throw new UpdateFailure(installation.exitCode, "npm process failed");
             if (installation.result.code !== 0)
@@ -207,7 +210,7 @@ export async function runSelfUpdate(options) {
         await transactionStore.advance("supervisor-verified");
         await transactionStore.finish("completed");
         await transactionStore.clearCompleted();
-        output.stdout(`AddOne updated successfully: ${targetVersion} (${channel}).\n`);
+        output.stdout(`${PRODUCT_TEXT.diagnostic(`updated successfully: ${targetVersion} (${channel}).`)}\n`);
         return 0;
     }
     catch (error) {
@@ -217,7 +220,7 @@ export async function runSelfUpdate(options) {
             : 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;
     }
 }
@@ -256,11 +259,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 +283,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 +316,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

@@ -58,4 +58,3 @@ export declare class ControlStore {
     } | null;
     close(): void;
 }
-//# sourceMappingURL=control-store.d.ts.map

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

@@ -1,6 +1,7 @@
 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";
 export const DEFAULT_WORKSPACE_ID = "workspace-default";
 const INITIAL_WORKSPACE_ID = DEFAULT_WORKSPACE_ID;
@@ -11,12 +12,18 @@ 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.reconcilePriorBootForegroundTerminalLeases(bootNonce);
+            }
+        }
+        catch (error) {
+            this.database.close();
+            throw error;
         }
     }
     migrate() {
@@ -24,6 +31,8 @@ export class ControlStore {
         const version = versionRow.user_version;
         if (version > 4)
             throw new Error(`control database version ${version} is newer than supported version 4`);
+        if (version !== 0)
+            this.#assertCurrentControlSchema();
         if (version === 0) {
             this.database.exec(`
         BEGIN IMMEDIATE;
@@ -165,6 +174,19 @@ export class ControlStore {
         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();
@@ -456,4 +478,3 @@ function foregroundLeaseFromRow(row) {
         outcome: row.outcome_json ? JSON.parse(row.outcome_json) : null,
     };
 }
-//# 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,7 +1,7 @@
 import { type SupervisorSnapshot } from "../lifecycle/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;
@@ -11,11 +11,10 @@ export declare class SupervisorServer {
     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);
     snapshot(): SupervisorSnapshot;
     listen(): Promise<void>;
     close(stopAgents?: boolean): Promise<void>;
     closeForReleaseReplacement(stopAgents: boolean): Promise<void>;
 }
-//# sourceMappingURL=server.d.ts.map

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

@@ -5,7 +5,8 @@ import { platform } from "node:os";
 import { assertNativeProcessIdentity, assertTransparentTerminalLaunchProfile, } from "../lifecycle/index.js";
 import { encodeFrame, isCommandMessage, isControlHello, LineFrameDecoder, localControlHello, MAX_CONTROL_FRAME_BYTES, negotiateControlFeatures } from "../protocol/index.js";
 import { ControlStore } from "../storage/index.js";
-import { resolveAddOnePaths } from "./paths.js";
+import { resolveProductPaths } from "./paths.js";
+import { PRODUCT_IDENTITY, PRODUCT_TEXT } from "../../product-identity.js";
 export class SupervisorServer {
     store;
     release;
@@ -21,7 +22,7 @@ export class SupervisorServer {
     #clients = new Set();
     #results = new Map();
     #metadataWrites = Promise.resolve();
-    constructor(store, paths = resolveAddOnePaths(), release, bootNonce = randomUUID(), terminateProcess = code => process.exit(code)) {
+    constructor(store, paths = resolveProductPaths(), release, bootNonce = randomUUID(), terminateProcess = code => process.exit(code)) {
         this.store = store;
         this.release = release;
         this.terminateProcess = terminateProcess;
@@ -38,7 +39,7 @@ export class SupervisorServer {
         await mkdir(this.paths.runtimeDir, { recursive: true, mode: 0o700 });
         if (platform() !== "win32") {
             if (await endpointIsLive(this.paths.endpoint))
-                throw new Error(`an AddOne supervisor already owns ${this.paths.endpoint}`);
+                throw new Error(PRODUCT_TEXT.diagnostic(`supervisor already owns ${this.paths.endpoint}`));
             await rm(this.paths.endpoint, { force: true });
         }
         const server = createServer(socket => this.#attach(socket));
@@ -103,7 +104,7 @@ export class SupervisorServer {
                             this.#send(socket, {
                                 type: "release-update-result",
                                 accepted,
-                                reason: accepted ? "verified AddOne owner accepted immediate update shutdown" : "boot nonce or target version mismatch",
+                                reason: accepted ? `verified ${PRODUCT_TEXT.displayName} owner accepted immediate update shutdown` : "boot nonce or target version mismatch",
                                 liveGenerationIds: this.#liveGenerationIds(),
                             });
                             if (accepted)
@@ -111,7 +112,7 @@ export class SupervisorServer {
                             continue;
                         }
                         if (!isControlHello(value)) {
-                            this.#send(socket, { type: "protocol-error", code: "invalid-control-handshake", message: "the first message must be a valid AddOne control feature handshake", diagnostics: { received: value } });
+                            this.#send(socket, { type: "protocol-error", code: "invalid-control-handshake", message: `the first message must be a valid ${PRODUCT_TEXT.displayName} control feature handshake`, diagnostics: { received: value } });
                             socket.destroy();
                             return;
                         }
@@ -232,6 +233,7 @@ export class SupervisorServer {
     }
     #writeEndpointMetadata() {
         const metadata = {
+            schema: PRODUCT_IDENTITY.protocol.supervisorSchema,
             ...localControlHello(this.release.releaseId),
             supervisorId: this.id,
             pid: process.pid,
@@ -280,4 +282,3 @@ async function endpointIsLive(endpoint) {
         setTimeout(() => done(false), 250).unref();
     });
 }
-//# sourceMappingURL=server.js.map

package/dist/src/foundation/transparent-terminal/command-resolution.d.ts

@@ -11,4 +11,3 @@ export interface TransparentCommandResolutionOptions {
 }
 /** Resolve a command without invoking a command interpreter. */
 export declare function resolveTransparentCommand(executable: string, arguments_: readonly string[], options: TransparentCommandResolutionOptions): Promise<ResolvedTransparentCommand>;
-//# sourceMappingURL=command-resolution.d.ts.map

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

@@ -67,4 +67,3 @@ async function isFile(path) {
         return false;
     }
 }
-//# sourceMappingURL=command-resolution.js.map

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

@@ -30,4 +30,3 @@ export interface ForegroundBrokerResult {
  * broker observes only process identity and the final lifecycle outcome.
  */
 export declare function runForegroundBroker(request: ForegroundBrokerRequest, control: ForegroundLeaseControl, launcher: TransparentNativeLauncher, createRequestId: () => RequestId): Promise<ForegroundBrokerResult>;
-//# sourceMappingURL=foreground-broker.d.ts.map

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

@@ -85,4 +85,3 @@ function errorMessage(error) {
 function errorCode(error) {
     return error instanceof Error && "code" in error && typeof error.code === "string" ? error.code : null;
 }
-//# sourceMappingURL=foreground-broker.js.map

package/dist/src/foundation/transparent-terminal/index.d.ts

@@ -1,4 +1,4 @@
 export * from "./command-resolution.js";
 export * from "./foreground-broker.js";
+export * from "./main.js";
 export * from "./native-launcher.js";
-//# sourceMappingURL=index.d.ts.map

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

@@ -1,4 +1,4 @@
 export * from "./command-resolution.js";
 export * from "./foreground-broker.js";
+export * from "./main.js";
 export * from "./native-launcher.js";
-//# sourceMappingURL=index.js.map