@astrosheep/keiyaku 2.9.2 → 2.9.4

package/build/core/petition-claim.js

@@ -1,117 +0,0 @@
-import { FlowError } from "../flow-error.js";
-import { readContractLog } from "./log.js";
-import { petitionContract } from "./petition.js";
-import { verdictContract } from "./verdict.js";
-import { nextReviewResponseNumber } from "./transcripts.js";
-import { buildClaimGatePipeline, } from "./petition-claim-gates.js";
-import { assertHeadUnchanged } from "./petition-head-guard.js";
-async function throwClaimGateFailure(failure, input, context, dependencies) {
-    const { cwd, contractId } = context;
-    void contractId;
-    void dependencies;
-    if (failure.reviewHeadBeforeWrite) {
-        await assertHeadUnchanged(cwd, failure.reviewHeadBeforeWrite, "claim review");
-    }
-    throw new FlowError(failure.code, failure.message, {
-        hints: failure.hints,
-        review: failure.review,
-    });
-}
-async function runClaimGatePipelineOrThrow(input, context, dependencies) {
-    const { verificationCommands } = await dependencies.resolveClaimGateConfig(context.cwd);
-    let review;
-    let reviewHeadBeforeWrite;
-    let reviewerActor;
-    for (const gate of buildClaimGatePipeline()) {
-        const result = await gate.evaluate({
-            cwd: context.cwd,
-            contractId: context.contractId,
-            input,
-            verificationCommands,
-            baseBranch: dependencies.baseBranch,
-            reviewNumber: dependencies.reviewNumber,
-        });
-        if (result.review) {
-            review = result.review;
-            reviewHeadBeforeWrite = result.reviewHeadBeforeWrite;
-        }
-        if (result.reviewerActor)
-            reviewerActor = result.reviewerActor;
-        if (!result.pass) {
-            await throwClaimGateFailure(result, input, context, dependencies);
-        }
-    }
-    return { review, reviewHeadBeforeWrite, reviewerActor };
-}
-function maxArc(entries) {
-    return entries.filter((entry) => entry.kind === "arc").length;
-}
-function cleanupWarnings(cleanup) {
-    return [
-        ...(cleanup.worktreeRemoveFailure
-            ? [`Could not remove contract worktree ${cleanup.worktreeRemoveFailure.path}: ${cleanup.worktreeRemoveFailure.reason}`]
-            : []),
-        ...(cleanup.branchDeleteFailure
-            ? [`Could not delete contract branch ${cleanup.branchDeleteFailure.name}: ${cleanup.branchDeleteFailure.reason}`]
-            : []),
-    ];
-}
-export async function claimKeiyaku(input, context, dependencies) {
-    const { cwd, baseBranch, contractId } = context;
-    const claimResult = "dangerouslyBypassGates" in input && input.dangerouslyBypassGates
-        ? { review: undefined, reviewHeadBeforeWrite: undefined, bypassedByArchitect: true }
-        : {
-            ...(await runClaimGatePipelineOrThrow(input, { cwd, contractId }, {
-                ...dependencies,
-                baseBranch,
-                reviewNumber: await nextReviewResponseNumber(cwd),
-            })),
-            bypassedByArchitect: false,
-        };
-    if (claimResult.review && claimResult.reviewHeadBeforeWrite) {
-        await assertHeadUnchanged(cwd, claimResult.reviewHeadBeforeWrite, "claim review");
-    }
-    const oath = String(input.oath ?? "").trim();
-    if (!oath) {
-        throw new FlowError("OATH_MISSING", "Oath missing.");
-    }
-    const petition = await petitionContract({
-        cwd,
-        contractId,
-        actor: "keiyaku",
-        nowMs: Date.now(),
-        intent: "claim",
-        oath,
-        waivePaths: input.waivePaths,
-    });
-    const log = await readContractLog({ cwd, contractId });
-    const verdict = await verdictContract({
-        cwd,
-        contractId,
-        actor: claimResult.reviewerActor ?? "keiyaku",
-        nowMs: Date.now(),
-        result: "approved",
-        summary: claimResult.review?.findings?.trim() || "礼成",
-    });
-    if (!verdict.claimed) {
-        throw new FlowError("INTERNAL_STATE", `approved verdict for ${contractId} did not produce an engine claim`);
-    }
-    const cleanup = verdict.claimed.cleanup ?? { absent: ["worktree", "branch"] };
-    const warnings = [...(verdict.claimed.warnings ?? []), ...cleanupWarnings(cleanup)];
-    return {
-        status: "success",
-        result: "merged",
-        arc: maxArc(log.entries),
-        currentBranch: baseBranch,
-        baseBranch,
-        commit: verdict.claimed.mergeCommit,
-        mergedInto: baseBranch,
-        ...(cleanup.deletedBranch ? { deletedBranch: cleanup.deletedBranch } : {}),
-        cleanup,
-        diff: `Merged contract ${contractId} with merge-tree/commit-tree CAS.`,
-        ...(petition.sealed ? { sealed: petition.sealed } : {}),
-        ...(warnings.length > 0
-            ? { meta: { warnings } }
-            : {}),
-    };
-}

package/build/core/petition-run.js

@@ -1,83 +0,0 @@
-import { assertSettingsKnobUsable } from "../config/settings/disease.js";
-import { loadKeiyakuSettings } from "../config/settings/loader.js";
-import { FlowError } from "../flow-error.js";
-import { readCurrentContractContext } from "./context.js";
-import { readLedger } from "./ledger.js";
-import { commissionTarget } from "./status/drift.js";
-import { getCurrentBranch, requireGitRepository } from "../git/branches.js";
-import { claimKeiyaku } from "./petition-claim.js";
-import { forfeitKeiyaku } from "./petition-forfeit.js";
-const VERDICT_DENIED_CODE = "VERDICT_DENIED";
-async function resolveClaimGateConfig(cwd) {
-    const merged = {
-        verificationCommands: [],
-    };
-    try {
-        const loaded = await loadKeiyakuSettings(cwd);
-        assertSettingsKnobUsable(loaded, "gate");
-        const gate = loaded.knobs?.gate;
-        if (!gate) {
-            return merged;
-        }
-        merged.verificationCommands = gate.commands ?? merged.verificationCommands;
-        return merged;
-    }
-    catch (error) {
-        if (error instanceof FlowError && error.code === "INVALID_SETTINGS") {
-            throw new FlowError(VERDICT_DENIED_CODE, `Configuration Error: ${error.message}`, {
-                cause: error,
-                hints: error.hints,
-            });
-        }
-        throw error;
-    }
-}
-async function loadCloseContext(cwd, requestedContractId) {
-    await requireGitRepository(cwd, "petition");
-    if (requestedContractId) {
-        const ledger = await readLedger(cwd, requestedContractId);
-        if (!ledger) {
-            throw new FlowError("INTERNAL_STATE", `contract ${requestedContractId} not found or not active`);
-        }
-        const target = commissionTarget(ledger.entries);
-        if (!target) {
-            throw new FlowError("INTERNAL_STATE", `contract ${requestedContractId} active ledger is missing commission target`);
-        }
-        return {
-            cwd,
-            keiyakuBranch: `keiyaku/${requestedContractId}`,
-            baseBranch: target.branch,
-            contractId: requestedContractId,
-        };
-    }
-    let contractContext;
-    try {
-        contractContext = await readCurrentContractContext(cwd);
-    }
-    catch (error) {
-        if (!(error instanceof FlowError) || error.code !== "EMPTY_PARAM") {
-            throw error;
-        }
-        throw new FlowError("NOT_ACTIVE_KEIYAKU_BRANCH", "Current workspace is not addressing an active Keiyaku contract.", { hints: ["keiyaku bind — opens a new contract"] });
-    }
-    const keiyakuBranch = await getCurrentBranch(cwd);
-    return {
-        cwd,
-        keiyakuBranch,
-        baseBranch: contractContext.baseBranch,
-        contractId: contractContext.contractId,
-    };
-}
-export async function petitionKeiyaku(input) {
-    const context = await loadCloseContext(input.cwd, input.contractId);
-    const { intent } = input;
-    if (intent === "FORFEIT") {
-        return forfeitKeiyaku(context);
-    }
-    if (intent === "CLAIM") {
-        return claimKeiyaku(input, context, {
-            resolveClaimGateConfig,
-        });
-    }
-    throw new FlowError("INVALID_CLOSE_INTENT", `unsupported close intent: ${intent}`);
-}

package/build/core/projection-coordinate.js

@@ -1,63 +0,0 @@
-import { spawnSync } from "node:child_process";
-import * as path from "node:path";
-import { ProjectionStateError } from "./atomic-publish.js";
-import { isGitExecutableUnavailable } from "../git/core.js";
-import { gitCommonRootPath, resolveGitCommonRootSync } from "./path-coordinate.js";
-/**
- * Resolve projection storage root and authority from one Git probe.
- *
- * A non-bare repository uses the parent of its absolute common Git directory,
- * so every linked worktree shares one coordinate. Repo-free callers retain the
- * existing cwd-local authority until its replacement is legislated.
- */
-export function resolveProjectionCoordinate(cwd) {
-    const result = spawnSync("git", ["rev-parse", "--is-bare-repository", "--path-format=absolute", "--git-common-dir"], {
-        cwd,
-        encoding: "utf8",
-        env: {
-            ...process.env,
-            GIT_TERMINAL_PROMPT: "0",
-            LC_ALL: "C",
-        },
-        stdio: ["ignore", "pipe", "pipe"],
-    });
-    if (result.error && isGitExecutableUnavailable(result.error)) {
-        return { physicalRoot: cwd, authority: { kind: "user" } };
-    }
-    if (result.error) {
-        throw new ProjectionStateError(`cannot resolve projection repository coordinate: ${result.error.message}`);
-    }
-    if (result.status !== 0) {
-        const detail = result.stderr.trim();
-        if (detail.includes("not a git repository")) {
-            return { physicalRoot: cwd, authority: { kind: "user" } };
-        }
-        throw new ProjectionStateError(`cannot resolve projection repository coordinate${detail ? `: ${detail}` : ` (git exited ${String(result.status)})`}`);
-    }
-    const [bare, commonDir] = result.stdout.trim().split(/\r?\n/);
-    const stableRoot = commonDir === undefined ? undefined : gitCommonRootPath(commonDir);
-    if (bare !== "false" || !commonDir || !stableRoot || !path.isAbsolute(stableRoot)) {
-        return { physicalRoot: cwd, authority: { kind: "user" } };
-    }
-    let physicalRoot;
-    try {
-        physicalRoot = resolveGitCommonRootSync(commonDir);
-    }
-    catch (error) {
-        throw new ProjectionStateError(`cannot resolve projection repository root ${stableRoot}`, { cause: error });
-    }
-    return {
-        physicalRoot,
-        authority: { kind: "repository", stableRoot: physicalRoot },
-    };
-}
-/**
- * Select the filesystem authority for repository projection state.
- *
- * A non-bare repository uses the parent of its absolute common Git directory,
- * so every linked worktree shares one coordinate. Repo-free callers retain the
- * existing cwd-local authority until its replacement is legislated.
- */
-export function projectionCoordinateRoot(cwd) {
-    return resolveProjectionCoordinate(cwd).physicalRoot;
-}

package/build/core/projection-wait.js

@@ -1,165 +0,0 @@
-import { foldAgentActivity } from "./projection-activity.js";
-import { readGenerationEvents, } from "./projection-core.js";
-import { readProjectionIdentity } from "./projection-identity.js";
-import { PROJECTION_ADOPTION_TIMEOUT_MS } from "./projection-generation-launcher.js";
-import { observeProjectionLifeSnapshot } from "./projection-life-observer.js";
-import { selectCurrentGeneration } from "./projection-life-protocol.js";
-import { readProjectionTellCounts } from "./projection/tell/store.js";
-import { invalidActivityEventDiagnostic, selectValidStoredAgentEvents, } from "./stored-agent-event.js";
-const WAIT_POLL_MS = 100;
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function waitingTellCount(projectionDirectory) {
-    const counts = readProjectionTellCounts(projectionDirectory);
-    return counts.inbox + counts.inflight + counts.submitted + counts.delivered;
-}
-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) {
-    const facts = current.verdict?.facts;
-    for (const key of ["completedAt", "failedAt", "dismissedAt", "killedAt"]) {
-        const value = facts?.[key];
-        if (typeof value === "string" && Number.isFinite(Date.parse(value)))
-            return value;
-    }
-    return 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 detail = current.verdict.facts.detail;
-    return {
-        state: state,
-        at: timestampFact(current, nowMs),
-        ...(typeof detail === "string" && detail.trim() ? { detail } : {}),
-    };
-}
-function outcomeText(current) {
-    const finalMessage = current.verdict?.facts.finalMessage;
-    if (typeof finalMessage === "string" && finalMessage.trim())
-        return finalMessage;
-    const detail = current.verdict?.facts.detail;
-    return typeof detail === "string" && detail.trim() ? detail : undefined;
-}
-function buildSnapshot(input) {
-    const { projectionDirectory, pact, phase, current, events, malformedEvents, nowMs } = 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 responsePath = current?.verdict?.facts.responsePath;
-    const artifactId = current?.verdict?.facts.artifactId;
-    const sourceArtifactId = current?.verdict?.facts.sourceArtifactId;
-    const errorFact = current?.verdict?.facts.error;
-    const failureCode = errorFact
-        && typeof errorFact === "object"
-        && !Array.isArray(errorFact)
-        && typeof errorFact.code === "string"
-        ? errorFact.code
-        : undefined;
-    return {
-        phase,
-        observedAtMs: Number.isFinite(anchorMs) ? anchorMs : nowMs,
-        durationMs: Number.isFinite(mintedAtMs) && Number.isFinite(anchorMs)
-            ? Math.max(0, anchorMs - mintedAtMs)
-            : 0,
-        ...(activityAgeMs !== undefined ? { activityAgeMs } : {}),
-        tellsWaiting: waitingTellCount(projectionDirectory),
-        activity: foldAgentActivity(events),
-        ...(invalidActivity ? { eventDiagnostics: [invalidActivity] } : {}),
-        workspaceRoot: pact.workspaceRoot,
-        ...(current ? {
-            executionId: current.launch.executionId,
-            eventLedgerFile: relativeEventLedgerFile(current.launch.executionId),
-        } : {}),
-        ...(typeof responsePath === "string" && responsePath.trim() ? { responsePath } : {}),
-        ...(typeof artifactId === "string" && artifactId.trim() ? { artifactId } : {}),
-        ...(typeof sourceArtifactId === "string" && sourceArtifactId.trim() ? { sourceArtifactId } : {}),
-        ...(failureCode ? { failureCode } : {}),
-    };
-}
-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.timeoutMs === undefined ? undefined : now() + input.timeoutMs;
-    for (;;) {
-        input.signal?.throwIfAborted();
-        const observedAtMs = now();
-        const observation = observeProjectionLifeSnapshot(input.projectionDirectory, {
-            nowMs: observedAtMs,
-            startupTimeoutMs: PROJECTION_ADOPTION_TIMEOUT_MS,
-        });
-        const current = observation.records
-            ? selectCurrentGeneration(observation.records)
-            : null;
-        const life = observation.life;
-        const verdict = current ? verdictFromCurrent(current, observedAtMs) : undefined;
-        const terminal = verdict !== undefined;
-        if (terminal || (deadline !== undefined && observedAtMs >= deadline)) {
-            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,
-            });
-            if (terminal && current) {
-                const text = outcomeText(current);
-                return {
-                    state: "terminal",
-                    pact,
-                    verdict,
-                    snapshot,
-                    ...(text ? { outcomeText: text } : {}),
-                };
-            }
-            return { state: "timeout", pact, snapshot };
-        }
-        const waitMs = deadline === undefined
-            ? WAIT_POLL_MS
-            : Math.max(0, Math.min(WAIT_POLL_MS, deadline - observedAtMs));
-        await sleep(waitMs);
-    }
-}

package/build/core/projection-wake.js

@@ -1,136 +0,0 @@
-import { FlowError } from "../flow-error.js";
-import { parseResolvedAkumaLaunchSnapshot } from "../agents/launch-snapshot/model.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 store.readCurrentGeneration();
-    }
-    finally {
-        store.close();
-    }
-}
-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 {
-        ...inherited,
-        createdAt: new Date(nowMs).toISOString(),
-        launchedBy: "tell-wake",
-        parentExecutionId: current.launch.executionId,
-        tellFence: snapshot.tellIds,
-        inputs: applyContinuationEffort(continuedInputs, snapshot.effort),
-    };
-}
-export function assertTellEffortSupported(projectionDirectory, effort) {
-    if (!effort)
-        return;
-    const current = readCurrentGeneration(projectionDirectory);
-    if (!current)
-        throw new ProjectionStateError("projection has no immutable generation launch");
-    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 });
-    }
-    if (launchSnapshot.akuma.model === undefined) {
-        throw new FlowError("INVALID_EFFORT_OVERRIDE", `Effort '${effort}' requires an explicit model.`);
-    }
-    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(", ")}.`);
-    }
-}
-async function startCommittedSuccessor(projectionDirectory, executionId) {
-    const started = await startProjectionGeneration(projectionDirectory, executionId);
-    return started.status === "adopted" ? "woken" : "pending";
-}
-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 {
-        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";
-        }
-        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";
-        }
-        if (life.phase !== "done") {
-            return "pending";
-        }
-        const transition = store.launchIfSettled({
-            executionId: successorExecutionId,
-            facts,
-        });
-        if (transition.status !== "committed")
-            return "pending";
-        return await startCommittedSuccessor(projectionDirectory, successorExecutionId);
-    }
-    finally {
-        store.close();
-    }
-}