@astrosheep/keiyaku 2.9.13 → 4.0.0

package/build/core/call/call.js

@@ -1,235 +0,0 @@
-import * as fs from "fs/promises";
-import { selectSubagent } from "../../agents/selector.js";
-import { applySnapshotEffort } from "../../agents/launch-snapshot/model.js";
-import { resolveAkumaLaunchSnapshot } from "../../agents/launch-snapshot/resolve.js";
-import { FlowError, requireText } from "../../flow-error.js";
-import { assertGitObservation, observeGitRepository } from "../../git/branches.js";
-import { ACTOR_IDENTITY } from "../../keiyaku.js";
-import { appendDebugBlock } from "../../telemetry/debug-log.js";
-import { logInfo } from "../../telemetry/logger.js";
-import { withResolvedAddress } from "../addressing.js";
-import { assertProjectionAlias, observeProjectionLife, waitForProjection, } from "../projection/index.js";
-import { normalizeFilesystemCoordinate } from "../../fs/path-coordinate.js";
-import { requireResumableArtifact } from "../transcripts.js";
-import { stableRepoRoot } from "../worktree-path.js";
-import { readCallKeiyakuContext } from "./context.js";
-import { executeSubagent, launchSubagentGeneration, } from "./execution.js";
-import { buildCallPrompt } from "./prompt.js";
-import { collectCallReferenceFiles } from "./reference.js";
-function renderSubagentWarning(warning) {
-    if (warning.reason === "retry") {
-        const status = warning.errorStatus === null ? "no response" : String(warning.errorStatus);
-        return `Provider warning: retry. attempt=${warning.attempt}, maxRetries=${warning.maxRetries}, retryDelayMs=${warning.retryDelayMs}, errorStatus=${status}`;
-    }
-    if (warning.reason === "rate-limit") {
-        return "Provider warning: rate limit exhausted.";
-    }
-    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;
-}
-export async function execSubagent(agentName, prompt, cwd, options) {
-    const { outcome } = await executeSubagent(agentName, prompt, cwd, options);
-    return outcome;
-}
-export async function runCall(input) {
-    const { signal, agent } = input;
-    const reviveArtifact = input.reviveArtifact ? requireResumableArtifact(input.reviveArtifact) : undefined;
-    let rawCwd = normalizeFilesystemCoordinate(input.cwd);
-    let rawRepo = input.repo === undefined ? undefined : normalizeFilesystemCoordinate(input.repo);
-    if (reviveArtifact?.provenance.authority.kind === "user") {
-        if (!("workdir" in reviveArtifact.provenance.evidence)) {
-            throw new FlowError("INVALID_RESPONSE_PATH", `Invalid response artifact '${reviveArtifact.artifactId}': field 'provenance.evidence.workdir' is missing.`);
-        }
-        rawCwd = normalizeFilesystemCoordinate(reviveArtifact.provenance.evidence.workdir);
-        rawRepo = undefined;
-    }
-    else if (reviveArtifact?.provenance.authority.kind === "repository") {
-        const artifactHome = await fs.realpath(reviveArtifact.storageRoot);
-        const addressed = normalizeFilesystemCoordinate(input.repo ?? input.cwd);
-        const observation = await observeGitRepository(addressed);
-        const coordinate = assertGitObservation(observation, "fork");
-        if (coordinate === "repository") {
-            const addressedRoot = await stableRepoRoot(addressed);
-            if (addressedRoot !== artifactHome) {
-                throw new FlowError("INVALID_RESPONSE_PATH", `Response artifact '${reviveArtifact.artifactId}' belongs to ${artifactHome}, but the addressed repository is ${addressedRoot}.`);
-            }
-        }
-        else {
-            throw new FlowError("NOT_GIT_REPO", `${addressed} is not a git repository`);
-        }
-        rawCwd = artifactHome;
-        rawRepo = artifactHome;
-    }
-    const cwd = await fs.realpath(rawCwd);
-    const repoCwd = rawRepo ? await fs.realpath(rawRepo) : undefined;
-    const title = requireText("title", input.title);
-    const task = requireText("task", input.task);
-    if (input.incognito && reviveArtifact) {
-        throw new FlowError("EMPTY_PARAM", "Parameter 'incognito' cannot be used with a fork source artifact — incognito calls cannot be forked or persist conversation history.");
-    }
-    const keiyakuContext = await readCallKeiyakuContext(cwd, {
-        bare: input.bare,
-        contractId: input.contractId,
-        contractAddressSource: input.contractAddressSource,
-        mode: input.mode ?? "call",
-        repoCwd,
-        reviveBinding: reviveArtifact?.provenance.binding,
-        signal: input.signal,
-    });
-    return await withResolvedAddress(keiyakuContext.address, async () => {
-        const executionCwd = keiyakuContext.effectiveCwd;
-        const referenceFiles = await collectCallReferenceFiles(executionCwd, keiyakuContext);
-        const prompt = buildCallPrompt({
-            task,
-            context: input.context,
-            referenceFiles,
-            commissioned: keiyakuContext.address.binding.kind === "commission",
-            worktree: keiyakuContext.effectiveCwd,
-        });
-        const launchSnapshot = reviveArtifact
-            ? input.effort !== undefined
-                ? applySnapshotEffort(reviveArtifact.launchSnapshot, input.effort)
-                : reviveArtifact.launchSnapshot
-            : resolveAkumaLaunchSnapshot(await selectSubagent(agent, keiyakuContext.profileCwd), {
-                executionCwd,
-                projectRoot: keiyakuContext.profileCwd,
-                ...(input.model !== undefined ? { model: input.model } : {}),
-                ...(input.effort !== undefined ? { effort: input.effort } : {}),
-            });
-        const continuation = reviveArtifact
-            ? {
-                session: reviveArtifact.session,
-                resumePath: reviveArtifact.absolutePath,
-                sourceArtifactId: reviveArtifact.artifactId,
-            }
-            : undefined;
-        logInfo(`[${ACTOR_IDENTITY}] Running execution for '${launchSnapshot.akuma.name}' in ${executionCwd}`, {
-            cwd: executionCwd,
-            section: "script",
-            progressOnly: true,
-        });
-        // Storage coordinate: addressed repository stable root / caller cwd.
-        // Evidence coordinate: commission worktree for bound runs; execution cwd otherwise.
-        const historyStorageCwd = keiyakuContext.historyCwd;
-        const evidenceCwd = executionCwd;
-        const executionOptions = {
-            signal,
-            continuation,
-            task,
-            launchSnapshot,
-            persistProjectionResponse: !input.incognito,
-            historyStorageCwd,
-            evidenceCwd,
-            projectionCwd: keiyakuContext.projectionCwd,
-            authority: keiyakuContext.address.repo.kind === "repository"
-                ? { kind: "repository" }
-                : { kind: "user" },
-            binding: keiyakuContext.address.binding,
-            carrier: keiyakuContext.carrier,
-            title,
-            context: input.context,
-            ...(input.mode === "call" && input.alias !== undefined ? { alias: assertProjectionAlias(input.alias) } : {}),
-        };
-        if ((input.mode ?? "call") === "call") {
-            const launched = await launchSubagentGeneration(launchSnapshot.akuma.name, prompt, executionCwd, executionOptions);
-            const adoptedProjection = {
-                id: launched.projection.id,
-                phase: observeProjectionLife(launched.projection.dir, {
-                    nowMs: Date.now(),
-                }).phase,
-                ...(launched.projection.alias ? { alias: launched.projection.alias } : {}),
-                ...(launched.projection.previousAliasTarget ? { previousAliasTarget: launched.projection.previousAliasTarget } : {}),
-            };
-            input.onLaunch?.({
-                address: keiyakuContext.address,
-                projection: adoptedProjection,
-                akumaName: launchSnapshot.akuma.name,
-            });
-            if (input.detach) {
-                return {
-                    state: "launched",
-                    summary: "",
-                    agent: launchSnapshot.akuma.name,
-                    launchSnapshot,
-                    projectionOwnsResponsePersistence: true,
-                    projection: adoptedProjection,
-                    address: keiyakuContext.address,
-                };
-            }
-            const joined = await waitForProjection({
-                projectionDirectory: launched.projection.dir,
-                signal,
-            });
-            if (joined.state !== "terminal") {
-                throw new FlowError("INTERNAL_STATE", "foreground call wait ended without a terminal projection verdict");
-            }
-            return {
-                state: "completed",
-                summary: joined.outcomeText || `${ACTOR_IDENTITY} completed successfully.`,
-                agent: launchSnapshot.akuma.name,
-                launchSnapshot,
-                ...(joined.snapshot.responsePath ? { responsePath: joined.snapshot.responsePath } : {}),
-                ...(joined.snapshot.artifactId ? { artifactId: joined.snapshot.artifactId } : {}),
-                projectionOwnsResponsePersistence: true,
-                meta: { effectivePolicy: launchSnapshot.akuma.policy },
-                projection: { id: launched.projection.id, phase: joined.snapshot.phase },
-                foregroundWait: joined,
-                address: keiyakuContext.address,
-            };
-        }
-        const execution = await executeSubagent(launchSnapshot.akuma.name, prompt, executionCwd, executionOptions);
-        const subagentOutcome = execution.outcome;
-        if (subagentOutcome.diagnostics.trim()) {
-            appendDebugBlock("subagent diagnostics", subagentOutcome.diagnostics, { cwd: executionCwd, section: "subagent-stderr" });
-        }
-        let projection;
-        let responsePath;
-        let artifactId;
-        if (execution.projection) {
-            responsePath = typeof execution.completionFacts?.responsePath === "string"
-                ? execution.completionFacts.responsePath
-                : undefined;
-            artifactId = typeof execution.completionFacts?.artifactId === "string"
-                ? execution.completionFacts.artifactId
-                : undefined;
-            try {
-                projection = {
-                    id: execution.projection.id,
-                    phase: observeProjectionLife(execution.projection.dir, {
-                        nowMs: Date.now(),
-                    }).phase,
-                };
-            }
-            catch {
-                // Projection observations are best-effort and must not reverse success.
-            }
-        }
-        return {
-            state: "completed",
-            summary: subagentOutcome.finalMessage || `${ACTOR_IDENTITY} completed successfully.`,
-            agent: launchSnapshot.akuma.name,
-            session: subagentOutcome.session,
-            launchSnapshot: subagentOutcome.launchSnapshot,
-            ...(responsePath ? { responsePath } : {}),
-            ...(artifactId ? { artifactId } : {}),
-            ...(reviveArtifact ? { sourceArtifactId: reviveArtifact.artifactId } : {}),
-            projectionOwnsResponsePersistence: execution.projection !== undefined,
-            meta: {
-                ...(subagentOutcome.warnings.length > 0 ? { warnings: subagentOutcome.warnings.map(renderSubagentWarning) } : {}),
-                effectivePolicy: subagentOutcome.launchSnapshot.akuma.policy,
-            },
-            ...(projection ? { projection } : {}),
-            address: keiyakuContext.address,
-            ...(input.incognito ? {} : { evidenceCwd }),
-        };
-    });
-}

package/build/core/call/context.js

@@ -1,210 +0,0 @@
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import { FlowError } from "../../flow-error.js";
-import { assertGitObservation, observeGitRepository } from "../../git/branches.js";
-import { AddressResolutionError, buildResolutionAttempt, buildUncommissionedAddress, buildUncommissionedRepositoryAddress, resolveCallWorktreeAddressFromRead, resolveExplicitContractAddressFromRead, withResolvedAddress, } from "../addressing.js";
-import { normalizeFilesystemCoordinate } from "../../fs/path-coordinate.js";
-import { readRepositoryLifecycle, } from "../repository-ledger/read-model.js";
-import { isTerminalState } from "../status/lifecycle.js";
-import { verifyCarrier } from "../contract-carrier.js";
-import { findRegisteredContractWorktreePathFromModel, stableRepoRoot, } from "../worktree-path.js";
-import { KEIYAKU_FILE } from "../../keiyaku.js";
-function throwCarrierDispatchRefusal(contractId, verification) {
-    let status;
-    if (verification.status === "missing") {
-        status = "missing";
-    }
-    else if (verification.status === "invalid-header") {
-        status = "incomplete-replay";
-    }
-    else if (verification.status === "identity-mismatch") {
-        status = verification.actual.contractId !== verification.expected.contractId ? "wrong-contract" : "lagging";
-    }
-    else {
-        status = "modified";
-    }
-    const recoveryCommand = `keiyaku bind --contract ${contractId}`;
-    throw new FlowError("CARRIER_MATERIALIZATION_FAILED", `contract ${contractId} carrier is ${status}; recover with ${recoveryCommand}`, {
-        facts: {
-            kind: "carrier_dispatch_refusal",
-            contractId,
-            status,
-            carrierPath: verification.target,
-            recoveryCommand,
-        },
-    });
-}
-export async function readCallKeiyakuContext(executionCwd, input, ports = {}) {
-    executionCwd = normalizeFilesystemCoordinate(executionCwd);
-    input.repoCwd = input.repoCwd === undefined ? undefined : normalizeFilesystemCoordinate(input.repoCwd);
-    const ledgerCandidate = input.repoCwd ?? executionCwd;
-    const ledgerObservation = await observeGitRepository(ledgerCandidate);
-    if (ledgerObservation.capability === "unknown")
-        throw ledgerObservation.error;
-    if (ledgerObservation.capability === "unavailable" && (input.repoCwd || input.contractId)) {
-        assertGitObservation(ledgerObservation, input.repoCwd ? `${input.mode ?? "call"} --repo` : "contract addressing");
-    }
-    if (input.repoCwd && ledgerObservation.capability === "available" && ledgerObservation.coordinate === "non-repository") {
-        throw new FlowError("NOT_GIT_REPO", `${ledgerCandidate} is not a git repository`);
-    }
-    if (ledgerObservation.capability !== "available" || ledgerObservation.coordinate !== "repository") {
-        if (input.bare && input.contractId) {
-            const asTyped = input.contractAddressSource === "at-address"
-                ? `@${input.contractId}`
-                : `--contract ${input.contractId}`;
-            throw new AddressResolutionError("INVALID_USAGE", `commission address ${asTyped} cannot be combined with --bare`, buildResolutionAttempt({
-                repo: { kind: "user" },
-                workdir: executionCwd,
-                spelling: {
-                    asTyped,
-                    source: input.contractAddressSource ?? "explicit-flag",
-                },
-            }));
-        }
-        if (input.contractId) {
-            const asTyped = input.contractAddressSource === "at-address"
-                ? `@${input.contractId}`
-                : `--contract ${input.contractId}`;
-            throw new AddressResolutionError("UNKNOWN_ADDRESS", `${asTyped} is a commission address, but ${ledgerCandidate} has no repository ledger; contract addressing requires a ledger`, buildResolutionAttempt({
-                repo: { kind: "user" },
-                workdir: executionCwd,
-                spelling: {
-                    asTyped,
-                    source: input.contractAddressSource ?? "explicit-flag",
-                },
-            }));
-        }
-        return {
-            activeKeiyaku: false,
-            effectiveCwd: executionCwd,
-            historyCwd: executionCwd,
-            profileCwd: executionCwd,
-            projectionCwd: executionCwd,
-            address: buildUncommissionedAddress({
-                repo: { kind: "user" },
-                workdir: executionCwd,
-                binding: "bare",
-            }),
-        };
-    }
-    const ledgerCwd = await stableRepoRoot(ledgerCandidate);
-    if (input.reviveBinding) {
-        if (input.reviveBinding.kind === "commission") {
-            input.contractId = input.reviveBinding.commissionId;
-            input.contractAddressSource = "artifact-provenance";
-        }
-        else {
-            return {
-                activeKeiyaku: false,
-                effectiveCwd: executionCwd,
-                historyCwd: ledgerCwd,
-                profileCwd: ledgerCwd,
-                projectionCwd: ledgerCwd,
-                address: buildUncommissionedRepositoryAddress({
-                    stableRoot: ledgerCwd,
-                    workdir: executionCwd,
-                    binding: input.reviveBinding.kind,
-                }),
-            };
-        }
-    }
-    if (input.bare && input.contractId) {
-        const repositoryAddress = buildUncommissionedRepositoryAddress({
-            stableRoot: ledgerCwd,
-            workdir: executionCwd,
-            binding: "bare",
-        });
-        const asTyped = input.contractAddressSource === "at-address"
-            ? `@${input.contractId}`
-            : `--contract ${input.contractId}`;
-        throw new AddressResolutionError("INVALID_USAGE", `commission address ${asTyped} cannot be combined with --bare`, buildResolutionAttempt({
-            repo: repositoryAddress.repo,
-            workdir: repositoryAddress.workdir,
-            spelling: {
-                asTyped,
-                source: input.contractAddressSource ?? "explicit-flag",
-            },
-        }));
-    }
-    if (input.bare) {
-        return {
-            activeKeiyaku: false,
-            effectiveCwd: executionCwd,
-            historyCwd: ledgerCwd,
-            profileCwd: ledgerCwd,
-            projectionCwd: ledgerCwd,
-            address: buildUncommissionedRepositoryAddress({
-                stableRoot: ledgerCwd,
-                workdir: executionCwd,
-                binding: "bare",
-            }),
-        };
-    }
-    // This immutable admission is the only lifecycle observation allowed to
-    // influence selection, intent, pins, or returned address facts.
-    const repository = await (ports.readRepositoryLifecycle ?? readRepositoryLifecycle)(ledgerCwd);
-    const admitted = input.contractId === undefined
-        ? await resolveCallWorktreeAddressFromRead({
-            read: repository,
-            stableRoot: ledgerCwd,
-            workdir: executionCwd,
-        })
-        : resolveExplicitContractAddressFromRead({
-            read: repository,
-            stableRoot: ledgerCwd,
-            workdir: executionCwd,
-            raw: input.contractId,
-            source: input.contractAddressSource,
-        });
-    if (!admitted) {
-        return {
-            activeKeiyaku: false,
-            effectiveCwd: executionCwd,
-            historyCwd: ledgerCwd,
-            profileCwd: ledgerCwd,
-            projectionCwd: ledgerCwd,
-            address: buildUncommissionedRepositoryAddress({
-                stableRoot: ledgerCwd,
-                workdir: executionCwd,
-                binding: "bare",
-            }),
-        };
-    }
-    const { address, model } = admitted;
-    return await withResolvedAddress(address, async () => {
-        const contractId = model.contract;
-        if (isTerminalState(address.lifecycle)) {
-            throw new FlowError("EMPTY_PARAM", `commission ${contractId} is terminal and cannot launch an Akuma`);
-        }
-        const effectiveCwd = model.resources.worktree
-            ? await findRegisteredContractWorktreePathFromModel(ledgerCwd, model)
-            : await fs.realpath(ledgerCwd);
-        if (!effectiveCwd) {
-            throw new FlowError("INTERNAL_STATE", `contract ${contractId} has no verified registered engine worktree`);
-        }
-        const carrier = await verifyCarrier({
-            target: path.join(effectiveCwd, KEIYAKU_FILE),
-            lifecycle: model,
-        });
-        if (carrier.status !== "current")
-            throwCarrierDispatchRefusal(contractId, carrier);
-        const executionAddress = { ...address, workdir: effectiveCwd };
-        const { contractId: verifiedContractId, contractHead: verifiedContractHead, bodyDigest } = carrier.actual;
-        return {
-            activeKeiyaku: true,
-            effectiveCwd,
-            historyCwd: ledgerCwd,
-            profileCwd: effectiveCwd,
-            projectionCwd: ledgerCwd,
-            carrier: {
-                path: ".keiyaku/KEIYAKU.md",
-                identity: {
-                    contractId: verifiedContractId,
-                    contractHead: verifiedContractHead,
-                    bodyDigest,
-                },
-            },
-            address: executionAddress,
-        };
-    });
-}