@astrosheep/keiyaku 2.9.13 → 4.0.1

package/build/core/call/execution.js

@@ -1,255 +0,0 @@
-import { buildCallTerms } from "../../agents/call-terms.js";
-import { createAbortError, restoreOutcome, SubagentFailure, } from "../../agents/harness/index.js";
-import { resolveAkumaLaunchSnapshot } from "../../agents/launch-snapshot/resolve.js";
-import { selectSubagent } from "../../agents/selector.js";
-import { assertSettingsKnobUsable } from "../../config/settings/disease.js";
-import { loadKeiyakuSettings } from "../../config/settings/loader.js";
-import { resolveProjectionAdoptionTimeoutMs } from "../../config/settings/knobs.js";
-import { FlowError } from "../../flow-error.js";
-import { assertProjectionAlias, moveProjectionAlias } from "../projection/index.js";
-import { projectionDir } from "../projection/index.js";
-import { createProjectionExecutionId, projectionRunnerLeasePath } from "../projection/index.js";
-import { startProjectionGeneration } from "../projection/index.js";
-import { openProjectionGenerationStore, openProjectionGenerationStoreReadOnly, } from "../projection/index.js";
-import { acquireRunnerLease } from "../run-control/runner-lease.js";
-import { observeProjectionLife } from "../projection/index.js";
-import { mintProjection, mintRepositoryProjection } from "../projection/index.js";
-import { waitForProjection } from "../projection/index.js";
-async function readProjectionAdoptionTimeoutMs(cwd) {
-    const settings = await loadKeiyakuSettings(cwd);
-    assertSettingsKnobUsable(settings, "projectionAdoptionTimeoutMs");
-    return resolveProjectionAdoptionTimeoutMs(settings.knobs);
-}
-export function readCurrentGenerationOrThrow(projectionDirectory) {
-    const store = openProjectionGenerationStoreReadOnly(projectionDirectory);
-    try {
-        const current = store.readCurrentGeneration();
-        if (!current)
-            throw new FlowError("INTERNAL_STATE", "projection has no current generation");
-        return current;
-    }
-    finally {
-        store.close();
-    }
-}
-export function outcomeFromGeneration(current) {
-    const verdict = current.verdict;
-    if (!verdict)
-        throw new FlowError("INTERNAL_STATE", "projection generation has no terminal verdict");
-    const facts = verdict.facts;
-    const finalMessage = typeof facts.finalMessage === "string"
-        ? facts.finalMessage
-        : typeof facts.detail === "string"
-            ? facts.detail
-            : "";
-    if (facts.state === "failed" && typeof facts.detail === "string") {
-        throw new FlowError("SUBAGENT_EXEC_ERROR", facts.detail);
-    }
-    const session = facts.session;
-    if (session === null || typeof session !== "object" || Array.isArray(session)) {
-        throw new FlowError("INTERNAL_STATE", "projection verdict is missing its session envelope");
-    }
-    const record = {
-        status: facts.state === "completed"
-            ? "completed"
-            : facts.state === "dismissed"
-                ? "dismissed"
-                : "failed",
-        finalMessage,
-        output: typeof facts.output === "string" ? facts.output : "",
-        diagnostics: typeof facts.diagnostics === "string" ? facts.diagnostics : "",
-        session: session,
-        warnings: Array.isArray(facts.warnings)
-            ? facts.warnings
-            : [],
-        ...(facts.error && typeof facts.error === "object" && !Array.isArray(facts.error)
-            ? { error: facts.error }
-            : {}),
-    };
-    return restoreOutcome(record);
-}
-export async function executeSubagent(agentName, prompt, cwd, options) {
-    const adoptionTimeoutMs = await readProjectionAdoptionTimeoutMs(cwd);
-    const { projection: projectionCoordinate, launchSnapshot, launchFacts } = await buildCallConfig(agentName, prompt, cwd, options);
-    if (!projectionCoordinate) {
-        throw new FlowError("INTERNAL_STATE", "durable execution requires a projection coordinate");
-    }
-    const launchOwnership = acquireRunnerLease(projectionRunnerLeasePath(projectionCoordinate.dir));
-    const launched = await startProjectionGeneration(projectionCoordinate.dir, projectionCoordinate.executionId, {
-        commitLaunch: () => {
-            const store = openProjectionGenerationStore(projectionCoordinate.dir);
-            try {
-                return store.launchIfSettled({ executionId: projectionCoordinate.executionId, facts: launchFacts }).status === "committed";
-            }
-            finally {
-                store.close();
-            }
-        },
-        launchOwnership,
-        adoptionTimeoutMs,
-    });
-    launchOwnership.close();
-    if (launched.status !== "adopted") {
-        const detail = launched.status === "pending"
-            ? "runner retained startup ownership without adopting before the bounded launch wait"
-            : launched.detail;
-        throw new FlowError("SUBAGENT_EXEC_ERROR", detail);
-    }
-    const joined = await waitForProjection({
-        projectionDirectory: projectionCoordinate.dir,
-        signal: options.signal,
-    });
-    if (joined.state !== "terminal") {
-        throw new FlowError("INTERNAL_STATE", "durable execution ended without a terminal generation");
-    }
-    const current = readCurrentGenerationOrThrow(projectionCoordinate.dir);
-    const providerOutcome = outcomeFromGeneration(current);
-    const outcome = {
-        status: providerOutcome.status,
-        finalMessage: providerOutcome.finalMessage,
-        output: providerOutcome.output,
-        diagnostics: providerOutcome.diagnostics,
-        session: providerOutcome.session,
-        warnings: providerOutcome.warnings,
-        ...(providerOutcome.error ? { error: providerOutcome.error } : {}),
-        launchSnapshot,
-    };
-    const completionFacts = current.verdict?.facts;
-    switch (outcome.status) {
-        case "completed":
-            return { outcome, projection: projectionCoordinate, ...(completionFacts ? { completionFacts } : {}) };
-        case "dismissed":
-            throw createAbortError("subagent exec cancelled by client");
-        case "failed": {
-            const error = outcome.error;
-            if (!error) {
-                throw new FlowError("SUBAGENT_EXEC_ERROR", "Subagent exec failed without an error payload.");
-            }
-            throw new FlowError(error.code, error.message, {
-                cause: new SubagentFailure(error.code, error.message, {
-                    timeoutMs: error.timeoutMs,
-                    exitCode: error.exitCode,
-                    output: outcome.output,
-                    diagnostics: outcome.diagnostics,
-                }),
-            });
-        }
-    }
-    throw new FlowError("INTERNAL_STATE", "Unhandled subagent outcome state.");
-}
-export async function launchSubagentGeneration(agentName, prompt, cwd, options) {
-    const adoptionTimeoutMs = await readProjectionAdoptionTimeoutMs(cwd);
-    const { projection, launchSnapshot, launchFacts } = await buildCallConfig(agentName, prompt, cwd, options);
-    if (!projection) {
-        throw new FlowError("INTERNAL_STATE", "durable launch requires a projection coordinate");
-    }
-    const launchOwnership = acquireRunnerLease(projectionRunnerLeasePath(projection.dir));
-    const launched = await startProjectionGeneration(projection.dir, projection.executionId, {
-        commitLaunch: () => {
-            const store = openProjectionGenerationStore(projection.dir);
-            try {
-                return store.launchIfSettled({ executionId: projection.executionId, facts: launchFacts }).status === "committed";
-            }
-            finally {
-                store.close();
-            }
-        },
-        launchOwnership,
-        adoptionTimeoutMs,
-    });
-    launchOwnership.close();
-    if (launched.status !== "adopted") {
-        throw new FlowError("SUBAGENT_EXEC_ERROR", launched.status === "pending"
-            ? "runner retained startup ownership without adopting before the bounded launch wait"
-            : launched.detail);
-    }
-    return { projection, launchSnapshot };
-}
-export async function buildCallConfig(agentName, prompt, cwd, options) {
-    const launchSnapshot = options.launchSnapshot ?? resolveAkumaLaunchSnapshot(await selectSubagent(agentName, cwd), {
-        executionCwd: cwd,
-        projectRoot: cwd,
-        ...(options.model !== undefined ? { model: options.model } : {}),
-        ...(options.effort !== undefined ? { effort: options.effort } : {}),
-    });
-    const resolvedTerms = buildCallTerms(launchSnapshot, prompt, cwd, {
-        signal: options.signal,
-        idleTimeoutMs: options.idleTimeoutMs,
-        carrier: options.carrier,
-    });
-    // Mint projection directory for supervisor pump.
-    const slug = launchSnapshot.akuma.name;
-    const publishProjection = async () => {
-        const mintInput = {
-            cwd: options.projectionCwd ?? cwd,
-            workspaceRoot: cwd,
-            slug,
-            pid: process.pid,
-            akuma: launchSnapshot.akuma.name,
-            provider: launchSnapshot.provider.kind,
-            binding: options.binding,
-            effectivePolicy: launchSnapshot.akuma.policy,
-            nowMs: Date.now(),
-        };
-        const minted = options.authority.kind === "repository"
-            ? await mintRepositoryProjection({ ...mintInput, authority: { kind: "repository" } })
-            : await mintProjection({ ...mintInput, authority: { kind: "user" } });
-        const executionId = createProjectionExecutionId();
-        const launchFacts = JSON.parse(JSON.stringify({
-            executionId,
-            createdAt: new Date().toISOString(),
-            launchedBy: "call",
-            inputs: {
-                prompt,
-                task: options.task ?? prompt,
-                launchSnapshot,
-                idleTimeoutMs: resolvedTerms.idleTimeoutMs,
-                executionTimeoutMs: resolvedTerms.executionTimeoutMs,
-                cwd,
-                historyCwd: options.historyStorageCwd ?? cwd,
-                ...(options.evidenceCwd !== undefined ? { evidenceCwd: options.evidenceCwd } : {}),
-                ...(options.title !== undefined ? { title: options.title } : {}),
-                ...(options.context !== undefined ? { context: options.context } : {}),
-                ...(options.carrier !== undefined ? { carrier: options.carrier } : {}),
-                persistProjectionResponse: options.persistProjectionResponse ?? false,
-                ...(options.continuation ? {
-                    session: options.continuation.session,
-                    resumePath: options.continuation.resumePath,
-                    sourceArtifactId: options.continuation.sourceArtifactId,
-                } : {}),
-            },
-        }));
-        const previousAliasTarget = options.alias === undefined
-            ? undefined
-            : await moveProjectionAlias(options.projectionCwd ?? cwd, assertProjectionAlias(options.alias), minted.id);
-        let previousAliasTargetStillRunning;
-        if (previousAliasTarget !== undefined) {
-            try {
-                const phase = observeProjectionLife(await projectionDir(options.projectionCwd ?? cwd, previousAliasTarget), { nowMs: Date.now() }).phase;
-                if (phase === "minting" || phase === "active" || phase === "quiescent") {
-                    previousAliasTargetStillRunning = previousAliasTarget;
-                }
-            }
-            catch {
-                previousAliasTargetStillRunning = undefined;
-            }
-        }
-        return {
-            id: minted.id,
-            dir: minted.dir,
-            executionId,
-            launchFacts,
-            ...(options.alias ? { alias: options.alias } : {}),
-            ...(previousAliasTargetStillRunning ? { previousAliasTarget: previousAliasTargetStillRunning } : {}),
-        };
-    };
-    // Every public launch has one durable projection object. Repository-free
-    // authority changes the storage owner, not whether the object exists; mint
-    // failure is therefore a launch failure rather than an in-process fallback.
-    const { launchFacts, ...projectionCoordinate } = await publishProjection();
-    return {
-        projection: projectionCoordinate,
-        launchSnapshot,
-        launchFacts,
-    };
-}

package/build/core/call/prompt.js

@@ -1,27 +0,0 @@
-import { ACTOR_IDENTITY } from "../../keiyaku.js";
-const COMMISSIONED_DELIVERY_BOUNDARY = [
-    "Delivery boundary: edit and test only inside this linked contract worktree.",
-    "Leave source changes uncommitted as a dirty working tree, then report changed files and verification run results.",
-    "Do not run git add, git commit, or any command that writes Git metadata. A refused Git metadata write is not a failed delivery.",
-    "The host coordinator reviews and commits accepted bytes, then continues arc, renew, or petition settlement.",
-].join(" ");
-export function buildCallPrompt(input) {
-    const references = [...new Set((input.referenceFiles ?? []).map((file) => file.trim()).filter(Boolean))];
-    if (!input.commissioned) {
-        return [
-            input.task,
-            input.context?.trim() ?? "",
-            references.length > 0 ? `Reference files:\n${references.map((file) => `- ${file}`).join("\n")}` : "",
-        ].filter(Boolean).join("\n\n");
-    }
-    return [
-        `You are a called ${ACTOR_IDENTITY} working in the commissioned contract worktree.`,
-        input.worktree ? `Worktree: ${input.worktree}` : "",
-        "Before work, read .keiyaku/KEIYAKU.md. It is the sole contract body for this dispatch.",
-        COMMISSIONED_DELIVERY_BOUNDARY,
-        `Task:\n${input.task}`,
-        input.context?.trim() ? `Context:\n${input.context.trim()}` : "",
-        references.length > 0 ? `Reference files:\n${references.map((file) => `- ${file}`).join("\n")}` : "",
-        "Provide the final result for the caller/main agent.",
-    ].filter(Boolean).join("\n\n");
-}

package/build/core/call/reference.js

@@ -1,24 +0,0 @@
-import * as fs from "fs/promises";
-import * as path from "path";
-import { isErrnoException } from "../../errno.js";
-import { BASE_RULES_FILE, KEIYAKU_FILE } from "../../keiyaku.js";
-async function fileExists(cwd, relativePath) {
-    try {
-        await fs.access(path.join(cwd, relativePath));
-        return true;
-    }
-    catch (error) {
-        if (isErrnoException(error) && error.code === "ENOENT") {
-            return false;
-        }
-        throw error;
-    }
-}
-export async function collectCallReferenceFiles(cwd, input) {
-    const candidates = [
-        ...(input.activeKeiyaku ? [KEIYAKU_FILE] : []),
-        BASE_RULES_FILE,
-    ];
-    const existing = await Promise.all(candidates.map(async (file) => ({ file, exists: await fileExists(cwd, file) })));
-    return existing.filter((entry) => entry.exists).map((entry) => entry.file);
-}

package/build/core/call-persist.js

@@ -1,76 +0,0 @@
-import { appendDebugLog } from "../telemetry/debug-log.js";
-import { logWarn } from "../telemetry/logger.js";
-import { runCall } from "./call/call.js";
-import { persistResponseHistory } from "./transcripts.js";
-import { assertGitObservation, observeGitRepository } from "../git/branches.js";
-import { FlowError } from "../flow-error.js";
-import * as path from "node:path";
-import * as fs from "node:fs/promises";
-import { stableRepoRoot } from "./worktree-path.js";
-function responsePathFromPrintingCwd(historyStorageCwd, responsePath) {
-    const printingCwd = process.cwd();
-    const absoluteHistoryCwd = path.resolve(printingCwd, historyStorageCwd);
-    return path.relative(printingCwd, path.resolve(absoluteHistoryCwd, responsePath));
-}
-export async function runCallAndPersist(input) {
-    const historyCandidate = input.repo ?? input.cwd;
-    const canonicalHistoryCandidate = await fs.realpath(historyCandidate);
-    const historyObservation = await observeGitRepository(historyCandidate);
-    if (input.repo && assertGitObservation(historyObservation, `${input.mode ?? "call"} --repo`) === "non-repository") {
-        throw new FlowError("NOT_GIT_REPO", `${historyCandidate} is not a git repository`);
-    }
-    if (historyObservation.capability === "unknown")
-        throw historyObservation.error;
-    const historyStorageCwd = (historyObservation.capability === "available" && historyObservation.coordinate === "repository")
-        ? await stableRepoRoot(historyCandidate)
-        : canonicalHistoryCandidate;
-    const historyDisplayCwd = path.resolve(historyCandidate, path.relative(canonicalHistoryCandidate, historyStorageCwd));
-    const result = await runCall(input);
-    if (input.incognito) {
-        return { result };
-    }
-    if (result.projectionOwnsResponsePersistence === true) {
-        return {
-            result,
-            ...(result.responsePath ? { responsePath: responsePathFromPrintingCwd(historyDisplayCwd, result.responsePath) } : {}),
-            ...(result.artifactId ? { artifactId: result.artifactId } : {}),
-        };
-    }
-    let responsePath;
-    let artifactId;
-    try {
-        if (!result.evidenceCwd)
-            throw new Error("call response persistence is missing evidenceCwd");
-        const authority = result.address.repo.kind === "repository"
-            ? { kind: "repository" }
-            : { kind: "user" };
-        const persisted = await persistResponseHistory({
-            cwd: historyStorageCwd,
-            tool: "call",
-            provenance: { authority, binding: result.address.binding, evidenceCwd: result.evidenceCwd },
-            title: input.title,
-            task: input.task,
-            context: input.context,
-            response: result.summary,
-            session: result.session,
-            subagentName: result.agent,
-            launchSnapshot: result.launchSnapshot,
-            effectivePolicy: result.meta?.effectivePolicy,
-        });
-        responsePath = persisted.responsePath;
-        artifactId = persisted.artifactId;
-    }
-    catch (historyError) {
-        const historyErrorMessage = historyError instanceof Error ? historyError.message : String(historyError);
-        logWarn(`Failed to persist call response: ${historyErrorMessage}`, { cwd: historyStorageCwd, section: "script" });
-        appendDebugLog(`tool call response persistence failed: ${historyErrorMessage}`, {
-            cwd: historyStorageCwd,
-            section: "script",
-        });
-    }
-    return {
-        result: artifactId ? { ...result, artifactId } : result,
-        ...(responsePath ? { responsePath: responsePathFromPrintingCwd(historyDisplayCwd, responsePath) } : {}),
-        ...(artifactId ? { artifactId } : {}),
-    };
-}

package/build/core/command-markdown.js

@@ -1,45 +0,0 @@
-import { FlowError } from "../flow-error.js";
-import { parseMarkdownListSection, parseMarkdownStructure } from "./markdown/sections.js";
-import { KeiyakuParseError } from "./markdown/types.js";
-import { normalizeSectionTitle } from "./markdown/titles.js";
-export function parseCommandMarkdown(content) {
-    try {
-        const parsed = parseMarkdownStructure(content);
-        const sections = new Map();
-        for (const [key, lines] of parsed.sections.entries()) {
-            sections.set(key, lines.join("\n").trim());
-        }
-        return { title: parsed.title, sections };
-    }
-    catch (error) {
-        if (error instanceof KeiyakuParseError) {
-            throw new FlowError("INVALID_KEIYAKU_DRAFT", error.message, { cause: error });
-        }
-        throw error;
-    }
-}
-export function requireMarkdownTextSection(parts, name) {
-    const normalized = normalizeSectionTitle(name);
-    const value = parts.sections.get(normalized)?.trim();
-    if (!value) {
-        throw new FlowError("INVALID_KEIYAKU_DRAFT", `missing required section: ## ${name}`);
-    }
-    return value;
-}
-export function requireMarkdownListSection(parts, name) {
-    const text = requireMarkdownTextSection(parts, name);
-    const items = parseMarkdownListSection(text)
-        .map((item) => item.trim())
-        .filter((item) => item.length > 0);
-    if (items.length === 0) {
-        throw new FlowError("INVALID_KEIYAKU_DRAFT", `missing required section: ## ${name}`);
-    }
-    return items;
-}
-export function requireMarkdownTitle(parts) {
-    const title = parts.title?.trim();
-    if (!title) {
-        throw new FlowError("INVALID_KEIYAKU_DRAFT", "missing required title: # Title");
-    }
-    return title;
-}

package/build/core/context.js

@@ -1,104 +0,0 @@
-import { KEIYAKU_BRANCH_PREFIX } from "../keiyaku.js";
-import { FlowError } from "../flow-error.js";
-import { createGit, errorContainsAnyPattern, MISSING_HEAD_PATTERNS, NOT_GIT_REPOSITORY_PATTERNS, wrapGitError } from "../git/core.js";
-import { getCurrentBranch, listLocalBranches } from "../git/branches.js";
-import { lookupCurrentContract, readRepositoryLifecycle, } from "./repository-ledger/read-model.js";
-import { currentContractBoundByWorktreeWitness, stableRepoRoot } from "./worktree-path.js";
-import { contractReadOutcomeError } from "./addressing.js";
-import { admitRepositoryLifecycleContract } from "./repository-ledger/admission.js";
-function isOperableContract(model) {
-    return model.phase !== "claimed" && model.phase !== "forfeited";
-}
-function operableContracts(read) {
-    return read.contracts.filter((model) => lookupCurrentContract(read, model.contract).status === "healthy" && isOperableContract(model));
-}
-function potentiallyOperableContracts(read) {
-    return read.contracts.filter(isOperableContract);
-}
-function admitOperableContractId(read, contractId) {
-    const outcome = admitRepositoryLifecycleContract(read, contractId);
-    if (outcome.status === "healthy")
-        return isOperableContract(outcome.model);
-    if (outcome.status === "absent")
-        return false;
-    throw contractReadOutcomeError(contractId, outcome);
-}
-export async function operableContractIds(cwd) {
-    const read = await readRepositoryLifecycle(cwd);
-    return operableContracts(read).map((model) => model.contract);
-}
-async function resolveImplicitCurrentContractIdFromRead(cwd, read) {
-    // Prefer the verified engine-worktree binding (same tier as existing-commission verbs).
-    try {
-        const stableRoot = await stableRepoRoot(cwd);
-        const bound = await currentContractBoundByWorktreeWitness({
-            cwd,
-            stableRoot,
-            contracts: potentiallyOperableContracts(read),
-        });
-        if (bound && admitOperableContractId(read, bound))
-            return bound;
-    }
-    catch (error) {
-        if (!errorContainsAnyPattern(error, NOT_GIT_REPOSITORY_PATTERNS))
-            throw error;
-    }
-    // Branch remains a residual signal for workspace:here checkouts without an engine worktree.
-    const git = createGit(cwd);
-    try {
-        const branch = (await git.raw(["branch", "--show-current"])).trim();
-        if (branch.startsWith("keiyaku/")) {
-            const id = branch.slice("keiyaku/".length);
-            const outcome = lookupCurrentContract(read, id);
-            if ((outcome.status === "healthy" || outcome.status === "diseased") &&
-                outcome.model.resources.worktree === null &&
-                admitOperableContractId(read, id))
-                return id;
-        }
-    }
-    catch (error) {
-        if (!errorContainsAnyPattern(error, MISSING_HEAD_PATTERNS)) {
-            throw wrapGitError("branch --show-current", error, cwd);
-        }
-    }
-    return undefined;
-}
-export async function resolveImplicitCurrentContractId(cwd) {
-    return resolveImplicitCurrentContractIdFromRead(cwd, await readRepositoryLifecycle(cwd));
-}
-async function resolveCurrentContractIdFromRead(cwd, read) {
-    const current = await resolveImplicitCurrentContractIdFromRead(cwd, read);
-    if (current)
-        return { status: "one", contractId: current };
-    const operable = operableContracts(read).map((model) => model.contract).sort();
-    if (operable.length === 0)
-        return { status: "none" };
-    if (operable.length === 1)
-        return { status: "one", contractId: operable[0] };
-    throw new FlowError("CONTRACT_AMBIGUOUS", `multiple active contracts found: ${operable.join(", ")}`);
-}
-export async function resolveCurrentContractId(cwd) {
-    return resolveCurrentContractIdFromRead(cwd, await readRepositoryLifecycle(cwd));
-}
-export async function listLocalKeiyakuBranches(cwd) {
-    return (await listLocalBranches(cwd)).filter((name) => name.startsWith(KEIYAKU_BRANCH_PREFIX));
-}
-export async function readCurrentContractContext(cwd) {
-    const read = await readRepositoryLifecycle(cwd);
-    const resolution = await resolveCurrentContractIdFromRead(cwd, read);
-    if (resolution.status === "none")
-        throw new FlowError("EMPTY_PARAM", "no active contract found");
-    const contractId = resolution.contractId;
-    const outcome = lookupCurrentContract(read, contractId);
-    if (outcome.status !== "healthy" || !isOperableContract(outcome.model)) {
-        throw new FlowError("INTERNAL_STATE", `contract ${contractId} not found or not active`);
-    }
-    const currentBranch = await getCurrentBranch(cwd);
-    const baseBranch = outcome.model.pins.target.ref.slice("refs/heads/".length);
-    return {
-        contractId,
-        currentBranch,
-        baseBranch,
-        base: outcome.model.pins.base,
-    };
-}