edsger 0.48.0 → 0.49.0

package/dist/commands/run-sheet/index.js

@@ -33,14 +33,8 @@ export const runRunSheetCommand = async (options) => {
         if (result.cloneError) {
             logInfo(`Clone warning: ${result.cloneError}`);
         }
-        if (result.commitsError) {
-            logInfo(`Commits warning: could not fetch commit list (${result.commitsError}). Run sheet rendered without {{commits}} / {{#each commits}} content.`);
-        }
-        if (result.missingPlaceholders && result.missingPlaceholders.length > 0) {
-            logInfo(`Unresolved placeholders: ${result.missingPlaceholders.join(', ')}`);
-        }
-        if (result.commitsTruncated) {
-            logInfo('Commit list truncated at GitHub 250-commit cap.');
+        if (typeof result.agentTurns === 'number') {
+            logInfo(`Agent used ${result.agentTurns} turn(s)${result.model ? ` on model ${result.model}` : ''}.`);
         }
         logInfo('View it in the Release detail page of your product dashboard.');
     }

package/dist/phases/run-sheet/agent.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Run-sheet generation via the Claude Agent SDK.
+ *
+ * The agent is handed the product's cloned repo (checked out at the
+ * release ref) plus release metadata and a free-form template, and is
+ * asked to produce the final run sheet Markdown. Unlike the previous
+ * placeholder-based renderer, the template here is a structural guide
+ * — it may contain no placeholders at all. The agent reads the diff
+ * and source to decide what each section should say.
+ */
+export interface AgentReleaseContext {
+    tag: string;
+    name: string | null;
+    body: string | null;
+    url: string | null;
+    published_at: string | null;
+    previous_tag: string | null;
+    previous_published_at: string | null;
+}
+export interface AgentProductContext {
+    name: string;
+    github_repository_full_name: string | null;
+}
+export interface RunSheetAgentInput {
+    product: AgentProductContext;
+    release: AgentReleaseContext;
+    template: string;
+    repoDir: string | null;
+    isDraft: boolean;
+    draftBaseRef: string | null;
+    verbose?: boolean;
+}
+export interface RunSheetAgentResult {
+    content: string;
+    turns: number;
+    model: string;
+    subtype: string;
+    error: string | null;
+}
+/** Exported for unit tests; not part of the public CLI surface. */
+export declare function buildUserPrompt(input: RunSheetAgentInput): string;
+/**
+ * Strip a single Markdown code fence wrapping the entire response.
+ * Defensive: the prompt forbids it, but models still occasionally do it.
+ *
+ * Exported for unit tests.
+ */
+export declare function stripWrappingFence(text: string): string;
+export declare function generateRunSheetWithAgent(input: RunSheetAgentInput): Promise<RunSheetAgentResult>;

package/dist/phases/run-sheet/agent.js

@@ -0,0 +1,157 @@
+/**
+ * Run-sheet generation via the Claude Agent SDK.
+ *
+ * The agent is handed the product's cloned repo (checked out at the
+ * release ref) plus release metadata and a free-form template, and is
+ * asked to produce the final run sheet Markdown. Unlike the previous
+ * placeholder-based renderer, the template here is a structural guide
+ * — it may contain no placeholders at all. The agent reads the diff
+ * and source to decide what each section should say.
+ */
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { DEFAULT_MODEL } from '../../constants.js';
+import { logError, logInfo } from '../../utils/logger.js';
+// Dropped from the agent's tool surface entirely so it cannot mutate the
+// cloned repo or anything else on disk. Bash stays available — we further
+// constrain it to read-only commands via the system prompt.
+const DISALLOWED_TOOLS = ['Edit', 'Write', 'NotebookEdit'];
+const SYSTEM_PROMPT = `You are generating a release run sheet for a software product.
+
+A run sheet is a release-readiness document: it summarises what is in the release, what operators need to do to ship it safely, and what to verify after rollout. You will receive product/release metadata and a TEMPLATE that describes the desired structure. The template is authoritative guidance — match its headings, section order, tone, and level of detail. It may be free-form prose with no placeholders or variable references at all.
+
+You have READ-ONLY access to the product's git repository, already cloned and checked out at the release ref (or the default branch for drafts), via the Bash, Read, Grep, and Glob tools. Use them to ground your output in real code:
+- \`git --no-pager log --no-decorate --pretty=format:"%h %s (%an)" <previous_ref>..HEAD\` to enumerate commits in the release
+- \`git --no-pager diff --stat <previous_ref>..HEAD\` for the files-changed summary
+- \`git --no-pager diff <previous_ref>..HEAD -- <path>\` to inspect specific changes when writing a section
+- \`git --no-pager show <sha>\` to inspect an individual commit
+- README / CHANGELOG / package manifests for product-level context
+
+Bash safety rules (strict):
+- Use \`git --no-pager ...\` for every git invocation so output never paginates.
+- ONLY run read-only commands. Allowed: \`git log\`, \`git diff\`, \`git show\`, \`git status\`, \`git rev-parse\`, \`git ls-files\`, \`git config --get\`, \`cat\`, \`head\`, \`tail\`, \`wc\`, \`ls\`. Forbidden: anything that mutates state — \`git push\`, \`git commit\`, \`git reset\`, \`git checkout\`, \`git fetch\`, \`git pull\`, \`git clean\`, \`git config <set>\`, \`rm\`, \`mv\`, \`cp\`, \`chmod\`, \`curl\`, \`wget\`, package managers, build commands.
+- Prefer Read/Grep/Glob over Bash for plain file inspection.
+
+Output rules:
+1. Output ONLY the final run-sheet Markdown. No preamble ("Here is..."), no trailing commentary, no wrapping code fence around the whole document.
+2. Follow the structure of the TEMPLATE exactly — same section headings in the same order. If the template is free-form prose, infer sensible sections from it.
+3. Ground every claim in the repo. Do not invent features, APIs, or risks that are not evidenced by the diff or code.
+4. If the release is marked DRAFT, include a short "Draft" note near the top explaining the tag is not yet cut.
+5. Prefer concise bullet points over long paragraphs for actionable items. Aim for under 600 lines of Markdown total — be specific, not exhaustive.
+6. If the diff is empty or there is no previous ref to compare against, state that plainly rather than fabricating content.`;
+function userMessage(content) {
+    return { type: 'user', message: { role: 'user', content } };
+}
+// eslint-disable-next-line @typescript-eslint/require-await -- async generator required by SDK interface
+async function* makePrompt(text) {
+    yield userMessage(text);
+}
+/** Exported for unit tests; not part of the public CLI surface. */
+export function buildUserPrompt(input) {
+    const { product, release, template, isDraft, draftBaseRef } = input;
+    const baseRef = release.previous_tag ?? '(none — no previous release)';
+    const headRef = isDraft && draftBaseRef ? draftBaseRef : release.tag;
+    const draftLine = isDraft
+        ? `DRAFT: true — the tag \`${release.tag}\` has not been cut on GitHub yet; the working tree is the default branch \`${draftBaseRef ?? 'HEAD'}\`.`
+        : 'DRAFT: false';
+    const metadata = [
+        `Product: ${product.name}`,
+        `Repository: ${product.github_repository_full_name ?? '(unknown)'}`,
+        `Release tag: ${release.tag}`,
+        `Release name: ${release.name ?? release.tag}`,
+        `Previous tag: ${release.previous_tag ?? '(none)'}`,
+        `Published at: ${release.published_at ?? '(unpublished)'}`,
+        `Previous published at: ${release.previous_published_at ?? '(n/a)'}`,
+        `Release URL: ${release.url ?? '(n/a)'}`,
+        draftLine,
+        `Compare range: ${baseRef}..${headRef}`,
+    ].join('\n');
+    const body = release.body?.trim()
+        ? `\n\n--- RELEASE NOTES (from GitHub release body) ---\n${release.body.trim()}`
+        : '';
+    return `Here is the context for the release you are writing a run sheet for.
+
+--- METADATA ---
+${metadata}${body}
+
+--- TEMPLATE (follow its structure; it may contain no placeholders) ---
+${template}
+
+--- INSTRUCTIONS ---
+Inspect the repo (it is your current working directory) and produce the final run sheet in Markdown. Output only the Markdown — no preamble, no wrapping fence.`;
+}
+/**
+ * Strip a single Markdown code fence wrapping the entire response.
+ * Defensive: the prompt forbids it, but models still occasionally do it.
+ *
+ * Exported for unit tests.
+ */
+export function stripWrappingFence(text) {
+    const trimmed = text.trim();
+    const fence = trimmed.match(/^```(?:markdown|md)?\s*\n([\s\S]*?)\n```\s*$/);
+    return fence ? fence[1].trim() : trimmed;
+}
+function summariseToolUse(name, input, turn) {
+    const i = (input ?? {});
+    const descRaw = i.description ?? i.command ?? 'Running...';
+    const desc = typeof descRaw === 'string' ? descRaw : 'Running...';
+    return `[Turn ${turn}] ${name}: ${desc.slice(0, 160)}`;
+}
+// eslint-disable-next-line complexity -- agent loop with message type handling
+export async function generateRunSheetWithAgent(input) {
+    const { repoDir } = input;
+    let assistantText = '';
+    let resultText = '';
+    let turns = 0;
+    let subtype = 'unknown';
+    let error = null;
+    logInfo('Connecting to Claude Agent SDK for run-sheet generation...');
+    const userPrompt = buildUserPrompt(input);
+    for await (const message of query({
+        prompt: makePrompt(userPrompt),
+        options: {
+            systemPrompt: {
+                type: 'preset',
+                preset: 'claude_code',
+                append: SYSTEM_PROMPT,
+            },
+            model: DEFAULT_MODEL,
+            permissionMode: 'bypassPermissions',
+            disallowedTools: DISALLOWED_TOOLS,
+            ...(repoDir ? { cwd: repoDir } : {}),
+        },
+    })) {
+        if (message.type === 'assistant' && message.message?.content) {
+            turns++;
+            for (const content of message.message.content) {
+                if (content.type === 'text') {
+                    assistantText += `${content.text}\n`;
+                }
+                else if (content.type === 'tool_use') {
+                    // Always emit tool-use lines (not gated on verbose) so the
+                    // desktop CliTerminal shows live progress instead of going
+                    // silent for the duration of the agent run.
+                    logInfo(summariseToolUse(content.name, content.input, turns));
+                }
+            }
+        }
+        if (message.type === 'result') {
+            subtype = message.subtype;
+            resultText = ('result' in message ? (message.result ?? '') : '') || '';
+            if (message.subtype !== 'success') {
+                error = `Agent finished with subtype=${message.subtype}`;
+                logError(`Run-sheet agent incomplete: ${message.subtype}`);
+            }
+        }
+    }
+    const raw = resultText.trim() || assistantText.trim();
+    if (!raw) {
+        throw new Error(`Run-sheet agent produced no output${error ? ` (${error})` : ''}`);
+    }
+    return {
+        content: stripWrappingFence(raw),
+        turns,
+        model: DEFAULT_MODEL,
+        subtype,
+        error,
+    };
+}

package/dist/phases/run-sheet/index.d.ts

@@ -3,13 +3,15 @@
  *
  * Given a release, fetches the product's `run_sheet_template`, clones the
  * repo at the release tag (reusing the workspace layout used by
- * smoke-test), renders placeholders, and upserts the result to the
- * `run_sheets` table.
+ * smoke-test), and hands the template + repo to the Claude Agent SDK
+ * which reads the diff and produces the run sheet Markdown. The result
+ * is upserted to the `run_sheets` table.
  *
  * Release tags are immutable, so if an existing run sheet has the same
  * template_snapshot + tag and no clone error, we short-circuit without
  * re-cloning. Pass `{ force: true }` to regenerate anyway.
  */
+import { type RunSheet } from '../../api/run-sheets.js';
 export interface RunSheetOptions {
     releaseId: string;
     force?: boolean;
@@ -21,11 +23,10 @@ export interface RunSheetResult {
     releaseTag?: string;
     summary: string;
     runSheetId?: string;
-    missingPlaceholders?: string[];
     cloneError?: string | null;
-    commitsError?: string | null;
-    commitsTruncated?: boolean;
     isDraft?: boolean;
+    agentTurns?: number;
+    model?: string;
 }
 /**
  * Atomic-create a `.lock` file alongside the workspace dir. Returns
@@ -51,4 +52,6 @@ export declare function releaseFileLock(lockPath: string): void;
 export declare function pruneStaleRunSheetWorkspaces(workspaceRoot: string, now?: number, maxAgeMs?: number): {
     removed: string[];
 };
+/** Exported for unit tests; not part of the public CLI surface. */
+export declare function runSheetIsFresh(existing: RunSheet | null, template: string, tag: string): boolean;
 export declare function runRunSheet(options: RunSheetOptions): Promise<RunSheetResult>;

package/dist/phases/run-sheet/index.js

@@ -3,14 +3,14 @@
  *
  * Given a release, fetches the product's `run_sheet_template`, clones the
  * repo at the release tag (reusing the workspace layout used by
- * smoke-test), renders placeholders, and upserts the result to the
- * `run_sheets` table.
+ * smoke-test), and hands the template + repo to the Claude Agent SDK
+ * which reads the diff and produces the run sheet Markdown. The result
+ * is upserted to the `run_sheets` table.
  *
  * Release tags are immutable, so if an existing run sheet has the same
  * template_snapshot + tag and no clone error, we short-circuit without
  * re-cloning. Pass `{ force: true }` to regenerate anyway.
  */
-import { createHash } from 'crypto';
 import { closeSync, mkdirSync, openSync, readdirSync, readFileSync, rmSync, statSync, unlinkSync, writeFileSync, } from 'fs';
 import { join } from 'path';
 import { getGitHubConfigByProduct } from '../../api/github.js';
@@ -18,36 +18,9 @@ import { getProduct } from '../../api/products.js';
 import { getRelease } from '../../api/releases.js';
 import { getRunSheetByRelease, upsertRunSheet, } from '../../api/run-sheets.js';
 import { logError, logInfo, logSuccess, logWarning, } from '../../utils/logger.js';
-import { cloneFeatureRepo, ensureWorkspaceDir, getFeatureRepoPath, syncRepoToRef, } from '../../workspace/workspace-manager.js';
-import { fetchAllCompareCommits, getDefaultBranchHead, } from '../release-sync/github.js';
-import { isSafeGitRef, renderTemplate } from './render.js';
-async function fetchCommitsBetween(owner, repo, base, head, token) {
-    if (!base) {
-        return { text: '', list: [], truncated: false };
-    }
-    try {
-        const { commits, truncated } = await fetchAllCompareCommits(owner, repo, base, head, token);
-        const list = commits.map((c) => {
-            const message = c.commit.message ?? '';
-            const summary = message.split('\n')[0];
-            return {
-                sha: c.sha,
-                short_sha: c.sha.slice(0, 7),
-                summary,
-                message,
-                author: c.commit.author?.name ?? '',
-                url: c.html_url ?? '',
-            };
-        });
-        const text = list.map((c) => `- ${c.short_sha} ${c.summary}`).join('\n');
-        return { text, list, truncated };
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        logWarning(`Could not fetch commits for run sheet: ${message}`);
-        return { text: '', list: [], truncated: false, error: message };
-    }
-}
+import { cloneFeatureRepo, ensureWorkspaceDir, getFeatureRepoPath, isSafeGitRef, syncRepoToRef, } from '../../workspace/workspace-manager.js';
+import { getDefaultBranchHead } from '../release-sync/github.js';
+import { generateRunSheetWithAgent } from './agent.js';
 // Stale locks (e.g. left behind by a crashed or SIGKILLed CLI) are
 // considered abandoned after this many ms.
 const LOCK_STALE_MS = 15 * 60 * 1000;
@@ -194,18 +167,8 @@ export function pruneStaleRunSheetWorkspaces(workspaceRoot, now = Date.now(), ma
     }
     return { removed };
 }
-function computeInputHash(parts) {
-    const h = createHash('sha256');
-    h.update(`template:${parts.template}\n`);
-    h.update(`tag:${parts.tag}\n`);
-    h.update(`prev:${parts.previousTag ?? ''}\n`);
-    for (const f of [...parts.filesRead].sort((a, b) => a.path.localeCompare(b.path))) {
-        h.update(`file:${f.path}:${f.bytes}\n`);
-    }
-    h.update(`commits:${parts.commitShas.join(',')}\n`);
-    return h.digest('hex');
-}
-function runSheetIsFresh(existing, template, tag) {
+/** Exported for unit tests; not part of the public CLI surface. */
+export function runSheetIsFresh(existing, template, tag) {
     if (!existing || !existing.content) {
         return false;
     }
@@ -219,9 +182,17 @@ function runSheetIsFresh(existing, template, tag) {
     if (meta.clone_error) {
         return false;
     }
+    if (meta.agent_error) {
+        return false;
+    }
+    // Drafts are rendered from the default branch HEAD, which moves. Always
+    // regenerate so the agent sees current code.
+    if (meta.is_draft) {
+        return false;
+    }
     return true;
 }
-// eslint-disable-next-line complexity -- orchestration with cache, clone, lock, render
+// eslint-disable-next-line complexity -- orchestration with cache, clone, lock, agent
 export async function runRunSheet(options) {
     const { releaseId, force, verbose } = options;
     let release;
@@ -255,7 +226,7 @@ export async function runRunSheet(options) {
             summary: 'Product has no run_sheet_template configured. Set one in product settings.',
         };
     }
-    // Short-circuit cache: identical template + tag, no prior clone error.
+    // Short-circuit cache: identical template + tag, no prior clone / agent error.
     if (!force) {
         const existing = await getRunSheetByRelease(releaseId, verbose).catch(() => null);
         if (existing && runSheetIsFresh(existing, template, release.tag)) {
@@ -266,38 +237,25 @@ export async function runRunSheet(options) {
                 releaseTag: release.tag,
                 runSheetId: existing.id,
                 summary: 'Cached (no change since last render)',
-                missingPlaceholders: existing.metadata?.missing_placeholders ?? [],
                 cloneError: null,
-                commitsTruncated: Boolean(existing.metadata?.commits_truncated),
             };
         }
     }
     const gh = await getGitHubConfigByProduct(release.product_id, verbose);
     const repoConfigured = gh.configured && gh.token && gh.owner && gh.repo;
-    // Clone at tag + fetch commits (both best-effort — we still render with
-    // whatever metadata we have).
     let repoDir = null;
     let cloneError = null;
-    let commitsError = null;
-    let commits = '';
-    let commitsList = [];
-    let commitsTruncated = false;
     let lockPath = null;
     // Draft mode: the release's tag doesn't exist on GitHub yet (e.g. a
     // Maven SNAPSHOT being planned pre-cut). We still want to produce a
-    // useful run sheet, so we fall back to the default branch HEAD for
-    // both the checkout and the commits compare.
+    // useful run sheet, so we fall back to the default branch HEAD.
     let isDraft = false;
     let draftBaseRef = null;
     if (repoConfigured && gh.owner && gh.repo && gh.token) {
         const { owner, repo, token } = gh;
         // Serialise concurrent CLI invocations for the *same release* by
-        // taking a file lock next to the clone dir. Different releases get
-        // different lock files (per-release workspace).
+        // taking a file lock next to the clone dir.
         const workspaceRoot = ensureWorkspaceDir();
-        // Sweep old per-release workspaces before cloning. Cheap (one
-        // readdir + stat per entry); silent unless something is actually
-        // removed.
         const pruned = pruneStaleRunSheetWorkspaces(workspaceRoot);
         if (pruned.removed.length > 0) {
             logInfo(`Pruned ${pruned.removed.length} stale run-sheet workspace(s).`);
@@ -314,86 +272,90 @@ export async function runRunSheet(options) {
             };
         }
         try {
-            // Clone into a per-release directory so two releases of the same
-            // product don't stomp each other's checkout during concurrent
-            // generation. (smoke-test uses `release-${product_id}` — that races;
-            // we don't want to inherit that bug here.)
             const { repoPath } = cloneFeatureRepo(workspaceRoot, workspaceName, owner, repo, token);
             repoDir = repoPath;
-            try {
-                syncRepoToRef(repoPath, { tag: release.tag }, token);
-            }
-            catch (err) {
-                const tagErr = err instanceof Error ? err.message : String(err);
-                logWarning(`Tag ${release.tag} not found — generating draft run sheet from default branch.`);
+            // SNAPSHOT releases have no GitHub release object backing them, so
+            // `published_at` is null. Use that as a free local signal to skip
+            // the tag-checkout entirely.
+            const expectDraft = release.published_at === null;
+            if (expectDraft) {
+                logInfo(`Tag ${release.tag} not yet cut (no published_at) — generating draft run sheet from default branch.`);
                 try {
                     const { branch } = await getDefaultBranchHead(owner, repo, token);
                     syncRepoToRef(repoPath, { branch }, token);
                     isDraft = true;
                     draftBaseRef = branch;
-                    cloneError = `Tag ${release.tag} not found; fell back to default branch ${branch}. (${tagErr})`;
                 }
                 catch (fallbackErr) {
-                    cloneError = `Could not checkout tag ${release.tag} or fall back to default branch: ${fallbackErr instanceof Error ? fallbackErr.message : String(fallbackErr)}`;
+                    cloneError = `Could not check out default branch for draft run sheet: ${fallbackErr instanceof Error ? fallbackErr.message : String(fallbackErr)}`;
                     logWarning(cloneError);
                 }
             }
+            else {
+                try {
+                    syncRepoToRef(repoPath, { tag: release.tag }, token);
+                }
+                catch (err) {
+                    const tagErr = err instanceof Error ? err.message : String(err);
+                    logWarning(`Tag ${release.tag} checkout failed — falling back to default branch.`);
+                    try {
+                        const { branch } = await getDefaultBranchHead(owner, repo, token);
+                        syncRepoToRef(repoPath, { branch }, token);
+                        isDraft = true;
+                        draftBaseRef = branch;
+                        cloneError = `Tag ${release.tag} could not be checked out; fell back to default branch ${branch}. (${tagErr})`;
+                    }
+                    catch (fallbackErr) {
+                        cloneError = `Could not checkout tag ${release.tag} or fall back to default branch: ${fallbackErr instanceof Error ? fallbackErr.message : String(fallbackErr)}`;
+                        logWarning(cloneError);
+                    }
+                }
+            }
         }
         catch (err) {
             cloneError = err instanceof Error ? err.message : String(err);
             logWarning(`Clone failed: ${cloneError}`);
         }
-        const head = isDraft && draftBaseRef ? draftBaseRef : release.tag;
-        const c = await fetchCommitsBetween(owner, repo, release.previous_tag, head, token);
-        commits = c.text;
-        commitsList = c.list;
-        commitsTruncated = c.truncated;
-        commitsError = c.error ?? null;
     }
     else {
         cloneError = 'Product is not linked to a GitHub repository';
     }
-    const draftNotice = isDraft
-        ? `> ⚠️ **Draft run sheet** — tag \`${release.tag}\` does not exist on GitHub yet. Rendered from default branch${draftBaseRef ? ` \`${draftBaseRef}\`` : ''}; regenerate after the tag is cut for final content.`
-        : '';
-    const { rendered, missing, filesRead } = await renderTemplate(template, {
-        name: product?.name ?? 'Unknown product',
-        github_repository_full_name: product?.github_repository_full_name ?? null,
-    }, {
-        tag: release.tag,
-        name: release.name,
-        body: release.body,
-        url: release.url,
-        published_at: release.published_at,
-        previous_tag: release.previous_tag,
-        previous_published_at: release.previous_published_at,
-        diff_summary: release.diff_summary,
-        diff_stats: release.diff_stats ?? {},
-    }, repoDir, commits, draftNotice, commitsList);
-    const inputHash = computeInputHash({
-        template,
-        tag: release.tag,
-        previousTag: release.previous_tag,
-        filesRead,
-        commitShas: commitsList.map((c) => c.sha),
-    });
     try {
+        const agentResult = await generateRunSheetWithAgent({
+            product: {
+                name: product?.name ?? 'Unknown product',
+                github_repository_full_name: product?.github_repository_full_name ?? null,
+            },
+            release: {
+                tag: release.tag,
+                name: release.name,
+                body: release.body,
+                url: release.url,
+                published_at: release.published_at,
+                previous_tag: release.previous_tag,
+                previous_published_at: release.previous_published_at,
+            },
+            template,
+            repoDir,
+            isDraft,
+            draftBaseRef,
+            verbose,
+        });
         const saved = await upsertRunSheet({
             release_id: release.id,
-            content: rendered,
+            content: agentResult.content,
             title: `Run Sheet — ${product?.name ?? ''} ${release.tag}`.trim(),
             template_snapshot: template,
             metadata: {
-                missing_placeholders: missing,
                 clone_error: cloneError,
-                commits_error: commitsError,
                 repo: product?.github_repository_full_name ?? null,
                 tag: release.tag,
-                commits_truncated: commitsTruncated,
                 is_draft: isDraft,
                 draft_base_ref: draftBaseRef,
-                input_hash: inputHash,
-                commits_count: commitsList.length,
+                model: agentResult.model,
+                agent_turns: agentResult.turns,
+                agent_subtype: agentResult.subtype,
+                agent_error: agentResult.error,
             },
             generated_at: new Date().toISOString(),
         }, verbose);
@@ -403,22 +365,21 @@ export async function runRunSheet(options) {
             releaseId: release.id,
             releaseTag: release.tag,
             runSheetId: saved.id,
-            summary: `Rendered ${rendered.length} characters`,
-            missingPlaceholders: missing,
+            summary: `Rendered ${agentResult.content.length} characters (${agentResult.turns} agent turn(s))`,
             cloneError,
-            commitsError,
-            commitsTruncated,
             isDraft,
+            agentTurns: agentResult.turns,
+            model: agentResult.model,
         };
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);
-        logError(`Failed to upsert run sheet: ${message}`);
+        logError(`Run-sheet generation failed: ${message}`);
         return {
             status: 'error',
             releaseId: release.id,
             releaseTag: release.tag,
-            summary: `Failed to upsert run sheet: ${message}`,
+            summary: `Run-sheet generation failed: ${message}`,
         };
     }
     finally {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "edsger",
-  "version": "0.48.0",
+  "version": "0.49.0",
   "type": "module",
   "bin": {
     "edsger": "dist/index.js"