@astrosheep/keiyaku 1.0.0 → 1.0.2

package/build/core/projection-wake.js

@@ -1,252 +1,130 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { spawn } from "node:child_process";
-import { fileURLToPath } from "node:url";
-import { ProjectionStateError } from "./atomic-publish.js";
 import { FlowError } from "../flow-error.js";
-import { CODEX_MODEL_REASONING_EFFORT_CONFIG_KEY } from "../keiyaku.js";
-import { acquireResumeLock, createProjectionExecutionId, deriveProjectionPhase, generationLogPath, isProjectionWakeEligible, latestGenerationLaunch, latestGenerationResult, listTellIds, publishGenerationLaunch, publishGenerationResult, readAdmissionLock, readGenerationLaunch, readTellOriginal, readTellSubmitted, readResumeLock, releaseAdmissionLockOwned, releaseResumeLockOwned, } from "./projection-core.js";
-export const WAKE_ADMISSION_TIMEOUT_MS = 4_000;
-export const WAKE_ADMISSION_POLL_MS = 20;
-export const RESUME_LOCK_STALE_MS = 30_000;
-/** Admission liveness permits a heartbeat window longer than status's 15s display threshold. */
-export const ADMISSION_HEARTBEAT_STALE_MS = 30_000;
-// This module lives at src/core or build/core; two parents reach the repository
-// root in either form, so the detached child never depends on ambient cwd.
-const COMPILED_ENTRY = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "build", "index.js");
-function defaultSleep(milliseconds) {
-    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, milliseconds);
-}
-function isResumeLockDeadOrStale(lock, now, probePid) {
-    try {
-        probePid(lock.pid);
-    }
-    catch {
-        return true;
-    }
-    const created = Date.parse(lock.createdAt);
-    return !Number.isFinite(created) || now - created > RESUME_LOCK_STALE_MS;
-}
-function isAdmissionDeadOrHeartbeatStale(projectionDirectory, lock, now, probePid, heartbeatStaleMs) {
-    try {
-        probePid(lock.pid);
-    }
-    catch {
-        return true;
-    }
+import { parseResolvedAkumaLaunchSnapshot } from "../agents/launch-snapshot_v2.js";
+import { ProjectionStateError } from "./atomic-publish.js";
+import { applyContinuationEffort, snapshotPendingTells, } from "./projection-generation-continuation.js";
+import { createProjectionExecutionId } from "./projection-generation-identity.js";
+import { startProjectionGeneration } from "./projection-generation-launcher.js";
+import { openProjectionGenerationStore, openProjectionGenerationStoreReadOnly, } from "./projection-generation-store.js";
+import { PROJECTION_ADOPTION_TIMEOUT_MS } from "./projection-generation-launcher.js";
+import { observeProjectionLife } from "./projection-life-observer.js";
+import { observeProjectionRunnerLock } from "./projection-runner-lock.js";
+function readCurrentGeneration(projectionDirectory) {
+    const store = openProjectionGenerationStoreReadOnly(projectionDirectory);
     try {
-        return now - fs.statSync(path.join(projectionDirectory, "heartbeat")).mtimeMs > heartbeatStaleMs;
+        return store.readCurrentGeneration();
     }
-    catch {
-        return true;
+    finally {
+        store.close();
     }
 }
-function acquireOrRecoverResumeLock(projectionDirectory, childId, deps) {
-    const first = acquireResumeLock(projectionDirectory, childId, process.pid, deps.now());
-    if (first === "published")
-        return "owned";
-    const previous = readResumeLock(projectionDirectory);
-    if (!previous || !isResumeLockDeadOrStale(previous, deps.now(), deps.probePid))
-        return "taken";
-    // The existing record is dead/stale. Re-read immediately before removing it
-    // so a live contender is never released as stale based on an old snapshot.
-    const current = readResumeLock(projectionDirectory);
-    if (!current || current.childId !== previous.childId || !isResumeLockDeadOrStale(current, deps.now(), deps.probePid))
-        return "taken";
-    releaseResumeLockOwned(projectionDirectory, current.childId);
-    return acquireResumeLock(projectionDirectory, childId, process.pid, deps.now()) === "published" ? "owned" : "taken";
-}
-function appendWakeLog(projectionDirectory, executionId, line) {
-    fs.appendFileSync(generationLogPath(projectionDirectory, executionId), `${line}\n`);
-}
-function ownLaunchInputs(projectionDirectory, launch = latestGenerationLaunch(projectionDirectory)) {
-    if (!launch)
-        return {};
-    const parent = latestGenerationResult(projectionDirectory);
+function successorFacts(current, snapshot, nowMs) {
+    const verdictFacts = current.verdict?.facts;
+    const originalInputs = current.launch.facts.inputs;
+    const inputs = originalInputs
+        && typeof originalInputs === "object"
+        && !Array.isArray(originalInputs)
+        ? originalInputs
+        : {};
+    const continuedInputs = {
+        ...inputs,
+        ...(verdictFacts?.session ? { session: verdictFacts.session } : {}),
+        ...(typeof verdictFacts?.responsePath === "string"
+            ? { resumePath: verdictFacts.responsePath }
+            : {}),
+    };
+    const { tellFence: _oldFence, ...inherited } = current.launch.facts;
     return {
-        ...readGenerationLaunch(projectionDirectory, launch.executionId).inputs,
-        ...(parent?.session !== undefined ? { session: parent.session } : {}),
-        ...(parent?.responsePath ? { resumePath: parent.responsePath } : {}),
+        ...inherited,
+        createdAt: new Date(nowMs).toISOString(),
+        launchedBy: "tell-wake",
+        parentExecutionId: current.launch.executionId,
+        tellFence: snapshot.tellIds,
+        inputs: applyContinuationEffort(continuedInputs, snapshot.effort),
     };
 }
-function overlayEffort(inputs, effort) {
-    if (!effort)
-        return inputs;
-    const rawProfile = inputs.profileData;
-    if (!rawProfile || typeof rawProfile !== "object" || Array.isArray(rawProfile))
-        throw new ProjectionStateError("generation launch is missing immutable profileData");
-    const profile = rawProfile;
-    if (profile.provider === "opencode-sdk")
-        throw new FlowError("UNSUPPORTED_EFFORT_OVERRIDE", `Provider 'opencode-sdk' does not support effort override '${effort}'.`);
-    if (profile.provider === "claude-agent-sdk")
-        return { ...inputs, profileData: { ...profile, effort } };
-    if (profile.provider === "pi")
-        return { ...inputs, profileData: { ...profile, thinkingLevel: effort === "max" ? "xhigh" : effort } };
-    if (profile.provider === "codex-sdk") {
-        const { effort: _legacyEffort, ...canonicalProfile } = profile;
-        const priorThreadOptions = profile.threadOptions && typeof profile.threadOptions === "object" && !Array.isArray(profile.threadOptions) ? profile.threadOptions : {};
-        return { ...inputs, profileData: { ...canonicalProfile, threadOptions: { ...priorThreadOptions, modelReasoningEffort: effort === "max" ? "xhigh" : effort } } };
-    }
-    if (profile.provider === "codex-app-server") {
-        const priorInputConfig = inputs.config && typeof inputs.config === "object" && !Array.isArray(inputs.config) ? inputs.config : {};
-        const priorProfileConfig = profile.config && typeof profile.config === "object" && !Array.isArray(profile.config) ? profile.config : {};
-        const inputConfig = { ...priorInputConfig, [CODEX_MODEL_REASONING_EFFORT_CONFIG_KEY]: effort };
-        const profileConfig = { ...priorProfileConfig, [CODEX_MODEL_REASONING_EFFORT_CONFIG_KEY]: effort };
-        return { ...inputs, config: inputConfig, profileData: { ...profile, config: profileConfig } };
-    }
-    throw new ProjectionStateError("generation launch has an unknown provider");
-}
-function pendingReplaySnapshot(projectionDirectory, inputs) {
-    const profile = inputs.profileData;
-    const pending = ["inbox", "inflight", "submitted"]
-        .flatMap((layer) => listTellIds(projectionDirectory, layer).map((tellId) => ({ layer, tellId })))
-        .sort((left, right) => left.tellId.localeCompare(right.tellId));
-    const effort = pending.reduce((value, item) => {
-        const tell = item.layer === "submitted"
-            ? readTellSubmitted(projectionDirectory, item.tellId)
-            : readTellOriginal(projectionDirectory, item.layer, item.tellId);
-        return tell.effort ?? value;
-    }, undefined);
-    return { tellFence: pending.map((item) => item.tellId), ...(effort ? { effort } : {}) };
-}
 export function assertTellEffortSupported(projectionDirectory, effort) {
     if (!effort)
         return;
-    const launch = latestGenerationLaunch(projectionDirectory);
-    if (!launch)
+    const current = readCurrentGeneration(projectionDirectory);
+    if (!current)
         throw new ProjectionStateError("projection has no immutable generation launch");
-    overlayEffort(readGenerationLaunch(projectionDirectory, launch.executionId).inputs, effort);
+    const inputs = current.launch.facts.inputs;
+    if (!inputs || typeof inputs !== "object" || Array.isArray(inputs)) {
+        throw new ProjectionStateError("generation launch inputs are missing");
+    }
+    let launchSnapshot;
+    try {
+        launchSnapshot = parseResolvedAkumaLaunchSnapshot(inputs.launchSnapshot);
+    }
+    catch (error) {
+        throw new ProjectionStateError("generation launch has an invalid immutable launchSnapshot", { cause: error });
+    }
+    const effortOptions = launchSnapshot.akuma.effortOptions;
+    if (effortOptions === undefined)
+        return;
+    if (!effortOptions.includes(effort)) {
+        throw new FlowError("INVALID_EFFORT_OVERRIDE", `Effort '${effort}' is not permitted; legal values: ${effortOptions.join(", ")}.`);
+    }
 }
-function defaultSpawn(argv, logFd) {
-    return spawn(argv[0], [...argv.slice(1)], { detached: true, stdio: ["ignore", logFd, logFd] });
+async function startCommittedSuccessor(projectionDirectory, executionId) {
+    const started = await startProjectionGeneration(projectionDirectory, executionId);
+    return started.status === "adopted" ? "woken" : "pending";
 }
-/** The single tell, sweep, and override launcher. It owns resume through child admission. */
-export function wakeProjection(projectionDirectory, launchedBy, options = {}) {
-    const deps = {
-        now: options.dependencies?.now ?? Date.now,
-        sleep: options.dependencies?.sleep ?? defaultSleep,
-        spawn: options.dependencies?.spawn ?? defaultSpawn,
-        probePid: options.dependencies?.probePid ?? ((pid) => process.kill(pid, 0)),
-        timeoutMs: options.dependencies?.timeoutMs ?? WAKE_ADMISSION_TIMEOUT_MS,
-        pollMs: options.dependencies?.pollMs ?? WAKE_ADMISSION_POLL_MS,
-        admissionHeartbeatStaleMs: options.dependencies?.admissionHeartbeatStaleMs ?? ADMISSION_HEARTBEAT_STALE_MS,
-    };
-    if (!options.force && !options.handoffExecutionId && !isProjectionWakeEligible(projectionDirectory))
-        return "ineligible";
-    const executionId = createProjectionExecutionId();
-    if (acquireOrRecoverResumeLock(projectionDirectory, executionId, deps) !== "owned")
-        return "already-waking";
-    let child;
+export async function tellProjection(projectionDirectory, effort) {
+    const nowMs = Date.now();
+    const life = observeProjectionLife(projectionDirectory, {
+        nowMs,
+        startupTimeoutMs: PROJECTION_ADOPTION_TIMEOUT_MS,
+    });
+    if (life.phase === "active")
+        return "active";
+    if (life.phase === "unknown" || life.phase === "minting" || life.phase === "quiescent") {
+        return "pending";
+    }
+    const current = readCurrentGeneration(projectionDirectory);
+    if (!current)
+        return "pending";
+    const snapshot = snapshotPendingTells(projectionDirectory);
+    const successorExecutionId = createProjectionExecutionId(nowMs);
+    const facts = successorFacts(current, { ...snapshot, ...(effort ? { effort } : {}) }, nowMs);
+    const store = openProjectionGenerationStore(projectionDirectory);
     try {
-        const parent = latestGenerationLaunch(projectionDirectory);
-        const ownInputs = ownLaunchInputs(projectionDirectory, parent);
-        const replaySnapshot = pendingReplaySnapshot(projectionDirectory, ownInputs);
-        const inheritedInputs = {
-            ...overlayEffort(ownInputs, replaySnapshot.effort ?? options.effort),
-            tellFence: replaySnapshot.tellFence,
-        };
-        publishGenerationLaunch(projectionDirectory, {
-            version: 1,
-            executionId,
-            ...(parent ? { parentExecutionId: parent.executionId } : {}),
-            createdAt: new Date(deps.now()).toISOString(),
-            launchedBy,
-            inputs: inheritedInputs,
-        });
-        if (options.clearStaleAdmission) {
-            const staleAdmission = readAdmissionLock(projectionDirectory);
-            if (staleAdmission) {
-                if (!isAdmissionDeadOrHeartbeatStale(projectionDirectory, staleAdmission, deps.now(), deps.probePid, deps.admissionHeartbeatStaleMs)) {
-                    throw new ProjectionStateError("refusing to clear a live admission while resuming projection");
-                }
-                const currentAdmission = readAdmissionLock(projectionDirectory);
-                if (!currentAdmission ||
-                    !staleAdmission.executionId ||
-                    currentAdmission.executionId !== staleAdmission.executionId ||
-                    !isAdmissionDeadOrHeartbeatStale(projectionDirectory, currentAdmission, deps.now(), deps.probePid, deps.admissionHeartbeatStaleMs)) {
-                    throw new ProjectionStateError("refusing to clear a changed or live admission while resuming projection");
-                }
-                releaseAdmissionLockOwned(projectionDirectory, staleAdmission.executionId);
-            }
-        }
-        if (options.handoffExecutionId)
-            releaseAdmissionLockOwned(projectionDirectory, options.handoffExecutionId);
-        const absoluteProjectionDirectory = path.resolve(projectionDirectory);
-        const logFd = fs.openSync(generationLogPath(absoluteProjectionDirectory, executionId), "a");
-        try {
-            child = deps.spawn([process.execPath, COMPILED_ENTRY, "__keiyaku-wake", absoluteProjectionDirectory], logFd);
-            child.unref();
+        if (life.phase === "startup-timeout") {
+            const transition = store.supersedeStartupTimeout({
+                executionId: current.launch.executionId,
+                observedAtMs: nowMs,
+                startupTimeoutMs: PROJECTION_ADOPTION_TIMEOUT_MS,
+                diagnostic: { detail: "runner did not adopt before startup timeout" },
+                successorExecutionId,
+                successorFacts: facts,
+            });
+            return transition.status === "committed"
+                ? await startCommittedSuccessor(projectionDirectory, successorExecutionId)
+                : "pending";
         }
-        finally {
-            fs.closeSync(logFd);
+        if (life.phase === "lost") {
+            const lock = observeProjectionRunnerLock(projectionDirectory);
+            if (lock.state !== "released")
+                return lock.state === "held" ? "active" : "pending";
+            const transition = store.replaceDeadRunner({
+                executionId: current.launch.executionId,
+                releasedLockEvidence: { observedAt: new Date(nowMs).toISOString() },
+                successorExecutionId,
+                successorFacts: facts,
+            });
+            return transition.status === "committed"
+                ? await startCommittedSuccessor(projectionDirectory, successorExecutionId)
+                : "pending";
         }
-        const deadline = deps.now() + deps.timeoutMs;
-        while (deps.now() <= deadline) {
-            const admission = readAdmissionLock(projectionDirectory);
-            if (admission?.executionId === executionId) {
-                releaseResumeLockOwned(projectionDirectory, executionId);
-                return "started";
-            }
-            if (admission?.executionId && admission.executionId !== executionId) {
-                throw new ProjectionStateError(`admission ownership mismatch: expected ${executionId}, found ${admission.executionId}`);
-            }
-            deps.sleep(deps.pollMs);
-        }
-        // A child can acquire between the last poll and failure handling.
-        const finalAdmission = readAdmissionLock(projectionDirectory);
-        if (finalAdmission?.executionId === executionId) {
-            releaseResumeLockOwned(projectionDirectory, executionId);
-            return "started";
-        }
-        if (finalAdmission?.executionId && finalAdmission.executionId !== executionId) {
-            throw new ProjectionStateError(`admission ownership mismatch: expected ${executionId}, found ${finalAdmission.executionId}`);
-        }
-        child?.kill("SIGTERM");
-        const parentResult = latestGenerationResult(projectionDirectory);
-        publishGenerationResult(projectionDirectory, {
-            version: 1, executionId, status: "failed", createdAt: new Date(deps.now()).toISOString(),
-            session: parentResult?.session, detail: "wake child did not acquire admission before timeout",
+        const transition = store.launchIfSettled({
+            executionId: successorExecutionId,
+            facts,
         });
-        appendWakeLog(projectionDirectory, executionId, "wake admission timeout");
-        releaseResumeLockOwned(projectionDirectory, executionId);
-        return "failed";
+        if (transition.status !== "committed")
+            return "pending";
+        return await startCommittedSuccessor(projectionDirectory, successorExecutionId);
     }
-    catch (error) {
-        const admission = readAdmissionLock(projectionDirectory);
-        if (admission?.executionId === executionId) {
-            releaseResumeLockOwned(projectionDirectory, executionId);
-            return "started";
-        }
-        // Never alter a competing admission. This launch has not become a generation.
-        child?.kill("SIGTERM");
-        if (!admission || admission.executionId === undefined) {
-            const detail = error instanceof Error ? error.message : String(error);
-            publishGenerationResult(projectionDirectory, { version: 1, executionId, status: "failed", createdAt: new Date(deps.now()).toISOString(), detail });
-            appendWakeLog(projectionDirectory, executionId, `wake spawn failure: ${detail}`);
-        }
-        releaseResumeLockOwned(projectionDirectory, executionId);
-        if (error instanceof ProjectionStateError)
-            throw error;
-        return "failed";
+    finally {
+        store.close();
     }
 }
-export function resumeProjectionOverride(projectionDirectory, dependencies, effort) {
-    const phase = deriveProjectionPhase(projectionDirectory, (dependencies?.now ?? Date.now)());
-    if (phase === "active")
-        return "active";
-    if (phase === "done")
-        return "done";
-    // force allows recovery only after this function has observed a non-active,
-    // non-done phase. The orchestrator owns resume before it clears stale admission.
-    return wakeProjection(projectionDirectory, "resume-override", { force: true, clearStaleAdmission: true, effort, dependencies });
-}
-export function tellProjection(projectionDirectory, effort) {
-    const phase = deriveProjectionPhase(projectionDirectory, Date.now());
-    if (phase === "active")
-        return "active";
-    if (phase === "failed" || phase === "dismissed")
-        return "terminal";
-    if (phase === "lost")
-        return "lost";
-    return wakeProjection(projectionDirectory, "tell-wake", { effort }) === "started" ? "woken" : "pending";
-}