@astrosheep/keiyaku 2.9.3 → 2.9.5

package/build/core/scope.js

@@ -1,8 +1,4 @@
-import { spawn } from "node:child_process";
-import * as fs from "node:fs/promises";
-import * as os from "node:os";
-import * as path from "node:path";
-import { createGit, wrapGitError } from "../git/core.js";
+import { FlowError } from "../flow-error.js";
 export class ScopePatternError extends Error {
     code = "INVALID_SCOPE_PATTERN";
     constructor(message) {
@@ -36,14 +32,140 @@ function stripUnescapedTrailingSpaces(value) {
 function canonicalizeScopePatternInput(pattern) {
     return stripUnescapedTrailingSpaces(pattern.replace(/^\s+/, ""));
 }
-/** True when a raw Scope Add / list line has no pattern after gitignore blank rules. */
+/** True when a raw scope line has no pattern after gitignore blank rules. */
 export function isBlankScopePatternLine(line) {
     return canonicalizeScopePatternInput(line).length === 0;
 }
+/** Parse Keiyaku's source-line Scope opener, not a normalized Markdown node. */
+export function parseScopeFenceOpening(line) {
+    const match = line.match(/^(`{3,})$/);
+    return match ? { length: match[1].length } : null;
+}
+/** Keiyaku closer: column-zero backticks, at least opener length, then whitespace. */
+export function isScopeFenceClosing(line, fence) {
+    const match = line.match(/^(`+)[ \t]*$/);
+    return Boolean(match && match[1].length >= fence.length);
+}
+function fencedScopeError(heading, detail) {
+    return new FlowError("INVALID_KEIYAKU_DRAFT", `${heading} must contain exactly one fenced gitignore-subset block; ${detail}. ` +
+        `Paste-ready canonical example:\n\n${heading}\n\`\`\`\nfoo\nbar\n\`\`\``);
+}
+/** Validate and normalize the one fenced block that constitutes a Scope body. */
+export function validateScopeFragmentLines(lines, options) {
+    const first = lines.findIndex((line) => line.trim().length > 0);
+    if (first === -1)
+        throw fencedScopeError(options.heading, "found no fenced block");
+    const fence = parseScopeFenceOpening(lines[first]);
+    if (!fence)
+        throw fencedScopeError(options.heading, `offending line '${lines[first]}'`);
+    let close = -1;
+    for (let index = first + 1; index < lines.length; index += 1) {
+        if (isScopeFenceClosing(lines[index], fence)) {
+            close = index;
+            break;
+        }
+    }
+    if (close === -1)
+        throw fencedScopeError(options.heading, "the fenced block is not closed");
+    const outside = lines.slice(close + 1).find((line) => line.trim().length > 0);
+    if (outside !== undefined) {
+        throw fencedScopeError(options.heading, `offending line '${outside}' appears outside the fenced block`);
+    }
+    const patterns = [];
+    for (const line of lines.slice(first + 1, close)) {
+        if (isBlankScopePatternLine(line))
+            continue;
+        try {
+            patterns.push(normalizeScopePattern(line));
+        }
+        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", options.emptyMessage);
+    return patterns;
+}
+function sourceFenceOpening(line) {
+    const match = line.match(/^ {0,3}(`{3,}|~{3,})(.*)$/);
+    if (!match)
+        return null;
+    const marker = match[1];
+    if (marker[0] === "`" && match[2].includes("`"))
+        return null;
+    return { delimiter: marker[0], length: marker.length };
+}
+function sourceFenceClosing(line, fence) {
+    const match = line.match(/^ {0,3}(`+|~+)[ \t]*$/);
+    return Boolean(match && match[1][0] === fence.delimiter && match[1].length >= fence.length);
+}
+/** Locate structural H1/H2 source ranges while leaving fenced headings inert. */
+export function markdownSourceSections(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, next });
+        start = next;
+    }
+    let frontMatterEnd = -1;
+    if (lines[0]?.text.trim() === "---") {
+        frontMatterEnd = lines.findIndex((line, index) => index > 0 && line.text.trim() === "---");
+    }
+    const headings = [];
+    let fence = null;
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index];
+        if (index <= frontMatterEnd)
+            continue;
+        if (fence) {
+            if (sourceFenceClosing(line.text, fence))
+                fence = null;
+            continue;
+        }
+        const opening = sourceFenceOpening(line.text);
+        if (opening) {
+            fence = opening;
+            continue;
+        }
+        // Column-0 only: indented ATX-looking lines inside list items remain content.
+        const heading = line.text.match(/^(#{1,2})(?!#)[ \t]+(.+)$/);
+        if (!heading)
+            continue;
+        headings.push({
+            level: heading[1].length,
+            title: heading[2],
+            start: line.start,
+            contentStart: line.next,
+        });
+    }
+    return headings.map((heading, index) => {
+        const next = heading.level === 2
+            ? headings.slice(index + 1).find((candidate) => candidate.level === 2)
+            : headings[index + 1];
+        return { ...heading, end: next?.start ?? markdown.length };
+    });
+}
+/** Render canonical Scope bytes with a fence that content cannot close. */
+export function renderScopeFragment(patterns) {
+    let longestRun = 0;
+    for (const pattern of patterns) {
+        for (const run of pattern.match(/`+/g) ?? [])
+            longestRun = Math.max(longestRun, run.length);
+    }
+    const fence = "`".repeat(Math.max(3, longestRun + 1));
+    return `${fence}\n${patterns.join("\n")}\n${fence}`;
+}
 /**
- * Canonicalize a scope gitignore pattern for exclude matching and persistence.
+ * Canonicalize a scope Gitignore-like pattern for matching and persistence.
  * Strips only a cosmetic leading `./` (including after `!`); preserves meaningful
- * leading `/` anchoring, gitignore backslash escapes, and escaped trailing spaces.
+ * leading `/` anchoring, supported backslash escapes, and escaped trailing spaces.
  */
 export function normalizeScopePattern(pattern) {
     if (pattern.includes("\0") || pattern.includes("\n") || pattern.includes("\r")) {
@@ -62,7 +184,7 @@ export function normalizeScopePattern(pattern) {
     return negative ? `!${body}` : body;
 }
 /**
- * Normalize a path to Git diff form for exact waiver comparison:
+ * Normalize a path to Git diff form for matcher comparison:
  * either slash convention, collapse separators, and strip cosmetic `./` or `/`.
  * Leading and trailing spaces are significant path bytes and must remain unchanged.
  */
@@ -78,75 +200,157 @@ export function normalizeScopePath(filePath) {
         throw new ScopePatternError("scope path cannot contain NUL");
     return normalized;
 }
-function runCheckIgnore(gitDir, workTree, cwd, paths) {
-    return new Promise((resolve, reject) => {
-        const child = spawn("git", [
-            `--git-dir=${gitDir}`,
-            `--work-tree=${workTree}`,
-            "check-ignore",
-            "--no-index",
-            "-z",
-            "--stdin",
-        ], {
-            cwd,
-            env: {
-                ...process.env,
-                GIT_TERMINAL_PROMPT: "0",
-                GCM_INTERACTIVE: "Never",
-                GIT_CONFIG_GLOBAL: "/dev/null",
-                GIT_CONFIG_NOSYSTEM: "1",
-                LC_ALL: "C",
-            },
-            stdio: ["pipe", "pipe", "pipe"],
-        });
-        const stdout = [];
-        const stderr = [];
-        child.stdout.on("data", (chunk) => stdout.push(chunk));
-        child.stderr.on("data", (chunk) => stderr.push(chunk));
-        child.stdin.on("error", reject);
-        child.on("error", reject);
-        child.on("close", (code) => {
-            if (code !== 0 && code !== 1) {
-                reject(wrapGitError("check-ignore --no-index -z --stdin", {
-                    message: `git check-ignore exited with status ${code ?? "unknown"}`,
-                    stderr: Buffer.concat(stderr).toString("utf8"),
-                    stdout: Buffer.concat(stdout).toString("utf8"),
-                }, cwd));
-                return;
+function splitPatternComponents(pattern) {
+    const components = [];
+    let component = "";
+    let escaped = false;
+    for (const character of pattern) {
+        if (escaped) {
+            component += `\\${character}`;
+            escaped = false;
+        }
+        else if (character === "\\") {
+            escaped = true;
+        }
+        else if (character === "/") {
+            components.push(component);
+            component = "";
+        }
+        else {
+            component += character;
+        }
+    }
+    if (escaped)
+        component += "\\\\";
+    components.push(component);
+    return components;
+}
+function parseScopePattern(pattern) {
+    const normalized = normalizeScopePattern(pattern);
+    const escapedLeading = normalized.startsWith("\\!") || normalized.startsWith("\\#");
+    const negative = normalized.startsWith("!");
+    const body = negative ? normalized.slice(1) : normalized;
+    const comment = !escapedLeading && body.startsWith("#");
+    const anchored = body.startsWith("/");
+    const unanchored = anchored ? body.slice(1) : body;
+    const directory = unanchored.endsWith("/");
+    const source = directory ? unanchored.slice(0, -1) : unanchored;
+    const segments = splitPatternComponents(source);
+    return { negative, comment, directory, segments, componentOnly: !anchored && !source.includes("/") };
+}
+function componentMatches(pattern, value) {
+    let expression = "^";
+    for (let index = 0; index < pattern.length; index += 1) {
+        const character = pattern[index];
+        if (character === "\\") {
+            index += 1;
+            expression += escapeRegex(pattern[index] ?? "\\");
+        }
+        else if (character === "*") {
+            if (pattern[index + 1] === "*") {
+                expression += ".*";
+                index += 1;
+            }
+            else
+                expression += "[^/]*";
+        }
+        else if (character === "?")
+            expression += "[^/]";
+        else if (character === "[") {
+            const close = pattern.indexOf("]", index + 1);
+            if (close === -1)
+                expression += "\\[";
+            else {
+                const rawClass = pattern.slice(index + 1, close);
+                const classBody = rawClass.startsWith("!") ? `^${rawClass.slice(1)}` : rawClass;
+                expression += `[${classBody.replace(/\\/g, "\\\\")}]`;
+                index = close;
+            }
+        }
+        else
+            expression += escapeRegex(character);
+    }
+    return new RegExp(`${expression}$`).test(value);
+}
+function escapeRegex(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function patternMatchesPath(parsed, filePath) {
+    if (parsed.comment)
+        return false;
+    const pathSegments = filePath.split("/");
+    if (parsed.componentOnly) {
+        const lastMatchIndex = parsed.directory ? pathSegments.length - 1 : pathSegments.length;
+        return pathSegments.slice(0, lastMatchIndex).some((segment) => componentMatches(parsed.segments[0], segment));
+    }
+    const memo = new Map();
+    const matchesFrom = (patternIndex, pathIndex) => {
+        const key = `${patternIndex}:${pathIndex}`;
+        const cached = memo.get(key);
+        if (cached !== undefined)
+            return cached;
+        let matched;
+        if (patternIndex === parsed.segments.length) {
+            matched = parsed.directory ? pathIndex < pathSegments.length : pathIndex === pathSegments.length;
+            memo.set(key, matched);
+            return matched;
+        }
+        const segment = parsed.segments[patternIndex];
+        if (segment === "**") {
+            matched = false;
+            for (let nextPathIndex = pathIndex; nextPathIndex <= pathSegments.length; nextPathIndex += 1) {
+                if (matchesFrom(patternIndex + 1, nextPathIndex)) {
+                    matched = true;
+                    break;
+                }
             }
-            resolve(new Set(Buffer.concat(stdout)
-                .toString("utf8")
-                .split("\0")
-                .filter(Boolean)));
+        }
+        else {
+            matched = pathIndex < pathSegments.length
+                && componentMatches(segment, pathSegments[pathIndex])
+                && matchesFrom(patternIndex + 1, pathIndex + 1);
+        }
+        memo.set(key, matched);
+        return matched;
+    };
+    return matchesFrom(0, 0);
+}
+/**
+ * Evaluate the settled ordered Gitignore-like scope subset without invoking Git.
+ */
+export async function scopePathEvidence(_cwd, patterns, filePaths) {
+    const normalizedPatterns = patterns.map(normalizeScopePattern);
+    const normalizedPaths = filePaths.map(normalizeScopePath);
+    const parsedPatterns = normalizedPatterns.map(parseScopePattern);
+    return normalizedPaths.map((normalizedPath) => {
+        const pathDecisions = parsedPatterns.flatMap((parsed, index) => {
+            if (!patternMatchesPath(parsed, normalizedPath))
+                return [];
+            const effect = parsed.negative ? "exclude" : "include";
+            return [{ index, pattern: normalizedPatterns[index], effect, matchedAfter: effect === "include" }];
         });
-        child.stdin.end(`${paths.join("\0")}\0`);
+        const decisivePattern = pathDecisions.at(-1);
+        const hasPositiveMatch = pathDecisions.some((decision) => decision.effect === "include");
+        const matched = decisivePattern?.matchedAfter ?? false;
+        return {
+            path: normalizedPath,
+            patterns: pathDecisions,
+            matched,
+            outcome: matched ? "matched" : hasPositiveMatch ? "excluded" : "no-positive-match",
+            ...(decisivePattern ? { decisivePattern } : {}),
+        };
     });
 }
 export async function pathsMatchingScope(cwd, patterns, filePaths) {
-    const normalizedPatterns = patterns.map(normalizeScopePattern);
-    const normalizedPaths = filePaths.map(normalizeScopePath);
-    if (normalizedPatterns.length === 0 || normalizedPaths.length === 0)
-        return new Set();
-    const temporaryRoot = await fs.mkdtemp(path.join(os.tmpdir(), "keiyaku-scope-"));
-    const gitDir = path.join(temporaryRoot, "scope.git");
-    const workTree = path.join(temporaryRoot, "worktree");
-    try {
-        await Promise.all([fs.mkdir(gitDir), fs.mkdir(workTree)]);
-        await createGit(gitDir).init(true);
-        await fs.writeFile(path.join(gitDir, "info", "exclude"), `${normalizedPatterns.join("\n")}\n`, "utf8");
-        return await runCheckIgnore(gitDir, workTree, cwd, normalizedPaths);
-    }
-    finally {
-        await fs.rm(temporaryRoot, { recursive: true, force: true });
-    }
+    const evidence = await scopePathEvidence(cwd, patterns, filePaths);
+    return new Set(evidence.filter((item) => item.matched).map((item) => item.path));
 }
 export function isNegativeScopePattern(pattern) {
     return normalizeScopePattern(pattern).startsWith("!");
 }
 /**
- * Parse only the subset whose path language can be proved statically: literal
- * segments, `*` segments, and `**` segments. Anything using richer gitignore
- * syntax is left to Git and produces no advisory warning.
+ * Parse only the positive subset whose path language can be proved statically:
+ * literal segments, `*` segments, and `**` segments.
  */
 function staticScopeSegments(pattern) {
     const positive = normalizeScopePattern(pattern);

package/build/core/seal.js

@@ -1,12 +1,12 @@
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
 import { FlowError } from "../flow-error.js";
-import { createGit, wrapGitError } from "../git/core.js";
+import { createGit, parseRevListOutput, wrapGitError } from "../git/core.js";
 import { KEIYAKU_FILE } from "../keiyaku.js";
+import { formatLedgerEntryCommitMessage } from "./entry.js";
 import { activeLedgerRef, appendWithRetry, readLedger } from "./ledger.js";
-import { renderContractView } from "./contract-view.js";
-import { normalizeScopePath, pathsMatchingScope } from "./scope.js";
+import { refreshContractView } from "./contract-view.js";
+import { normalizeScopePattern, scopePathEvidence, } from "./scope.js";
 import { deriveContractState, isTerminalState } from "./status/lifecycle.js";
+import { casUpdateRefLog, createRefLogCommit } from "./ref-log.js";
 function findBind(entries) {
     const bind = entries.find((entry) => entry.kind === "bind");
     if (!bind)
@@ -64,10 +64,7 @@ async function resolveCommit(cwd, revision) {
 async function revList(cwd, from, to) {
     const git = createGit(cwd);
     try {
-        return (await git.raw(["rev-list", "--reverse", `${from}..${to}`]))
-            .split(/\r?\n/)
-            .map((line) => line.trim())
-            .filter(Boolean);
+        return parseRevListOutput(await git.raw(["rev-list", "--reverse", `${from}..${to}`]));
     }
     catch (error) {
         throw wrapGitError(`rev-list ${from}..${to}`, error, cwd);
@@ -104,8 +101,58 @@ async function diffstat(cwd, from, to) {
 }
 async function scopeViolations(cwd, paths, scope) {
     const auditedPaths = paths.filter((changedPath) => changedPath !== KEIYAKU_FILE);
-    const matched = await pathsMatchingScope(cwd, scope, auditedPaths);
-    return auditedPaths.filter((changedPath) => !matched.has(changedPath));
+    return (await scopePathEvidence(cwd, scope, auditedPaths)).filter((evidence) => !evidence.matched);
+}
+async function auditScope(cwd, entries, paths) {
+    const scope = effectiveScope(entries);
+    const scopeViolationEvidence = await scopeViolations(cwd, paths, scope);
+    if (scopeViolationEvidence.length > 0) {
+        throw new ScopeAuditError(findBind(entries).contract, scope, scopeViolationEvidence);
+    }
+    const violations = scopeViolationEvidence.map((violation) => violation.path);
+    return {
+        scopeAudit: { violations },
+        scopeViolationEvidence,
+    };
+}
+const APPEND_SCOPE_AMENDMENT = "Scope extended by lifecycle command.";
+export async function appendScopeTerms(input) {
+    if (!input.patterns || input.patterns.length === 0)
+        return null;
+    const patterns = input.patterns.map(normalizeScopePattern);
+    const at = new Date(input.nowMs).toISOString();
+    const result = await appendWithRetry(input.cwd, activeLedgerRef(input.contractId), (_head, entries) => {
+        assertOperable(input.contractId, entries);
+        return {
+            v: 1,
+            kind: "amend",
+            contract: input.contractId,
+            at,
+            actor: input.actor,
+            data: { amendment: APPEND_SCOPE_AMENDMENT, scopeDelta: { add: patterns } },
+        };
+    });
+    if (!result.ok) {
+        throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} active ledger disappeared while appending scope`);
+    }
+    await refreshContractView({ ledgerCwd: input.cwd, renderCwd: input.renderCwd, contractId: input.contractId });
+    return result.head;
+}
+export class ScopeAuditError extends FlowError {
+    scopeViolationEvidence;
+    constructor(_contractId, scope, evidence) {
+        const count = evidence.length;
+        const fileLabel = count === 1 ? "file" : "files";
+        super("SCOPE_VIOLATION", `scope violation — ${count} ${fileLabel} outside declared scope`, {
+            facts: {
+                kind: "scope_violation",
+                scope: [...scope],
+                violations: evidence,
+            },
+        });
+        this.name = "ScopeAuditError";
+        this.scopeViolationEvidence = evidence;
+    }
 }
 function assertOperable(contractId, entries) {
     const state = deriveContractState(entries);
@@ -127,14 +174,13 @@ export function currentSealArc(entries) {
 }
 /** Stable read-only coordinate naming the receipt source a petition would seal. */
 export function petitionSealSource(entries) {
-    const arc = currentSealArc(entries);
-    const fence = getFence(entries);
-    return arc === null
-        ? `no open arc · fence ${fence}`
-        : `a${arc} · fence ${fence}▸HEAD`;
+    return {
+        arc: currentSealArc(entries),
+        fence: getFence(entries),
+    };
 }
 /** Shared read-only owner for the seal capture and its compact changed-path evidence. */
-export async function previewSeal(cwd, entries, head = "HEAD", waivePaths = []) {
+export async function previewSeal(cwd, entries, head = "HEAD") {
     const arc = currentSealArc(entries);
     if (arc === null)
         return { capture: null, paths: [] };
@@ -145,13 +191,7 @@ export async function previewSeal(cwd, entries, head = "HEAD", waivePaths = [])
         changedPaths(cwd, oldFence, newFence),
         diffstat(cwd, oldFence, newFence),
     ]);
-    const scope = effectiveScope(entries);
-    const violations = await scopeViolations(cwd, paths, scope);
-    const waivedPaths = new Set(waivePaths.map(normalizeScopePath));
-    const unwaived = violations.filter((violation) => !waivedPaths.has(violation));
-    if (unwaived.length > 0) {
-        throw new FlowError("INTERNAL_STATE", `scope audit failed for contract ${findBind(entries).contract}: paths ${unwaived.join(", ")} outside ${scope.join(", ")}`);
-    }
+    const scopeAudit = await auditScope(cwd, entries, paths);
     return {
         capture: {
             arc,
@@ -159,20 +199,38 @@ export async function previewSeal(cwd, entries, head = "HEAD", waivePaths = [])
             newFence,
             receipts,
             diffstat: stat,
-            scopeAudit: { violations, waived: violations.length > 0 },
+            ...scopeAudit,
         },
         paths,
     };
 }
-export async function captureSeal(cwd, entries, head = "HEAD", waivePaths = []) {
-    return (await previewSeal(cwd, entries, head, waivePaths)).capture;
+export async function captureSeal(cwd, entries, head = "HEAD") {
+    return (await previewSeal(cwd, entries, head)).capture;
 }
-async function renderUpdatedContract(ledgerCwd, renderCwd, contractId) {
-    const ledger = await readLedger(ledgerCwd, contractId);
-    if (!ledger) {
-        throw new FlowError("INTERNAL_STATE", `contract ${contractId} active ledger disappeared before render`);
-    }
-    await fs.writeFile(path.join(renderCwd, KEIYAKU_FILE), renderContractView({ id: contractId, entries: ledger.entries }), "utf8");
+/** Preserve original receipt hashes while auditing the rebased delivery content. */
+export async function captureRenewSeal(input) {
+    const arc = currentSealArc(input.entries);
+    if (arc === null)
+        return null;
+    const oldFence = getFence(input.entries);
+    const [receiptHead, contentBase, contentHead] = await Promise.all([
+        resolveCommit(input.cwd, input.receiptHead),
+        resolveCommit(input.cwd, input.contentBase),
+        resolveCommit(input.cwd, input.contentHead),
+    ]);
+    const [receipts, paths, stat] = await Promise.all([
+        revList(input.cwd, oldFence, receiptHead),
+        changedPaths(input.cwd, contentBase, contentHead),
+        diffstat(input.cwd, contentBase, contentHead),
+    ]);
+    return {
+        arc,
+        oldFence,
+        newFence: receiptHead,
+        receipts,
+        diffstat: stat,
+        ...await auditScope(input.cwd, input.entries, paths),
+    };
 }
 export async function sealCurrentArc(input) {
     const ledger = await readLedger(input.cwd, input.contractId);
@@ -180,7 +238,7 @@ export async function sealCurrentArc(input) {
         throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} not found or not active`);
     }
     assertOperable(input.contractId, ledger.entries);
-    const capture = input.capture ?? await captureSeal(input.cwd, ledger.entries, "HEAD", input.waivePaths);
+    const capture = input.capture ?? await captureSeal(input.cwd, ledger.entries, "HEAD");
     if (!capture)
         return null;
     const at = new Date(input.nowMs).toISOString();
@@ -196,25 +254,92 @@ export async function sealCurrentArc(input) {
         if (currentArc !== capture.arc || getFence(entries) !== capture.oldFence) {
             throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} changed while sealing arc a${capture.arc}`);
         }
+        const { scopeViolationEvidence: _scopeViolationEvidence, ...durableCapture } = capture;
         return {
-            v: 1,
+            v: 2,
             kind: "seal",
             contract: input.contractId,
             at,
             actor: "engine",
-            data: { ...capture, sealedBy: input.sealedBy },
+            data: { ...durableCapture, sealedBy: input.sealedBy },
         };
     });
     if (!result.ok) {
         throw new FlowError("INTERNAL_STATE", `failed to seal arc for ${input.contractId}: ${result.reason}`);
     }
-    await renderUpdatedContract(input.cwd, input.renderCwd, input.contractId);
+    await refreshContractView({
+        ledgerCwd: input.cwd,
+        renderCwd: input.renderCwd,
+        contractId: input.contractId,
+    });
     return {
         ...capture,
         sealedBy: input.sealedBy,
         ledgerHead: result.head,
-        incrementalDiff: capture.receipts.length === 0
-            ? "nothing sealed"
-            : `${capture.receipts.length} receipt${capture.receipts.length === 1 ? "" : "s"} · +${capture.diffstat.insertions} −${capture.diffstat.deletions}`,
     };
 }
+function splitLedgerMessage(entry) {
+    const message = formatLedgerEntryCommitMessage(entry);
+    const separator = message.indexOf("\n\n");
+    return { subject: message.slice(0, separator), body: message.slice(separator + 2).trimEnd() };
+}
+export async function appendRenewSettlement(input) {
+    const ledger = await readLedger(input.cwd, input.contractId);
+    if (!ledger || ledger.head !== input.expectedLedgerHead) {
+        throw new FlowError("CONCURRENT_MODIFICATION", `contract ${input.contractId} changed while renewing`);
+    }
+    assertOperable(input.contractId, ledger.entries);
+    if (input.capture && (currentSealArc(ledger.entries) !== input.capture.arc || getFence(ledger.entries) !== input.capture.oldFence)) {
+        throw new FlowError("CONCURRENT_MODIFICATION", `contract ${input.contractId} changed while renewing`);
+    }
+    const at = new Date(input.nowMs).toISOString();
+    let parentHead = ledger.head;
+    let sealHead;
+    if (input.capture) {
+        const { scopeViolationEvidence: _evidence, ...durableCapture } = input.capture;
+        const sealEntry = {
+            v: 2,
+            kind: "seal",
+            contract: input.contractId,
+            at,
+            actor: "engine",
+            data: { ...durableCapture, newFence: input.newHead, sealedBy: "renew" },
+        };
+        const message = splitLedgerMessage(sealEntry);
+        sealHead = await createRefLogCommit(input.cwd, {
+            ...message,
+            parentHead,
+            errorLabel: `ledger seal ${input.contractId}`,
+        });
+        parentHead = sealHead;
+    }
+    const renewEntry = {
+        v: 1,
+        kind: "renew",
+        contract: input.contractId,
+        at,
+        actor: input.actor,
+        data: {
+            oldBase: input.oldBase,
+            newBase: input.newBase,
+            oldHead: input.oldHead,
+            newHead: input.newHead,
+        },
+    };
+    const message = splitLedgerMessage(renewEntry);
+    const renewHead = await createRefLogCommit(input.cwd, {
+        ...message,
+        parentHead,
+        errorLabel: `ledger renew ${input.contractId}`,
+    });
+    if (!await casUpdateRefLog(input.cwd, activeLedgerRef(input.contractId), renewHead, ledger.head)) {
+        throw new FlowError("CONCURRENT_MODIFICATION", `contract ${input.contractId} changed while renewing`);
+    }
+    const sealed = input.capture ? {
+        ...input.capture,
+        newFence: input.newHead,
+        sealedBy: "renew",
+        ledgerHead: sealHead,
+    } : null;
+    return { ledgerHead: renewHead, sealed };
+}