@astrosheep/keiyaku 4.0.2 → 4.0.4

package/build/src/cli/commands/akuma-invoke.js

@@ -13,7 +13,6 @@ async function invokeWait(command, input) {
         result: await Keiyaku.wait({
             path: input.path,
             akuma: command.akuma,
-            settings: input.settings,
             ...(input.repo === undefined ? {} : { repo: input.repo }),
             ...(command.completion === undefined ? {} : { completion: command.completion }),
             ...(command.timeoutMs === undefined ? {} : { timeoutMs: command.timeoutMs }),
@@ -24,11 +23,21 @@ async function invokeWait(command, input) {
 async function invokeTell(command, input) {
     const body = await promptBody(command, input);
     if (command.interrupt) {
-        const result = await Keiyaku.interrupt({ path: input.path, akuma: command.akuma, settings: input.settings, body, ...(input.repo === undefined ? {} : { repo: input.repo }) });
+        const result = await Keiyaku.interrupt({
+            path: input.path,
+            akuma: command.akuma,
+            body,
+            ...(input.repo === undefined ? {} : { repo: input.repo }),
+        });
         const alias = inputAlias(command.akuma);
         return { kind: "akuma", action: "tell", mode: "interrupt", result, body, ...(alias === undefined ? {} : { alias }) };
     }
-    const result = await Keiyaku.tell({ path: input.path, akuma: command.akuma, settings: input.settings, body, ...(input.repo === undefined ? {} : { repo: input.repo }) });
+    const result = await Keiyaku.tell({
+        path: input.path,
+        akuma: command.akuma,
+        body,
+        ...(input.repo === undefined ? {} : { repo: input.repo }),
+    });
     const alias = inputAlias(command.akuma);
     return { kind: "akuma", action: "tell", mode: "ordinary", result, body, ...(alias === undefined ? {} : { alias }) };
 }
@@ -36,7 +45,6 @@ async function invokeHistory(command, input) {
     const result = await Keiyaku.history({
         path: input.path,
         akuma: command.akuma,
-        settings: input.settings,
         ...(input.repo === undefined ? {} : { repo: input.repo }),
         ...(command.before === undefined ? {} : { before: command.before }),
         ...(command.since === undefined ? {} : { since: command.since }),
@@ -64,7 +72,6 @@ async function invokeFork(command, input) {
             path: input.path,
             akuma: command.akuma,
             at: command.at,
-            settings: input.settings,
             ...(input.repo === undefined ? {} : { repo: input.repo }),
         }),
     };
@@ -77,7 +84,6 @@ async function invokeKill(command, input) {
         result: await Keiyaku.kill({
             path: input.path,
             akuma: command.akuma,
-            settings: input.settings,
             ...(input.repo === undefined ? {} : { repo: input.repo }),
         }),
         ...(alias === undefined ? {} : { alias }),
@@ -91,12 +97,14 @@ export async function invokeAkuma(command, input) {
                 path: input.path,
                 archetype: command.archetype,
                 body,
-                settings: input.settings,
-                ...(input.executionCwd === undefined ? {} : { cwd: input.executionCwd }),
+                ...(input.home === undefined ? {} : { home: input.home }),
+                ...(input.settings === undefined ? {} : { settings: input.settings }),
+                ...(input.statedCwd === undefined ? {} : { cwd: input.statedCwd }),
                 mode: command.mode,
                 ...(command.timeoutMs === undefined ? {} : { timeoutMs: command.timeoutMs }),
                 ...(input.contract === undefined ? {} : { contract: input.contract }),
                 ...(command.alias === undefined ? {} : { alias: command.alias }),
+                ...(command.allowed === undefined ? {} : { allowed: command.allowed }),
             });
             return { kind: "akuma", action: "call", result, world: input.path };
         }
@@ -107,11 +115,11 @@ export async function invokeAkuma(command, input) {
         case "kill": return await invokeKill(command, input);
     }
 }
-export async function invokeAkumaStatus(path, akuma, settings, alias, repo) {
+export async function invokeAkumaStatus(path, akuma, alias, repo) {
     return {
         kind: "akuma",
         action: "status",
-        status: await Keiyaku.status({ path, akuma, settings, ...(repo === undefined ? {} : { repo }) }),
+        status: await Keiyaku.status({ path, akuma, ...(repo === undefined ? {} : { repo }) }),
         ...(alias === undefined ? {} : { alias }),
     };
 }

package/build/src/cli/commands/akuma.d.ts

@@ -1,4 +1,5 @@
 import { type AkumaAlias } from "../../identity/selector.js";
+import { type AllowedActions } from "../../akuma/allowed.js";
 type Output = Readonly<{
     output: "text" | "json";
 }>;
@@ -21,6 +22,7 @@ export type ParsedAkumaCommand = Output & ((Readonly<{
     alias?: AkumaAlias;
     mode: "wait" | "detach";
     timeoutMs?: number;
+    allowed?: AllowedActions;
 }> & Prompted) | Readonly<{
     command: "kill";
     akuma: readonly string[];
@@ -38,15 +40,22 @@ export type ParsedAkumaCommand = Output & ((Readonly<{
     before?: number;
     since?: number;
     limit?: number;
-}> & Addressed) | (Readonly<{
+}> & Addressed) | Readonly<{
+    command: "history";
+    contract: string;
+}> | (Readonly<{
     command: "fork";
     at: string;
 }> & Addressed));
+export type InvokedAkumaCommand = Exclude<ParsedAkumaCommand, {
+    command: "history";
+    contract: string;
+}>;
 export type AkumaAction = ParsedAkumaCommand["command"];
 export declare function isAkumaAction(value: string | undefined): value is AkumaAction;
 export declare function isParsedAkumaCommand(command: Readonly<{
     command: string;
-}>): command is ParsedAkumaCommand;
+}>): command is InvokedAkumaCommand;
 export declare function renderAkumaRootRows(): readonly string[];
 export declare function renderAkumaHelp(action: AkumaAction): string;
 export declare function renderAkumaUsage(action: AkumaAction): string;

package/build/src/cli/commands/akuma.js

@@ -1,7 +1,8 @@
-import { CliUsageError, isBlankInput, usageLine } from "../usage.js";
+import { CliUsageError, isBlankInput, usageLine, withJsonAutomationHelp } from "../usage.js";
 import { archetypeName, parseAkuId } from "../../akuma/identity.js";
 import { parseDuration as decodeDuration } from "../../duration.js";
 import { parseAkumaAlias, parseAkumaGlob } from "../../identity/selector.js";
+import { decodeAllowedActions } from "../../akuma/allowed.js";
 const AKUMA_COMMAND_SPECS = {
     call: {
         arity: 1,
@@ -11,15 +12,17 @@ const AKUMA_COMMAND_SPECS = {
             alias: "value",
             wait: "value",
             detach: "boolean",
+            allowed: "repeatable",
             json: "boolean",
         },
-        usage: "call <akuma-name> [--contract <kei/...>] [--alias @name] [--wait <duration> | -d | --detach] [--json] (<prompt> | -)",
+        usage: "call <akuma-name> [--contract <kei/...>] [--alias @name] [--allowed <product.action>]... [--wait <duration> | -d | --detach] [--json] (<prompt> | -)",
         purpose: "Birth an Akuma from <akuma-name> with one prompt.",
         details: [
             "Give <prompt> as one argument, or use final - to read stdin.",
             "Default: --wait 5m. An explicit --wait replaces that duration; -d and --detach return after birth.",
             "--contract dispatches the born Akuma to that Contract.",
             "--alias assigns the world-local @name selector to the born Akuma.",
+            "Repeated --allowed replaces the Archetype list; --allowed none selects an empty list.",
             "With --contract, Dispatch succeeds first. If @name exists, the alias then moves.",
         ].join("\n"),
     },
@@ -45,8 +48,8 @@ const AKUMA_COMMAND_SPECS = {
         arity: 1,
         stdin: false,
         flags: { before: "value", since: "value", limit: "value", last: "boolean", json: "boolean" },
-        usage: "history <aku/...> [--before <index> | --since <index>] [--limit <count>] [--last] [--json]",
-        purpose: "Read the persistent execution history or the last answer.",
+        usage: "history <aku/...|@alias|kei/...> [--before <index> | --since <index>] [--limit <count>] [--last] [--json]",
+        purpose: "Read Akuma execution history or one complete Contract journal and Dispatch timeline.",
     },
     fork: {
         arity: 1,
@@ -67,14 +70,14 @@ export function isAkumaAction(value) {
     return value !== undefined && Object.hasOwn(AKUMA_COMMAND_SPECS, value);
 }
 export function isParsedAkumaCommand(command) {
-    return isAkumaAction(command.command);
+    return isAkumaAction(command.command) && !("contract" in command && command.command === "history");
 }
 export function renderAkumaRootRows() {
     return Object.values(AKUMA_COMMAND_SPECS).flatMap((spec) => [`  ${spec.usage}`, `    ${spec.purpose}`]);
 }
 export function renderAkumaHelp(action) {
     const spec = AKUMA_COMMAND_SPECS[action];
-    return `${spec.purpose}\n\n${usageLine(spec.usage)}${spec.details === undefined ? "" : `\n\n${spec.details}`}`;
+    return withJsonAutomationHelp(`${spec.purpose}\n\n${usageLine(spec.usage)}${spec.details === undefined ? "" : `\n\n${spec.details}`}`);
 }
 export function renderAkumaUsage(action) {
     return usageLine(AKUMA_COMMAND_SPECS[action].usage);
@@ -104,6 +107,29 @@ function parseDuration(raw, option, fail) {
         fail(`${option} duration exceeds the safe millisecond range`);
     return duration.milliseconds;
 }
+function scanNamedOption(input, flags, fail) {
+    const token = input.argv[input.index];
+    const name = token.slice(2);
+    const kind = input.spec.flags[name];
+    if (kind === undefined)
+        fail(`option ${token} is not valid for ${input.action}`);
+    if (kind !== "repeatable" && flags[name] !== undefined)
+        fail(`duplicate option: ${token}`);
+    if (kind === "boolean") {
+        flags[name] = true;
+        return input.index;
+    }
+    const value = input.argv[input.index + 1];
+    if (value === undefined || value === "-" || value === "-d" || value.startsWith("--")) {
+        fail(`${token} requires a value`);
+    }
+    if (isBlankInput(value))
+        fail(`${token} requires a nonblank value`);
+    flags[name] = kind === "repeatable"
+        ? [...(Array.isArray(flags[name]) ? flags[name] : []), value]
+        : value;
+    return input.index + 1;
+}
 function scanAkuma(action, argv, fail) {
     const spec = AKUMA_COMMAND_SPECS[action];
     const flags = {};
@@ -129,24 +155,7 @@ function scanAkuma(action, argv, fail) {
             positionals.push(token);
         }
         else {
-            const name = token.slice(2);
-            const kind = spec.flags[name];
-            if (kind === undefined)
-                fail(`option ${token} is not valid for ${action}`);
-            if (flags[name] !== undefined)
-                fail(`duplicate option: ${token}`);
-            if (kind === "boolean")
-                flags[name] = true;
-            else {
-                const value = argv[index + 1];
-                if (value === undefined || value === "-" || value === "-d" || value.startsWith("--")) {
-                    fail(`${token} requires a value`);
-                }
-                if (isBlankInput(value))
-                    fail(`${token} requires a nonblank value`);
-                flags[name] = value;
-                index += 1;
-            }
+            index = scanNamedOption({ action, spec, argv, index }, flags, fail);
         }
     }
     return { flags, positionals, stdin };
@@ -200,7 +209,13 @@ function parseWait(rawSelectors, flags, output, fail) {
         output,
     };
 }
-function parseHistory(akuma, flags, output, fail) {
+function parseHistory(selector, flags, output, fail) {
+    if (selector.startsWith("kei/")) {
+        if (flags.before !== undefined || flags.since !== undefined || flags.limit !== undefined || flags.last === true) {
+            fail("history kei/... does not accept --before, --since, --limit, or --last");
+        }
+        return { command: "history", contract: selector, output };
+    }
     if (flags.before !== undefined && flags.since !== undefined)
         fail("history --before and --since are mutually exclusive");
     if (flags.last === true && (flags.before !== undefined || flags.since !== undefined || flags.limit !== undefined)) {
@@ -211,7 +226,7 @@ function parseHistory(akuma, flags, output, fail) {
         fail("--limit must be no greater than 5000");
     return {
         command: "history",
-        akuma,
+        akuma: validateDirect(selector, fail),
         last: flags.last === true,
         ...(flags.before === undefined ? {} : { before: positiveIndex(flags.before, "--before", fail) }),
         ...(flags.since === undefined ? {} : { since: positiveIndex(flags.since, "--since", fail) }),
@@ -224,9 +239,13 @@ function parseAddressed(action, rawSelectors, flags, output, fail) {
         return { command: action, akuma: rawSelectors.map((value) => validateSet(value, fail)), output };
     if (action === "wait")
         return parseWait(rawSelectors, flags, output, fail);
+    if (action === "history") {
+        const selector = rawSelectors[0];
+        if (selector.includes("*"))
+            fail("history accepts one complete aku/..., @alias, or kei/... selector");
+        return parseHistory(selector, flags, output, fail);
+    }
     const akuma = validateDirect(rawSelectors[0], fail);
-    if (action === "history")
-        return parseHistory(akuma, flags, output, fail);
     const at = stringFlag(flags.at, "fork requires --at <historyId>", fail);
     return { command: action, akuma, at, output };
 }
@@ -246,6 +265,24 @@ function parsePrompted(action, positionals, stdin, fail) {
 function parseTell(flags, subject, prompt, output, fail) {
     return { command: "tell", akuma: validateDirect(subject, fail), interrupt: flags.interrupt === true, prompt, output };
 }
+function parseAllowedFlag(raw, fail) {
+    if (raw === undefined)
+        return undefined;
+    if (!Array.isArray(raw))
+        fail("--allowed requires a value");
+    const selected = raw;
+    if (selected.includes("none")) {
+        if (selected.length !== 1)
+            fail("--allowed none cannot be combined with another value");
+        return [];
+    }
+    try {
+        return decodeAllowedActions(selected, "--allowed");
+    }
+    catch (error) {
+        fail(error instanceof Error ? error.message : "invalid --allowed action");
+    }
+}
 function parseCall(flags, archetype, prompt, output, fail) {
     let alias;
     if (flags.alias !== undefined) {
@@ -260,6 +297,7 @@ function parseCall(flags, archetype, prompt, output, fail) {
         fail("call --wait and --detach are mutually exclusive");
     const mode = flags.detach === true ? "detach" : "wait";
     const timeoutMs = flags.wait === undefined ? undefined : parseDuration(flags.wait, "--wait", fail);
+    const allowed = parseAllowedFlag(flags.allowed, fail);
     return {
         command: "call",
         archetype,
@@ -267,6 +305,7 @@ function parseCall(flags, archetype, prompt, output, fail) {
         ...(alias === undefined ? {} : { alias }),
         mode,
         ...(timeoutMs === undefined ? {} : { timeoutMs }),
+        ...(allowed === undefined ? {} : { allowed }),
         prompt,
         output,
     };

package/build/src/cli/commands/amend.d.ts

@@ -4,7 +4,7 @@ type AmendCommandInput = Readonly<{
     command: ParsedAmend;
     repo: Repo;
     contract: Keiyaku;
-    markdown: string;
+    markdown?: string;
     gates: readonly Gate[] | undefined;
     actor?: ActorId;
     hooks?: WorktreeHooks;

package/build/src/cli/commands/amend.js

@@ -4,7 +4,7 @@ export function amendFromCommand({ command, repo, contract, markdown, gates, act
         ? []
         : command.after?.map((id) => contractFromInput(repo, id).id);
     return contract.amend({
-        markdown,
+        ...(markdown === undefined ? {} : { markdown }),
         ...(actor === undefined ? {} : { actor }),
         ...(hooks === undefined ? {} : { hooks }),
         ...(after === undefined ? {} : { after }),

package/build/src/cli/commands/contract.d.ts

@@ -25,7 +25,7 @@ export declare const CONTRACT_COMMAND_SPECS: {
     };
     readonly amend: {
         readonly positional: "optional";
-        readonly stdin: "required";
+        readonly stdin: "optional";
         readonly flags: {
             readonly actor: "value";
             readonly after: "repeat-value";
@@ -33,8 +33,8 @@ export declare const CONTRACT_COMMAND_SPECS: {
             readonly gates: "value";
             readonly json: "boolean";
         };
-        readonly usage: "amend [<contract>|@<contract>] [--after <kei/...> ... | --clear-after] [--gates <name>] [--actor <actor>] [--json] -";
-        readonly purpose: "Apply stdin amendment operations to one Contract.";
+        readonly usage: "amend [<contract>|@<contract>] [--after <kei/...> ... | --clear-after] [--gates <name>] [--actor <actor>] [--json] [-]";
+        readonly purpose: "Amend one Contract's document operations or structured terms.";
     };
     readonly deliver: {
         readonly positional: "optional";

package/build/src/cli/commands/contract.js

@@ -5,7 +5,7 @@ export const AMEND_MINIMAL_STDIN_HELP = [
 ].join("\n");
 export const CONTRACT_COMMAND_SPECS = {
     bind: { positional: "none", stdin: "required", flags: { actor: "value", task: "value", target: "value", here: "boolean", after: "repeat-value", gates: "value", json: "boolean" }, usage: "bind [--task <task/...>] [--target <ref>] [--here] [--after <kei/...> ...] [--gates <name>] [--actor <actor>] [--json] -", purpose: "Create one Contract from stdin Markdown." },
-    amend: { positional: "optional", stdin: "required", flags: { actor: "value", after: "repeat-value", "clear-after": "boolean", gates: "value", json: "boolean" }, usage: "amend [<contract>|@<contract>] [--after <kei/...> ... | --clear-after] [--gates <name>] [--actor <actor>] [--json] -", purpose: "Apply stdin amendment operations to one Contract." },
+    amend: { positional: "optional", stdin: "optional", flags: { actor: "value", after: "repeat-value", "clear-after": "boolean", gates: "value", json: "boolean" }, usage: "amend [<contract>|@<contract>] [--after <kei/...> ... | --clear-after] [--gates <name>] [--actor <actor>] [--json] [-]", purpose: "Amend one Contract's document operations or structured terms." },
     deliver: { positional: "optional", stdin: "none", flags: { actor: "value", message: "value", "include-dirty": "boolean", json: "boolean" }, usage: "deliver [<contract>|@<contract>] [--message <text>] [--include-dirty] [--actor <actor>] [--json]", purpose: "Deliver one Contract candidate." },
     review: { positional: "optional", stdin: "optional", flags: { actor: "value", satisfied: "boolean", unsatisfied: "boolean", summary: "value", json: "boolean" }, usage: "review [<contract>|@<contract>] (--satisfied | --unsatisfied) (--summary <text> | -) [--actor <actor>] [--json]", purpose: "Record one review verdict." },
     arc: { positional: "optional", stdin: "required", flags: { actor: "value", json: "boolean" }, usage: "arc [<contract>|@<contract>] [--actor <actor>] [--json] -", purpose: "Record stdin arc Markdown for one Contract." },

package/build/src/cli/commands/install.js

@@ -1,7 +1,7 @@
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { runProcess } from "../../runtime/proc/run.js";
-import { CliUsageError, usageLine } from "../usage.js";
+import { runCrossPlatformProcess } from "../../runtime/proc/run.js";
+import { CliUsageError, usageLine, withJsonAutomationHelp } from "../usage.js";
 export const HARNESS_NAMES = ["codex", "claude", "opencode", "pi"];
 export const INSTALL_USAGE = "install <codex|claude|opencode|pi> [--json]\n       install --all [--json]";
 function isHarness(value) {
@@ -43,7 +43,7 @@ export function parseInstallCommand(argv) {
     };
 }
 export function renderInstallHelp() {
-    return `Install the Keiyaku skills into one or more agent harnesses.\n\n${usageLine(INSTALL_USAGE)}`;
+    return withJsonAutomationHelp(`Install the Keiyaku skills into one or more agent harnesses.\n\n${usageLine(INSTALL_USAGE)}`);
 }
 const INSTALL_TIMEOUT_MS = 5 * 60 * 1000;
 const ASSET_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "../../../integrations/marketplace");
@@ -80,7 +80,7 @@ function diagnostic(argv, outcome) {
 export function installAssetsRoot() {
     return ASSET_ROOT;
 }
-export async function installHarnesses(harnesses, environment, runner = runProcess) {
+export async function installHarnesses(harnesses, environment, runner = runCrossPlatformProcess) {
     const results = [];
     for (const harness of harnesses) {
         let failure;

package/build/src/cli/commands/task-query.d.ts

@@ -1,4 +1,4 @@
-import type { TaskQueryExpression } from "../../task/index.js";
+import { type TaskQueryExpression } from "../../task/index.js";
 export type { TaskQueryExpression } from "../../task/index.js";
 export declare function parseTaskQueryExpression(source: string): TaskQueryExpression;
 export declare function validateTaskLimit(source: string): void;

package/build/src/cli/commands/task-query.js

@@ -1,3 +1,4 @@
+import { TASK_RELATION_PREDICATE_FIELDS, } from "../../task/index.js";
 import { MAX_TASK_LIMIT, normalizeTaskQuery } from "../../task/query.js";
 function syntax(message, offset) { throw new Error(`${message} at column ${offset + 1}`); }
 function scanString(source, offset) {
@@ -133,7 +134,15 @@ function parseTextPredicate(field, operator, value) {
     return { field, operator: selected, value: value.value };
 }
 function parseRelationPredicate(field, operator, value) {
-    return { field, operator: equalityOperator(operator, field), value: canonicalTaskId(value, field) };
+    const relationField = TASK_RELATION_PREDICATE_FIELDS.find((candidate) => candidate === field.value);
+    if (relationField === undefined) {
+        syntax(`unknown query field ${JSON.stringify(field.value)}`, field.offset);
+    }
+    return {
+        field: relationField,
+        operator: equalityOperator(operator, relationField),
+        value: canonicalTaskId(value, relationField),
+    };
 }
 function parseBooleanPredicate(field, operator, value) {
     return { field, operator: equalityOperator(operator, field), value: boolean(value) };
@@ -216,14 +225,11 @@ class Parser {
                 operator: equalityOperator(operator, "parent"),
                 value: value.value === "none" ? null : canonicalTaskId(value, "parent"),
             };
-            case "under": return parseRelationPredicate("under", operator, value);
-            case "needs": return parseRelationPredicate("needs", operator, value);
-            case "blocks": return parseRelationPredicate("blocks", operator, value);
             case "ready": return parseBooleanPredicate("ready", operator, value);
             case "blocked": return parseBooleanPredicate("blocked", operator, value);
             case "created": return parseTimestampPredicate("created", operator, value);
             case "updated": return parseTimestampPredicate("updated", operator, value);
-            default: return syntax(`unknown query field ${JSON.stringify(field.value)}`, field.offset);
+            default: return parseRelationPredicate(field, operator, value);
         }
     }
 }

package/build/src/cli/commands/task.js

@@ -1,4 +1,4 @@
-import { CliUsageError, isBlankInput, usageLine } from "../usage.js";
+import { CliUsageError, isBlankInput, usageLine, withJsonAutomationHelp } from "../usage.js";
 import { parseTaskQueryExpression, validateTaskLimit, validateTaskParent, } from "./task-query.js";
 const COMMON = { json: "boolean" };
 const TASK_COMMAND_SPECS = {
@@ -46,14 +46,14 @@ export function isTaskAction(value) {
 export function renderTaskHelp(action) {
     if (action !== undefined) {
         const spec = TASK_COMMAND_SPECS[action];
-        return `${spec.purpose}\n\n${usageLine(spec.usage)}`;
+        return withJsonAutomationHelp(`${spec.purpose}\n\n${usageLine(spec.usage)}`);
     }
-    return [
+    return withJsonAutomationHelp([
         "usage: keiyaku task <command> ...",
         "",
         "commands:",
         ...Object.values(TASK_COMMAND_SPECS).flatMap((spec) => spec.usage.split("\n").map((line) => `  ${line}`).concat(`    ${spec.purpose}`)),
-    ].join("\n");
+    ].join("\n"));
 }
 export function renderTaskUsage(action) {
     return usageLine(TASK_COMMAND_SPECS[action].usage);

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

@@ -3,6 +3,7 @@ import { type WorldRoot } from "../world.js";
 import { type ParsedCommand } from "./parse.js";
 export type CliCoordinates = Readonly<{
     cwd: string;
+    cwdSource: "input" | "process";
     repo?: Repo;
     world: WorldRoot | null;
     candidateWorld: WorldRoot | null;

package/build/src/cli/coordinates.js

@@ -38,8 +38,11 @@ function repoPolicy(command) {
             return { use: command.query.kind === "contracts" ? "required" : "none", acceptsExplicit: false };
         case "status":
         case "tell":
-        case "history":
             return { use: "optional", acceptsExplicit: false };
+        case "history":
+            return "contract" in command
+                ? { use: "required", acceptsExplicit: true }
+                : { use: "optional", acceptsExplicit: false };
         case "fork":
             return { use: "optional", acceptsExplicit: true };
         case "wait":
@@ -112,6 +115,7 @@ export async function resolveCliCoordinates(input) {
     const world = await resolveWorld(cwd, worldRepo);
     return {
         cwd,
+        cwdSource: input.cwd === undefined ? "process" : "input",
         ...(repo === undefined ? {} : { repo }),
         world: world.root,
         candidateWorld: world.candidate,

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

@@ -10,6 +10,7 @@ type InvokeRuntime = Readonly<{
     environment?: NodeJS.ProcessEnv;
     readStdin?: () => Promise<string>;
     actor?: ActorId;
+    onOperationStart?: () => void;
 }>;
 export type SettingsInvocationResult = Readonly<{
     kind: "settings";