@astrosheep/keiyaku 2.9.6 → 2.9.8

package/build/cli/render/wait.js

@@ -3,6 +3,27 @@ import { displayColumns, resolveLineColumns, truncateColumns } from "./line-widt
 import { formatTellCommand, projectionRejoinHintLines, textResponse } from "./shared.js";
 import { renderTerminalFailureFace } from "./terminal-failure.js";
 const WAIT_HEADER_MAX_COLUMNS = 60;
+const WAIT_BODY_MAX_ROWS = 10;
+const WAIT_ROW_PRIORITY = {
+    "end-anchor": 100,
+    "storage-diagnostic": 90,
+    diagnostic: 90,
+    tell: 80,
+    summary: 70,
+    activity: 60,
+    plan: 55,
+    liveness: 50,
+    silence: 65,
+    file: 20,
+};
+/** One owner admits every wait-body row, then restores presentation order. */
+export function selectWaitBodyRows(rows, limit = WAIT_BODY_MAX_ROWS) {
+    const selected = rows
+        .slice()
+        .sort((left, right) => WAIT_ROW_PRIORITY[right.kind] - WAIT_ROW_PRIORITY[left.kind] || left.order - right.order)
+        .slice(0, limit);
+    return selected.sort((left, right) => left.order - right.order);
+}
 function shortAddress(projectionId) {
     return /\/([0-9a-f]{8})$/.exec(projectionId)?.[1] ?? projectionId;
 }
@@ -26,29 +47,10 @@ function isTerminalPhase(phase) {
     return ["done", "failed", "killed", "dismissed"].includes(phase);
 }
 function waitStateText(snapshot) {
-    switch (snapshot.phase) {
-        case "active":
-        case "quiescent": {
-            const pulse = snapshot.activityAgeMs === undefined ? "unknown" : formatTimelineDuration(snapshot.activityAgeMs);
-            return `pulse ${pulse} · breathing ${formatTimelineDuration(snapshot.durationMs)}`;
-        }
-        case "minting":
-            return `starting · lived ${formatTimelineDuration(snapshot.durationMs)}`;
-        case "startup-timeout":
-            return `startup timed out · lived ${formatTimelineDuration(snapshot.durationMs)}`;
-        case "unknown":
-            return `state unknown · observed ${formatTimelineDuration(snapshot.durationMs)}`;
-        case "done":
-            return `returned · lived ${formatTimelineDuration(snapshot.durationMs)}`;
-        case "failed":
-            return `dead · lived ${formatTimelineDuration(snapshot.durationMs)}`;
-        case "killed":
-            return "killed";
-        case "dismissed":
-            return "dismissed";
-        case "lost":
-            return `no pulse ${snapshot.activityAgeMs === undefined ? "unknown" : formatTimelineDuration(snapshot.activityAgeMs)}`;
-    }
+    const idle = snapshot.activityAgeMs === undefined
+        ? formatTimelineDuration(snapshot.durationMs)
+        : formatTimelineDuration(snapshot.activityAgeMs);
+    return `up ${formatTimelineDuration(snapshot.durationMs)} · idle ${idle}`;
 }
 function projectionIdentityParts(projectionId) {
     const match = /^(.*)\/([0-9a-f]{8})$/.exec(projectionId);
@@ -56,8 +58,7 @@ function projectionIdentityParts(projectionId) {
 }
 function waitHeader(projectionId, akuma, snapshot, outputColumns) {
     const maxColumns = Math.min(WAIT_HEADER_MAX_COLUMNS, outputColumns);
-    const tellSuffix = snapshot.tellsWaiting > 0 ? ` · ${snapshot.tellsWaiting} tells waiting` : "";
-    const state = `${waitStateText(snapshot)}${tellSuffix}`;
+    const state = waitStateText(snapshot);
     const identity = projectionIdentityParts(projectionId);
     // Slug often mirrors the Akuma name; print once when they are the same fact.
     const description = identity.slug && akuma && identity.slug === akuma
@@ -69,6 +70,14 @@ function waitHeader(projectionId, akuma, snapshot, outputColumns) {
     const dashCount = Math.max(1, maxColumns - displayColumns(`${prefix}  ${state}`));
     return `${prefix} ${"─".repeat(dashCount)} ${state}`;
 }
+function pendingTellLines(snapshot, maxColumns) {
+    return snapshot.tells.window.map((tell) => {
+        const age = Math.max(0, snapshot.observedAtMs - Date.parse(tell.createdAt));
+        const fixed = `${"".padStart(5)}│ ${"tell".padEnd(7)} `;
+        const suffix = ` · undelivered ${formatTimelineDuration(Number.isFinite(age) ? age : 0)}`;
+        return `${fixed}${truncateColumns(`“${tell.text}”`, Math.max(0, maxColumns - displayColumns(fixed) - displayColumns(suffix)))}${suffix}`;
+    });
+}
 function ledgerHint(projectionId, snapshot) {
     const file = snapshot.eventLedgerFile ?? "events.jsonl";
     return `· ledger: .keiyaku/projection/${projectionId}/${file}`;
@@ -136,7 +145,11 @@ function unknownResponse(projectionId, akuma, snapshot, maxColumns) {
         ...(snapshot.workspaceRoot ? { workspaceRoot: snapshot.workspaceRoot } : {}),
         maxColumns,
     });
-    const historicalLines = rendered.lines.map((line) => line.replace(/[┆├]/, "│"));
+    const historicalLines = selectWaitBodyRows(rendered.lines.map((line, index) => ({
+        kind: rendered.rowKinds[index] ?? "activity",
+        line,
+        order: index,
+    }))).map((row) => row.line.replace(/[┆├]/, "│"));
     return {
         ...textResponse([
             `? ${akuma} · projection: ${projectionId} · unknown`,
@@ -186,7 +199,7 @@ export function buildWaitResponse(projectionId, result, options = {}) {
         && (result.terminalSnapshot || isTerminalPhase(result.snapshot.phase))
         ? { ...result.snapshot, phase: "active" }
         : result.snapshot;
-    const maxColumns = options.maxColumns ?? resolveLineColumns();
+    const maxColumns = Math.min(120, options.maxColumns ?? resolveLineColumns());
     if (result.state === "terminal" && result.verdict.state === "killed") {
         return {
             ...textResponse(`× killed ${projectionId}`),
@@ -203,6 +216,14 @@ export function buildWaitResponse(projectionId, result, options = {}) {
     if (state === "returned") {
         return returnedResponse(projectionId, result);
     }
+    const tells = pendingTellLines(snapshot, maxColumns);
+    const summary = ["running", "stalled", "unknown"].includes(state)
+        ? renderProjectionActivitySummary(snapshot.activity, {
+            state,
+            ...(snapshot.workspaceRoot ? { workspaceRoot: snapshot.workspaceRoot } : {}),
+            maxColumns,
+        })
+        : undefined;
     const rendered = renderProjectionActivity(snapshot.activity, {
         anchorMs: snapshot.observedAtMs,
         state,
@@ -210,28 +231,27 @@ export function buildWaitResponse(projectionId, result, options = {}) {
         ...(snapshot.workspaceRoot ? { workspaceRoot: snapshot.workspaceRoot } : {}),
         maxColumns,
     });
-    const storageDiagnostics = (snapshot.eventDiagnostics ?? []).map((diagnostic) => `‼ ${diagnostic.kind} · ${diagnostic.detail}`);
-    const lines = [
-        waitHeader(projectionId, result.pact.akuma, snapshot, maxColumns),
-        ...storageDiagnostics,
-        ...rendered.lines,
-    ]
-        .map((line) => truncateColumns(line, maxColumns));
-    if (rendered.lines.length === 0 && state === "running") {
-        lines.push("   not a word out of it yet — pulse is steady");
+    let order = 0;
+    const bodyPlan = [];
+    for (const diagnostic of snapshot.eventDiagnostics ?? []) {
+        bodyPlan.push({ kind: "storage-diagnostic", line: `‼ ${diagnostic.kind} · ${diagnostic.detail}`, order: order++ });
     }
-    // Live/timeout observation faces keep the bounded activity window and add the
-    // existing compact rollup after those rows. Terminal faces already own end└
-    // and must not duplicate it; returned response-only faces never reach here.
-    if (!rendered.hasEndAnchor) {
-        const summary = renderProjectionActivitySummary(snapshot.activity, {
-            state,
-            ...(snapshot.workspaceRoot ? { workspaceRoot: snapshot.workspaceRoot } : {}),
-            maxColumns,
-        });
-        if (summary) {
-            lines.push(summary);
-        }
+    rendered.lines.forEach((line, index) => {
+        bodyPlan.push({ kind: rendered.rowKinds[index] ?? "activity", line, order: order++ });
+    });
+    for (const line of tells)
+        bodyPlan.push({ kind: "tell", line, order: order++ });
+    if (rendered.lines.length === 0 && tells.length === 0 && state === "running") {
+        bodyPlan.push({ kind: "liveness", line: "   not a word out of it yet — idle", order: order++ });
+    }
+    if (!rendered.hasEndAnchor && summary) {
+        bodyPlan.push({ kind: "summary", line: summary, order: order++ });
+    }
+    const bodyLines = selectWaitBodyRows(bodyPlan).map((row) => truncateColumns(row.line, maxColumns));
+    const lines = [waitHeader(projectionId, result.pact.akuma, snapshot, maxColumns), ...bodyLines];
+    const pendingTellCount = snapshot.tells.totals.undelivered;
+    if (pendingTellCount > 0) {
+        lines.push(`${pendingTellCount} tell${pendingTellCount === 1 ? "" : "s"} undelivered`);
     }
     const nextActions = state === "running" && options.runningActions === false
         ? []

package/build/cli/subagent-guard.js

@@ -11,6 +11,9 @@ function isSubagentSafeCommand(args) {
         const subcommand = args[1];
         return subcommand === "list" || subcommand === "show" || SUBAGENT_SAFE_FLAGS.has(subcommand ?? "");
     }
+    if (head === "task") {
+        return args[1] === "log" || SUBAGENT_SAFE_FLAGS.has(args[1] ?? "");
+    }
     return ((head !== undefined && SUBAGENT_SAFE_COMMANDS.has(head)) ||
         (args.length === 1 && head !== undefined && SUBAGENT_SAFE_FLAGS.has(head)));
 }

package/build/cli/types.js

@@ -1 +1 @@
-export const TASK_SUBCOMMANDS = ["add", "show", "ls", "start", "stop", "done", "drop", "update", "doctor"];
+export const TASK_SUBCOMMANDS = ["add", "show", "ls", "log", "start", "stop", "done", "drop", "update", "doctor"];

package/build/config/settings/disease.js

@@ -1,11 +1,10 @@
 import { FlowError } from "../../flow-error.js";
-import { SETTINGS_FILE } from "../../keiyaku.js";
 export function findSettingsDiseasesForKnob(diseases, knob) {
-    return diseases.filter((disease) => disease.knob === knob);
+    return diseases.filter((disease) => disease.knob === knob || disease.knob === undefined);
 }
 export function formatSettingsDiseases(diseases) {
     return diseases.map((disease) => {
-        const where = disease.knob ? `${disease.source}:${disease.knob}` : `${disease.source}:(root)`;
+        const where = disease.knob ? `${disease.coordinate}:${disease.knob}` : `${disease.coordinate}:(root)`;
         return `${where}: ${disease.reason}`;
     });
 }
@@ -20,11 +19,12 @@ export function assertSettingsKnobUsable(loaded, knob) {
     const hits = findSettingsDiseasesForKnob(loaded.diseases, knob);
     if (hits.length === 0)
         return;
-    throw new FlowError("INVALID_SETTINGS", `Invalid settings in ${SETTINGS_FILE} (diseased knob '${knob}').`, {
+    throw new FlowError("INVALID_SETTINGS", `Invalid settings for diseased knob '${knob}'.`, {
         facts: {
             kind: "invalid_settings",
             diseases: hits.map((disease) => ({
                 source: disease.source,
+                coordinate: disease.coordinate,
                 ...(disease.knob !== undefined ? { knob: disease.knob } : {}),
                 reason: disease.reason,
             })),

package/build/config/settings/loader.js

@@ -58,11 +58,11 @@ function formatProviderInstanceIssues(name, error) {
     })
         .join("; ");
 }
-function collectProviderCandidates(source, rawProviders) {
+function collectProviderCandidates(settingsSource, providerSource, rawProviders) {
     if (!isPlainObject(rawProviders)) {
         return {
             candidates: [],
-            disease: { source: source === "project" ? "local" : "global", knob: "providers", reason: "providers: must be a JSON object" },
+            disease: { ...settingsSource, knob: "providers", reason: "providers: must be a JSON object" },
         };
     }
     const candidates = [];
@@ -71,7 +71,8 @@ function collectProviderCandidates(source, rawProviders) {
         if (!nameResult.success) {
             candidates.push({
                 name,
-                source,
+                source: providerSource,
+                coordinate: settingsSource.coordinate,
                 reason: formatProviderInstanceIssues(name, nameResult.error),
             });
             continue;
@@ -80,7 +81,8 @@ function collectProviderCandidates(source, rawProviders) {
         if (!instanceResult.success) {
             candidates.push({
                 name,
-                source,
+                source: providerSource,
+                coordinate: settingsSource.coordinate,
                 reason: formatProviderInstanceIssues(name, instanceResult.error),
             });
             continue;
@@ -93,7 +95,7 @@ function collectProviderCandidates(source, rawProviders) {
             "writableRoots" in instance
             ? instance.writableRoots
             : undefined;
-        if (writableRoots !== undefined && source === "global") {
+        if (writableRoots !== undefined && providerSource === "global") {
             let relativeIndex;
             for (let i = 0; i < writableRoots.length; i++) {
                 if (!path.posix.isAbsolute(writableRoots[i])) {
@@ -104,13 +106,14 @@ function collectProviderCandidates(source, rawProviders) {
             if (relativeIndex !== undefined) {
                 candidates.push({
                     name,
-                    source,
+                    source: providerSource,
+                    coordinate: settingsSource.coordinate,
                     reason: `providers.${name}.writableRoots.${relativeIndex}: writableRoots item must be an absolute path for global provider instances`,
                 });
                 continue;
             }
         }
-        candidates.push({ name, source, instance: instanceResult.data });
+        candidates.push({ name, source: providerSource, coordinate: settingsSource.coordinate, instance: instanceResult.data });
     }
     return { candidates };
 }
@@ -126,21 +129,23 @@ function mergeProviderCandidates(catalog, candidates) {
     }
     return { selected, shadows };
 }
-function collectSourceDiseases(source, providerSource, read) {
+function collectSourceDiseases(settingsSource, providerSource, read) {
     if (!read.found) {
-        return { partial: {}, diseases: [], providerCandidates: [] };
+        return { settingsSource, partial: {}, diseases: [], providerCandidates: [] };
     }
     if (read.parseError !== undefined) {
         return {
+            settingsSource,
             partial: {},
-            diseases: [{ source, reason: `settings root is unreadable (${read.parseError})` }],
+            diseases: [{ ...settingsSource, reason: `settings root is unreadable (${read.parseError})` }],
             providerCandidates: [],
         };
     }
     if (!isPlainObject(read.raw)) {
         return {
+            settingsSource,
             partial: {},
-            diseases: [{ source, reason: "settings root must be a JSON object" }],
+            diseases: [{ ...settingsSource, reason: "settings root must be a JSON object" }],
             providerCandidates: [],
         };
     }
@@ -151,7 +156,7 @@ function collectSourceDiseases(source, providerSource, read) {
     for (const key of Object.keys(raw)) {
         if (!KNOWN_SETTINGS_ROOT_KEYS.includes(key)) {
             diseases.push({
-                source,
+                ...settingsSource,
                 knob: key,
                 reason: key === "agents"
                     ? 'settings key "agents" has been removed; define profiles in .keiyaku/akuma/<name>.md'
@@ -160,7 +165,7 @@ function collectSourceDiseases(source, providerSource, read) {
         }
     }
     if ("providers" in raw) {
-        const collectedProviders = collectProviderCandidates(providerSource, raw.providers);
+        const collectedProviders = collectProviderCandidates(settingsSource, providerSource, raw.providers);
         providerCandidates = collectedProviders.candidates;
         if (collectedProviders.disease !== undefined)
             diseases.push(collectedProviders.disease);
@@ -170,9 +175,9 @@ function collectSourceDiseases(source, providerSource, read) {
             continue;
         // worktreeBootstrap is project-layer only. Global/user presence is a named
         // disease and never contributes execution authority.
-        if (knob === "worktreeBootstrap" && source === "global") {
+        if (knob === "worktreeBootstrap" && settingsSource.source === "global") {
             diseases.push({
-                source,
+                ...settingsSource,
                 knob,
                 reason: "worktreeBootstrap is project-only and never supplies a value from global settings",
             });
@@ -182,7 +187,7 @@ function collectSourceDiseases(source, providerSource, read) {
         const result = schema.safeParse(raw[knob]);
         if (!result.success) {
             diseases.push({
-                source,
+                ...settingsSource,
                 knob,
                 reason: formatZodIssues(result.error),
             });
@@ -192,7 +197,7 @@ function collectSourceDiseases(source, providerSource, read) {
             continue;
         partial[knob] = result.data;
     }
-    return { partial, diseases, providerCandidates };
+    return { settingsSource, partial, diseases, providerCandidates };
 }
 function mergeSettingsKnobs(base, override) {
     // worktreeBootstrap is whole-value project authority; never field-merge it.
@@ -217,9 +222,21 @@ function mergeSettingsKnobs(base, override) {
         merged.worktreeBootstrap = bootstrap;
     return merged;
 }
+function collectKnobSources(global, local) {
+    const sources = {};
+    for (const knob of KNOWN_SETTINGS_KNOBS) {
+        if (global.partial[knob] !== undefined)
+            sources[knob] = global.settingsSource;
+        if (local.partial[knob] !== undefined)
+            sources[knob] = local.settingsSource;
+    }
+    return sources;
+}
 export async function loadKeiyakuSettings(cwd) {
     const localSettingsPath = path.join(cwd, SETTINGS_FILE);
     const globalSettingsPath = path.join(getKeiyakuHome(), path.basename(SETTINGS_FILE));
+    const globalSource = { source: "global", coordinate: globalSettingsPath };
+    const localSource = { source: "local", coordinate: localSettingsPath };
     let globalRead;
     let localRead;
     try {
@@ -233,12 +250,13 @@ export async function loadKeiyakuSettings(cwd) {
         const reason = error instanceof Error ? error.message : String(error);
         return {
             knobs: null,
-            diseases: [{ source: "local", reason: `settings root is unreadable (${reason})` }],
+            diseases: [{ ...localSource, reason: `settings root is unreadable (${reason})` }],
+            knobSources: {},
             providerInstances: builtinProviderInstanceCatalog(),
         };
     }
-    const globalCollected = collectSourceDiseases("global", "global", globalRead);
-    const localCollected = collectSourceDiseases("local", "project", localRead);
+    const globalCollected = collectSourceDiseases(globalSource, "global", globalRead);
+    const localCollected = collectSourceDiseases(localSource, "project", localRead);
     const diseases = [...globalCollected.diseases, ...localCollected.diseases];
     let providerInstances = builtinProviderInstanceCatalog();
     providerInstances = mergeProviderCandidates(providerInstances, globalCollected.providerCandidates);
@@ -248,5 +266,10 @@ export async function loadKeiyakuSettings(cwd) {
         knobs = mergeSettingsKnobs(globalCollected.partial, localCollected.partial);
     }
     // Empty object still means "settings files were present"; callers treat null as absent files.
-    return { knobs, diseases, providerInstances };
+    return {
+        knobs,
+        diseases,
+        knobSources: collectKnobSources(globalCollected, localCollected),
+        providerInstances,
+    };
 }

package/build/core/addressing.js

@@ -1,8 +1,8 @@
 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 { commissionSlug, formatCommissionCoordinate, isCommissionId } from "./ids.js";
+import { readAllLedgerSnapshots, readLedgerSnapshot } from "./ledger-batch.js";
 import { isResponseArtifactId } from "./response-artifact-id.js";
 import { activeContractBoundByEngineWorktree, stableRepoRoot } from "./worktree-path.js";
 import { assertNoRenewRecoverySession } from "./renew-session.js";
@@ -115,12 +115,8 @@ export class AddressResolutionError extends FlowError {
 function candidatePlace(candidate) {
     return candidate.bind.data.workspace === "worktree" ? candidate.bind.data.place ?? null : null;
 }
-async function commissionAddressCandidates(cwd) {
-    const ids = await listContractIds(cwd);
-    const ledgers = await Promise.all(ids.map(async (contractId) => readLedger(cwd, contractId)));
+function commissionAddressCandidatesFromLedgers(ledgers) {
     return ledgers.flatMap((ledger) => {
-        if (!ledger)
-            return [];
         const bind = ledger.entries.find((entry) => entry.kind === "bind");
         if (!bind || bind.contract !== ledger.contractId)
             return [];
@@ -133,6 +129,17 @@ async function commissionAddressCandidates(cwd) {
             }];
     });
 }
+async function commissionAddressCandidates(cwd, exactContractId) {
+    if (exactContractId) {
+        const ledger = await readLedgerSnapshot(cwd, exactContractId);
+        return ledger ? commissionAddressCandidatesFromLedgers([ledger]) : [];
+    }
+    const reads = await readAllLedgerSnapshots(cwd);
+    const failed = reads.find((read) => "error" in read);
+    if (failed && "error" in failed)
+        throw failed.error;
+    return commissionAddressCandidatesFromLedgers(reads.filter((read) => !("error" in read)));
+}
 function matchCommissionAddress(query, candidates) {
     return candidates.flatMap((candidate) => {
         const matches = [];
@@ -221,7 +228,7 @@ export async function resolveContractAddress(cwd, raw, source = raw?.startsWith(
                 actual: "artifact",
             });
         }
-        const candidates = await commissionAddressCandidates(repo.stableRoot);
+        const candidates = await commissionAddressCandidates(repo.stableRoot, isCommissionId(query) ? query : undefined);
         const matches = matchCommissionAddress(query, candidates);
         const attempt = {
             repo,
@@ -260,7 +267,7 @@ export async function resolveContractAddress(cwd, raw, source = raw?.startsWith(
     try {
         const effectiveRepo = await stableRepoRoot(workdir);
         if (effectiveRepo === repo.stableRoot) {
-            boundContractId = await activeContractBoundByEngineWorktree(workdir);
+            boundContractId = await activeContractBoundByEngineWorktree(workdir, effectiveRepo);
         }
     }
     catch (error) {
@@ -305,6 +312,30 @@ 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);
 }
+/**
+ * `call` may inherit only the active commission proven by the selected
+ * engine-owned worktree. Unlike existing-contract resolution, this never
+ * considers sole-active cardinality.
+ */
+export async function resolveCallWorktreeAddress(cwd, effectiveDirectory = cwd) {
+    const repo = await resolvedRepository(cwd);
+    const workdir = path.resolve(effectiveDirectory);
+    let contractId;
+    try {
+        const effectiveRepo = await stableRepoRoot(workdir);
+        if (effectiveRepo !== repo.stableRoot)
+            return undefined;
+        contractId = await activeContractBoundByEngineWorktree(workdir, effectiveRepo);
+    }
+    catch (error) {
+        if (!errorContainsAnyPattern(error, NOT_GIT_REPOSITORY_PATTERNS))
+            throw error;
+        return undefined;
+    }
+    if (!contractId)
+        return undefined;
+    return await resolveContractAddress(repo.stableRoot, contractId, "worktree-binding", workdir);
+}
 export async function resolveExistingContractAddress(cwd, raw, source = raw?.startsWith("@") ? "at-address" : "explicit-flag", effectiveDirectory = cwd) {
     const address = await resolveContractAddress(cwd, raw, source, effectiveDirectory);
     try {

package/build/core/amend.js

@@ -5,7 +5,7 @@ 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 { markdownSourceSections, normalizeScopePattern, validateScopeFragmentLines } from "./scope.js";
+import { markdownSourceSections, normalizeScopePattern, ScopePatternError, validateScopeFragmentLines } from "./scope.js";
 import { normalizeSectionTitle } from "./markdown/titles.js";
 import { resolveContractDeliveryCwd } from "./worktree-path.js";
 function amendScopeHeading(name) {
@@ -44,9 +44,25 @@ function scopePatterns(markdown, section) {
         emptyMessage: `amend input has an empty ${amendScopeHeading(section.name)} section`,
     });
 }
-export function buildAmendInput(markdown, cwd, contractId, contractAddressSource) {
+function normalizeAmendScopePatterns(patterns) {
+    try {
+        return patterns.map((pattern) => normalizeScopePattern(pattern));
+    }
+    catch (error) {
+        if (error instanceof ScopePatternError) {
+            throw new FlowError("INVALID_KEIYAKU_DRAFT", error.message);
+        }
+        throw error;
+    }
+}
+export function buildAmendInput(markdown, cwd, contractId, contractAddressSource, appendScope) {
     const { sections, prose } = parseAmendScopeSections(markdown);
-    const append = sections.append ? scopePatterns(markdown, sections.append) : [];
+    if (sections.append && appendScope && appendScope.length > 0) {
+        throw new FlowError("INVALID_KEIYAKU_DRAFT", "amend input may use either --append-scope or ## Scope Append, not both");
+    }
+    const append = sections.append
+        ? scopePatterns(markdown, sections.append)
+        : normalizeAmendScopePatterns(appendScope ?? []);
     if (!prose.trim()) {
         throw new FlowError("EMPTY_PARAM", "amendment cannot be empty");
     }
@@ -55,7 +71,7 @@ export function buildAmendInput(markdown, cwd, contractId, contractAddressSource
         ...(contractId ? { contractId } : {}),
         ...(contractAddressSource ? { contractAddressSource } : {}),
         amendment: prose,
-        ...(sections.append ? { scopeDelta: { add: append } } : {}),
+        ...(append.length > 0 ? { scopeDelta: { add: append } } : {}),
     };
 }
 function requireAmendment(value) {
@@ -76,7 +92,7 @@ function normalizeScopeDelta(scopeDelta) {
     if (!scopeDelta)
         return undefined;
     // Scope patterns are gitignore text; do not requireText/trim, or escaped trailing spaces die.
-    const add = scopeDelta.add.map((pattern) => normalizeScopePattern(pattern));
+    const add = normalizeAmendScopePatterns(scopeDelta.add);
     if (add.length === 0)
         return undefined;
     return { add };