@timurproko/a1 0.1.0 → 0.1.1-dev.1

package/dist/src/foundation/agent-engine-contracts/domain.d.ts

@@ -0,0 +1,90 @@
+export type AgentJsonValue = null | boolean | number | string | readonly AgentJsonValue[] | {
+    readonly [key: string]: AgentJsonValue;
+};
+export type AgentMessageContent = {
+    readonly kind: "text" | "thinking";
+    readonly text: string;
+} | {
+    readonly kind: "image";
+    readonly mediaType: string;
+    readonly data: string;
+} | {
+    readonly kind: "tool-call";
+    readonly invocationId: string;
+    readonly toolName: string;
+    readonly input: AgentJsonValue;
+} | {
+    readonly kind: "tool-result";
+    readonly invocationId: string;
+    readonly output: AgentJsonValue;
+    readonly failed: boolean;
+} | {
+    readonly kind: "unknown";
+    readonly sourceType: string;
+    readonly payload: AgentJsonValue;
+};
+export interface AgentMessage {
+    readonly id: string;
+    readonly role: "user" | "assistant" | "tool" | "system";
+    readonly status: "streaming" | "final";
+    readonly content: readonly AgentMessageContent[];
+}
+export interface AgentToolDescriptor {
+    readonly name: string;
+    readonly description: string;
+    readonly inputSchema: AgentJsonValue;
+}
+export interface AgentUsage {
+    readonly inputTokens: number;
+    readonly outputTokens: number;
+    readonly cacheReadTokens: number;
+    readonly cacheWriteTokens: number;
+    readonly cost: number | null;
+}
+export interface AgentModelDescriptor {
+    readonly providerId: string;
+    readonly modelId: string;
+    readonly displayName: string;
+    readonly contextWindow: number;
+    readonly thinkingLevels: readonly string[];
+}
+export interface AgentSettingDescriptor {
+    readonly key: string;
+    readonly valueType: "boolean" | "number" | "string" | "enum" | "json";
+    readonly writable: boolean;
+    readonly choices?: readonly AgentJsonValue[];
+}
+export interface AgentResourceDescriptor {
+    readonly id: string;
+    readonly kind: "command" | "prompt" | "skill" | "extension" | "other";
+    readonly label: string;
+    readonly metadata: AgentJsonValue;
+}
+export interface AgentThemeDescriptor {
+    readonly id: string;
+    readonly label: string;
+    readonly tokens: Readonly<Record<string, string>>;
+}
+export interface AgentUiContribution {
+    readonly id: string;
+    readonly slot: "transcript" | "tool" | "editor" | "status" | "dialog" | "overlay" | "unknown";
+    readonly version: number;
+    readonly payload: AgentJsonValue;
+}
+export type AgentFailureCategory = "configuration" | "authentication" | "authorization" | "network" | "rate-limit" | "context-limit" | "tool" | "cancelled" | "engine" | "unknown";
+export interface AgentFailure {
+    readonly category: AgentFailureCategory;
+    readonly code: string;
+    readonly message: string;
+    readonly retryable: boolean;
+    readonly details: AgentJsonValue;
+}
+export interface AgentDomainCapabilities {
+    readonly messageContent: readonly AgentMessageContent["kind"][];
+    readonly tools: readonly ("discovery" | "invocation" | "streaming-results")[];
+    readonly usage: readonly ("tokens" | "cache" | "cost")[];
+    readonly models: readonly ("discovery" | "selection" | "thinking-level")[];
+    readonly settings: readonly ("read" | "write")[];
+    readonly resources: readonly ("commands" | "prompts" | "skills" | "extensions" | "themes")[];
+    readonly uiContributions: readonly AgentUiContribution["slot"][];
+}

package/dist/src/foundation/agent-engine-contracts/domain.js

@@ -0,0 +1 @@
+export {};

package/dist/src/foundation/agent-engine-contracts/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./capability-ports.js";
+export * from "./domain.js";
+export * from "./domain-validation.js";
+export * from "./model.js";
+export * from "./ports.js";
+export * from "./validation.js";
+export * from "./serialization.js";

package/dist/src/foundation/agent-engine-contracts/index.js

@@ -0,0 +1,7 @@
+export * from "./capability-ports.js";
+export * from "./domain.js";
+export * from "./domain-validation.js";
+export * from "./model.js";
+export * from "./ports.js";
+export * from "./validation.js";
+export * from "./serialization.js";

package/dist/src/foundation/agent-engine-contracts/model.d.ts

@@ -0,0 +1,78 @@
+import type { AgentMessage } from "./domain.js";
+export declare const AGENT_ENGINE_CONTRACT_VERSION: 1;
+export type AgentSessionId = string;
+export type AgentCommandId = string;
+export type AgentEventSequence = number;
+export type AgentSessionLifecycle = "starting" | "ready" | "busy" | "stopping" | "stopped" | "failed";
+export type AgentCommandCapability = "prompt" | "steer" | "follow-up" | "abort" | "retry" | "compact" | "bash" | "replace-session";
+export type AgentEventCapability = "lifecycle" | "content" | "command-outcome" | "snapshot-invalidated" | "diagnostic";
+export interface AgentCapabilityContract {
+    readonly contractVersion: typeof AGENT_ENGINE_CONTRACT_VERSION;
+    readonly commands: readonly AgentCommandCapability[];
+    readonly events: readonly AgentEventCapability[];
+    readonly snapshots: {
+        readonly supported: boolean;
+        readonly maxBytes: number;
+    };
+}
+interface AgentCommandEnvelope {
+    readonly contractVersion: typeof AGENT_ENGINE_CONTRACT_VERSION;
+    readonly commandId: AgentCommandId;
+    readonly sessionId: AgentSessionId;
+}
+export type AgentCommand = (AgentCommandEnvelope & {
+    readonly type: "prompt" | "steer" | "follow-up";
+    readonly text: string;
+}) | (AgentCommandEnvelope & {
+    readonly type: "abort" | "retry" | "compact";
+}) | (AgentCommandEnvelope & {
+    readonly type: "bash";
+    readonly command: string;
+}) | (AgentCommandEnvelope & {
+    readonly type: "replace-session";
+    readonly source: {
+        readonly kind: "new";
+    } | {
+        readonly kind: "resume";
+        readonly sessionPath: string;
+    };
+});
+export type AgentCommandOutcome = "accepted" | "completed" | "rejected" | "failed" | "cancelled";
+interface AgentEventEnvelope {
+    readonly contractVersion: typeof AGENT_ENGINE_CONTRACT_VERSION;
+    readonly sessionId: AgentSessionId;
+    readonly sequence: AgentEventSequence;
+}
+export type AgentEvent = (AgentEventEnvelope & {
+    readonly type: "lifecycle";
+    readonly lifecycle: AgentSessionLifecycle;
+    readonly reason: string | null;
+}) | (AgentEventEnvelope & {
+    readonly type: "content";
+    readonly content: AgentMessage;
+}) | (AgentEventEnvelope & {
+    readonly type: "command-outcome";
+    readonly commandId: AgentCommandId;
+    readonly outcome: AgentCommandOutcome;
+    readonly diagnostic: string | null;
+}) | (AgentEventEnvelope & {
+    readonly type: "snapshot-invalidated";
+    readonly expectedRevision: number;
+}) | (AgentEventEnvelope & {
+    readonly type: "diagnostic";
+    readonly code: string;
+    readonly message: string;
+    readonly recoverable: boolean;
+});
+export interface AgentSnapshot {
+    readonly contractVersion: typeof AGENT_ENGINE_CONTRACT_VERSION;
+    readonly snapshotId: string;
+    readonly sessionId: AgentSessionId;
+    readonly revision: number;
+    readonly sequence: AgentEventSequence;
+    readonly lifecycle: AgentSessionLifecycle;
+    readonly content: readonly AgentMessage[];
+    readonly activeCommandIds: readonly AgentCommandId[];
+    readonly capabilities: AgentCapabilityContract;
+}
+export {};

package/dist/src/foundation/agent-engine-contracts/model.js

@@ -0,0 +1 @@
+export const AGENT_ENGINE_CONTRACT_VERSION = 1;

package/dist/src/foundation/agent-engine-contracts/ports.d.ts

@@ -0,0 +1,18 @@
+import type { AgentCapabilityContract, AgentCommand, AgentCommandOutcome, AgentEvent, AgentSessionId, AgentSessionLifecycle, AgentSnapshot } from "./model.js";
+export interface AgentSessionPort {
+    readonly sessionId: AgentSessionId;
+    readonly lifecycle: AgentSessionLifecycle;
+    readonly capabilities: AgentCapabilityContract;
+    execute(command: AgentCommand): Promise<AgentCommandOutcome>;
+    subscribe(listener: (event: AgentEvent) => void): () => void;
+    snapshot(): Promise<AgentSnapshot>;
+    dispose(): Promise<void>;
+}
+export interface AgentEnginePort {
+    readonly capabilities: AgentCapabilityContract;
+    createSession(input: {
+        readonly sessionId: AgentSessionId;
+        readonly cwd: string;
+    }): Promise<AgentSessionPort>;
+    dispose(): Promise<void>;
+}

package/dist/src/foundation/agent-engine-contracts/ports.js

@@ -0,0 +1 @@
+export {};

package/dist/src/foundation/agent-engine-contracts/serialization.d.ts

@@ -0,0 +1,7 @@
+import type { AgentCapabilityContract, AgentCommand, AgentEvent, AgentSnapshot } from "./model.js";
+export declare function encodeAgentCommand(command: AgentCommand, capabilities?: AgentCapabilityContract): string;
+export declare function decodeAgentCommand(source: string, capabilities?: AgentCapabilityContract): AgentCommand;
+export declare function encodeAgentEvent(event: AgentEvent, capabilities?: AgentCapabilityContract): string;
+export declare function decodeAgentEvent(source: string, capabilities?: AgentCapabilityContract): AgentEvent;
+export declare function encodeAgentSnapshot(snapshot: AgentSnapshot): string;
+export declare function decodeAgentSnapshot(source: string): AgentSnapshot;

package/dist/src/foundation/agent-engine-contracts/serialization.js

@@ -0,0 +1,58 @@
+import { assertAgentCommand, assertAgentEvent, assertAgentSnapshot } from "./validation.js";
+const MAX_ENVELOPE_BYTES = 1024 * 1024;
+export function encodeAgentCommand(command, capabilities) {
+    assertAgentCommand(command, capabilities);
+    return encode(command);
+}
+export function decodeAgentCommand(source, capabilities) {
+    const value = decode(source);
+    assertAgentCommand(value, capabilities);
+    return value;
+}
+export function encodeAgentEvent(event, capabilities) {
+    assertAgentEvent(event, capabilities);
+    return encode(event);
+}
+export function decodeAgentEvent(source, capabilities) {
+    const value = decode(source);
+    assertAgentEvent(value, capabilities);
+    return value;
+}
+export function encodeAgentSnapshot(snapshot) {
+    assertAgentSnapshot(snapshot);
+    const encoded = encode(snapshot);
+    if (Buffer.byteLength(encoded, "utf8") > snapshot.capabilities.snapshots.maxBytes)
+        throw new RangeError("agent snapshot exceeds negotiated byte limit");
+    return encoded;
+}
+export function decodeAgentSnapshot(source) {
+    const value = decode(source);
+    assertAgentSnapshot(value);
+    if (Buffer.byteLength(source, "utf8") > value.capabilities.snapshots.maxBytes)
+        throw new RangeError("agent snapshot exceeds negotiated byte limit");
+    return value;
+}
+function encode(value) {
+    let encoded;
+    try {
+        encoded = JSON.stringify(value);
+    }
+    catch (error) {
+        throw new TypeError("agent contract value must be JSON serializable", { cause: error });
+    }
+    if (encoded === undefined)
+        throw new TypeError("agent contract value must be JSON serializable");
+    if (Buffer.byteLength(encoded, "utf8") > MAX_ENVELOPE_BYTES)
+        throw new RangeError("agent contract envelope exceeds its byte limit");
+    return encoded;
+}
+function decode(source) {
+    if (typeof source !== "string" || Buffer.byteLength(source, "utf8") > MAX_ENVELOPE_BYTES)
+        throw new RangeError("agent contract envelope exceeds its byte limit");
+    try {
+        return JSON.parse(source);
+    }
+    catch (error) {
+        throw new TypeError("agent contract envelope is invalid JSON", { cause: error });
+    }
+}

package/dist/src/foundation/agent-engine-contracts/validation.d.ts

@@ -0,0 +1,5 @@
+import { type AgentCapabilityContract, type AgentCommand, type AgentEvent, type AgentSnapshot } from "./model.js";
+export declare function assertAgentCapabilityContract(value: AgentCapabilityContract): void;
+export declare function assertAgentCommand(command: AgentCommand, capabilities?: AgentCapabilityContract): void;
+export declare function assertAgentEvent(event: AgentEvent, capabilities?: AgentCapabilityContract): void;
+export declare function assertAgentSnapshot(snapshot: AgentSnapshot): void;

package/dist/src/foundation/agent-engine-contracts/validation.js

@@ -0,0 +1,128 @@
+import { AGENT_ENGINE_CONTRACT_VERSION, } from "./model.js";
+import { assertAgentMessage } from "./domain-validation.js";
+const COMMANDS = new Set(["prompt", "steer", "follow-up", "abort", "retry", "compact", "bash", "replace-session"]);
+const EVENTS = new Set(["lifecycle", "content", "command-outcome", "snapshot-invalidated", "diagnostic"]);
+const LIFECYCLES = new Set(["starting", "ready", "busy", "stopping", "stopped", "failed"]);
+const OUTCOMES = new Set(["accepted", "completed", "rejected", "failed", "cancelled"]);
+const MAX_TEXT_BYTES = 256 * 1024;
+const MAX_COLLECTION = 10_000;
+export function assertAgentCapabilityContract(value) {
+    assertVersion(value.contractVersion);
+    assertUniqueEnum(value.commands, COMMANDS, "agent command capabilities");
+    assertUniqueEnum(value.events, EVENTS, "agent event capabilities");
+    if (typeof value.snapshots?.supported !== "boolean" || !Number.isSafeInteger(value.snapshots.maxBytes) || value.snapshots.maxBytes < 1024) {
+        throw new TypeError("agent snapshot capability is invalid");
+    }
+}
+export function assertAgentCommand(command, capabilities) {
+    assertVersion(command.contractVersion);
+    assertId(command.commandId, "agent command id");
+    assertId(command.sessionId, "agent command session id");
+    if (!COMMANDS.has(command.type))
+        throw new TypeError("agent command type is unknown");
+    if (capabilities !== undefined) {
+        assertAgentCapabilityContract(capabilities);
+        if (!capabilities.commands.includes(command.type))
+            throw new TypeError(`agent command capability is unavailable: ${command.type}`);
+    }
+    if (command.type === "prompt" || command.type === "steer" || command.type === "follow-up")
+        assertText(command.text, "agent command text");
+    if (command.type === "bash")
+        assertText(command.command, "agent bash command");
+    if (command.type === "replace-session" && command.source.kind === "resume")
+        assertText(command.source.sessionPath, "agent resume path");
+}
+export function assertAgentEvent(event, capabilities) {
+    assertVersion(event.contractVersion);
+    assertId(event.sessionId, "agent event session id");
+    assertNonNegative(event.sequence, "agent event sequence");
+    if (!EVENTS.has(event.type))
+        throw new TypeError("agent event type is unknown");
+    if (capabilities !== undefined) {
+        assertAgentCapabilityContract(capabilities);
+        if (!capabilities.events.includes(event.type))
+            throw new TypeError(`agent event capability is unavailable: ${event.type}`);
+    }
+    switch (event.type) {
+        case "lifecycle":
+            if (!LIFECYCLES.has(event.lifecycle))
+                throw new TypeError("agent lifecycle is invalid");
+            if (event.reason !== null)
+                assertText(event.reason, "agent lifecycle reason");
+            return;
+        case "content":
+            assertAgentMessage(event.content);
+            return;
+        case "command-outcome":
+            assertId(event.commandId, "agent outcome command id");
+            if (!OUTCOMES.has(event.outcome))
+                throw new TypeError("agent command outcome is invalid");
+            if (event.diagnostic !== null)
+                assertText(event.diagnostic, "agent outcome diagnostic");
+            return;
+        case "snapshot-invalidated":
+            assertNonNegative(event.expectedRevision, "agent expected snapshot revision");
+            return;
+        case "diagnostic":
+            assertId(event.code, "agent diagnostic code");
+            assertText(event.message, "agent diagnostic message");
+            if (typeof event.recoverable !== "boolean")
+                throw new TypeError("agent diagnostic recovery flag is invalid");
+    }
+}
+export function assertAgentSnapshot(snapshot) {
+    assertVersion(snapshot.contractVersion);
+    assertId(snapshot.snapshotId, "agent snapshot id");
+    assertId(snapshot.sessionId, "agent snapshot session id");
+    assertNonNegative(snapshot.revision, "agent snapshot revision");
+    assertNonNegative(snapshot.sequence, "agent snapshot sequence");
+    if (!LIFECYCLES.has(snapshot.lifecycle))
+        throw new TypeError("agent snapshot lifecycle is invalid");
+    assertAgentCapabilityContract(snapshot.capabilities);
+    if (!Array.isArray(snapshot.content) || snapshot.content.length > MAX_COLLECTION)
+        throw new RangeError("agent snapshot content collection is invalid");
+    for (const content of snapshot.content)
+        assertAgentEvent({ contractVersion: AGENT_ENGINE_CONTRACT_VERSION, sessionId: snapshot.sessionId, sequence: snapshot.sequence, type: "content", content });
+    if (!Array.isArray(snapshot.activeCommandIds) || snapshot.activeCommandIds.length > MAX_COLLECTION)
+        throw new RangeError("agent active command collection is invalid");
+    const ids = new Set();
+    for (const id of snapshot.activeCommandIds) {
+        assertId(id, "agent active command id");
+        if (ids.has(id))
+            throw new TypeError(`duplicate agent active command id: ${id}`);
+        ids.add(id);
+    }
+}
+function assertVersion(version) {
+    if (version !== AGENT_ENGINE_CONTRACT_VERSION)
+        throw new TypeError("unsupported agent engine contract version");
+}
+function assertUniqueEnum(values, allowed, label) {
+    if (!Array.isArray(values))
+        throw new TypeError(`${label} must be an array`);
+    const unique = new Set();
+    for (const value of values) {
+        if (!allowed.has(value))
+            throw new TypeError(`${label} contains an unknown value: ${String(value)}`);
+        if (unique.has(value))
+            throw new TypeError(`${label} contains a duplicate value: ${String(value)}`);
+        unique.add(value);
+    }
+}
+function assertId(value, label) {
+    if (typeof value !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(value))
+        throw new TypeError(`${label} is invalid`);
+}
+function assertText(value, label) {
+    if (typeof value !== "string" || value.length === 0)
+        throw new TypeError(`${label} is invalid`);
+    assertPossiblyEmptyText(value, label);
+}
+function assertPossiblyEmptyText(value, label) {
+    if (typeof value !== "string" || Buffer.byteLength(value, "utf8") > MAX_TEXT_BYTES)
+        throw new RangeError(`${label} exceeds its byte limit`);
+}
+function assertNonNegative(value, label) {
+    if (!Number.isSafeInteger(value) || value < 0)
+        throw new TypeError(`${label} is invalid`);
+}

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

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

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

@@ -1,3 +1,2 @@
 export * from "./model.js";
 export * from "./paths.js";
-//# sourceMappingURL=index.js.map

package/dist/src/foundation/lifecycle/model.d.ts

@@ -1,4 +1,4 @@
-export type LaunchProfileId = "addone" | "pi" | "sandbox";
+export type LaunchProfileId = "a1" | "pi" | "sandbox";
 export type GenerationId = string;
 export type DriverProfileId = string;
 export type RequestId = string;
@@ -98,4 +98,3 @@ export declare function assertLaunchProfileId(value: unknown): asserts value is
 export declare function assertDimensions(dimensions: TerminalDimensions): void;
 export declare function assertTransparentTerminalLaunchProfile(profile: TransparentTerminalLaunchProfile): void;
 export declare function assertNativeProcessIdentity(identity: NativeProcessIdentity): void;
-//# sourceMappingURL=model.d.ts.map

package/dist/src/foundation/lifecycle/model.js

@@ -1,6 +1,7 @@
+import { PRODUCT_TEXT } from "../../product-identity.js";
 export function assertLaunchProfileId(value) {
-    if (value !== "addone" && value !== "pi" && value !== "sandbox")
-        throw new TypeError(`invalid AddOne launch profile: ${String(value)}`);
+    if (value !== "a1" && value !== "pi" && value !== "sandbox")
+        throw new TypeError(PRODUCT_TEXT.diagnostic(`launch profile is invalid: ${String(value)}`));
 }
 export function assertDimensions(dimensions) {
     if (!Number.isInteger(dimensions.columns) || dimensions.columns < 2 || dimensions.columns > 500) {
@@ -37,4 +38,3 @@ export function assertNativeProcessIdentity(identity) {
         throw new TypeError("invalid native process identity");
     }
 }
-//# sourceMappingURL=model.js.map

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

@@ -1,4 +1,4 @@
-export interface AddOnePaths {
+export interface ProductPaths {
     readonly configDir: string;
     readonly dataDir: string;
     readonly runtimeDir: string;
@@ -7,5 +7,4 @@ export interface AddOnePaths {
     readonly endpointMetadataPath: string;
     readonly supervisorLogPath: string;
 }
-export declare function resolveAddOnePaths(environment?: NodeJS.ProcessEnv): AddOnePaths;
-//# sourceMappingURL=paths.d.ts.map
+export declare function resolveProductPaths(environment?: NodeJS.ProcessEnv, hostPlatform?: NodeJS.Platform, fallbackHome?: string): ProductPaths;

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

@@ -1,26 +1,42 @@
 import { createHash } from "node:crypto";
 import { homedir, platform } from "node:os";
-import { join, resolve } from "node:path";
-export function resolveAddOnePaths(environment = process.env) {
-    const windows = platform() === "win32";
-    const home = environment.HOME ?? environment.USERPROFILE ?? homedir();
-    const configDir = resolve(environment.ADDONE_CONFIG_DIR
-        ?? (windows ? join(environment.APPDATA ?? home, "AddOne") : join(environment.XDG_CONFIG_HOME ?? join(home, ".config"), "addone")));
-    const dataDir = resolve(environment.ADDONE_DATA_DIR
-        ?? (windows ? join(environment.LOCALAPPDATA ?? home, "AddOne") : join(environment.XDG_DATA_HOME ?? join(home, ".local", "share"), "addone")));
-    const runtimeDir = resolve(environment.ADDONE_RUNTIME_DIR
-        ?? (windows ? join(dataDir, "runtime") : join(environment.XDG_RUNTIME_DIR ?? dataDir, "addone-runtime")));
+import { posix, win32 } from "node:path";
+import { PRODUCT_IDENTITY } from "../../product-identity.js";
+export function resolveProductPaths(environment = process.env, hostPlatform = platform(), fallbackHome = homedir()) {
+    const windows = hostPlatform === "win32";
+    const path = windows ? win32 : posix;
+    const home = environment.HOME ?? environment.USERPROFILE ?? fallbackHome;
+    const configOverride = environment[PRODUCT_IDENTITY.environment.configDir];
+    const dataOverride = environment[PRODUCT_IDENTITY.environment.dataDir];
+    const runtimeOverride = environment[PRODUCT_IDENTITY.environment.runtimeDir];
+    const databaseOverride = environment[PRODUCT_IDENTITY.environment.databasePath];
+    const endpointOverride = environment[PRODUCT_IDENTITY.environment.endpoint];
+    const configDir = path.resolve(configOverride
+        ?? (windows
+            ? path.join(environment.APPDATA ?? home, PRODUCT_IDENTITY.state.windowsControlDirectory)
+            : path.join(environment.XDG_CONFIG_HOME ?? path.join(home, ".config"), PRODUCT_IDENTITY.state.unixControlDirectory)));
+    const dataDir = path.resolve(dataOverride
+        ?? (windows
+            ? path.join(environment.LOCALAPPDATA ?? home, PRODUCT_IDENTITY.state.windowsControlDirectory)
+            : path.join(environment.XDG_DATA_HOME ?? path.join(home, ".local", "share"), PRODUCT_IDENTITY.state.unixControlDirectory)));
+    const runtimeDir = path.resolve(runtimeOverride
+        ?? (windows
+            ? path.join(dataDir, "runtime")
+            : environment.XDG_RUNTIME_DIR
+                ? path.join(environment.XDG_RUNTIME_DIR, PRODUCT_IDENTITY.state.unixControlDirectory)
+                : path.join(dataDir, "runtime")));
     const namespace = createHash("sha256").update(runtimeDir.toLowerCase()).digest("hex").slice(0, 20);
-    const endpoint = environment.ADDONE_ENDPOINT
-        ?? (windows ? `\\\\.\\pipe\\addone-${namespace}` : join(runtimeDir, "supervisor.sock"));
+    const endpoint = endpointOverride
+        ?? (windows
+            ? `\\\\.\\pipe\\${PRODUCT_IDENTITY.endpoint.windowsPipeStem}-${namespace}`
+            : path.join(runtimeDir, PRODUCT_IDENTITY.endpoint.unixSocketFilename));
     return {
         configDir,
         dataDir,
         runtimeDir,
-        databasePath: resolve(environment.ADDONE_DATABASE_PATH ?? join(dataDir, "control.sqlite3")),
+        databasePath: path.resolve(databaseOverride ?? path.join(dataDir, PRODUCT_IDENTITY.endpoint.databaseFilename)),
         endpoint,
-        endpointMetadataPath: join(runtimeDir, "supervisor.json"),
-        supervisorLogPath: join(runtimeDir, "supervisor.log"),
+        endpointMetadataPath: path.join(runtimeDir, PRODUCT_IDENTITY.endpoint.metadataFilename),
+        supervisorLogPath: path.join(runtimeDir, PRODUCT_IDENTITY.endpoint.supervisorLogFilename),
     };
 }
-//# sourceMappingURL=paths.js.map

package/dist/src/foundation/native-host-protocol/codec.d.ts

@@ -9,4 +9,3 @@ export declare class NativeHostFrameCodec {
     push(chunk: Buffer | string): NativeHostProofMessage[];
     private decodeLine;
 }
-//# sourceMappingURL=codec.d.ts.map

package/dist/src/foundation/native-host-protocol/codec.js

@@ -54,4 +54,3 @@ function isProofMessage(value) {
         && typeof value.type === "string"
         && ["hello", "hello-result", "command", "command-result", "event", "error"].includes(value.type);
 }
-//# sourceMappingURL=codec.js.map

package/dist/src/foundation/native-host-protocol/evidence.d.ts

@@ -1,4 +1,4 @@
-export declare const NATIVE_SPIKE_EVIDENCE_SCHEMA: "addone-native-host-spike-evidence-v1";
+export declare const NATIVE_SPIKE_EVIDENCE_SCHEMA: string;
 export declare const NATIVE_SPIKE_WORKLOADS: readonly ["four-concurrent-sessions", "input-routing", "unicode-cursor-modes", "alternate-screen", "paste", "mouse", "ime", "live-resize", "dpi", "high-rate-output", "pane-abnormal-exit", "host-cleanup"];
 export type NativeSpikeWorkloadId = typeof NATIVE_SPIKE_WORKLOADS[number];
 export interface NativeSpikeMetricSummary {
@@ -34,7 +34,7 @@ export interface NativeSpikeEvidence {
         readonly sizeBytes: number;
     };
     readonly source: {
-        readonly addoneCommit: string;
+        readonly "a1Commit": string;
         readonly libghosttyVtCommit: string;
         readonly portablePtyVersion: string;
         readonly crosstermVersion: string;
@@ -65,4 +65,3 @@ export interface NativeSpikeEvidence {
     };
 }
 export declare function assertNativeSpikeEvidence(value: NativeSpikeEvidence): void;
-//# sourceMappingURL=evidence.d.ts.map

package/dist/src/foundation/native-host-protocol/evidence.js

@@ -1,4 +1,5 @@
-export const NATIVE_SPIKE_EVIDENCE_SCHEMA = "addone-native-host-spike-evidence-v1";
+import { PRODUCT_IDENTITY, PRODUCT_TEXT } from "../../product-identity.js";
+export const NATIVE_SPIKE_EVIDENCE_SCHEMA = PRODUCT_IDENTITY.evidence.nativeSpikeSchema;
 export const NATIVE_SPIKE_WORKLOADS = [
     "four-concurrent-sessions",
     "input-routing",
@@ -34,8 +35,8 @@ export function assertNativeSpikeEvidence(value) {
         throw new TypeError("native spike artifact hash must be SHA-256");
     if (!Number.isSafeInteger(value.artifact.sizeBytes) || value.artifact.sizeBytes <= 0)
         throw new RangeError("native spike artifact size is invalid");
-    if (!/^[a-f0-9]{40}$/.test(value.source.addoneCommit))
-        throw new TypeError("native spike AddOne commit is invalid");
+    if (!/^[a-f0-9]{40}$/.test(value.source["a1Commit"]))
+        throw new TypeError(PRODUCT_TEXT.diagnostic("native spike commit is invalid"));
     if (value.source.libghosttyVtCommit !== EXPECTED_LIBGHOSTTY_VT ||
         value.source.portablePtyVersion !== EXPECTED_PORTABLE_PTY ||
         value.source.crosstermVersion !== EXPECTED_CROSSTERM) {
@@ -138,4 +139,3 @@ function assertJsonObject(value, name) {
     if (!encoded || encoded.length > 64_000)
         throw new RangeError(`${name} exceeds the bounded evidence detail limit`);
 }
-//# sourceMappingURL=evidence.js.map

package/dist/src/foundation/native-host-protocol/index.d.ts

@@ -2,4 +2,3 @@ export * from "./codec.js";
 export * from "./evidence.js";
 export * from "./messages.js";
 export * from "./proof-gate.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/src/foundation/native-host-protocol/index.js

@@ -2,4 +2,3 @@ export * from "./codec.js";
 export * from "./evidence.js";
 export * from "./messages.js";
 export * from "./proof-gate.js";
-//# sourceMappingURL=index.js.map

package/dist/src/foundation/native-host-protocol/messages.d.ts

@@ -1,5 +1,5 @@
 import { type CorrelationId, type NativeHostCommand, type NativeHostEvent, type NativeHostHello, type PaneId, type TerminalSessionLaunch } from "../workspace-contracts/index.js";
-export declare const NATIVE_HOST_PROTOCOL_NAME: "addone-native-host";
+export declare const NATIVE_HOST_PROTOCOL_NAME: string;
 export declare const MAX_NATIVE_HOST_MESSAGE_BYTES: number;
 export type NativeHostProofMessage = {
     readonly type: "hello";
@@ -54,4 +54,3 @@ export declare function nativeHostCommandResult(correlationId: CorrelationId, re
 export declare function nativeHostFailure(code: string, message: string, retryable?: boolean): NativeHostFailure;
 export declare function nativeHostTimedOut(deadlineAt: number, now: number): boolean;
 export declare function assertNativeHostProofMessage(message: NativeHostProofMessage): void;
-//# sourceMappingURL=messages.d.ts.map

package/dist/src/foundation/native-host-protocol/messages.js

@@ -1,5 +1,6 @@
 import { NATIVE_HOST_PROTOCOL_VERSION, assertNativeHostCommand, assertTerminalSessionLaunch, } from "../workspace-contracts/index.js";
-export const NATIVE_HOST_PROTOCOL_NAME = "addone-native-host";
+import { PRODUCT_IDENTITY } from "../../product-identity.js";
+export const NATIVE_HOST_PROTOCOL_NAME = PRODUCT_IDENTITY.protocol.nativeHostSchema;
 export const MAX_NATIVE_HOST_MESSAGE_BYTES = 1024 * 1024;
 export function negotiateNativeHostHello(value) {
     if (value.protocolVersion !== NATIVE_HOST_PROTOCOL_VERSION) {
@@ -146,4 +147,3 @@ function negotiation(accepted, negotiatedCapabilities, diagnostic) {
 function isText(value, maximum) {
     return typeof value === "string" && value.length > 0 && value.length <= maximum && !value.includes("\0");
 }
-//# sourceMappingURL=messages.js.map

package/dist/src/foundation/native-host-protocol/proof-gate.d.ts

@@ -11,4 +11,3 @@ export interface NativeSpikeGateDecision {
     readonly reasons: readonly string[];
 }
 export declare function evaluateNativeSpikeGate(evidence: NativeSpikeEvidence): NativeSpikeGateDecision;
-//# sourceMappingURL=proof-gate.d.ts.map

package/dist/src/foundation/native-host-protocol/proof-gate.js

@@ -31,4 +31,3 @@ export function evaluateNativeSpikeGate(evidence) {
     }
     return Object.freeze({ decision: "go", integrationAllowed: true, reasons: Object.freeze(["technical and physical proof accepted"]) });
 }
-//# sourceMappingURL=proof-gate.js.map

package/dist/src/foundation/owned-ui-contracts/extension-ui.d.ts

@@ -300,4 +300,3 @@ export interface OwnedUiExtensionRendererPort {
     }, theme: OwnedUiExtensionThemePort, context: OwnedUiExtensionToolRenderContext): OwnedUiExtensionComponent;
 }
 export declare function assertOwnedUiExtensionUiPort(value: unknown): asserts value is OwnedUiExtensionUiPort;
-//# sourceMappingURL=extension-ui.d.ts.map