@astrosheep/keiyaku 2.9.13 → 4.0.1

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

@@ -1,442 +0,0 @@
-import fs from "node:fs";
-import * as path from "node:path";
-import { isErrnoException } from "../../errno.js";
-import { isProjectionId, projectionRoot, projectionRootAtCoordinate } from "./projection-core.js";
-import { projectionAliasRootAtCoordinate, readProjectionAliasAtRoot, } from "./projection-alias.js";
-import { resolveProjectionCoordinate } from "./projection-coordinate.js";
-import { readProjectionIdentity } from "./projection-identity.js";
-import { observeProjectionLifeSnapshot, } from "./projection-life-observer.js";
-import { worktreeContainsCoordinate } from "../worktree-path.js";
-import { readProjectionRow, readProjectionSummary } from "./projection-status-observation.js";
-const MAX_STATUS_FILE_BYTES = 256 * 1024;
-const STATUS_GROUP = {
-    "startup-timeout": 0,
-    lost: 0,
-    unknown: 0,
-    minting: 1,
-    out: 1,
-    failed: 2,
-    dead: 2,
-    done: 3,
-    killed: 4,
-    dismissed: 4,
-    incompatible: 5,
-};
-function isOmissibleProjectionStatusState(state) {
-    return state === "failed"
-        || state === "dead"
-        || state === "done"
-        || state === "killed"
-        || state === "dismissed"
-        || state === "incompatible";
-}
-function rowSortTime(row) {
-    if (row.activityAtMs !== undefined && Number.isFinite(row.activityAtMs)) {
-        return row.activityAtMs;
-    }
-    if (row.mintedAt !== undefined) {
-        const mintedAtMs = Date.parse(row.mintedAt);
-        if (Number.isFinite(mintedAtMs))
-            return mintedAtMs;
-    }
-    return Number.NEGATIVE_INFINITY;
-}
-function compareProjectionStatusRows(a, b) {
-    const groupDifference = STATUS_GROUP[a.state] - STATUS_GROUP[b.state];
-    if (groupDifference !== 0)
-        return groupDifference;
-    const aTime = rowSortTime(a);
-    const bTime = rowSortTime(b);
-    if (aTime !== bTime) {
-        if (aTime === Number.NEGATIVE_INFINITY)
-            return 1;
-        if (bTime === Number.NEGATIVE_INFINITY)
-            return -1;
-        return bTime - aTime;
-    }
-    return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
-}
-export function prioritizeProjectionStatusRows(rows) {
-    const ordered = [...rows].sort(compareProjectionStatusRows);
-    const visible = ordered.filter((row) => !isOmissibleProjectionStatusState(row.state));
-    const byState = {
-        failed: 0,
-        dead: 0,
-        done: 0,
-        killed: 0,
-        dismissed: 0,
-        incompatible: 0,
-    };
-    for (const row of ordered) {
-        if (isOmissibleProjectionStatusState(row.state))
-            byState[row.state] += 1;
-    }
-    const total = Object.values(byState).reduce((sum, count) => sum + count, 0);
-    return total > 0 ? { rows: visible, omitted: { total, byState } } : { rows: visible };
-}
-const TRIAGE_UNKNOWN_LIMIT = 8;
-const TRIAGE_ACTIVE_LIMIT = 8;
-const TRIAGE_RECENT_TERMINAL_LIMIT = 3;
-function isTerminalVerdictState(state) {
-    return state === "failed"
-        || state === "dead"
-        || state === "done"
-        || state === "killed"
-        || state === "dismissed"
-        || state === "incompatible";
-}
-function isUnknownRow(row) {
-    return row.state === "lost" || row.state === "unknown";
-}
-function isStartupFailedRow(row) {
-    return row.state === "startup-timeout";
-}
-function isActiveRow(row) {
-    return row.state === "minting" || row.state === "out";
-}
-/**
- * Main status is a bounded lifecycle summary, not a second roster. Keep
- * category limits here so JSON and the human renderer receive the same rows.
- */
-export function triageProjectionStatusRows(rows) {
-    if (rows.length === 0)
-        return { rows: [] };
-    const ordered = [...rows].sort(compareProjectionStatusRows);
-    const startupFailedRows = ordered.filter(isStartupFailedRow);
-    const unknownRows = ordered.filter(isUnknownRow);
-    const activeRows = ordered.filter(isActiveRow);
-    const terminalRows = ordered.filter((row) => isTerminalVerdictState(row.state));
-    const boundedObservationFailures = ordered
-        .filter((row) => isStartupFailedRow(row) || isUnknownRow(row))
-        .slice(0, TRIAGE_UNKNOWN_LIMIT);
-    const startupFailed = boundedObservationFailures.filter(isStartupFailedRow);
-    const unknown = boundedObservationFailures.filter(isUnknownRow);
-    const selected = new Set(boundedObservationFailures.map((row) => row.id));
-    const active = ordered.filter((row) => !selected.has(row.id) && isActiveRow(row)).slice(0, TRIAGE_ACTIVE_LIMIT);
-    active.forEach((row) => selected.add(row.id));
-    const recentTerminal = ordered
-        .filter((row) => !selected.has(row.id) && isTerminalVerdictState(row.state))
-        .slice(0, TRIAGE_RECENT_TERMINAL_LIMIT);
-    recentTerminal.forEach((row) => selected.add(row.id));
-    const omittedRows = ordered.filter((row) => !selected.has(row.id));
-    const byState = {
-        failed: 0, dead: 0, done: 0, killed: 0, dismissed: 0, incompatible: 0,
-    };
-    for (const row of omittedRows) {
-        if (isOmissibleProjectionStatusState(row.state))
-            byState[row.state] += 1;
-    }
-    const omittedTerminalTotal = Object.values(byState).reduce((sum, count) => sum + count, 0);
-    return {
-        rows: [...startupFailed, ...unknown, ...active, ...recentTerminal],
-        triage: {
-            startupFailed,
-            unknown,
-            active,
-            recentTerminal,
-            totals: {
-                startupFailed: startupFailedRows.length,
-                unknown: unknownRows.length,
-                active: activeRows.length,
-                terminal: terminalRows.length,
-            },
-            overflow: omittedRows.length,
-        },
-        ...(omittedTerminalTotal > 0 ? { omitted: { total: omittedTerminalTotal, byState } } : {}),
-    };
-}
-/** Terminal history is pageable; active observations stay complete. */
-export function paginateProjectionStatusRoster(board, input) {
-    const limit = input.limit ?? 20;
-    const offset = input.offset ?? 0;
-    const nonterminal = board.rows.filter((row) => !isTerminalVerdictState(row.state));
-    const terminal = board.rows.filter((row) => isTerminalVerdictState(row.state));
-    const selectedTerminal = terminal.slice(offset, offset + limit);
-    const omittedRows = [...terminal.slice(0, offset), ...terminal.slice(offset + limit)];
-    const byState = {
-        failed: 0, dead: 0, done: 0, killed: 0, dismissed: 0, incompatible: 0,
-    };
-    for (const row of omittedRows) {
-        if (isOmissibleProjectionStatusState(row.state))
-            byState[row.state] += 1;
-    }
-    return {
-        rows: [...nonterminal, ...selectedTerminal],
-        ...(omittedRows.length > 0 ? { omitted: { total: omittedRows.length, byState } } : {}),
-        pagination: {
-            limit,
-            offset,
-            returned: selectedTerminal.length,
-            total: terminal.length,
-            hasMore: offset + selectedTerminal.length < terminal.length,
-        },
-    };
-}
-export function requiresProjectionStatusDetails(state) {
-    return !isOmissibleProjectionStatusState(state);
-}
-async function readProjectionStatusAliases(root) {
-    const aliases = new Map();
-    try {
-        for (const alias of fs.readdirSync(root).sort()) {
-            if (alias.startsWith("."))
-                continue;
-            const id = await readProjectionAliasAtRoot(root, alias);
-            if (id)
-                aliases.set(id, alias);
-        }
-    }
-    catch (error) {
-        if (!(isErrnoException(error) && error.code === "ENOENT"))
-            throw error;
-    }
-    return aliases;
-}
-function readProjectionTopologyEntries(directory) {
-    try {
-        if (!fs.lstatSync(directory).isDirectory())
-            return null;
-        return fs.readdirSync(directory).sort();
-    }
-    catch (error) {
-        if (isErrnoException(error) && error.code === "ENOENT")
-            return null;
-        throw error;
-    }
-}
-function readProjectionRootTopology(coordinate) {
-    const root = projectionRootAtCoordinate(coordinate);
-    const akumas = readProjectionTopologyEntries(root);
-    return akumas ? { root, akumas } : null;
-}
-function readAkumaProjectionStatusSummaries(root, akuma, aliases, nowMs) {
-    const akumaDir = path.join(root, akuma);
-    const hexes = readProjectionTopologyEntries(akumaDir);
-    if (!hexes)
-        return null;
-    const summaries = [];
-    for (const hex of hexes) {
-        const id = `${akuma}/${hex}`;
-        const dir = path.join(akumaDir, hex);
-        if (!isProjectionId(id))
-            continue;
-        try {
-            if (!fs.lstatSync(dir).isDirectory())
-                continue;
-        }
-        catch {
-            continue;
-        }
-        summaries.push(readProjectionSummary(dir, id, aliases.get(id), nowMs, {
-            requiresIdentity: requiresProjectionStatusDetails,
-        }));
-    }
-    return summaries;
-}
-function isNonterminalProjectionStatusSummary(summary) {
-    return summary.snapshot.compatibility === "current"
-        && requiresProjectionStatusDetails(summary.state);
-}
-export async function readOperationalProjectionStatusBoard(cwd, nowMs) {
-    const coordinate = await resolveProjectionCoordinate(cwd);
-    const topology = readProjectionRootTopology(coordinate);
-    if (!topology)
-        return null;
-    const { root, akumas } = topology;
-    const aliases = await readProjectionStatusAliases(projectionAliasRootAtCoordinate(coordinate));
-    const summaries = [];
-    for (const akuma of akumas) {
-        if (akuma.startsWith("."))
-            continue;
-        const scoped = readAkumaProjectionStatusSummaries(root, akuma, aliases, nowMs);
-        // Seeing an entry and then being unable to observe its namespace is not an
-        // observable zero. Keep the whole aggregate surface unavailable.
-        if (scoped === null)
-            return null;
-        summaries.push(...scoped);
-    }
-    const rows = summaries.map((summary) => readProjectionRow(summary, nowMs, requiresProjectionStatusDetails(summary.state)));
-    // A published root is an observable surface even when it currently has no
-    // rows. The caller must distinguish that fact from an unavailable root.
-    return triageProjectionStatusRows(rows);
-}
-/** Full roster read. The main board applies triage separately; this surface never caps stored projections. */
-export async function readProjectionRosterStatusBoard(cwd, nowMs) {
-    const coordinate = await resolveProjectionCoordinate(cwd);
-    const topology = readProjectionRootTopology(coordinate);
-    if (!topology)
-        return null;
-    const aliases = await readProjectionStatusAliases(projectionAliasRootAtCoordinate(coordinate));
-    const summaries = [];
-    for (const akuma of topology.akumas) {
-        if (akuma.startsWith("."))
-            continue;
-        const scoped = readAkumaProjectionStatusSummaries(topology.root, akuma, aliases, nowMs);
-        if (scoped === null)
-            return null;
-        summaries.push(...scoped);
-    }
-    return {
-        rows: summaries
-            .map((summary) => readProjectionRow(summary, nowMs, requiresProjectionStatusDetails(summary.state)))
-            .sort(compareProjectionStatusRows),
-    };
-}
-export async function readExactProjectionStatus(cwd, nowMs, projectionId) {
-    if (!isProjectionId(projectionId))
-        return null;
-    const coordinate = await resolveProjectionCoordinate(cwd);
-    const root = projectionRootAtCoordinate(coordinate);
-    try {
-        if (!fs.lstatSync(root).isDirectory())
-            return null;
-    }
-    catch (error) {
-        if (isErrnoException(error) && error.code === "ENOENT")
-            return null;
-        throw error;
-    }
-    const [akuma, hex] = projectionId.split("/");
-    const dir = path.join(root, akuma, hex);
-    try {
-        if (!fs.lstatSync(dir).isDirectory())
-            return null;
-    }
-    catch (error) {
-        if (isErrnoException(error) && error.code === "ENOENT")
-            return null;
-        throw error;
-    }
-    const aliases = await readProjectionStatusAliases(projectionAliasRootAtCoordinate(coordinate));
-    return readProjectionRow(readProjectionSummary(dir, projectionId, aliases.get(projectionId), nowMs), nowMs, true);
-}
-/** Shared bounded selector for human and structured status consumers. */
-export async function selectProjectionStatus(cwd, nowMs, input) {
-    if (input.kind === "operational")
-        return { input, board: await readOperationalProjectionStatusBoard(cwd, nowMs) };
-    const coordinate = await resolveProjectionCoordinate(cwd);
-    const canonicalId = isProjectionId(input.token)
-        ? input.token
-        : await readProjectionAliasAtRoot(projectionAliasRootAtCoordinate(coordinate), input.token);
-    if (!canonicalId)
-        return { input, board: null };
-    const row = await readExactProjectionStatus(cwd, nowMs, canonicalId);
-    if (!row)
-        return { input, board: null };
-    const aliasMovedTo = input.token === canonicalId
-        ? undefined
-        : await readProjectionAliasAtRoot(projectionAliasRootAtCoordinate(coordinate), input.token);
-    return {
-        input,
-        board: {
-            rows: [{
-                    ...row,
-                    addressedBy: {
-                        token: input.token,
-                        kind: input.token === canonicalId ? "canonical" : "alias",
-                        ...(aliasMovedTo && aliasMovedTo !== canonicalId ? { aliasMovedTo } : {}),
-                    },
-                }],
-        },
-    };
-}
-export async function readAkumaNonterminalProjectionStatus(cwd, nowMs, akuma) {
-    if (!isProjectionId(`${akuma}/00000000`))
-        return null;
-    const coordinate = await resolveProjectionCoordinate(cwd);
-    const root = projectionRootAtCoordinate(coordinate);
-    try {
-        if (!fs.lstatSync(root).isDirectory())
-            return null;
-    }
-    catch (error) {
-        if (isErrnoException(error) && error.code === "ENOENT")
-            return null;
-        throw error;
-    }
-    const aliases = await readProjectionStatusAliases(projectionAliasRootAtCoordinate(coordinate));
-    const summaries = readAkumaProjectionStatusSummaries(root, akuma, aliases, nowMs);
-    if (summaries === null)
-        return null;
-    const rows = summaries
-        .filter(isNonterminalProjectionStatusSummary)
-        .map((summary) => readProjectionRow(summary, nowMs, true))
-        .sort(compareProjectionStatusRows);
-    return rows.length > 0 ? { rows } : null;
-}
-/**
- * Renew-only lifecycle guard. Immutable identity is checked before lifecycle,
- * so an unrelated or unattributable projection cannot block a commission.
- */
-export async function hasStrandableProjectionGeneration(input) {
-    const root = await projectionRoot(input.cwd);
-    let akumas;
-    try {
-        if (!fs.lstatSync(root).isDirectory())
-            return false;
-        akumas = fs.readdirSync(root);
-    }
-    catch (error) {
-        if (isErrnoException(error) && error.code === "ENOENT")
-            return false;
-        throw error;
-    }
-    for (const akuma of akumas.sort()) {
-        if (akuma.startsWith("."))
-            continue;
-        const akumaDir = path.join(root, akuma);
-        try {
-            if (!fs.lstatSync(akumaDir).isDirectory())
-                continue;
-        }
-        catch {
-            continue;
-        }
-        let hexes;
-        try {
-            hexes = fs.readdirSync(akumaDir);
-        }
-        catch {
-            continue;
-        }
-        for (const hex of hexes.sort()) {
-            const projectionId = `${akuma}/${hex}`;
-            const projectionDir = path.join(akumaDir, hex);
-            if (!isProjectionId(projectionId))
-                continue;
-            try {
-                if (!fs.lstatSync(projectionDir).isDirectory())
-                    continue;
-            }
-            catch {
-                continue;
-            }
-            let identity;
-            try {
-                identity = readProjectionIdentity(projectionDir);
-            }
-            catch {
-                // Corrupt identity has no trustworthy commission/worktree join and
-                // therefore cannot become a repository-wide renew interlock.
-                continue;
-            }
-            if (identity.binding.kind !== "commission"
-                || identity.binding.commissionId !== input.commissionId
-                || !worktreeContainsCoordinate(input.deliveryWorktree, identity.workspaceRoot)) {
-                continue;
-            }
-            const observation = observeProjectionLifeSnapshot(projectionDir, {
-                nowMs: input.nowMs,
-            });
-            if (observation.compatibility !== "current")
-                continue;
-            const phase = observation.life.phase;
-            if (phase === "active"
-                || phase === "minting"
-                || phase === "unknown") {
-                return true;
-            }
-        }
-    }
-    return false;
-}

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 } : {}),
-    };
-}