@timurproko/a1 0.1.0 → 0.1.1-dev.1

package/dist/src/foundation/release/release-gc.js

@@ -14,4 +14,3 @@ export async function collectRelease(store, dataDir, releaseId, externalReferenc
     await store.removeUnreferencedRelease(releaseId, externalReferences);
     await rm(release.releaseRoot, { recursive: true, force: false });
 }
-//# sourceMappingURL=release-gc.js.map

package/dist/src/foundation/release/release-store.d.ts

@@ -1,11 +1,10 @@
-import { type AddOneReleaseIdentity } from "./release.js";
-export declare const RELEASE_MANIFEST = ".addone-release.json";
-export interface MaterializedRelease extends AddOneReleaseIdentity {
+import { type ReleaseIdentity } from "./release.js";
+export declare const RELEASE_MANIFEST_FILENAME: string;
+export interface MaterializedRelease extends ReleaseIdentity {
     readonly releaseRoot: string;
 }
 export declare function materializeRelease(packageRoot: string, dataDir: string): Promise<MaterializedRelease>;
 export declare function readMaterializedRelease(releaseRoot: string): Promise<MaterializedRelease>;
-export declare function verifyMaterializedRelease(releaseRoot: string, expected?: AddOneReleaseIdentity, selectedStoreRoot?: string): Promise<MaterializedRelease>;
+export declare function verifyMaterializedRelease(releaseRoot: string, expected?: ReleaseIdentity, selectedStoreRoot?: string): Promise<MaterializedRelease>;
 export declare function assertImmutableExecutionRoot(release: MaterializedRelease, dataDir: string): Promise<void>;
 export declare function resolveReleaseEntryPoint(release: MaterializedRelease, entryPoint: string): Promise<string>;
-//# sourceMappingURL=release-store.d.ts.map

package/dist/src/foundation/release/release-store.js

@@ -1,8 +1,9 @@
 import { createHash, randomUUID } from "node:crypto";
 import { chmod, copyFile, lstat, mkdir, readFile, realpath, rename, rm, writeFile } from "node:fs/promises";
 import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
-import { ADDONE_PACKAGE_NAME, deriveReleaseIdentity, resolveWithin } from "./release.js";
-export const RELEASE_MANIFEST = ".addone-release.json";
+import { PRODUCT_PACKAGE_NAME, deriveReleaseIdentity, resolveWithin } from "./release.js";
+import { PRODUCT_IDENTITY, PRODUCT_TEXT } from "../../product-identity.js";
+export const RELEASE_MANIFEST_FILENAME = PRODUCT_IDENTITY.manifest.releaseFilename;
 export async function materializeRelease(packageRoot, dataDir) {
     const identity = await deriveReleaseIdentity(packageRoot);
     const storeRoot = resolve(dataDir, "releases");
@@ -21,7 +22,7 @@ export async function materializeRelease(packageRoot, dataDir) {
             await copyFile(source, destination);
             await chmod(destination, file.executable ? 0o500 : 0o400);
         }
-        await writeFile(resolve(candidate, RELEASE_MANIFEST), JSON.stringify(identity, null, 2), { mode: 0o400, flag: "wx" });
+        await writeFile(resolve(candidate, RELEASE_MANIFEST_FILENAME), JSON.stringify(identity, null, 2), { mode: 0o400, flag: "wx" });
         await verifyMaterializedRelease(candidate, identity);
         await rename(candidate, releaseRoot);
         return await verifyMaterializedRelease(releaseRoot, identity);
@@ -33,14 +34,14 @@ export async function materializeRelease(packageRoot, dataDir) {
 }
 export async function readMaterializedRelease(releaseRoot) {
     const canonical = await realpath(releaseRoot);
-    const manifest = JSON.parse(await readFile(resolve(canonical, RELEASE_MANIFEST), "utf8"));
+    const manifest = JSON.parse(await readFile(resolve(canonical, RELEASE_MANIFEST_FILENAME), "utf8"));
     return await verifyMaterializedRelease(canonical, manifest);
 }
 export async function verifyMaterializedRelease(releaseRoot, expected, selectedStoreRoot) {
     const canonical = await realpath(releaseRoot);
     if (selectedStoreRoot)
         assertContained(await realpath(selectedStoreRoot), canonical, "release root is outside the selected release store");
-    const manifestPath = resolveWithin(canonical, RELEASE_MANIFEST);
+    const manifestPath = resolveWithin(canonical, RELEASE_MANIFEST_FILENAME);
     const manifest = JSON.parse(await readFile(manifestPath, "utf8"));
     validateManifest(manifest);
     if (expected && (manifest.releaseId !== expected.releaseId || manifest.contentDigest !== expected.contentDigest)) {
@@ -58,11 +59,12 @@ export async function verifyMaterializedRelease(releaseRoot, expected, selectedS
 }
 export async function assertImmutableExecutionRoot(release, dataDir) {
     await verifyMaterializedRelease(release.releaseRoot, release, resolve(dataDir, "releases"));
-    if (!process.env.ADDONE_RELEASE_ROOT)
-        throw new Error("persistent AddOne process has no immutable release root");
-    const selected = await realpath(process.env.ADDONE_RELEASE_ROOT);
+    const selectedRoot = process.env[PRODUCT_IDENTITY.environment.releaseRoot];
+    if (!selectedRoot)
+        throw new Error(PRODUCT_TEXT.diagnostic("persistent process has no immutable release root"));
+    const selected = await realpath(selectedRoot);
     if (selected !== release.releaseRoot)
-        throw new Error("persistent AddOne process selected a different immutable release root");
+        throw new Error(PRODUCT_TEXT.diagnostic("persistent process selected a different immutable release root"));
 }
 export async function resolveReleaseEntryPoint(release, entryPoint) {
     const normalized = entryPoint.split("\\").join("/").replace(/^\.\//, "");
@@ -85,10 +87,10 @@ async function verifyFile(root, file) {
         throw new Error(`release file digest mismatch: ${file.path}`);
 }
 function validateManifest(value) {
-    if (value.packageName !== ADDONE_PACKAGE_NAME || typeof value.packageVersion !== "string")
-        throw new Error("invalid AddOne release manifest metadata");
+    if (value.packageName !== PRODUCT_PACKAGE_NAME || typeof value.packageVersion !== "string")
+        throw new Error(PRODUCT_TEXT.diagnostic("release manifest metadata is invalid"));
     if (!/^[a-f0-9]{64}$/.test(value.contentDigest) || !/^[0-9A-Za-z.+_-]+-[a-f0-9]{20}$/.test(value.releaseId))
-        throw new Error("invalid AddOne release identity");
+        throw new Error(PRODUCT_TEXT.diagnostic("release identity is invalid"));
     if (!Array.isArray(value.files) || value.files.length === 0)
         throw new Error("release manifest contains no files");
     for (const file of value.files) {
@@ -112,4 +114,3 @@ function assertContained(parent, child, message) {
         return;
     throw new Error(`${message}: ${child}`);
 }
-//# sourceMappingURL=release-store.js.map

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

@@ -1,12 +1,12 @@
-export declare const ADDONE_PACKAGE_NAME = "@timurproko/a1";
+export declare const PRODUCT_PACKAGE_NAME: string;
 export interface ReleaseFileIdentity {
     readonly path: string;
     readonly bytes: number;
     readonly sha256: string;
     readonly executable: boolean;
 }
-export interface AddOneReleaseIdentity {
-    readonly packageName: typeof ADDONE_PACKAGE_NAME;
+export interface ReleaseIdentity {
+    readonly packageName: typeof PRODUCT_PACKAGE_NAME;
     readonly packageVersion: string;
     readonly contentDigest: string;
     readonly releaseId: string;
@@ -14,11 +14,10 @@ export interface AddOneReleaseIdentity {
     readonly files: readonly ReleaseFileIdentity[];
 }
 /**
- * Derive AddOne execution identity only from installed distribution metadata and
+ * Derive release execution identity only from installed distribution metadata and
  * bytes. The version remains display metadata; the digest selects executable
  * content.
  */
-export declare function deriveReleaseIdentity(packageRoot: string): Promise<AddOneReleaseIdentity>;
+export declare function deriveReleaseIdentity(packageRoot: string): Promise<ReleaseIdentity>;
 export declare function resolveWithin(root: string, candidate: string): string;
 export declare function packageRootFromModule(moduleUrl: string): string;
-//# sourceMappingURL=release.d.ts.map

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

@@ -1,9 +1,10 @@
 import { createHash } from "node:crypto";
 import { lstat, readFile, readdir, realpath } from "node:fs/promises";
 import { basename, dirname, isAbsolute, relative, resolve, sep } from "node:path";
-export const ADDONE_PACKAGE_NAME = "@timurproko/a1";
+import { PRODUCT_IDENTITY, PRODUCT_TEXT } from "../../product-identity.js";
+export const PRODUCT_PACKAGE_NAME = PRODUCT_IDENTITY.packageName;
 /**
- * Derive AddOne execution identity only from installed distribution metadata and
+ * Derive release execution identity only from installed distribution metadata and
  * bytes. The version remains display metadata; the digest selects executable
  * content.
  */
@@ -11,10 +12,10 @@ export async function deriveReleaseIdentity(packageRoot) {
     const canonicalRoot = await realpath(packageRoot);
     const manifestPath = resolve(canonicalRoot, "package.json");
     const manifest = JSON.parse(await readFile(manifestPath, "utf8"));
-    if (manifest.name !== ADDONE_PACKAGE_NAME)
-        throw new Error(`unexpected AddOne package name: ${String(manifest.name)}`);
+    if (manifest.name !== PRODUCT_PACKAGE_NAME)
+        throw new Error(`unexpected ${PRODUCT_TEXT.displayName} package name: ${String(manifest.name)}`);
     if (typeof manifest.version !== "string" || manifest.version.length === 0)
-        throw new Error("AddOne package metadata has no version");
+        throw new Error(PRODUCT_TEXT.diagnostic("package metadata has no version"));
     const roots = distributionRoots(manifest);
     const paths = new Set(["package.json"]);
     for (const root of roots) {
@@ -41,7 +42,7 @@ export async function deriveReleaseIdentity(packageRoot) {
         digest.update(`${file.path}\0${file.bytes}\0${file.sha256}\0${file.executable ? 1 : 0}\n`);
     const contentDigest = digest.digest("hex");
     return {
-        packageName: ADDONE_PACKAGE_NAME,
+        packageName: PRODUCT_PACKAGE_NAME,
         packageVersion: manifest.version,
         contentDigest,
         releaseId: `${manifest.version}-${contentDigest.slice(0, 20)}`,
@@ -60,15 +61,15 @@ export function resolveWithin(root, candidate) {
 }
 function distributionRoots(manifest) {
     if (!Array.isArray(manifest.files))
-        throw new Error("AddOne package metadata has no distribution files list");
+        throw new Error(PRODUCT_TEXT.diagnostic("package metadata has no distribution files list"));
     const roots = manifest.files.map(value => {
         if (typeof value !== "string" || value.length === 0)
-            throw new Error("AddOne distribution file entry is invalid");
+            throw new Error(PRODUCT_TEXT.diagnostic("distribution file entry is invalid"));
         const normalized = normalizeRelative(value);
         if (normalized === "package.json")
             return normalized;
         if (isAbsolute(value) || normalized === ".." || normalized.startsWith("../"))
-            throw new Error(`AddOne distribution path escapes package root: ${value}`);
+            throw new Error(PRODUCT_TEXT.diagnostic(`distribution path escapes package root: ${value}`));
         return normalized;
     });
     return [...new Set(roots)];
@@ -98,7 +99,7 @@ async function collectDependencyClosure(root, requesterRoot, manifest, output, v
         if (!packagePath) {
             if (optional.has(name))
                 continue;
-            throw new Error(`installed AddOne dependency is missing: ${name}`);
+            throw new Error(`installed ${PRODUCT_TEXT.displayName} dependency is missing: ${name}`);
         }
         if (visited.has(packagePath))
             continue;
@@ -130,7 +131,7 @@ function dependencyNames(value) {
     if (value === undefined)
         return [];
     if (typeof value !== "object" || value === null || Array.isArray(value))
-        throw new Error("AddOne dependency metadata is invalid");
+        throw new Error(PRODUCT_TEXT.diagnostic("dependency metadata is invalid"));
     return Object.keys(value);
 }
 function normalizeRelative(path) {
@@ -139,13 +140,12 @@ function normalizeRelative(path) {
 export function packageRootFromModule(moduleUrl) {
     const url = new URL(moduleUrl);
     if (url.protocol !== "file:")
-        throw new Error(`AddOne module URL must be a file URL: ${moduleUrl}`);
+        throw new Error(PRODUCT_TEXT.diagnostic(`module URL must be a file URL: ${moduleUrl}`));
     let directory = dirname(url.pathname.replace(/^\/(.:)/, "$1"));
     while (basename(directory) !== "") {
         if (basename(directory) === "dist")
             return dirname(directory);
         directory = dirname(directory);
     }
-    throw new Error("could not derive AddOne package root from module URL");
+    throw new Error(PRODUCT_TEXT.diagnostic("package root could not be derived from module URL"));
 }
-//# sourceMappingURL=release.js.map

package/dist/src/foundation/release/stable-release.d.ts

@@ -1,3 +1,4 @@
+export declare const STABLE_RELEASE_SCHEMA: string;
 export interface StableReleaseEvidenceInput {
     readonly packageName: string;
     readonly version: string;
@@ -9,7 +10,7 @@ export interface StableReleaseEvidenceInput {
     readonly recordedAt: string;
 }
 export interface StableReleaseEvidence extends StableReleaseEvidenceInput {
-    readonly schema: "addone-stable-release-v1";
+    readonly schema: typeof STABLE_RELEASE_SCHEMA;
     readonly channel: "latest";
 }
 export interface StableRegistryState {
@@ -27,4 +28,3 @@ export interface StableRegistryVerificationOptions {
 }
 export declare function createStableReleaseEvidence(input: StableReleaseEvidenceInput): StableReleaseEvidence;
 export declare function verifyStableRegistry(expected: StableReleaseEvidence, observe: () => Promise<StableRegistryState>, options?: StableRegistryVerificationOptions): Promise<void>;
-//# sourceMappingURL=stable-release.d.ts.map

package/dist/src/foundation/release/stable-release.js

@@ -1,7 +1,9 @@
 import { prerelease, valid } from "semver";
-import { ADDONE_PACKAGE_NAME } from "./release.js";
+import { PRODUCT_PACKAGE_NAME } from "./release.js";
+import { PRODUCT_IDENTITY } from "../../product-identity.js";
+export const STABLE_RELEASE_SCHEMA = PRODUCT_IDENTITY.evidence.stableReleaseSchema;
 export function createStableReleaseEvidence(input) {
-    if (input.packageName !== ADDONE_PACKAGE_NAME)
+    if (input.packageName !== PRODUCT_PACKAGE_NAME)
         throw new Error(`unexpected stable package: ${input.packageName}`);
     if (valid(input.version) === null || prerelease(input.version) !== null)
         throw new Error(`stable release requires an exact stable version: ${input.version}`);
@@ -11,7 +13,7 @@ export function createStableReleaseEvidence(input) {
         throw new Error("stable release integrity is malformed");
     if (!/^[a-f0-9]{40}$/.test(input.shasum))
         throw new Error("stable release shasum is malformed");
-    return { schema: "addone-stable-release-v1", channel: "latest", ...input };
+    return { schema: STABLE_RELEASE_SCHEMA, channel: "latest", ...input };
 }
 export async function verifyStableRegistry(expected, observe, options = {}) {
     const attempts = options.attempts ?? 12;
@@ -28,11 +30,10 @@ export async function verifyStableRegistry(expected, observe, options = {}) {
             && state.integrity === expected.integrity
             && state.shasum === expected.shasum
             && state.bins.length === 1
-            && state.bins[0] === "a1")
+            && state.bins[0] === PRODUCT_IDENTITY.commandName)
             return;
         if (attempt < attempts)
             await delay(delayMs);
     }
     throw new Error(`npm latest did not match accepted ${expected.packageName}@${expected.version} after ${attempts} attempts: ${JSON.stringify(state)}`);
 }
-//# sourceMappingURL=stable-release.js.map

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

@@ -1,7 +1,8 @@
+export declare const UPDATE_JOURNAL_SCHEMA: string;
 import type { UpdateChannel } from "./update.js";
 export type UpdateTransactionPhase = "shutdown-intent" | "ownership-released" | "package-installed" | "materialized" | "certified" | "active-reference-committed" | "supervisor-verified";
 export interface UpdateTransaction {
-    readonly schemaVersion: 1;
+    readonly schema: typeof UPDATE_JOURNAL_SCHEMA;
     readonly transactionId: string;
     readonly channel: UpdateChannel;
     readonly targetVersion: string;
@@ -28,4 +29,3 @@ export declare class UpdateTransactionStore {
     finish(status: "completed" | "rolled-back" | "failed", error?: string | null): Promise<UpdateTransaction>;
     clearCompleted(): Promise<void>;
 }
-//# sourceMappingURL=update-transaction.d.ts.map

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

@@ -1,6 +1,8 @@
 import { randomUUID } from "node:crypto";
 import { mkdir, open, readFile, rename, rm } from "node:fs/promises";
 import { dirname, resolve } from "node:path";
+import { PRODUCT_IDENTITY, PRODUCT_TEXT } from "../../product-identity.js";
+export const UPDATE_JOURNAL_SCHEMA = PRODUCT_IDENTITY.protocol.updateJournalSchema;
 export class UpdateTransactionStore {
     path;
     constructor(dataDir) { this.path = resolve(dataDir, "update-transaction.json"); }
@@ -20,13 +22,13 @@ export class UpdateTransactionStore {
         const current = await this.read();
         if (current?.status === "active") {
             if (current.targetVersion !== input.targetVersion || current.channel !== input.channel) {
-                throw new Error(`unfinished AddOne update ${current.transactionId} targets ${current.targetVersion}; reconcile it before starting ${input.targetVersion}`);
+                throw new Error(PRODUCT_TEXT.diagnostic(`has unfinished update ${current.transactionId} targeting ${current.targetVersion}; reconcile it before starting ${input.targetVersion}`));
             }
             return current;
         }
         const now = new Date().toISOString();
         return await this.#write({
-            schemaVersion: 1,
+            schema: UPDATE_JOURNAL_SCHEMA,
             transactionId: randomUUID(),
             ...input,
             phase: "shutdown-intent",
@@ -45,7 +47,7 @@ export class UpdateTransactionStore {
     async finish(status, error = null) {
         const current = await this.read();
         if (!current)
-            throw new Error("no AddOne update transaction is recorded");
+            throw new Error(`no ${PRODUCT_TEXT.displayName} update transaction is recorded`);
         return await this.#write({ ...current, status, error, updatedAt: new Date().toISOString() });
     }
     async clearCompleted() {
@@ -56,7 +58,7 @@ export class UpdateTransactionStore {
     async #requiredActive() {
         const current = await this.read();
         if (!current || current.status !== "active")
-            throw new Error("no active AddOne update transaction is recorded");
+            throw new Error(`no active ${PRODUCT_TEXT.displayName} update transaction is recorded`);
         return current;
     }
     async #write(value) {
@@ -79,10 +81,9 @@ function phaseOrder(phase) {
     return ["shutdown-intent", "ownership-released", "package-installed", "materialized", "certified", "active-reference-committed", "supervisor-verified"].indexOf(phase);
 }
 function validate(value) {
-    if (value.schemaVersion !== 1 || typeof value.transactionId !== "string" || !["stable", "next"].includes(value.channel)
+    if (value.schema !== UPDATE_JOURNAL_SCHEMA || typeof value.transactionId !== "string" || !["stable", "next"].includes(value.channel)
         || typeof value.targetVersion !== "string" || typeof value.packageRoot !== "string" || typeof value.startedAt !== "string"
         || typeof value.updatedAt !== "string" || phaseOrder(value.phase) < 0 || !["active", "completed", "rolled-back", "failed"].includes(value.status)) {
-        throw new Error("invalid AddOne update transaction journal");
+        throw new Error(`invalid ${PRODUCT_TEXT.displayName} update transaction journal`);
     }
 }
-//# sourceMappingURL=update-transaction.js.map

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;
@@ -52,4 +52,3 @@ export interface UpdateTransactionJournal {
 export declare function createNpmProcessRunner(platform?: NodeJS.Platform): UpdateProcessRunner;
 export declare function createUpdateLifecycleCoordinator(environment?: NodeJS.ProcessEnv, fileSystem?: UpdateFileSystem): UpdateLifecycleCoordinator;
 export declare function runSelfUpdate(options: SelfUpdateOptions): Promise<number>;
-//# sourceMappingURL=update.d.ts.map

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"); },
@@ -40,7 +41,7 @@ export function createNpmProcessRunner(platform = process.platform) {
     });
 }
 export function createUpdateLifecycleCoordinator(environment = process.env, fileSystem = defaultFileSystem) {
-    const paths = resolveAddOnePaths(environment);
+    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,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);
@@ -135,23 +136,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,15 +161,15 @@ 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 paths = resolveProductPaths(environment);
     const lifecycle = options.lifecycle ?? createUpdateLifecycleCoordinator(environment, fileSystem);
     const transactionStore = options.transactionStore ?? new UpdateTransactionStore(paths.dataDir);
     let transaction = await transactionStore.read();
@@ -179,7 +180,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 +196,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 +208,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 +218,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 +257,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 +281,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 +314,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