@astrosheep/keiyaku 2.9.0 → 2.9.2

package/build/cli/parse.js

@@ -1,342 +1,11 @@
 import { FlowError } from "../flow-error.js";
 import { agentNameSchema } from "../config/settings/schema.js";
 import { isResponseArtifactId } from "../core/response-artifact-id.js";
-import { BOOLEAN_FLAGS, CONTROL_FLAGS, HELP_FLAGS, SHORT_FLAG_ALIASES, VALUE_FLAGS, } from "./flags.js";
-import { commandParseOrder, getCommandMetadata } from "./commands/registry.js";
-import { TASK_SUBCOMMANDS } from "./types.js";
-/** Commands that may carry an explicit commission selector (@ or --contract). */
-const COMMISSION_SELECTOR_COMMANDS = new Set([
-    "arc",
-    "amend",
-    "call",
-    "wait",
-    "tell",
-    "kill",
-    "log",
-    "renew",
-    "petition",
-    "forfeit",
-]);
-/** Parse-time allowed flags; prefers meta.parseFlags when help flags omit a mouth-only flag. */
-function allowedFlagsForParse(command) {
-    const meta = getCommandMetadata(command);
-    return meta.parseFlags ?? meta.flags;
-}
-export function normalizeContractAddress(raw) {
-    const value = raw.startsWith("@") ? raw.slice(1) : raw;
-    if (!value.trim()) {
-        throw new FlowError("EMPTY_PARAM", "contract address cannot be empty");
-    }
-    return value.trim();
-}
-export function isCallCommand(command) {
-    return command === "call";
-}
-/** Identify petition --dry-run before parsing without mistaking flag values or literal payload. */
-export function isPetitionDryRunInvocation(tokens) {
-    const boundary = tokens.indexOf("--");
-    const head = boundary === -1 ? tokens : tokens.slice(0, boundary);
-    if (!head.some((token) => token === "--dry-run" || token.startsWith("--dry-run=")))
-        return false;
-    for (let index = 0; index < head.length; index += 1) {
-        const token = head[index];
-        if (HELP_FLAGS.has(token) || token.startsWith("@"))
-            continue;
-        if (/^-[A-Za-z]$/.test(token)) {
-            const name = SHORT_FLAG_ALIASES[token.slice(1)];
-            if (name && VALUE_FLAGS.has(name))
-                index += 1;
-            continue;
-        }
-        if (token.startsWith("--")) {
-            const eq = token.indexOf("=");
-            const name = parseFlagName(eq === -1 ? token : token.slice(0, eq));
-            if (eq === -1 && VALUE_FLAGS.has(name))
-                index += 1;
-            continue;
-        }
-        return token === "petition";
-    }
-    return false;
-}
-export function commandUsesPromptInput(command) {
-    return isCallCommand(command) || command === "tell" || command === "revive";
-}
-export function parseWaitTimeout(value) {
-    const matched = /^(?<amount>[1-9][0-9]*)(?<unit>[smh])$/.exec(value);
-    if (!matched?.groups) {
-        throw new FlowError("EMPTY_PARAM", "wait timeout must use <positive integer><s|m|h>, for example 45s, 5m, or 2h (maximum 24h)");
-    }
-    const amount = Number(matched.groups.amount);
-    const multiplier = matched.groups.unit === "s" ? 1_000 : matched.groups.unit === "m" ? 60_000 : 3_600_000;
-    const timeoutMs = amount * multiplier;
-    if (!Number.isSafeInteger(timeoutMs) || timeoutMs > 24 * 3_600_000) {
-        throw new FlowError("EMPTY_PARAM", "wait timeout must use <positive integer><s|m|h>, for example 45s, 5m, or 2h (maximum 24h)");
-    }
-    return timeoutMs;
-}
-export function commandPositionalRange(command) {
-    if (command === "akuma view")
-        return { min: 1, max: 1, label: "<name>" };
-    if (command === "log")
-        return { min: 0, max: 0, label: "" };
-    if (isCallCommand(command))
-        return { min: 1, max: 1, label: "<BODY|->" };
-    if (command === "tell")
-        return { min: 2, max: 2, label: "<PROJECTION> <BODY|->" };
-    if (command === "revive")
-        return { min: 1, max: 2, label: "<ARTIFACT> [BODY|-]" };
-    if (command === "wait")
-        return { min: 1, max: 1, label: "<projection-address>" };
-    if (command === "kill")
-        return { min: 1, max: 1, label: "<projection-address>" };
-    if (command === "status")
-        return { min: 0, max: 1, label: "[projection-id]" };
-    if (command === "task add")
-        return { min: 1, max: 1, label: "<BODY|->" };
-    if (command === "task view" || command === "task start" || command === "task drop")
-        return { min: 1, max: 1, label: "<ID>" };
-    if (command === "task update")
-        return { min: 1, max: 1, label: "<ID>" };
-    if (command === "task stop" || command === "task done")
-        return { min: 0, max: 1, label: "[ID]" };
-    return { min: 0, max: 0 };
-}
-function commandRequiresStdin(command) {
-    return getCommandMetadata(command).stdin === "required";
-}
-function commandTokens(command) {
-    return command.split(" ");
-}
-function parseFlagName(raw) {
-    return raw.slice(2);
-}
-function assignFlag(flags, name, value) {
-    switch (name) {
-        case "cwd":
-            flags.cwd = String(value);
-            return;
-        case "repo":
-            flags.repo = String(value);
-            return;
-        case "contract":
-            flags.contractId = normalizeContractAddress(String(value));
-            flags.contractAddressSource = "explicit-flag";
-            return;
-        case "akuma":
-            flags.akuma = String(value);
-            return;
-        case "projection":
-            flags.projection = String(value);
-            return;
-        case "alias":
-            flags.alias = String(value);
-            return;
-        case "timeout":
-        case "wait":
-            flags.timeoutMs = parseWaitTimeout(String(value));
-            return;
-        case "model":
-            flags.model = String(value);
-            return;
-        case "effort": {
-            const effort = String(value);
-            flags.effort = effort;
-            return;
-        }
-        case "incognito":
-            flags.incognito = Boolean(value);
-            return;
-        case "bare":
-            flags.bare = Boolean(value);
-            return;
-        case "detach":
-            flags.detach = Boolean(value);
-            return;
-        case "draft-only":
-            flags.draftOnly = Boolean(value);
-            return;
-        case "exclusive":
-            flags.exclusive = Boolean(value);
-            return;
-        case "place":
-            if (flags.bindPlace !== undefined) {
-                throw new FlowError("EMPTY_PARAM", "option --place may only be specified once");
-            }
-            flags.bindPlace = String(value);
-            return;
-        case "objective":
-            if (flags.bindObjective !== undefined) {
-                throw new FlowError("EMPTY_PARAM", "option --objective may only be specified once");
-            }
-            flags.bindObjective = String(value);
-            return;
-        case "scope":
-            if (flags.bindScope !== undefined) {
-                throw new FlowError("EMPTY_PARAM", "option --scope may only be specified once");
-            }
-            flags.bindScope = String(value);
-            return;
-        case "checks":
-            if (flags.bindChecks !== undefined) {
-                throw new FlowError("EMPTY_PARAM", "option --checks may only be specified once");
-            }
-            flags.bindChecks = String(value);
-            return;
-        case "task":
-            if (flags.bindTaskId !== undefined)
-                throw new FlowError("EMPTY_PARAM", "option --task may only be specified once");
-            flags.bindTaskId = String(value);
-            return;
-        case "after":
-            flags.after = [...(flags.after ?? []), String(value)];
-            return;
-        case "force":
-            flags.force = Boolean(value);
-            return;
-        case "reason":
-            flags.reason = String(value);
-            return;
-        case "dry-run":
-            flags.dryRun = Boolean(value);
-            return;
-        case "waive":
-            flags.waivePaths = [...(flags.waivePaths ?? []), String(value)];
-            return;
-        case "shell":
-            flags.shell = String(value);
-            return;
-        case "word":
-            flags.word = String(value);
-            return;
-        case "previous":
-            flags.previous = String(value);
-            return;
-        case "complete":
-            flags.complete = Boolean(value);
-            return;
-        case "all":
-            flags.all = Boolean(value);
-            return;
-        case "target":
-            if (flags.target !== undefined) {
-                throw new FlowError("EMPTY_PARAM", "option --target may only be specified once");
-            }
-            flags.target = String(value);
-            return;
-        case "json":
-            flags.json = Boolean(value);
-            return;
-        case "done":
-            flags.done = Boolean(value);
-            return;
-        case "pri": {
-            const raw = String(value);
-            if (!/^[0-3]$/.test(raw))
-                throw new FlowError("EMPTY_PARAM", "task priority must be an integer from 0 through 3");
-            if (flags.taskPri !== undefined)
-                throw new FlowError("EMPTY_PARAM", "option --pri may only be specified once");
-            flags.taskPri = Number(raw);
-            return;
-        }
-        case "needs":
-            flags.taskNeeds = [...(flags.taskNeeds ?? []), String(value)];
-            return;
-        case "drop-needs":
-            flags.taskDropNeeds = [...(flags.taskDropNeeds ?? []), String(value)];
-            return;
-        case "from":
-            flags.taskFrom = [...(flags.taskFrom ?? []), String(value)];
-            return;
-        case "parent":
-            if (flags.taskParent !== undefined)
-                throw new FlowError("EMPTY_PARAM", "option --parent may only be specified once");
-            flags.taskParent = String(value);
-            return;
-        case "no-parent":
-            flags.taskNoParent = Boolean(value);
-            return;
-        case "title":
-            if (flags.taskTitle !== undefined)
-                throw new FlowError("EMPTY_PARAM", "option --title may only be specified once");
-            flags.taskTitle = String(value);
-            return;
-        case "body":
-            if (flags.taskBody !== undefined)
-                throw new FlowError("EMPTY_PARAM", "option --body may only be specified once");
-            flags.taskBody = String(value);
-            return;
-        default:
-            throw new FlowError("EMPTY_PARAM", `unknown option: --${name}`);
-    }
-}
-function assertAllowedFlag(command, name) {
-    if (!allowedFlagsForParse(command).includes(name)) {
-        throw new FlowError("EMPTY_PARAM", `option --${name} is not valid for ${command}`);
-    }
-}
-function resolveCommand(tokens) {
-    if (tokens[0] === "petition" && (tokens[1] === "claim" || tokens[1] === "forfeit")) {
-        throw new FlowError("UNKNOWN_COMMAND", `unknown command: petition ${tokens[1]}`);
-    }
-    for (const command of commandParseOrder()) {
-        const parts = commandTokens(command);
-        if (parts.every((part, index) => tokens[index] === part)) {
-            return { command, rest: tokens.slice(parts.length) };
-        }
-    }
-    const [head] = tokens;
-    if (head === "skills") {
-        return { command: "skills", rest: tokens.slice(1) };
-    }
-    if (!head)
-        throw new FlowError("EMPTY_PARAM", "command cannot be empty");
-    throw new FlowError("UNKNOWN_COMMAND", `unknown command: ${head ?? ""}`.trim());
-}
-function splitAtLiteralBoundary(tokens) {
-    const boundary = tokens.indexOf("--");
-    if (boundary === -1)
-        return { head: tokens, payload: [] };
-    return { head: tokens.slice(0, boundary), payload: tokens.slice(boundary + 1) };
-}
-function readValueFlag(name, token, eq, tokens, index) {
-    // --target and task --body own emptiness in core; empty remains supplied.
-    // Other value flags keep the historical requires-a-value rejection.
-    if (eq !== -1) {
-        const value = token.slice(eq + 1);
-        if (value === "" && name !== "target" && name !== "body") {
-            throw new FlowError("EMPTY_PARAM", `option --${name} requires a value`);
-        }
-        return { value, nextIndex: index };
-    }
-    const value = tokens[index + 1];
-    if (value === undefined || value === "--" || value.startsWith("--")) {
-        throw new FlowError("EMPTY_PARAM", `option --${name} requires a value`);
-    }
-    if (value === "" && name !== "target" && name !== "body") {
-        throw new FlowError("EMPTY_PARAM", `option --${name} requires a value`);
-    }
-    // Short-flag values may begin with @; they are flag values, not commission tokens.
-    return { value, nextIndex: index + 1 };
-}
-function commissionConflictMessage(atForm, contractForm) {
-    return `commission address supplied twice: ${atForm} and --contract ${contractForm}; use exactly one form`;
-}
-function formatSelectorList(items) {
-    if (items.length <= 1)
-        return items[0] ?? "";
-    if (items.length === 2)
-        return `${items[0]} and ${items[1]}`;
-    return `${items.slice(0, -1).join(", ")}, and ${items[items.length - 1]}`;
-}
-function multiCommissionSelectorMessage(command, spellings) {
-    return `${command} accepts one commission address; got ${formatSelectorList(spellings)}`;
-}
-function commissionSelectorSpelling(source, value, rawToken) {
-    if (source === "at-address")
-        return rawToken ?? `@${value}`;
-    return `--contract ${rawToken ?? value}`;
-}
+import { HELP_FLAGS } from "./flags.js";
+import { assertAllowedFlag, assignFlag, BOOLEAN_FLAGS, CONTROL_FLAGS, parseFlagName, readValueFlag, SHORT_FLAG_ALIASES, VALUE_FLAGS, } from "./parse-flags.js";
+import { commandPositionalRange, commandRequiresStdin, isCallCommand, resolveCommand, splitAtLiteralBoundary, TASK_SUBCOMMANDS, } from "./parse-metadata.js";
+import { applyCommissionSelector, assertCommissionSelectorAllowed, assertProjectionSelectorPresent, } from "./parse-selectors.js";
+export { commandPositionalRange, commandUsesPromptInput, isCallCommand, isPetitionDryRunInvocation, normalizeContractAddress, parseWaitTimeout, } from "./parse-metadata.js";
 export function parseCliArgs(tokens) {
     const { head, payload } = splitAtLiteralBoundary(tokens);
     const flags = {};
@@ -411,29 +80,21 @@ export function parseCliArgs(tokens) {
         }
     }
     const { command, rest } = resolveCommand(free);
-    if (atTokens.length > 0 && contractFlagRaws.length > 0) {
-        throw new FlowError("EMPTY_PARAM", commissionConflictMessage(atTokens[0], contractFlagRaws[0]));
-    }
-    if (atTokens.length > 1) {
-        throw new FlowError("EMPTY_PARAM", multiCommissionSelectorMessage(command, atTokens));
-    }
-    if (contractFlagRaws.length > 1) {
-        throw new FlowError("EMPTY_PARAM", multiCommissionSelectorMessage(command, contractFlagRaws.map((raw) => `--contract ${raw}`)));
-    }
-    if (atTokens.length === 1) {
-        flags.contractId = normalizeContractAddress(atTokens[0]);
-        flags.contractAddressSource = "at-address";
-    }
-    else if (contractFlagRaws.length === 1) {
-        assignFlag(flags, "contract", contractFlagRaws[0]);
-    }
+    applyCommissionSelector(command, flags, atTokens, contractFlagRaws);
     if (helpRequested) {
         return {
             command,
-            flags: flags.contractId ? { contractId: flags.contractId, contractAddressSource: flags.contractAddressSource, ...(flags.cwd ? { cwd: flags.cwd } : {}), ...(flags.repo ? { repo: flags.repo } : {}) } : {
-                ...(flags.cwd ? { cwd: flags.cwd } : {}),
-                ...(flags.repo ? { repo: flags.repo } : {}),
-            },
+            flags: flags.contractId
+                ? {
+                    contractId: flags.contractId,
+                    contractAddressSource: flags.contractAddressSource,
+                    ...(flags.cwd ? { cwd: flags.cwd } : {}),
+                    ...(flags.repo ? { repo: flags.repo } : {}),
+                }
+                : {
+                    ...(flags.cwd ? { cwd: flags.cwd } : {}),
+                    ...(flags.repo ? { repo: flags.repo } : {}),
+                },
             positional: [],
             helpRequested: true,
         };
@@ -447,7 +108,6 @@ export function parseCliArgs(tokens) {
     if (command === "task") {
         throw new FlowError("EMPTY_PARAM", `task requires subcommand: ${TASK_SUBCOMMANDS.join(", ")}`);
     }
-    // --place is bind's H1 domain flag; every other command keeps the retired-selector mouth.
     if (command !== "bind" && seenFlagNames.has("place")) {
         throw new FlowError("EMPTY_PARAM", "unknown option --place; use @addr or --contract <addr>");
     }
@@ -471,22 +131,8 @@ export function parseCliArgs(tokens) {
     if (command === "petition" && flags.json && !flags.dryRun) {
         throw new FlowError("EMPTY_PARAM", "petition --json requires --dry-run");
     }
-    if (flags.contractId !== undefined && !COMMISSION_SELECTOR_COMMANDS.has(command)) {
-        throw new FlowError("EMPTY_PARAM", command === "bind"
-            ? `bind creates a commission and does not accept @${flags.contractId}; use -C/--cwd to select the repository`
-            : `contract address @${flags.contractId} is not valid for ${command}`);
-    }
-    if ((command === "wait" || command === "tell") && flags.contractId !== undefined) {
-        const selectorSpelling = commissionSelectorSpelling(flags.contractAddressSource === "at-address" ? "at-address" : "explicit-flag", flags.contractId, flags.contractAddressSource === "at-address" ? atTokens[0] : contractFlagRaws[0]);
-        const scopeOnlyMessage = `${command} requires a projection id or alias; ${selectorSpelling} only limits projection lookup, so add the projection address`;
-        if (command === "wait" && rest.length + payload.length === 0) {
-            throw new FlowError("EMPTY_PARAM", scopeOnlyMessage);
-        }
-        if (command === "tell" && rest.length === 0) {
-            // Payload after -- is the message body, never the projection address.
-            throw new FlowError("EMPTY_PARAM", scopeOnlyMessage);
-        }
-    }
+    assertCommissionSelectorAllowed(command, flags);
+    assertProjectionSelectorPresent(command, flags, atTokens, contractFlagRaws, rest.length, payload.length);
     const positional = [...rest, ...payload];
     if (isCallCommand(command)) {
         if (flags.akuma) {

package/build/cli/skills-install.js

@@ -7,7 +7,7 @@ import { FlowError, asMessage } from "../flow-error.js";
 import { VERSION } from "../generated/version.js";
 const MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
 const PACKAGE_ROOT = path.resolve(MODULE_DIR, "../..");
-const OFFICIAL_SKILLS = ["keiyaku", "keiyaku-akuma"];
+const OFFICIAL_SKILLS = ["keiyaku", "keiyaku-akuma", "keiyaku-workflow", "keiyaku-task"];
 const SKILL_ROOT = path.join(PACKAGE_ROOT, "skills");
 const INSTALL_MARKER = ".keiyaku-skill-owned.json";
 function skillSource(skill) {

package/build/config/akuma-loader.js

@@ -2,7 +2,7 @@ import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { z } from "zod";
 import { parseToAST } from "../core/markdown/parser.js";
-import { isGitRepo } from "../git/branches.js";
+import { observeGitRepository } from "../git/branches.js";
 import { BUILTIN_AGENT_PROFILES } from "../keiyaku.js";
 import { getKeiyakuHome } from "./env.js";
 import { agentNameSchema, providerInstanceNameSchema } from "./settings/schema.js";
@@ -211,7 +211,10 @@ export async function loadAkumaCatalog(cwd) {
         selected[name] = candidate;
     }
     foldLayer(selected, shadows, candidates, "user", await readLayer(path.join(getKeiyakuHome(), "akuma"), "user"));
-    if (await isGitRepo(cwd)) {
+    const repository = await observeGitRepository(cwd);
+    if (repository.capability === "unknown")
+        throw repository.error;
+    if (repository.capability === "available" && repository.coordinate === "repository") {
         foldLayer(selected, shadows, candidates, "project", await readLayer(path.join(cwd, ".keiyaku", "akuma"), "project"));
     }
     return Object.freeze({

package/build/core/amend.js

@@ -1,7 +1,7 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { FlowError } from "../flow-error.js";
-import { getCurrentBranch, isGitRepo } from "../git/branches.js";
+import { getCurrentBranch, requireGitRepository } from "../git/branches.js";
 import { KEIYAKU_FILE } from "../keiyaku.js";
 import { activeLedgerRef, appendWithRetry, readLedger } from "./ledger.js";
 import { renderContractView } from "./contract-view.js";
@@ -71,10 +71,7 @@ export async function amendContract(input) {
     return { contractId: input.contractId, amendmentNumber, ledgerHead: result.head };
 }
 export async function amendKeiyaku(input) {
-    const isRepo = await isGitRepo(input.cwd);
-    if (!isRepo) {
-        throw new FlowError("NOT_GIT_REPO", `${input.cwd} is not a git repository`);
-    }
+    await requireGitRepository(input.cwd, "amend");
     const address = await resolveContractAddress(input.cwd, input.contractId, input.contractAddressSource);
     return await withResolvedAddress(address, async () => {
         const contractId = address.binding.commissionId;

package/build/core/arc.js

@@ -1,7 +1,7 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { requireText, FlowError } from "../flow-error.js";
-import { getCurrentBranch, isGitRepo } from "../git/branches.js";
+import { getCurrentBranch, requireGitRepository } from "../git/branches.js";
 import { DIRTY_FILE_CATEGORY, getDirtyFiles, renderDirtyFileStatusLine } from "../git/worktree.js";
 import { KEIYAKU_FILE, ACTOR_IDENTITY } from "../keiyaku.js";
 import { buildDirtyWorktreeArtifactHint } from "./hints.js";
@@ -161,9 +161,7 @@ async function readBranchLabels(cwd) {
     return { currentBranch, baseBranch };
 }
 export async function arcKeiyaku(input) {
-    if (!(await isGitRepo(input.cwd))) {
-        throw new FlowError("NOT_GIT_REPO", `${input.cwd} is not a git repository`);
-    }
+    await requireGitRepository(input.cwd, "arc");
     const address = await resolveContractAddress(input.cwd, input.contractId, input.contractAddressSource);
     return await withResolvedAddress(address, async () => {
         await assertCleanWorkingTree(input.cwd, []);

package/build/core/call/call.js

@@ -3,7 +3,7 @@ import { selectSubagent } from "../../agents/selector.js";
 import { applySnapshotEffort } from "../../agents/launch-snapshot/model.js";
 import { resolveAkumaLaunchSnapshot } from "../../agents/launch-snapshot/resolve.js";
 import { FlowError, requireText } from "../../flow-error.js";
-import { isGitRepo } from "../../git/branches.js";
+import { assertGitObservation, observeGitRepository } from "../../git/branches.js";
 import { ACTOR_IDENTITY } from "../../keiyaku.js";
 import { appendDebugBlock } from "../../telemetry/debug-log.js";
 import { logInfo } from "../../telemetry/logger.js";
@@ -54,12 +54,17 @@ export async function runCall(input) {
     else if (reviveArtifact?.provenance.authority.kind === "repository") {
         const artifactHome = await fs.realpath(reviveArtifact.storageRoot);
         const addressed = input.repo ?? input.cwd;
-        if (await isGitRepo(addressed)) {
+        const observation = await observeGitRepository(addressed);
+        const coordinate = assertGitObservation(observation, "revive");
+        if (coordinate === "repository") {
             const addressedRoot = await stableRepoRoot(addressed);
             if (addressedRoot !== artifactHome) {
                 throw new FlowError("INVALID_RESPONSE_PATH", `Response artifact '${reviveArtifact.artifactId}' belongs to ${artifactHome}, but the addressed repository is ${addressedRoot}.`);
             }
         }
+        else {
+            throw new FlowError("NOT_GIT_REPO", `${addressed} is not a git repository`);
+        }
         rawCwd = artifactHome;
         rawRepo = artifactHome;
     }

package/build/core/call/context.js

@@ -1,6 +1,6 @@
 import * as fs from "fs/promises";
 import { FlowError } from "../../flow-error.js";
-import { isGitRepo } from "../../git/branches.js";
+import { assertGitObservation, observeGitRepository } from "../../git/branches.js";
 import { createGit, wrapGitError } from "../../git/core.js";
 import { AddressResolutionError, buildResolutionAttempt, buildUncommissionedAddress, buildUncommissionedRepositoryAddress, resolveContractAddress, withResolvedAddress, } from "../addressing.js";
 import { findOpenArcView } from "../arc.js";
@@ -48,8 +48,16 @@ async function resolveWorkspaceCwd(cwd, contractId, bind) {
 }
 export async function readCallKeiyakuContext(executionCwd, input) {
     const ledgerCandidate = input.repoCwd ?? executionCwd;
-    const isRepo = await isGitRepo(ledgerCandidate);
-    if (!isRepo) {
+    const ledgerObservation = await observeGitRepository(ledgerCandidate);
+    if (ledgerObservation.capability === "unknown")
+        throw ledgerObservation.error;
+    if (ledgerObservation.capability === "unavailable" && (input.repoCwd || input.contractId)) {
+        assertGitObservation(ledgerObservation, input.repoCwd ? `${input.mode ?? "call"} --repo` : "contract addressing");
+    }
+    if (input.repoCwd && ledgerObservation.capability === "available" && ledgerObservation.coordinate === "non-repository") {
+        throw new FlowError("NOT_GIT_REPO", `${ledgerCandidate} is not a git repository`);
+    }
+    if (ledgerObservation.capability !== "available" || ledgerObservation.coordinate !== "repository") {
         if (input.bare && input.contractId) {
             const asTyped = input.contractAddressSource === "at-address"
                 ? `@${input.contractId}`
@@ -146,18 +154,23 @@ export async function readCallKeiyakuContext(executionCwd, input) {
     if (input.contractId) {
         address = await resolveContractAddress(ledgerCwd, input.contractId, input.contractAddressSource);
     }
-    else if (await isGitRepo(executionCwd)) {
-        const executionRepo = await stableRepoRoot(executionCwd);
-        if (input.repoCwd && executionRepo !== ledgerCwd) {
-            const presented = await contractPresentedByWorktree(executionCwd);
-            if (presented) {
-                throw new FlowError("EMPTY_PARAM", `cross-repository contract-worktree addressing is pending: -C presents @${presented} from ${executionRepo}, but --repo selects ${ledgerCwd}`);
+    else {
+        const executionObservation = await observeGitRepository(executionCwd);
+        if (executionObservation.capability === "unknown")
+            throw executionObservation.error;
+        if (executionObservation.capability === "available" && executionObservation.coordinate === "repository") {
+            const executionRepo = await stableRepoRoot(executionCwd);
+            if (input.repoCwd && executionRepo !== ledgerCwd) {
+                const presented = await contractPresentedByWorktree(executionCwd);
+                if (presented) {
+                    throw new FlowError("EMPTY_PARAM", `cross-repository contract-worktree addressing is pending: -C presents @${presented} from ${executionRepo}, but --repo selects ${ledgerCwd}`);
+                }
             }
-        }
-        else {
-            const presented = await contractPresentedByWorktree(executionCwd);
-            if (presented) {
-                address = await resolveContractAddress(ledgerCwd, presented, "worktree-presented");
+            else {
+                const presented = await contractPresentedByWorktree(executionCwd);
+                if (presented) {
+                    address = await resolveContractAddress(ledgerCwd, presented, "worktree-presented");
+                }
             }
         }
     }

package/build/core/call-persist.js

@@ -2,7 +2,8 @@ import { appendDebugLog } from "../telemetry/debug-log.js";
 import { logWarn } from "../telemetry/logger.js";
 import { runCall } from "./call/call.js";
 import { persistResponseHistory } from "./transcripts.js";
-import { isGitRepo } from "../git/branches.js";
+import { assertGitObservation, observeGitRepository } from "../git/branches.js";
+import { FlowError } from "../flow-error.js";
 import * as path from "node:path";
 import * as fs from "node:fs/promises";
 import { stableRepoRoot } from "./worktree-path.js";
@@ -14,7 +15,13 @@ function responsePathFromPrintingCwd(historyStorageCwd, responsePath) {
 export async function runCallAndPersist(input) {
     const historyCandidate = input.repo ?? input.cwd;
     const canonicalHistoryCandidate = await fs.realpath(historyCandidate);
-    const historyStorageCwd = (await isGitRepo(historyCandidate))
+    const historyObservation = await observeGitRepository(historyCandidate);
+    if (input.repo && assertGitObservation(historyObservation, `${input.mode ?? "call"} --repo`) === "non-repository") {
+        throw new FlowError("NOT_GIT_REPO", `${historyCandidate} is not a git repository`);
+    }
+    if (historyObservation.capability === "unknown")
+        throw historyObservation.error;
+    const historyStorageCwd = (historyObservation.capability === "available" && historyObservation.coordinate === "repository")
         ? await stableRepoRoot(historyCandidate)
         : canonicalHistoryCandidate;
     const historyDisplayCwd = path.resolve(historyCandidate, path.relative(canonicalHistoryCandidate, historyStorageCwd));

package/build/core/path-coordinate.js

@@ -0,0 +1,27 @@
+import * as fs from "node:fs";
+import * as fsPromises from "node:fs/promises";
+import * as path from "node:path";
+/**
+ * Git for Windows may emit native, slash-normalized, or MSYS drive paths.
+ * Keep one host-native spelling before using a coordinate as a filesystem cwd.
+ */
+export function normalizeGitPath(raw, platform = process.platform) {
+    const value = raw.trim();
+    if (platform !== "win32")
+        return path.normalize(value);
+    const msysDrive = value.match(/^\/([A-Za-z])(?:\/|$)(.*)$/);
+    if (msysDrive)
+        return path.win32.normalize(`${msysDrive[1].toUpperCase()}:/${msysDrive[2]}`);
+    const normalized = path.win32.normalize(value);
+    return normalized.replace(/^([a-z]):/, (_, drive) => `${drive.toUpperCase()}:`);
+}
+export function gitCommonRootPath(raw, platform = process.platform) {
+    const paths = platform === "win32" ? path.win32 : path.posix;
+    return paths.dirname(normalizeGitPath(raw, platform));
+}
+export async function resolveGitCommonRoot(raw) {
+    return await fsPromises.realpath(gitCommonRootPath(raw));
+}
+export function resolveGitCommonRootSync(raw) {
+    return fs.realpathSync(gitCommonRootPath(raw));
+}

package/build/core/petition-run.js

@@ -4,7 +4,7 @@ import { FlowError } from "../flow-error.js";
 import { readCurrentContractContext } from "./context.js";
 import { readLedger } from "./ledger.js";
 import { commissionTarget } from "./status/drift.js";
-import { getCurrentBranch, isGitRepo } from "../git/branches.js";
+import { getCurrentBranch, requireGitRepository } from "../git/branches.js";
 import { claimKeiyaku } from "./petition-claim.js";
 import { forfeitKeiyaku } from "./petition-forfeit.js";
 const VERDICT_DENIED_CODE = "VERDICT_DENIED";
@@ -33,10 +33,7 @@ async function resolveClaimGateConfig(cwd) {
     }
 }
 async function loadCloseContext(cwd, requestedContractId) {
-    const isRepo = await isGitRepo(cwd);
-    if (!isRepo) {
-        throw new FlowError("NOT_GIT_REPO", `${cwd} is not a git repository`);
-    }
+    await requireGitRepository(cwd, "petition");
     if (requestedContractId) {
         const ledger = await readLedger(cwd, requestedContractId);
         if (!ledger) {