@astrosheep/keiyaku 4.0.1 → 4.0.2

package/build/src/cli/draft.d.ts

@@ -0,0 +1,8 @@
+import type { WorldRoot } from "../world.js";
+import type { BindDraftReceipt } from "./result.js";
+export declare class BindDraftError extends Error {
+    readonly original: unknown;
+    readonly draft: BindDraftReceipt;
+    constructor(original: unknown, draft: BindDraftReceipt);
+}
+export declare function preserveBindDraft(world: WorldRoot, markdown: string, now?: number): Promise<BindDraftReceipt>;

package/build/src/cli/draft.js

@@ -0,0 +1,96 @@
+import { createHash } from "node:crypto";
+import { lstatSync, mkdirSync, readFileSync, readdirSync, unlinkSync, utimesSync } from "node:fs";
+import { join } from "node:path";
+import { repairDerivedFile, replaceFileDurably } from "../coordination/durable-file.js";
+const RETENTION_MS = 7 * 24 * 60 * 60 * 1_000;
+const DRAFT_NAME = /^bind-[0-9a-f]{64}\.md$/u;
+export class BindDraftError extends Error {
+    original;
+    draft;
+    constructor(original, draft) {
+        super(original instanceof Error ? original.message : String(original));
+        this.name = "BindDraftError";
+        this.original = original;
+        this.draft = draft;
+    }
+}
+function diagnostic(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function sweep(directory, now) {
+    for (const entry of readdirSync(directory, { withFileTypes: true })) {
+        if (!entry.isFile() || !DRAFT_NAME.test(entry.name))
+            continue;
+        const path = join(directory, entry.name);
+        try {
+            if (now - lstatSync(path).mtimeMs > RETENTION_MS)
+                unlinkSync(path);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+    }
+}
+export async function preserveBindDraft(world, markdown, now = Date.now()) {
+    const digest = createHash("sha256").update(markdown, "utf8").digest("hex");
+    const name = `bind-${digest}.md`;
+    const relativePath = `.keiyaku/draft/${name}`;
+    const directory = join(world, ".keiyaku", "draft");
+    const path = join(directory, name);
+    const warnings = [];
+    try {
+        mkdirSync(directory, { recursive: true });
+    }
+    catch (error) {
+        return { warning: `bind draft could not be preserved: ${diagnostic(error)}` };
+    }
+    try {
+        await repairDerivedFile(join(directory, ".gitignore"), "*\n");
+    }
+    catch (error) {
+        warnings.push(`bind draft ignore could not be maintained: ${diagnostic(error)}`);
+    }
+    try {
+        let equal = false;
+        try {
+            const status = lstatSync(path);
+            equal = status.isFile() && !status.isSymbolicLink() && readFileSync(path).equals(Buffer.from(markdown));
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+        if (equal) {
+            try {
+                const touched = new Date(now);
+                utimesSync(path, touched, touched);
+            }
+            catch (error) {
+                if (error.code !== "ENOENT")
+                    throw error;
+                await replaceFileDurably(path, markdown);
+            }
+        }
+        else {
+            await replaceFileDurably(path, markdown);
+        }
+        if (!readFileSync(path).equals(Buffer.from(markdown))) {
+            throw new Error(`bind draft bytes do not match their content address: ${relativePath}`);
+        }
+    }
+    catch (error) {
+        warnings.push(`bind draft could not be preserved: ${diagnostic(error)}`);
+        return { warning: warnings.join("; ") };
+    }
+    try {
+        sweep(directory, now);
+    }
+    catch (error) {
+        warnings.push(`bind draft sweep failed: ${diagnostic(error)}`);
+    }
+    return {
+        path: relativePath,
+        ...(warnings.length === 0 ? {} : { warning: warnings.join("; ") }),
+    };
+}

package/build/src/cli/invoke.d.ts

@@ -1,14 +1,15 @@
-import { type ContractId, type Settings } from "../index.js";
+import { type ActorId, type ContractId, type Settings } from "../index.js";
 import { type AkumaInvocationResult } from "./commands/akuma-invoke.js";
 import { type InstallInvocationResult } from "./commands/install.js";
 import { type TaskInvocationResult } from "./commands/task-invoke.js";
 import { type ParsedExecution } from "./parse.js";
 import type { InvocationResult } from "./result.js";
-export type { AcceptedFact, DiffUnavailable, InvocationResult, Lag } from "./result.js";
+export type { AcceptedFact, InvocationResult, Lag } from "./result.js";
 type InvokeRuntime = Readonly<{
     cwd?: string;
     environment?: NodeJS.ProcessEnv;
-    readStdin?: () => string;
+    readStdin?: () => Promise<string>;
+    actor?: ActorId;
 }>;
 export type SettingsInvocationResult = Readonly<{
     kind: "settings";

package/build/src/cli/invoke.js

@@ -1,9 +1,7 @@
-import { readFileSync, realpathSync } from "node:fs";
-import { resolve } from "node:path";
-import { gatesFrom, Keiyaku, NoGitWorldError, Repo, requireBranchesToBeUpToDateFrom, settings, SettingsError, worktreeHooksFrom } from "../index.js";
-import { kanshi, selectKanshi } from "../kanshi/index.js";
+import { AkumaWorldScopeError, gatesFrom, Keiyaku, requireBranchesToBeUpToDateFrom, settings, SettingsError, worktreeHooksFrom } from "../index.js";
+import { kanshi, selectKanshi, selectRegion } from "../kanshi/index.js";
 import { resolveActor } from "./actor.js";
-import { resultFromMutationCall } from "./accepted.js";
+import { acceptedAbandon, acceptedAmend, acceptedArc, acceptedAudit, acceptedBind, acceptedDeliver, acceptedReview, resultFromMutationCall, } from "./accepted.js";
 import { amendFromCommand } from "./commands/amend.js";
 import { invokeAkuma, invokeAkumaStatus } from "./commands/akuma-invoke.js";
 import { isParsedAkumaCommand } from "./commands/akuma.js";
@@ -11,42 +9,53 @@ import { bindFromCommand } from "./commands/bind.js";
 import { installHarnesses } from "./commands/install.js";
 import { invokeTask } from "./commands/task-invoke.js";
 import { CliUsageError, renderCommandUsage } from "./parse.js";
+import { isBlankInput } from "./usage.js";
 import { contractFromInput, resolveContextualContract, resolveKanshiContract } from "./selectors.js";
 import { resolveNamedAddress } from "../library/address.js";
-import { World, WorldError } from "../world.js";
-function settingsAt(root, environment) {
-    const home = environment.KEIYAKU_HOME?.trim();
-    return settings({ ...(root === undefined ? {} : { root }), ...(home === undefined || home.length === 0 ? {} : { home }) });
+import { assertExplicitRepoUse, resolveCliCoordinates } from "./coordinates.js";
+import { BindDraftError, preserveBindDraft } from "./draft.js";
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin)
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    return Buffer.concat(chunks).toString("utf8");
 }
-function locateWorld(coordinate) {
-    try {
-        return World.locate(coordinate);
-    }
-    catch (error) {
-        if (error instanceof WorldError)
-            throw new CliUsageError(error.message);
-        throw error;
+function selectedStdinDiagnostic(command) {
+    switch (command.command) {
+        case "bind":
+        case "amend":
+        case "arc":
+            return `${command.command} requires a nonblank stdin document`;
+        case "review":
+            return command.summaryFromStdin === true ? "review requires a nonblank summary" : undefined;
+        case "call":
+        case "tell":
+            return command.prompt.kind === "stdin" ? `${command.command} requires a nonblank prompt` : undefined;
+        case "task":
+            switch (command.stdin) {
+                case "document": return "task add requires a nonblank stdin document";
+                case "compose": return "task compose requires a nonblank stdin document";
+                case "body": return "task update --body requires a nonblank value";
+                case "append": return "task update --append requires a nonblank value";
+                case "note": return "task update --note requires a nonblank value";
+                default: return undefined;
+            }
+        default:
+            return undefined;
     }
 }
-function canonicalInvocationCwd(input) {
-    try {
-        return realpathSync(input);
-    }
-    catch {
-        throw new CliUsageError(`invocation cwd is not an existing directory: ${input}`);
-    }
+async function withAcquiredStdin(command, runtime) {
+    const diagnostic = selectedStdinDiagnostic(command);
+    if (diagnostic === undefined)
+        return runtime;
+    const bytes = await (runtime.readStdin ?? readStdin)();
+    if (isBlankInput(bytes))
+        throw new CliUsageError(diagnostic);
+    return { ...runtime, readStdin: async () => bytes };
 }
-function establishWorld(coordinate, located) {
-    if (located !== null)
-        return located;
-    try {
-        return World.at(coordinate);
-    }
-    catch (error) {
-        if (error instanceof WorldError)
-            throw new CliUsageError(error.message);
-        throw error;
-    }
+function settingsAt(root, environment) {
+    const home = environment.KEIYAKU_HOME?.trim();
+    return settings({ ...(root === undefined ? {} : { root }), ...(home === undefined || home.length === 0 ? {} : { home }) });
 }
 function selectedGates(value, name) {
     try {
@@ -88,93 +97,47 @@ function actorFromEdge(actor, environment) {
     }
     return resolved;
 }
-function repoAt(coordinate) {
-    return Repo.at({ path: coordinate });
-}
-function optionalRepoAt(coordinate) {
-    try {
-        return repoAt(coordinate);
-    }
-    catch (error) {
-        if (error instanceof NoGitWorldError)
-            return undefined;
-        throw error;
-    }
-}
-function repoUse(command) {
-    switch (command.command) {
-        case "bind":
-        case "amend":
-        case "deliver":
-        case "review":
-        case "arc":
-        case "abandon":
-        case "audit":
-        case "reconcile":
-        case "show":
-            return "required";
-        case "ls":
-            return command.query.kind === "contracts" ? "required" : "none";
-        case "status":
-        case "tell":
-        case "history":
-        case "fork":
-            return "optional";
-        case "wait":
-        case "kill":
-            return command.akuma.some((selector) => selector.startsWith("kei/")) ? "required" : "optional";
-        case "call":
-            return command.contract === undefined ? "none" : "required";
-        case "settings":
-        case "task":
-        case "install":
-            return "none";
-    }
-}
-function refuseUnusedRepo(command) {
-    if (command.command === "call")
-        throw new CliUsageError("--repo has no consumer without --contract");
-    throw new CliUsageError(`--repo has no consumer for ${command.command}`);
-}
-function repoFor(use, coordinate) {
-    switch (use) {
-        case "none": return undefined;
-        case "optional": return optionalRepoAt(coordinate);
-        case "required": return repoAt(coordinate);
-    }
-}
 async function selectContract(repo, selector, scope) {
     if (selector !== undefined && !selector.startsWith("@"))
         return contractFromInput(repo, selector);
     const id = resolveContextualContract(await Keiyaku.list({ repo }), selector, scope);
     return contractFromInput(repo, id);
 }
-async function invokeBind(parsed, repo, edge, configuration, hooks) {
-    const markdown = edge.readStdin();
+async function bindDraftReceipt(establishWorld, markdown) {
+    try {
+        return preserveBindDraft(await establishWorld(), markdown);
+    }
+    catch (error) {
+        return { warning: `bind draft could not be preserved: ${error instanceof Error ? error.message : String(error)}` };
+    }
+}
+async function invokeBind({ parsed, repo, edge, configuration, hooks, establishWorld }) {
+    const markdown = await edge.readStdin();
     const gates = selectedGates(configuration, parsed.gates);
     const actor = actorFromEdge(parsed.actor, edge.environment);
-    return resultFromMutationCall("bind", () => bindFromCommand({
-        command: parsed,
-        repo,
-        markdown,
-        gates,
-        ...(actor === undefined ? {} : { actor }),
-        hooks,
-    }), {
-        project: (result) => {
-            const bound = result.facts.find((fact) => fact.kind === "bind");
+    try {
+        const result = await resultFromMutationCall("bind", () => bindFromCommand({
+            command: parsed,
+            repo,
+            markdown,
+            gates,
+            ...(actor === undefined ? {} : { actor }),
+            hooks,
+        }), (accepted) => {
+            const bound = accepted.facts.find((fact) => fact.kind === "bind");
             if (bound === undefined || bound.kind !== "bind")
                 throw new Error("accepted bind is missing its bind fact");
-            return { target: bound.data.coordinates.target ?? null };
-        },
-    });
-}
-function unavailableDiff(delivery) {
-    return {
-        reason: "git-unavailable",
-        integrationSnapshot: delivery.integration.snapshot,
-        changeId: delivery.integration.changeId,
-    };
+            return acceptedBind(accepted, bound.data.coordinates.target ?? null);
+        });
+        if (result.kind !== "refused")
+            return result;
+        return { ...result, draft: await bindDraftReceipt(establishWorld, markdown) };
+    }
+    catch (error) {
+        if (!(error instanceof TypeError))
+            throw error;
+        throw new BindDraftError(error, await bindDraftReceipt(establishWorld, markdown));
+    }
 }
 function deliverRefusal(refusal) {
     if (typeof refusal !== "object" || refusal === null || !("kind" in refusal) || refusal.kind !== "dirty-workspace") {
@@ -190,50 +153,28 @@ async function invokeDeliver(parsed, seat, requireBranchesToBeUpToDate) {
         requireBranchesToBeUpToDate,
         includeDirty: parsed.includeDirty,
         hooks: seat.hooks,
-    }), {
+    }), (result) => acceptedDeliver(result, seat.id), {
         coordinate: seat.id,
         projectRefusal: deliverRefusal,
-        project: (result) => ({
-            obligations: {
-                ...(result.value.verification === undefined ? {} : { verification: result.value.verification }),
-                ...(result.value.placement === undefined ? {} : { placement: result.value.placement }),
-                ...(result.value.cleanup === undefined ? {} : { cleanup: result.value.cleanup }),
-                ...(result.value.leak === undefined ? {} : { leak: result.value.leak }),
-            },
-        }),
     });
 }
 async function invokeReview(parsed, seat, readStdin) {
-    const summary = parsed.summaryFromStdin === true ? readStdin() : parsed.summary;
+    const summary = parsed.summaryFromStdin === true ? await readStdin() : parsed.summary;
     return resultFromMutationCall("review", () => seat.contract.review({
         verdict: parsed.verdict,
         ...(seat.actor === undefined ? {} : { actor: seat.actor }),
         ...(summary === undefined ? {} : { summary }),
         hooks: seat.hooks,
-    }), {
-        coordinate: seat.id,
-        project: (result) => ({
-            obligations: result.value.placement === undefined ? {} : { placement: result.value.placement },
-            workspace: result.value.workspace,
-        }),
-    });
+    }), (result) => acceptedReview(result, seat.id), { coordinate: seat.id });
 }
-async function invokeAudit(parsed, seat) {
-    const delivery = parsed.showDiffBody ? await seat.contract.delivery() : null;
-    return resultFromMutationCall("audit", () => seat.contract.audit({ ...(seat.actor === undefined ? {} : { actor: seat.actor }), hooks: seat.hooks }), {
-        coordinate: seat.id,
-        project: async (result) => {
-            let renderedDiff;
-            if (parsed.showDiffBody && delivery !== null) {
-                const diff = await delivery.diff();
-                renderedDiff = diff === null ? unavailableDiff(delivery) : diff;
-            }
-            return {
-                report: result.value,
-                ...(renderedDiff === undefined ? {} : { diff: renderedDiff }),
-            };
-        },
-    });
+async function invokeAudit(parsed, seat, requireBranchesToBeUpToDate) {
+    return resultFromMutationCall("audit", () => seat.contract.audit({
+        ...(seat.actor === undefined ? {} : { actor: seat.actor }),
+        includeDirty: parsed.includeDirty,
+        showDiff: parsed.showDiff,
+        requireBranchesToBeUpToDate,
+        hooks: seat.hooks,
+    }), (result) => acceptedAudit(result, seat.id), { coordinate: seat.id });
 }
 async function invokeExisting({ parsed, repo, edge, scope, configuration, hooks }) {
     const { id, contract } = await selectContract(repo, parsed.contract, scope);
@@ -241,32 +182,32 @@ async function invokeExisting({ parsed, repo, edge, scope, configuration, hooks
     const seat = { contract, id, ...(actor === undefined ? {} : { actor }), hooks };
     switch (parsed.command) {
         case "amend": {
-            const markdown = edge.readStdin();
+            const markdown = await edge.readStdin();
             const gates = parsed.gates === undefined
                 ? undefined
                 : selectedGates(configuration, parsed.gates);
-            return resultFromMutationCall("amend", () => amendFromCommand({ command: parsed, repo, contract, markdown, gates, ...(actor === undefined ? {} : { actor }), hooks }), { coordinate: id });
+            return resultFromMutationCall("amend", () => amendFromCommand({ command: parsed, repo, contract, markdown, gates, ...(actor === undefined ? {} : { actor }), hooks }), (result) => acceptedAmend(result, id), { coordinate: id });
         }
         case "deliver":
             return invokeDeliver(parsed, seat, selectedGitPolicy(configuration));
         case "review":
             return invokeReview(parsed, seat, edge.readStdin);
         case "arc": {
-            const markdown = edge.readStdin();
+            const markdown = await edge.readStdin();
             return resultFromMutationCall("arc", () => contract.arc({
                 markdown,
                 ...(actor === undefined ? {} : { actor }),
                 hooks,
-            }), { coordinate: id });
+            }), (result) => acceptedArc(result, id), { coordinate: id });
         }
         case "abandon":
             return resultFromMutationCall("abandon", () => contract.abandon({
                 ...(actor === undefined ? {} : { actor }),
                 ...(parsed.note === undefined ? {} : { note: parsed.note }),
                 hooks,
-            }), { coordinate: id });
+            }), (result) => acceptedAbandon(result, id), { coordinate: id });
         case "audit":
-            return invokeAudit(parsed, seat);
+            return invokeAudit(parsed, seat, selectedGitPolicy(configuration));
         default:
             return parsed;
     }
@@ -279,7 +220,7 @@ async function invokeAkumaCommand(parsed, input) {
         const selected = contractFromInput(repo, parsed.contract);
         return await invokeAkuma(parsed, {
             path,
-            executionCwd,
+            ...(executionCwd === undefined ? {} : { executionCwd }),
             settings: configuration,
             contract: selected.contract,
             readStdin: edge.readStdin,
@@ -287,7 +228,7 @@ async function invokeAkumaCommand(parsed, input) {
     }
     return await invokeAkuma(parsed, {
         path,
-        executionCwd,
+        ...(executionCwd === undefined ? {} : { executionCwd }),
         settings: configuration,
         ...(repo === undefined ? {} : { repo }),
         readStdin: edge.readStdin,
@@ -298,13 +239,15 @@ async function invokeAkumaFromEdge(parsed, input) {
         return await invokeAkumaCommand(parsed, input);
     }
     catch (error) {
+        if (error instanceof AkumaWorldScopeError)
+            throw error;
         if (error instanceof TypeError)
             throw new CliUsageError(error.message);
         throw error;
     }
 }
-function akumaWorldFor(parsed, cwd, located) {
-    const world = parsed.command === "call" ? establishWorld(cwd, located) : located;
+async function akumaWorldFor(parsed, located, candidate, establish) {
+    const world = parsed.command === "call" ? candidate ?? await establish() : located;
     if (world === null)
         throw new CliUsageError("no Keiyaku world contains the invocation cwd");
     return world;
@@ -319,7 +262,7 @@ async function invokeCatalog(parsed, world, repo, edge) {
         if (parsed.query.kind === "archetypes") {
             return {
                 kind: "catalog",
-                catalog: await Keiyaku.ls({ query: parsed.query, settings: settingsAt(undefined, edge.environment) }),
+                catalog: await Keiyaku.ls({ query: parsed.query, settings: await settingsAt(undefined, edge.environment) }),
             };
         }
         if (world === null)
@@ -336,7 +279,7 @@ async function invokeCatalog(parsed, world, repo, edge) {
     }
 }
 async function invokeStatus(parsed, world, repo, edge) {
-    const configuration = settingsAt(world ?? undefined, edge.environment);
+    const configuration = await settingsAt(world ?? undefined, edge.environment);
     if (parsed.akuma === true) {
         if (world === null)
             throw new CliUsageError("no Keiyaku world contains the invocation cwd");
@@ -348,7 +291,7 @@ async function invokeStatus(parsed, world, repo, edge) {
     }
     if (parsed.contract.startsWith("@")) {
         try {
-            const address = resolveNamedAddress({
+            const address = await resolveNamedAddress({
                 path: world,
                 selector: parsed.contract,
                 contracts: repo === undefined ? [] : (await Keiyaku.list({ repo })).rows,
@@ -371,26 +314,59 @@ async function invokeStatus(parsed, world, repo, edge) {
     const contract = resolveKanshiContract(report, parsed.contract);
     return { kind: "status", report: selectKanshi({ report, contract }), selection: "contract" };
 }
-async function invokeParsed(invocation, runtime, use) {
-    const processCwd = resolve(runtime.cwd ?? ".");
-    const cwd = canonicalInvocationCwd(resolve(processCwd, invocation.cwd ?? "."));
+async function invokeRegion(parsed, world, repo) {
+    const read = async (region) => {
+        try {
+            return await kanshi({ world, repo, region });
+        }
+        catch (error) {
+            if (error instanceof TypeError)
+                throw new CliUsageError(error.message);
+            throw error;
+        }
+    };
+    if (parsed.contract === undefined) {
+        const selection = parsed.path !== undefined
+            ? { kind: "path", path: parsed.path }
+            : parsed.overlap ? { kind: "overlap" } : { kind: "declarations" };
+        const report = await read(selection);
+        return { kind: "region", region: report.region ?? { kind: "absent" } };
+    }
+    const report = await read({ kind: "declarations" });
+    const contract = resolveKanshiContract(report, parsed.contract);
+    if (report.contracts.kind !== "present" || report.contracts.value.rows.every((row) => row.id !== contract || row.disposition !== "active")) {
+        throw new CliUsageError(`unknown contract selector: ${parsed.contract}`);
+    }
+    if (report.region?.kind !== "present" || report.region.value.kind !== "declarations") {
+        return { kind: "region", region: report.region ?? { kind: "absent" } };
+    }
+    const selection = parsed.overlap ? { kind: "overlap", contract } : { kind: "contract", contract };
+    return { kind: "region", region: { kind: "present", value: selectRegion({ declarations: report.region.value.declarations, selection }) } };
+}
+// eslint-disable-next-line complexity -- command dispatch keeps the CLI's existing boundary in one place.
+async function invokeParsed(invocation, runtime) {
+    const coordinates = await resolveCliCoordinates({
+        ...(runtime.cwd === undefined ? {} : { processCwd: runtime.cwd }),
+        ...(invocation.cwd === undefined ? {} : { cwd: invocation.cwd }),
+        ...(invocation.repo === undefined ? {} : { repo: invocation.repo }),
+        command: invocation.command,
+    });
+    const { cwd, repo, world, candidateWorld, establishWorld } = coordinates;
     const edge = {
         environment: runtime.environment ?? process.env,
-        readStdin: runtime.readStdin ?? (() => readFileSync(0, "utf8")),
+        readStdin: runtime.readStdin ?? readStdin,
     };
     const parsed = invocation.command;
-    const repoCoordinate = resolve(cwd, invocation.repo ?? ".");
-    const repo = repoFor(use, repoCoordinate);
-    const world = locateWorld(cwd);
     if (parsed.command === "settings") {
-        return { kind: "settings", value: settingsAt(world ?? undefined, edge.environment) };
+        return { kind: "settings", value: await settingsAt(world ?? undefined, edge.environment) };
     }
     if (parsed.command === "task") {
         try {
             return await invokeTask(parsed, {
                 world,
-                establish: () => establishWorld(cwd, world),
+                establish: coordinates.establishWorld,
                 readStdin: edge.readStdin,
+                ...(runtime.actor === undefined ? {} : { actor: runtime.actor }),
             });
         }
         catch (error) {
@@ -400,11 +376,13 @@ async function invokeParsed(invocation, runtime, use) {
         }
     }
     if (isParsedAkumaCommand(parsed)) {
-        const akumaWorld = akumaWorldFor(parsed, cwd, world);
-        const configuration = settingsAt(akumaWorld, edge.environment);
+        const akumaWorld = await akumaWorldFor(parsed, world, candidateWorld, coordinates.establishWorld);
+        const configuration = await settingsAt(akumaWorld, edge.environment);
         return await invokeAkumaFromEdge(parsed, {
             path: akumaWorld,
-            executionCwd: cwd,
+            ...(parsed.command === "call" && parsed.contract !== undefined && invocation.cwd === undefined
+                ? {}
+                : { executionCwd: cwd }),
             ...(repo === undefined ? {} : { repo }),
             configuration,
             edge,
@@ -416,8 +394,10 @@ async function invokeParsed(invocation, runtime, use) {
         return await invokeStatus(parsed, world, repo, edge);
     if (repo === undefined)
         throw new Error(`${parsed.command} requires a resolved Repo`);
+    if (parsed.command === "region")
+        return invokeRegion(parsed, world, repo);
     const scope = cwd;
-    const configuration = settingsAt(world ?? undefined, edge.environment);
+    const configuration = await settingsAt(world ?? undefined, edge.environment);
     const hooks = selectedHooks(configuration);
     if (parsed.command === "show") {
         const selected = await selectContract(repo, parsed.contract, scope);
@@ -432,27 +412,28 @@ async function invokeParsed(invocation, runtime, use) {
             return { kind: "observation", command: "reconcile", ...await contract.reconcile({ hooks, retryHooks: parsed.retryHooks }) };
         }
         case "bind":
-            return invokeBind(parsed, repo, edge, configuration, hooks);
+            return invokeBind({ parsed, repo, edge, configuration, hooks, establishWorld });
         default:
             return invokeExisting({ parsed, repo, edge, scope, configuration, hooks });
     }
 }
-async function invokeInstall(command, runtime) {
-    return installHarnesses(command.harnesses, runtime.environment ?? process.env);
+function withResolvedTaskActor(command, runtime) {
+    if (command.command !== "task" || (command.action !== "add" && command.action !== "compose"))
+        return runtime;
+    const actor = actorFromEdge(typeof command.flags.actor === "string" ? command.flags.actor : undefined, runtime.environment ?? process.env);
+    return actor === undefined ? runtime : { ...runtime, actor };
 }
 export async function invoke(invocation, runtime = {}) {
     try {
         const command = invocation.command;
-        const use = repoUse(command);
-        if (invocation.repo !== undefined && use === "none")
-            refuseUnusedRepo(command);
+        assertExplicitRepoUse(command, invocation.repo);
         if (command.command === "install")
-            return await invokeInstall(command, runtime);
+            return installHarnesses(command.harnesses, runtime.environment ?? process.env);
         return await invokeParsed({
             ...(invocation.cwd === undefined ? {} : { cwd: invocation.cwd }),
             ...(invocation.repo === undefined ? {} : { repo: invocation.repo }),
             command,
-        }, runtime, use);
+        }, await withAcquiredStdin(command, withResolvedTaskActor(command, runtime)));
     }
     catch (error) {
         if (error instanceof CliUsageError && error.projection === undefined) {