@jinn-network/jinn-layer 0.1.0

package/dist/scripts/scan-skills-registry.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Full skills.sh registry scan (issue #1313 follow-up).
+ *
+ * The registry publishes its complete catalogue via sitemaps
+ * (sitemap-skills-*.xml — ~20k skill pages across ~2.5k source repos).
+ * This script enumerates it, licence-checks every SOURCE repo against the
+ * seed importer's disclosed allowlist, resolves each skill's SKILL.md path
+ * from the repo's git tree, and emits:
+ *
+ *   - candidates.txt   — seed-list lines (owner/repo#path) for every skill
+ *                        whose repo licence passes the import gate
+ *   - scan-report.json — full per-repo results (licence, verdict, skills)
+ *   - a terminal summary (counts by licence / verdict)
+ *
+ * Read-only against GitHub (REST, token from GITHUB_TOKEN or `gh auth
+ * token`). Checkpointed: repo results append to the report file as they
+ * land, and a rerun skips repos already scanned — safe to interrupt.
+ * Publishes nothing; the output is INPUT to `seed plan`, and the human
+ * approval gate on `seed execute` is unchanged.
+ *
+ * Run: cd packages/layer && yarn build && GITHUB_TOKEN=$(gh auth token) \
+ *   node dist/scripts/scan-skills-registry.js [--out <dir>]
+ */
+export {};

package/dist/scripts/scan-skills-registry.js

@@ -0,0 +1,207 @@
+/**
+ * Full skills.sh registry scan (issue #1313 follow-up).
+ *
+ * The registry publishes its complete catalogue via sitemaps
+ * (sitemap-skills-*.xml — ~20k skill pages across ~2.5k source repos).
+ * This script enumerates it, licence-checks every SOURCE repo against the
+ * seed importer's disclosed allowlist, resolves each skill's SKILL.md path
+ * from the repo's git tree, and emits:
+ *
+ *   - candidates.txt   — seed-list lines (owner/repo#path) for every skill
+ *                        whose repo licence passes the import gate
+ *   - scan-report.json — full per-repo results (licence, verdict, skills)
+ *   - a terminal summary (counts by licence / verdict)
+ *
+ * Read-only against GitHub (REST, token from GITHUB_TOKEN or `gh auth
+ * token`). Checkpointed: repo results append to the report file as they
+ * land, and a rerun skips repos already scanned — safe to interrupt.
+ * Publishes nothing; the output is INPUT to `seed plan`, and the human
+ * approval gate on `seed execute` is unchanged.
+ *
+ * Run: cd packages/layer && yarn build && GITHUB_TOKEN=$(gh auth token) \
+ *   node dist/scripts/scan-skills-registry.js [--out <dir>]
+ */
+import { execFileSync } from 'node:child_process';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { parseArgs } from 'node:util';
+import { checkLicence } from '../seed-import/licence.js';
+const SITEMAP_INDEX = 'https://www.skills.sh/sitemap.xml';
+const GITHUB_API = 'https://api.github.com';
+const CONCURRENCY = 8;
+function token() {
+    const env = (process.env['GITHUB_TOKEN'] || '').trim();
+    if (env)
+        return env;
+    try {
+        return execFileSync('gh', ['auth', 'token'], { encoding: 'utf-8' }).trim();
+    }
+    catch {
+        throw new Error('set GITHUB_TOKEN or log in with gh');
+    }
+}
+async function fetchText(url) {
+    const res = await fetch(url, { redirect: 'follow' });
+    if (!res.ok)
+        throw new Error(`${res.status} for ${url}`);
+    return res.text();
+}
+async function github(path, tok) {
+    const res = await fetch(`${GITHUB_API}${path}`, {
+        headers: {
+            accept: 'application/vnd.github+json',
+            'user-agent': 'jinn-harness-layer-registry-scan',
+            authorization: `Bearer ${tok}`,
+        },
+    });
+    if (res.status === 403 || res.status === 429) {
+        const reset = Number(res.headers.get('x-ratelimit-reset') || 0) * 1000;
+        const waitMs = Math.max(5_000, reset - Date.now() + 1_000);
+        console.warn(`[scan] rate limited — waiting ${Math.ceil(waitMs / 1000)}s`);
+        await new Promise((r) => setTimeout(r, waitMs));
+        return github(path, tok);
+    }
+    if (res.status === 404)
+        return null;
+    if (!res.ok)
+        throw new Error(`GitHub ${res.status} for ${path}`);
+    return res.json();
+}
+async function enumerateRegistry() {
+    const index = await fetchText(SITEMAP_INDEX);
+    const sitemaps = [...index.matchAll(/<loc>([^<]+sitemap-skills-[^<]+)<\/loc>/g)].map((m) => m[1]);
+    const byRepo = new Map();
+    for (const sm of sitemaps) {
+        const body = await fetchText(sm);
+        for (const m of body.matchAll(/<loc>https?:\/\/(?:www\.)?skills\.sh\/([^/<]+)\/([^/<]+)\/([^/<]+)<\/loc>/g)) {
+            const [, owner, repo, skill] = m;
+            // Registry lists some non-GitHub sources (e.g. open.feishu.cn slugs) —
+            // owner/repo that are not valid GitHub names get filtered by the 404 path.
+            const key = `${owner}/${repo}`;
+            (byRepo.get(key) ?? byRepo.set(key, new Set()).get(key)).add(decodeURIComponent(skill));
+        }
+    }
+    return byRepo;
+}
+async function scanRepo(repo, skills, tok) {
+    const meta = (await github(`/repos/${repo}`, tok));
+    if (meta === null) {
+        return { repo, licence: null, verdict: 'skip', reason: 'not found on GitHub', resolved: {}, unresolved: [...skills] };
+    }
+    const spdx = meta.license?.spdx_id && meta.license.spdx_id !== 'NOASSERTION' ? meta.license.spdx_id : null;
+    const { verdict, reason } = checkLicence(spdx);
+    const scan = { repo, licence: spdx, verdict, reason, resolved: {}, unresolved: [] };
+    if (verdict !== 'import') {
+        scan.unresolved = [...skills];
+        return scan;
+    }
+    // One tree call resolves every skill's SKILL.md directory.
+    const tree = (await github(`/repos/${repo}/git/trees/${meta.default_branch ?? 'HEAD'}?recursive=1`, tok));
+    const dirs = new Map(); // dir basename → dir path (first wins, shallowest first)
+    const entries = (tree?.tree ?? [])
+        .filter((e) => e.type === 'blob' && e.path.endsWith('/SKILL.md'))
+        .sort((a, b) => a.path.split('/').length - b.path.split('/').length);
+    for (const e of entries) {
+        const dir = e.path.slice(0, -'/SKILL.md'.length);
+        const base = dir.split('/').pop();
+        if (!dirs.has(base))
+            dirs.set(base, dir);
+    }
+    // Root SKILL.md: usable when the registry slug equals the repo name.
+    const hasRootSkillMd = (tree?.tree ?? []).some((e) => e.type === 'blob' && e.path === 'SKILL.md');
+    for (const skill of skills) {
+        const dir = dirs.get(skill);
+        if (dir !== undefined)
+            scan.resolved[skill] = dir;
+        else if (hasRootSkillMd && skill === repo.split('/')[1])
+            scan.resolved[skill] = '';
+        else
+            scan.unresolved.push(skill);
+    }
+    if (tree?.truncated)
+        scan.error = 'git tree truncated — unresolved list may overcount';
+    return scan;
+}
+async function main() {
+    const { values } = parseArgs({
+        options: { out: { type: 'string', default: 'registry-scan' } },
+    });
+    const outDir = values.out;
+    mkdirSync(outDir, { recursive: true });
+    const reportPath = join(outDir, 'scan-report.json');
+    const candidatesPath = join(outDir, 'candidates.txt');
+    const tok = token();
+    console.log('[scan] enumerating registry sitemaps…');
+    const byRepo = await enumerateRegistry();
+    const totalSkills = [...byRepo.values()].reduce((n, s) => n + s.size, 0);
+    console.log(`[scan] ${totalSkills} skills across ${byRepo.size} repos`);
+    // Resume support: skip repos already in the report.
+    const done = new Map();
+    if (existsSync(reportPath)) {
+        for (const row of JSON.parse(readFileSync(reportPath, 'utf-8')))
+            done.set(row.repo, row);
+        console.log(`[scan] resuming — ${done.size} repos already scanned`);
+    }
+    const queue = [...byRepo.entries()].filter(([repo]) => !done.has(repo));
+    const results = [...done.values()];
+    let inFlight = 0;
+    let cursor = 0;
+    let scanned = 0;
+    await new Promise((resolve) => {
+        const pump = () => {
+            if (cursor >= queue.length && inFlight === 0)
+                return resolve();
+            while (inFlight < CONCURRENCY && cursor < queue.length) {
+                const [repo, skills] = queue[cursor];
+                cursor += 1;
+                inFlight += 1;
+                scanRepo(repo, skills, tok)
+                    .catch((err) => ({
+                    repo,
+                    licence: null,
+                    verdict: 'skip',
+                    reason: `scan error: ${err instanceof Error ? err.message : String(err)}`,
+                    resolved: {},
+                    unresolved: [...skills],
+                    error: String(err),
+                }))
+                    .then((scan) => {
+                    results.push(scan);
+                    scanned += 1;
+                    if (scanned % 100 === 0) {
+                        console.log(`[scan] ${scanned}/${queue.length} repos`);
+                        writeFileSync(reportPath, JSON.stringify(results, null, 1));
+                    }
+                    inFlight -= 1;
+                    pump();
+                });
+            }
+        };
+        pump();
+    });
+    writeFileSync(reportPath, JSON.stringify(results, null, 1));
+    const lines = [];
+    for (const scan of results.sort((a, b) => a.repo.localeCompare(b.repo))) {
+        for (const [skill, dir] of Object.entries(scan.resolved).sort()) {
+            lines.push(dir === '' ? scan.repo : `${scan.repo}#${dir}`);
+            void skill;
+        }
+    }
+    writeFileSync(candidatesPath, [...new Set(lines)].join('\n') + '\n');
+    const importRepos = results.filter((r) => r.verdict === 'import');
+    const licences = {};
+    for (const r of importRepos)
+        licences[r.licence ?? '?'] = (licences[r.licence ?? '?'] ?? 0) + 1;
+    const resolvedCount = importRepos.reduce((n, r) => n + Object.keys(r.resolved).length, 0);
+    const unresolvedLicensed = importRepos.reduce((n, r) => n + r.unresolved.length, 0);
+    console.log('[scan] done');
+    console.log(`  repos: ${results.length} scanned · ${importRepos.length} licence-pass`);
+    console.log(`  licences (passing): ${JSON.stringify(licences)}`);
+    console.log(`  skills: ${resolvedCount} resolved SKILL.md paths → ${candidatesPath}`);
+    console.log(`  ${unresolvedLicensed} skills in licensed repos had no resolvable SKILL.md path`);
+    console.log(`  full report: ${reportPath}`);
+}
+main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/dist/seed-import/curated-batch.d.ts

@@ -0,0 +1,36 @@
+import type { SeedEpisode } from './episode-fetch.js';
+export declare const CURATED_SEED_AUDIT_SCHEMA_VERSION: "jinn.curated-seed-audit.v1";
+export interface CuratedSeedRecordAudit {
+    id: string;
+    automatedStatus: 'pass' | 'fail';
+    errors: string[];
+}
+export interface CuratedSeedBatchAudit {
+    schemaVersion: typeof CURATED_SEED_AUDIT_SCHEMA_VERSION;
+    repoSlug: string;
+    probeTerms: string[];
+    requiredRecords: number;
+    recordCount: number;
+    eligibleRecordCount: number;
+    automatedStatus: 'pass' | 'fail';
+    errors: string[];
+    records: CuratedSeedRecordAudit[];
+    humanCurationRequired: true;
+    publishAuthorized: false;
+    liveProbe: {
+        status: 'not-run';
+        command: string;
+    };
+}
+export interface AuditCuratedSeedBatchOptions {
+    repoSlug: string;
+    episodes: SeedEpisode[];
+}
+/**
+ * Audit the automatable portion of a candidate curated seed batch.
+ *
+ * A passing report means only that the records meet the mechanical evidence,
+ * provenance, retrieval, and scrub gates. It deliberately cannot approve the
+ * curation judgment, publish records, or claim that a live corpus probe passed.
+ */
+export declare function auditCuratedSeedBatch({ repoSlug, episodes, }: AuditCuratedSeedBatchOptions): Promise<CuratedSeedBatchAudit>;

package/dist/seed-import/curated-batch.js

@@ -0,0 +1,103 @@
+import { deriveRepositorySearchTerms, hasRetrievalMark } from '@jinn-network/plugin';
+import { CORPUS_ONBOARDING_K } from '../corpus-probes.js';
+import { publishedEpisodeTags, seedEpisodePrivacyRedactionCount, } from './episode-execute.js';
+export const CURATED_SEED_AUDIT_SCHEMA_VERSION = 'jinn.curated-seed-audit.v1';
+const REQUIRED_STEP_LABELS = ['failure', 'fix', 'command'];
+const ACCEPTED_VERIFIABILITY_TIERS = new Set(['tests-passed', 'evaluator-verified']);
+/**
+ * Audit the automatable portion of a candidate curated seed batch.
+ *
+ * A passing report means only that the records meet the mechanical evidence,
+ * provenance, retrieval, and scrub gates. It deliberately cannot approve the
+ * curation judgment, publish records, or claim that a live corpus probe passed.
+ */
+export async function auditCuratedSeedBatch({ repoSlug, episodes, }) {
+    const probeTerms = deriveRepositorySearchTerms(repoSlug);
+    const seenIds = new Set();
+    const seenSourceUrls = new Set();
+    const commitUrlPrefix = `https://github.com/${repoSlug}/commit/`;
+    const records = [];
+    for (const episode of episodes) {
+        const errors = [];
+        const publishedTags = publishedEpisodeTags(episode);
+        if (episode.repo !== repoSlug) {
+            errors.push(`repo must be ${repoSlug}`);
+        }
+        if (!episode.baseCommit) {
+            errors.push('baseCommit must name a full commit');
+        }
+        if (!hasRetrievalMark(publishedTags)) {
+            errors.push('published tags missing retrieval visibility mark');
+        }
+        if (!probeTerms.some((term) => publishedTags.includes(term))) {
+            errors.push(`published tags must include a shared probe term: ${probeTerms.join(', ')}`);
+        }
+        if (episode.outcome.status !== 'completed' ||
+            !ACCEPTED_VERIFIABILITY_TIERS.has(episode.outcome.verifiabilityTier)) {
+            errors.push('outcome must be completed and tests-passed or evaluator-verified');
+        }
+        const stepLabels = new Set(episode.steps.map((step) => step.label));
+        if (!REQUIRED_STEP_LABELS.every((label) => stepLabels.has(label))) {
+            errors.push('steps must include failure, fix, and command evidence');
+        }
+        if (episode.attribution.origin !== 'operator-recorded-session') {
+            errors.push('attribution origin must be operator-recorded-session');
+        }
+        const sourceUrl = episode.attribution.sourceUrl;
+        const sourceCommit = sourceUrl?.startsWith(commitUrlPrefix) === true
+            ? sourceUrl.slice(commitUrlPrefix.length)
+            : '';
+        if (!/^[0-9a-f]{40}$/.test(sourceCommit)) {
+            errors.push(`sourceUrl must name a full ${repoSlug} commit`);
+        }
+        if (seenIds.has(episode.id)) {
+            errors.push(`duplicate episode id: ${episode.id}`);
+        }
+        else {
+            seenIds.add(episode.id);
+        }
+        if (sourceUrl) {
+            if (seenSourceUrls.has(sourceUrl)) {
+                errors.push(`duplicate sourceUrl: ${sourceUrl}`);
+            }
+            else {
+                seenSourceUrls.add(sourceUrl);
+            }
+        }
+        const redactionCount = await seedEpisodePrivacyRedactionCount(episode);
+        if (redactionCount > 0) {
+            errors.push(`seed scrub rejected content: ${redactionCount} redaction(s) would be required`);
+        }
+        records.push({
+            id: episode.id,
+            automatedStatus: errors.length === 0 ? 'pass' : 'fail',
+            errors,
+        });
+    }
+    const eligibleRecordCount = records.filter((record) => record.automatedStatus === 'pass').length;
+    const errors = [];
+    const failedRecordCount = records.length - eligibleRecordCount;
+    if (failedRecordCount > 0) {
+        errors.push(`${failedRecordCount} record${failedRecordCount === 1 ? '' : 's'} failed automated checks`);
+    }
+    if (eligibleRecordCount < CORPUS_ONBOARDING_K) {
+        errors.push(`need at least ${CORPUS_ONBOARDING_K} mechanically eligible records; found ${eligibleRecordCount}`);
+    }
+    return {
+        schemaVersion: CURATED_SEED_AUDIT_SCHEMA_VERSION,
+        repoSlug,
+        probeTerms,
+        requiredRecords: CORPUS_ONBOARDING_K,
+        recordCount: episodes.length,
+        eligibleRecordCount,
+        automatedStatus: errors.length === 0 ? 'pass' : 'fail',
+        errors,
+        records,
+        humanCurationRequired: true,
+        publishAuthorized: false,
+        liveProbe: {
+            status: 'not-run',
+            command: `jinn-layer corpus probe "${repoSlug}" --json`,
+        },
+    };
+}

package/dist/seed-import/episode-execute.d.ts

@@ -0,0 +1,50 @@
+/**
+ * `executeEpisodes()` — publish approved evidence-episode rows through the
+ * SAME `capture() -> publish()` path skill seeds use (issue #1771). Each
+ * episode becomes a synthetic captured task: one step per authored
+ * `SeedEpisodeStep` (content), plus a final step carrying the synthesis +
+ * attribution (episode-fetch.ts's step convention). `provenance: 'imported'`
+ * throughout, same as skill seeds — excluded from the demand signal and
+ * emissions eligibility by every provenance-aware reader.
+ *
+ * Idempotent by seed identity (state.ts, shared with the skill lane):
+ * unchanged content republishes nothing; changed content republishes and
+ * points the new record's `seed.attribution.supersedes` at the prior
+ * envelopeRef.
+ */
+import { type HarnessPublishDeps } from '../publish.js';
+import { type EpisodeSource, type SeedEpisode } from './episode-fetch.js';
+import type { EpisodeImportReport } from './episode-report.js';
+import { type SeedImportStateStore } from './state.js';
+export interface EpisodeImportResult {
+    imported: Array<{
+        id: string;
+        envelopeRef: string;
+        anchorTx: string | null;
+        /** Prior envelopeRef this publish supersedes, or null for a fresh identity. */
+        supersedes: string | null;
+        /** Publication succeeded, but local lineage state needs operator recovery. */
+        stateWarning?: string;
+        /** Anchor succeeded, but the local publication ledger needs recovery. */
+        ledgerWarning?: string;
+    }>;
+    skipped: Array<{
+        id: string;
+        reason: string;
+    }>;
+    errors: Array<{
+        id: string;
+        error: string;
+    }>;
+}
+/**
+ * Episode tags: the `seed-import` marker (shared with skill seeds — the
+ * "how did this land in the corpus" signal) plus the episode's own declared
+ * tags, deduped and capped. Mirrors `seedTags()` in execute.ts.
+ */
+export declare function publishedEpisodeTags(episode: SeedEpisode): string[];
+/** Read-only privacy preflight shared by execute and curated-batch auditing. */
+export declare function seedEpisodePrivacyRedactionCount(episode: SeedEpisode): Promise<number>;
+export declare function executeEpisodes(report: EpisodeImportReport, source: EpisodeSource, deps: HarnessPublishDeps, opts?: {
+    state?: SeedImportStateStore;
+}): Promise<EpisodeImportResult>;

package/dist/seed-import/episode-execute.js

@@ -0,0 +1,235 @@
+/**
+ * `executeEpisodes()` — publish approved evidence-episode rows through the
+ * SAME `capture() -> publish()` path skill seeds use (issue #1771). Each
+ * episode becomes a synthetic captured task: one step per authored
+ * `SeedEpisodeStep` (content), plus a final step carrying the synthesis +
+ * attribution (episode-fetch.ts's step convention). `provenance: 'imported'`
+ * throughout, same as skill seeds — excluded from the demand signal and
+ * emissions eligibility by every provenance-aware reader.
+ *
+ * Idempotent by seed identity (state.ts, shared with the skill lane):
+ * unchanged content republishes nothing; changed content republishes and
+ * points the new record's `seed.attribution.supersedes` at the prior
+ * envelopeRef.
+ */
+import { capture } from '../capture.js';
+import { buildSeedScrubPipeline } from '@jinn-network/core/scrub';
+import { publish, PublishLedgerError, } from '../publish.js';
+import { episodeContentDigest } from './episode-fetch.js';
+import { createMemorySeedImportState, } from './state.js';
+/** Same caps as seed-import/execute.ts's skill tags (envelope-v0.md size limits). */
+const MAX_TAG_CHARS = 64;
+const MAX_TAGS = 16;
+/**
+ * Episode tags: the `seed-import` marker (shared with skill seeds — the
+ * "how did this land in the corpus" signal) plus the episode's own declared
+ * tags, deduped and capped. Mirrors `seedTags()` in execute.ts.
+ */
+export function publishedEpisodeTags(episode) {
+    const tags = [];
+    for (const candidate of ['seed-import', ...episode.tags]) {
+        const tag = candidate.trim().slice(0, MAX_TAG_CHARS);
+        if (tag && !tags.includes(tag))
+            tags.push(tag);
+    }
+    return tags.slice(0, MAX_TAGS);
+}
+function toCapturedTask(episode, now, supersedes) {
+    const nanoBase = now.getTime();
+    const nanoAt = (offset) => `${nanoBase + offset}000000`;
+    const contentSteps = episode.steps.map((step, i) => ({
+        spanId: `seed-${i + 1}`,
+        parentSpanId: null,
+        name: `seed:step:${step.label}`,
+        startTimeUnixNano: nanoAt(i),
+        endTimeUnixNano: nanoAt(i),
+        attributes: {
+            'seed.step.label': step.label,
+            'seed.step.title': step.title,
+            'seed.step.text': step.text,
+        },
+        redactedKeys: [],
+    }));
+    const metaIndex = contentSteps.length;
+    const metaStep = {
+        spanId: `seed-${metaIndex + 1}`,
+        parentSpanId: null,
+        name: 'seed:synthesis',
+        startTimeUnixNano: nanoAt(metaIndex),
+        endTimeUnixNano: nanoAt(metaIndex),
+        attributes: {
+            'seed.synthesis': episode.synthesis,
+            'seed.attribution': {
+                repo: episode.repo,
+                ...(episode.baseCommit ? { baseCommit: episode.baseCommit } : {}),
+                origin: episode.attribution.origin,
+                ...(episode.attribution.sourceUrl ? { sourceUrl: episode.attribution.sourceUrl } : {}),
+                ...(supersedes ? { supersedes } : {}),
+            },
+        },
+        redactedKeys: [],
+    };
+    return {
+        session: { sessionId: `seed-episode:${episode.id}`, capturedAt: now.toISOString() },
+        task: {
+            summary: episode.taskSummary,
+            distributionTags: publishedEpisodeTags(episode),
+            repositorySlug: episode.repo,
+            ...(episode.baseCommit ? { baseCommit: episode.baseCommit } : {}),
+        },
+        environment: {
+            harness: { name: 'jinn-layer-seed-episode-import', version: '0.1.0' },
+            model: 'none',
+            tools: [],
+        },
+        steps: [...contentSteps, metaStep],
+        outcome: { status: episode.outcome.status, verifiabilityTier: episode.outcome.verifiabilityTier },
+        cost: { durationMs: 0 },
+        provenance: 'imported',
+    };
+}
+/** Every episode-originated string that can influence the published envelope. */
+function episodePrivacyAttributes(episode) {
+    const attributes = {
+        'episode.id': episode.id,
+        'episode.repo': episode.repo,
+        'episode.taskSummary': episode.taskSummary,
+        'episode.outcome.status': episode.outcome.status,
+        'episode.outcome.verifiabilityTier': episode.outcome.verifiabilityTier,
+        'episode.synthesis': episode.synthesis,
+        'episode.attribution.origin': episode.attribution.origin,
+    };
+    if (episode.baseCommit)
+        attributes['episode.baseCommit'] = episode.baseCommit;
+    if (episode.attribution.sourceUrl) {
+        attributes['episode.attribution.sourceUrl'] = episode.attribution.sourceUrl;
+    }
+    episode.tags.forEach((tag, index) => {
+        attributes[`episode.tags[${index}]`] = tag;
+    });
+    episode.steps.forEach((step, index) => {
+        attributes[`episode.steps[${index}].label`] = step.label;
+        attributes[`episode.steps[${index}].title`] = step.title;
+        attributes[`episode.steps[${index}].text`] = step.text;
+    });
+    return attributes;
+}
+/** Read-only privacy preflight shared by execute and curated-batch auditing. */
+export async function seedEpisodePrivacyRedactionCount(episode) {
+    const scrub = await buildSeedScrubPipeline().run(episodePrivacyAttributes(episode));
+    return scrub.redactions.length;
+}
+export async function executeEpisodes(report, source, deps, opts = {}) {
+    const episodes = new Map();
+    for (const episode of await source.list()) {
+        if (!episodes.has(episode.id))
+            episodes.set(episode.id, episode);
+    }
+    const result = { imported: [], skipped: [], errors: [] };
+    const now = deps.now?.() ?? new Date();
+    // Evidence episodes are public, transformed, human-reviewed seeds — like
+    // the skill lane, not operator trace data — so they run the seed profile
+    // (plan §4.4; spec/2026-07-02-jinn-harness-network.md §7): deterministic
+    // key policy, plain-patterns, and secretlint pass-1 only. The strict
+    // trace profile's probabilistic stages (openredaction, entropy fallback)
+    // false-positive on ordinary words and hex-looking SHAs in this content
+    // (#1784) and are not appropriate for a pre-vetted, checked-in corpus.
+    const episodeScrubPipeline = buildSeedScrubPipeline();
+    const state = opts.state ?? createMemorySeedImportState();
+    for (const row of report) {
+        if (row.verdict === 'skip') {
+            result.skipped.push({ id: row.id, reason: row.reason });
+            continue;
+        }
+        try {
+            const episode = episodes.get(row.id);
+            if (!episode)
+                throw new Error(`episode ${row.id} not found in source ${source.name}`);
+            const identity = `episode:${episode.id}`;
+            const contentHash = episodeContentDigest(episode);
+            if (contentHash !== row.contentDigest) {
+                throw new Error(`approved content digest ${row.contentDigest} does not match execute-time digest ${contentHash} for ${row.id}`);
+            }
+            let prior;
+            try {
+                prior = state.get(identity);
+            }
+            catch (err) {
+                result.errors.push({
+                    id: row.id,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+                break;
+            }
+            if (prior && prior.contentHash === contentHash) {
+                result.skipped.push({ id: row.id, reason: `unchanged since ${prior.envelopeRef}` });
+                continue;
+            }
+            const privacy = await episodeScrubPipeline.run(episodePrivacyAttributes(episode));
+            if (privacy.redactions.length > 0) {
+                const detectors = [
+                    ...new Set(privacy.redactions.map((redaction) => `${redaction.stage}${redaction.detail ? `:${redaction.detail}` : ''}`)),
+                ];
+                throw new Error(`sensitive content detected (${detectors.join(', ')}); refusing to publish evidence episode ${row.id}`);
+            }
+            const pending = await capture(toCapturedTask(episode, now, prior?.envelopeRef), {
+                pipeline: episodeScrubPipeline,
+            });
+            const sensitiveRedactions = pending.redactions.filter((redaction) => redaction.stage !== 'fit');
+            if (sensitiveRedactions.length > 0) {
+                const detectors = [
+                    ...new Set(sensitiveRedactions.map((redaction) => `${redaction.stage}${redaction.detail ? `:${redaction.detail}` : ''}`)),
+                ];
+                throw new Error(`sensitive content detected (${detectors.join(', ')}); refusing to publish evidence episode ${row.id}`);
+            }
+            let published;
+            let ledgerWarning;
+            try {
+                published = await publish(pending, deps);
+            }
+            catch (err) {
+                if (err instanceof PublishLedgerError) {
+                    published = err.result;
+                    ledgerWarning = err.message;
+                }
+                else {
+                    const detail = err instanceof Error ? err.message : String(err);
+                    result.errors.push({
+                        id: row.id,
+                        error: `publication outcome unknown; do not auto-retry: ${detail}`,
+                    });
+                    break;
+                }
+            }
+            if (published.vetoed)
+                throw new Error('unexpected veto on seed publish');
+            let stateWarning;
+            try {
+                state.set(identity, { contentHash, envelopeRef: published.envelopeRef, publishedAt: now.toISOString() });
+            }
+            catch (err) {
+                const detail = err instanceof Error ? err.message : String(err);
+                stateWarning =
+                    `published ${published.envelopeRef}, but seed-import state persistence failed: ${detail}; ` +
+                        'recovery required before retrying this episode';
+            }
+            result.imported.push({
+                id: row.id,
+                envelopeRef: published.envelopeRef,
+                anchorTx: published.anchorTx,
+                supersedes: prior?.envelopeRef ?? null,
+                ...(ledgerWarning ? { ledgerWarning } : {}),
+                ...(stateWarning ? { stateWarning } : {}),
+            });
+            if (ledgerWarning || stateWarning)
+                break;
+        }
+        catch (err) {
+            result.errors.push({
+                id: row.id,
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    return result;
+}