@astrosheep/keiyaku 2.9.12 → 4.0.0

package/build/core/projection/projection-terminal-failure.js

@@ -1,111 +0,0 @@
-import { constants as osConstants } from "node:os";
-import { RESPONSE_ARTIFACT_ID_RE } from "../response-artifact-id.js";
-import { OUTCOME_ERROR_VERSION } from "../../agents/types.js";
-const HARNESS_FAILURE_CODES = new Set([
-    "SUBAGENT_TIMEOUT",
-    "SUBAGENT_TRANSPORT_ERROR",
-    "SUBAGENT_POLICY_BUDGET",
-    "SUBAGENT_NON_ZERO_EXIT",
-    "SUBAGENT_SPAWN_ERROR",
-    "SUBAGENT_EXEC_ERROR",
-    "SUBAGENT_PROVIDER_UNAVAILABLE",
-]);
-const SYSTEM_SIGNALS = new Set(Object.keys(osConstants.signals));
-function objectValue(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value)
-        ? value
-        : undefined;
-}
-function failureCode(value) {
-    return typeof value === "string" && HARNESS_FAILURE_CODES.has(value)
-        ? value
-        : undefined;
-}
-function nonNegativeNumber(value) {
-    return typeof value === "number" && Number.isSafeInteger(value) && value >= 0
-        ? value
-        : undefined;
-}
-function exitCode(value) {
-    return typeof value === "number" && Number.isSafeInteger(value) ? value : undefined;
-}
-function signal(value) {
-    return typeof value === "string" && SYSTEM_SIGNALS.has(value)
-        ? value
-        : undefined;
-}
-function artifactId(source) {
-    for (const value of [source.artifactId, source.sourceArtifactId]) {
-        if (typeof value === "string" && RESPONSE_ARTIFACT_ID_RE.test(value))
-            return value;
-    }
-    return undefined;
-}
-function providerFailureCause(value) {
-    const source = objectValue(value);
-    return source && isHarnessFailureValue(source) ? source : undefined;
-}
-function isHarnessFailureValue(value) {
-    if (value === null || typeof value === "boolean" || typeof value === "string")
-        return true;
-    if (typeof value === "number")
-        return Number.isFinite(value);
-    if (Array.isArray(value))
-        return value.every(isHarnessFailureValue);
-    const object = objectValue(value);
-    return object !== undefined && Object.values(object).every(isHarnessFailureValue);
-}
-/** Convert the public harness terminal failure into the shared projection face. */
-export function projectTerminalFailure(state, facts) {
-    if (state !== "failed" && state !== "lost-runner" && state !== "launch-failed")
-        return undefined;
-    const source = objectValue(facts);
-    if (!source)
-        return undefined;
-    const error = objectValue(source.error);
-    const publicArtifactId = artifactId(source);
-    // Runner verdict authority wins classification even when harness evidence is
-    // also attached to the verdict.
-    if (state === "launch-failed" || state === "lost-runner") {
-        const phase = state === "lost-runner"
-            ? "adoption"
-            : source.stage === "spawn" ? "launch" : "adoption";
-        const code = phase === "launch"
-            ? "SUBAGENT_SPAWN_ERROR"
-            : "SUBAGENT_EXEC_ERROR";
-        const timeoutMs = nonNegativeNumber(error?.timeoutMs ?? source.timeoutMs);
-        const publicExitCode = exitCode(error?.exitCode ?? source.exitCode);
-        const publicSignal = signal(error?.signal ?? source.signal);
-        return {
-            class: "runner",
-            code,
-            phase,
-            ...(timeoutMs !== undefined ? { timeoutMs } : {}),
-            ...(publicExitCode !== undefined ? { exitCode: publicExitCode } : {}),
-            ...(publicSignal ? { signal: publicSignal } : {}),
-            ...(publicArtifactId ? { artifactId: publicArtifactId } : {}),
-        };
-    }
-    if (error?.version !== OUTCOME_ERROR_VERSION)
-        return undefined;
-    const publicSignal = signal(error?.signal ?? source.signal);
-    const publicExitCode = exitCode(error?.exitCode ?? source.exitCode);
-    const code = failureCode(error?.code ?? source.code)
-        ?? (publicSignal ? "SUBAGENT_EXEC_ERROR" : undefined)
-        ?? (publicExitCode !== undefined ? "SUBAGENT_NON_ZERO_EXIT" : undefined);
-    if (!code || code === "SUBAGENT_SPAWN_ERROR")
-        return undefined;
-    const timeoutMs = nonNegativeNumber(error?.timeoutMs ?? source.timeoutMs);
-    const publicCause = providerFailureCause(error?.publicCause);
-    return {
-        class: "harness",
-        code,
-        phase: source.phase === "adoption" ? "adoption" : "runtime",
-        ...(typeof error.message === "string" ? { message: error.message } : {}),
-        ...(timeoutMs !== undefined ? { timeoutMs } : {}),
-        ...(publicExitCode !== undefined ? { exitCode: publicExitCode } : {}),
-        ...(publicSignal ? { signal: publicSignal } : {}),
-        ...(publicArtifactId ? { artifactId: publicArtifactId } : {}),
-        ...(publicCause ? { publicCause } : {}),
-    };
-}

package/build/core/projection/projection-wait.js

@@ -1,318 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { foldPublicProjectionActivity } from "./projection-activity.js";
-import { readGenerationEvents, isProjectionId, projectionRootAtCoordinate, } from "./projection-core.js";
-import { resolveProjectionCoordinate } from "./projection-coordinate.js";
-import { readProjectionIdentity } from "./projection-identity.js";
-import { RESPONSE_ARTIFACT_ID_RE } from "../response-artifact-id.js";
-import { extractTerminalTimestamp } from "./generation/model.js";
-import { PROJECTION_ADOPTION_TIMEOUT_MS } from "./generation/projection-generation-launcher.js";
-import { observeProjectionLifeSnapshot } from "./projection-life-observer.js";
-import { deriveProjectionLife } from "./projection-life-protocol.js";
-import { readProjectionGenerationContinuationSnapshot, } from "./generation/projection-generation-continuation.js";
-import { projectTerminalFailure, } from "./projection-terminal-failure.js";
-import { invalidActivityEventDiagnostic, selectValidStoredAgentEvents, } from "../stored-agent-event.js";
-import { tellProjection } from "./projection-wake.js";
-import { FlowError } from "../../flow-error.js";
-/** Return the commission-bound projection IDs visible at one admission instant. */
-export async function snapshotCommissionProjectionIds(cwd, commissionId) {
-    return snapshotCommissionProjectionIdsAtCoordinate(await resolveProjectionCoordinate(cwd), commissionId);
-}
-/** Scan one already-resolved projection coordinate for commission-bound IDs. */
-export async function snapshotCommissionProjectionIdsAtCoordinate(coordinate, commissionId) {
-    const root = projectionRootAtCoordinate(coordinate);
-    let akumas;
-    try {
-        akumas = fs.readdirSync(root).sort();
-    }
-    catch (error) {
-        if (error instanceof Error && "code" in error && error.code === "ENOENT")
-            return [];
-        throw error;
-    }
-    const ids = [];
-    for (const akuma of akumas) {
-        if (akuma.startsWith("."))
-            continue;
-        const akumaDirectory = path.join(root, akuma);
-        try {
-            if (!fs.lstatSync(akumaDirectory).isDirectory())
-                continue;
-        }
-        catch {
-            continue;
-        }
-        let projections;
-        try {
-            projections = fs.readdirSync(akumaDirectory).sort();
-        }
-        catch {
-            continue;
-        }
-        for (const hex of projections) {
-            const id = `${akuma}/${hex}`;
-            if (!isProjectionId(id))
-                continue;
-            const directory = path.join(akumaDirectory, hex);
-            try {
-                if (!fs.lstatSync(directory).isDirectory())
-                    continue;
-            }
-            catch {
-                continue;
-            }
-            let pact;
-            try {
-                pact = readProjectionIdentity(directory);
-            }
-            catch {
-                // A commission snapshot admits only identities that can prove their
-                // binding. Missing or corrupt unrelated storage is not such proof.
-                continue;
-            }
-            if (pact.binding.kind === "commission" && pact.binding.commissionId === commissionId)
-                ids.push(id);
-        }
-    }
-    return ids;
-}
-const WAIT_POLL_MS = 100;
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function latestValidEventAgeMs(events, nowMs) {
-    let latest;
-    for (const event of events) {
-        const atMs = Date.parse(event.at);
-        if (!Number.isFinite(atMs))
-            continue;
-        if (latest === undefined || atMs > latest)
-            latest = atMs;
-    }
-    return latest === undefined ? undefined : Math.max(0, nowMs - latest);
-}
-function adoptionAgeMs(current, nowMs) {
-    const adoptedAt = current?.adoption?.facts.adoptedAt;
-    if (typeof adoptedAt !== "string")
-        return undefined;
-    const adoptedAtMs = Date.parse(adoptedAt);
-    return Number.isFinite(adoptedAtMs)
-        ? Math.max(0, nowMs - adoptedAtMs)
-        : undefined;
-}
-function relativeEventLedgerFile(executionId) {
-    return `${executionId}.events.jsonl`;
-}
-function timestampFact(current, nowMs) {
-    return extractTerminalTimestamp(current.verdict?.facts) ?? new Date(nowMs).toISOString();
-}
-function verdictFromCurrent(current, nowMs) {
-    if (!current.verdict)
-        return undefined;
-    const state = current.verdict.facts.state;
-    if (typeof state !== "string")
-        return undefined;
-    const terminalFailure = projectTerminalFailure(state, current.verdict.facts);
-    return {
-        state: state,
-        at: timestampFact(current, nowMs),
-        ...(terminalFailure ? { terminalFailure } : {}),
-    };
-}
-function outcomeText(current) {
-    if (current.verdict?.facts.state !== "completed")
-        return undefined;
-    const finalMessage = current.verdict?.facts.finalMessage;
-    if (typeof finalMessage === "string" && finalMessage.trim())
-        return finalMessage;
-    return undefined;
-}
-function buildSnapshot(input) {
-    const { projectionDirectory, pact, phase, current, events, malformedEvents, nowMs, tells } = input;
-    const anchorAt = current?.verdict ? timestampFact(current, nowMs) : new Date(nowMs).toISOString();
-    const anchorMs = Date.parse(anchorAt);
-    const mintedAtMs = Date.parse(pact.mintedAt);
-    const activityAgeMs = latestValidEventAgeMs(events, nowMs)
-        ?? adoptionAgeMs(current, nowMs);
-    const invalidActivity = invalidActivityEventDiagnostic(malformedEvents);
-    const artifactId = current?.verdict?.facts.artifactId;
-    const responsePath = current?.verdict?.facts.responsePath;
-    const completed = current?.verdict?.facts.state === "completed";
-    return {
-        phase,
-        observedAtMs: Number.isFinite(anchorMs) ? anchorMs : nowMs,
-        durationMs: Number.isFinite(mintedAtMs) && Number.isFinite(anchorMs)
-            ? Math.max(0, anchorMs - mintedAtMs)
-            : 0,
-        ...(activityAgeMs !== undefined ? { activityAgeMs } : {}),
-        tells,
-        activity: foldPublicProjectionActivity(events),
-        ...(invalidActivity ? { eventDiagnostics: [invalidActivity] } : {}),
-        workspaceRoot: pact.workspaceRoot,
-        ...(current ? {
-            executionId: current.launch.executionId,
-            eventLedgerFile: relativeEventLedgerFile(current.launch.executionId),
-        } : {}),
-        ...(completed && typeof responsePath === "string" && responsePath.trim() ? { responsePath } : {}),
-        ...(completed && typeof artifactId === "string" && RESPONSE_ARTIFACT_ID_RE.test(artifactId) ? { artifactId } : {}),
-    };
-}
-export async function waitForProjection(input) {
-    const now = input.now ?? Date.now;
-    let pact;
-    try {
-        pact = readProjectionIdentity(input.projectionDirectory);
-    }
-    catch (error) {
-        return {
-            state: "unknown",
-            diagnostic: `projection identity could not be observed: ${error instanceof Error ? error.message : String(error)}`,
-        };
-    }
-    const deadline = input.deadlineMs
-        ?? (input.timeoutMs === undefined ? undefined : now() + input.timeoutMs);
-    const wakeProjection = input.wakeProjection ?? ((directory, id) => tellProjection(directory, id));
-    const readContinuationSnapshot = input.readContinuationSnapshot ?? readProjectionGenerationContinuationSnapshot;
-    let wakeAttempted = false;
-    for (;;) {
-        input.signal?.throwIfAborted();
-        const observedAtMs = now();
-        const continuation = readContinuationSnapshot(input.projectionDirectory, 10);
-        const current = continuation.current;
-        let life = deriveProjectionLife({
-            records: continuation.records,
-            nowMs: observedAtMs,
-            startupTimeoutMs: PROJECTION_ADOPTION_TIMEOUT_MS,
-        });
-        if (current && !current.verdict && current.adoption) {
-            const observation = observeProjectionLifeSnapshot(input.projectionDirectory, {
-                nowMs: observedAtMs,
-                startupTimeoutMs: PROJECTION_ADOPTION_TIMEOUT_MS,
-            });
-            if (observation.compatibility === "incompatible") {
-                life = { phase: "unknown", diagnostic: observation.diagnostic };
-            }
-            else if ((observation.records?.at(-1)?.seq ?? 0) !== continuation.generationSequence) {
-                continue;
-            }
-            else {
-                life = observation.life;
-            }
-        }
-        if (!wakeAttempted
-            && current
-            && life.phase !== "active"
-            && life.phase !== "minting"
-            && life.phase !== "quiescent"
-            && life.phase !== "unknown"
-            && continuation.requiresWake) {
-            wakeAttempted = true;
-            try {
-                const wakeState = await wakeProjection(input.projectionDirectory, `${pact.akuma}/${path.basename(input.projectionDirectory)}`);
-                if (wakeState === "active" || wakeState === "woken")
-                    continue;
-            }
-            catch (error) {
-                if (!(error instanceof FlowError) || error.code !== "PROJECTION_WAKE_FAILED")
-                    throw error;
-                // The wake path persisted any launch/adoption failure. Refresh once so
-                // this invocation reports that typed truth without retrying in a loop.
-                continue;
-            }
-        }
-        const verdict = current ? verdictFromCurrent(current, observedAtMs) : undefined;
-        const terminal = verdict !== undefined;
-        const terminalAtMs = verdict === undefined ? undefined : Date.parse(verdict.at);
-        const terminalWithinDeadline = terminal && (deadline === undefined
-            || (typeof terminalAtMs === "number" && Number.isFinite(terminalAtMs) && terminalAtMs < deadline));
-        if (terminalWithinDeadline || (deadline !== undefined && observedAtMs >= deadline)) {
-            const revalidated = readContinuationSnapshot(input.projectionDirectory, 10);
-            if (revalidated.generationSequence !== continuation.generationSequence)
-                continue;
-            const stored = current
-                ? readGenerationEvents(input.projectionDirectory, current.launch.executionId)
-                : [];
-            const { events, malformed } = selectValidStoredAgentEvents(stored);
-            const snapshot = buildSnapshot({
-                projectionDirectory: input.projectionDirectory,
-                pact,
-                phase: life.phase,
-                current,
-                events,
-                malformedEvents: malformed,
-                nowMs: observedAtMs,
-                tells: revalidated.tells,
-            });
-            if (terminalWithinDeadline && current) {
-                const text = outcomeText(current);
-                return {
-                    state: "terminal",
-                    pact,
-                    verdict,
-                    snapshot,
-                    ...(text ? { outcomeText: text } : {}),
-                };
-            }
-            return {
-                state: "timeout",
-                pact,
-                snapshot,
-                ...(terminal ? { terminalSnapshot: true } : {}),
-            };
-        }
-        const waitMs = deadline === undefined
-            ? WAIT_POLL_MS
-            : Math.max(0, Math.min(WAIT_POLL_MS, deadline - observedAtMs));
-        await sleep(waitMs);
-    }
-}
-/**
- * Observe a fixed projection set. Admission owns the set snapshot; this reader
- * never discovers or adds a projection while it is waiting.
- */
-export async function waitForProjectionSet(input) {
-    const controller = new AbortController();
-    const abort = () => controller.abort(input.signal?.reason);
-    if (input.signal?.aborted)
-        abort();
-    input.signal?.addEventListener("abort", abort, { once: true });
-    const members = [...input.projections].sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
-    const now = input.now ?? Date.now;
-    const deadlineMs = input.timeoutMs === undefined ? undefined : now() + input.timeoutMs;
-    try {
-        const waits = members.map((member, index) => waitForProjection({
-            projectionDirectory: member.projectionDirectory,
-            ...(deadlineMs === undefined ? {} : { deadlineMs }),
-            now,
-            signal: controller.signal,
-        }).then((result) => ({ index, id: member.id, result }), (error) => ({ index, id: member.id, error })));
-        if (input.selection === "all") {
-            const settled = await Promise.all(waits);
-            for (const item of settled) {
-                if ("error" in item)
-                    throw item.error;
-            }
-            return {
-                selection: "all",
-                results: settled.map((item) => ({ id: item.id, result: item.result })),
-            };
-        }
-        const pending = new Set(waits.keys());
-        const observed = [];
-        while (pending.size > 0) {
-            const next = await Promise.race([...pending].map((index) => waits[index]));
-            pending.delete(next.index);
-            if ("error" in next)
-                throw next.error;
-            if (next.result.state === "terminal") {
-                controller.abort();
-                return { selection: "any", selectedId: next.id, results: [{ id: next.id, result: next.result }] };
-            }
-            observed.push({ id: next.id, result: next.result });
-        }
-        return { selection: "any", results: observed.sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0) };
-    }
-    finally {
-        input.signal?.removeEventListener("abort", abort);
-    }
-}