@astrosheep/keiyaku 2.8.5 → 2.9.1

package/build/core/transcripts.js

@@ -1,7 +1,7 @@
 import { randomBytes } from "node:crypto";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
-import { parseResolvedAkumaLaunchSnapshot, } from "../agents/launch-snapshot_v2.js";
+import { parseResolvedAkumaLaunchSnapshot, } from "../agents/launch-snapshot/model.js";
 import { resolvePersistedSubagentSession } from "../agents/session.js";
 import { isErrnoException } from "../errno.js";
 import { FlowError, requireText } from "../flow-error.js";
@@ -13,6 +13,8 @@ import { parseExecutionCoordinates } from "./execution-coordinate.js";
 import { createUlid } from "./ids.js";
 import { parseToAST } from "./markdown/parser.js";
 import { isResponseArtifactId, RESPONSE_ARTIFACT_ID_RE } from "./response-artifact-id.js";
+import { getResponseArtifactCatalog, } from "./response-artifact-catalog.js";
+import { assertExactFields, assertNonBlankString, isPlainRecord, } from "./validation.js";
 export { isResponseArtifactId, RESPONSE_ARTIFACT_ID_RE } from "./response-artifact-id.js";
 const RESPONSE_HISTORY_SLUG_MAX_LENGTH = 24;
 const RESPONSE_HISTORY_SESSION_KEY = "session";
@@ -30,43 +32,30 @@ const RESUMABLE_RESPONSE_HEADINGS = Object.values(RESPONSE_ARTIFACT_HEADINGS);
 function artifactError(locator, field, reason) {
     return new FlowError("INVALID_RESPONSE_PATH", `Invalid response artifact '${locator}': field '${field}' ${reason}.`);
 }
-function isRecord(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function assertExactFields(value, required, locator, prefix) {
-    for (const field of required) {
-        if (!(field in value))
-            throw artifactError(locator, `${prefix}.${field}`, "is missing");
-    }
-    const allowed = new Set(required);
-    const unknown = Object.keys(value).filter((field) => !allowed.has(field)).sort()[0];
-    if (unknown !== undefined)
-        throw artifactError(locator, `${prefix}.${unknown}`, "is unknown");
-}
-function nonBlank(value, locator, field) {
-    if (typeof value !== "string" || value.trim() === "")
-        throw artifactError(locator, field, "must be a non-blank string");
+function artifactInvalid(locator) {
+    return (field, reason) => artifactError(locator, field, reason);
 }
 /** The sole durable provenance parser. */
 export function parseResponseArtifactProvenance(value, locator) {
-    if (!isRecord(value))
+    const invalid = artifactInvalid(locator);
+    if (!isPlainRecord(value))
         throw artifactError(locator, "provenance", "must be an object");
-    assertExactFields(value, ["artifactId", "authority", "binding", "evidence"], locator, "provenance");
-    nonBlank(value.artifactId, locator, "provenance.artifactId");
+    assertExactFields(value, ["artifactId", "authority", "binding", "evidence"], [], "provenance", invalid);
+    assertNonBlankString(value.artifactId, "provenance.artifactId", invalid);
     if (!RESPONSE_ARTIFACT_ID_RE.test(value.artifactId)) {
         throw artifactError(locator, "provenance.artifactId", "must be rsp_ followed by a ULID");
     }
     const { authority, binding } = parseExecutionCoordinates(value.authority, value.binding, (field, reason) => artifactError(locator, `provenance.${field}`, reason));
-    if (!isRecord(value.evidence))
+    if (!isPlainRecord(value.evidence))
         throw artifactError(locator, "provenance.evidence", "must be an object");
     if (authority.kind === "repository") {
-        assertExactFields(value.evidence, ["branch", "commit"], locator, "provenance.evidence");
-        nonBlank(value.evidence.branch, locator, "provenance.evidence.branch");
-        nonBlank(value.evidence.commit, locator, "provenance.evidence.commit");
+        assertExactFields(value.evidence, ["branch", "commit"], [], "provenance.evidence", invalid);
+        assertNonBlankString(value.evidence.branch, "provenance.evidence.branch", invalid);
+        assertNonBlankString(value.evidence.commit, "provenance.evidence.commit", invalid);
         return { artifactId: value.artifactId, authority, binding, evidence: { branch: value.evidence.branch, commit: value.evidence.commit } };
     }
-    assertExactFields(value.evidence, ["workdir"], locator, "provenance.evidence");
-    nonBlank(value.evidence.workdir, locator, "provenance.evidence.workdir");
+    assertExactFields(value.evidence, ["workdir"], [], "provenance.evidence", invalid);
+    assertNonBlankString(value.evidence.workdir, "provenance.evidence.workdir", invalid);
     if (!path.isAbsolute(value.evidence.workdir)) {
         throw artifactError(locator, "provenance.evidence.workdir", "must be an absolute path");
     }
@@ -130,6 +119,15 @@ export async function persistResponseHistory(input) {
     const responsePath = path.join(historyDir, `${fileStamp}_${input.tool.toUpperCase()}_${slug(input.title ?? "", input.tool)}.md`);
     await fs.mkdir(historyDir, { recursive: true });
     await fs.writeFile(responsePath, buildMarkdown(input, iso, provenance), "utf8");
+    try {
+        getResponseArtifactCatalog()?.register({
+            id: artifactId,
+            stableRoot: await fs.realpath(input.cwd),
+        });
+    }
+    catch {
+        // The catalog is a disposable read model; the persisted artifact remains truth.
+    }
     return { artifactId, responsePath: path.relative(input.cwd, responsePath) };
 }
 function detectTool(document) {
@@ -206,43 +204,30 @@ export async function readResponseArtifact(input) {
         }
     }
     const subagentName = frontmatter.subagent_name?.trim() || undefined;
-    const storageRoot = path.resolve(path.dirname(absolutePath), "..", "..");
+    const storageRoot = await fs.realpath(path.resolve(path.dirname(absolutePath), "..", ".."));
     return { artifactId: provenance.artifactId, responsePath: path.relative(input.cwd, absolutePath), absolutePath, storageRoot, provenance, tool, ...(session ? { session } : {}), ...(launchSnapshot ? { launchSnapshot } : {}), ...(subagentName ? { subagentName } : {}) };
 }
-export async function locateResponseArtifact(input) {
-    const carry = (error) => {
-        throw attachAddressCarrier(error, input.attempt);
-    };
-    let identity;
-    try {
-        identity = requireText("artifactId", input.artifactId);
-    }
-    catch (error) {
-        return carry(error);
-    }
-    if (!isResponseArtifactId(identity)) {
-        return carry(new FlowError("INVALID_RESPONSE_PATH", `${identity} is not a response artifact handle; revive expects an artifact id`));
-    }
-    const historyDir = path.join(input.cwd, RESPONSE_HISTORY_DIR);
+async function findResponseArtifactAtRoot(input) {
+    const physicalHistoryDir = path.join(input.stableRoot, RESPONSE_HISTORY_DIR);
+    const historyDir = path.join(input.displayRoot ?? input.stableRoot, RESPONSE_HISTORY_DIR);
     let names;
     try {
-        names = await fs.readdir(historyDir);
+        names = await fs.readdir(physicalHistoryDir);
     }
     catch (error) {
-        if (isErrnoException(error) && error.code === "ENOENT") {
-            return carry(new FlowError("INVALID_RESPONSE_PATH", `Response artifact '${identity}' was not found in ${historyDir}.`));
-        }
-        return carry(error);
+        if (isErrnoException(error) && error.code === "ENOENT")
+            return { kind: "missing" };
+        return input.carry(error);
     }
     let match;
     for (const name of names.filter((candidate) => candidate.endsWith(".md")).sort()) {
         const responsePath = path.join(RESPONSE_HISTORY_DIR, name);
         let document;
         try {
-            document = await fs.readFile(path.join(input.cwd, responsePath), "utf8");
+            document = await fs.readFile(path.join(input.stableRoot, responsePath), "utf8");
         }
         catch (error) {
-            return carry(error);
+            return input.carry(error);
         }
         const encoded = parseToAST(document).frontmatter?.entries?.[RESPONSE_HISTORY_PROVENANCE_KEY];
         if (encoded === undefined)
@@ -254,26 +239,123 @@ export async function locateResponseArtifact(input) {
         catch {
             continue;
         }
-        if (!isRecord(indexed) || indexed.artifactId !== identity)
+        if (!isPlainRecord(indexed) || indexed.artifactId !== input.artifactId)
             continue;
         let parsed;
         try {
-            parsed = await readResponseArtifact({ cwd: input.cwd, responsePath });
+            parsed = await readResponseArtifact({ cwd: input.stableRoot, responsePath });
         }
         catch (error) {
-            return carry(error);
+            return input.carry(error);
         }
         if (!parsed)
             continue;
         if (match) {
-            return carry(new FlowError("INVALID_RESPONSE_PATH", `Response artifact identity '${identity}' is duplicated in ${historyDir}.`));
+            return input.carry(new FlowError("INVALID_RESPONSE_PATH", `Response artifact identity '${input.artifactId}' is duplicated in ${historyDir}.`));
         }
         match = parsed;
     }
-    if (!match) {
-        return carry(new FlowError("INVALID_RESPONSE_PATH", `Response artifact '${identity}' was not found in ${historyDir}.`));
+    return match ? { kind: "found", artifact: match } : { kind: "missing" };
+}
+function observeCatalogArtifact(catalog, artifact) {
+    try {
+        catalog?.touch({ id: artifact.artifactId, stableRoot: artifact.storageRoot });
+    }
+    catch {
+        // Artifact observation remains authoritative when the disposable catalog is unavailable.
+    }
+}
+export async function reconcileResponseArtifactCatalog(stableRoot) {
+    const catalog = getResponseArtifactCatalog();
+    if (!catalog)
+        return;
+    const physicalRoot = await fs.realpath(stableRoot);
+    const historyDir = path.join(physicalRoot, RESPONSE_HISTORY_DIR);
+    let names;
+    try {
+        names = await fs.readdir(historyDir);
+    }
+    catch (error) {
+        if (isErrnoException(error) && error.code === "ENOENT")
+            return;
+        throw error;
     }
-    return match;
+    for (const name of names.filter((candidate) => candidate.endsWith(".md")).sort()) {
+        try {
+            const artifact = await readResponseArtifact({
+                cwd: physicalRoot,
+                responsePath: path.join(RESPONSE_HISTORY_DIR, name),
+            });
+            if (artifact)
+                catalog.register({ id: artifact.artifactId, stableRoot: artifact.storageRoot });
+        }
+        catch {
+            // Reconciliation observes valid local artifacts only; it never repairs artifact truth.
+        }
+    }
+}
+export async function locateResponseArtifact(input) {
+    const carry = (error) => {
+        throw attachAddressCarrier(error, input.attempt);
+    };
+    let identity;
+    try {
+        identity = requireText("artifactId", input.artifactId);
+    }
+    catch (error) {
+        return carry(error);
+    }
+    if (!isResponseArtifactId(identity)) {
+        return carry(new FlowError("INVALID_RESPONSE_PATH", `${identity} is not a response artifact handle; revive expects an artifact id`));
+    }
+    let physicalLocalRoot;
+    try {
+        physicalLocalRoot = await fs.realpath(input.cwd);
+    }
+    catch (error) {
+        if (!isErrnoException(error) || error.code !== "ENOENT")
+            return carry(error);
+        physicalLocalRoot = path.resolve(input.cwd);
+    }
+    const local = await findResponseArtifactAtRoot({
+        stableRoot: physicalLocalRoot,
+        displayRoot: input.cwd,
+        artifactId: identity,
+        carry,
+    });
+    const catalog = getResponseArtifactCatalog();
+    if (local.kind === "found") {
+        observeCatalogArtifact(catalog, local.artifact);
+        return local.artifact;
+    }
+    let cataloged;
+    try {
+        cataloged = catalog?.lookup(identity);
+    }
+    catch {
+        cataloged = undefined;
+    }
+    if (cataloged) {
+        const catalogedRoot = cataloged.stableRoot;
+        const remote = await findResponseArtifactAtRoot({
+            stableRoot: catalogedRoot,
+            artifactId: identity,
+            carry,
+        });
+        if (remote.kind === "found") {
+            observeCatalogArtifact(catalog, remote.artifact);
+            return remote.artifact;
+        }
+        try {
+            catalog?.removeDead({ id: identity, stableRoot: catalogedRoot });
+        }
+        catch {
+            // Dead-row cleanup is best-effort; the physical lookup result owns the error.
+        }
+        return carry(new FlowError("INVALID_RESPONSE_PATH", `${identity} not found at cataloged root ${catalogedRoot}`));
+    }
+    const historyDir = path.join(input.cwd, RESPONSE_HISTORY_DIR);
+    return carry(new FlowError("INVALID_RESPONSE_PATH", `Response artifact '${identity}' was not found in ${historyDir}.`));
 }
 export function requireResumableArtifact(artifact) {
     if (!artifact.session)

package/build/core/validation.js

@@ -0,0 +1,17 @@
+export function isPlainRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+export function assertExactFields(value, required, optional, prefix, invalid) {
+    for (const field of required) {
+        if (!(field in value))
+            throw invalid(prefix ? `${prefix}.${field}` : field, "is missing");
+    }
+    const allowed = new Set([...required, ...optional]);
+    const unknown = Object.keys(value).filter((field) => !allowed.has(field)).sort()[0];
+    if (unknown !== undefined)
+        throw invalid(prefix ? `${prefix}.${unknown}` : unknown, "is unknown");
+}
+export function assertNonBlankString(value, field, invalid) {
+    if (typeof value !== "string" || value.trim() === "")
+        throw invalid(field, "must be a non-blank string");
+}

package/build/core/verdict.js

@@ -1,8 +1,8 @@
 import { FlowError } from "../flow-error.js";
 import { claimContract } from "./claim.js";
 import { activeLedgerRef, appendWithRetry, readLedger } from "./ledger.js";
-import { assertClaimQueueHead, queueMembership, readQueueReadModel } from "./queue_v2.js";
-import { deriveContractState } from "./status.js";
+import { assertClaimQueueHead, queueMembership, readQueueReadModel } from "./queue.js";
+import { deriveContractState } from "./status/lifecycle.js";
 function latestVerdict(entries) {
     for (let index = entries.length - 1; index >= 0; index -= 1) {
         const entry = entries[index];

package/build/core/worktree-path.js

@@ -4,7 +4,8 @@ import { FlowError } from "../flow-error.js";
 import { createGit, wrapGitError } from "../git/core.js";
 import { readLedger } from "./ledger.js";
 import { listContractIds } from "./ledger.js";
-import { deriveContractState, isTerminalState } from "./status.js";
+import { deriveContractState, isTerminalState } from "./status/lifecycle.js";
+import { gitCommonRootPath, resolveGitCommonRoot } from "./path-coordinate.js";
 export function findBindEntry(entries) {
     return entries.find((entry) => entry.kind === "bind");
 }
@@ -58,10 +59,16 @@ export async function stableRepoRoot(cwd) {
     catch (error) {
         throw wrapGitError("rev-parse --path-format=absolute --git-common-dir", error, cwd);
     }
-    if (!path.isAbsolute(commonDir)) {
+    const stableRoot = gitCommonRootPath(commonDir);
+    if (!path.isAbsolute(stableRoot)) {
         throw new FlowError("INTERNAL_STATE", `git common directory is not absolute: ${commonDir}`);
     }
-    return path.dirname(commonDir);
+    try {
+        return await resolveGitCommonRoot(commonDir);
+    }
+    catch (error) {
+        throw new FlowError("INTERNAL_STATE", `cannot resolve git common directory ${stableRoot}`, { cause: error });
+    }
 }
 export async function contractWorktreePathFromBind(cwd, contractId, bind) {
     return path.join(await stableRepoRoot(cwd), ".keiyaku", "wt", bind?.data.place ?? contractId);
@@ -94,11 +101,11 @@ export async function findContractWorktreePath(cwd, contractId) {
     return (await findContractWorktree(cwd, contractId)).path;
 }
 /**
- * Resolve the active commission presented by an engine-owned contract
- * worktree containing cwd. Ordinary repository directories and arbitrary
- * worktrees never present a commission address.
+ * Resolve the contract id for an engine-owned bound worktree containing cwd.
+ * Matches the canonical bind place path and worktree workspace only; ledger
+ * terminal state is optional so residual worktrees after cleanup still bind.
  */
-export async function contractPresentedByWorktree(cwd) {
+async function contractIdForEngineOwnedWorktree(cwd, options) {
     const stableRoot = await stableRepoRoot(cwd);
     const canonicalCwd = await fs.realpath(cwd);
     for (const worktree of await listWorktrees(stableRoot)) {
@@ -107,7 +114,9 @@ export async function contractPresentedByWorktree(cwd) {
             continue;
         const contractId = worktree.branch.slice(branchPrefix.length);
         const ledger = await readLedger(stableRoot, contractId);
-        if (!ledger || isTerminalState(deriveContractState(ledger.entries)))
+        if (!ledger)
+            continue;
+        if (options.requireActive && isTerminalState(deriveContractState(ledger.entries)))
             continue;
         const bind = findBindEntry(ledger.entries);
         if (!bind || bind.data.workspace !== "worktree")
@@ -128,6 +137,22 @@ export async function contractPresentedByWorktree(cwd) {
     }
     return undefined;
 }
+/**
+ * Resolve the active commission presented by an engine-owned contract
+ * worktree containing cwd. Ordinary repository directories and arbitrary
+ * worktrees never present a commission address.
+ */
+export async function contractPresentedByWorktree(cwd) {
+    return contractIdForEngineOwnedWorktree(cwd, { requireActive: true });
+}
+/**
+ * Resolve the contract bound by an engine-owned worktree containing cwd,
+ * including when the ledger is already terminal. Task CLI contract context
+ * uses this residual binding; call/addressing keep active-only presentation.
+ */
+export async function contractBoundByEngineWorktree(cwd) {
+    return contractIdForEngineOwnedWorktree(cwd, { requireActive: false });
+}
 export async function cleanupContractWorkspace(cwd, contractId) {
     const stableRoot = await stableRepoRoot(cwd);
     const git = createGit(stableRoot);

package/build/flow-error.js

@@ -1,4 +1,5 @@
-import { ACTOR_IDENTITY, SETTINGS_FILE } from "./keiyaku.js";
+import { ACTOR_IDENTITY, SETTINGS_PATH_SEGMENTS } from "./keiyaku-constants.js";
+const SETTINGS_DISPLAY_PATH = SETTINGS_PATH_SEGMENTS.join("/");
 const DEFAULT_HINT_CONTEXT = {
     bindToolName: "bind",
     arcToolName: "arc",
@@ -20,6 +21,8 @@ function resolveFlowErrorHint(code, context) {
     switch (code) {
         case "NOT_GIT_REPO":
             return "The provided `cwd` is not a git repository.";
+        case "GIT_UNAVAILABLE":
+            return "Install Git, or use an explicitly bare command that does not require repository authority.";
         case "ACTIVE_KEIYAKU_EXISTS":
             return `Next: open an arc with \`${context.arcToolName}\`, then use \`${context.renewToolName}\` when delivery must follow the current base, or \`${context.closeToolName}\` to settle it.`;
         case "CONTRACT_AMBIGUOUS":
@@ -63,7 +66,7 @@ function resolveFlowErrorHint(code, context) {
         case "INVALID_CLOSE_INTENT":
             return "Invalid close intent. Valid values are `CLAIM` and `FORFEIT`.";
         case "INVALID_SETTINGS":
-            return `Fix invalid configuration in \`${SETTINGS_FILE}\` and retry.`;
+            return `Fix invalid configuration in \`${SETTINGS_DISPLAY_PATH}\` and retry.`;
         case "INVALID_EFFORT_OVERRIDE":
             return "Choose an effort value declared by the selected Akuma's effortOptions.";
         case "CONCURRENT_MODIFICATION":

package/build/generated/version.js

@@ -1,2 +1,2 @@
 // Auto-generated by scripts/generate-version.mjs
-export const VERSION = "2.8.5";
+export const VERSION = "2.9.0";

package/build/git/branches.js

@@ -1,17 +1,41 @@
 import { simpleGit } from "simple-git";
 import { FlowError } from "../flow-error.js";
-import { createGit, wrapGitError } from "./core.js";
-export async function isGitRepo(cwd) {
-    const git = simpleGit(cwd);
-    git.env("GIT_TERMINAL_PROMPT", "0");
-    git.env("GCM_INTERACTIVE", "Never");
-    git.env("GIT_MERGE_AUTOEDIT", "no");
-    git.env("LC_ALL", "C");
+import { createGit, errorContainsAnyPattern, isGitExecutableUnavailable, NOT_GIT_REPOSITORY_PATTERNS, wrapGitError, } from "./core.js";
+export async function observeGitRepository(cwd) {
     try {
-        return await git.checkIsRepo();
+        const git = simpleGit(cwd);
+        git.env("GIT_TERMINAL_PROMPT", "0");
+        git.env("GCM_INTERACTIVE", "Never");
+        git.env("GIT_MERGE_AUTOEDIT", "no");
+        git.env("LC_ALL", "C");
+        git.env("PATH", process.env.PATH ?? "");
+        const output = await git.raw(["rev-parse", "--is-inside-work-tree", "--is-bare-repository"]);
+        const [insideWorktree, bare] = output.trim().split(/\r?\n/);
+        return {
+            capability: "available",
+            coordinate: insideWorktree === "true" && bare !== "true" ? "repository" : "non-repository",
+        };
     }
     catch (err) {
-        throw wrapGitError("check-is-repo", err, cwd);
+        if (isGitExecutableUnavailable(err))
+            return { capability: "unavailable" };
+        if (errorContainsAnyPattern(err, NOT_GIT_REPOSITORY_PATTERNS)) {
+            return { capability: "available", coordinate: "non-repository" };
+        }
+        return { capability: "unknown", error: wrapGitError("check-is-repo", err, cwd) };
+    }
+}
+export function assertGitObservation(observation, operation) {
+    if (observation.capability === "unavailable") {
+        throw new FlowError("GIT_UNAVAILABLE", `Git executable is unavailable; ${operation} requires repository authority.`);
+    }
+    if (observation.capability === "unknown")
+        throw observation.error;
+    return observation.coordinate;
+}
+export async function requireGitRepository(cwd, operation) {
+    if (assertGitObservation(await observeGitRepository(cwd), operation) === "non-repository") {
+        throw new FlowError("NOT_GIT_REPO", `${cwd} is not a git repository`);
     }
 }
 export async function getCurrentBranch(cwd) {

package/build/git/commits.js

@@ -1,5 +1,8 @@
 import { FlowError } from "../flow-error.js";
 import { createGit, wrapGitError } from "./core.js";
+export function shortCommitHash(hash) {
+    return hash.slice(0, 12);
+}
 export async function resolveCommitRef(cwd, ref) {
     const git = createGit(cwd);
     try {

package/build/git/core.js

@@ -10,6 +10,14 @@ export const MISSING_HEAD_PATTERNS = [
     "unknown revision or path not in the working tree",
     "bad revision 'HEAD'",
 ];
+/** Git is an optional adapter for directory-local product surfaces. */
+export function isGitExecutableUnavailable(error) {
+    const source = (error ?? {});
+    if (source.code === "ENOENT")
+        return true;
+    const message = typeof source.message === "string" ? source.message : String(error);
+    return /spawn\s+git\s+ENOENT|git(?:\.exe)?["']?\s*:\s*(?:not found|no such file)/i.test(message);
+}
 export function compactText(input, maxChars = GIT_ERROR_COMPACT_MAX_CHARS) {
     const text = input.trim();
     if (!text)
@@ -58,5 +66,6 @@ export function createGit(cwd) {
     git.env("GCM_INTERACTIVE", "Never");
     git.env("GIT_MERGE_AUTOEDIT", "no");
     git.env("LC_ALL", "C");
+    git.env("PATH", process.env.PATH ?? "");
     return git;
 }

package/build/git/diff/parsers.js

@@ -1,17 +1,4 @@
-import { Buffer } from "node:buffer";
-const DIFF_GIT_HEADER_PREFIX = "diff --git ";
 const DIFF_TRUNCATED_MARKER = "...[truncated]";
-const GIT_QUOTED_PATH_ESCAPES = {
-    '"': 34,
-    "\\": 92,
-    a: 7,
-    b: 8,
-    f: 12,
-    n: 10,
-    r: 13,
-    t: 9,
-    v: 11,
-};
 export function splitDiffByFile(content) {
     const sections = [];
     let current = [];
@@ -94,87 +81,6 @@ export function isMissingBaseRevisionError(err) {
         text.includes("unknown revision or path not in the working tree") ||
         text.includes("ambiguous argument"));
 }
-function unescapeQuotedDiffPath(value) {
-    const bytes = [];
-    for (let index = 0; index < value.length; index += 1) {
-        const char = value[index];
-        if (char !== "\\") {
-            bytes.push(...Buffer.from(char ?? "", "utf8"));
-            continue;
-        }
-        const escaped = value[index + 1];
-        if (escaped === undefined) {
-            bytes.push(92);
-            continue;
-        }
-        if (escaped >= "0" && escaped <= "7") {
-            let octal = escaped;
-            let cursor = index + 2;
-            while (cursor < value.length && octal.length < 3) {
-                const digit = value[cursor];
-                if (digit === undefined || digit < "0" || digit > "7")
-                    break;
-                octal += digit;
-                cursor += 1;
-            }
-            bytes.push(Number.parseInt(octal, 8));
-            index = cursor - 1;
-            continue;
-        }
-        const decoded = GIT_QUOTED_PATH_ESCAPES[escaped];
-        if (decoded !== undefined) {
-            bytes.push(decoded);
-            index += 1;
-            continue;
-        }
-        bytes.push(...Buffer.from(escaped, "utf8"));
-        index += 1;
-    }
-    return Buffer.from(bytes).toString("utf8");
-}
-function readDiffHeaderToken(line, startIndex) {
-    let index = startIndex;
-    while (index < line.length && line[index] === " ") {
-        index += 1;
-    }
-    if (index >= line.length)
-        return null;
-    if (line[index] !== '"') {
-        let endIndex = index;
-        while (endIndex < line.length && line[endIndex] !== " ") {
-            endIndex += 1;
-        }
-        return {
-            value: line.slice(index, endIndex),
-            nextIndex: endIndex,
-        };
-    }
-    let endIndex = index + 1;
-    let escaped = false;
-    while (endIndex < line.length) {
-        const char = line[endIndex];
-        if (!escaped && char === '"') {
-            return {
-                value: unescapeQuotedDiffPath(line.slice(index + 1, endIndex)),
-                nextIndex: endIndex + 1,
-            };
-        }
-        escaped = !escaped && char === "\\";
-        endIndex += 1;
-    }
-    return null;
-}
-export function parseDiffPathFromHeader(diffGitLine) {
-    if (!diffGitLine.startsWith(DIFF_GIT_HEADER_PREFIX))
-        return null;
-    const aPart = readDiffHeaderToken(diffGitLine, DIFF_GIT_HEADER_PREFIX.length);
-    if (!aPart)
-        return null;
-    const bPart = readDiffHeaderToken(diffGitLine, aPart.nextIndex)?.value ?? "";
-    if (!bPart.startsWith("b/"))
-        return null;
-    return bPart.slice(2);
-}
 export function totalJoinedLength(blocks) {
     if (blocks.length === 0)
         return 0;

package/build/index.js

@@ -6,7 +6,9 @@ import { ENV_KEYS } from "./config/env-keys.js";
 import { logErrorWithCause } from "./telemetry/logger.js";
 import { runProjectionGenerationRuntime } from "./core/projection-generation-runtime.js";
 import { renderCliHelp, runCliCommand } from "./cli/index.js";
+import { installCliOutputStreamErrorPolicy } from "./cli/output-stream-error-policy.js";
 import { assertSubagentCliCommandAllowed } from "./cli/subagent-guard.js";
+installCliOutputStreamErrorPolicy(process.stdout, process.stderr);
 const packageVersion = VERSION;
 function findCliCwd(args) {
     for (let index = 0; index < args.length; index += 1) {

package/build/keiyaku-constants.js

@@ -0,0 +1,2 @@
+export const ACTOR_IDENTITY = "Akuma";
+export const SETTINGS_PATH_SEGMENTS = [".keiyaku", "settings.json"];

package/build/keiyaku.js

@@ -1,4 +1,6 @@
 import * as path from "path";
+import { ACTOR_IDENTITY, SETTINGS_PATH_SEGMENTS } from "./keiyaku-constants.js";
+export { ACTOR_IDENTITY } from "./keiyaku-constants.js";
 export const KEIYAKU_FILE = path.join(".keiyaku", "KEIYAKU.md");
 export const KEIYAKU_DRAFT_DIR = path.join(".keiyaku", "draft");
 export const RESPONSE_HISTORY_DIR = path.join(".keiyaku", "response");
@@ -13,7 +15,6 @@ export const TOOL_NAMES = {
     status: "status",
     help: "help",
 };
-export const ACTOR_IDENTITY = "Akuma";
 export const ACTOR_IDENTITY_PLURAL = `${ACTOR_IDENTITY}s`;
 function formatArtifactDirectory(directory) {
     return `\`${directory}/\``;
@@ -35,7 +36,7 @@ export const DRAFT_ARTIFACT_NOTICE = buildArtifactNotice(KEIYAKU_ARTIFACT_DIRS[0
 export const RESPONSE_ARTIFACT_NOTICE = buildArtifactNotice(KEIYAKU_ARTIFACT_DIRS[1]);
 export const KEIYAKU_BRANCH_PREFIX = "keiyaku/";
 export const BASE_RULES_FILE = path.join(".keiyaku", "base-rules.md");
-export const SETTINGS_FILE = path.join(".keiyaku", "settings.json");
+export const SETTINGS_FILE = path.join(...SETTINGS_PATH_SEGMENTS);
 export const SUBAGENT_PROVIDERS = [
     "codex-sdk",
     "codex-app-server",
@@ -50,7 +51,7 @@ export const CODEX_MODEL_REASONING_EFFORT_CONFIG_KEY = "model_reasoning_effort";
 export const BUILTIN_AGENT_NAMES = ["akuma-codex", "akuma-claude"];
 export const DEFAULT_AGENT_NAME = "akuma-codex";
 export const BUILTIN_AGENT_PROFILES = {
-    "akuma-codex": { provider: "codex-sdk", description: "Default Codex SDK Akuma." },
+    "akuma-codex": { provider: "codex-sdk", description: "Deprecated Codex SDK Akuma; use codex-app-server." },
     "akuma-claude": { provider: "claude-agent-sdk", description: "Default Claude Agent SDK Akuma." },
 };
 export const CLAUDE_PERMISSION_MODES = ["default", "acceptEdits", "bypassPermissions", "plan", "dontAsk", "auto"];