@astrosheep/keiyaku 1.0.0 → 1.0.2

package/build/core/summon-persist.js

@@ -1,73 +0,0 @@
-import { isFlowError } from "../flow-error.js";
-import { appendDebugLog } from "../telemetry/debug-log.js";
-import { logWarn } from "../telemetry/logger.js";
-import { runSummon } from "./summon.js";
-import { persistResponseHistory } from "./transcripts.js";
-import { getCurrentBranch } from "../git/branches.js";
-import { MISSING_HEAD_PATTERNS, NOT_GIT_REPOSITORY_PATTERNS, errorContainsAnyPattern } from "../git/core.js";
-import { getLatestCommitHash } from "../git/staging.js";
-import { isErrnoException } from "../errno.js";
-function isMissingPathError(error) {
-    return isErrnoException(error) && error.code === "ENOENT";
-}
-function isBenignHistoryBranchLookupError(error) {
-    return ((isFlowError(error) && error.code === "DETACHED_HEAD") ||
-        isMissingPathError(error) ||
-        errorContainsAnyPattern(error, NOT_GIT_REPOSITORY_PATTERNS));
-}
-function isBenignHistoryCommitLookupError(error) {
-    return (isMissingPathError(error) ||
-        errorContainsAnyPattern(error, NOT_GIT_REPOSITORY_PATTERNS) ||
-        errorContainsAnyPattern(error, MISSING_HEAD_PATTERNS));
-}
-export async function runSummonAndPersist(input) {
-    const result = await runSummon(input);
-    if (input.incognito) {
-        return { result };
-    }
-    let responsePath;
-    let historyBranch;
-    try {
-        historyBranch = await getCurrentBranch(input.cwd);
-    }
-    catch (error) {
-        if (!isBenignHistoryBranchLookupError(error)) {
-            throw error;
-        }
-        historyBranch = undefined;
-    }
-    let commitHash;
-    try {
-        commitHash = await getLatestCommitHash(input.cwd);
-    }
-    catch (error) {
-        if (!isBenignHistoryCommitLookupError(error)) {
-            throw error;
-        }
-        commitHash = undefined;
-    }
-    try {
-        responsePath = await persistResponseHistory({
-            cwd: input.cwd,
-            tool: "summon",
-            title: input.title,
-            task: input.task,
-            context: input.context,
-            response: result.summary,
-            session: result.session,
-            subagentName: result.agent,
-            branch: historyBranch,
-            commit: commitHash,
-            effectivePolicy: result.meta?.effectivePolicy,
-        });
-    }
-    catch (historyError) {
-        const historyErrorMessage = historyError instanceof Error ? historyError.message : String(historyError);
-        logWarn(`Failed to persist summon response: ${historyErrorMessage}`, { cwd: input.cwd, section: "script" });
-        appendDebugLog(`tool summon response persistence failed: ${historyErrorMessage}`, {
-            cwd: input.cwd,
-            section: "script",
-        });
-    }
-    return { result, responsePath };
-}

package/build/core/summon.js

@@ -1,377 +0,0 @@
-import * as fs from "fs/promises";
-import * as path from "path";
-import { ACTOR_IDENTITY, BASE_RULES_FILE, KEIYAKU_FILE, isSubagentProvider } from "../keiyaku.js";
-import { isErrnoException } from "../errno.js";
-import { FlowError, requireText } from "../flow-error.js";
-import { isGitRepo } from "../git/branches.js";
-import { createGit, wrapGitError } from "../git/core.js";
-import { selectSubagent } from "../agents/selector.js";
-import { buildSummonTerms, createAbortError } from "../agents/index.js";
-import { resolveEffectiveCodexSdkProfile } from "../agents/effective-policy.js";
-import { resume, summon } from "../agents/harness/index.js";
-import { mintProjection } from "./projection-mint.js";
-import { createProjectionExecutionId, latestGenerationLaunch, publishGenerationLaunch, publishGenerationResult, publishVerdict, readAdmissionLock, releaseAdmissionLockOwned } from "./projection-core.js";
-import { CODEX_MODEL_REASONING_EFFORT_CONFIG_KEY } from "../keiyaku.js";
-import { initializeConfig } from "../config/env.js";
-import { resolveSummonResumePath } from "./transcripts.js";
-import { appendDebugBlock } from "../telemetry/debug-log.js";
-import { logInfo } from "../telemetry/logger.js";
-import { SubagentFailure } from "../agents/types.js";
-import { resolveCurrentContractId } from "./context.js";
-import { readLedger } from "./ledger.js";
-import { findOpenArcView } from "./arc.js";
-import { deriveContractState } from "./status.js";
-import { contractWorktreePathFromBind } from "./worktree-path.js";
-export function buildSummonPrompt(input) {
-    const references = [...new Set((input.referenceFiles ?? []).map((file) => file.trim()).filter(Boolean))];
-    if (!input.arc) {
-        return [input.task, input.context?.trim() ?? "", references.length > 0 ? `Reference files:\n${references.map((file) => `- ${file}`).join("\n")}` : ""]
-            .filter(Boolean)
-            .join("\n\n");
-    }
-    const arc = input.arc;
-    return [
-        `You are a summoned ${ACTOR_IDENTITY} working inside open arc a${arc.arc}.`,
-        "Stay within the arc scope and do the requested work directly.",
-        `Title: ${arc.title}`,
-        `Objective: ${arc.objective}`,
-        `Brief:\n${arc.brief}`,
-        "",
-        `Task:\n${input.task}`,
-        `Context:\n${input.context?.trim() || "(none provided)"}`,
-        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");
-}
-function renderSubagentWarning(warning) {
-    const modelTransition = warning.originalModel && warning.fallbackModel
-        ? `${warning.originalModel} -> ${warning.fallbackModel}`
-        : warning.originalModel ?? warning.fallbackModel;
-    const details = [
-        modelTransition,
-        warning.direction ? `direction=${warning.direction}` : undefined,
-        warning.requestId !== undefined ? `requestId=${warning.requestId ?? "null"}` : undefined,
-        warning.signerModel ? `signerModel=${warning.signerModel}` : undefined,
-    ].filter((value) => Boolean(value));
-    const summary = warning.reason === "refusal" ? "Provider warning: model fallback." : "Provider warning: overload fallback.";
-    return details.length > 0 ? `${summary} ${details.join(", ")}` : summary;
-}
-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;
-    }
-}
-async function collectSummonReferenceFiles(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);
-}
-async function findWorktreePathForContract(cwd, contractId) {
-    const git = createGit(cwd);
-    let output;
-    try {
-        output = await git.raw(["worktree", "list", "--porcelain"]);
-    }
-    catch (error) {
-        throw wrapGitError("worktree list --porcelain", error, cwd);
-    }
-    let currentPath;
-    for (const line of output.split(/\r?\n/)) {
-        if (line.startsWith("worktree ")) {
-            currentPath = line.slice("worktree ".length);
-            continue;
-        }
-        if (line === `branch refs/heads/keiyaku/${contractId}`) {
-            return currentPath;
-        }
-    }
-    return undefined;
-}
-async function resolveWorkspaceCwd(cwd, contractId, bind) {
-    const repoRoot = cwd;
-    if (bind.data.workspace === "here")
-        return repoRoot;
-    const listedWorktreePath = await findWorktreePathForContract(cwd, contractId);
-    const worktreePath = listedWorktreePath ?? await contractWorktreePathFromBind(repoRoot, contractId, bind);
-    let stat;
-    try {
-        stat = await fs.stat(worktreePath);
-    }
-    catch (error) {
-        throw new FlowError("INTERNAL_STATE", `contract ${contractId} worktree not found at ${worktreePath}`, { cause: error });
-    }
-    if (!stat.isDirectory()) {
-        throw new FlowError("INTERNAL_STATE", `contract ${contractId} worktree path is not a directory: ${worktreePath}`);
-    }
-    return worktreePath;
-}
-async function readSummonKeiyakuContext(cwd, bare = false) {
-    if (bare)
-        return { activeKeiyaku: false, effectiveCwd: cwd };
-    const isRepo = await isGitRepo(cwd);
-    if (!isRepo) {
-        return { activeKeiyaku: false, effectiveCwd: cwd };
-    }
-    const resolution = await resolveCurrentContractId(cwd);
-    if (resolution.status === "none")
-        return { activeKeiyaku: false, effectiveCwd: cwd };
-    const contractId = resolution.contractId;
-    const ledger = await readLedger(cwd, contractId);
-    if (!ledger) {
-        throw new FlowError("INTERNAL_STATE", `contract ${contractId} not found or not active`);
-    }
-    const state = deriveContractState(ledger.entries);
-    if (state.state === "corrupt") {
-        throw new FlowError("INTERNAL_STATE", `contract ${contractId} is corrupt at entry ${state.at}: ${state.reason}`);
-    }
-    const bind = ledger.entries.find((entry) => entry.kind === "bind");
-    if (!bind) {
-        throw new FlowError("INTERNAL_STATE", `contract ${contractId} active ledger is missing bind entry`);
-    }
-    const effectiveCwd = await resolveWorkspaceCwd(cwd, contractId, bind);
-    const openArc = findOpenArcView(ledger.entries);
-    return {
-        activeKeiyaku: true,
-        effectiveCwd,
-        openArc: openArc ?? undefined,
-    };
-}
-export async function execSubagent(agentName, prompt, cwd, options = {}) {
-    const config = await buildSummonConfig(agentName, prompt, cwd, options);
-    const projection = options.resume
-        ? resume({
-            ...config,
-            session: options.resume.session,
-            resumePath: options.resume.resumePath,
-        })
-        : summon(config);
-    const outcome = await projection.outcome;
-    switch (outcome.status) {
-        case "completed":
-            return outcome;
-        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.");
-}
-async function buildSummonConfig(agentName, prompt, cwd, options) {
-    const selected = options.selected ?? await selectSubagent(agentName, cwd);
-    const withModel = options.model ? { ...selected.profile, model: options.model } : selected.profile;
-    if (selected.profile.provider !== "codex-sdk" && (selected.profile.accessPolicy !== undefined || selected.profile.networkPolicy !== undefined || selected.profile.webSearchPolicy !== undefined)) {
-        throw new FlowError("UNSUPPORTED_POLICY", `Provider '${selected.profile.provider}' does not support Akuma policy fields.`);
-    }
-    const effectiveProfile = options.config && (selected.profile.provider === "codex-sdk" || selected.profile.provider === "codex-app-server")
-        ? { ...withModel, config: options.config }
-        : withModel;
-    if (options.effort && effectiveProfile.provider === "opencode-sdk") {
-        throw new FlowError("UNSUPPORTED_EFFORT_OVERRIDE", `Provider 'opencode-sdk' does not support effort override '${options.effort}'.`);
-    }
-    const effortProfile = options.effort
-        ? effectiveProfile.provider === "claude-agent-sdk"
-            ? { ...effectiveProfile, effort: options.effort }
-            : effectiveProfile.provider === "codex-sdk"
-                ? { ...effectiveProfile, effort: options.effort }
-                : effectiveProfile.provider === "codex-app-server"
-                    ? { ...effectiveProfile, config: { ...(effectiveProfile.config ?? {}), [CODEX_MODEL_REASONING_EFFORT_CONFIG_KEY]: options.effort } }
-                    : effectiveProfile.provider === "pi"
-                        ? { ...effectiveProfile, thinkingLevel: options.effort === "max" ? "xhigh" : options.effort }
-                        : effectiveProfile
-        : effectiveProfile;
-    const resolvedProfile = effortProfile.provider === "codex-sdk"
-        ? resolveEffectiveCodexSdkProfile(effectiveProfile, cwd, {
-            ...(options.model ? { model: options.model } : {}),
-            ...(options.effort ? { effort: options.effort } : {}),
-        })
-        : effortProfile;
-    // Mint projection directory for supervisor pump.
-    const slug = agentName.replace(/[^a-zA-Z0-9_-]/g, "-").toLowerCase();
-    let mintedDir;
-    let projectionExecutionId;
-    try {
-        const minted = mintProjection({
-            cwd,
-            slug,
-            pid: process.pid,
-            akuma: agentName,
-            provider: resolvedProfile.provider,
-            ...(resolvedProfile.provider === "codex-sdk" ? { effectivePolicy: resolvedProfile.effectivePolicy } : {}),
-            nowMs: Date.now(),
-        });
-        mintedDir = minted.dir;
-        projectionExecutionId = createProjectionExecutionId();
-        publishGenerationLaunch(mintedDir, {
-            version: 1,
-            executionId: projectionExecutionId,
-            createdAt: new Date().toISOString(),
-            launchedBy: "summon",
-            inputs: {
-                prompt,
-                task: options.task ?? prompt,
-                model: resolvedProfile.model,
-                profile: agentName,
-                // This is the immutable provider/profile snapshot. The wake path must
-                // not be changed by later catalog or settings edits.
-                profileData: resolvedProfile,
-                cwd,
-                akumaBody: selected.definition.body,
-                ...(resolvedProfile.provider === "codex-sdk" || resolvedProfile.provider === "codex-app-server" ? { config: resolvedProfile.config } : {}),
-            },
-        });
-    }
-    catch {
-        // If minting fails (e.g., EACCES), continue without supervisor.
-    }
-    return buildSummonTerms(resolvedProfile, prompt, cwd, {
-        signal: options.signal,
-        timeoutMs: options.timeoutMs,
-        idleTimeoutMs: options.idleTimeoutMs,
-        projectionDir: mintedDir,
-        projectionExecutionId,
-        // Selection is rooted in this canonical execution cwd, so the selected body is too.
-        akumaBody: selected.definition.body,
-    });
-}
-/** Internal wake entrypoint: reconstruct one persisted generation in its original projection. */
-export async function runProjectionGeneration(projectionDirectory) {
-    const launch = latestGenerationLaunch(projectionDirectory);
-    if (!launch)
-        throw new FlowError("INTERNAL_STATE", "projection has no generation launch record");
-    const executionId = launch.executionId;
-    try {
-        const input = launch.inputs;
-        const profile = typeof input.profile === "string" ? input.profile : undefined;
-        const prompt = typeof input.prompt === "string" ? input.prompt : undefined;
-        const cwd = typeof input.cwd === "string" ? input.cwd : undefined;
-        if (!profile || !prompt || !cwd)
-            throw new FlowError("INTERNAL_STATE", "generation launch is missing profile, prompt, or cwd");
-        // Hidden wake must recreate the exact runtime environment before term construction.
-        initializeConfig(process.env, cwd);
-        const durableProfile = input.profileData && typeof input.profileData === "object" && !Array.isArray(input.profileData)
-            ? input.profileData
-            : undefined;
-        const durableBody = typeof input.akumaBody === "string" ? input.akumaBody : undefined;
-        let effective;
-        let akumaBody;
-        if (durableProfile && durableBody !== undefined) {
-            if (typeof durableProfile.provider !== "string" || !isSubagentProvider(durableProfile.provider)) {
-                throw new FlowError("INTERNAL_STATE", "generation launch immutable profileData has an invalid provider");
-            }
-            effective = durableProfile;
-            akumaBody = durableBody;
-        }
-        else {
-            // Compatibility only for legacy launches that predate the complete immutable snapshot.
-            const selected = await selectSubagent(profile, cwd);
-            const model = typeof input.model === "string" ? input.model : undefined;
-            const withModel = model ? { ...selected.profile, model } : selected.profile;
-            const config = input.config && typeof input.config === "object" && !Array.isArray(input.config)
-                ? input.config
-                : undefined;
-            effective = config && (withModel.provider === "codex-sdk" || withModel.provider === "codex-app-server")
-                ? { ...withModel, config }
-                : withModel;
-            akumaBody = durableBody ?? selected.definition.body;
-        }
-        const terms = buildSummonTerms(effective, prompt, cwd, {
-            projectionDir: projectionDirectory,
-            projectionExecutionId: executionId,
-            akumaBody,
-        });
-        const session = input.session;
-        const resumePath = typeof input.resumePath === "string" ? input.resumePath : undefined;
-        const projection = session && resumePath
-            ? resume({ ...terms, session: session, resumePath })
-            : summon(terms);
-        await projection.outcome;
-    }
-    catch (error) {
-        const detail = error instanceof Error ? error.message : String(error);
-        // A child that failed to acquire admission must be entirely silent: it may
-        // be a duplicate wake and cannot publish over the winner's ledger.
-        const admission = readAdmissionLock(projectionDirectory);
-        if (admission?.executionId === executionId) {
-            publishGenerationResult(projectionDirectory, {
-                version: 1,
-                executionId,
-                status: "failed",
-                createdAt: new Date().toISOString(),
-                detail,
-            });
-            publishVerdict(projectionDirectory, "failed", Date.now(), detail);
-            releaseAdmissionLockOwned(projectionDirectory, executionId);
-        }
-        throw error;
-    }
-}
-export async function runSummon(input) {
-    const { signal, agent, resumePath } = input;
-    const rawCwd = input.cwd;
-    const cwd = await fs.realpath(rawCwd);
-    requireText("title", input.title);
-    const task = requireText("task", input.task);
-    if (input.incognito && resumePath) {
-        throw new FlowError("EMPTY_PARAM", "Parameter 'incognito' cannot be used with 'resumePath' — incognito summons do not resume or persist conversation history.");
-    }
-    const keiyakuContext = await readSummonKeiyakuContext(cwd, input.bare);
-    const executionCwd = keiyakuContext.effectiveCwd;
-    const referenceFiles = await collectSummonReferenceFiles(executionCwd, keiyakuContext);
-    const prompt = buildSummonPrompt({
-        task,
-        context: input.context,
-        referenceFiles,
-        arc: keiyakuContext.openArc,
-    });
-    const resumePathResolution = resumePath ? await resolveSummonResumePath({ cwd: rawCwd, resumePath }) : undefined;
-    const selectedSubagent = resumePathResolution
-        ? await selectSubagent(resumePathResolution.subagentName, executionCwd)
-        : await selectSubagent(agent, executionCwd);
-    const resume = resumePath && resumePathResolution
-        ? { ...resumePathResolution, resumePath }
-        : undefined;
-    logInfo(`[${ACTOR_IDENTITY}] Running execution for '${selectedSubagent.name}' in ${executionCwd}`, {
-        cwd: executionCwd,
-        section: "script",
-        progressOnly: true,
-    });
-    const subagentOutcome = await execSubagent(selectedSubagent.name, prompt, executionCwd, {
-        signal,
-        resume,
-        model: input.model,
-        effort: input.effort,
-        task,
-        selected: selectedSubagent,
-    });
-    if (subagentOutcome.diagnostics.trim()) {
-        appendDebugBlock("subagent diagnostics", subagentOutcome.diagnostics, { cwd: executionCwd, section: "subagent-stderr" });
-    }
-    return {
-        summary: subagentOutcome.finalMessage || `${ACTOR_IDENTITY} completed successfully.`,
-        agent: selectedSubagent.name,
-        session: subagentOutcome.session,
-        ...(subagentOutcome.warnings.length > 0 || subagentOutcome.effectivePolicy ? { meta: { ...(subagentOutcome.warnings.length > 0 ? { warnings: subagentOutcome.warnings.map(renderSubagentWarning) } : {}), ...(subagentOutcome.effectivePolicy ? { effectivePolicy: subagentOutcome.effectivePolicy } : {}) } } : {}),
-    };
-}