@astrosheep/keiyaku 2.9.9 → 2.9.11

package/build/core/address-carrier.js

@@ -0,0 +1,89 @@
+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,12 +1,14 @@
 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, isCommissionId } from "./ids.js";
-import { readAllLedgerSnapshots, readLedgerSnapshot } from "./ledger-batch.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 { activeContractBoundByEngineWorktree, stableRepoRoot } from "./worktree-path.js";
-import { assertNoRenewRecoverySession } from "./renew-session.js";
-import { deriveContractState, isTerminalState, } from "./status/lifecycle.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;
@@ -15,88 +17,6 @@ function normalizeAddressQuery(raw) {
     }
     return value.trim();
 }
-const ADDRESS_CARRIER = Symbol.for("keiyaku.address-carrier");
-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",
-    };
-}
 function commissionSelectorAsTyped(query, source) {
     if (source === "at-address")
         return `@${query}`;
@@ -104,63 +24,163 @@ function commissionSelectorAsTyped(query, source) {
         return `--contract ${query}`;
     return query;
 }
-export class AddressResolutionError extends FlowError {
-    attempt;
-    constructor(code, message, attempt, options) {
-        super(code, message, options);
-        this.name = "AddressResolutionError";
-        this.attempt = attempt;
+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 candidatePlace(candidate) {
-    return candidate.bind.data.workspace === "worktree" ? candidate.bind.data.place ?? null : null;
+function commissionAddressCandidates(read) {
+    return read.contracts.map((model) => {
+        const lifecycle = legacyLifecycle(model);
+        return {
+            contractId: model.contract,
+            model,
+            operable: !isTerminalState(lifecycle),
+            lifecycle,
+        };
+    });
 }
-function commissionAddressCandidatesFromLedgers(ledgers) {
-    return ledgers.flatMap((ledger) => {
-        const bind = ledger.entries.find((entry) => entry.kind === "bind");
-        if (!bind || bind.contract !== ledger.contractId)
-            return [];
-        const lifecycle = deriveContractState(ledger.entries);
-        return [{
-                contractId: ledger.contractId,
-                bind,
-                active: lifecycle.state !== "corrupt" && !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 }),
+            })),
+        },
     });
 }
-async function commissionAddressCandidates(cwd, exactContractId) {
-    if (exactContractId) {
-        const ledger = await readLedgerSnapshot(cwd, exactContractId);
-        return ledger ? commissionAddressCandidatesFromLedgers([ledger]) : [];
+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");
     }
-    const reads = await readAllLedgerSnapshots(cwd);
-    const failed = reads.find((read) => "error" in read);
-    if (failed && "error" in failed)
-        throw failed.error;
-    return commissionAddressCandidatesFromLedgers(reads.filter((read) => !("error" in read)));
+    return matches;
 }
-function matchCommissionAddress(query, candidates) {
-    return candidates.flatMap((candidate) => {
-        const matches = [];
-        if (candidate.contractId === query)
-            matches.push({ ...candidate, spelling: "id" });
-        if (commissionSlug(candidate.contractId) === query)
-            matches.push({ ...candidate, spelling: "slug" });
-        if (candidate.active && candidatePlace(candidate) === query) {
-            matches.push({ ...candidate, spelling: "place" });
+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;
         }
-        return matches;
-    });
+        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.bind.data.name,
-        objective: candidate.bind.data.objective,
+        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.bind.data.target },
+        target: { branch: candidate.model.pins.target.ref },
     }));
 }
 function truncateObjectiveFirstLine(objective) {
@@ -190,7 +210,7 @@ function buildResolvedAddress(input) {
         spelling: { asTyped: input.asTyped, source: input.source, matchedBy: input.matchedBy },
         place: { display: candidatePlace(input.candidate) },
         lifecycle: input.candidate.lifecycle,
-        target: { branch: input.candidate.bind.data.target },
+        target: { branch: input.candidate.model.pins.target.ref },
         inference: input.inference,
     };
 }
@@ -210,64 +230,83 @@ export function buildUncommissionedRepositoryAddress(input) {
         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("EMPTY_PARAM", `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("EMPTY_PARAM", `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) {
-        const query = normalizeAddressQuery(raw);
-        const spelling = { asTyped: commissionSelectorAsTyped(query, source), source };
-        // Lexical artifact fence: no ledger enumeration for rsp_<ULID>.
-        if (isResponseArtifactId(query)) {
-            throw new AddressResolutionError("EMPTY_PARAM", `artifact ${query} is a response artifact; expected a commission address`, {
-                repo,
-                workdir,
-                expected: "commission",
-                spelling,
-                candidates: [],
-                inference: [],
-                actual: "artifact",
-            });
-        }
-        const candidates = await commissionAddressCandidates(repo.stableRoot, isCommissionId(query) ? query : undefined);
-        const matches = matchCommissionAddress(query, candidates);
-        const attempt = {
-            repo,
+        return resolveExplicitContractAddressFromRead({
+            read,
+            stableRoot: repo.stableRoot,
             workdir,
-            expected: "commission",
-            spelling,
-            candidates: matches.map((candidate) => ({
-                commissionId: candidate.contractId,
-                matchedBy: candidate.spelling,
-                place: candidatePlace(candidate),
-                name: candidate.bind.data.name,
-                objective: candidate.bind.data.objective,
-                lifecycle: candidate.lifecycle,
-                target: { branch: candidate.bind.data.target },
-            })),
-            inference: [],
-        };
-        if (matches.length === 1) {
-            return buildResolvedAddress({
-                repo,
-                workdir,
-                candidate: matches[0],
-                matchedBy: matches[0].spelling,
-                asTyped: attempt.spelling.asTyped,
-                source,
-                inference: [],
-            });
-        }
-        if (matches.length === 0) {
-            throw new AddressResolutionError("EMPTY_PARAM", `unknown contract address @${query}`, attempt);
-        }
-        throw new AddressResolutionError("CONTRACT_AMBIGUOUS", `@${query} is ambiguous:\n${attempt.candidates.map((candidate) => `  ${formatAmbiguousCandidate(candidate)}`).join("\n")}\nuse a full @commission-id`, attempt);
+            raw,
+            source,
+        }).address;
     }
-    const candidates = await commissionAddressCandidates(repo.stableRoot);
+    const candidates = commissionAddressCandidates(read);
     let boundContractId;
     try {
         const effectiveRepo = await stableRepoRoot(workdir);
         if (effectiveRepo === repo.stableRoot) {
-            boundContractId = await activeContractBoundByEngineWorktree(workdir, effectiveRepo);
+            boundContractId = await currentContractBoundByWorktreeWitness({
+                cwd: workdir,
+                stableRoot: effectiveRepo,
+                contracts: candidates.filter((candidate) => candidate.operable).map((candidate) => candidate.model),
+            });
         }
     }
     catch (error) {
@@ -275,8 +314,9 @@ export async function resolveContractAddress(cwd, raw, source = raw?.startsWith(
             throw error;
     }
     if (boundContractId) {
-        const candidate = candidates.find((item) => item.active && item.contractId === boundContractId);
+        const candidate = candidates.find((item) => item.operable && item.contractId === boundContractId);
         if (candidate) {
+            admitContractCandidate(read, candidate);
             return buildResolvedAddress({
                 repo,
                 workdir,
@@ -288,16 +328,16 @@ export async function resolveContractAddress(cwd, raw, source = raw?.startsWith(
             });
         }
     }
-    const operable = candidates.filter((candidate) => candidate.active);
+    const operable = candidates.filter((candidate) => candidate.operable);
     const attempt = {
         repo,
         workdir,
         expected: "commission",
         candidates: attemptCandidates(operable),
-        inference: ["consulted active commission ledgers"],
+        inference: ["consulted repository lifecycle ledger"],
     };
     if (operable.length === 1) {
-        const candidate = operable[0];
+        const candidate = admitContractCandidate(read, operable[0]);
         return buildResolvedAddress({
             repo,
             workdir,
@@ -317,15 +357,20 @@ export async function resolveContractAddress(cwd, raw, source = raw?.startsWith(
  * engine-owned worktree. Unlike existing-contract resolution, this never
  * considers sole-active cardinality.
  */
-export async function resolveCallWorktreeAddress(cwd, effectiveDirectory = cwd) {
-    const repo = await resolvedRepository(cwd);
-    const workdir = path.resolve(effectiveDirectory);
+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 activeContractBoundByEngineWorktree(workdir, effectiveRepo);
+        contractId = await currentContractBoundByWorktreeWitness({
+            cwd: workdir,
+            stableRoot: effectiveRepo,
+            contracts: candidates.map((candidate) => candidate.model),
+        });
     }
     catch (error) {
         if (!errorContainsAnyPattern(error, NOT_GIT_REPOSITORY_PATTERNS))
@@ -334,15 +379,29 @@ export async function resolveCallWorktreeAddress(cwd, effectiveDirectory = cwd)
     }
     if (!contractId)
         return undefined;
-    return await resolveContractAddress(repo.stableRoot, contractId, "worktree-binding", workdir);
+    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) {
-    const address = await resolveContractAddress(cwd, raw, source, effectiveDirectory);
-    try {
-        await assertNoRenewRecoverySession(address.repo.stableRoot, address.binding.commissionId);
-    }
-    catch (error) {
-        throw attachAddressCarrier(error, address);
-    }
-    return address;
+    return resolveContractAddress(cwd, raw, source, effectiveDirectory);
 }