@astrosheep/keiyaku 2.9.2 → 2.9.4

package/build/config/settings/schema.js

@@ -1,185 +1,15 @@
 import { z } from "zod";
-import { CLAUDE_SETTING_SOURCES, } from "../../keiyaku.js";
-const tomlValueSchema = z.lazy(() => z.union([
-    z.string(),
-    z.number(),
-    z.boolean(),
-    z.array(tomlValueSchema),
-    z.record(z.string(), tomlValueSchema),
-]));
-const structuredTomlValueSchema = z.record(z.string(), tomlValueSchema);
-const executableSchema = z.string().superRefine((value, ctx) => {
-    if (value.length === 0 || /\s/.test(value) || value.includes("\"") || value.includes("'")) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: "must be a single program name token with no spaces or quotes.",
-        });
-    }
-});
-const nonblankOptionalString = z
-    .string()
-    .refine((value) => value.trim().length > 0, { message: "must not be blank." })
-    .optional();
-const providerCommonFields = {
-    description: nonblankOptionalString,
-};
-const providerEnvSchema = z.record(z.string(), z.string()).optional();
-function refinePiEnvInjection(data, ctx) {
-    if (data.env === undefined)
-        return;
-    if (Object.keys(data.env).length === 0)
-        return;
-    ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        path: ["env"],
-        message: "env injection not supported for provider pi",
-    });
-}
-const CODEX_SDK_FORBIDDEN_THREAD_OPTIONS_KEYS = [
-    "model",
-    "modelReasoningEffort",
-    "sandboxMode",
-    "networkAccessEnabled",
-    "webSearchMode",
-    "approvalPolicy",
-    "workingDirectory",
-    "skipGitRepoCheck",
-];
-const FORBIDDEN_CONFIG_KEYS = [
-    "model",
-    "model_reasoning_effort",
-];
-function isConfigKeyForbidden(key) {
-    return FORBIDDEN_CONFIG_KEYS.includes(key);
-}
-const claudeSettingSourceSchema = z.enum(CLAUDE_SETTING_SOURCES);
-const writableRootItemSchema = z.string().superRefine((value, ctx) => {
-    if (value.length === 0) {
-        ctx.addIssue({ code: z.ZodIssueCode.custom, message: "must not be empty." });
-        return;
-    }
-    if (value.startsWith("~")) {
-        ctx.addIssue({ code: z.ZodIssueCode.custom, message: "must not begin with tilde." });
-        return;
-    }
-    if (value.includes("\0")) {
-        ctx.addIssue({ code: z.ZodIssueCode.custom, message: "must not contain NUL byte." });
-        return;
-    }
-    if (/\$[A-Za-z_]/.test(value) || /\$\{/.test(value)) {
-        ctx.addIssue({ code: z.ZodIssueCode.custom, message: "must not contain environment variable references." });
-        return;
-    }
-});
-export const providerInstanceSchema = z.discriminatedUnion("kind", [
-    z
-        .object({
-        kind: z.literal("codex-sdk"),
-        ...providerCommonFields,
-        executable: executableSchema.optional(),
-        profile: z.string().optional(),
-        config: structuredTomlValueSchema.optional(),
-        threadOptions: structuredTomlValueSchema.optional(),
-    })
-        .strict()
-        .superRefine((data, ctx) => {
-        if (data.threadOptions) {
-            for (const key of CODEX_SDK_FORBIDDEN_THREAD_OPTIONS_KEYS) {
-                if (key in data.threadOptions) {
-                    ctx.addIssue({
-                        code: z.ZodIssueCode.custom,
-                        path: ["threadOptions", key],
-                        message: `"${key}" is owned by the Akuma or Keiyaku execution, not this provider instance`,
-                    });
-                }
-            }
-        }
-        if (data.config) {
-            for (const key of Object.keys(data.config)) {
-                if (isConfigKeyForbidden(key)) {
-                    ctx.addIssue({
-                        code: z.ZodIssueCode.custom,
-                        path: ["config", key],
-                        message: `"${key}" is owned by the Akuma or Keiyaku execution, not this provider instance`,
-                    });
-                }
-            }
-        }
-    }),
-    z
-        .object({
-        kind: z.literal("codex-app-server"),
-        ...providerCommonFields,
-        executable: executableSchema.optional(),
-        profile: z.string().optional(),
-        config: structuredTomlValueSchema.optional(),
-        writableRoots: z.array(writableRootItemSchema).optional(),
-        env: providerEnvSchema,
-    })
-        .strict()
-        .superRefine((data, ctx) => {
-        if (data.config) {
-            for (const key of Object.keys(data.config)) {
-                if (isConfigKeyForbidden(key)) {
-                    ctx.addIssue({
-                        code: z.ZodIssueCode.custom,
-                        path: ["config", key],
-                        message: `"${key}" is owned by the Akuma or Keiyaku execution, not this provider instance`,
-                    });
-                }
-            }
-        }
-    }),
-    z
-        .object({
-        kind: z.literal("claude-agent-sdk"),
-        ...providerCommonFields,
-        executable: executableSchema.optional(),
-        settingSources: z.array(claudeSettingSourceSchema).optional(),
-        env: providerEnvSchema,
-    })
-        .strict(),
-    z
-        .object({
-        kind: z.literal("opencode-sdk"),
-        ...providerCommonFields,
-        executable: executableSchema.optional(),
-        env: providerEnvSchema,
-    })
-        .strict(),
-    z
-        .object({
-        kind: z.literal("pi"),
-        ...providerCommonFields,
-        env: providerEnvSchema,
-    })
-        .strict()
-        .superRefine(refinePiEnvInjection),
-]);
+import { BUILTIN_PROVIDER_INSTANCE_CANDIDATES as REGISTRY_BUILTIN_PROVIDER_INSTANCE_CANDIDATES, providerInstanceSchema as registryProviderInstanceSchema, } from "../../agents/providers/registry.js";
+export const providerInstanceSchema = registryProviderInstanceSchema;
+export const BUILTIN_PROVIDER_INSTANCE_CANDIDATES = REGISTRY_BUILTIN_PROVIDER_INSTANCE_CANDIDATES;
 const PROVIDER_INSTANCE_NAME_PATTERN = /^[a-z0-9][a-z0-9-]*$/;
 export const providerInstanceNameSchema = z
     .string()
     .max(64, "must contain at most 64 characters.")
     .regex(PROVIDER_INSTANCE_NAME_PATTERN, "must match ^[a-z0-9][a-z0-9-]*$.");
-export const BUILTIN_PROVIDER_INSTANCE_CANDIDATES = {
-    "codex-sdk": { name: "codex-sdk", source: "builtin", instance: { kind: "codex-sdk", executable: "codex" } },
-    "codex-app-server": {
-        name: "codex-app-server",
-        source: "builtin",
-        instance: { kind: "codex-app-server", executable: "codex" },
-    },
-    "claude-agent-sdk": {
-        name: "claude-agent-sdk",
-        source: "builtin",
-        instance: { kind: "claude-agent-sdk", executable: "claude", settingSources: ["project"] },
-    },
-    "opencode-sdk": {
-        name: "opencode-sdk",
-        source: "builtin",
-        instance: { kind: "opencode-sdk", executable: "opencode" },
-    },
-    pi: { name: "pi", source: "builtin", instance: { kind: "pi" } },
-};
+// Ensure the registry builtin map stays keyed by the closed provider vocabulary.
+const _builtinCheck = BUILTIN_PROVIDER_INSTANCE_CANDIDATES;
+void _builtinCheck;
 const AGENT_NAME_PATTERN = /^[a-zA-Z0-9]+(?:[.-][a-zA-Z0-9]+)*$/;
 export const agentNameSchema = z
     .string()

package/build/core/addressing.js

@@ -1,9 +1,13 @@
 import * as path from "node:path";
 import { FlowError } from "../flow-error.js";
+import { errorContainsAnyPattern, NOT_GIT_REPOSITORY_PATTERNS } from "../git/core.js";
+import { commissionSlug, formatCommissionCoordinate } from "./ids.js";
 import { listContractIds, readLedger } from "./ledger.js";
 import { isResponseArtifactId } from "./response-artifact-id.js";
-import { stableRepoRoot } from "./worktree-path.js";
+import { activeContractBoundByEngineWorktree, stableRepoRoot } from "./worktree-path.js";
+import { assertNoRenewRecoverySession } from "./renew-session.js";
 import { deriveContractState, isTerminalState, } from "./status/lifecycle.js";
+const AMBIGUOUS_OBJECTIVE_MAX_CHARS = 60;
 function normalizeAddressQuery(raw) {
     const value = raw.startsWith("@") ? raw.slice(1) : raw;
     if (!value.trim()) {
@@ -17,8 +21,8 @@ class AddressedFlowError extends FlowError {
     constructor(error, carrier) {
         super(error.code, error.message, {
             cause: error,
-            hints: error.hints,
             review: error.review,
+            facts: error.facts,
         });
         this.name = error.name;
         this[ADDRESS_CARRIER] = carrier;
@@ -108,9 +112,8 @@ export class AddressResolutionError extends FlowError {
         this.attempt = attempt;
     }
 }
-function contractSlug(contractId) {
-    const separator = contractId.indexOf(".");
-    return separator > 0 ? contractId.slice(0, separator) : contractId;
+function candidatePlace(candidate) {
+    return candidate.bind.data.workspace === "worktree" ? candidate.bind.data.place ?? null : null;
 }
 async function commissionAddressCandidates(cwd) {
     const ids = await listContractIds(cwd);
@@ -135,9 +138,9 @@ function matchCommissionAddress(query, candidates) {
         const matches = [];
         if (candidate.contractId === query)
             matches.push({ ...candidate, spelling: "id" });
-        if (contractSlug(candidate.contractId) === query)
+        if (commissionSlug(candidate.contractId) === query)
             matches.push({ ...candidate, spelling: "slug" });
-        if (candidate.active && candidate.bind.data.place === query) {
+        if (candidate.active && candidatePlace(candidate) === query) {
             matches.push({ ...candidate, spelling: "place" });
         }
         return matches;
@@ -146,16 +149,28 @@ function matchCommissionAddress(query, candidates) {
 function attemptCandidates(candidates) {
     return candidates.map((candidate) => ({
         commissionId: candidate.contractId,
-        place: candidate.bind.data.place ?? null,
+        place: candidatePlace(candidate),
         name: candidate.bind.data.name,
         objective: candidate.bind.data.objective,
         lifecycle: candidate.lifecycle,
         target: { branch: candidate.bind.data.target },
     }));
 }
-function formatAmbiguousCandidate(query, candidate) {
-    const label = candidate.matchedBy ?? "candidate";
-    return `${label} @${query}: ${candidate.name} · ${candidate.objective} · commission ${candidate.commissionId}`;
+function truncateObjectiveFirstLine(objective) {
+    const firstLine = objective.split(/\r?\n/, 1)[0]?.trim() ?? "";
+    if (firstLine.length <= AMBIGUOUS_OBJECTIVE_MAX_CHARS)
+        return firstLine;
+    return `${firstLine.slice(0, AMBIGUOUS_OBJECTIVE_MAX_CHARS)}…`;
+}
+function formatAmbiguousCandidate(candidate) {
+    const coordinate = formatCommissionCoordinate({
+        commissionId: candidate.commissionId,
+        place: candidate.place,
+    });
+    const objective = truncateObjectiveFirstLine(candidate.objective);
+    return [coordinate, objective || undefined, candidate.commissionId]
+        .filter((part) => part !== undefined)
+        .join(" · ");
 }
 async function resolvedRepository(cwd) {
     return { kind: "repository", stableRoot: await stableRepoRoot(cwd) };
@@ -166,7 +181,7 @@ function buildResolvedAddress(input) {
         workdir: input.workdir,
         binding: { kind: "commission", commissionId: input.candidate.contractId },
         spelling: { asTyped: input.asTyped, source: input.source, matchedBy: input.matchedBy },
-        place: { display: input.candidate.bind.data.place ?? null },
+        place: { display: candidatePlace(input.candidate) },
         lifecycle: input.candidate.lifecycle,
         target: { branch: input.candidate.bind.data.target },
         inference: input.inference,
@@ -188,8 +203,8 @@ export function buildUncommissionedRepositoryAddress(input) {
         inference: input.inference,
     });
 }
-export async function resolveContractAddress(cwd, raw, source = raw?.startsWith("@") ? "at-address" : "explicit-flag") {
-    const workdir = path.resolve(cwd);
+export async function resolveContractAddress(cwd, raw, source = raw?.startsWith("@") ? "at-address" : "explicit-flag", effectiveDirectory = cwd) {
+    const workdir = path.resolve(effectiveDirectory);
     const repo = await resolvedRepository(cwd);
     if (raw !== undefined) {
         const query = normalizeAddressQuery(raw);
@@ -216,7 +231,7 @@ export async function resolveContractAddress(cwd, raw, source = raw?.startsWith(
             candidates: matches.map((candidate) => ({
                 commissionId: candidate.contractId,
                 matchedBy: candidate.spelling,
-                place: candidate.bind.data.place ?? null,
+                place: candidatePlace(candidate),
                 name: candidate.bind.data.name,
                 objective: candidate.bind.data.objective,
                 lifecycle: candidate.lifecycle,
@@ -238,9 +253,34 @@ export async function resolveContractAddress(cwd, raw, source = raw?.startsWith(
         if (matches.length === 0) {
             throw new AddressResolutionError("EMPTY_PARAM", `unknown contract address @${query}`, attempt);
         }
-        throw new AddressResolutionError("CONTRACT_AMBIGUOUS", `contract address @${query} is ambiguous: ${attempt.candidates.map((candidate) => formatAmbiguousCandidate(query, candidate)).join("; ")}; use a full @commission-id`, attempt);
+        throw new AddressResolutionError("CONTRACT_AMBIGUOUS", `@${query} is ambiguous:\n${attempt.candidates.map((candidate) => `  ${formatAmbiguousCandidate(candidate)}`).join("\n")}\nuse a full @commission-id`, attempt);
     }
     const candidates = await commissionAddressCandidates(repo.stableRoot);
+    let boundContractId;
+    try {
+        const effectiveRepo = await stableRepoRoot(workdir);
+        if (effectiveRepo === repo.stableRoot) {
+            boundContractId = await activeContractBoundByEngineWorktree(workdir);
+        }
+    }
+    catch (error) {
+        if (!errorContainsAnyPattern(error, NOT_GIT_REPOSITORY_PATTERNS))
+            throw error;
+    }
+    if (boundContractId) {
+        const candidate = candidates.find((item) => item.active && item.contractId === boundContractId);
+        if (candidate) {
+            return buildResolvedAddress({
+                repo,
+                workdir,
+                candidate,
+                matchedBy: "id",
+                asTyped: `@${candidate.contractId}`,
+                source: "worktree-binding",
+                inference: ["verified active engine worktree binding"],
+            });
+        }
+    }
     const operable = candidates.filter((candidate) => candidate.active);
     const attempt = {
         repo,
@@ -265,3 +305,13 @@ export async function resolveContractAddress(cwd, raw, source = raw?.startsWith(
         ? "no active commission found; pass @place, @slug, full @commission-id, or --contract <addr>"
         : "multiple active commissions found; pass @place, @slug, full @commission-id, or --contract <addr>", attempt);
 }
+export async function resolveExistingContractAddress(cwd, raw, source = raw?.startsWith("@") ? "at-address" : "explicit-flag", effectiveDirectory = cwd) {
+    const address = await resolveContractAddress(cwd, raw, source, effectiveDirectory);
+    try {
+        await assertNoRenewRecoverySession(address.repo.stableRoot, address.binding.commissionId);
+    }
+    catch (error) {
+        throw attachAddressCarrier(error, address);
+    }
+    return address;
+}

package/build/core/amend.js

@@ -1,15 +1,137 @@
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
 import { FlowError } from "../flow-error.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";
+import { activeLedgerRef, appendWithRetry } from "./ledger.js";
+import { refreshContractView } from "./contract-view.js";
 import { deriveContractState, isTerminalState } from "./status/lifecycle.js";
 import { resolveContractAddress, withResolvedAddress } from "./addressing.js";
 import { resolveDefaultBranch } from "./status/drift.js";
-import { assertCleanWorkingTree } from "./arc.js";
-import { normalizeScopePattern } from "./scope.js";
+import { isBlankScopePatternLine, normalizeScopePattern, ScopePatternError } from "./scope.js";
+import { normalizeSectionTitle } from "./markdown/titles.js";
+import { resolveContractDeliveryCwd } from "./worktree-path.js";
+function amendScopeHeading(name) {
+    return `## Scope ${name[0].toUpperCase()}${name.slice(1)}`;
+}
+function sourceLines(markdown) {
+    const lines = [];
+    let start = 0;
+    while (start < markdown.length) {
+        const newline = markdown.indexOf("\n", start);
+        const end = newline === -1 ? markdown.length : newline;
+        const next = newline === -1 ? markdown.length : newline + 1;
+        const raw = markdown.slice(start, end);
+        lines.push({ text: raw.endsWith("\r") ? raw.slice(0, -1) : raw, start, end, next });
+        start = next;
+    }
+    return lines;
+}
+function amendHeading(line) {
+    const match = line.match(/^ {0,3}(#{1,2})(?!#)[ \t]+(.+)$/);
+    if (!match)
+        return null;
+    const level = match[1].length;
+    const title = normalizeSectionTitle(match[2]);
+    if (level !== 2)
+        return { level };
+    if (title === "scope add")
+        return { level, name: "add" };
+    return { level };
+}
+function amendFence(line) {
+    const match = line.match(/^ {0,3}(`{3,}|~{3,})/);
+    if (!match)
+        return null;
+    const marker = match[1];
+    return { delimiter: marker[0], length: marker.length };
+}
+function parseAmendScopeSections(markdown) {
+    const lines = sourceLines(markdown);
+    const sections = {};
+    let active;
+    let fence;
+    let frontMatterEnd = -1;
+    if (lines[0]?.text.trim() === "---") {
+        for (let index = 1; index < lines.length; index += 1) {
+            if (lines[index].text.trim() === "---") {
+                frontMatterEnd = index;
+                break;
+            }
+        }
+    }
+    const finishActive = (end) => {
+        if (!active)
+            return;
+        sections[active.name] = { ...active, end };
+        active = undefined;
+    };
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index];
+        if (index <= frontMatterEnd)
+            continue;
+        const marker = amendFence(line.text);
+        if (fence) {
+            if (marker && marker.delimiter === fence.delimiter && marker.length >= fence.length) {
+                fence = undefined;
+            }
+            continue;
+        }
+        if (marker) {
+            fence = marker;
+            continue;
+        }
+        const heading = amendHeading(line.text);
+        if (!heading)
+            continue;
+        finishActive(line.start);
+        if (!heading.name)
+            continue;
+        if (sections[heading.name]) {
+            throw new FlowError("INVALID_KEIYAKU_DRAFT", `amend input may contain ${amendScopeHeading(heading.name)} at most once`);
+        }
+        active = { name: heading.name, start: line.start, contentStart: line.next };
+    }
+    finishActive(markdown.length);
+    let prose = markdown;
+    for (const section of Object.values(sections).sort((left, right) => right.start - left.start)) {
+        prose = `${prose.slice(0, section.start)}${prose.slice(section.end)}`;
+    }
+    return { sections, prose };
+}
+function scopePatterns(markdown, section) {
+    const patterns = markdown
+        .slice(section.contentStart, section.end)
+        .split(/\r?\n/)
+        .filter((line) => !isBlankScopePatternLine(line))
+        .map((pattern) => {
+        try {
+            // Do not trim() here: gitignore treats trailing `\ ` as a significant space.
+            return normalizeScopePattern(pattern);
+        }
+        catch (error) {
+            if (error instanceof ScopePatternError) {
+                throw new FlowError("INVALID_KEIYAKU_DRAFT", error.message);
+            }
+            throw error;
+        }
+    });
+    if (patterns.length === 0) {
+        throw new FlowError("INVALID_KEIYAKU_DRAFT", `amend input has an empty ${amendScopeHeading(section.name)} section`);
+    }
+    return patterns;
+}
+export function buildAmendInput(markdown, cwd, contractId, contractAddressSource) {
+    const { sections, prose } = parseAmendScopeSections(markdown);
+    const add = sections.add ? scopePatterns(markdown, sections.add) : [];
+    if (!prose.trim()) {
+        throw new FlowError("EMPTY_PARAM", "amendment cannot be empty");
+    }
+    return {
+        cwd,
+        ...(contractId ? { contractId } : {}),
+        ...(contractAddressSource ? { contractAddressSource } : {}),
+        amendment: prose,
+        ...(sections.add ? { scopeDelta: { add } } : {}),
+    };
+}
 function requireAmendment(value) {
     if (!value.trim())
         throw new FlowError("EMPTY_PARAM", "amendment cannot be empty");
@@ -24,13 +146,6 @@ function assertContractOperable(contractId, entries) {
         throw new FlowError("INTERNAL_STATE", `contract ${contractId} is terminal (${state.state})`);
     }
 }
-async function renderUpdatedContract(cwd, contractId) {
-    const ledger = await readLedger(cwd, contractId);
-    if (!ledger) {
-        throw new FlowError("INTERNAL_STATE", `contract ${contractId} active ledger disappeared before render`);
-    }
-    await fs.writeFile(path.join(cwd, KEIYAKU_FILE), renderContractView({ id: contractId, entries: ledger.entries }), "utf8");
-}
 function normalizeScopeDelta(scopeDelta) {
     if (!scopeDelta)
         return undefined;
@@ -43,6 +158,7 @@ function normalizeScopeDelta(scopeDelta) {
 export async function amendContract(input) {
     const amendment = requireAmendment(input.amendment);
     const scopeDelta = normalizeScopeDelta(input.scopeDelta);
+    const renderCwd = input.renderCwd ?? input.cwd;
     const at = new Date(input.nowMs).toISOString();
     const ref = activeLedgerRef(input.contractId);
     let amendmentNumber = 0;
@@ -67,20 +183,21 @@ export async function amendContract(input) {
     if (amendmentNumber === 0) {
         throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} active ledger disappeared during amend`);
     }
-    await renderUpdatedContract(input.cwd, input.contractId);
+    await refreshContractView({ ledgerCwd: input.cwd, renderCwd, contractId: input.contractId });
     return { contractId: input.contractId, amendmentNumber, ledgerHead: result.head };
 }
 export async function amendKeiyaku(input) {
     await requireGitRepository(input.cwd, "amend");
-    const address = await resolveContractAddress(input.cwd, input.contractId, input.contractAddressSource);
+    const address = input.address ?? await resolveContractAddress(input.cwd, input.contractId, input.contractAddressSource);
     return await withResolvedAddress(address, async () => {
         const contractId = address.binding.commissionId;
-        await assertCleanWorkingTree(input.cwd, []);
+        const renderCwd = await resolveContractDeliveryCwd(input.cwd, contractId);
         const amendment = requireAmendment(input.amendment);
-        const currentBranch = await getCurrentBranch(input.cwd);
+        const currentBranch = await getCurrentBranch(renderCwd);
         const baseBranch = (await resolveDefaultBranch(input.cwd))?.branch ?? currentBranch;
         const amended = await amendContract({
             cwd: input.cwd,
+            renderCwd,
             contractId,
             actor: "keiyaku",
             nowMs: Date.now(),