@astrosheep/keiyaku 2.9.13 → 4.0.1

package/build/config/settings/schema.js

@@ -1,113 +0,0 @@
-import { z } from "zod";
-import { BUILTIN_PROVIDER_INSTANCE_CANDIDATES as REGISTRY_BUILTIN_PROVIDER_INSTANCE_CANDIDATES, providerInstanceSchema as registryProviderInstanceSchema, } from "../../agents/providers/registry.js";
-import { akumaNameSchema } from "../../core/projection/akuma-name.js";
-import { PROJECTION_ADOPTION_TIMEOUT_MAX_MS, PROJECTION_ADOPTION_TIMEOUT_MIN_MS, } from "./knobs.js";
-export const providerInstanceSchema = registryProviderInstanceSchema;
-export const BUILTIN_PROVIDER_INSTANCE_CANDIDATES = REGISTRY_BUILTIN_PROVIDER_INSTANCE_CANDIDATES;
-const PROVIDER_INSTANCE_NAME_PATTERN = /^[a-z0-9][a-z0-9-]*$/;
-export const providerInstanceNameSchema = z
-    .string()
-    .max(64, "must contain at most 64 characters.")
-    .regex(PROVIDER_INSTANCE_NAME_PATTERN, "must match ^[a-z0-9][a-z0-9-]*$.");
-// Ensure the registry builtin map stays keyed by the closed provider vocabulary.
-const _builtinCheck = BUILTIN_PROVIDER_INSTANCE_CANDIDATES;
-void _builtinCheck;
-export const agentNameSchema = akumaNameSchema;
-function optionalTrimmedString() {
-    return z.string().transform((value) => {
-        const trimmed = value.trim();
-        return trimmed.length > 0 ? trimmed : undefined;
-    }).optional();
-}
-function requiredTrimmedString(message) {
-    return z.string().transform((value, ctx) => {
-        const trimmed = value.trim();
-        if (trimmed.length === 0) {
-            ctx.addIssue({
-                code: z.ZodIssueCode.custom,
-                message,
-            });
-            return z.NEVER;
-        }
-        return trimmed;
-    });
-}
-const gateCommandSchema = z
-    .object({
-    label: requiredTrimmedString("must not be empty."),
-    command: requiredTrimmedString("must not be empty.").superRefine((value, ctx) => {
-        if (/\s/.test(value) || value.includes("\"") || value.includes("'")) {
-            ctx.addIssue({
-                code: z.ZodIssueCode.custom,
-                message: "must be a single program name token with no spaces or quotes.",
-            });
-        }
-    }),
-    args: z.array(z.string()).optional(),
-})
-    .strict()
-    .transform((value) => ({
-    ...value,
-    args: value.args ?? [],
-}));
-const gateSchema = z
-    .object({
-    commands: z.array(gateCommandSchema).optional(),
-    timeoutMs: z.number().int("timeoutMs must be an integer.").min(1).max(3_600_000).optional(),
-})
-    .strict()
-    .transform((value) => ({ ...value, timeoutMs: value.timeoutMs ?? 300_000 }));
-const WORKTREE_BOOTSTRAP_DEFAULT_TIMEOUT_MS = 300_000;
-const WORKTREE_BOOTSTRAP_MIN_TIMEOUT_MS = 1;
-const WORKTREE_BOOTSTRAP_MAX_TIMEOUT_MS = 3_600_000;
-export const projectionAdoptionTimeoutSchema = z
-    .number()
-    .int("projectionAdoptionTimeoutMs must be an integer.")
-    .min(PROJECTION_ADOPTION_TIMEOUT_MIN_MS, `projectionAdoptionTimeoutMs must be >= ${PROJECTION_ADOPTION_TIMEOUT_MIN_MS}.`)
-    .max(PROJECTION_ADOPTION_TIMEOUT_MAX_MS, `projectionAdoptionTimeoutMs must be <= ${PROJECTION_ADOPTION_TIMEOUT_MAX_MS}.`);
-export const worktreeBootstrapSchema = z
-    .object({
-    command: z
-        .array(z.string())
-        .min(1, "command must be a nonempty argv array.")
-        .superRefine((items, ctx) => {
-        items.forEach((item, index) => {
-            if (item.trim().length === 0) {
-                ctx.addIssue({
-                    code: z.ZodIssueCode.custom,
-                    path: [index],
-                    message: "command items must be nonempty after trimming.",
-                });
-            }
-        });
-    }),
-    timeoutMs: z
-        .number()
-        .int("timeoutMs must be an integer.")
-        .min(WORKTREE_BOOTSTRAP_MIN_TIMEOUT_MS, `timeoutMs must be >= ${WORKTREE_BOOTSTRAP_MIN_TIMEOUT_MS}.`)
-        .max(WORKTREE_BOOTSTRAP_MAX_TIMEOUT_MS, `timeoutMs must be <= ${WORKTREE_BOOTSTRAP_MAX_TIMEOUT_MS}.`)
-        .optional(),
-})
-    .strict()
-    .transform((value) => ({
-    command: value.command,
-    timeoutMs: value.timeoutMs ?? WORKTREE_BOOTSTRAP_DEFAULT_TIMEOUT_MS,
-}));
-const settingsSchema = z
-    .object({
-    default: agentNameSchema.optional(),
-    reviewer: agentNameSchema.optional(),
-    gate: gateSchema.optional(),
-    defaultBranch: optionalTrimmedString(),
-    worktreeBootstrap: worktreeBootstrapSchema.optional(),
-    projectionAdoptionTimeoutMs: projectionAdoptionTimeoutSchema.optional(),
-})
-    .strict();
-export const knobSchemas = {
-    default: agentNameSchema,
-    reviewer: agentNameSchema,
-    gate: gateSchema,
-    defaultBranch: optionalTrimmedString(),
-    worktreeBootstrap: worktreeBootstrapSchema,
-    projectionAdoptionTimeoutMs: projectionAdoptionTimeoutSchema,
-};

package/build/core/address-carrier.js

@@ -1,89 +0,0 @@
-import * as path from "node:path";
-import { FlowError } from "../flow-error.js";
-const ADDRESS_CARRIER = Symbol.for("keiyaku.address-carrier");
-export class AddressResolutionError extends FlowError {
-    attempt;
-    constructor(code, message, attempt, options) {
-        super(code, message, options);
-        this.name = "AddressResolutionError";
-        this.attempt = attempt;
-    }
-}
-class AddressedFlowError extends FlowError {
-    [ADDRESS_CARRIER];
-    constructor(error, carrier) {
-        super(error.code, error.message, {
-            cause: error,
-            review: error.review,
-            facts: error.facts,
-        });
-        this.name = error.name;
-        this[ADDRESS_CARRIER] = carrier;
-    }
-}
-class AddressedError extends Error {
-    [ADDRESS_CARRIER];
-    constructor(error, carrier) {
-        super(error instanceof Error ? error.message : String(error), { cause: error });
-        this.name = error instanceof Error ? error.name : "Error";
-        this[ADDRESS_CARRIER] = carrier;
-    }
-}
-export function attachAddressCarrier(error, carrier) {
-    if (addressCarrierFromError(error))
-        return error;
-    return error instanceof FlowError
-        ? new AddressedFlowError(error, carrier)
-        : new AddressedError(error, carrier);
-}
-export function addressCarrierFromError(error) {
-    const seen = new Set();
-    let current = error;
-    while (((typeof current === "object" && current !== null) || typeof current === "function") && !seen.has(current)) {
-        seen.add(current);
-        if (current instanceof AddressResolutionError)
-            return current.attempt;
-        const addressed = current;
-        if (addressed[ADDRESS_CARRIER])
-            return addressed[ADDRESS_CARRIER];
-        current = addressed.cause;
-    }
-    return undefined;
-}
-export async function withResolvedAddress(address, operation) {
-    try {
-        return await operation();
-    }
-    catch (error) {
-        throw attachAddressCarrier(error, address);
-    }
-}
-export function buildResolutionAttempt(input) {
-    return {
-        repo: input.repo,
-        workdir: path.resolve(input.workdir),
-        expected: "commission",
-        ...(input.spelling ? { spelling: input.spelling } : {}),
-        ...(input.actual !== undefined ? { actual: input.actual } : {}),
-        candidates: [...(input.candidates ?? [])],
-        inference: [...(input.inference ?? [])],
-    };
-}
-export function buildObjectResolutionAttempt(input) {
-    return {
-        repo: input.repo,
-        workdir: path.resolve(input.workdir),
-        expected: input.expected,
-        supplied: input.supplied,
-        ...(input.actual !== undefined ? { actual: input.actual } : {}),
-        ...(input.scope ? { scope: input.scope } : {}),
-        candidates: [...(input.candidates ?? [])],
-        inference: [...(input.inference ?? [])],
-    };
-}
-export function buildArtifactResolutionAttempt(input) {
-    return {
-        ...buildObjectResolutionAttempt({ ...input, expected: "artifact" }),
-        expected: "artifact",
-    };
-}

package/build/core/addressing.js

@@ -1,407 +0,0 @@
-import * as path from "node:path";
-import { FlowError } from "../flow-error.js";
-import { errorContainsAnyPattern, NOT_GIT_REPOSITORY_PATTERNS } from "../git/core.js";
-import { commissionSlug, formatCommissionCoordinate } from "./ids.js";
-import { readRepositoryLifecycle, } from "./repository-ledger/read-model.js";
-import { admitRepositoryLifecycleContract, } from "./repository-ledger/admission.js";
-import { isResponseArtifactId } from "./response-artifact-id.js";
-import { currentContractBoundByWorktreeWitness, stableRepoRoot } from "./worktree-path.js";
-import { isTerminalState, } from "./status/lifecycle.js";
-import { AddressResolutionError, } from "./address-carrier.js";
-export { AddressResolutionError, addressCarrierFromError, attachAddressCarrier, buildArtifactResolutionAttempt, buildObjectResolutionAttempt, buildResolutionAttempt, withResolvedAddress, } from "./address-carrier.js";
-const AMBIGUOUS_OBJECTIVE_MAX_CHARS = 60;
-function normalizeAddressQuery(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();
-}
-function commissionSelectorAsTyped(query, source) {
-    if (source === "at-address")
-        return `@${query}`;
-    if (source === "explicit-flag")
-        return `--contract ${query}`;
-    return query;
-}
-function candidatePlace(candidate) {
-    return candidate.model.resources.worktree?.place ?? null;
-}
-function legacyLifecycle(model) {
-    switch (model.phase) {
-        case "active":
-            return model.history.every((row) => row.entry.kind === "bind" || row.entry.kind === "bootstrap")
-                ? { state: "bound" }
-                : { state: "active" };
-        case "sealed":
-            return { state: "active" };
-        case "awaiting-verdict":
-        case "approved":
-            return { state: "petitioned" };
-        case "claimed":
-            return { state: "claimed" };
-        case "forfeited":
-            return { state: "forfeited" };
-    }
-}
-function commissionAddressCandidates(read) {
-    return read.contracts.map((model) => {
-        const lifecycle = legacyLifecycle(model);
-        return {
-            contractId: model.contract,
-            model,
-            operable: !isTerminalState(lifecycle),
-            lifecycle,
-        };
-    });
-}
-export function contractReadOutcomeError(contractId, outcome) {
-    return new FlowError("INTERNAL_STATE", `contract ${contractId} is unavailable because repository lifecycle evidence is ${outcome.status}`, {
-        facts: {
-            kind: "repository_lifecycle_disease",
-            contractId,
-            status: outcome.status,
-            diagnostics: outcome.diagnostics.map((diagnostic) => ({
-                objectId: diagnostic.objectId,
-                code: diagnostic.code,
-                detail: diagnostic.detail,
-                ...(diagnostic.contract === undefined ? {} : { contract: diagnostic.contract }),
-            })),
-        },
-    });
-}
-function admitContractCandidate(read, candidate) {
-    const outcome = admitRepositoryLifecycleContract(read, candidate.contractId);
-    if (outcome.status === "healthy")
-        return candidate;
-    if (outcome.status === "absent") {
-        throw new FlowError("INTERNAL_STATE", `contract ${candidate.contractId} disappeared from the repository lifecycle read model`);
-    }
-    throw contractReadOutcomeError(candidate.contractId, outcome);
-}
-function admittedAddress(read, candidate, address) {
-    admitContractCandidate(read, candidate);
-    return { address, model: candidate.model };
-}
-function matchedCommissionSpellings(query, candidate) {
-    const matches = [];
-    if (candidate.contractId === query)
-        matches.push("id");
-    if (commissionSlug(candidate.contractId) === query)
-        matches.push("slug");
-    if (candidate.operable && candidatePlace(candidate) === query) {
-        matches.push("place");
-    }
-    return matches;
-}
-function preferredCommissionSpelling(spellings) {
-    for (const spelling of ["id", "slug", "place"]) {
-        if (spellings.has(spelling))
-            return spelling;
-    }
-    throw new FlowError("INTERNAL_STATE", "contract address identity has no matched spelling");
-}
-function explicitAddressIdentities(read, query) {
-    const identities = new Map();
-    const upsert = (contractId, spellings, candidate) => {
-        if (spellings.length === 0)
-            return;
-        const current = identities.get(contractId);
-        if (current) {
-            for (const spelling of spellings)
-                current.matchedSpellings.add(spelling);
-            if (!current.candidate && candidate)
-                current.candidate = candidate;
-            return;
-        }
-        identities.set(contractId, {
-            contractId,
-            matchedSpellings: new Set(spellings),
-            ...(candidate ? { candidate } : {}),
-            outcome: admitRepositoryLifecycleContract(read, contractId),
-        });
-    };
-    for (const candidate of commissionAddressCandidates(read)) {
-        upsert(candidate.contractId, matchedCommissionSpellings(query, candidate), candidate);
-    }
-    for (const contractId of read.isolatedContracts) {
-        const spellings = [];
-        if (contractId === query)
-            spellings.push("id");
-        if (commissionSlug(contractId) === query)
-            spellings.push("slug");
-        upsert(contractId, spellings);
-    }
-    return [...identities.values()].sort((left, right) => left.contractId.localeCompare(right.contractId));
-}
-function resolutionCandidateForIdentity(identity) {
-    const matchedBy = preferredCommissionSpelling(identity.matchedSpellings);
-    if (identity.candidate) {
-        const candidate = identity.candidate;
-        return {
-            commissionId: candidate.contractId,
-            matchedBy,
-            place: candidatePlace(candidate),
-            name: candidate.model.history[0].entry.kind === "bind" ? candidate.model.history[0].entry.data.title : candidate.model.intent.title,
-            objective: candidate.model.intent.objective,
-            lifecycle: candidate.lifecycle,
-            target: { branch: candidate.model.pins.target.ref },
-            ...(identity.outcome.status === "diseased" || identity.outcome.status === "isolated" || identity.outcome.status === "indeterminate"
-                ? {
-                    availability: {
-                        status: identity.outcome.status,
-                        diagnostics: identity.outcome.diagnostics,
-                    },
-                }
-                : {}),
-        };
-    }
-    if (identity.outcome.status === "healthy" || identity.outcome.status === "absent") {
-        throw new FlowError("INTERNAL_STATE", `contract ${identity.contractId} matched without a lifecycle model`);
-    }
-    return {
-        commissionId: identity.contractId,
-        matchedBy,
-        place: null,
-        name: identity.contractId,
-        objective: `repository lifecycle evidence is ${identity.outcome.status}`,
-        lifecycle: { state: "corrupt", at: 0, reason: `repository lifecycle evidence is ${identity.outcome.status}` },
-        target: { branch: "" },
-        availability: {
-            status: identity.outcome.status,
-            diagnostics: identity.outcome.diagnostics,
-        },
-    };
-}
-function attemptCandidates(candidates) {
-    return candidates.map((candidate) => ({
-        commissionId: candidate.contractId,
-        place: candidatePlace(candidate),
-        name: candidate.model.history[0].entry.kind === "bind" ? candidate.model.history[0].entry.data.title : candidate.model.intent.title,
-        objective: candidate.model.intent.objective,
-        lifecycle: candidate.lifecycle,
-        target: { branch: candidate.model.pins.target.ref },
-    }));
-}
-function truncateObjectiveFirstLine(objective) {
-    const firstLine = objective.split(/\r?\n/, 1)[0]?.trim() ?? "";
-    if (firstLine.length <= AMBIGUOUS_OBJECTIVE_MAX_CHARS)
-        return firstLine;
-    return `${firstLine.slice(0, AMBIGUOUS_OBJECTIVE_MAX_CHARS)}…`;
-}
-function formatAmbiguousCandidate(candidate) {
-    const coordinate = formatCommissionCoordinate({
-        commissionId: candidate.commissionId,
-        place: candidate.place,
-    });
-    const objective = truncateObjectiveFirstLine(candidate.objective);
-    return [coordinate, objective || undefined, candidate.commissionId]
-        .filter((part) => part !== undefined)
-        .join(" · ");
-}
-async function resolvedRepository(cwd) {
-    return { kind: "repository", stableRoot: await stableRepoRoot(cwd) };
-}
-function buildResolvedAddress(input) {
-    return {
-        repo: input.repo,
-        workdir: input.workdir,
-        binding: { kind: "commission", commissionId: input.candidate.contractId },
-        spelling: { asTyped: input.asTyped, source: input.source, matchedBy: input.matchedBy },
-        place: { display: candidatePlace(input.candidate) },
-        lifecycle: input.candidate.lifecycle,
-        target: { branch: input.candidate.model.pins.target.ref },
-        inference: input.inference,
-    };
-}
-export function buildUncommissionedAddress(input) {
-    return {
-        repo: input.repo,
-        workdir: path.resolve(input.workdir),
-        binding: { kind: input.binding },
-        inference: [...(input.inference ?? [])],
-    };
-}
-export function buildUncommissionedRepositoryAddress(input) {
-    return buildUncommissionedAddress({
-        repo: { kind: "repository", stableRoot: input.stableRoot },
-        workdir: input.workdir,
-        binding: input.binding,
-        inference: input.inference,
-    });
-}
-export function resolveExplicitContractAddressFromRead(input) {
-    const workdir = path.resolve(input.workdir);
-    const repo = { kind: "repository", stableRoot: input.stableRoot };
-    const query = normalizeAddressQuery(input.raw);
-    const source = input.source ?? (input.raw.startsWith("@") ? "at-address" : "explicit-flag");
-    const spelling = { asTyped: commissionSelectorAsTyped(query, source), source };
-    if (isResponseArtifactId(query)) {
-        throw new AddressResolutionError("UNKNOWN_ADDRESS", `artifact ${query} is a response artifact; expected a commission address`, { repo, workdir, expected: "commission", spelling, candidates: [], inference: [], actual: "artifact" });
-    }
-    const identities = explicitAddressIdentities(input.read, query);
-    const attempt = {
-        repo,
-        workdir,
-        expected: "commission",
-        spelling,
-        candidates: identities.map(resolutionCandidateForIdentity),
-        inference: [],
-    };
-    if (identities.length > 1) {
-        const detail = attempt.candidates.length > 0
-            ? `:\n${attempt.candidates.map((candidate) => `  ${formatAmbiguousCandidate(candidate)}`).join("\n")}`
-            : "";
-        throw new AddressResolutionError("CONTRACT_AMBIGUOUS", `@${query} is ambiguous${detail}\nuse a full @commission-id`, attempt);
-    }
-    if (identities.length === 1) {
-        const identity = identities[0];
-        if (identity.outcome.status !== "healthy") {
-            if (identity.outcome.status === "absent") {
-                throw new FlowError("INTERNAL_STATE", `contract ${identity.contractId} disappeared from the repository lifecycle read model`);
-            }
-            throw contractReadOutcomeError(identity.contractId, identity.outcome);
-        }
-        const candidate = identity.candidate;
-        if (!candidate) {
-            throw new FlowError("INTERNAL_STATE", `healthy contract ${identity.contractId} matched without a lifecycle model`);
-        }
-        const matchedBy = preferredCommissionSpelling(identity.matchedSpellings);
-        const address = buildResolvedAddress({
-            repo,
-            workdir,
-            candidate,
-            matchedBy,
-            asTyped: spelling.asTyped,
-            source,
-            inference: [],
-        });
-        return { address, model: candidate.model };
-    }
-    const unknown = admitRepositoryLifecycleContract(input.read, query);
-    if (unknown.status === "diseased" || unknown.status === "isolated" || unknown.status === "indeterminate") {
-        throw contractReadOutcomeError(query, unknown);
-    }
-    throw new AddressResolutionError("UNKNOWN_ADDRESS", `unknown contract address @${query}`, attempt);
-}
-export async function resolveContractAddress(cwd, raw, source = raw?.startsWith("@") ? "at-address" : "explicit-flag", effectiveDirectory = cwd) {
-    const workdir = path.resolve(effectiveDirectory);
-    const repo = await resolvedRepository(cwd);
-    const read = await readRepositoryLifecycle(repo.stableRoot);
-    if (raw !== undefined) {
-        return resolveExplicitContractAddressFromRead({
-            read,
-            stableRoot: repo.stableRoot,
-            workdir,
-            raw,
-            source,
-        }).address;
-    }
-    const candidates = commissionAddressCandidates(read);
-    let boundContractId;
-    try {
-        const effectiveRepo = await stableRepoRoot(workdir);
-        if (effectiveRepo === repo.stableRoot) {
-            boundContractId = await currentContractBoundByWorktreeWitness({
-                cwd: workdir,
-                stableRoot: effectiveRepo,
-                contracts: candidates.filter((candidate) => candidate.operable).map((candidate) => candidate.model),
-            });
-        }
-    }
-    catch (error) {
-        if (!errorContainsAnyPattern(error, NOT_GIT_REPOSITORY_PATTERNS))
-            throw error;
-    }
-    if (boundContractId) {
-        const candidate = candidates.find((item) => item.operable && item.contractId === boundContractId);
-        if (candidate) {
-            admitContractCandidate(read, candidate);
-            return buildResolvedAddress({
-                repo,
-                workdir,
-                candidate,
-                matchedBy: "id",
-                asTyped: `@${candidate.contractId}`,
-                source: "worktree-binding",
-                inference: ["verified active engine worktree binding"],
-            });
-        }
-    }
-    const operable = candidates.filter((candidate) => candidate.operable);
-    const attempt = {
-        repo,
-        workdir,
-        expected: "commission",
-        candidates: attemptCandidates(operable),
-        inference: ["consulted repository lifecycle ledger"],
-    };
-    if (operable.length === 1) {
-        const candidate = admitContractCandidate(read, operable[0]);
-        return buildResolvedAddress({
-            repo,
-            workdir,
-            candidate,
-            matchedBy: "id",
-            asTyped: `@${candidate.contractId}`,
-            source: "sole-active",
-            inference: attempt.inference,
-        });
-    }
-    throw new AddressResolutionError(operable.length === 0 ? "UNKNOWN_ADDRESS" : "CONTRACT_AMBIGUOUS", operable.length === 0
-        ? "no active commission found; pass @place, @slug, full @commission-id, or --contract <addr>"
-        : "multiple active commissions found; pass @place, @slug, full @commission-id, or --contract <addr>", attempt);
-}
-/**
- * `call` may inherit only the active commission proven by the selected
- * engine-owned worktree. Unlike existing-contract resolution, this never
- * considers sole-active cardinality.
- */
-export async function resolveCallWorktreeAddressFromRead(input) {
-    const repo = { kind: "repository", stableRoot: input.stableRoot };
-    const workdir = path.resolve(input.workdir);
-    const candidates = commissionAddressCandidates(input.read).filter((candidate) => candidate.operable);
-    let contractId;
-    try {
-        const effectiveRepo = await stableRepoRoot(workdir);
-        if (effectiveRepo !== repo.stableRoot)
-            return undefined;
-        contractId = await currentContractBoundByWorktreeWitness({
-            cwd: workdir,
-            stableRoot: effectiveRepo,
-            contracts: candidates.map((candidate) => candidate.model),
-        });
-    }
-    catch (error) {
-        if (!errorContainsAnyPattern(error, NOT_GIT_REPOSITORY_PATTERNS))
-            throw error;
-        return undefined;
-    }
-    if (!contractId)
-        return undefined;
-    const candidate = candidates.find((item) => item.contractId === contractId);
-    if (!candidate)
-        return undefined;
-    const address = buildResolvedAddress({
-        repo,
-        workdir,
-        candidate,
-        matchedBy: "id",
-        asTyped: `@${candidate.contractId}`,
-        source: "worktree-binding",
-        inference: ["verified active engine worktree binding"],
-    });
-    return admittedAddress(input.read, candidate, address);
-}
-export async function resolveCallWorktreeAddress(cwd, effectiveDirectory = cwd) {
-    const repo = await resolvedRepository(cwd);
-    const admitted = await resolveCallWorktreeAddressFromRead({
-        read: await readRepositoryLifecycle(repo.stableRoot),
-        stableRoot: repo.stableRoot,
-        workdir: effectiveDirectory,
-    });
-    return admitted?.address;
-}
-export async function resolveExistingContractAddress(cwd, raw, source = raw?.startsWith("@") ? "at-address" : "explicit-flag", effectiveDirectory = cwd) {
-    return resolveContractAddress(cwd, raw, source, effectiveDirectory);
-}