@astrosheep/keiyaku 2.9.13 → 4.0.0

package/build/core/task/validation.js

@@ -1,48 +0,0 @@
-import { FlowError } from "../../flow-error.js";
-import { isNormalizedIdentifierSlug } from "../identifier-slug.js";
-import { isTaskCoordinate } from "./coordinate.js";
-export const TASK_STATES = new Set(["open", "in_progress", "on_hold", "done", "drop"]);
-const CANONICAL_ISO_UTC_MS = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
-export function invalid(message) {
-    throw new FlowError("INVALID_TARGET", message);
-}
-export function nonblank(field, value) {
-    if (typeof value !== "string" || value.trim() === "") {
-        return invalid(`task field '${field}' must be a nonblank string`);
-    }
-    return value;
-}
-export function fullId(field, value) {
-    const id = nonblank(field, value);
-    if (!isTaskCoordinate(id))
-        invalid(`task field '${field}' must be a canonical full task coordinate`);
-    return id;
-}
-export function isTaskId(value) {
-    return isNormalizedIdentifierSlug(value);
-}
-export function canonicalTimestamp(field, value) {
-    const timestamp = nonblank(field, value);
-    if (!CANONICAL_ISO_UTC_MS.test(timestamp)) {
-        invalid(`task field '${field}' must be a canonical ISO UTC millisecond timestamp`);
-    }
-    try {
-        if (new Date(timestamp).toISOString() !== timestamp) {
-            invalid(`task field '${field}' must be a canonical ISO UTC millisecond timestamp`);
-        }
-    }
-    catch {
-        invalid(`task field '${field}' must be a canonical ISO UTC millisecond timestamp`);
-    }
-    return timestamp;
-}
-export function dateTimestamp(field, value) {
-    try {
-        return canonicalTimestamp(field, value.toISOString());
-    }
-    catch (error) {
-        if (error instanceof FlowError)
-            throw error;
-        return invalid(`task field '${field}' must be a valid date`);
-    }
-}

package/build/core/transcripts.js

@@ -1,485 +0,0 @@
-import { randomBytes } from "node:crypto";
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import { parseResolvedAkumaLaunchSnapshot, } from "../agents/launch-snapshot/model.js";
-import { resolvePersistedSubagentSession } from "../agents/session.js";
-import { OutcomeErrorValidationError, parseCurrentOutcomeError, } from "../agents/harness/index.js";
-import { isErrnoException } from "../errno.js";
-import { FlowError, requireText } from "../flow-error.js";
-import { getCurrentBranch } from "../git/branches.js";
-import { getLatestCommitHash } from "../git/staging.js";
-import { RESPONSE_ARTIFACT_NOTICE, RESPONSE_HISTORY_DIR } from "../keiyaku.js";
-import { attachAddressCarrier } from "./addressing.js";
-import { parseExecutionCoordinates } from "./execution-coordinate.js";
-import { createUlid } from "./ids.js";
-import { parseToAST } from "./markdown/parser.js";
-import { isResponseArtifactId, RESPONSE_ARTIFACT_ID_RE } from "./response-artifact-id.js";
-import { getResponseArtifactCatalog, } from "./response-artifact-catalog.js";
-import { assertExactFields, assertNonBlankString, isPlainRecord, } from "./validation.js";
-export { isResponseArtifactId, RESPONSE_ARTIFACT_ID_RE } from "./response-artifact-id.js";
-const RESPONSE_HISTORY_SLUG_MAX_LENGTH = 24;
-const RESPONSE_HISTORY_SESSION_KEY = "session";
-const RESPONSE_HISTORY_LAUNCH_SNAPSHOT_KEY = "launch_snapshot";
-const RESPONSE_HISTORY_TERMINAL_FAILURE_KEY = "terminal_failure";
-const RESPONSE_HISTORY_PROVENANCE_KEY = "provenance";
-const REVIEW_HISTORY_FILE_RE = /^\d{8}-\d{9}_REVIEW_(\d+)\.md$/;
-/** Artifact-owner rendering of seal receipt/diffstat facts into the durable Diff section. */
-export function renderSealDiffSection(sealed, emptyLabel) {
-    if (!sealed)
-        return emptyLabel;
-    if (sealed.receipts.length === 0)
-        return "nothing sealed";
-    const count = sealed.receipts.length;
-    return `${count} receipt${count === 1 ? "" : "s"} · +${sealed.diffstat.insertions} −${sealed.diffstat.deletions}`;
-}
-export const RESPONSE_ARTIFACT_HEADINGS = {
-    call: "# Call",
-    bind: "# Bind",
-    arc: "# Arc",
-    renew: "# Renew",
-    review: "# Review",
-};
-const RESUMABLE_RESPONSE_HEADINGS = Object.values(RESPONSE_ARTIFACT_HEADINGS);
-function artifactError(locator, field, reason) {
-    return new FlowError("INVALID_RESPONSE_PATH", `Invalid response artifact '${locator}': field '${field}' ${reason}.`);
-}
-function artifactInvalid(locator) {
-    return (field, reason) => artifactError(locator, field, reason);
-}
-/** The sole durable provenance parser. */
-export function parseResponseArtifactProvenance(value, locator) {
-    const invalid = artifactInvalid(locator);
-    if (!isPlainRecord(value))
-        throw artifactError(locator, "provenance", "must be an object");
-    assertExactFields(value, ["artifactId", "authority", "binding", "evidence"], [], "provenance", invalid);
-    assertNonBlankString(value.artifactId, "provenance.artifactId", invalid);
-    if (!RESPONSE_ARTIFACT_ID_RE.test(value.artifactId)) {
-        throw artifactError(locator, "provenance.artifactId", "must be rsp_ followed by a ULID");
-    }
-    const { authority, binding } = parseExecutionCoordinates(value.authority, value.binding, (field, reason) => artifactError(locator, `provenance.${field}`, reason));
-    if (!isPlainRecord(value.evidence))
-        throw artifactError(locator, "provenance.evidence", "must be an object");
-    if (authority.kind === "repository") {
-        assertExactFields(value.evidence, ["branch", "commit"], [], "provenance.evidence", invalid);
-        assertNonBlankString(value.evidence.branch, "provenance.evidence.branch", invalid);
-        assertNonBlankString(value.evidence.commit, "provenance.evidence.commit", invalid);
-        return { artifactId: value.artifactId, authority, binding, evidence: { branch: value.evidence.branch, commit: value.evidence.commit } };
-    }
-    assertExactFields(value.evidence, ["workdir"], [], "provenance.evidence", invalid);
-    assertNonBlankString(value.evidence.workdir, "provenance.evidence.workdir", invalid);
-    if (!path.isAbsolute(value.evidence.workdir)) {
-        throw artifactError(locator, "provenance.evidence.workdir", "must be an absolute path");
-    }
-    return { artifactId: value.artifactId, authority, binding, evidence: { workdir: value.evidence.workdir } };
-}
-async function captureArtifactEvidence(coordinate) {
-    const evidenceCwd = path.resolve(coordinate.evidenceCwd);
-    if (coordinate.authority.kind === "user")
-        return { workdir: evidenceCwd };
-    const [branch, commit] = await Promise.all([getCurrentBranch(evidenceCwd), getLatestCommitHash(evidenceCwd)]);
-    if (!branch.trim())
-        throw artifactError("new response artifact", "provenance.evidence.branch", "must be a non-blank string");
-    if (!commit.trim())
-        throw artifactError("new response artifact", "provenance.evidence.commit", "must be a non-blank string");
-    return { branch, commit };
-}
-function timestampParts(now) {
-    const part = (value, width) => String(value).padStart(width, "0");
-    return {
-        fileStamp: `${now.getFullYear()}${part(now.getMonth() + 1, 2)}${part(now.getDate(), 2)}-${part(now.getHours(), 2)}${part(now.getMinutes(), 2)}${part(now.getSeconds(), 2)}${part(now.getMilliseconds(), 3)}`,
-        iso: now.toISOString(),
-    };
-}
-function slug(text, fallback) {
-    return text.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").slice(0, RESPONSE_HISTORY_SLUG_MAX_LENGTH).replace(/^-+|-+$/g, "") || fallback;
-}
-function yamlQuote(value) { return `'${value.replace(/'/g, "''")}'`; }
-function section(value) { return value?.trim() ? value : "(none)"; }
-function buildMarkdown(input, iso, provenance) {
-    const frontmatter = [
-        "---",
-        `${RESPONSE_HISTORY_PROVENANCE_KEY}: ${yamlQuote(JSON.stringify(provenance))}`,
-        ...(input.session ? [`${RESPONSE_HISTORY_SESSION_KEY}: ${yamlQuote(JSON.stringify(input.session))}`] : []),
-        ...(input.launchSnapshot ? [`${RESPONSE_HISTORY_LAUNCH_SNAPSHOT_KEY}: ${yamlQuote(JSON.stringify(input.launchSnapshot))}`] : []),
-        ...(input.tool === "call" && input.terminalFailure ? [`${RESPONSE_HISTORY_TERMINAL_FAILURE_KEY}: ${yamlQuote(JSON.stringify(input.terminalFailure))}`] : []),
-        ...(input.subagentName?.trim() ? [`subagent_name: ${yamlQuote(input.subagentName.trim())}`] : []),
-        ...(input.effectivePolicy ? [`effective_policy: ${yamlQuote(JSON.stringify(input.effectivePolicy))}`] : []),
-        `time: ${yamlQuote(iso)}`,
-        `notice: ${yamlQuote(RESPONSE_ARTIFACT_NOTICE)}`,
-        "---", "",
-    ];
-    if (input.tool === "call")
-        return [...frontmatter, "# Call", "", "## Task", section(input.task), "", "## Context", section(input.context), "", "## Response", section(input.response), ""].join("\n");
-    if (input.tool === "review")
-        return [...frontmatter, "# Review", "", "## Prompt", section(input.prompt), "", "## Response", section(input.response), ""].join("\n");
-    if (input.tool === "arc") {
-        const diff = renderSealDiffSection(input.sealed, input.emptyDiffLabel);
-        return [...frontmatter, "# Arc", "", "## Objective", section(input.objective), "", "## Brief", section(input.brief), "", "## Ledger Commit", section(input.ledgerCommit), "", "## Summary", section(input.summary), "", "## Diff", section(diff), ""].join("\n");
-    }
-    const diff = renderSealDiffSection(input.sealed, input.emptyDiffLabel);
-    return [...frontmatter, "# Renew", "", "## Base", `${input.oldBase} -> ${input.newBase}`, "", "## Head", `${input.oldHead} -> ${input.newHead}`, "", "## Ledger Commit", section(input.ledgerCommit), "", "## Summary", section(input.summary), "", "## Diff", section(diff), ""].join("\n");
-}
-/** The sole response artifact writer. */
-export async function persistResponseHistory(input) {
-    const coordinates = parseExecutionCoordinates(input.provenance.authority, input.provenance.binding, (field, reason) => artifactError("new response artifact", `provenance.${field}`, reason));
-    const now = input.now ?? new Date();
-    const artifactId = `rsp_${createUlid(now.getTime(), [...randomBytes(10)])}`;
-    const provenance = {
-        artifactId,
-        ...coordinates,
-        evidence: await captureArtifactEvidence({ ...input.provenance, ...coordinates }),
-    };
-    const { fileStamp, iso } = timestampParts(now);
-    const historyDir = path.join(input.cwd, RESPONSE_HISTORY_DIR);
-    const responsePath = path.join(historyDir, `${fileStamp}_${input.tool.toUpperCase()}_${slug(input.title ?? "", input.tool)}.md`);
-    await fs.mkdir(historyDir, { recursive: true });
-    await fs.writeFile(responsePath, buildMarkdown(input, iso, provenance), "utf8");
-    try {
-        getResponseArtifactCatalog()?.register({
-            id: artifactId,
-            stableRoot: await fs.realpath(input.cwd),
-        });
-    }
-    catch {
-        // The catalog is a disposable read model; the persisted artifact remains truth.
-    }
-    return { artifactId, responsePath: path.relative(input.cwd, responsePath) };
-}
-function detectTool(document) {
-    const lines = document.split("\n");
-    let index = 0;
-    if (lines[0] === "---") {
-        index = lines.indexOf("---", 1);
-        if (index < 0)
-            return null;
-        index += 1;
-    }
-    for (; index < lines.length; index += 1) {
-        const line = lines[index].trim();
-        if (!line)
-            continue;
-        const found = Object.entries(RESPONSE_ARTIFACT_HEADINGS).find(([, heading]) => heading === line);
-        return found?.[0] ?? null;
-    }
-    return null;
-}
-export async function readResponseArtifact(input) {
-    const locator = requireText("responsePath", input.responsePath);
-    const absolutePath = path.isAbsolute(locator) ? locator : path.resolve(input.cwd, locator);
-    let document;
-    try {
-        document = await fs.readFile(absolutePath, "utf8");
-    }
-    catch (error) {
-        if (isErrnoException(error) && (error.code === "ENOENT" || error.code === "EISDIR"))
-            throw new FlowError("INVALID_RESPONSE_PATH", `Response artifact not found: '${locator}'.`);
-        throw error;
-    }
-    return parseResponseArtifactDocument(input, locator, absolutePath, document);
-}
-/** Parse one already-read response document without a second filesystem read. */
-async function parseResponseArtifactDocument(input, locator, absolutePath, document) {
-    const ast = parseToAST(document);
-    const frontmatter = ast.frontmatter?.entries;
-    if (!frontmatter)
-        throw artifactError(locator, "provenance", "is missing");
-    if (frontmatter.notice !== RESPONSE_ARTIFACT_NOTICE)
-        throw artifactError(locator, "notice", "does not identify a Keiyaku response artifact");
-    const rawProvenance = frontmatter[RESPONSE_HISTORY_PROVENANCE_KEY];
-    if (rawProvenance === undefined)
-        throw artifactError(locator, "provenance", "is missing");
-    let provenanceValue;
-    try {
-        provenanceValue = JSON.parse(rawProvenance);
-    }
-    catch (error) {
-        throw artifactError(locator, "provenance", `contains malformed JSON${error instanceof Error ? ` (${error.message})` : ""}`);
-    }
-    const provenance = parseResponseArtifactProvenance(provenanceValue, locator);
-    const tool = detectTool(document);
-    if (!tool)
-        throw artifactError(locator, "artifactType", "is unsupported");
-    if (input.allowedTools?.length && !input.allowedTools.includes(tool)) {
-        if (input.onArtifactTypeMismatch === "return-null")
-            return undefined;
-        throw artifactError(locator, "artifactType", `must be ${input.allowedTools.join("/")}`);
-    }
-    const session = frontmatter[RESPONSE_HISTORY_SESSION_KEY] === undefined ? undefined : resolvePersistedSubagentSession({ resumePath: locator, sessionText: frontmatter[RESPONSE_HISTORY_SESSION_KEY] });
-    let launchSnapshot;
-    const rawLaunchSnapshot = frontmatter[RESPONSE_HISTORY_LAUNCH_SNAPSHOT_KEY];
-    if (rawLaunchSnapshot !== undefined) {
-        let launchSnapshotValue;
-        try {
-            launchSnapshotValue = JSON.parse(rawLaunchSnapshot);
-        }
-        catch (error) {
-            throw artifactError(locator, RESPONSE_HISTORY_LAUNCH_SNAPSHOT_KEY, `contains malformed JSON${error instanceof Error ? ` (${error.message})` : ""}`);
-        }
-        try {
-            launchSnapshot = parseResolvedAkumaLaunchSnapshot(launchSnapshotValue);
-        }
-        catch (error) {
-            throw artifactError(locator, RESPONSE_HISTORY_LAUNCH_SNAPSHOT_KEY, `is invalid${error instanceof Error ? ` (${error.message})` : ""}`);
-        }
-    }
-    let terminalFailure;
-    const rawTerminalFailure = frontmatter[RESPONSE_HISTORY_TERMINAL_FAILURE_KEY];
-    if (rawTerminalFailure !== undefined) {
-        let terminalFailureValue;
-        try {
-            terminalFailureValue = JSON.parse(rawTerminalFailure);
-        }
-        catch (error) {
-            throw artifactError(locator, RESPONSE_HISTORY_TERMINAL_FAILURE_KEY, `contains malformed JSON${error instanceof Error ? ` (${error.message})` : ""}`);
-        }
-        try {
-            terminalFailure = parseCurrentOutcomeError(terminalFailureValue, RESPONSE_HISTORY_TERMINAL_FAILURE_KEY);
-        }
-        catch (error) {
-            if (error instanceof OutcomeErrorValidationError) {
-                throw artifactError(locator, RESPONSE_HISTORY_TERMINAL_FAILURE_KEY, `is invalid (${error.message})`);
-            }
-            throw error;
-        }
-    }
-    const subagentName = frontmatter.subagent_name?.trim() || undefined;
-    const storageRoot = await fs.realpath(path.resolve(path.dirname(absolutePath), "..", ".."));
-    return { artifactId: provenance.artifactId, responsePath: path.relative(input.cwd, absolutePath), absolutePath, storageRoot, provenance, tool, ...(session ? { session } : {}), ...(launchSnapshot ? { launchSnapshot } : {}), ...(terminalFailure ? { terminalFailure } : {}), ...(subagentName ? { subagentName } : {}) };
-}
-function artifactIdFromDocument(document) {
-    const encoded = parseToAST(document).frontmatter?.entries?.[RESPONSE_HISTORY_PROVENANCE_KEY];
-    if (encoded === undefined)
-        return undefined;
-    try {
-        const provenance = JSON.parse(encoded);
-        return isPlainRecord(provenance) && typeof provenance.artifactId === "string" && isResponseArtifactId(provenance.artifactId)
-            ? provenance.artifactId
-            : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-/** Read each response artifact file at most once to build a query-local lookup. */
-export async function indexResponseArtifacts(input) {
-    let stableRoot;
-    try {
-        stableRoot = await fs.realpath(input.cwd);
-    }
-    catch (error) {
-        if (!isErrnoException(error) || error.code !== "ENOENT")
-            throw error;
-        stableRoot = path.resolve(input.cwd);
-    }
-    const historyDir = path.join(stableRoot, RESPONSE_HISTORY_DIR);
-    let names;
-    try {
-        names = await (input.readDirectory ?? fs.readdir)(historyDir);
-    }
-    catch (error) {
-        if (isErrnoException(error) && error.code === "ENOENT")
-            return { coverage: "complete", lookup: () => undefined };
-        throw error;
-    }
-    const entries = new Map();
-    let coverage = "complete";
-    for (const name of names.filter((candidate) => candidate.endsWith(".md")).sort()) {
-        const responsePath = path.join(RESPONSE_HISTORY_DIR, name);
-        let document;
-        try {
-            document = await fs.readFile(path.join(stableRoot, responsePath), "utf8");
-            const artifact = await parseResponseArtifactDocument({ cwd: stableRoot, responsePath }, responsePath, path.join(stableRoot, responsePath), document);
-            if (!artifact)
-                continue;
-            if (entries.has(artifact.artifactId))
-                entries.set(artifact.artifactId, { state: "incompatible" });
-            else
-                entries.set(artifact.artifactId, { state: "available", artifact });
-        }
-        catch (error) {
-            const artifactId = document === undefined ? undefined : artifactIdFromDocument(document);
-            if (isErrnoException(error)) {
-                if (artifactId && error.code !== "ENOENT")
-                    entries.set(artifactId, { state: "unavailable" });
-                if (error.code !== "ENOENT")
-                    coverage = "incomplete";
-            }
-            else if (artifactId) {
-                entries.set(artifactId, { state: "incompatible" });
-            }
-        }
-    }
-    return { coverage, lookup: (artifactId) => entries.get(artifactId) };
-}
-async function findResponseArtifactAtRoot(input) {
-    const physicalHistoryDir = path.join(input.stableRoot, RESPONSE_HISTORY_DIR);
-    const historyDir = path.join(input.displayRoot ?? input.stableRoot, RESPONSE_HISTORY_DIR);
-    let names;
-    try {
-        names = await fs.readdir(physicalHistoryDir);
-    }
-    catch (error) {
-        if (isErrnoException(error) && error.code === "ENOENT")
-            return { kind: "missing" };
-        return input.carry(error);
-    }
-    let match;
-    for (const name of names.filter((candidate) => candidate.endsWith(".md")).sort()) {
-        const responsePath = path.join(RESPONSE_HISTORY_DIR, name);
-        let document;
-        try {
-            document = await fs.readFile(path.join(input.stableRoot, responsePath), "utf8");
-        }
-        catch (error) {
-            return input.carry(error);
-        }
-        const encoded = parseToAST(document).frontmatter?.entries?.[RESPONSE_HISTORY_PROVENANCE_KEY];
-        if (encoded === undefined)
-            continue;
-        let indexed;
-        try {
-            indexed = JSON.parse(encoded);
-        }
-        catch {
-            continue;
-        }
-        if (!isPlainRecord(indexed) || indexed.artifactId !== input.artifactId)
-            continue;
-        let parsed;
-        try {
-            parsed = await readResponseArtifact({ cwd: input.stableRoot, responsePath });
-        }
-        catch (error) {
-            return input.carry(error);
-        }
-        if (!parsed)
-            continue;
-        if (match) {
-            return input.carry(new FlowError("INVALID_RESPONSE_PATH", `Response artifact identity '${input.artifactId}' is duplicated in ${historyDir}.`));
-        }
-        match = parsed;
-    }
-    return match ? { kind: "found", artifact: match } : { kind: "missing" };
-}
-function observeCatalogArtifact(catalog, artifact) {
-    try {
-        catalog?.touch({ id: artifact.artifactId, stableRoot: artifact.storageRoot });
-    }
-    catch {
-        // Artifact observation remains authoritative when the disposable catalog is unavailable.
-    }
-}
-export async function reconcileResponseArtifactCatalog(stableRoot) {
-    const catalog = getResponseArtifactCatalog();
-    if (!catalog)
-        return;
-    const physicalRoot = await fs.realpath(stableRoot);
-    const historyDir = path.join(physicalRoot, RESPONSE_HISTORY_DIR);
-    let names;
-    try {
-        names = await fs.readdir(historyDir);
-    }
-    catch (error) {
-        if (isErrnoException(error) && error.code === "ENOENT")
-            return;
-        throw error;
-    }
-    for (const name of names.filter((candidate) => candidate.endsWith(".md")).sort()) {
-        try {
-            const artifact = await readResponseArtifact({
-                cwd: physicalRoot,
-                responsePath: path.join(RESPONSE_HISTORY_DIR, name),
-            });
-            if (artifact)
-                catalog.register({ id: artifact.artifactId, stableRoot: artifact.storageRoot });
-        }
-        catch {
-            // Reconciliation observes valid local artifacts only; it never repairs artifact truth.
-        }
-    }
-}
-export async function locateResponseArtifact(input) {
-    const carry = (error) => {
-        throw attachAddressCarrier(error, input.attempt);
-    };
-    let identity;
-    try {
-        identity = requireText("artifactId", input.artifactId);
-    }
-    catch (error) {
-        return carry(error);
-    }
-    if (!isResponseArtifactId(identity)) {
-        return carry(new FlowError("INVALID_RESPONSE_PATH", `${identity} is not a response artifact handle; fork expects an artifact id`));
-    }
-    let physicalLocalRoot;
-    try {
-        physicalLocalRoot = await fs.realpath(input.cwd);
-    }
-    catch (error) {
-        if (!isErrnoException(error) || error.code !== "ENOENT")
-            return carry(error);
-        physicalLocalRoot = path.resolve(input.cwd);
-    }
-    const local = await findResponseArtifactAtRoot({
-        stableRoot: physicalLocalRoot,
-        displayRoot: input.cwd,
-        artifactId: identity,
-        carry,
-    });
-    const catalog = getResponseArtifactCatalog();
-    if (local.kind === "found") {
-        observeCatalogArtifact(catalog, local.artifact);
-        return local.artifact;
-    }
-    let cataloged;
-    try {
-        cataloged = catalog?.lookup(identity);
-    }
-    catch {
-        cataloged = undefined;
-    }
-    if (cataloged) {
-        const catalogedRoot = cataloged.stableRoot;
-        const remote = await findResponseArtifactAtRoot({
-            stableRoot: catalogedRoot,
-            artifactId: identity,
-            carry,
-        });
-        if (remote.kind === "found") {
-            observeCatalogArtifact(catalog, remote.artifact);
-            return remote.artifact;
-        }
-        try {
-            catalog?.removeDead({ id: identity, stableRoot: catalogedRoot });
-        }
-        catch {
-            // Dead-row cleanup is best-effort; the physical lookup result owns the error.
-        }
-        return carry(new FlowError("INVALID_RESPONSE_PATH", `${identity} not found at cataloged root ${catalogedRoot}`));
-    }
-    const historyDir = path.join(input.cwd, RESPONSE_HISTORY_DIR);
-    return carry(new FlowError("INVALID_RESPONSE_PATH", `Response artifact '${identity}' was not found in ${historyDir}.`));
-}
-export function requireResumableArtifact(artifact) {
-    if (!artifact.session)
-        throw artifactError(artifact.artifactId, RESPONSE_HISTORY_SESSION_KEY, "is missing; this conversation cannot be forked");
-    if (!artifact.subagentName)
-        throw artifactError(artifact.artifactId, "subagent_name", "is missing; this conversation cannot be forked");
-    if (!artifact.launchSnapshot)
-        throw artifactError(artifact.artifactId, RESPONSE_HISTORY_LAUNCH_SNAPSHOT_KEY, "is missing; this conversation cannot be forked");
-    return artifact;
-}
-export async function nextReviewResponseNumber(cwd) {
-    const historyDir = path.join(cwd, RESPONSE_HISTORY_DIR);
-    let names;
-    try {
-        names = await fs.readdir(historyDir);
-    }
-    catch (error) {
-        if (isErrnoException(error) && error.code === "ENOENT")
-            return 1;
-        throw error;
-    }
-    return names.reduce((max, name) => Math.max(max, Number(REVIEW_HISTORY_FILE_RE.exec(name)?.[1] ?? 0)), 0) + 1;
-}

package/build/core/validation.js

@@ -1,17 +0,0 @@
-export function isPlainRecord(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-export function assertExactFields(value, required, optional, prefix, invalid) {
-    for (const field of required) {
-        if (!(field in value))
-            throw invalid(prefix ? `${prefix}.${field}` : field, "is missing");
-    }
-    const allowed = new Set([...required, ...optional]);
-    const unknown = Object.keys(value).filter((field) => !allowed.has(field)).sort()[0];
-    if (unknown !== undefined)
-        throw invalid(prefix ? `${prefix}.${unknown}` : unknown, "is unknown");
-}
-export function assertNonBlankString(value, field, invalid) {
-    if (typeof value !== "string" || value.trim() === "")
-        throw invalid(field, "must be a non-blank string");
-}

package/build/core/verification-declaration.js

@@ -1,95 +0,0 @@
-import { FlowError } from "../flow-error.js";
-import { z } from "zod";
-export const VERIFICATION_EXECUTORS = ["bash", "zsh", "pwsh"];
-export const verificationDeclarationSchema = z.object({
-    executor: z.enum(VERIFICATION_EXECUTORS),
-    script: z.string().refine((value) => value.trim().length > 0, "expected a nonblank script"),
-}).strict();
-function example(heading) {
-    return `${heading}\n\`\`\`bash\n<verification script>\n\`\`\``;
-}
-function invalid(options, detail) {
-    throw new FlowError("INVALID_KEIYAKU_DRAFT", `${options.heading} ${detail}. Use a fenced executor script block:\n${example(options.heading)}`);
-}
-function isExecutor(value) {
-    return VERIFICATION_EXECUTORS.includes(value);
-}
-/**
- * Parse the sole persisted contract Verification declaration grammar. Bodies
- * are deliberately source-level so shell backticks and blank lines stay exact.
- */
-export function parseVerificationDeclarations(source, options) {
-    const lines = source.split(/\r?\n/);
-    const declarations = [];
-    let sawNone = false;
-    for (let index = 0; index < lines.length;) {
-        const line = lines[index];
-        if (line.trim().length === 0) {
-            index += 1;
-            continue;
-        }
-        if (options.allowNone && line.trim() === "- (none)") {
-            if (declarations.length > 0 || sawNone) {
-                invalid(options, "the explicit '- (none)' replacement cannot be combined with Verification declarations");
-            }
-            sawNone = true;
-            index += 1;
-            continue;
-        }
-        const opening = line.match(/^ {0,3}(`{3,}|~{3,})(.*)$/);
-        if (!opening)
-            invalid(options, "must contain only direct fenced script blocks");
-        const fence = opening[1];
-        const delimiter = fence[0];
-        const executor = opening[2].trim();
-        if (!executor)
-            invalid(options, "fenced script blocks require an executor header (bash, zsh, or pwsh)");
-        if (!isExecutor(executor))
-            invalid(options, `does not support the '${executor}' executor`);
-        const body = [];
-        index += 1;
-        let closed = false;
-        while (index < lines.length) {
-            const candidate = lines[index];
-            const close = candidate.match(/^ {0,3}(`+|~+)[ \t]*$/);
-            if (close && close[1][0] === delimiter && close[1].length >= fence.length) {
-                closed = true;
-                index += 1;
-                break;
-            }
-            body.push(candidate);
-            index += 1;
-        }
-        if (!closed)
-            invalid(options, "contains an unclosed fenced script block");
-        const script = body.join("\n");
-        if (script.trim().length === 0)
-            invalid(options, "contains an empty fenced script block");
-        if (sawNone) {
-            invalid(options, "the explicit '- (none)' replacement cannot be combined with Verification declarations");
-        }
-        declarations.push({ executor, script });
-    }
-    if (sawNone)
-        return [];
-    if (declarations.length === 0)
-        invalid(options, "must contain at least one fenced script block");
-    return declarations;
-}
-function fenceFor(executor, script) {
-    const candidateLengths = ["`", "~"].map((delimiter) => {
-        const largestRun = script.split("\n").reduce((largest, line) => {
-            const match = line.match(new RegExp(`^ {0,3}\\${delimiter}+`));
-            return Math.max(largest, match?.[0].trim().length ?? 0);
-        }, 0);
-        return { delimiter, length: Math.max(3, largestRun + 1) };
-    });
-    const selected = candidateLengths.sort((left, right) => left.length - right.length)[0];
-    return selected.delimiter.repeat(selected.length);
-}
-export function renderVerificationDeclarations(declarations) {
-    return declarations.map((declaration) => {
-        const fence = fenceFor(declaration.executor, declaration.script);
-        return `${fence}${declaration.executor}\n${declaration.script}\n${fence}`;
-    }).join("\n\n");
-}