@astrosheep/keiyaku 2.9.4 → 2.9.5

package/build/cli/render/status.js

@@ -25,6 +25,7 @@ function projectionGlyph(state) {
         case "startup-timeout":
             return "!";
         case "unknown":
+        case "incompatible":
             return "?";
     }
 }
@@ -44,9 +45,9 @@ function renderTaskStatusSection(tasks) {
         tasks.blocked > 0 ? `${tasks.blocked} blocked` : undefined,
     ].filter((segment) => segment !== undefined);
     const lines = [`tasks · ${segments.join(" / ")}`];
-    lines.push(...tasks.topTasks.map((task) => `  ${task.id} · P${task.pri} · ${task.state === "in_progress" ? "in_progress" : "ready"} · ${task.title}`));
+    lines.push(...tasks.topTasks.map((task) => `  ${task.id} · P${task.pri} · ${task.state === "in_progress" ? "in_progress" : "ready"} · age ${formatAgeMs(task.ageMs)} · active ${formatAgeMs(task.activityAgeMs)} · ${task.title}`));
     if (tasks.omitted > 0) {
-        lines.push(`  · +${tasks.omitted} more · shown in_progress then ready; each by priority, created, id`);
+        lines.push(`  · +${tasks.omitted} more — keiyaku task ls`);
     }
     return `${lines.join("\n")}\n`;
 }
@@ -68,30 +69,34 @@ function terminalFailureSuffix(row) {
 function renderProjectionOmission(board) {
     if (!board.omitted)
         return undefined;
-    const counts = ["failed", "dead", "done", "killed", "dismissed"]
+    const counts = ["failed", "dead", "done", "killed", "dismissed", "incompatible"]
         .flatMap((state) => {
         const count = board.omitted?.byState[state] ?? 0;
         return count > 0 ? [`${count} ${state}`] : [];
     });
-    return `  · +${board.omitted.total} not shown (${counts.join(" · ")}) — keiyaku status --all`;
+    return `  · +${board.omitted.total} historical projections not shown (${counts.join(" · ")}) — keiyaku status --all`;
 }
 function renderProjectionAge(row) {
-    const age = formatAgeMs(row.activityAgeMs);
+    const duration = formatAgeMs(row.durationMs) ?? "?";
+    const activity = formatAgeMs(row.activityAgeMs) ?? "?";
+    const facts = `dur ${duration} · active ${activity}`;
     if (row.state === "done")
-        return age ? `done ${age}` : "done";
+        return `done · ${facts}`;
     if (row.state === "killed")
-        return age ? `killed ${age}` : "killed";
+        return `killed · ${facts}`;
     if (row.state === "dismissed")
-        return age ? `dismissed ${age}` : "dismissed";
+        return `dismissed · ${facts}`;
     if (row.state === "failed")
-        return age ? `failed ${age}` : "failed";
+        return `failed · ${facts}`;
     if (row.state === "dead")
-        return age ? `dead ${age}` : "dead";
+        return `dead · ${facts}`;
     if (row.state === "startup-timeout")
-        return "startup timed out";
+        return `startup timed out · ${facts}`;
     if (row.state === "unknown")
-        return "unknown";
-    return formatAgeMs(row.activityAgeMs) ?? "";
+        return `unknown · ${facts}`;
+    if (row.state === "incompatible")
+        return "incompatible history";
+    return facts;
 }
 function renderProjectionTellCounts(row) {
     const { inbox, inflight, submitted, consumed } = row.tellCounts;
@@ -111,10 +116,11 @@ function projectionActivityState(row) {
         case "out": return "running";
         case "startup-timeout": return "stalled";
         case "unknown": return "unknown";
+        case "incompatible": return "unknown";
     }
 }
 function renderProjectionActivityLine(row) {
-    if (row.state === "startup-timeout" || row.state === "unknown")
+    if (row.state === "startup-timeout" || row.state === "unknown" || row.state === "incompatible")
         return undefined;
     if (!row.activity)
         return undefined;
@@ -133,15 +139,15 @@ function renderProjectionRow(row) {
                 : row.state);
     const identity = row.alias ? `${row.id} (${row.alias})` : row.id;
     let heading;
-    if (row.state === "startup-timeout" || row.state === "unknown") {
+    if (row.state === "startup-timeout" || row.state === "unknown" || row.state === "incompatible") {
         const akuma = (row.akuma ?? "(unknown)").padEnd(18);
         heading = `  ${glyph} ${identity}    ${akuma} ${renderProjectionAge(row)}${terminalFailureSuffix(row)}${renderProjectionDiagnostics(row)}`.trimEnd();
     }
     else if (row.state === "minting") {
-        heading = `  ${glyph} ${identity.padEnd(18)} (minting)${terminalFailureSuffix(row)}${renderProjectionDiagnostics(row)}`.trimEnd();
+        heading = `  ${glyph} ${identity.padEnd(18)} (minting) · ${renderProjectionAge(row)}${terminalFailureSuffix(row)}${renderProjectionDiagnostics(row)}`.trimEnd();
     }
     else {
-        const age = renderProjectionAge(row).padEnd(9);
+        const age = renderProjectionAge(row);
         const akuma = (row.akuma ?? "(unknown)").padEnd(18);
         heading = `  ${glyph} ${identity}    ${akuma} ${age}${renderProjectionTellCounts(row)}${terminalFailureSuffix(row)}${renderProjectionDiagnostics(row)}`.trimEnd();
     }
@@ -154,7 +160,8 @@ function isTerminalProjectionStatus(row) {
         || row.state === "killed"
         || row.state === "dismissed"
         || row.state === "failed"
-        || row.state === "dead";
+        || row.state === "dead"
+        || row.state === "incompatible";
 }
 export function renderProjectionFilteredStatus(board, projectionId) {
     const head = board.defaultHead ? shortCommitHash(board.defaultHead) : "(no HEAD)";
@@ -167,6 +174,9 @@ export function renderProjectionFilteredStatus(board, projectionId) {
         return renderTerminalFailureFace(projectionId, row.terminalFailure).join("\n");
     }
     const lines = [heading, "", ...renderProjectionRow(row), ""];
+    if (row.observation.compatibility === "incompatible") {
+        return `${lines.join("\n")}\n`;
+    }
     if (!isTerminalProjectionStatus(row))
         lines.push(`» ${formatTellCommand(projectionId, '"..."')}`);
     lines.push(`» keiyaku wait ${projectionId}`);

package/build/cli/render/success-response.js

@@ -1,4 +1,5 @@
 import { repositoryCoordinateFromAddress } from "../commands/shared.js";
+import { writeCliOutput } from "../output-stream-error-policy.js";
 import { renderResolvedAddressReceipt } from "./address.js";
 import { formatCallNextAction } from "./shared.js";
 function responseText(response) {
@@ -54,24 +55,24 @@ function conversationalFooter(response) {
     }
     return lines.join("\n");
 }
-export function writeSuccessResponse(command, flags, response) {
+export async function writeSuccessResponse(command, flags, response) {
     // Plain tell is always silent; tell --wait owns the ordinary wait response.
     if (command === "tell" && flags.timeoutMs === undefined)
         return;
     if (command === "bind" && flags.dryRun) {
         // Canonical Markdown already ends with exactly one newline.
-        process.stdout.write(responseText(response));
+        await writeCliOutput(process.stdout, responseText(response));
         return;
     }
     if (command !== "revive") {
-        process.stdout.write(`${responseText(response)}\n`);
+        await writeCliOutput(process.stdout, `${responseText(response)}\n`);
         return;
     }
     const data = responseData(response);
     const answer = typeof data.summary === "string" ? data.summary.trim() : responseText(response).trim();
     const footer = conversationalFooter(response);
-    process.stdout.write(`${answer}\n`);
+    await writeCliOutput(process.stdout, `${answer}\n`);
     if (footer) {
-        process.stderr.write(`${footer}\n`);
+        await writeCliOutput(process.stderr, `${footer}\n`);
     }
 }

package/build/cli/render/task.js

@@ -1,17 +1,11 @@
 import { commissionSlug } from "../../core/ids.js";
+import { deriveTaskDisplay as deriveStructuredTaskDisplay, selectTaskList, } from "../../core/task/index.js";
 export function shortContractId(contractId) {
     return commissionSlug(contractId);
 }
 export function deriveTaskDisplay(task) {
-    if (task.state === "done")
-        return "done";
-    if (task.state === "drop")
-        return "dropped";
-    if (task.contractId !== undefined)
-        return `bound(${shortContractId(task.contractId)})`;
-    if (task.state === "in_progress")
-        return "in_progress";
-    return task.blocked ? "blocked" : "ready";
+    const display = deriveStructuredTaskDisplay(task);
+    return display === "bound" ? `bound(${shortContractId(task.contractId)})` : display;
 }
 function renderTaskRowWithId(task, id) {
     return `${id} · P${task.pri} · ${deriveTaskDisplay(task)} · ${task.title}`;
@@ -25,43 +19,14 @@ export function renderTaskMutationRow(task) {
 export function renderTaskRow(task, completeId = false) {
     return completeId ? renderTaskMutationRow(task) : renderTaskListRow(task);
 }
-function displayOrder(display) {
-    if (display === "in_progress")
-        return 0;
-    if (display === "ready")
-        return 1;
-    if (display === "blocked")
-        return 2;
-    if (display.startsWith("bound("))
-        return 3;
-    return display === "done" ? 4 : 5;
-}
-function compareText(left, right) {
-    return left < right ? -1 : left > right ? 1 : 0;
-}
-function compareTasks(left, right) {
-    const displayDifference = displayOrder(deriveTaskDisplay(left)) - displayOrder(deriveTaskDisplay(right));
-    if (displayDifference !== 0)
-        return displayDifference;
-    if (left.pri !== right.pri)
-        return left.pri - right.pri;
-    const createdDifference = compareText(left.createdAt, right.createdAt);
-    return createdDifference || compareText(left.id, right.id);
-}
-function selected(task, selection) {
-    const display = deriveTaskDisplay(task);
-    const terminal = display === "done" || display === "dropped";
-    if (selection === "done")
-        return terminal;
-    if (selection === "default")
-        return !terminal;
-    return true;
-}
 export function groupAndSortTasks(tasks, selection = "default") {
-    return tasks.filter((task) => selected(task, selection)).sort(compareTasks);
+    return selectTaskList(tasks, { selection });
 }
 export function renderTaskList(tasks, options = {}) {
-    return groupAndSortTasks(tasks, options.selection).map(renderTaskListRow).join("\n");
+    return selectTaskList(tasks, options).map(renderTaskListRow).join("\n");
+}
+export function renderSelectedTaskList(tasks) {
+    return tasks.map(renderTaskListRow).join("\n");
 }
 function renderIds(ids) {
     return ids.length === 0 ? "(none)" : ids.join(", ");
@@ -128,6 +93,7 @@ export function taskJson(task) {
         from: [...task.from],
         contractId: task.contractId ?? null,
         createdAt: task.createdAt,
+        updatedAt: task.updatedAt ?? task.createdAt,
         creator: task.creator,
     };
 }
@@ -151,3 +117,6 @@ export function renderTaskShowJson(task, tree) {
 export function renderTaskListJson(tasks, selection = "default") {
     return `${JSON.stringify(groupAndSortTasks(tasks, selection).map(taskJson))}\n`;
 }
+export function renderSelectedTaskListJson(tasks) {
+    return `${JSON.stringify(tasks.map(taskJson))}\n`;
+}

package/build/cli/render/terminal-failure.js

@@ -14,6 +14,10 @@ export function terminalFailureColdStatement(failure) {
     switch (failure.code) {
         case "SUBAGENT_TIMEOUT":
             return "the akuma went silent";
+        case "SUBAGENT_TRANSPORT_ERROR":
+            return "the provider transport failed";
+        case "SUBAGENT_POLICY_BUDGET":
+            return "the execution policy budget expired";
         case "SUBAGENT_PROVIDER_UNAVAILABLE":
             return "the provider did not answer";
         case "SUBAGENT_NON_ZERO_EXIT":
@@ -29,8 +33,9 @@ function terminalFailureEvidence(failure, statement) {
         && failure.code === "SUBAGENT_NON_ZERO_EXIT"
         && failure.exitCode !== undefined;
     const parts = [];
-    if (failure.timeoutMs !== undefined)
-        parts.push(`idle ${failure.timeoutMs}ms`);
+    if (failure.timeoutMs !== undefined) {
+        parts.push(failure.code === "SUBAGENT_POLICY_BUDGET" ? `budget ${failure.timeoutMs}ms` : `idle ${failure.timeoutMs}ms`);
+    }
     if (failure.signal)
         parts.push(`signal ${failure.signal}`);
     if (!exitAlreadyInStatement && failure.exitCode !== undefined)

package/build/cli/render/wait.js

@@ -1,4 +1,4 @@
-import { formatTimelineDuration, renderProjectionActivity, } from "./projection-activity.js";
+import { formatTimelineDuration, renderProjectionActivity, renderProjectionActivitySummary, } from "./projection-activity.js";
 import { displayColumns, resolveLineColumns, truncateColumns } from "./line-width.js";
 import { formatTellCommand, projectionRejoinHintLines, textResponse } from "./shared.js";
 import { renderTerminalFailureFace } from "./terminal-failure.js";
@@ -220,7 +220,22 @@ export function buildWaitResponse(projectionId, result, options = {}) {
     if (rendered.lines.length === 0 && state === "running") {
         lines.push("   not a word out of it yet — pulse is steady");
     }
-    const nextActions = nextActionLines(options.alias ?? projectionId, result, state);
+    // 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);
+        }
+    }
+    const nextActions = state === "running" && options.runningActions === false
+        ? []
+        : nextActionLines(options.alias ?? projectionId, result, state);
     if (nextActions.length > 0)
         lines.push("");
     lines.push(...nextActions);
@@ -237,15 +252,28 @@ export function buildProjectionWaitSetResponse(result) {
     const rendered = result.results
         .slice()
         .sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0)
-        .map((member) => ({ id: member.id, response: buildWaitResponse(member.id, member.result) }));
-    const text = rendered.map(({ id, response }) => `${id}\n${response.text}`).join("\n\n");
-    const selectionSucceeded = result.selection === "all"
-        ? result.results.every((member) => member.result.state === "terminal" && member.result.verdict.state === "completed")
-        : result.selectedId !== undefined;
+        .map((member) => ({
+        id: member.id,
+        result: member.result,
+        response: buildWaitResponse(member.id, member.result, { runningActions: false }),
+    }));
+    const liveIds = rendered
+        .filter((member) => member.result.state === "timeout")
+        .map((member) => member.id);
+    const blocks = rendered.map(({ id, response }) => `${id}\n${response.text}`);
+    if (liveIds.length > 0) {
+        blocks.push([
+            "Come back for the result:",
+            `  » keiyaku wait ${liveIds.join(" ")} --${result.selection} [--timeout DURATION]`,
+            "Steer them while they work:",
+            `  » ${formatTellCommand("<projection-id>", '"your words"')}`,
+        ].join("\n"));
+    }
+    const text = blocks.join("\n\n");
     const exitCode = rendered.reduce((current, { response }) => {
         if (response.exitCode === 130)
             return 130;
         return response.exitCode === 1 ? 1 : current;
-    }, selectionSucceeded ? undefined : 1);
+    }, undefined);
     return exitCode === undefined ? textResponse(text) : { ...textResponse(text), exitCode };
 }

package/build/config/env-keys.js

@@ -10,6 +10,7 @@ export const ENV_KEYS = {
     AGENT_OVERRIDE: "KEIYAKU_AGENT_OVERRIDE",
     DISABLE_SUBAGENT_SPAWN: DISABLE_SUBAGENT_SPAWN_ENV_KEY,
     SUBAGENT_EXEC_IDLE_TIMEOUT_MS: "KEIYAKU_SUBAGENT_EXEC_IDLE_TIMEOUT_MS",
+    SUBAGENT_EXEC_MAX_DURATION_MS: "KEIYAKU_SUBAGENT_EXEC_MAX_DURATION_MS",
     CODEX_EXEC_MAX_CAPTURE_CHARS: "KEIYAKU_CODEX_EXEC_MAX_CAPTURE_CHARS",
     CLAUDE_EXEC_MAX_CAPTURE_CHARS: "KEIYAKU_CLAUDE_EXEC_MAX_CAPTURE_CHARS",
     OPENCODE_EXEC_MAX_CAPTURE_CHARS: "KEIYAKU_OPENCODE_EXEC_MAX_CAPTURE_CHARS",
@@ -26,6 +27,7 @@ const ENV_KEY_ENTRIES = [
     { key: ENV_KEYS.AGENT_OVERRIDE, defaultValue: "", description: "Override default agent name", category: "subagent" },
     { key: ENV_KEYS.DISABLE_SUBAGENT_SPAWN, defaultValue: "0", description: "Disable subprocess subagent spawning when set to 1", category: "subagent" },
     { key: ENV_KEYS.SUBAGENT_EXEC_IDLE_TIMEOUT_MS, defaultValue: "300000", description: "Subagent provider-ingress idle timeout in milliseconds", category: "subagent" },
+    { key: ENV_KEYS.SUBAGENT_EXEC_MAX_DURATION_MS, defaultValue: "3600000", description: "Subagent absolute execution policy budget in milliseconds", category: "subagent" },
     { key: ENV_KEYS.CODEX_EXEC_MAX_CAPTURE_CHARS, defaultValue: "200000", description: "Codex runtime output/diagnostics capture cap", category: "subagent" },
     { key: ENV_KEYS.CLAUDE_EXEC_MAX_CAPTURE_CHARS, defaultValue: "200000", description: "Claude runtime output/diagnostics capture cap", category: "subagent" },
     { key: ENV_KEYS.OPENCODE_EXEC_MAX_CAPTURE_CHARS, defaultValue: "200000", description: "OpenCode runtime output/diagnostics capture cap", category: "subagent" },

package/build/config/env.js

@@ -141,6 +141,7 @@ const subagentSchema = z.object({
     nameOverride: z.string().default(getEnvDefaultValue(ENV_KEYS.AGENT_OVERRIDE)).transform((value) => value.trim()),
     disableSpawn: booleanFlagEnv(ENV_KEYS.DISABLE_SUBAGENT_SPAWN),
     execIdleTimeoutMs: positiveIntEnv(ENV_KEYS.SUBAGENT_EXEC_IDLE_TIMEOUT_MS),
+    execMaxDurationMs: positiveIntEnv(ENV_KEYS.SUBAGENT_EXEC_MAX_DURATION_MS),
 });
 const codexSchema = z.object({
     execMaxCaptureChars: positiveIntEnv(ENV_KEYS.CODEX_EXEC_MAX_CAPTURE_CHARS),
@@ -175,6 +176,7 @@ const envSchema = z
     [ENV_KEYS.AGENT_OVERRIDE]: z.string().optional(),
     [ENV_KEYS.DISABLE_SUBAGENT_SPAWN]: z.string().optional(),
     [ENV_KEYS.SUBAGENT_EXEC_IDLE_TIMEOUT_MS]: z.string().optional(),
+    [ENV_KEYS.SUBAGENT_EXEC_MAX_DURATION_MS]: z.string().optional(),
     [ENV_KEYS.CODEX_EXEC_MAX_CAPTURE_CHARS]: z.string().optional(),
     [ENV_KEYS.CLAUDE_EXEC_MAX_CAPTURE_CHARS]: z.string().optional(),
     [ENV_KEYS.OPENCODE_EXEC_MAX_CAPTURE_CHARS]: z.string().optional(),
@@ -195,6 +197,7 @@ const envSchema = z
         nameOverride: rawEnv[ENV_KEYS.AGENT_OVERRIDE],
         disableSpawn: rawEnv[ENV_KEYS.DISABLE_SUBAGENT_SPAWN],
         execIdleTimeoutMs: rawEnv[ENV_KEYS.SUBAGENT_EXEC_IDLE_TIMEOUT_MS],
+        execMaxDurationMs: rawEnv[ENV_KEYS.SUBAGENT_EXEC_MAX_DURATION_MS],
     }),
     codex: codexSchema.parse({
         execMaxCaptureChars: rawEnv[ENV_KEYS.CODEX_EXEC_MAX_CAPTURE_CHARS],

package/build/core/amend.js

@@ -5,91 +5,33 @@ 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 { isBlankScopePatternLine, normalizeScopePattern, ScopePatternError } from "./scope.js";
+import { markdownSourceSections, normalizeScopePattern, validateScopeFragmentLines } 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;
-            }
+    for (const section of markdownSourceSections(markdown)) {
+        if (section.level !== 2)
             continue;
+        const title = normalizeSectionTitle(section.title);
+        if (title === "scope add") {
+            throw new FlowError("INVALID_KEIYAKU_DRAFT", "Scope Add is obsolete; use ## Scope Append with a fenced gitignore-subset block");
         }
-        if (marker) {
-            fence = marker;
+        if (title !== "scope append")
             continue;
+        if (sections.append) {
+            throw new FlowError("INVALID_KEIYAKU_DRAFT", `amend input may contain ${amendScopeHeading("append")} at most once`);
         }
-        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 };
+        sections.append = {
+            name: "append",
+            start: section.start,
+            contentStart: section.contentStart,
+            end: section.end,
+        };
     }
-    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)}`;
@@ -97,30 +39,14 @@ function parseAmendScopeSections(markdown) {
     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;
-        }
+    return validateScopeFragmentLines(markdown.slice(section.contentStart, section.end).split(/\r?\n/), {
+        heading: amendScopeHeading(section.name),
+        emptyMessage: `amend input has an empty ${amendScopeHeading(section.name)} section`,
     });
-    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) : [];
+    const append = sections.append ? scopePatterns(markdown, sections.append) : [];
     if (!prose.trim()) {
         throw new FlowError("EMPTY_PARAM", "amendment cannot be empty");
     }
@@ -129,7 +55,7 @@ export function buildAmendInput(markdown, cwd, contractId, contractAddressSource
         ...(contractId ? { contractId } : {}),
         ...(contractAddressSource ? { contractAddressSource } : {}),
         amendment: prose,
-        ...(sections.add ? { scopeDelta: { add } } : {}),
+        ...(sections.append ? { scopeDelta: { add: append } } : {}),
     };
 }
 function requireAmendment(value) {

package/build/core/arc.js

@@ -9,7 +9,7 @@ import { parseCommandMarkdown, requireMarkdownTextSection, requireMarkdownTitle,
 import { resolveContractAddress, withResolvedAddress } from "./addressing.js";
 import { activeLedgerRef, appendWithRetry, readLedger } from "./ledger.js";
 import { refreshContractView } from "./contract-view.js";
-import { findOpenArc, getMaxArc, sealCurrentArc } from "./seal.js";
+import { appendScopeTerms, findOpenArc, getMaxArc, sealCurrentArc } from "./seal.js";
 import { deriveContractState, isTerminalState } from "./status/lifecycle.js";
 import { resolveDefaultBranch } from "./status/drift.js";
 import { persistResponseHistory } from "./transcripts.js";
@@ -61,6 +61,14 @@ export async function openArc(input) {
         throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} not found or not active`);
     }
     assertArcOpenable(input.contractId, ledger.entries);
+    await appendScopeTerms({
+        cwd: input.cwd,
+        renderCwd,
+        contractId: input.contractId,
+        patterns: input.appendScope,
+        actor: input.actor,
+        nowMs: input.nowMs,
+    });
     // Seal capture needs delivery HEAD; ledger append may use hub or delivery (shared refs).
     const sealed = await sealCurrentArc({
         cwd: renderCwd,
@@ -68,7 +76,6 @@ export async function openArc(input) {
         contractId: input.contractId,
         sealedBy: "arc",
         nowMs: input.nowMs,
-        waivePaths: input.waivePaths,
     });
     const at = new Date(input.nowMs).toISOString();
     let arcNumber = 0;
@@ -93,7 +100,7 @@ export async function openArc(input) {
     await refreshContractView({ ledgerCwd: input.cwd, renderCwd, contractId: input.contractId });
     return { contractId: input.contractId, arc: arcNumber, ledgerHead: result.head, sealed };
 }
-export function buildArcInput(content, cwd, waivePaths = [], contractId, contractAddressSource) {
+export function buildArcInput(content, cwd, appendScope = [], contractId, contractAddressSource) {
     const parts = parseCommandMarkdown(content);
     return {
         cwd,
@@ -102,7 +109,7 @@ export function buildArcInput(content, cwd, waivePaths = [], contractId, contrac
         title: requireMarkdownTitle(parts),
         objective: requireMarkdownTextSection(parts, "Objective"),
         brief: requireMarkdownTextSection(parts, "Brief"),
-        waivePaths,
+        appendScope,
     };
 }
 async function readBranchLabels(cwd) {
@@ -126,16 +133,17 @@ export async function arcKeiyaku(input) {
         const title = normalizeInlineTitle(requireText("title", input.title));
         const objective = requireText("objective", input.objective);
         const brief = requireText("brief", input.brief);
+        const nowMs = Date.now();
         const opened = await openArc({
             cwd: input.cwd,
             renderCwd,
             contractId,
             actor: ACTOR_IDENTITY,
-            nowMs: Date.now(),
+            nowMs,
             title,
             objective,
             brief,
-            waivePaths: input.waivePaths,
+            appendScope: input.appendScope,
         });
         const { currentBranch, baseBranch } = await readBranchLabels(renderCwd);
         const summary = opened.sealed