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

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,36 +1,25 @@
 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;
+declare const AUTOMATIC_UPDATE_STATE_SCHEMA = 1;
 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;
     readonly failure: string | null;
 }
-export declare class AutomaticUpdateStateStore {
-    readonly path: string;
-    constructor(dataDir: string);
-    read(): Promise<AutomaticUpdateState | null>;
-    write(value: AutomaticUpdateState): Promise<void>;
-}
-export interface ActiveReleaseObservationOptions {
+interface ActiveReleaseObservationOptions {
     readonly runningVersion: string;
     readonly environment?: NodeJS.ProcessEnv;
     readonly signal?: AbortSignal;
     readonly onNewer: (version: string) => void;
     readonly fallbackMs?: number;
 }
-/** Read the approved active release only when this process executes an older release on that channel. */
-export declare function readNewerActiveRelease(runningVersion: string, environment?: NodeJS.ProcessEnv): Promise<string | null>;
 /** Observe local release activation promptly, with a bounded fallback for missed filesystem events. */
 export declare function observeNewerActiveRelease(options: ActiveReleaseObservationOptions): () => void;
-export interface AutomaticUpdateRequestOptions {
+interface AutomaticUpdateRequestOptions {
     readonly release: AvailableRelease;
     readonly runningVersion: string;
     readonly environment?: NodeJS.ProcessEnv;
@@ -38,14 +27,14 @@ export interface AutomaticUpdateRequestOptions {
     readonly now?: () => number;
     readonly spawnWorker?: (entry: string, arguments_: readonly string[], environment: NodeJS.ProcessEnv) => Promise<void>;
     readonly sleep?: (durationMs: number) => Promise<void>;
-    /** Focused-test seams; production resolves both from the certified launch cohort. */
+    /** Focused-test seams; production resolves both from the certified launch release. */
     readonly worker?: {
         readonly entry: string;
         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>;
 export declare function runAutomaticUpdateWorker(argv: readonly string[], environment?: NodeJS.ProcessEnv): Promise<number>;
+export {};

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

@@ -6,22 +6,21 @@ import { basename, dirname, resolve } from "node:path";
 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 { ReleaseStateStore } from "./release-state.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";
-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;
+import { runSelfUpdate, UPDATE_ALREADY_RUNNING_EXIT_CODE } from "./update.js";
+const AUTOMATIC_UPDATE_STATE_SCHEMA = 1;
+const AUTOMATIC_UPDATE_RETRY_MS = 24 * 60 * 60_000;
 const AUTOMATIC_UPDATE_STATE_FILENAME = "automatic-update.json";
 const MAX_STATE_BYTES = 16_384;
 const OBSERVER_POLL_MS = 250;
 const WORKER_START_GRACE_MS = 5_000;
-export const ACTIVE_RELEASE_FALLBACK_MS = 5_000;
-export class AutomaticUpdateStateStore {
+const ACTIVE_RELEASE_FALLBACK_MS = 5_000;
+class AutomaticUpdateStateStore {
     path;
     constructor(dataDir) { this.path = resolve(dataDir, AUTOMATIC_UPDATE_STATE_FILENAME); }
     async read() {
@@ -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;
     }
@@ -62,7 +65,7 @@ export class AutomaticUpdateStateStore {
     }
 }
 /** Read the approved active release only when this process executes an older release on that channel. */
-export async function readNewerActiveRelease(runningVersion, environment = process.env) {
+async function readNewerActiveRelease(runningVersion, environment = process.env) {
     const channel = releaseChannelOf(runningVersion);
     if (channel === null)
         return null;
@@ -80,7 +83,7 @@ export function observeNewerActiveRelease(options) {
     if (releaseChannelOf(options.runningVersion) === null || options.signal?.aborted)
         return () => { };
     const paths = resolveProductPaths(options.environment ?? process.env);
-    const store = new CohortStateStore(paths.dataDir);
+    const store = new ReleaseStateStore(paths.dataDir);
     let closed = false;
     let checking = false;
     let requested = false;
@@ -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))
@@ -198,8 +193,8 @@ export async function requestAutomaticUpdate(options) {
     let worker = options.worker;
     if (worker === undefined) {
         const launch = readLaunchContext(environment, "release");
-        const cohort = await new CohortStateStore(paths.dataDir).read();
-        const record = launch.releaseId === undefined ? undefined : cohort.releases[launch.releaseId];
+        const releaseState = await new ReleaseStateStore(paths.dataDir).read();
+        const record = launch.releaseId === undefined ? undefined : releaseState.releases[launch.releaseId];
         if (!record || record.approval !== "approved" || record.releaseRoot !== launch.releaseRoot
             || record.contentDigest !== launch.releaseDigest)
             return null;
@@ -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;
@@ -262,8 +248,8 @@ export async function runAutomaticUpdateWorker(argv, environment = process.env)
     let verified = false;
     try {
         const launch = readLaunchContext(environment, "release");
-        const cohort = await new CohortStateStore(paths.dataDir).read();
-        const record = launch.releaseId === undefined ? undefined : cohort.releases[launch.releaseId];
+        const releaseState = await new ReleaseStateStore(paths.dataDir).read();
+        const record = launch.releaseId === undefined ? undefined : releaseState.releases[launch.releaseId];
         if (record?.approval === "approved" && samePath(record.releaseRoot, launch.releaseRoot ?? "")
             && record.contentDigest === launch.releaseDigest) {
             const selected = await readCertifiedReleaseManifest(record, resolve(paths.dataDir, "releases"));
@@ -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)
@@ -380,11 +360,11 @@ function activeNewerPackageVersion(active, runningVersion, channel, minimum) {
         ? active.packageVersion : null;
 }
 async function activeRelease(dataDir) {
-    const cohort = await new CohortStateStore(dataDir).read();
-    const activeId = cohort.references.active;
+    const releaseState = await new ReleaseStateStore(dataDir).read();
+    const activeId = releaseState.references.active;
     if (activeId === null)
         return null;
-    const active = cohort.releases[activeId];
+    const active = releaseState.releases[activeId];
     return active?.approval === "approved" ? active : null;
 }
 function state(parsed, status, attemptedAt, installedVersion, failure) {
@@ -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>;