@astrosheep/keiyaku 2.9.12 → 4.0.0

package/build/core/call/context.js

@@ -1,197 +0,0 @@
-import * as fs from "node:fs/promises";
-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 { findRegisteredContractWorktreePathFromModel, stableRepoRoot, } from "../worktree-path.js";
-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 bind = model.history[0]?.entry;
-        if (!bind || bind.kind !== "bind") {
-            throw new FlowError("INTERNAL_STATE", `contract ${contractId} active ledger is missing bind entry`);
-        }
-        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 executionAddress = { ...address, workdir: effectiveCwd };
-        const openArc = model.phase === "active" && model.history.some(({ entry }) => entry.kind === "arc")
-            ? model.intent
-            : null;
-        const currentIntent = openArc
-            ? {
-                source: "arc",
-                arc: openArc.arc,
-                title: openArc.title,
-                objective: openArc.objective,
-                brief: openArc.brief ?? "",
-            }
-            : model.history.some(({ entry }) => entry.kind === "arc")
-                ? undefined
-                : {
-                    source: "bind",
-                    arc: 0,
-                    title: bind.data.title,
-                    context: bind.data.context,
-                    objective: bind.data.objective,
-                    design: bind.data.design,
-                    scope: [...model.effectiveScope],
-                    criteria: [...bind.data.criteria],
-                    verification: [...bind.data.verification],
-                    extensions: bind.data.extensions.map((extension) => ({ ...extension })),
-                };
-        return {
-            activeKeiyaku: true,
-            effectiveCwd,
-            historyCwd: ledgerCwd,
-            profileCwd: effectiveCwd,
-            projectionCwd: ledgerCwd,
-            currentIntent,
-            address: executionAddress,
-        };
-    });
-}

package/build/core/call/execution.js

@@ -1,240 +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 { FlowError } from "../../flow-error.js";
-import { assertProjectionAlias, moveProjectionAlias } from "../projection/index.js";
-import { projectionDir } from "../projection/index.js";
-import { createProjectionExecutionId } from "../projection/index.js";
-import { PROJECTION_ADOPTION_TIMEOUT_MS, startProjectionGeneration } from "../projection/index.js";
-import { openProjectionGenerationStore, openProjectionGenerationStoreReadOnly, acquireProjectionRunnerLock, } from "../projection/index.js";
-import { observeProjectionLife } from "../projection/index.js";
-import { mintProjection, mintRepositoryProjection } from "../projection/index.js";
-import { waitForProjection } from "../projection/index.js";
-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 { 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 = acquireProjectionRunnerLock(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,
-    });
-    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 { projection, launchSnapshot, launchFacts } = await buildCallConfig(agentName, prompt, cwd, options);
-    if (!projection) {
-        throw new FlowError("INTERNAL_STATE", "durable launch requires a projection coordinate");
-    }
-    const launchOwnership = acquireProjectionRunnerLock(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,
-    });
-    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,
-    });
-    // 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 } : {}),
-                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(), startupTimeoutMs: PROJECTION_ADOPTION_TIMEOUT_MS }).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,58 +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.currentIntent?.source === "arc") {
-        const arc = input.currentIntent;
-        return [
-            `You are a called ${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}`,
-            COMMISSIONED_DELIVERY_BOUNDARY,
-            "",
-            `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");
-    }
-    if (input.currentIntent?.source === "bind") {
-        const bind = input.currentIntent;
-        const trimmedContext = input.context?.trim() ?? "";
-        const extensionsBlock = bind.extensions.length > 0
-            ? `Extensions:\n${bind.extensions.map((extension) => `## ${extension.title}\n${extension.content}`).join("\n\n")}`
-            : "";
-        return [
-            `You are a called ${ACTOR_IDENTITY} working inside derived default arc a0.`,
-            "Stay within the contract scope and do the requested work directly.",
-            `Contract: ${bind.title}`,
-            `Context:\n${bind.context}`,
-            `Objective:\n${bind.objective}`,
-            `Design & Approach:\n${bind.design}`,
-            `Scope:\n${bind.scope.map((value) => `- ${value}`).join("\n")}`,
-            `Criteria:\n${bind.criteria.map((value) => `- ${value}`).join("\n")}`,
-            `Verification:\n${bind.verification.map((value) => `- ${value}`).join("\n")}`,
-            extensionsBlock,
-            COMMISSIONED_DELIVERY_BOUNDARY,
-            `Task:\n${input.task}`,
-            trimmedContext ? `Context:\n${trimmedContext}` : "",
-            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");
-    }
-    return [
-        input.task,
-        input.context?.trim() ?? "",
-        input.commissioned ? COMMISSIONED_DELIVERY_BOUNDARY : "",
-        references.length > 0 ? `Reference files:\n${references.map((file) => `- ${file}`).join("\n")}` : "",
-    ]
-        .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;
-}