@astrosheep/keiyaku 2.8.5 → 2.9.0

package/build/cli/commands/projection/wait/handler.js

@@ -0,0 +1,21 @@
+import { resolveContractAddress, withResolvedAddress, } from "../../../../core/addressing.js";
+import { projectionDir } from "../../../../core/projection-core.js";
+import { waitForProjection } from "../../../../core/projection-wait.js";
+import { resolveProjectionAddress } from "../../../projection-address.js";
+import { prependAddressReceipt } from "../../../render/address.js";
+import { buildWaitResponse } from "../../../render/wait.js";
+import { projectDirectory, repositoryDirectory } from "../../shared.js";
+export const handler = async (_stdin, flags, signal, positional) => {
+    const cwd = flags.contractId ? await repositoryDirectory(flags) : await projectDirectory(flags);
+    const address = flags.contractId ? await resolveContractAddress(cwd, flags.contractId, flags.contractAddressSource) : undefined;
+    const operation = async () => {
+        const projection = await resolveProjectionAddress({
+            cwd,
+            address: positional[0],
+            scope: address,
+            verb: "wait",
+        });
+        return prependAddressReceipt(buildWaitResponse(projection.id, await waitForProjection({ projectionDirectory: projectionDir(cwd, projection.id), timeoutMs: flags.timeoutMs, signal }), { alias: projection.alias }), address, { projectionId: projection.id, projectionAlias: projection.alias });
+    };
+    return address ? await withResolvedAddress(address, operation) : await operation();
+};

package/build/cli/commands/projection/wait/meta.js

@@ -0,0 +1,11 @@
+export const meta = {
+    command: "wait",
+    summary: "Wait for an akuma projection",
+    usage: [
+        "keiyaku wait <projection-address> [--timeout DURATION]",
+        "keiyaku @addr wait <projection-address> [--timeout DURATION]",
+    ],
+    stdin: "none",
+    flags: ["cwd", "repo", "contract", "timeout"],
+    purpose: "Read an akuma projection until its outcome is available, or show a timeout snapshot.",
+};

package/build/cli/commands/registry.js

@@ -0,0 +1,100 @@
+import { FlowError } from "../../flow-error.js";
+import { contractCatalog } from "./contract/catalog.js";
+import { projectionCatalog } from "./projection/catalog.js";
+import { akumaCatalog } from "./akuma/catalog.js";
+import { skillsCatalog } from "./skills/catalog.js";
+import { systemCatalog } from "./system/catalog.js";
+import { taskCatalog } from "./task/catalog.js";
+/** Stable metadata key order consumed by help and tests. */
+const METADATA_ORDER = [
+    "bind",
+    "arc",
+    "call",
+    "revive",
+    "wait",
+    "tell",
+    "kill",
+    "log",
+    "akuma",
+    "akuma ls",
+    "akuma view",
+    "skills",
+    "skills install",
+    "amend",
+    "renew",
+    "petition",
+    "forfeit",
+    "guide",
+    "completion",
+    "status",
+    "task",
+    "task add",
+    "task view",
+    "task ls",
+    "task start",
+    "task stop",
+    "task done",
+    "task drop",
+    "task update",
+    "task doctor",
+    "dump-env",
+];
+function buildRegistry(catalogs) {
+    const registrations = catalogs.flat();
+    const byCommand = new Map();
+    for (const registration of registrations) {
+        const command = registration.meta.command;
+        if (byCommand.has(command)) {
+            throw new FlowError("INTERNAL_STATE", `duplicate CLI command registration: ${command}`);
+        }
+        byCommand.set(command, registration);
+    }
+    const registry = {};
+    for (const command of METADATA_ORDER) {
+        const registration = byCommand.get(command);
+        if (!registration) {
+            throw new FlowError("INTERNAL_STATE", `missing CLI command registration: ${command}`);
+        }
+        registry[command] = registration;
+        byCommand.delete(command);
+    }
+    if (byCommand.size > 0) {
+        const extras = [...byCommand.keys()].join(", ");
+        throw new FlowError("INTERNAL_STATE", `unexpected CLI command registration: ${extras}`);
+    }
+    return Object.freeze(registry);
+}
+const REGISTRY = buildRegistry([
+    contractCatalog,
+    projectionCatalog,
+    akumaCatalog,
+    skillsCatalog,
+    systemCatalog,
+    taskCatalog,
+]);
+/** Longest multi-token match first; same token count keeps METADATA_ORDER. */
+function deriveParseOrder(order) {
+    return [...order].sort((a, b) => {
+        const tokenDelta = b.split(" ").length - a.split(" ").length;
+        if (tokenDelta !== 0)
+            return tokenDelta;
+        return order.indexOf(a) - order.indexOf(b);
+    });
+}
+const PARSE_ORDER = deriveParseOrder(METADATA_ORDER);
+export function getCommandRegistration(command) {
+    return REGISTRY[command];
+}
+export function getCommandMetadata(command) {
+    return REGISTRY[command].meta;
+}
+export function allCommandMetadata() {
+    return METADATA_ORDER.map((command) => REGISTRY[command].meta);
+}
+export function commandParseOrder() {
+    return PARSE_ORDER;
+}
+export async function loadCommandHandler(command) {
+    const module = await REGISTRY[command].load();
+    return module.handler;
+}

package/build/cli/commands/shared.js

@@ -0,0 +1,71 @@
+import { FlowError } from "../../flow-error.js";
+import { AddressResolutionError, buildResolutionAttempt, } from "../../core/addressing.js";
+import { isGitRepo } from "../../git/branches.js";
+import { stableRepoRoot } from "../../core/worktree-path.js";
+import { assertProjectionAlias } from "../../core/projection-alias.js";
+export function titleFromCallPrompt(prompt) {
+    const firstLine = prompt
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .find((line) => line.length > 0);
+    if (!firstLine)
+        return "Call";
+    return firstLine.replace(/^#+\s*/, "").slice(0, 80) || "Call";
+}
+export function repositoryCoordinateFromAddress(address) {
+    return address?.repo.kind === "repository" ? address.repo.stableRoot : undefined;
+}
+export function buildCallInput(content, flags, mode = "call") {
+    const cwd = flags.cwd ?? process.cwd();
+    const task = content.trim();
+    if (!task) {
+        throw new FlowError("EMPTY_PARAM", `${mode} body cannot be empty`);
+    }
+    return {
+        cwd,
+        repo: flags.repo,
+        mode,
+        contractId: flags.contractId,
+        contractAddressSource: flags.contractAddressSource,
+        title: titleFromCallPrompt(task),
+        task,
+        agent: flags.akuma,
+        model: flags.model,
+        effort: flags.effort,
+        incognito: flags.incognito,
+        bare: flags.bare,
+        detach: flags.detach,
+        ...(mode === "call" && flags.alias !== undefined ? { alias: assertProjectionAlias(flags.alias) } : {}),
+    };
+}
+export function revivePrompt(stdin) {
+    return stdin.trim() ? stdin : "Continue from the previous response.";
+}
+export function effectiveDirectory(flags) {
+    return flags.cwd ?? process.cwd();
+}
+export async function repositoryDirectory(flags) {
+    const candidate = flags.repo ?? effectiveDirectory(flags);
+    if (!(await isGitRepo(candidate))) {
+        if (flags.contractId) {
+            const asTyped = flags.contractAddressSource === "at-address"
+                ? `@${flags.contractId}`
+                : `--contract ${flags.contractId}`;
+            throw new AddressResolutionError("EMPTY_PARAM", `${asTyped} is a commission address, but ${candidate} has no repository ledger; contract addressing requires a ledger`, buildResolutionAttempt({
+                repo: { kind: "user" },
+                workdir: effectiveDirectory(flags),
+                spelling: {
+                    asTyped,
+                    source: flags.contractAddressSource ?? "explicit-flag",
+                },
+            }));
+        }
+        throw new FlowError("NOT_GIT_REPO", `${candidate} is not a git repository`);
+    }
+    return flags.repo ? await stableRepoRoot(candidate) : candidate;
+}
+export async function projectDirectory(flags) {
+    if (flags.repo)
+        return await repositoryDirectory(flags);
+    return effectiveDirectory(flags);
+}

package/build/cli/commands/skills/catalog.js

@@ -0,0 +1,6 @@
+import { meta as skillsMeta } from "./skills/meta.js";
+import { meta as installMeta } from "./install/meta.js";
+export const skillsCatalog = [
+    { meta: skillsMeta, load: () => import("./skills/handler.js") },
+    { meta: installMeta, load: () => import("./install/handler.js") },
+];

package/build/cli/commands/skills/install/handler.js

@@ -0,0 +1,10 @@
+import { installOfficialSkills } from "../../../skills-install.js";
+import { textResponse } from "../../../render/shared.js";
+export const handler = async (_stdin, flags) => {
+    const result = await installOfficialSkills(flags.force);
+    return textResponse([
+        "Installed official Keiyaku skills:",
+        ...result.targets.map((target) => `- ${target.path} -> ${target.source} (${target.status})`),
+        ...(result.warnings.length > 0 ? ["", "## Warning", ...result.warnings.map((warning) => `- ${warning}`)] : []),
+    ].join("\n"));
+};

package/build/cli/commands/skills/install/meta.js

@@ -0,0 +1,9 @@
+export const meta = {
+    command: "skills install",
+    summary: "Install the official Keiyaku skills",
+    usage: ["keiyaku skills install [-f|--force]"],
+    stdin: "none",
+    flags: ["force"],
+    purpose: "Install the bundled official Keiyaku skills into supported agent skill directories.",
+    notes: ["Force permits replacement of foreign collisions."],
+};

package/build/cli/commands/skills/skills/handler.js

@@ -0,0 +1,4 @@
+import { missingSubcommandError } from "../../../help.js";
+export const handler = async () => {
+    throw missingSubcommandError("skills", ["install"]);
+};

package/build/cli/commands/skills/skills/meta.js

@@ -0,0 +1,10 @@
+export const meta = {
+    command: "skills",
+    summary: "Install official skills",
+    usage: ["keiyaku skills install"],
+    stdin: "none",
+    flags: [],
+    purpose: "Install bundled official Keiyaku skills into supported agent skill directories.",
+    subcommands: ["install"],
+    completionRank: 7,
+};

package/build/cli/commands/system/catalog.js

@@ -0,0 +1,8 @@
+import { meta as guideMeta } from "./guide/meta.js";
+import { meta as completionMeta } from "./completion/meta.js";
+import { meta as dumpEnvMeta } from "./dump-env/meta.js";
+export const systemCatalog = [
+    { meta: guideMeta, load: () => import("./guide/handler.js") },
+    { meta: completionMeta, load: () => import("./completion/handler.js") },
+    { meta: dumpEnvMeta, load: () => import("./dump-env/handler.js") },
+];

package/build/cli/commands/system/completion/handler.js

@@ -0,0 +1,10 @@
+import { renderCompletionCandidates, renderCompletionScript } from "../../../completion.js";
+import { textResponse } from "../../../render/shared.js";
+import { projectDirectory } from "../../shared.js";
+export const handler = async (_stdin, flags) => {
+    const cwd = await projectDirectory(flags);
+    if (flags.complete) {
+        return textResponse(await renderCompletionCandidates({ cwd, word: flags.word, previous: flags.previous }));
+    }
+    return textResponse(renderCompletionScript(flags.shell));
+};

package/build/cli/commands/system/completion/meta.js

@@ -0,0 +1,9 @@
+export const meta = {
+    command: "completion",
+    summary: "Print shell completion",
+    usage: ["keiyaku completion [--shell bash|zsh]"],
+    stdin: "none",
+    flags: ["cwd", "repo", "shell", "word", "previous", "complete"],
+    purpose: "Print command and address candidates.",
+    completionRank: 13,
+};

package/build/cli/commands/system/dump-env/handler.js

@@ -0,0 +1,3 @@
+import { renderEnvExample } from "../../../../config/env-keys.js";
+import { textResponse } from "../../../render/shared.js";
+export const handler = async () => textResponse(renderEnvExample());

package/build/cli/commands/system/dump-env/meta.js

@@ -0,0 +1,10 @@
+export const meta = {
+    command: "dump-env",
+    summary: "Print the environment template",
+    usage: ["keiyaku dump-env"],
+    stdin: "none",
+    flags: [],
+    purpose: "Print supported environment keys.",
+    notes: ["Keiyaku loads <KEIYAKU_HOME>/.env, then .keiyaku/.env; process environment values win."],
+    completionRank: 15,
+};

package/build/cli/commands/system/guide/handler.js

@@ -0,0 +1,4 @@
+import { VERSION } from "../../../../generated/version.js";
+import { buildKeiyakuGuide } from "../../../help.js";
+import { textResponse } from "../../../render/shared.js";
+export const handler = async () => textResponse(buildKeiyakuGuide(VERSION));

package/build/cli/commands/system/guide/meta.js

@@ -0,0 +1,9 @@
+export const meta = {
+    command: "guide",
+    summary: "Print the Keiyaku guide",
+    usage: ["keiyaku guide"],
+    stdin: "none",
+    flags: [],
+    purpose: "Print workflow guidance.",
+    completionRank: 12,
+};

package/build/cli/commands/task/add/handler.js

@@ -0,0 +1,21 @@
+import { randomBytes } from "node:crypto";
+import { resolveTaskCreator } from "../../../../core/task-git-actor.js";
+import { openTaskCommandRepository } from "../../../../core/task-git-runtime.js";
+import { createTask } from "../../../../core/task.js";
+import { renderTaskMutationRow } from "../../../render/task.js";
+import { textResponse } from "../../../render/shared.js";
+import { effectiveDirectory } from "../../shared.js";
+import { parseTaskAddInput } from "../shared.js";
+export const handler = async (stdin, flags, _signal, positional) => {
+    const cwd = effectiveDirectory(flags);
+    const input = parseTaskAddInput(positional[0] === "-" ? stdin : positional[0]);
+    const task = await createTask(await openTaskCommandRepository(cwd), {
+        ...input,
+        creator: resolveTaskCreator(cwd),
+        ...(flags.taskPri === undefined ? {} : { pri: flags.taskPri }),
+        needs: flags.taskNeeds ?? [],
+        parent: flags.taskParent ?? null,
+        from: flags.taskFrom ?? [],
+    }, { randomBytes, now: () => new Date() });
+    return textResponse(renderTaskMutationRow(task));
+};

package/build/cli/commands/task/add/meta.js

@@ -0,0 +1,8 @@
+export const meta = {
+    command: "task add",
+    summary: "Add a task",
+    usage: ["keiyaku task add [-C|--cwd DIR] [--needs ID] [--parent ID] [--from ID] [--pri 0-3] <BODY|->"],
+    stdin: "none",
+    flags: ["cwd", "needs", "parent", "from", "pri"],
+    purpose: "Create a lightweight task from a title and optional body.",
+};

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

@@ -0,0 +1,22 @@
+import { meta as taskMeta } from "./task/meta.js";
+import { meta as addMeta } from "./add/meta.js";
+import { meta as viewMeta } from "./view/meta.js";
+import { meta as lsMeta } from "./ls/meta.js";
+import { meta as startMeta } from "./start/meta.js";
+import { meta as stopMeta } from "./stop/meta.js";
+import { meta as doneMeta } from "./done/meta.js";
+import { meta as dropMeta } from "./drop/meta.js";
+import { meta as updateMeta } from "./update/meta.js";
+import { meta as doctorMeta } from "./doctor/meta.js";
+export const taskCatalog = [
+    { meta: taskMeta, load: () => import("./task/handler.js") },
+    { meta: addMeta, load: () => import("./add/handler.js") },
+    { meta: viewMeta, load: () => import("./view/handler.js") },
+    { meta: lsMeta, load: () => import("./ls/handler.js") },
+    { meta: startMeta, load: () => import("./start/handler.js") },
+    { meta: stopMeta, load: () => import("./stop/handler.js") },
+    { meta: doneMeta, load: () => import("./done/handler.js") },
+    { meta: dropMeta, load: () => import("./drop/handler.js") },
+    { meta: updateMeta, load: () => import("./update/handler.js") },
+    { meta: doctorMeta, load: () => import("./doctor/handler.js") },
+];

package/build/cli/commands/task/doctor/handler.js

@@ -0,0 +1,4 @@
+import { textResponse } from "../../../render/shared.js";
+import { effectiveDirectory } from "../../shared.js";
+import { renderTaskDoctor } from "../shared.js";
+export const handler = async (_stdin, flags) => textResponse(await renderTaskDoctor(effectiveDirectory(flags)));

package/build/cli/commands/task/doctor/meta.js

@@ -0,0 +1,8 @@
+export const meta = {
+    command: "task doctor",
+    summary: "Diagnose the task board",
+    usage: ["keiyaku task doctor [-C|--cwd DIR]"],
+    stdin: "none",
+    flags: ["cwd"],
+    purpose: "Report task state counts, supported board diseases, and lock state without repair.",
+};

package/build/cli/commands/task/done/handler.js

@@ -0,0 +1,17 @@
+import { openTaskCommandRepository } from "../../../../core/task-git-runtime.js";
+import { doneTask } from "../../../../core/task.js";
+import { renderTaskMutationRow } from "../../../render/task.js";
+import { textResponse } from "../../../render/shared.js";
+import { effectiveDirectory } from "../../shared.js";
+import { mutationSelectionMessage, rejectBareContractTaskState } from "../shared.js";
+export const handler = async (_stdin, flags, _signal, positional) => {
+    try {
+        const cwd = effectiveDirectory(flags);
+        if (positional[0] === undefined)
+            await rejectBareContractTaskState(cwd, "done");
+        return textResponse(renderTaskMutationRow(await doneTask(await openTaskCommandRepository(cwd), positional[0])));
+    }
+    catch (error) {
+        return mutationSelectionMessage(error);
+    }
+};

package/build/cli/commands/task/done/meta.js

@@ -0,0 +1,8 @@
+export const meta = {
+    command: "task done",
+    summary: "Complete a task",
+    usage: ["keiyaku task done [-C|--cwd DIR] [ID]"],
+    stdin: "none",
+    flags: ["cwd"],
+    purpose: "Complete an open or in-progress task.",
+};

package/build/cli/commands/task/drop/handler.js

@@ -0,0 +1,6 @@
+import { openTaskCommandRepository } from "../../../../core/task-git-runtime.js";
+import { dropTask } from "../../../../core/task.js";
+import { renderTaskMutationRow } from "../../../render/task.js";
+import { textResponse } from "../../../render/shared.js";
+import { effectiveDirectory } from "../../shared.js";
+export const handler = async (_stdin, flags, _signal, positional) => textResponse(renderTaskMutationRow(await dropTask(await openTaskCommandRepository(effectiveDirectory(flags)), positional[0])));

package/build/cli/commands/task/drop/meta.js

@@ -0,0 +1,8 @@
+export const meta = {
+    command: "task drop",
+    summary: "Drop a task",
+    usage: ["keiyaku task drop [-C|--cwd DIR] ID"],
+    stdin: "none",
+    flags: ["cwd"],
+    purpose: "Abandon an open or in-progress task.",
+};

package/build/cli/commands/task/ls/handler.js

@@ -0,0 +1,13 @@
+import { openTaskCommandRepository } from "../../../../core/task-git-runtime.js";
+import { readTaskBoard } from "../../../../core/task.js";
+import { renderTaskList, renderTaskListJson } from "../../../render/task.js";
+import { textResponse } from "../../../render/shared.js";
+import { effectiveDirectory } from "../../shared.js";
+import { taskJsonText, taskSelection } from "../shared.js";
+export const handler = async (_stdin, flags) => {
+    const board = await readTaskBoard(await openTaskCommandRepository(effectiveDirectory(flags)));
+    const selection = taskSelection(flags);
+    return textResponse(flags.json
+        ? taskJsonText(renderTaskListJson(board.tasks, selection))
+        : renderTaskList(board.tasks, { selection }));
+};

package/build/cli/commands/task/ls/meta.js

@@ -0,0 +1,8 @@
+export const meta = {
+    command: "task ls",
+    summary: "List tasks",
+    usage: ["keiyaku task ls [-C|--cwd DIR] [--all|--done] [--json]"],
+    stdin: "none",
+    flags: ["cwd", "all", "done", "json"],
+    purpose: "List tasks from the working-tree board.",
+};

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

@@ -0,0 +1,131 @@
+import * as path from "node:path";
+import { FlowError } from "../../../flow-error.js";
+import { readTaskDoctor, taskCommandContractId } from "../../../core/task-git-runtime.js";
+import { deriveTaskDisplay, renderTaskList, } from "../../render/task.js";
+import { parseTaskDocument, } from "../../../core/task.js";
+export function parseTaskAddInput(input) {
+    if (!input.trim())
+        throw new FlowError("EMPTY_PARAM", "task add input cannot be blank");
+    const lines = input.split(/\r?\n/);
+    const title = lines[0]?.trim() ?? "";
+    if (!title)
+        throw new FlowError("EMPTY_PARAM", "task title cannot be blank");
+    if (lines.length > 1 && lines[1].trim() !== "") {
+        throw new FlowError("EMPTY_PARAM", "task add body must follow the title after a blank line");
+    }
+    return { title, body: lines.slice(2).join("\n") };
+}
+export function taskSelection(flags) {
+    return flags.all ? "all" : flags.done ? "done" : "default";
+}
+export function taskJsonText(text) {
+    return text.endsWith("\n") ? text.slice(0, -1) : text;
+}
+export function mutationSelectionMessage(error) {
+    if (error instanceof FlowError) {
+        const candidates = error.candidateTasks;
+        if (candidates && candidates.length > 1) {
+            error.message = `${renderTaskList(candidates, { selection: "all" })}\n${error.message}`;
+        }
+    }
+    throw error;
+}
+function taskDocumentsById(sources) {
+    const documents = new Map();
+    for (const source of sources) {
+        try {
+            const document = parseTaskDocument(source);
+            documents.set(document.id, document);
+        }
+        catch {
+            // Invalid documents are reported from board diseases.
+        }
+    }
+    return documents;
+}
+function renderTaskDiseaseRows(diseases, documents) {
+    const rows = [];
+    const renderedCycles = new Set();
+    for (const disease of diseases) {
+        if (disease.code === "invalid_document") {
+            const name = path.basename(disease.path).replace(/\.md$/, "");
+            if (/^k-[0-9a-f]{12}$/.test(name))
+                rows.push(`! ${name} invalid front matter — quarantined`);
+            continue;
+        }
+        if (disease.code === "needs_cycle" && disease.id && disease.relatedIds) {
+            const cycleKey = disease.relatedIds.join("\0");
+            if (renderedCycles.has(cycleKey))
+                continue;
+            renderedCycles.add(cycleKey);
+            if (disease.relatedIds.length === 1) {
+                rows.push(`! ${disease.id} needs itself`);
+                continue;
+            }
+            const members = new Set(disease.relatedIds);
+            const start = [...members].sort()[0];
+            const cycle = [start];
+            let current = start;
+            for (let count = 0; count <= members.size; count += 1) {
+                const next = documents.get(current)?.needs.filter((id) => members.has(id)).sort()[0];
+                if (!next)
+                    break;
+                cycle.push(next);
+                if (next === start)
+                    break;
+                current = next;
+            }
+            if (cycle.at(-1) === start)
+                rows.push(`! cycle detected: ${cycle.join(" → ")}`);
+            continue;
+        }
+        if (disease.code === "missing_reference" && disease.id && disease.relatedIds) {
+            const document = documents.get(disease.id);
+            if (!document)
+                continue;
+            for (const related of disease.relatedIds) {
+                if (document.needs.includes(related))
+                    rows.push(`! ${disease.id} needs missing task ${related}`);
+                if (document.parent === related)
+                    rows.push(`? ${disease.id} parent ${related} does not exist`);
+            }
+        }
+    }
+    return rows;
+}
+export async function renderTaskDoctor(cwd) {
+    const result = await readTaskDoctor(cwd);
+    const board = result.board;
+    const tasks = board.tasks;
+    const counts = { inProgress: 0, ready: 0, blocked: 0, done: 0, dropped: 0, bound: 0 };
+    for (const task of tasks) {
+        const display = deriveTaskDisplay(task);
+        if (display === "in_progress")
+            counts.inProgress += 1;
+        else if (display === "ready")
+            counts.ready += 1;
+        else if (display === "blocked")
+            counts.blocked += 1;
+        else if (display === "done")
+            counts.done += 1;
+        else if (display === "dropped")
+            counts.dropped += 1;
+        else
+            counts.bound += 1;
+    }
+    const lines = [
+        `tasks · ${tasks.length} total`,
+        `${counts.inProgress} in_progress · ${counts.ready} ready · ${counts.blocked} blocked · ${counts.done} done · ${counts.dropped} dropped · ${counts.bound} bound`,
+        ...renderTaskDiseaseRows(board.diseases, taskDocumentsById(result.sources)),
+        ...result.orphans.map(({ taskId, contractId }) => `! ${taskId} points at contract ${contractId} which has no ledger entry — rolling back`),
+    ];
+    if (result.lockHeld)
+        lines.push("× board lock currently held by a live writer");
+    return lines.join("\n");
+}
+export async function rejectBareContractTaskState(cwd, verb) {
+    const contractId = await taskCommandContractId(cwd);
+    if (contractId) {
+        throw new FlowError("UNSUPPORTED_POLICY", `task ${verb} is not available in a contract worktree; task state follows the contract (${contractId})`);
+    }
+}

package/build/cli/commands/task/start/handler.js

@@ -0,0 +1,6 @@
+import { openTaskCommandRepository } from "../../../../core/task-git-runtime.js";
+import { startTask } from "../../../../core/task.js";
+import { renderTaskMutationRow } from "../../../render/task.js";
+import { textResponse } from "../../../render/shared.js";
+import { effectiveDirectory } from "../../shared.js";
+export const handler = async (_stdin, flags, _signal, positional) => textResponse(renderTaskMutationRow(await startTask(await openTaskCommandRepository(effectiveDirectory(flags)), positional[0], new Date())));

package/build/cli/commands/task/start/meta.js

@@ -0,0 +1,8 @@
+export const meta = {
+    command: "task start",
+    summary: "Start a task",
+    usage: ["keiyaku task start [-C|--cwd DIR] ID"],
+    stdin: "none",
+    flags: ["cwd"],
+    purpose: "Move an open task to in_progress.",
+};

package/build/cli/commands/task/stop/handler.js

@@ -0,0 +1,17 @@
+import { openTaskCommandRepository } from "../../../../core/task-git-runtime.js";
+import { stopTask } from "../../../../core/task.js";
+import { renderTaskMutationRow } from "../../../render/task.js";
+import { textResponse } from "../../../render/shared.js";
+import { effectiveDirectory } from "../../shared.js";
+import { mutationSelectionMessage, rejectBareContractTaskState } from "../shared.js";
+export const handler = async (_stdin, flags, _signal, positional) => {
+    try {
+        const cwd = effectiveDirectory(flags);
+        if (positional[0] === undefined)
+            await rejectBareContractTaskState(cwd, "stop");
+        return textResponse(renderTaskMutationRow(await stopTask(await openTaskCommandRepository(cwd), positional[0])));
+    }
+    catch (error) {
+        return mutationSelectionMessage(error);
+    }
+};

package/build/cli/commands/task/stop/meta.js

@@ -0,0 +1,8 @@
+export const meta = {
+    command: "task stop",
+    summary: "Stop a task",
+    usage: ["keiyaku task stop [-C|--cwd DIR] [ID]"],
+    stdin: "none",
+    flags: ["cwd"],
+    purpose: "Return an in-progress task to open.",
+};

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

@@ -0,0 +1,5 @@
+import { missingSubcommandError } from "../../../help.js";
+import { TASK_SUBCOMMANDS } from "../../../types.js";
+export const handler = async () => {
+    throw missingSubcommandError("task", TASK_SUBCOMMANDS);
+};