@kbediako/codex-orchestrator 0.1.0

package/dist/scripts/design/pipeline/extract.js

@@ -0,0 +1,249 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import { join, relative } from 'node:path';
+import { tmpdir } from 'node:os';
+import { loadDesignContext } from './context.js';
+import { appendArtifacts, loadDesignRunState, saveDesignRunState, upsertStage } from './state.js';
+import { stageArtifacts } from '../../../orchestrator/src/persistence/ArtifactStager.js';
+import { loadPlaywright } from './optionalDeps.js';
+async function main() {
+    const context = await loadDesignContext();
+    const state = await loadDesignRunState(context.statePath);
+    const stageId = 'design-extract';
+    const metadata = context.config.config.metadata.design;
+    if (metadata.captureUrls.length === 0) {
+        upsertStage(state, {
+            id: stageId,
+            title: 'Playwright extractor',
+            status: 'skipped',
+            notes: ['No capture URLs configured.']
+        });
+        await saveDesignRunState(context.statePath, state);
+        console.log('[design-extract] skipped — no capture URLs configured');
+        return;
+    }
+    const breakpoints = metadata.breakpoints.length > 0 ? metadata.breakpoints : defaultBreakpoints();
+    const records = [];
+    const stageSummaries = [];
+    const notes = [];
+    let successCount = 0;
+    const playwright = await loadPlaywright();
+    const browser = await playwright.chromium.launch({ headless: true });
+    const tmpRoot = join(tmpdir(), `design-extract-${Date.now()}`);
+    await mkdir(tmpRoot, { recursive: true });
+    try {
+        for (const url of metadata.captureUrls) {
+            for (const breakpoint of breakpoints) {
+                try {
+                    const result = await captureWithPlaywright({
+                        browser,
+                        url,
+                        breakpoint,
+                        tmpRoot,
+                        taskId: context.taskId,
+                        runId: context.runId,
+                        allowThirdParty: metadata.privacy.allowThirdParty,
+                        maskSelectors: metadata.maskSelectors ?? []
+                    });
+                    records.push(...result.records);
+                    stageSummaries.push(...result.stageSummaries);
+                    successCount += 1;
+                    console.log(`[design-extract] staged assets for ${url} @ ${breakpoint.id}`);
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    notes.push(`${url} (${breakpoint.id}): ${message}`);
+                    console.error(`[design-extract] capture failed for ${url} @ ${breakpoint.id}: ${message}`);
+                }
+            }
+        }
+    }
+    finally {
+        await browser.close();
+    }
+    appendArtifacts(state, records);
+    const stageStatus = successCount === 0 ? 'failed' : notes.length > 0 ? 'failed' : 'succeeded';
+    upsertStage(state, {
+        id: stageId,
+        title: 'Playwright extractor',
+        status: stageStatus,
+        notes: notes.length > 0 ? notes : undefined,
+        metrics: {
+            capture_count: successCount,
+            failure_count: notes.length,
+            breakpoint_count: breakpoints.length
+        },
+        artifacts: stageSummaries
+    });
+    await saveDesignRunState(context.statePath, state);
+    if (stageStatus === 'failed') {
+        throw new Error('Playwright extraction encountered failures. See stage notes for details.');
+    }
+}
+async function captureWithPlaywright(options) {
+    const { browser, url, breakpoint, tmpRoot, taskId, runId, allowThirdParty, maskSelectors } = options;
+    const context = await browser.newContext({
+        viewport: { width: breakpoint.width, height: breakpoint.height },
+        deviceScaleFactor: breakpoint.deviceScaleFactor
+    });
+    const baseOrigin = new URL(url).origin;
+    if (!allowThirdParty) {
+        await context.route('**/*', async (route) => {
+            const requestUrl = route.request().url();
+            if (isSameOrigin(baseOrigin, requestUrl)) {
+                await route.continue();
+            }
+            else {
+                await route.abort();
+            }
+        });
+    }
+    const page = await context.newPage();
+    try {
+        await page.goto(url, { waitUntil: 'networkidle', timeout: 60_000 });
+        if (maskSelectors.length > 0) {
+            await page.addStyleTag({ content: createMaskStyles(maskSelectors) });
+        }
+        const slug = slugify(`${url}-${breakpoint.id}`);
+        const captureDir = join(tmpRoot, slug);
+        await mkdir(captureDir, { recursive: true });
+        const domPath = join(captureDir, 'dom.html');
+        const cssPath = join(captureDir, 'styles.css');
+        const screenshotPath = join(captureDir, 'screenshot.png');
+        const metadataPath = join(captureDir, 'metadata.json');
+        const html = await page.content();
+        const css = await collectStyles(page);
+        const screenshot = await page.screenshot({ fullPage: true, type: 'png' });
+        const metadata = {
+            url,
+            breakpoint,
+            capturedAt: new Date().toISOString(),
+            assets: {
+                dom: 'dom.html',
+                css: 'styles.css',
+                screenshot: 'screenshot.png'
+            },
+            privacy: {
+                allowThirdParty,
+                maskSelectors
+            }
+        };
+        await Promise.all([
+            writeFile(domPath, html, 'utf8'),
+            writeFile(cssPath, css, 'utf8'),
+            writeFile(screenshotPath, screenshot),
+            writeFile(metadataPath, JSON.stringify(metadata, null, 2), 'utf8')
+        ]);
+        const relativeDir = `design/reference/playwright/${sanitizeSegment(breakpoint.id)}/${slug}`;
+        const staged = await stageArtifacts({
+            taskId,
+            runId,
+            artifacts: [
+                { path: relative(process.cwd(), domPath), description: `DOM snapshot for ${url}` },
+                { path: relative(process.cwd(), cssPath), description: `CSS snapshot for ${url}` },
+                { path: relative(process.cwd(), screenshotPath), description: `Screenshot for ${url}` },
+                { path: relative(process.cwd(), metadataPath), description: `Capture metadata for ${url}` }
+            ],
+            options: {
+                relativeDir,
+                overwrite: true
+            }
+        });
+        const [domArtifact, cssArtifact, screenshotArtifact, metadataArtifact] = staged;
+        const records = [
+            buildDesignRecord('dom', domArtifact.path, url, breakpoint.id),
+            buildDesignRecord('css', cssArtifact.path, url, breakpoint.id),
+            buildDesignRecord('screenshot', screenshotArtifact.path, url, breakpoint.id),
+            {
+                stage: 'extract',
+                status: 'succeeded',
+                relative_path: metadataArtifact.path,
+                type: 'metadata',
+                description: `${url} (${breakpoint.id}) metadata`,
+                metadata
+            }
+        ];
+        const stageSummaries = [
+            summaryEntry(domArtifact.path, 'DOM snapshot'),
+            summaryEntry(cssArtifact.path, 'CSS snapshot'),
+            summaryEntry(screenshotArtifact.path, 'Screenshot'),
+            summaryEntry(metadataArtifact.path, 'Metadata')
+        ];
+        return { records, stageSummaries };
+    }
+    finally {
+        await context.close();
+    }
+}
+function summaryEntry(path, description) {
+    return {
+        relative_path: path,
+        stage: 'extract',
+        status: 'succeeded',
+        description
+    };
+}
+function buildDesignRecord(type, path, url, breakpointId) {
+    return {
+        stage: 'extract',
+        status: 'succeeded',
+        relative_path: path,
+        type,
+        description: `${url} (${breakpointId})`
+    };
+}
+function createMaskStyles(selectors) {
+    const rules = selectors
+        .map((selector) => `${selector} { filter: blur(10px) !important; }`)
+        .join('\n');
+    return `${rules}\n`;
+}
+function isSameOrigin(baseOrigin, requestUrl) {
+    try {
+        const requestOrigin = new URL(requestUrl).origin;
+        return requestOrigin === baseOrigin;
+    }
+    catch {
+        return false;
+    }
+}
+async function collectStyles(page) {
+    return (await page.evaluate(() => {
+        const outputs = [];
+        for (const sheet of Array.from(document.styleSheets)) {
+            try {
+                const rules = sheet.cssRules ? Array.from(sheet.cssRules).map((rule) => rule.cssText).join('\n') : '';
+                outputs.push(rules);
+            }
+            catch (error) {
+                const href = sheet.href ?? 'inline';
+                outputs.push(`/* Unable to read stylesheet: ${href} (${String(error)}) */`);
+            }
+        }
+        return outputs.join('\n\n');
+    }));
+}
+function defaultBreakpoints() {
+    return [
+        {
+            id: 'default',
+            width: 1280,
+            height: 720
+        }
+    ];
+}
+function slugify(value) {
+    return value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 60) || 'capture';
+}
+function sanitizeSegment(value) {
+    const slug = slugify(value);
+    return slug.length > 0 ? slug : 'default';
+}
+main().catch((error) => {
+    console.error('[design-extract] failed to stage assets');
+    console.error(error instanceof Error ? error.stack ?? error.message : error);
+    process.exitCode = 1;
+});

package/dist/scripts/design/pipeline/optionalDeps.js

@@ -0,0 +1,107 @@
+import { existsSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+const DESIGN_SETUP_HINT = 'Run "npm run setup:design-tools" and "npx playwright install" to enable design tooling.';
+function isModuleNotFound(error) {
+    const candidate = error;
+    if (!candidate) {
+        return false;
+    }
+    const message = candidate.message ?? '';
+    return (candidate.code === 'ERR_MODULE_NOT_FOUND' ||
+        candidate.code === 'MODULE_NOT_FOUND' ||
+        message.includes('Cannot find package') ||
+        message.includes('Cannot find module'));
+}
+function missingDependency(specifier) {
+    return new Error(`[design-tools] Missing optional dependency "${specifier}". ${DESIGN_SETUP_HINT}`);
+}
+function resolveWithRequire(specifier, base) {
+    try {
+        const resolver = createRequire(base);
+        return resolver.resolve(specifier);
+    }
+    catch {
+        return null;
+    }
+}
+function resolveWithImportMeta(specifier, parentUrl) {
+    const resolver = import.meta.resolve;
+    if (typeof resolver !== 'function') {
+        return null;
+    }
+    try {
+        return resolver(specifier, parentUrl);
+    }
+    catch {
+        return null;
+    }
+}
+function resolveOptionalDependency(specifier, cwd = process.cwd()) {
+    const cwdPackage = join(cwd, 'package.json');
+    if (existsSync(cwdPackage)) {
+        const cwdRequireResolved = resolveWithRequire(specifier, cwdPackage);
+        if (cwdRequireResolved) {
+            return cwdRequireResolved;
+        }
+        const cwdImportResolved = resolveWithImportMeta(specifier, pathToFileURL(cwdPackage).href);
+        if (cwdImportResolved) {
+            return cwdImportResolved;
+        }
+    }
+    const selfRequireResolved = resolveWithRequire(specifier, import.meta.url);
+    if (selfRequireResolved) {
+        return selfRequireResolved;
+    }
+    return resolveWithImportMeta(specifier, import.meta.url);
+}
+function toModuleUrl(resolved) {
+    if (resolved.startsWith('file://') || resolved.startsWith('node:')) {
+        return resolved;
+    }
+    return pathToFileURL(resolved).href;
+}
+async function loadOptionalDependency(specifier) {
+    const resolved = resolveOptionalDependency(specifier);
+    if (!resolved) {
+        throw missingDependency(specifier);
+    }
+    try {
+        return (await import(toModuleUrl(resolved)));
+    }
+    catch (error) {
+        if (isModuleNotFound(error)) {
+            throw missingDependency(specifier);
+        }
+        throw error;
+    }
+}
+let playwrightPromise = null;
+let pngPromise = null;
+let pixelmatchPromise = null;
+let cheerioPromise = null;
+export async function loadPlaywright() {
+    if (!playwrightPromise) {
+        playwrightPromise = loadOptionalDependency('playwright');
+    }
+    return playwrightPromise;
+}
+export async function loadPngjs() {
+    if (!pngPromise) {
+        pngPromise = loadOptionalDependency('pngjs');
+    }
+    return pngPromise;
+}
+export async function loadPixelmatch() {
+    if (!pixelmatchPromise) {
+        pixelmatchPromise = loadOptionalDependency('pixelmatch');
+    }
+    return pixelmatchPromise;
+}
+export async function loadCheerio() {
+    if (!cheerioPromise) {
+        cheerioPromise = loadOptionalDependency('cheerio');
+    }
+    return cheerioPromise;
+}

package/dist/scripts/design/pipeline/prepare.js

@@ -0,0 +1,46 @@
+import { loadDesignContext, resolveDesignPipelineId } from './context.js';
+import { loadDesignRunState, mergeMetrics, saveDesignRunState, upsertStage } from './state.js';
+async function main() {
+    const context = await loadDesignContext();
+    const state = await loadDesignRunState(context.statePath);
+    state.configSnapshot = JSON.parse(JSON.stringify(context.config.config));
+    const retention = context.config.config.metadata.design.retention;
+    state.retention = {
+        days: retention.days,
+        autoPurge: Boolean(retention.autoPurge),
+        policy: 'design.config.retention'
+    };
+    const designMetadata = context.config.config.metadata.design;
+    const privacy = designMetadata.privacy;
+    state.privacy = {
+        allowThirdParty: Boolean(privacy.allowThirdParty),
+        requireApproval: Boolean(privacy.requireApproval),
+        maskSelectors: [...designMetadata.maskSelectors],
+        approver: privacy.approver ?? null
+    };
+    mergeMetrics(state, {
+        design_pipeline_id: resolveDesignPipelineId(context.config),
+        design_pipeline_enabled: designMetadata.enabled,
+        capture_url_count: designMetadata.captureUrls.length,
+        breakpoint_count: designMetadata.breakpoints.length
+    });
+    const stageNotes = context.config.warnings.length > 0 ? context.config.warnings : undefined;
+    upsertStage(state, {
+        id: 'design-config',
+        title: 'Resolve design configuration',
+        status: 'succeeded',
+        notes: stageNotes,
+        metrics: {
+            config_path: context.designConfigPath
+        }
+    });
+    await saveDesignRunState(context.statePath, state);
+    console.log(`[design-config] task=${context.taskId} run=${context.runId} designEnabled=${context.config.config.metadata.design.enabled}`);
+    console.log(`[design-config] retention=${state.retention?.days ?? retention.days}d autoPurge=${state.retention?.autoPurge ?? retention.autoPurge}`);
+    console.log(`[design-config] privacy allowThirdParty=${state.privacy?.allowThirdParty} requireApproval=${state.privacy?.requireApproval}`);
+}
+main().catch((error) => {
+    console.error('[design-config] failed to prepare design context');
+    console.error(error instanceof Error ? error.stack ?? error.message : error);
+    process.exitCode = 1;
+});

package/dist/scripts/design/pipeline/reference.js

@@ -0,0 +1,94 @@
+import { writeFile, mkdir } from 'node:fs/promises';
+import { join, relative } from 'node:path';
+import { tmpdir } from 'node:os';
+import { loadDesignContext } from './context.js';
+import { appendArtifacts, loadDesignRunState, saveDesignRunState, upsertStage } from './state.js';
+import { stageArtifacts } from '../../../orchestrator/src/persistence/ArtifactStager.js';
+async function main() {
+    const context = await loadDesignContext();
+    const state = await loadDesignRunState(context.statePath);
+    const stageId = 'design-reference';
+    const html = buildReferencePage(context.config.config.metadata.design.captureUrls, state.artifacts.filter((artifact) => artifact.stage === 'extract'));
+    const tmpRoot = join(tmpdir(), `design-reference-${Date.now()}`);
+    await mkdir(tmpRoot, { recursive: true });
+    const tempFile = join(tmpRoot, 'motherduck.html');
+    await writeFile(tempFile, html, 'utf8');
+    const [staged] = await stageArtifacts({
+        taskId: context.taskId,
+        runId: context.runId,
+        artifacts: [
+            {
+                path: relative(process.cwd(), tempFile),
+                description: 'Design reference page'
+            }
+        ],
+        options: {
+            relativeDir: 'design/reference',
+            overwrite: true
+        }
+    });
+    const artifact = {
+        stage: 'reference',
+        status: 'succeeded',
+        relative_path: staged.path,
+        type: 'motherduck-html',
+        description: 'Aggregated reference page'
+    };
+    appendArtifacts(state, [artifact]);
+    upsertStage(state, {
+        id: stageId,
+        title: 'Build motherduck reference page',
+        status: 'succeeded',
+        artifacts: [
+            {
+                relative_path: staged.path,
+                stage: 'reference',
+                status: 'succeeded',
+                description: 'motherduck.html'
+            }
+        ]
+    });
+    await saveDesignRunState(context.statePath, state);
+    console.log(`[design-reference] staged reference page: ${staged.path}`);
+}
+function buildReferencePage(urls, extractArtifacts) {
+    const captures = extractArtifacts.map((artifact) => artifact.relative_path);
+    const listItems = urls
+        .map((url) => `<li><a href="${url}">${url}</a></li>`)
+        .join('\n');
+    const captureList = captures
+        .map((path) => `<li><code>${path}</code></li>`)
+        .join('\n');
+    return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <title>Design Reference</title>
+    <style>
+      body { font-family: system-ui, sans-serif; margin: 2rem; }
+      h1 { margin-bottom: 1rem; }
+      section { margin-bottom: 2rem; }
+    </style>
+  </head>
+  <body>
+    <h1>Design Reference Overview</h1>
+    <section>
+      <h2>Capture Targets</h2>
+      <ol>
+        ${listItems}
+      </ol>
+    </section>
+    <section>
+      <h2>Staged Artifacts</h2>
+      <ul>
+        ${captureList}
+      </ul>
+    </section>
+  </body>
+</html>`;
+}
+main().catch((error) => {
+    console.error('[design-reference] failed to generate reference page');
+    console.error(error instanceof Error ? error.stack ?? error.message : error);
+    process.exitCode = 1;
+});

package/dist/scripts/design/pipeline/state.js

@@ -0,0 +1,206 @@
+import { readFile, writeFile } from 'node:fs/promises';
+export async function loadDesignRunState(path) {
+    try {
+        const raw = await readFile(path, 'utf8');
+        const parsed = JSON.parse(raw);
+        return sanitizeState(parsed);
+    }
+    catch (error) {
+        const nodeError = error;
+        if (nodeError && nodeError.code === 'ENOENT') {
+            return createEmptyState();
+        }
+        throw error;
+    }
+}
+export async function saveDesignRunState(path, state) {
+    const payload = JSON.stringify(state, null, 2);
+    await writeFile(path, `${payload}\n`, 'utf8');
+}
+export function upsertStage(state, stage) {
+    const existingIndex = state.stages.findIndex((entry) => entry.id === stage.id);
+    const normalized = sanitizeStage(stage);
+    if (existingIndex >= 0) {
+        state.stages[existingIndex] = {
+            ...state.stages[existingIndex],
+            ...normalized,
+            notes: mergeNotes(state.stages[existingIndex].notes, normalized.notes),
+            metrics: { ...state.stages[existingIndex].metrics, ...normalized.metrics },
+            artifacts: mergeStageArtifacts(state.stages[existingIndex].artifacts, normalized.artifacts)
+        };
+        return state.stages[existingIndex];
+    }
+    state.stages.push(normalized);
+    return normalized;
+}
+export function appendArtifacts(state, artifacts) {
+    for (const artifact of artifacts) {
+        const existingIndex = state.artifacts.findIndex((entry) => entry.stage === artifact.stage && entry.relative_path === artifact.relative_path && entry.type === artifact.type);
+        if (existingIndex >= 0) {
+            state.artifacts[existingIndex] = { ...state.artifacts[existingIndex], ...artifact };
+        }
+        else {
+            state.artifacts.push(artifact);
+        }
+    }
+}
+export function appendToolkitArtifacts(state, artifacts) {
+    const toolkit = ensureToolkitState(state);
+    for (const artifact of artifacts) {
+        const index = toolkit.artifacts.findIndex((entry) => entry.id === artifact.id &&
+            entry.stage === artifact.stage &&
+            entry.relative_path === artifact.relative_path);
+        if (index >= 0) {
+            toolkit.artifacts[index] = {
+                ...toolkit.artifacts[index],
+                ...artifact
+            };
+        }
+        else {
+            toolkit.artifacts.push({ ...artifact });
+        }
+    }
+}
+export function appendApprovals(state, approvals) {
+    for (const approval of approvals) {
+        const exists = state.approvals.some((entry) => entry.id === approval.id);
+        if (!exists) {
+            state.approvals.push(approval);
+        }
+    }
+}
+export function mergeMetrics(state, metrics) {
+    state.metrics = {
+        ...state.metrics,
+        ...metrics
+    };
+}
+export function ensureToolkitState(state) {
+    if (!state.toolkit) {
+        state.toolkit = {
+            contexts: [],
+            artifacts: []
+        };
+    }
+    return state.toolkit;
+}
+export function upsertToolkitContext(state, contextRecord) {
+    const toolkit = ensureToolkitState(state);
+    const index = toolkit.contexts.findIndex((entry) => entry.id === contextRecord.id);
+    if (index >= 0) {
+        toolkit.contexts[index] = {
+            ...toolkit.contexts[index],
+            ...contextRecord
+        };
+        return toolkit.contexts[index];
+    }
+    toolkit.contexts.push({ ...contextRecord });
+    return toolkit.contexts[toolkit.contexts.length - 1];
+}
+function sanitizeState(state) {
+    if (!state || typeof state !== 'object') {
+        return createEmptyState();
+    }
+    return {
+        configSnapshot: state.configSnapshot ?? null,
+        retention: state.retention,
+        privacy: state.privacy,
+        approvals: Array.isArray(state.approvals) ? [...state.approvals] : [],
+        artifacts: Array.isArray(state.artifacts) ? [...state.artifacts] : [],
+        toolkit: sanitizeToolkitState(state.toolkit),
+        stages: Array.isArray(state.stages) ? state.stages.map(sanitizeStage) : [],
+        metrics: state.metrics && typeof state.metrics === 'object' ? { ...state.metrics } : {},
+        designPlan: cloneDesignValue(state.designPlan),
+        designGuardrail: cloneDesignValue(state.designGuardrail),
+        designHistory: cloneDesignValue(state.designHistory),
+        designStyleProfile: cloneDesignValue(state.designStyleProfile),
+        designMetrics: cloneDesignValue(state.designMetrics)
+    };
+}
+function createEmptyState() {
+    return {
+        approvals: [],
+        artifacts: [],
+        toolkit: {
+            contexts: [],
+            artifacts: []
+        },
+        stages: [],
+        metrics: {},
+        designPlan: null,
+        designGuardrail: null,
+        designHistory: null,
+        designStyleProfile: null,
+        designMetrics: null
+    };
+}
+function sanitizeStage(stage) {
+    return {
+        id: stage.id,
+        title: stage.title,
+        status: stage.status,
+        notes: stage.notes ? [...stage.notes] : [],
+        metrics: stage.metrics ? { ...stage.metrics } : undefined,
+        artifacts: mergeStageArtifacts([], stage.artifacts)
+    };
+}
+function mergeNotes(existing, next) {
+    const combined = [...(existing ?? []), ...(next ?? [])];
+    if (combined.length === 0) {
+        return undefined;
+    }
+    return Array.from(new Set(combined));
+}
+function mergeStageArtifacts(existing, incoming) {
+    if ((!existing || existing.length === 0) && (!incoming || incoming.length === 0)) {
+        return undefined;
+    }
+    const records = [...(existing ?? [])];
+    for (const artifact of incoming ?? []) {
+        const index = records.findIndex((entry) => entry.relative_path === artifact.relative_path);
+        if (index >= 0) {
+            records[index] = { ...records[index], ...artifact };
+        }
+        else {
+            records.push({ ...artifact });
+        }
+    }
+    return records;
+}
+function cloneDesignValue(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return JSON.parse(JSON.stringify(value));
+}
+function sanitizeToolkitState(toolkit) {
+    if (!toolkit || typeof toolkit !== 'object') {
+        return {
+            contexts: [],
+            artifacts: []
+        };
+    }
+    const contexts = Array.isArray(toolkit.contexts)
+        ? toolkit.contexts.map((context) => ({ ...context }))
+        : [];
+    const artifacts = Array.isArray(toolkit.artifacts)
+        ? toolkit.artifacts.map((artifact) => ({ ...artifact }))
+        : [];
+    const retention = toolkit.retention
+        ? {
+            days: Number(toolkit.retention.days) || 0,
+            autoPurge: Boolean(toolkit.retention.autoPurge),
+            policy: toolkit.retention.policy
+        }
+        : undefined;
+    const summary = toolkit.summary && typeof toolkit.summary === 'object' ? { ...toolkit.summary } : undefined;
+    return {
+        contexts,
+        artifacts,
+        retention,
+        summary: summary ?? null
+    };
+}