@astrosheep/keiyaku 2.9.13 → 4.0.1

package/build/cli/parse-metadata.js

@@ -1,132 +0,0 @@
-import { FlowError } from "../flow-error.js";
-import { HELP_FLAGS, SHORT_FLAG_ALIASES, VALUE_FLAGS } from "./flags.js";
-import { commandParseOrder } from "./commands/metadata.js";
-import { TASK_SUBCOMMANDS } from "./types.js";
-export function normalizeContractAddress(raw) {
-    const value = raw.startsWith("@") ? raw.slice(1) : raw;
-    if (!value.trim()) {
-        throw new FlowError("EMPTY_PARAM", "contract address cannot be empty");
-    }
-    return value.trim();
-}
-export function isCallCommand(command) {
-    return command === "call";
-}
-export function isPetitionDryRunInvocation(tokens) {
-    const boundary = tokens.indexOf("--");
-    const head = boundary === -1 ? tokens : tokens.slice(0, boundary);
-    if (!head.some((token) => token === "--dry-run" || token.startsWith("--dry-run="))) {
-        return false;
-    }
-    for (let index = 0; index < head.length; index += 1) {
-        const token = head[index];
-        if (HELP_FLAGS.has(token) || token.startsWith("@")) {
-            continue;
-        }
-        if (/^-[A-Za-z]$/.test(token)) {
-            const name = SHORT_FLAG_ALIASES[token.slice(1)];
-            if (name && VALUE_FLAGS.has(name)) {
-                index += 1;
-            }
-            continue;
-        }
-        if (token.startsWith("--")) {
-            const eq = token.indexOf("=");
-            const name = (eq === -1 ? token : token.slice(0, eq)).slice(2);
-            if (eq === -1 && VALUE_FLAGS.has(name)) {
-                index += 1;
-            }
-            continue;
-        }
-        return token === "petition";
-    }
-    return false;
-}
-export function parseWaitTimeout(value) {
-    const matched = /^(?<amount>[1-9][0-9]*)(?<unit>[smh])$/.exec(value);
-    if (!matched?.groups) {
-        throw new FlowError("INVALID_USAGE", "wait timeout must use <positive integer><s|m|h>, for example 45s, 5m, or 2h (maximum 24h)");
-    }
-    const amount = Number(matched.groups.amount);
-    const multiplier = matched.groups.unit === "s" ? 1_000 : matched.groups.unit === "m" ? 60_000 : 3_600_000;
-    const timeoutMs = amount * multiplier;
-    if (!Number.isSafeInteger(timeoutMs) || timeoutMs > 24 * 3_600_000) {
-        throw new FlowError("INVALID_USAGE", "wait timeout must use <positive integer><s|m|h>, for example 45s, 5m, or 2h (maximum 24h)");
-    }
-    return timeoutMs;
-}
-export function commandPositionalRange(command) {
-    if (command === "akuma show") {
-        return { min: 1, max: 1, label: "<name>" };
-    }
-    if (command === "log") {
-        return { min: 0, max: 0, label: "" };
-    }
-    if (isCallCommand(command)) {
-        return { min: 1, max: 1, label: "<BODY|->" };
-    }
-    if (command === "tell") {
-        return { min: 2, max: 2, label: "<PROJECTION> <BODY|->" };
-    }
-    if (command === "fork") {
-        return { min: 1, max: 2, label: "<ARTIFACT> [BODY|-]" };
-    }
-    if (command === "wait") {
-        return { min: 0, max: Number.MAX_SAFE_INTEGER, label: "<projection-address>" };
-    }
-    if (command === "kill") {
-        return { min: 1, max: 1, label: "<projection-address>" };
-    }
-    if (command === "status") {
-        return { min: 0, max: 1, label: "[projection-id]" };
-    }
-    if (command === "history") {
-        return { min: 0, max: 1, label: "[projection|alias|rsp]" };
-    }
-    if (command === "task add") {
-        return { min: 1, max: 1, label: "<TITLE|->" };
-    }
-    if (command === "task compose") {
-        return { min: 0, max: 0 };
-    }
-    if (command === "task show" || command === "task log" || command === "task start" || command === "task hold" || command === "task resume" || command === "task drop") {
-        return { min: 1, max: 1, label: "<ID>" };
-    }
-    if (command === "task note") {
-        return { min: 2, max: 2, label: "<ID> <TEXT|->" };
-    }
-    if (command === "task update") {
-        return { min: 1, max: 1, label: "<ID>" };
-    }
-    if (command === "task stop" || command === "task done") {
-        return { min: 0, max: 1, label: "[ID]" };
-    }
-    return { min: 0, max: 0 };
-}
-export function resolveCommand(tokens) {
-    if (tokens[0] === "petition" && (tokens[1] === "claim" || tokens[1] === "forfeit")) {
-        throw new FlowError("UNKNOWN_COMMAND", `unknown command: petition ${tokens[1]}`);
-    }
-    for (const command of commandParseOrder()) {
-        const parts = command.split(" ");
-        if (parts.every((part, index) => tokens[index] === part)) {
-            return { command, rest: tokens.slice(parts.length) };
-        }
-    }
-    const [head] = tokens;
-    if (head === "skills") {
-        return { command: "skills", rest: tokens.slice(1) };
-    }
-    if (!head) {
-        throw new FlowError("EMPTY_PARAM", "command cannot be empty");
-    }
-    throw new FlowError("UNKNOWN_COMMAND", `unknown command: ${head ?? ""}`.trim());
-}
-export function splitAtLiteralBoundary(tokens) {
-    const boundary = tokens.indexOf("--");
-    if (boundary === -1) {
-        return { head: tokens, payload: [] };
-    }
-    return { head: tokens.slice(0, boundary), payload: tokens.slice(boundary + 1) };
-}
-export { TASK_SUBCOMMANDS };

package/build/cli/parse-selectors.js

@@ -1,83 +0,0 @@
-import { FlowError } from "../flow-error.js";
-import { assignFlag } from "./parse-flags.js";
-import { normalizeContractAddress } from "./parse-metadata.js";
-const COMMISSION_SELECTOR_COMMANDS = new Set([
-    "bind",
-    "arc",
-    "amend",
-    "call",
-    "wait",
-    "tell",
-    "kill",
-    "log",
-    "renew",
-    "petition",
-    "forfeit",
-    "audit",
-    "status",
-    "task add",
-    "task compose",
-    "task show",
-    "task ls",
-    "task log",
-    "task start",
-    "task stop",
-    "task hold",
-    "task resume",
-    "task done",
-    "task note",
-    "task drop",
-    "task update",
-    "task doctor",
-]);
-function formatSelectorList(items) {
-    if (items.length <= 1) {
-        return items[0] ?? "";
-    }
-    if (items.length === 2) {
-        return `${items[0]} and ${items[1]}`;
-    }
-    return `${items.slice(0, -1).join(", ")}, and ${items[items.length - 1]}`;
-}
-export function applyCommissionSelector(command, flags, atTokens, contractFlagRaws) {
-    if (atTokens.length > 0 && contractFlagRaws.length > 0) {
-        throw new FlowError("INVALID_USAGE", `commission address supplied twice: ${atTokens[0]} and --contract ${contractFlagRaws[0]}; use exactly one form`);
-    }
-    if (atTokens.length > 1) {
-        throw new FlowError("INVALID_USAGE", `${command} accepts one commission address; got ${formatSelectorList(atTokens)}`);
-    }
-    if (contractFlagRaws.length > 1) {
-        throw new FlowError("INVALID_USAGE", `${command} accepts one commission address; got ${formatSelectorList(contractFlagRaws.map((raw) => `--contract ${raw}`))}`);
-    }
-    if (atTokens.length === 1) {
-        flags.contractId = normalizeContractAddress(atTokens[0]);
-        flags.contractAddressSource = "at-address";
-    }
-    else if (contractFlagRaws.length === 1) {
-        assignFlag(flags, "contract", contractFlagRaws[0]);
-    }
-}
-export function assertCommissionSelectorAllowed(command, flags) {
-    if (flags.contractId === undefined || COMMISSION_SELECTOR_COMMANDS.has(command)) {
-        return;
-    }
-    throw new FlowError("INVALID_USAGE", `contract address @${flags.contractId} is not valid for ${command}`);
-}
-export function assertProjectionSelectorPresent(command, flags, atTokens, contractFlagRaws, restLength, payloadLength) {
-    if (command === "status" && flags.contractId !== undefined && restLength + payloadLength > 0) {
-        throw new FlowError("INVALID_USAGE", `status accepts either one projection id or one commission selector; ${flags.contractAddressSource === "at-address" ? atTokens[0] ?? `@${flags.contractId}` : `--contract ${contractFlagRaws[0] ?? flags.contractId}`} cannot be combined with a projection id`);
-    }
-    if ((command !== "wait" && command !== "tell") || flags.contractId === undefined) {
-        return;
-    }
-    const selectorSpelling = flags.contractAddressSource === "at-address"
-        ? atTokens[0] ?? `@${flags.contractId}`
-        : `--contract ${contractFlagRaws[0] ?? flags.contractId}`;
-    const message = `${command} requires a projection id or alias; ${selectorSpelling} only limits projection lookup, so add the projection address`;
-    if (command === "wait" && restLength + payloadLength === 0 && !flags.any && !flags.all) {
-        throw new FlowError("EMPTY_PARAM", message);
-    }
-    if (command === "tell" && restLength === 0) {
-        throw new FlowError("EMPTY_PARAM", message);
-    }
-}

package/build/cli/parse.js

@@ -1,250 +0,0 @@
-import { FlowError } from "../flow-error.js";
-import { agentNameSchema } from "../config/settings/schema.js";
-import { isResponseArtifactId } from "../core/response-artifact-id.js";
-import { isCommissionId } from "../core/ids.js";
-import { HELP_FLAGS } from "./flags.js";
-import { getCommandMetadata } from "./commands/metadata.js";
-import { AKUMA_SUBCOMMANDS } from "./types.js";
-import { assertAllowedFlag, assignFlag, BOOLEAN_FLAGS, CONTROL_FLAGS, parseFlagName, readValueFlag, SHORT_FLAG_ALIASES, VALUE_FLAGS, } from "./parse-flags.js";
-import { commandPositionalRange, isCallCommand, resolveCommand, splitAtLiteralBoundary, TASK_SUBCOMMANDS, } from "./parse-metadata.js";
-import { applyCommissionSelector, assertCommissionSelectorAllowed, assertProjectionSelectorPresent, } from "./parse-selectors.js";
-import { WAIT_SET_SELECTION_ERROR } from "./commands/projection/wait/meta.js";
-import { TASK_ADD_INPUT_SHAPE_ERROR } from "./commands/task/add/meta.js";
-import { TASK_UPDATE_EXPLICIT_CHANGE_ERROR } from "./commands/task/update/meta.js";
-export { commandPositionalRange, isCallCommand, isPetitionDryRunInvocation, normalizeContractAddress, parseWaitTimeout, } from "./parse-metadata.js";
-export function parseCliArgs(tokens) {
-    const { head, payload } = splitAtLiteralBoundary(tokens);
-    const flags = {};
-    const free = [];
-    const seenFlagNames = new Set();
-    const atTokens = [];
-    const contractFlagRaws = [];
-    let helpRequested = false;
-    for (let index = 0; index < head.length; index += 1) {
-        const token = head[index];
-        if (HELP_FLAGS.has(token)) {
-            helpRequested = true;
-            continue;
-        }
-        if (token.startsWith("@")) {
-            atTokens.push(token);
-            continue;
-        }
-        if (/^-[A-Za-z]$/.test(token)) {
-            const short = token.slice(1);
-            const name = SHORT_FLAG_ALIASES[short];
-            if (!name) {
-                throw new FlowError("UNKNOWN_OPTION", `unknown option: ${token}`);
-            }
-            seenFlagNames.add(name);
-            if (VALUE_FLAGS.has(name)) {
-                const value = head[index + 1];
-                if (value === undefined || value === "--" || /^--/.test(value) || (/^-[A-Za-z]$/.test(value) && SHORT_FLAG_ALIASES[value.slice(1)])) {
-                    throw new FlowError("EMPTY_PARAM", `option -${short} requires a value`);
-                }
-                index += 1;
-                if (name === "contract") {
-                    contractFlagRaws.push(value);
-                }
-                else {
-                    assignFlag(flags, name, value);
-                }
-                continue;
-            }
-            if (BOOLEAN_FLAGS.has(name)) {
-                assignFlag(flags, name, true);
-                continue;
-            }
-            throw new FlowError("UNKNOWN_OPTION", `unknown option: ${token}`);
-        }
-        if (!token.startsWith("--")) {
-            free.push(token);
-            continue;
-        }
-        const eq = token.indexOf("=");
-        const name = parseFlagName(eq === -1 ? token : token.slice(0, eq));
-        if (!CONTROL_FLAGS.has(name)) {
-            throw new FlowError("UNKNOWN_OPTION", `unknown option: --${name}`);
-        }
-        seenFlagNames.add(name);
-        // `--akuma` is a status-only collection selector. Elsewhere it remains
-        // the existing value-taking launch option.
-        if (name === "akuma" && head.includes("status")) {
-            if (eq !== -1)
-                throw new FlowError("INVALID_USAGE", "option --akuma does not accept a value for status");
-            flags.akumaRoster = true;
-            continue;
-        }
-        if (VALUE_FLAGS.has(name)) {
-            const { value, nextIndex } = readValueFlag(name, token, eq, head, index);
-            index = nextIndex;
-            if (name === "contract") {
-                contractFlagRaws.push(value);
-            }
-            else {
-                assignFlag(flags, name, value);
-            }
-            continue;
-        }
-        if (BOOLEAN_FLAGS.has(name)) {
-            if (eq !== -1) {
-                throw new FlowError("INVALID_USAGE", `option --${name} does not accept a value`);
-            }
-            assignFlag(flags, name, true);
-        }
-    }
-    const { command, rest } = resolveCommand(free);
-    applyCommissionSelector(command, flags, atTokens, contractFlagRaws);
-    if (helpRequested) {
-        return {
-            command,
-            flags: flags.contractId
-                ? {
-                    contractId: flags.contractId,
-                    contractAddressSource: flags.contractAddressSource,
-                    ...(flags.cwd ? { cwd: flags.cwd } : {}),
-                    ...(flags.repo ? { repo: flags.repo } : {}),
-                }
-                : {
-                    ...(flags.cwd ? { cwd: flags.cwd } : {}),
-                    ...(flags.repo ? { repo: flags.repo } : {}),
-                },
-            positional: [],
-            helpRequested: true,
-        };
-    }
-    if (command === "akuma") {
-        throw new FlowError("EMPTY_PARAM", `akuma requires subcommand: ${AKUMA_SUBCOMMANDS.slice(0, -1).join(", ")} or ${AKUMA_SUBCOMMANDS.at(-1)}`);
-    }
-    if (command === "skills") {
-        throw new FlowError("EMPTY_PARAM", "skills requires subcommand: install");
-    }
-    if (command === "task") {
-        throw new FlowError("EMPTY_PARAM", `task requires subcommand: ${TASK_SUBCOMMANDS.join(", ")}`);
-    }
-    if (seenFlagNames.has("place")) {
-        if (command === "bind") {
-            throw new FlowError("UNKNOWN_OPTION", "bind no longer accepts --place; use --title <text>");
-        }
-        throw new FlowError("UNKNOWN_OPTION", "unknown option --place; use @addr or --contract <addr>");
-    }
-    for (const name of seenFlagNames) {
-        assertAllowedFlag(command, name);
-    }
-    if (command === "bind" && flags.taskTitle !== undefined) {
-        flags.bindTitle = flags.taskTitle;
-        delete flags.taskTitle;
-    }
-    if (command === "call" && flags.detach && flags.timeoutMs !== undefined) {
-        throw new FlowError("INVALID_USAGE", "call cannot combine --detach and --wait");
-    }
-    if (command === "task ls" && flags.all && flags.done) {
-        throw new FlowError("INVALID_USAGE", "task ls cannot combine --all and --done");
-    }
-    if (command === "wait" && flags.any && flags.all) {
-        throw new FlowError("INVALID_USAGE", WAIT_SET_SELECTION_ERROR);
-    }
-    if (command === "task update" && flags.taskParent !== undefined && flags.taskNoParent) {
-        throw new FlowError("INVALID_USAGE", "task update cannot combine --parent and --no-parent");
-    }
-    if (command === "task update" && flags.taskBody !== undefined && flags.taskAppend !== undefined) {
-        throw new FlowError("INVALID_USAGE", "task update cannot combine --body and --append");
-    }
-    if (command === "task update" && flags.taskTitle === undefined && flags.taskBody === undefined && flags.taskAppend === undefined
-        && flags.taskPri === undefined && flags.taskNeeds === undefined && flags.taskDropNeeds === undefined
-        && flags.taskParent === undefined && !flags.taskNoParent && flags.taskFrom === undefined
-        && flags.taskSupersedes === undefined && flags.taskDropSupersedes === undefined
-        && flags.taskRelatesTo === undefined && flags.taskDropRelatesTo === undefined) {
-        throw new FlowError("INVALID_USAGE", TASK_UPDATE_EXPLICIT_CHANGE_ERROR);
-    }
-    if (command === "petition" && flags.json && !flags.dryRun) {
-        throw new FlowError("INVALID_USAGE", "petition --json requires --dry-run");
-    }
-    if (command === "renew") {
-        const recoveryModes = [flags.renewContinue, flags.renewAbort].filter(Boolean).length;
-        if (recoveryModes > 1) {
-            throw new FlowError("INVALID_USAGE", "renew accepts only one of --continue or --abort");
-        }
-        if (flags.renewAbort && (flags.appendScope?.length ?? 0) > 0) {
-            throw new FlowError("INVALID_USAGE", "renew --abort does not accept --append-scope");
-        }
-    }
-    assertCommissionSelectorAllowed(command, flags);
-    assertProjectionSelectorPresent(command, flags, atTokens, contractFlagRaws, rest.length, payload.length);
-    const positional = [...rest, ...payload];
-    if (command === "amend" && flags.appendScope && positional.length > 0 && positional[0] !== "-") {
-        throw new FlowError("INVALID_USAGE", "amend accepts Markdown only through literal '-' and --append-scope never reads unselected stdin");
-    }
-    if (command === "bind" && flags.contractId !== undefined) {
-        if (!isCommissionId(flags.contractId)) {
-            throw new FlowError("UNKNOWN_ADDRESS", `bind replay requires a full canonical contract id; got ${flags.contractId}`);
-        }
-        const hasReplayInput = positional.length > 0
-            || flags.bindTaskIds !== undefined
-            || flags.after !== undefined
-            || flags.exclusive === true
-            || flags.draftOnly === true
-            || flags.dryRun === true
-            || flags.bindTitle !== undefined
-            || flags.bindContext !== undefined
-            || flags.bindObjective !== undefined
-            || flags.bindDesign !== undefined
-            || flags.bindScope !== undefined
-            || flags.bindCriteria !== undefined
-            || flags.bindVerification !== undefined;
-        if (hasReplayInput) {
-            throw new FlowError("INVALID_USAGE", "addressed bind is replay-only and accepts no draft or creation input");
-        }
-    }
-    if (command === "wait") {
-        if (positional.length === 0 && !flags.contractId) {
-            throw new FlowError("EMPTY_PARAM", "wait requires <projection-address>");
-        }
-        if (positional.length > 1 && !flags.any && !flags.all) {
-            throw new FlowError("INVALID_USAGE", WAIT_SET_SELECTION_ERROR);
-        }
-    }
-    if (isCallCommand(command)) {
-        if (flags.akuma) {
-            if (positional.length > 1) {
-                throw new FlowError("INVALID_USAGE", `${command} accepts at most one <BODY|-> when --akuma is used`);
-            }
-        }
-        else {
-            const [name] = positional;
-            if (!name) {
-                throw new FlowError("EMPTY_PARAM", `${command} requires an agent name; use \`keiyaku ${command} NAME <BODY|->\``);
-            }
-            if (isResponseArtifactId(name)) {
-                throw new FlowError("UNKNOWN_ADDRESS", `artifact ${name} is a response artifact; call expects an Akuma profile name`);
-            }
-            const parsedName = agentNameSchema.safeParse(name);
-            if (!parsedName.success) {
-                throw new FlowError("UNKNOWN_ADDRESS", `${command} requires a valid agent name before <BODY|->`);
-            }
-            flags.akuma = parsedName.data;
-            positional.shift();
-            if (positional.length > 1) {
-                throw new FlowError("INVALID_USAGE", `${command} accepts at most one <BODY|-> after the agent name`);
-            }
-        }
-    }
-    const positionalRange = commandPositionalRange(command);
-    if (positional.length < positionalRange.min) {
-        throw new FlowError("EMPTY_PARAM", `${command} requires ${positionalRange.label ?? "an argument"}`);
-    }
-    const stdin = getCommandMetadata(command).stdin;
-    const documentStdinSelector = stdin.mode === "document"
-        && stdin.selector.kind === "positional"
-        && positional.length === stdin.selector.index + 1
-        && positional[stdin.selector.index] === "-";
-    if (positional.length > positionalRange.max && !documentStdinSelector) {
-        const message = command === "task add"
-            ? TASK_ADD_INPUT_SHAPE_ERROR
-            : stdin.mode === "document"
-                ? `${command} reads Markdown only through literal '-'; file path arguments are not supported`
-                : `${command} does not accept positional arguments`;
-        throw new FlowError("INVALID_USAGE", message);
-    }
-    return { command, flags, positional };
-}

package/build/cli/projection-address.js

@@ -1,105 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { AddressResolutionError, buildObjectResolutionAttempt, } from "../core/addressing.js";
-import { assertProjectionTellable, projectionAliasRootAtCoordinate, projectionDirAtCoordinate, resolveProjectionCoordinate, } from "../core/projection/index.js";
-import { isProjectionId } from "../core/projection/index.js";
-import { isProjectionAlias, readProjectionAliasAtRoot } from "../core/projection/index.js";
-import { readProjectionIdentity } from "../core/projection/index.js";
-import { isResponseArtifactId } from "../core/response-artifact-id.js";
-import { isErrnoException } from "../errno.js";
-function isRealDirectory(directory) {
-    try {
-        return fs.lstatSync(directory).isDirectory();
-    }
-    catch (error) {
-        if (isErrnoException(error) && error.code === "ENOENT")
-            return false;
-        throw error;
-    }
-}
-export async function resolveProjectionAddress(input) {
-    const workdir = path.resolve(input.cwd);
-    // Scoped lookup reuses the commission carrier's repository root: zero Git probes.
-    // Unscoped lookup performs exactly one coordinate probe.
-    let repo;
-    let coordinate;
-    let attempt;
-    if (input.scope) {
-        repo = input.scope.repo;
-        coordinate = {
-            physicalRoot: input.scope.repo.stableRoot,
-            authority: { kind: "repository", stableRoot: input.scope.repo.stableRoot },
-        };
-        attempt = buildObjectResolutionAttempt({
-            repo,
-            workdir,
-            expected: "projection",
-            supplied: input.address,
-            scope: {
-                commissionId: input.scope.binding.commissionId,
-                asTyped: input.scope.spelling.asTyped,
-            },
-            inference: ["commission-scoped projection lookup"],
-        });
-    }
-    else {
-        coordinate = input.coordinate ?? await resolveProjectionCoordinate(input.cwd);
-        repo = coordinate.authority.kind === "repository"
-            ? { kind: "repository", stableRoot: coordinate.authority.stableRoot }
-            : { kind: "user" };
-        attempt = buildObjectResolutionAttempt({
-            repo,
-            workdir,
-            expected: "projection",
-            supplied: input.address,
-            inference: ["projection directory lookup"],
-        });
-    }
-    if (isResponseArtifactId(input.address)) {
-        throw new AddressResolutionError("UNKNOWN_ADDRESS", `artifact ${input.address} is a response artifact; ${input.verb} expects a projection id or alias`, { ...attempt, actual: "artifact" });
-    }
-    const suffix = input.scope
-        ? `within ${input.scope.spelling.asTyped}`
-        : repo.kind === "repository" ? `in repository ${repo.stableRoot}` : `in workdir ${workdir}`;
-    let id;
-    let alias;
-    if (input.address.includes("/")) {
-        if (!isProjectionId(input.address))
-            throw new AddressResolutionError("UNKNOWN_ADDRESS", `projection ${input.address} has no match ${suffix}`, attempt);
-        id = input.address;
-    }
-    else {
-        if (!isProjectionAlias(input.address))
-            throw new AddressResolutionError("UNKNOWN_ADDRESS", `projection alias ${input.address} has no match ${suffix}`, attempt);
-        const target = await readProjectionAliasAtRoot(projectionAliasRootAtCoordinate(coordinate), input.address);
-        if (!target)
-            throw new AddressResolutionError("UNKNOWN_ADDRESS", `projection alias ${input.address} has no match ${suffix}`, attempt);
-        id = target;
-        alias = input.address;
-    }
-    const directory = projectionDirAtCoordinate(coordinate, id);
-    if (!isRealDirectory(directory)) {
-        const subject = alias ? `projection alias ${alias} points to missing projection ${id}` : `projection ${id}`;
-        throw new AddressResolutionError("UNKNOWN_ADDRESS", `${subject} has no match ${suffix}`, attempt);
-    }
-    // Historical projection storage has no current identity to resolve. Tell
-    // still reaches its typed no-mutation refusal instead of exposing storage
-    // parser details or creating a mailbox row.
-    if (input.verb === "tell")
-        assertProjectionTellable(directory);
-    let identity;
-    try {
-        identity = readProjectionIdentity(directory);
-    }
-    catch (error) {
-        if (error instanceof Error && /ENOENT|no such file/i.test(error.message)) {
-            const subject = alias ? `projection alias ${alias} points to missing projection ${id}` : `projection ${id}`;
-            throw new AddressResolutionError("UNKNOWN_ADDRESS", `${subject} has no match ${suffix}`, attempt);
-        }
-        throw error;
-    }
-    if (input.scope && (identity.binding.kind !== "commission" || identity.binding.commissionId !== input.scope.binding.commissionId)) {
-        throw new AddressResolutionError("UNKNOWN_ADDRESS", `projection ${id} has no match ${suffix}`, attempt);
-    }
-    return { id, directory, ...(alias ? { alias } : {}) };
-}

package/build/cli/render/address.js

@@ -1,101 +0,0 @@
-import { formatCommissionCoordinate } from "../../core/ids.js";
-function isCommissionAddress(address) {
-    return address.binding.kind === "commission";
-}
-function projectionSegment(facts) {
-    if (!facts.projectionId)
-        return undefined;
-    return facts.projectionAlias
-        ? `projection ${facts.projectionId} (${facts.projectionAlias})`
-        : `projection ${facts.projectionId}`;
-}
-/**
- * Human-facing address receipt. Contract coordinates are `<slug> @<place>` or `<slug>`;
- * Opaque contract identity, branch ref, binding source, and repo path stay in payload/carrier.
- */
-export function renderResolvedAddressReceipt(address, facts = {}) {
-    if (!isCommissionAddress(address)) {
-        if (address.binding.kind === "unbound") {
-            if (address.repo.kind !== "repository") {
-                throw new Error("unbound address receipt requires repository authority");
-            }
-            return [
-                "Unbound",
-                "no active commission",
-                `workdir ${address.workdir}`,
-                facts.artifactId ? `artifact ${facts.artifactId}` : undefined,
-                projectionSegment(facts),
-            ].filter((part) => part !== undefined).join(" · ");
-        }
-        return [
-            "Bare",
-            "no contract",
-            `workdir ${address.workdir}`,
-            facts.artifactId ? `artifact ${facts.artifactId}` : undefined,
-            projectionSegment(facts),
-        ].filter((part) => part !== undefined).join(" · ");
-    }
-    const place = address.place.display;
-    if (facts.akumaName) {
-        if (!facts.projectionId)
-            throw new Error("commissioned call receipt requires projection id");
-        return `call ${facts.akumaName} · ${formatCommissionCoordinate({
-            commissionId: address.binding.commissionId,
-            place,
-        })} · projection ${facts.projectionId} · out there`;
-    }
-    return [
-        formatCommissionCoordinate({
-            commissionId: address.binding.commissionId,
-            place,
-        }),
-        facts.artifactId ? `artifact ${facts.artifactId}` : undefined,
-        projectionSegment(facts),
-    ].filter((part) => part !== undefined).join(" · ");
-}
-function renderAttemptCandidate(candidate) {
-    const coordinate = formatCommissionCoordinate({
-        commissionId: candidate.commissionId,
-        place: candidate.place,
-    });
-    const objectiveLine = candidate.objective.split(/\r?\n/, 1)[0]?.trim() ?? "";
-    const objective = objectiveLine.length > 60
-        ? `${objectiveLine.slice(0, 60)}…`
-        : objectiveLine;
-    return [
-        coordinate,
-        objective || undefined,
-        candidate.commissionId,
-    ].filter((part) => part !== undefined).join(" · ");
-}
-function isCommissionResolutionAttempt(attempt) {
-    return attempt.expected === "commission";
-}
-export function renderResolutionAttemptPreamble(attempt) {
-    if (!isCommissionResolutionAttempt(attempt)) {
-        return [
-            attempt.scope ? `scope ${attempt.scope.asTyped}` : undefined,
-        ].filter((part) => part !== undefined).join(" · ") || "resolution failed";
-    }
-    const parts = [
-        attempt.spelling ? `address ${attempt.spelling.asTyped}` : undefined,
-        attempt.candidates.length > 0
-            ? `candidates ${attempt.candidates.map(renderAttemptCandidate).join("; ")}`
-            : undefined,
-        attempt.inference.length > 0 ? `inference ${attempt.inference.join("; ")}` : undefined,
-    ];
-    return parts.filter((part) => part !== undefined).join(" · ") || "resolution failed";
-}
-export function renderAddressCarrier(carrier, facts = {}) {
-    return "expected" in carrier
-        ? renderResolutionAttemptPreamble(carrier)
-        : renderResolvedAddressReceipt(carrier, facts);
-}
-export function prependAddressReceipt(output, address, facts = {}) {
-    if (!address)
-        return output;
-    return { ...output, address, text: `${renderResolvedAddressReceipt(address, facts)}\n${output.text}` };
-}
-export function carryAddress(output, address) {
-    return { ...output, address };
-}