@timurproko/a1 0.2.7-dev.1249 → 0.2.7-dev.1252

package/dist/foundation/lifecycle/paths.js

@@ -1,27 +1,6 @@
-import { createHash } from "node:crypto";
 import { homedir, platform } from "node:os";
 import { posix, win32 } from "node:path";
 import { PRODUCT_IDENTITY } from "../../product-identity.js";
-/**
- * Endpoint identity for one release cohort. Two cohorts can be live at once — an update
- * leaves a working session on the release it started on — so the name a supervisor listens
- * on has to name the release as well as the runtime directory, or the two contend for one
- * endpoint and replacing one means ending the other.
- *
- * An explicit endpoint override keeps its single endpoint: it is how an isolated run pins
- * the address it is going to talk to.
- */
-export function resolveCohortEndpoint(paths, releaseId, environment = process.env, hostPlatform = platform()) {
-    if (environment[PRODUCT_IDENTITY.environment.endpoint]) {
-        return { endpoint: paths.endpoint, endpointMetadataPath: paths.endpointMetadataPath };
-    }
-    const path = hostPlatform === "win32" ? win32 : posix;
-    const token = createHash("sha256").update(releaseId).digest("hex").slice(0, 16);
-    const endpoint = hostPlatform === "win32"
-        ? `${paths.endpoint}-${token}`
-        : path.join(paths.endpointDirectory ?? paths.runtimeDir, `${token}-${PRODUCT_IDENTITY.endpoint.unixSocketFilename}`);
-    return { endpoint, endpointMetadataPath: path.join(paths.endpointsDir, `${token}.json`) };
-}
 export function resolveProductPaths(environment = process.env, hostPlatform = platform(), fallbackHome = homedir()) {
     const windows = hostPlatform === "win32";
     const path = windows ? win32 : posix;
@@ -29,8 +8,6 @@ export function resolveProductPaths(environment = process.env, hostPlatform = pl
     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)
@@ -45,26 +22,9 @@ export function resolveProductPaths(environment = process.env, hostPlatform = pl
             : 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);
-    // Platform: Darwin limits Unix-domain socket paths to roughly 104 bytes. Runtime roots
-    // under /var/folders can exceed that before the cohort suffix is added, so only socket
-    // files use a short owned namespace while metadata remains under the selected runtime.
-    const endpointDirectory = !endpointOverride && hostPlatform === "darwin"
-        ? posix.join("/tmp", `${PRODUCT_IDENTITY.state.unixControlDirectory}-${namespace}`)
-        : null;
-    const endpoint = endpointOverride
-        ?? (windows
-            ? `\\\\.\\pipe\\${PRODUCT_IDENTITY.endpoint.windowsPipeStem}-${namespace}`
-            : path.join(endpointDirectory ?? runtimeDir, PRODUCT_IDENTITY.endpoint.unixSocketFilename));
     return {
         configDir,
         dataDir,
         runtimeDir,
-        databasePath: path.resolve(databaseOverride ?? path.join(dataDir, PRODUCT_IDENTITY.endpoint.databaseFilename)),
-        endpoint,
-        endpointMetadataPath: path.join(runtimeDir, PRODUCT_IDENTITY.endpoint.metadataFilename),
-        endpointsDir: path.join(runtimeDir, "endpoints"),
-        endpointDirectory,
-        supervisorLogPath: path.join(runtimeDir, PRODUCT_IDENTITY.endpoint.supervisorLogFilename),
     };
 }

package/dist/foundation/lifecycle/process-liveness.d.ts

@@ -0,0 +1,8 @@
+import type { ProcessIdentity } from "./model.js";
+/**
+ * The identity every record written by this build carries. Liveness is a pid probe, so the
+ * identity only distinguishes records this build wrote from records an older build left.
+ */
+export declare const PID_LIVENESS_IDENTITY = "pid-liveness";
+/** Observe whether a process is running; a permission refusal still proves the pid exists. */
+export declare function inspectLiveProcess(pid: number): Promise<ProcessIdentity | null>;

package/dist/foundation/lifecycle/process-liveness.js

@@ -0,0 +1,18 @@
+/**
+ * The identity every record written by this build carries. Liveness is a pid probe, so the
+ * identity only distinguishes records this build wrote from records an older build left.
+ */
+export const PID_LIVENESS_IDENTITY = "pid-liveness";
+/** Observe whether a process is running; a permission refusal still proves the pid exists. */
+export async function inspectLiveProcess(pid) {
+    if (!Number.isSafeInteger(pid) || pid <= 0)
+        return null;
+    try {
+        process.kill(pid, 0);
+    }
+    catch (error) {
+        if (!(error instanceof Error && "code" in error && error.code === "EPERM"))
+            return null;
+    }
+    return { pid, startIdentity: PID_LIVENESS_IDENTITY };
+}

package/dist/foundation/lifecycle/session-claim-lock.d.ts

@@ -5,7 +5,7 @@ interface ClaimLockOptions {
 /** Inventory is advisory and read-only, including when abandoned metadata needs recovery. */
 export declare function claimMutationPending(directory: string): Promise<boolean>;
 /**
- * The persistent directory excludes legacy wx-file writers. Only native descriptor authority
+ * The persistent directory excludes legacy wx-file writers. Only the gate beside the authority file
  * permits upgraded mutations; owner.json is disposable evidence, never a liveness oracle.
  * Never remove the barrier or authority file: doing so would create a second lock universe.
  */

package/dist/foundation/lifecycle/session-claim-lock.js

@@ -2,7 +2,7 @@ import { randomUUID } from "node:crypto";
 import { lstat, mkdir, open, readdir, realpath, rename, rm } from "node:fs/promises";
 import { join } from "node:path";
 import { setTimeout as delay } from "node:timers/promises";
-import { tryAcquireClaimGate } from "./native-claim-gate.js";
+import { tryAcquireClaimGate } from "./claim-gate.js";
 const FILES = new Set(["owner.json", "owner.next", "recovery.json", "recovery.next"]);
 /** Inventory is advisory and read-only, including when abandoned metadata needs recovery. */
 export async function claimMutationPending(directory) {
@@ -19,7 +19,7 @@ export async function claimMutationPending(directory) {
     }
 }
 /**
- * The persistent directory excludes legacy wx-file writers. Only native descriptor authority
+ * The persistent directory excludes legacy wx-file writers. Only the gate beside the authority file
  * permits upgraded mutations; owner.json is disposable evidence, never a liveness oracle.
  * Never remove the barrier or authority file: doing so would create a second lock universe.
  */

package/dist/foundation/lifecycle/session-repository-context.d.ts

@@ -1,4 +1,4 @@
-import type { NativeProcessIdentity } from "./model.js";
+import type { ProcessIdentity } from "./model.js";
 /** Records without an agent id were written by a single-agent release and belong to its one agent. */
 export declare const PRIMARY_SESSION_AGENT_ID = "primary";
 export interface SessionRepositoryIdentity {
@@ -21,16 +21,16 @@ export interface SessionRepositoryContextOptions {
     readonly runtimeId?: string;
     /** Agent within the runtime that owns the claim; defaults to the primary agent. */
     readonly agentId?: string;
-    readonly runtimeIdentity?: NativeProcessIdentity;
-    readonly inspectProcess?: (pid: number) => Promise<NativeProcessIdentity | null>;
+    readonly runtimeIdentity?: ProcessIdentity;
+    readonly inspectProcess?: (pid: number) => Promise<ProcessIdentity | null>;
     readonly lockTimeoutMs?: number;
 }
 /** Publish the exact live runtime that may acquire a delivery worktree. */
-export declare function registerSessionRepositoryRuntime(identity: SessionRepositoryIdentity, runtimeId: string, runtimeIdentity: NativeProcessIdentity, options?: SessionRepositoryContextOptions): Promise<void>;
+export declare function registerSessionRepositoryRuntime(identity: SessionRepositoryIdentity, runtimeId: string, runtimeIdentity: ProcessIdentity, options?: SessionRepositoryContextOptions): Promise<void>;
 /** Revalidate a durable association and acquire its live claim for this runtime's agent; sibling agents' claims stay. */
-export declare function activateSessionRepositoryContext(identity: SessionRepositoryIdentity, runtimeId: string, runtimeIdentity: NativeProcessIdentity, options?: SessionRepositoryContextOptions): Promise<SessionRepositoryContext | null>;
+export declare function activateSessionRepositoryContext(identity: SessionRepositoryIdentity, runtimeId: string, runtimeIdentity: ProcessIdentity, options?: SessionRepositoryContextOptions): Promise<SessionRepositoryContext | null>;
 /** Release every agent's cooperative editing claims held by this exact runtime generation. */
-export declare function releaseSessionRepositoryRuntime(runtimeId: string, runtimeIdentity: NativeProcessIdentity, options?: SessionRepositoryContextOptions): Promise<void>;
+export declare function releaseSessionRepositoryRuntime(runtimeId: string, runtimeIdentity: ProcessIdentity, options?: SessionRepositoryContextOptions): Promise<void>;
 /** Persist one explicit same-repository worktree association after atomically claiming it. */
 export declare function setSessionRepositoryContext(identity: SessionRepositoryIdentity, worktreePath: string, options?: SessionRepositoryContextOptions): Promise<SessionRepositoryContext>;
 /** Remove only the association and live claim belonging to the supplied stable session/runtime. */

package/dist/foundation/lifecycle/session-repository-context.js

@@ -3,6 +3,7 @@ import { open, lstat, mkdir, readFile, readdir, realpath, rename, rm, writeFile
 import { dirname, isAbsolute, join, resolve } from "node:path";
 import { promisify } from "node:util";
 import { PRODUCT_IDENTITY } from "../../product-identity.js";
+import { inspectLiveProcess } from "./process-liveness.js";
 import { resolveProductPaths } from "./paths.js";
 import { claimMutationPending, withSessionClaimLock } from "./session-claim-lock.js";
 const CONTEXT_SCHEMA = "a1-session-repository-context-v1";
@@ -512,9 +513,7 @@ function ownedBy(record, owner) {
     return record.runtimeId === owner.runtimeId && record.agentId === owner.agentId;
 }
 function requireInspector(options) {
-    if (options.inspectProcess === undefined)
-        throw contextError("native process identity inspection is unavailable", "process-inspection-unavailable");
-    return options.inspectProcess;
+    return options.inspectProcess ?? inspectLiveProcess;
 }
 function processIdentityOf(record) {
     return { pid: record.pid, startIdentity: record.startIdentity };

package/dist/foundation/release/automatic-update.d.ts

@@ -1,13 +1,12 @@
 import { type AvailableRelease, type ReleaseChannel } from "./latest-release.js";
 export declare const AUTOMATIC_UPDATE_STATE_SCHEMA = 1;
 export declare const AUTOMATIC_UPDATE_RETRY_MS: number;
-export declare const AUTOMATIC_UPDATE_ACTIVATION_RETRY_MS = 15000;
 export declare const ACTIVE_RELEASE_FALLBACK_MS = 5000;
 export interface AutomaticUpdateState {
     readonly schema: typeof AUTOMATIC_UPDATE_STATE_SCHEMA;
     readonly channel: ReleaseChannel;
     readonly targetVersion: string;
-    readonly status: "running" | "blocked" | "installed" | "failed";
+    readonly status: "running" | "installed" | "failed";
     readonly attemptedAt: number;
     readonly updatedAt: number;
     readonly installedVersion: string | null;
@@ -44,7 +43,6 @@ export interface AutomaticUpdateRequestOptions {
         readonly packageRoot: string;
     };
     readonly activeVersion?: () => Promise<string | null>;
-    readonly onActivationBlocked?: (version: string | null) => void;
 }
 /** Start or observe one silent update and resolve with the active newer version once restart is useful. */
 export declare function requestAutomaticUpdate(options: AutomaticUpdateRequestOptions): Promise<string | null>;

package/dist/foundation/release/automatic-update.js

@@ -7,15 +7,14 @@ import { valid as validSemver } from "semver";
 import { readLaunchContext } from "../launch-context/index.js";
 import { resolveProductPaths } from "../lifecycle/index.js";
 import { CohortStateStore } from "./cohort-state.js";
-import { processIsAlive } from "./process-cleanup.js";
+import { processIsAlive } from "./process-liveness.js";
 import { isNewerRelease, releaseChannelOf } from "./latest-release.js";
 import { readCertifiedReleaseManifest, resolveReleaseEntryPoint } from "./release-store.js";
 import { acquireUpdateExecutionLease, readUpdateExecutionOwner } from "./update-execution-lease.js";
 import { UpdateTransactionStore } from "./update-transaction.js";
-import { runSelfUpdate, UPDATE_ACTIVATION_BLOCKED_EXIT_CODE, UPDATE_ALREADY_RUNNING_EXIT_CODE } from "./update.js";
+import { runSelfUpdate, UPDATE_ALREADY_RUNNING_EXIT_CODE } from "./update.js";
 export const AUTOMATIC_UPDATE_STATE_SCHEMA = 1;
 export const AUTOMATIC_UPDATE_RETRY_MS = 24 * 60 * 60_000;
-export const AUTOMATIC_UPDATE_ACTIVATION_RETRY_MS = 15_000;
 const AUTOMATIC_UPDATE_STATE_FILENAME = "automatic-update.json";
 const MAX_STATE_BYTES = 16_384;
 const OBSERVER_POLL_MS = 250;
@@ -37,6 +36,10 @@ export class AutomaticUpdateStateStore {
         if (Buffer.byteLength(source, "utf8") > MAX_STATE_BYTES)
             throw new Error("automatic update state is oversized");
         const value = JSON.parse(source);
+        // Compatibility: a record left by an activation that waited on resident tabs says nothing
+        // about the next attempt, so it is read as no record at all.
+        if (value?.status === "blocked")
+            return null;
         validateState(value);
         return value;
     }
@@ -183,14 +186,6 @@ export async function requestAutomaticUpdate(options) {
             await store.write(existing).catch(() => undefined);
         }
     }
-    const blockedUpdatedAt = existing?.status === "blocked" && existing.channel === options.release.channel
-        && existing.targetVersion === options.release.version ? existing.updatedAt : null;
-    const observedBlocked = blockedUpdatedAt !== null;
-    if (observedBlocked) {
-        options.onActivationBlocked?.(options.release.version);
-        if (now() - blockedUpdatedAt >= 0 && now() - blockedUpdatedAt < AUTOMATIC_UPDATE_ACTIVATION_RETRY_MS)
-            return null;
-    }
     if (existing?.status === "failed" && existing.channel === options.release.channel && now() - existing.attemptedAt >= 0
         && now() - existing.attemptedAt < AUTOMATIC_UPDATE_RETRY_MS
         && !isNewerRelease(options.release.version, existing.targetVersion))
@@ -223,8 +218,6 @@ export async function requestAutomaticUpdate(options) {
             // Invariant: no worker began this attempt. Do not invent a successful install or an owner.
             await store.write(state({ packageRoot: worker.packageRoot, channel: options.release.channel,
                 targetVersion: options.release.version, dataDir: paths.dataDir }, "failed", now(), null, "worker-start-failed")).catch(() => undefined);
-            if (observedBlocked)
-                options.onActivationBlocked?.(null);
             return null;
         }
     }
@@ -238,15 +231,8 @@ export async function requestAutomaticUpdate(options) {
         if (installed !== null)
             return installed;
         const state = await store.read().catch(() => null);
-        if (state?.targetVersion === options.release.version && state.status === "blocked") {
-            options.onActivationBlocked?.(state.targetVersion);
-            return null;
-        }
-        if (state?.targetVersion === options.release.version && state.status === "failed" && state.attemptedAt >= startedAt) {
-            if (observedBlocked)
-                options.onActivationBlocked?.(null);
+        if (state?.targetVersion === options.release.version && state.status === "failed" && state.attemptedAt >= startedAt)
             return null;
-        }
         const owner = await readUpdateExecutionOwner(paths.dataDir).catch(() => null);
         if ((owner === null || !processIsAlive(owner.pid)) && now() - startedAt >= WORKER_START_GRACE_MS)
             return null;
@@ -296,12 +282,6 @@ export async function runAutomaticUpdateWorker(argv, environment = process.env)
         });
         if (code === UPDATE_ALREADY_RUNNING_EXIT_CODE)
             return 0;
-        if (code === UPDATE_ACTIVATION_BLOCKED_EXIT_CODE) {
-            await runningWrite;
-            if (acquired)
-                await store.write(state(parsed, "blocked", attemptedAt, null, "resident-continuity-blocked"));
-            return code;
-        }
         if (code !== 0) {
             await runningWrite;
             if (acquired)
@@ -419,11 +399,10 @@ function parseWorkerArguments(argv) {
 }
 function validateState(value) {
     if (value.schema !== AUTOMATIC_UPDATE_STATE_SCHEMA || (value.channel !== "stable" && value.channel !== "development")
-        || validSemver(value.targetVersion) === null || !["running", "blocked", "installed", "failed"].includes(value.status)
+        || validSemver(value.targetVersion) === null || !["running", "installed", "failed"].includes(value.status)
         || !Number.isFinite(value.attemptedAt) || !Number.isFinite(value.updatedAt)
         || (value.installedVersion !== null && validSemver(value.installedVersion) === null)
-        || (value.failure !== null && (typeof value.failure !== "string" || value.failure.length > 512))
-        || value.status === "blocked" && (value.installedVersion !== null || value.failure !== "resident-continuity-blocked")) {
+        || (value.failure !== null && (typeof value.failure !== "string" || value.failure.length > 512))) {
         throw new Error("invalid automatic update state");
     }
 }

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

@@ -1,49 +1,26 @@
-import { type SupervisorEndpointMetadata } from "./cohort-state.js";
-import { resolveProductPaths, type SessionSelection, type LaunchProfileId, type SupervisorStartupAttemptIdentity } from "../lifecycle/index.js";
-import { cleanupProvenIdleOwner } from "./process-cleanup.js";
+import { resolveProductPaths, type SessionSelection, type LaunchProfileId } from "../lifecycle/index.js";
 import { type MaterializedRelease, type VerifyMaterializedReleaseOptions } from "./release-store.js";
-import { type EnsureTerminalHostOptions, type EnsureTerminalHostResult } from "../resident-tabs/index.js";
 export interface BootstrapOptions {
     readonly packageRoot: string;
     readonly launchIntent?: {
         readonly kind: "interactive";
         readonly profileId: LaunchProfileId;
-        readonly launchMode: "tabs" | "solo";
         readonly sessionSelection?: SessionSelection;
     };
     readonly environment?: NodeJS.ProcessEnv;
     readonly output?: Pick<NodeJS.WriteStream, "write">;
     /** Optional package-resolution probe that excludes a damaged retained release. */
     readonly releaseIsLaunchable?: (releaseRoot: string) => boolean;
-    /** Test seam for bounded maintenance scheduled after stale endpoint sweeping. */
+    /** Test seam for bounded maintenance scheduled before the UI starts. */
     readonly scheduleMaintenance?: (dataDir: string, paths: ReturnType<typeof resolveProductPaths>) => Promise<void>;
-    /** Test seam for resident launch routing before the guardian starts. */
-    readonly ensureTerminalHost?: (options: EnsureTerminalHostOptions) => Promise<EnsureTerminalHostResult>;
-    /** Test seam for whether this process's standard input and output are terminals; absent reads them. */
-    readonly interactiveTerminal?: boolean;
 }
 export declare function runBootstrap(options: BootstrapOptions): Promise<number>;
 export declare function certifyMaterializedRelease(release: MaterializedRelease, dataDir: string, verification?: VerifyMaterializedReleaseOptions): Promise<string>;
 /** Persist current-format evidence after an authenticated parent has certified the exact release. */
 export declare function recordParentCertifiedRelease(release: MaterializedRelease, dataDir: string): Promise<string>;
-export interface SupervisorStartupAttempt extends SupervisorStartupAttemptIdentity {
-    readonly childOutcome: Promise<{
-        readonly exitCode: number | null;
-        readonly signal: NodeJS.Signals | null;
-    }>;
-}
-/** Reuse a verified owner, or join the winner if another launch starts the same cohort first. */
-export declare function ensureSupervisor(release: MaterializedRelease, environment: NodeJS.ProcessEnv): Promise<void>;
-export declare function startSupervisor(release: MaterializedRelease, environment: NodeJS.ProcessEnv): Promise<SupervisorStartupAttempt>;
 /**
  * Hand a release the key set its own build reads. A retained pre-cutover release is
  * still startable this way, which is what lets a launch fall back to the previous
  * version instead of failing while an installation is being replaced.
  */
 export declare function releaseEnvironment(environment: NodeJS.ProcessEnv, release: MaterializedRelease, profile?: LaunchProfileId): NodeJS.ProcessEnv;
-export declare function waitForVerifiedEndpoint(path: string, release: MaterializedRelease, timeoutMs: number, startup?: SupervisorStartupAttempt): Promise<void>;
-export declare function releaseVerifiedIdleOwner(metadata: SupervisorEndpointMetadata, dataDir: string, operations?: {
-    readonly waitForExit?: typeof waitForProcessExit;
-    readonly cleanup?: typeof cleanupProvenIdleOwner;
-}): Promise<boolean>;
-export declare function waitForProcessExit(pid: number, timeoutMs: number): Promise<void>;