delimit-cli 4.1.53 → 4.3.0

package/gateway/ai/workers/outreach_drafter.py

@@ -0,0 +1,161 @@
+"""Outreach-drafter worker (LED-976).
+
+Takes an audit-program target from the signal corpus or ledger,
+runs delimit_lint against the target's spec if available, and drafts
+a GitHub issue body per the AUDIT_PROGRAM.md template. Cannot post —
+produces a work-order for founder approval.
+
+Bounded to: delimit_lint, delimit_diff, delimit_sense, read_file.
+Cannot: write files, post issues, commit, push.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any, Dict
+
+from ai.workers.base import Worker, WorkerResult
+from ai.work_order import create_work_order
+
+
+class OutreachDrafterWorker(Worker):
+    worker_type = "outreach_drafter"
+    description = "Drafts governance-outreach GitHub issues"
+
+    def execute(self, ledger_item: Dict[str, Any]) -> WorkerResult:
+        item_id = ledger_item.get("id", "?")
+        title = ledger_item.get("title", "")
+        context = ledger_item.get("context", "")
+        description = ledger_item.get("description", "")
+
+        # Extract repo info
+        import re
+        repo = ""
+        for field in [context, description, title]:
+            match = re.search(r'([\w.-]+/[\w.-]+)', field)
+            if match and "/" in match.group(1):
+                candidate = match.group(1)
+                # Skip our own repos
+                if not candidate.startswith("delimit-ai/"):
+                    repo = candidate
+                    break
+
+        if not repo:
+            return WorkerResult(
+                worker_type=self.worker_type,
+                ledger_item_id=item_id,
+                success=False,
+                error="Could not extract target repo from ledger item",
+            )
+
+        # Draft the issue body per AUDIT_PROGRAM.md template
+        issue_title = f"Suggestion: CI check for API schema drift"
+        issue_body = f"""## Context
+
+This repo maintains an API specification that downstream consumers depend on.
+Breaking changes in API contracts (endpoint removal, type changes, required
+parameter additions) can cause silent integration failures for consumers.
+
+## Suggestion
+
+Add an advisory CI check that diffs the base branch spec against PRs.
+A single workflow file:
+
+```yaml
+name: API Schema Check
+on:
+  pull_request:
+    paths:
+      - 'api/**'
+      - '*.yaml'
+      - '*.json'
+permissions:
+  contents: read
+  pull-requests: write
+jobs:
+  check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - uses: delimit-ai/delimit-action@v1
+        with:
+          spec: openapi.yaml
+```
+
+This diffs the base branch spec against the PR and posts a comment
+identifying breaking vs non-breaking changes with semver classification.
+Advisory only — never blocks merges. Teams can upgrade to enforcement later.
+
+## What it catches
+
+| DGF Control | Detection | Severity |
+|---|---|---|
+| DGF-BC-001 | Endpoint removal | High |
+| DGF-BC-002 | Required parameter added | High |
+| DGF-BC-003 | Required response field removed | High |
+| DGF-BC-004 | Type changed | High |
+| DGF-BC-005 | Enum value removed | High |
+| + 10 more | See [DGF v0.1.0](https://github.com/delimit-ai/governance-framework) | — |
+
+Zero config, no API keys, runs in under 30 seconds.
+[Live demo](https://github.com/delimit-ai/delimit-action-demo/pull/2).
+
+Happy to open a PR if there's interest.
+"""
+
+        # Emit a structured action the executor can run after founder
+        # approval. Keeps the human steps above for readability; the
+        # executor uses this typed list to actually post the issue.
+        executable = [
+            {
+                "action": "gh_issue_create",
+                "params": {
+                    "repo": repo,
+                    "title": issue_title,
+                    "body": issue_body.strip(),
+                },
+            }
+        ]
+
+        # Create the work order
+        wo = create_work_order(
+            title=f"Outreach: Open governance issue on {repo}",
+            goal=f"Open a GitHub issue on {repo} suggesting API schema CI check",
+            context=f"Source: {item_id}. Per AUDIT_PROGRAM.md playbook. Must pass pre-outreach capability-test gate: run delimit lint against the target's spec before claiming detection.",
+            steps=[
+                f"Verify {repo} has a checked-in API spec (search for openapi.yaml, swagger.yaml, api.json, schema.json)",
+                f"Run: delimit lint <old_spec> <new_spec> on a recent PR that changed the spec (proves the tool works on their spec)",
+                f"If lint works, open the issue:",
+                f"```",
+                f"gh issue create --repo {repo} \\",
+                f"  --title '{issue_title}' \\",
+                f"  --body-file /dev/stdin <<'BODY'",
+                issue_body.strip(),
+                "BODY",
+                f"```",
+                "Wait for maintainer response (do NOT open a PR immediately)",
+            ],
+            acceptance_criteria=[
+                f"Pre-outreach capability test passes (delimit lint works on {repo}'s spec)",
+                f"Issue opened on {repo} matching AUDIT_PROGRAM.md format",
+                "No capability claims the tool can't back",
+                "Staggered timing (not batch-submitted with other issues)",
+            ],
+            ledger_item_id=item_id,
+            priority=ledger_item.get("priority", "P1"),
+            tools_needed=["gh", "delimit"],
+            estimated_minutes=20,
+            worker_type=self.worker_type,
+            executable_actions=executable,
+        )
+
+        return WorkerResult(
+            worker_type=self.worker_type,
+            ledger_item_id=item_id,
+            success=True,
+            artifact_path=wo.get("filepath", ""),
+            artifact_preview=wo.get("preview", "")[:300],
+            work_order_id=wo.get("id", ""),
+        )

package/gateway/ai/workers/pr_drafter.py

@@ -0,0 +1,148 @@
+"""PR-drafter worker (LED-975).
+
+Takes a ledger item describing an outreach target (repo with checked-in
+spec) and produces a draft PR body + workflow YAML as a work-order
+artifact the founder can copy-paste into a gh pr create command.
+
+Bounded to: delimit_lint, delimit_diff, delimit_spec_health, read_file.
+Cannot: write files, commit, push, post comments.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any, Dict
+
+from ai.workers.base import Worker, WorkerResult
+from ai.work_order import create_work_order
+
+
+class PRDrafterWorker(Worker):
+    worker_type = "pr_drafter"
+    description = "Drafts PR bodies for governance check workflows"
+
+    def execute(self, ledger_item: Dict[str, Any]) -> WorkerResult:
+        item_id = ledger_item.get("id", "?")
+        title = ledger_item.get("title", "")
+        context = ledger_item.get("context", "")
+        description = ledger_item.get("description", "")
+
+        # Extract repo info from the ledger item
+        repo = ""
+        spec_path = ""
+        for field in [context, description, title]:
+            # Look for owner/repo pattern
+            import re
+            match = re.search(r'([\w.-]+/[\w.-]+)', field)
+            if match and "/" in match.group(1):
+                repo = match.group(1)
+                break
+
+        if not repo:
+            return WorkerResult(
+                worker_type=self.worker_type,
+                ledger_item_id=item_id,
+                success=False,
+                error="Could not extract repo from ledger item",
+            )
+
+        # Try to detect the spec path
+        common_spec_paths = [
+            "api/openapi.yaml",
+            "api/openapi.yml",
+            "api/swagger.yaml",
+            "api/swagger.yml",
+            "openapi.yaml",
+            "openapi.yml",
+            "swagger.yaml",
+            "swagger.yml",
+            "api/v2.0/swagger.yaml",
+            "schema.json",
+            "api.json",
+        ]
+        spec_path = common_spec_paths[0]  # default, will be refined
+
+        # Generate the workflow YAML
+        workflow_yaml = f"""name: API Schema Check
+on:
+  pull_request:
+    paths:
+      - '{spec_path.rsplit("/", 1)[0] if "/" in spec_path else "."}/**'
+permissions:
+  contents: read
+  pull-requests: write
+jobs:
+  check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - uses: delimit-ai/delimit-action@v1
+        with:
+          spec: {spec_path}
+"""
+
+        # Generate the PR body
+        pr_body = f"""## Summary
+
+Add an API schema drift check for `{spec_path}`. Advisory only — never blocks merges.
+
+The action diffs the base branch spec against the PR and posts a comment identifying breaking vs non-breaking changes with semver classification. Detects 27 change types including endpoint removal, type changes, required parameter additions, and enum value removals.
+
+## Changes
+
+- Add `.github/workflows/api-schema-check.yml`
+
+## Details
+
+- Scoped to `{spec_path.rsplit("/", 1)[0] if "/" in spec_path else "."}/**` — only runs on PRs that modify the spec
+- Zero config, no API keys, runs in under 30 seconds
+- [Live demo](https://github.com/delimit-ai/delimit-action-demo/pull/2) showing 23 breaking changes detected
+
+## References
+
+- [Delimit Governance Framework (DGF)](https://github.com/delimit-ai/governance-framework) — 15 citeable controls
+- [Delimit Action on Marketplace](https://github.com/marketplace/actions/delimit-api-governance)
+"""
+
+        # Create the work order
+        wo = create_work_order(
+            title=f"PR: Add governance check to {repo}",
+            goal=f"Open a PR on {repo} adding .github/workflows/api-schema-check.yml scoped to {spec_path}",
+            context=f"Source ledger item: {item_id}. Target: {repo}.",
+            steps=[
+                f"Fork {repo} (if not already forked)",
+                f"Create branch: add-api-schema-check",
+                f"Add file .github/workflows/api-schema-check.yml with content below",
+                "```yaml",
+                workflow_yaml.strip(),
+                "```",
+                f"Commit with: git commit -s -m 'ci: add API schema drift check for {spec_path}'",
+                f"Push and open PR with body below",
+                "```",
+                pr_body.strip(),
+                "```",
+                f"Or one-liner: gh pr create --title 'ci: add API schema drift check' --body-file <(cat <<'BODY'\n{pr_body.strip()}\nBODY\n)",
+            ],
+            acceptance_criteria=[
+                f"PR opened on {repo}",
+                "Workflow file is advisory-only (never blocks merges)",
+                "DCO sign-off included",
+                "Maintainer response within 7 days",
+            ],
+            ledger_item_id=item_id,
+            priority=ledger_item.get("priority", "P1"),
+            tools_needed=["gh", "git"],
+            estimated_minutes=15,
+            worker_type=self.worker_type,
+        )
+
+        return WorkerResult(
+            worker_type=self.worker_type,
+            ledger_item_id=item_id,
+            success=True,
+            artifact_path=wo.get("filepath", ""),
+            artifact_preview=wo.get("preview", "")[:300],
+            work_order_id=wo.get("id", ""),
+        )

package/lib/ai-sbom-engine.js

@@ -0,0 +1,154 @@
+// lib/ai-sbom-engine.js
+//
+// LED-1018 Venture #6 MVP: `delimit ai-sbom` aggregation.
+// Scans a directory of attestations, extracts the AI surface (models, prompts,
+// tool calls, data classes), and emits a CycloneDX 1.6-shaped bill of materials
+// with AI-specific fields.
+//
+// CycloneDX-AI schema reference: https://cyclonedx.org/capabilities/mlbom/
+// Per the architecture doc, MVP aggregates what attestations already capture;
+// explicit static-analysis code-walker lands in Phase 2.
+
+const { loadAttestations } = require('./trust-page-engine');
+const crypto = require('crypto');
+
+const KNOWN_MODEL_PROVIDERS = [
+    // Loose matching against wrapped_command strings. Extends easily.
+    { pattern: /claude|anthropic/i, vendor: 'anthropic', family: 'claude' },
+    { pattern: /openai|gpt-\d|o1|o3/i, vendor: 'openai', family: 'gpt' },
+    { pattern: /gemini|vertex/i, vendor: 'google', family: 'gemini' },
+    { pattern: /codex/i, vendor: 'openai', family: 'codex' },
+    { pattern: /grok|xai/i, vendor: 'xai', family: 'grok' },
+    { pattern: /llama|mistral/i, vendor: 'meta-or-mistral', family: 'open-weight' },
+    { pattern: /cursor/i, vendor: 'cursor', family: 'cursor-agent' },
+    { pattern: /aider/i, vendor: 'aider', family: 'aider-agent' },
+    { pattern: /copilot/i, vendor: 'github', family: 'copilot' },
+];
+
+function detectModelFromCommand(cmd) {
+    if (!cmd) return null;
+    for (const m of KNOWN_MODEL_PROVIDERS) {
+        if (m.pattern.test(cmd)) return { vendor: m.vendor, family: m.family };
+    }
+    return null;
+}
+
+function aggregateAISurface(attestations) {
+    const models = new Map(); // key: vendor:family -> { count, first_seen, last_seen }
+    const toolCallCounts = new Map(); // tool name -> count
+    const totalAttestations = attestations.length;
+    let earliest = null, latest = null;
+    let totalGatesRun = 0, totalViolations = 0;
+
+    for (const att of attestations) {
+        const b = att.bundle || {};
+
+        // Model detection — prefer explicit ai_surface.models_detected, fall back to command heuristic
+        const explicitModels = (b.ai_surface?.models_detected) || [];
+        for (const m of explicitModels) {
+            const key = m.includes(':') ? m : `unknown:${m}`;
+            const [vendor, family] = key.split(':', 2);
+            const entry = models.get(key) || { vendor, family, count: 0, first_seen: null, last_seen: null };
+            entry.count += 1;
+            if (b.started_at) {
+                if (!entry.first_seen || b.started_at < entry.first_seen) entry.first_seen = b.started_at;
+                if (!entry.last_seen || b.started_at > entry.last_seen) entry.last_seen = b.started_at;
+            }
+            models.set(key, entry);
+        }
+        if (explicitModels.length === 0) {
+            const inferred = detectModelFromCommand(b.wrapped_command || '');
+            if (inferred) {
+                const key = `${inferred.vendor}:${inferred.family}`;
+                const entry = models.get(key) || { vendor: inferred.vendor, family: inferred.family, count: 0, first_seen: null, last_seen: null, source: 'inferred' };
+                entry.count += 1;
+                entry.source = 'inferred';
+                if (b.started_at) {
+                    if (!entry.first_seen || b.started_at < entry.first_seen) entry.first_seen = b.started_at;
+                    if (!entry.last_seen || b.started_at > entry.last_seen) entry.last_seen = b.started_at;
+                }
+                models.set(key, entry);
+            }
+        }
+
+        // Tool calls
+        const tools = b.ai_surface?.tool_calls || [];
+        for (const t of tools) toolCallCounts.set(t, (toolCallCounts.get(t) || 0) + 1);
+
+        // Timestamps
+        if (b.started_at) {
+            if (!earliest || b.started_at < earliest) earliest = b.started_at;
+            if (!latest || b.started_at > latest) latest = b.started_at;
+        }
+
+        // Governance counts
+        totalGatesRun += (b.governance?.gates || []).length;
+        totalViolations += (b.governance?.violations || []).length;
+    }
+
+    return {
+        total_attestations: totalAttestations,
+        total_gates_run: totalGatesRun,
+        total_violations: totalViolations,
+        models: Array.from(models.values()),
+        tool_calls: Array.from(toolCallCounts.entries()).map(([name, count]) => ({ name, count })),
+        earliest,
+        latest,
+    };
+}
+
+function renderCycloneDXAI(aggregate, { name = 'ai-sbom', version = '1.0.0' } = {}) {
+    const serialNumber = 'urn:uuid:' + crypto.randomUUID();
+
+    return {
+        bomFormat: 'CycloneDX',
+        specVersion: '1.6',
+        serialNumber,
+        version: 1,
+        metadata: {
+            timestamp: new Date().toISOString(),
+            tools: [{ vendor: 'delimit', name: 'delimit-ai-sbom', version }],
+            component: {
+                'bom-ref': `pkg:${name}@${version}`,
+                type: 'application',
+                name,
+                version,
+            },
+            properties: [
+                { name: 'delimit:total_attestations', value: String(aggregate.total_attestations) },
+                { name: 'delimit:total_gates_run', value: String(aggregate.total_gates_run) },
+                { name: 'delimit:total_violations', value: String(aggregate.total_violations) },
+                { name: 'delimit:earliest_attestation', value: aggregate.earliest || '' },
+                { name: 'delimit:latest_attestation', value: aggregate.latest || '' },
+                { name: 'delimit:tool_surface', value: JSON.stringify(aggregate.tool_calls) },
+            ],
+        },
+        components: aggregate.models.map(m => ({
+            'bom-ref': `model:${m.vendor}/${m.family}`,
+            type: 'machine-learning-model',
+            vendor: m.vendor,
+            name: m.family,
+            description: `AI model detected across ${m.count} attestations${m.source ? ` (${m.source} from command)` : ''}`,
+            modelCard: {
+                modelParameters: {
+                    approach: { type: 'supervised' },
+                },
+                properties: [
+                    { name: 'delimit:usage_count', value: String(m.count) },
+                    { name: 'delimit:first_seen', value: m.first_seen || '' },
+                    { name: 'delimit:last_seen', value: m.last_seen || '' },
+                    ...(m.source ? [{ name: 'delimit:detection_source', value: m.source }] : []),
+                ],
+            },
+        })),
+    };
+}
+
+function buildAISBOM(attestationDir, opts = {}) {
+    const attestations = loadAttestations(attestationDir);
+    const aggregate = aggregateAISurface(attestations);
+    const sbom = renderCycloneDXAI(aggregate, opts);
+    return { sbom, aggregate, attestation_count: attestations.length };
+}
+
+module.exports = { buildAISBOM, aggregateAISurface, renderCycloneDXAI, detectModelFromCommand };

package/lib/trust-page-engine.js

@@ -0,0 +1,179 @@
+// lib/trust-page-engine.js
+//
+// LED-1018 Venture #6 MVP: `delimit trust-page` render.
+// Scans a directory of delimit.attestation.v1 JSON files, verifies signatures,
+// renders a static index.html + JSON Feed 1.1-shaped feed.json.
+//
+// Local-only render. Cloud sync is a Pro/Premium feature, deferred.
+
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+function loadHmacKey() {
+    const keyPath = path.join(os.homedir(), '.delimit', 'wrap-hmac.key');
+    if (!fs.existsSync(keyPath)) return null;
+    return fs.readFileSync(keyPath);
+}
+
+function verifySignature(attestation, key) {
+    if (!key) return 'unverifiable';
+    try {
+        const canonical = JSON.stringify(attestation.bundle, Object.keys(attestation.bundle).sort());
+        const expected = crypto.createHmac('sha256', key).update(canonical).digest('hex');
+        return expected === attestation.signature ? 'verified' : 'signature_mismatch';
+    } catch {
+        return 'verify_error';
+    }
+}
+
+function loadAttestations(dir) {
+    if (!fs.existsSync(dir)) return [];
+    const results = [];
+    for (const f of fs.readdirSync(dir)) {
+        if (!f.startsWith('att_') || !f.endsWith('.json')) continue;
+        try {
+            const att = JSON.parse(fs.readFileSync(path.join(dir, f), 'utf-8'));
+            if (att.id && att.bundle) results.push(att);
+        } catch { /* skip corrupted */ }
+    }
+    // Reverse-chronological
+    results.sort((a, b) => {
+        const ta = a.bundle?.started_at || '';
+        const tb = b.bundle?.started_at || '';
+        return tb.localeCompare(ta);
+    });
+    return results;
+}
+
+function escapeHtml(s) {
+    return String(s || '').replace(/[&<>"']/g, c => ({
+        '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;'
+    }[c]));
+}
+
+function redactCommand(cmd, redactLevel = 'basic') {
+    // MVP: basic redaction only. Strip quoted strings longer than 24 chars (likely prompt text).
+    if (!cmd) return '';
+    if (redactLevel === 'none') return cmd;
+    return cmd.replace(/"[^"]{24,}"/g, '"<prompt redacted>"')
+              .replace(/'[^']{24,}'/g, "'<prompt redacted>'");
+}
+
+function countGateResults(governance) {
+    const gates = governance?.gates || [];
+    let pass = 0, fail = 0, info = 0;
+    for (const g of gates) {
+        if (g.exit === 0) pass++;
+        else if (g.exit !== undefined) fail++;
+        else info++;
+    }
+    return { pass, fail, info, total: gates.length };
+}
+
+function renderHTML(attestations, title = 'Trust Page') {
+    const hmacKey = loadHmacKey();
+    const rows = attestations.map(att => {
+        const verify = verifySignature(att, hmacKey);
+        const b = att.bundle || {};
+        const counts = countGateResults(b.governance);
+        const violations = (b.governance?.violations || []).length;
+        const status = violations > 0 ? 'violations' : (counts.fail > 0 ? 'failures' : 'clean');
+        return `    <tr>
+      <td><code>${escapeHtml(att.id)}</code></td>
+      <td class="cmd">${escapeHtml(redactCommand(b.wrapped_command))}</td>
+      <td>${escapeHtml(b.started_at || '')}</td>
+      <td class="gates">${counts.pass}/${counts.total}</td>
+      <td class="v-${verify}">${verify.replace('_', ' ')}</td>
+      <td class="s-${status}">${status}</td>
+    </tr>`;
+    }).join('\n');
+
+    const empty = attestations.length === 0
+        ? `  <p class="empty">No attestations yet. Run <code>delimit wrap &lt;cmd&gt;</code> to create one.</p>`
+        : '';
+
+    return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width,initial-scale=1">
+<title>${escapeHtml(title)}</title>
+<style>
+  :root { color-scheme: light dark; --fg:#111; --bg:#fff; --muted:#666; --ok:#087443; --warn:#b45309; --err:#b91c1c; }
+  @media (prefers-color-scheme: dark) { :root { --fg:#eee; --bg:#0a0a0a; --muted:#888; } }
+  body { font: 14px/1.5 -apple-system, BlinkMacSystemFont, system-ui, sans-serif; color: var(--fg); background: var(--bg); max-width: 980px; margin: 2rem auto; padding: 0 1rem; }
+  h1 { margin-bottom: .25rem; font-weight: 600; }
+  .sub { color: var(--muted); margin-bottom: 2rem; }
+  table { width: 100%; border-collapse: collapse; }
+  th, td { text-align: left; padding: .5rem .75rem; border-bottom: 1px solid rgba(0,0,0,.08); }
+  th { font-weight: 600; color: var(--muted); font-size: .82em; text-transform: uppercase; letter-spacing: .03em; }
+  code { font: 12px/1.3 ui-monospace, SFMono-Regular, Menlo, monospace; }
+  td.cmd { max-width: 380px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+  .gates { font-variant-numeric: tabular-nums; color: var(--muted); }
+  .v-verified { color: var(--ok); }
+  .v-unverifiable, .v-signature_mismatch { color: var(--warn); }
+  .s-clean { color: var(--ok); }
+  .s-violations, .s-failures { color: var(--err); }
+  .empty { color: var(--muted); padding: 3rem 0; text-align: center; }
+  footer { margin-top: 3rem; color: var(--muted); font-size: .85em; }
+</style>
+</head>
+<body>
+  <h1>${escapeHtml(title)}</h1>
+  <p class="sub">${attestations.length} signed attestation${attestations.length === 1 ? '' : 's'} · generated ${new Date().toISOString()}</p>
+${empty || `  <table>
+    <thead><tr><th>ID</th><th>Command</th><th>Started</th><th>Gates</th><th>Signature</th><th>Status</th></tr></thead>
+    <tbody>
+${rows}
+    </tbody>
+  </table>`}
+  <footer>
+    Generated by <code>delimit trust-page</code>. <a href="feed.json">JSON Feed</a>.<br>
+    Each row is an <code>att_*</code> record signed with HMAC-SHA256. Schema: <code>delimit.attestation.v1</code>.
+  </footer>
+</body>
+</html>
+`;
+}
+
+function renderFeed(attestations, title = 'Trust Page') {
+    const items = attestations.map(att => {
+        const b = att.bundle || {};
+        const verify = verifySignature(att, loadHmacKey());
+        return {
+            id: att.id,
+            title: redactCommand(b.wrapped_command || att.id),
+            content_text: `wrapped=${b.wrapped_command || ''} | exit=${b.wrapped_exit} | gates=${(b.governance?.gates || []).length} | violations=${(b.governance?.violations || []).length} | signature=${verify}`,
+            date_published: b.started_at,
+            _delimit: {
+                attestation_id: att.id,
+                signature: att.signature,
+                signature_alg: att.signature_alg,
+                wrapped_exit: b.wrapped_exit,
+                changed_files: b.changed_files,
+                governance: b.governance,
+                ai_surface: b.ai_surface || null,
+            }
+        };
+    });
+    return {
+        version: 'https://jsonfeed.org/version/1.1',
+        title,
+        description: 'Signed replayable attestations for AI-assisted merges. Schema: delimit.attestation.v1.',
+        items,
+    };
+}
+
+function renderTrustPage(attestationDir, outDir, title) {
+    const attestations = loadAttestations(attestationDir);
+    fs.mkdirSync(outDir, { recursive: true });
+    const html = renderHTML(attestations, title);
+    const feed = renderFeed(attestations, title);
+    fs.writeFileSync(path.join(outDir, 'index.html'), html);
+    fs.writeFileSync(path.join(outDir, 'feed.json'), JSON.stringify(feed, null, 2));
+    return { count: attestations.length, outDir, html_bytes: html.length, feed_items: feed.items.length };
+}
+
+module.exports = { renderTrustPage, loadAttestations, verifySignature, renderHTML, renderFeed };