@playcraft/cli 0.1.49-beta → 0.1.51

package/dist/video-replication/comparison-evidence.js

@@ -1,149 +0,0 @@
-import { readFile, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import sharp from 'sharp';
-import { replicaValidationResultSchema, validateReplicaComparisonContent, } from '@playcraft/common/agent-tools';
-import { openVideo, runMediaTool, verifyVideo } from './media.js';
-import { comparisonOutputPath, writeComparisonArtifact, writeComparisonJson } from './comparison-output.js';
-import { comparisonMessage as t, ComparisonCliError } from './comparison-messages.js';
-import { comparisonSha256 } from './comparison-files.js';
-const xml = (text) => text.replace(/[&<>"']/g, value => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&apos;' })[value]);
-const md = (text) => text.replace(/([\\`*_[\]<>])/g, '\\$1');
-const reasonMessages = {
-    'video.eventPairMissing': 'reasonEventPairMissing', 'video.dimensionUncertain': 'reasonDimensionUncertain',
-    'video.dimensionEventMissing': 'reasonDimensionEventMissing', 'video.progressionEvidenceMissing': 'reasonProgressionEvidenceMissing',
-    'video.timingPrecisionInsufficient': 'reasonTimingPrecisionInsufficient', 'video.timingFailureUnverified': 'reasonTimingFailureUnverified',
-    'video.requiredEffectsMissing': 'reasonRequiredEffectsMissing', 'video.controlRuntimeUncertain': 'reasonControlRuntimeUncertain',
-    'video.controlEvidenceMissing': 'reasonControlEvidenceMissing', 'video.requestsFailed': 'reasonRequestsFailed',
-};
-const renderReason = (reason) => {
-    const key = reason.startsWith('video.referenceKindMissing:') ? 'reasonReferenceKindMissing'
-        : Object.prototype.hasOwnProperty.call(reasonMessages, reason) ? reasonMessages[reason] : undefined;
-    return md(key ? `${t(key)} (${reason})` : reason);
-};
-async function tile(frame, out) {
-    const image = await sharp(join(out, frame.path)).resize(260, 190, { fit: 'contain', background: '#f4f4f4' }).png().toBuffer();
-    const label = Buffer.from(`<svg width="260" height="34"><rect width="100%" height="100%" fill="white"/><text x="8" y="14" font-size="11">${xml(frame.inputId)} · ${xml(frame.evidenceId)}</text><text x="8" y="29" font-size="11">${(frame.timeMs / 1000).toFixed(3)}s</text></svg>`);
-    return sharp({ create: { width: 260, height: 224, channels: 3, background: '#fff' } }).composite([{ input: image, top: 0, left: 0 }, { input: label, top: 190, left: 0 }]).png().toBuffer();
-}
-export function renderComparisonReport(comparison, frames) {
-    const frameMap = new Map(frames.map(frame => [frame.evidenceId, frame]));
-    const refs = (ids) => ids.map(id => `[${md(id)}](${frameMap.get(id)?.path})`).join(', ');
-    const list = (values) => values.length ? values.map(md).join(', ') : t('reportNone');
-    const timingStatus = comparison.timingChecks.some(check => check.status === 'fail') ? 'fail'
-        : !comparison.timingChecks.length || comparison.timingChecks.some(check => check.status === 'inconclusive') ? 'inconclusive' : 'pass';
-    const lines = [`# ${t('summary')}: ${comparison.status}`, '', t('coverageNotice'), '',
-        `## ${t('decision')}`, '', `- ${t('reportStatus')}: **${comparison.status}**`, `- ${t('reportScope')}: ${comparison.scope}`,
-        `- ${t('reportPolicy')}: ${comparison.policySha256}`, `- ${t('reportRecording')}: ${comparison.recordingHash}`, ''];
-    lines.push(t(comparison.status === 'pass' ? 'policyPassedNotice' : 'policyNotPassedNotice'), '', `## ${t('coverage')}`, '', t('deterministicNotice'), '', `- ${t('reportRequired')}: ${list(comparison.coverage.requiredEventIds)}`, `- ${t('reportEvaluated')}: ${list(comparison.coverage.evaluatedEventIds)}`, `- ${t('reportMissing')}: ${list(comparison.coverage.missingEventIds)}`, `- ${t('reportRequiredKinds')}: ${list(comparison.coverage.requiredKinds)}`, `- ${t('reportMissingKinds')}: ${list(comparison.coverage.missingKinds)}`, '', `### ${t('reportMissingEvidence')}`, '');
-    if (comparison.missingEvidence.some(item => item.dimension === 'interaction'))
-        lines.push(t('interactionUnverified'), '');
-    for (const item of comparison.missingEvidence)
-        lines.push(`- ${item.eventId ? `${md(item.eventId)}: ` : ''}${item.dimension ? `${item.dimension}: ` : ''}${renderReason(item.reason)}`);
-    if (!comparison.missingEvidence.length)
-        lines.push(`- ${t('reportNone')}`);
-    lines.push('', `### ${t('reportTimingChecks')}: ${timingStatus}`, '');
-    if (timingStatus === 'inconclusive')
-        lines.push(t('timingUnverified'), '');
-    for (const check of comparison.timingChecks)
-        lines.push(`- ${t('reportTiming')} ${md(check.eventId)} (${check.measurement}): ${check.status}; ${t('reportReference')} ${check.referenceRangeMs.join('–')} ms; ${t('reportCandidate')} ${check.candidateRangeMs.join('–')} ms; ${t('reportTolerance')} ${check.toleranceMs} ms`);
-    lines.push('', `## ${t('modelObservations')}`, '', t('modelObservationNotice'), '', `- ${t('reportModel')}: ${comparison.model.provider}/${comparison.model.model} (${comparison.model.processing})`, '', `### ${t('modelSummary')}`, '', md(comparison.summary), '', `### ${t('modelDimensions')}`, '');
-    for (const [dimension, judgment] of Object.entries(comparison.dimensions))
-        lines.push(`- **${dimension}: ${judgment.status}** (${judgment.confidence}) — ${md(judgment.reason)} ${refs(judgment.evidenceIds)}`);
-    lines.push('', `## ${t('differences')}`, '');
-    for (const finding of comparison.findings)
-        lines.push(`### ${md(finding.id)} · ${finding.severity} · ${finding.dimension}`, '', `- ${t('reportExpected')}: ${md(finding.expected)}`, `- ${t('reportObserved')}: ${md(finding.observed)}`, `- ${t('reportSuggestedFix')}: ${md(finding.suggestedFix)}`, `- ${t('reportConfidence')}: ${finding.confidence}; ${t('reportEvidence')}: ${refs(finding.evidenceIds)}`, '');
-    lines.push(`## ${t('alignment')}`, '');
-    for (const alignment of comparison.alignments) {
-        const reference = frameMap.get(alignment.referenceEvidenceId);
-        const candidate = frameMap.get(alignment.candidateEvidenceId);
-        lines.push(`- **${md(alignment.eventId)}** (${alignment.confidence}): ${t('reportReference')} ${reference?.timeMs} ms ↔ ${t('reportCandidate')} ${candidate?.timeMs} ms; ${refs([alignment.referenceEvidenceId, alignment.candidateEvidenceId])}`);
-    }
-    lines.push('', `## ${t('controls')}`, '');
-    for (const check of comparison.controlChecks)
-        lines.push(`- ${md(check.stepId)} → ${md(check.eventId)}; ${md(check.controlInputId)}: ${check.effect} (${check.confidence}); ${refs([check.candidateEvidenceId, check.controlEvidenceId])}`);
-    lines.push('', `## ${t('evidence')}`, '');
-    for (const frame of frames)
-        lines.push(`- ${md(frame.evidenceId)} · ${md(frame.inputId)}: ${t('reportRequested')} ${frame.requestedTimeMs} ms, ${t('reportDecoded')} ${frame.timeMs} ms; [${t('reportFrame')}](${frame.path})`);
-    return `${lines.join('\n')}\n`;
-}
-/** Extract real source frames for each validated input; model output never supplies local paths. */
-export async function materializeComparisonEvidence(input) {
-    let comparison;
-    try {
-        comparison = replicaValidationResultSchema.parse(input.comparison);
-        validateReplicaComparisonContent({ summary: comparison.summary, evidence: comparison.evidence, alignments: comparison.alignments,
-            dimensions: comparison.dimensions, findings: comparison.findings, controlChecks: comparison.controlChecks, timings: comparison.timings, missingEvidence: comparison.missingEvidence }, { inputs: comparison.inputs, analysis: input.request.analysis, recording: input.request.recording, policy: input.request.policy, processing: input.request.processing, fps: input.request.fps });
-    }
-    catch {
-        throw new ComparisonCliError('comparisonResult');
-    }
-    // Validate every destination before replacing any prior artifact.
-    for (const path of [...comparison.evidence.map(item => `keyframes/${item.inputId}/${item.id}.png`), 'comparison.json', 'comparison.md', 'manifest.json', 'contact-sheet.jpg', 'paired-contact-sheet.jpg'])
-        await comparisonOutputPath(input.out, path);
-    const frames = [];
-    for (const source of comparison.inputs) {
-        const local = input.inputs.find(item => item.id === source.id && item.role === source.role);
-        if (!local)
-            throw new ComparisonCliError('comparisonResult');
-        const evidence = comparison.evidence.filter(item => item.inputId === source.id);
-        if (!evidence.length)
-            continue;
-        const file = await openVideo(local.video.path);
-        try {
-            await verifyVideo(file, source.source);
-            const output = await runMediaTool('ffprobe', ['-v', 'error', '-protocol_whitelist', 'file,pipe', '-format_whitelist', 'mov,matroska,webm',
-                '-select_streams', 'v:0', '-show_entries', 'frame=best_effort_timestamp_time', '-of', 'csv=p=0', '/dev/fd/3'], file.fd, input.signal);
-            const raw = output.split('\n').map(line => Number.parseFloat(line) * 1000).filter(Number.isFinite);
-            const origin = raw[0] ?? 0;
-            const times = raw.map(time => time - origin).filter(time => time >= 0 && time < source.source.durationMs);
-            if (!times.length)
-                throw new ComparisonCliError('comparisonResult');
-            for (const item of evidence) {
-                input.signal?.throwIfAborted();
-                const requestedTimeMs = (item.startMs + item.endMs) / 2;
-                const timeMs = times.reduce((best, time) => Math.abs(time - requestedTimeMs) < Math.abs(best - requestedTimeMs) ? time : best);
-                const path = `keyframes/${source.id}/${item.id}.png`;
-                await writeComparisonArtifact(input.out, path, temporary => runMediaTool('ffmpeg', ['-v', 'error', '-nostdin', '-y', '-protocol_whitelist', 'file,pipe', '-format_whitelist', 'mov,matroska,webm',
-                    '-ss', (Math.max(0, timeMs - 0.01) / 1000).toFixed(6), '-i', '/dev/fd/3', '-map', '0:v:0', '-frames:v', '1',
-                    '-vf', 'scale=min(1280\\,iw):-2', '-threads', '1', temporary], file.fd, input.signal));
-                const bytes = await readFile(join(input.out, path));
-                const metadata = await sharp(bytes).metadata();
-                if (!metadata.width || !metadata.height)
-                    throw new ComparisonCliError('comparisonResult');
-                frames.push({ evidenceId: item.id, inputId: source.id, requestedTimeMs, timeMs, path, sha256: comparisonSha256(bytes) });
-            }
-            await verifyVideo(file, source.source);
-        }
-        finally {
-            await file.close();
-        }
-    }
-    if (frames.length !== comparison.evidence.length)
-        throw new ComparisonCliError('comparisonResult');
-    const tiles = await Promise.all(frames.map(frame => tile(frame, input.out)));
-    const columns = Math.min(4, tiles.length);
-    const contactSheet = join(input.out, 'contact-sheet.jpg');
-    await writeComparisonArtifact(input.out, 'contact-sheet.jpg', temporary => sharp({ create: { width: columns * 260, height: Math.ceil(tiles.length / columns) * 224, channels: 3, background: '#ddd' } })
-        .composite(tiles.map((value, index) => ({ input: value, left: index % columns * 260, top: Math.floor(index / columns) * 224 }))).jpeg({ quality: 85 }).toFile(temporary));
-    const pairs = comparison.alignments.flatMap(alignment => [alignment.referenceEvidenceId, alignment.candidateEvidenceId]);
-    const selected = pairs.length ? pairs.map(id => tiles[frames.findIndex(frame => frame.evidenceId === id)])
-        : ['reference', 'candidate'].flatMap(inputId => { const index = frames.findIndex(frame => frame.inputId === inputId); return index >= 0 ? [tiles[index]] : []; });
-    if (!selected.length)
-        throw new ComparisonCliError('comparisonResult');
-    const pairedContactSheet = join(input.out, 'paired-contact-sheet.jpg');
-    await writeComparisonArtifact(input.out, 'paired-contact-sheet.jpg', temporary => sharp({ create: { width: 520, height: Math.ceil(selected.length / 2) * 224, channels: 3, background: '#ddd' } })
-        .composite(selected.map((value, index) => ({ input: value, left: index % 2 * 260, top: Math.floor(index / 2) * 224 }))).jpeg({ quality: 85 }).toFile(temporary));
-    const resultPath = join(input.out, 'comparison.json');
-    const markdown = join(input.out, 'comparison.md');
-    await writeComparisonJson(input.out, 'comparison.json', comparison);
-    await writeComparisonArtifact(input.out, 'comparison.md', temporary => writeFile(temporary, renderComparisonReport(comparison, frames), { mode: 0o600, flag: 'wx' }));
-    const files = [];
-    for (const path of ['comparison.json', 'comparison.md', 'contact-sheet.jpg', 'paired-contact-sheet.jpg'])
-        files.push({ path, sha256: comparisonSha256(await readFile(join(input.out, path))) });
-    const manifest = join(input.out, 'manifest.json');
-    await writeComparisonJson(input.out, 'manifest.json', { schemaVersion: 'playcraft.replica-evidence.v1', runId: comparison.runId, state: 'completed', status: comparison.status,
-        recordingHash: comparison.recordingHash, policySha256: comparison.policySha256, model: comparison.model, inputs: comparison.inputs,
-        comparison: 'comparison.json', markdown: 'comparison.md', contactSheet: 'contact-sheet.jpg', pairedContactSheet: 'paired-contact-sheet.jpg',
-        files, frames, frameTimeSemantics: 'nearest-decoded-original-video-frame', audio: 'not_evaluated' });
-    return { manifest, comparison: resultPath, markdown, contactSheet, pairedContactSheet, keyframes: frames.map(frame => join(input.out, frame.path)) };
-}

package/dist/video-replication/comparison-files.js

@@ -1,57 +0,0 @@
-import { createHash } from 'node:crypto';
-import { lstat, open, realpath } from 'node:fs/promises';
-import { isAbsolute, relative, resolve, sep } from 'node:path';
-import { ComparisonCliError } from './comparison-messages.js';
-export function comparisonSha256(value) {
-    return createHash('sha256').update(value).digest('hex');
-}
-export async function readComparisonJson(path, maxBytes = 2 * 1024 * 1024) {
-    const file = await open(path, 'r');
-    try {
-        const stat = await file.stat();
-        if (!stat.isFile() || stat.size <= 0 || stat.size > maxBytes)
-            throw new ComparisonCliError('invalidRecording', 64);
-        return JSON.parse(await file.readFile('utf8'));
-    }
-    finally {
-        await file.close();
-    }
-}
-/** Only recorder-owned, regular files under the exact recording directory may become evidence. */
-export async function recordingArtifactPath(root, path) {
-    if (!path || isAbsolute(path) || path.includes('\\') || path.split('/').some(part => !part || part === '.' || part === '..'))
-        throw new ComparisonCliError('invalidRecording', 64);
-    const base = await realpath(root);
-    const target = resolve(base, path);
-    const local = relative(base, target);
-    if (!local || local === '..' || local.startsWith(`..${sep}`) || isAbsolute(local))
-        throw new ComparisonCliError('invalidRecording', 64);
-    let current = base;
-    for (const part of local.split(sep)) {
-        current = resolve(current, part);
-        const stat = await lstat(current);
-        if (stat.isSymbolicLink())
-            throw new ComparisonCliError('invalidRecording', 64);
-    }
-    if (await realpath(target) !== target || !(await lstat(target)).isFile())
-        throw new ComparisonCliError('invalidRecording', 64);
-    return target;
-}
-export async function verifyRecordingArtifact(root, artifact, maxBytes = 8 * 1024 * 1024) {
-    const path = await recordingArtifactPath(root, artifact.path);
-    const file = await open(path, 'r');
-    try {
-        const stat = await file.stat();
-        if (!stat.isFile() || stat.size > maxBytes)
-            throw new ComparisonCliError('invalidRecording', 64);
-        const hash = createHash('sha256');
-        for await (const chunk of file.createReadStream({ autoClose: false, start: 0 }))
-            hash.update(chunk);
-        if (hash.digest('hex') !== artifact.sha256)
-            throw new ComparisonCliError('invalidRecording', 64);
-    }
-    finally {
-        await file.close();
-    }
-    return path;
-}

package/dist/video-replication/comparison-log.js

@@ -1,72 +0,0 @@
-import { canonicalReplicaJson } from '@playcraft/common/agent-tools';
-import { ComparisonCliError } from './comparison-messages.js';
-/** Completed capture and every real/omitted scenario step must be represented in the hashed log. */
-export function validateComparisonInputLog(records, scenario, artifact) {
-    const invalid = () => { throw new ComparisonCliError('invalidRecording', 64); };
-    const finiteTime = (value) => typeof value === 'number' && Number.isFinite(value) && value >= 0;
-    if (records.some(value => value === null || typeof value !== 'object' || Array.isArray(value)))
-        invalid();
-    const log = records;
-    const starts = log.filter(record => record.kind === 'recording-start'), ends = log.filter(record => record.kind === 'recording-end');
-    if (starts.length !== 1 || ends.length !== 1 || log[0] !== starts[0] || log.at(-1) !== ends[0])
-        invalid();
-    const start = starts[0], end = ends[0];
-    if (start.plannedAtMs !== 0 || start.actualAtMs !== 0 || start.device !== scenario.pointer || canonicalReplicaJson(start.reset) !== canonicalReplicaJson(scenario.reset)
-        || end.plannedAtMs !== scenario.durationMs || !finiteTime(end.actualAtMs) || end.actualAtMs < scenario.durationMs || end.status !== 'completed')
-        invalid();
-    if (log.some(record => record.status === 'failed' || !finiteTime(record.actualAtMs) || !finiteTime(record.plannedAtMs)))
-        invalid();
-    const finals = log.filter(record => ['tap', 'drag'].includes(String(record.kind)) && ['dispatched', 'omitted'].includes(String(record.status)));
-    if (finals.length !== scenario.steps.length)
-        invalid();
-    let previousEnd = -1;
-    for (const step of scenario.steps) {
-        const matching = finals.filter(record => record.stepId === step.id);
-        if (matching.length !== 1)
-            invalid();
-        const record = matching[0], omitted = artifact.omittedStepIds.includes(step.id);
-        if (record.kind !== step.type || record.plannedAtMs !== step.atMs || record.device !== scenario.pointer || record.status !== (omitted ? 'omitted' : 'dispatched')
-            || !finiteTime(record.actualAtMs) || record.actualAtMs + 2 < step.atMs || record.actualAtMs < previousEnd)
-            invalid();
-        const expected = (step.type === 'tap' ? [{ offsetMs: 0, x: step.x, y: step.y }] : step.path).map(point => ({ ...point, actual: {
-                x: (scenario.contentRect.x + point.x * scenario.contentRect.width) * scenario.viewport.width,
-                y: (scenario.contentRect.y + point.y * scenario.contentRect.height) * scenario.viewport.height,
-            } }));
-        if (canonicalReplicaJson(record.points) !== canonicalReplicaJson(expected))
-            invalid();
-        if (!omitted) {
-            if (!finiteTime(record.completedAtMs) || record.completedAtMs < record.actualAtMs
-                || record.completedAtMs > artifact.video.source.durationMs + artifact.timing.uncertaintyMs)
-                invalid();
-            const pointers = log.filter(pointer => pointer.stepId === step.id && pointer.kind === 'pointer' && pointer.status === 'dispatched');
-            if (step.type === 'tap' ? !pointers.some(pointer => pointer.phase === 'tap') : !['start', 'move', 'end'].every(phase => pointers.some(pointer => pointer.phase === phase)))
-                invalid();
-            previousEnd = record.completedAtMs;
-        }
-        else
-            previousEnd = record.actualAtMs;
-    }
-}
-/** Runtime counters must agree with the hashed console and browser event evidence. */
-export function validateComparisonConsoleLog(records, artifact) {
-    const counts = { pageErrors: 0, consoleErrors: 0, failedRequests: 0 };
-    for (const value of records) {
-        if (value === null || typeof value !== 'object' || Array.isArray(value))
-            throw new ComparisonCliError('invalidRecording', 64);
-        const record = value;
-        if (typeof record.atMs !== 'number' || !Number.isFinite(record.atMs) || record.atMs < 0)
-            throw new ComparisonCliError('invalidRecording', 64);
-        if (record.kind === 'console') {
-            if (record.level === 'error')
-                counts.consoleErrors++;
-        }
-        else if (['pageerror', 'popup', 'dialog'].includes(String(record.kind)))
-            counts.pageErrors++;
-        else if (record.kind === 'requestfailed')
-            counts.failedRequests++;
-        else
-            throw new ComparisonCliError('invalidRecording', 64);
-    }
-    if (canonicalReplicaJson(counts) !== canonicalReplicaJson(artifact.runtime))
-        throw new ComparisonCliError('invalidRecording', 64);
-}

package/dist/video-replication/comparison-messages.js

@@ -1,104 +0,0 @@
-const messages = {
-    en: {
-        compare: 'Compare a recorded playable with its reference and extract paired evidence',
-        processing: 'static | agentic (defaults to static)',
-        reference: 'Original local reference video', analysis: 'Completed reference analysis.json',
-        candidate: 'Locally recorded candidate video', recording: 'Recording metadata.json with input and control evidence',
-        policy: 'Optional versioned comparison policy JSON', kind: 'understanding | comparison (defaults to understanding)',
-        invalidComparison: 'Comparison arguments or policy are invalid.',
-        unsafeOutput: 'The comparison output contains a linked or invalid directory or artifact. Choose a safe output directory.',
-        invalidRecording: 'Recording metadata, source hashes, input logs, or controls are invalid.',
-        staleRecording: 'The project changed after recording. Make a fresh recording before comparison.',
-        comparisonContext: 'The reference analysis does not match the reference video.',
-        comparisonResume: 'The saved comparison request is missing or does not match this run and workspace.',
-        comparisonUnavailable: 'No authorized model supports the requested comparison.',
-        comparisonResult: 'The comparison service returned invalid or incomplete evidence.',
-        comparisonFailed: 'Comparison failed. Inspect its saved request and task before retrying.',
-        summary: 'Comparison', decision: 'Policy decision', alignment: 'Model event alignment',
-        differences: 'Model-observed differences and modification suggestions', coverage: 'Coverage and uncertainty',
-        evidence: 'Paired evidence', controls: 'Model interpretation of interaction controls',
-        reportStatus: 'Result', reportRequiredKinds: 'Required event kinds', reportMissingKinds: 'Missing event kinds',
-        reportMissingEvidence: 'Missing or uncertain evidence', reportTimingChecks: 'Deterministic timing checks', reportNone: 'none',
-        modelObservations: 'Model observations', modelSummary: 'Model summary', modelDimensions: 'Model dimension judgments',
-        modelObservationNotice: 'These are model observations and interpretations. A model pass does not override the policy decision or missing evidence above.',
-        policyPassedNotice: 'Policy acceptance passed for this recorded scenario.',
-        policyNotPassedNotice: 'Policy acceptance has not passed. Gameplay equivalence has not been established.',
-        deterministicNotice: 'Coverage and timing checks below are deterministic. Missing evidence remains unverified even when a model observation says pass.',
-        interactionUnverified: 'Interaction is not fully verified: required causal or control evidence is missing or uncertain.',
-        timingUnverified: 'Timing is not fully verified: evidence precision or coverage is insufficient for the policy tolerance.',
-        reasonReferenceKindMissing: 'Reference analysis lacks a required event kind.',
-        reasonEventPairMissing: 'Reference and candidate lack a sufficiently confident event pair.',
-        reasonDimensionUncertain: 'The model judgment for this dimension is uncertain or below the required confidence.',
-        reasonDimensionEventMissing: 'This dimension does not cover a required event.',
-        reasonProgressionEvidenceMissing: 'Evidence for event progression timing is missing or insufficient.',
-        reasonTimingPrecisionInsufficient: 'Timing precision or coverage cannot resolve the policy tolerance.',
-        reasonTimingFailureUnverified: 'The model timing failure is not confirmed by deterministic timing checks.',
-        reasonRequiredEffectsMissing: 'Required gameplay results are not linked to recorded input steps.',
-        reasonControlRuntimeUncertain: 'A control recording contains runtime errors or failed requests.',
-        reasonControlEvidenceMissing: 'Required control evidence is missing, uncertain, or does not cover the candidate result window.',
-        reasonRequestsFailed: 'The candidate recording contains failed network requests.',
-        reportScope: 'Scope', reportModel: 'Model', reportPolicy: 'Policy', reportRecording: 'Recording',
-        reportExpected: 'Expected', reportObserved: 'Observed', reportSuggestedFix: 'Suggested fix',
-        reportConfidence: 'Confidence', reportEvidence: 'evidence', reportReference: 'reference', reportCandidate: 'candidate',
-        reportRequired: 'Required', reportEvaluated: 'Evaluated', reportMissing: 'Missing', reportTiming: 'Timing',
-        reportTolerance: 'tolerance', reportRequested: 'requested', reportDecoded: 'decoded', reportFrame: 'frame',
-        coverageNotice: 'This result covers only the recorded scenario. Audio and unshown gameplay branches were not evaluated.',
-    },
-    zh: {
-        compare: '比较复刻玩法录像与参考视频，并抽取成对证据',
-        processing: 'static | agentic，默认 static',
-        reference: '本地原始参考视频', analysis: '已完成的参考分析 analysis.json',
-        candidate: '本地录制的候选视频', recording: '包含输入和对照证据的录制 metadata.json',
-        policy: '可选的版本化比较策略 JSON', kind: 'understanding | comparison，默认 understanding',
-        invalidComparison: '比较参数或策略无效。',
-        unsafeOutput: '比较输出目录或制品包含符号链接或无效文件，请使用安全的输出目录。',
-        invalidRecording: '录制元数据、视频摘要、输入日志或对照证据无效。',
-        staleRecording: '工程在录制后发生了变化，请重新录制再比较。',
-        comparisonContext: '参考分析与参考视频不一致。',
-        comparisonResume: '比较请求不存在，或与任务、工作区不一致。',
-        comparisonUnavailable: '没有有权使用且支持所需比较模式的模型。',
-        comparisonResult: '比较服务返回的证据无效或不完整。',
-        comparisonFailed: '比较失败，请先核对已保存的请求和任务再重试。',
-        summary: '比较报告', decision: '策略结论', alignment: '模型事件配对',
-        differences: '模型观察到的差异和修改建议', coverage: '覆盖范围与未知项', evidence: '成对证据',
-        controls: '模型对交互对照的解释', coverageNotice: '结论仅覆盖本次录制场景；音频及未展示的玩法分支尚未评估。',
-        reportStatus: '结论', reportRequiredKinds: '必需事件类型', reportMissingKinds: '缺失事件类型',
-        reportMissingEvidence: '缺失或不确定的证据', reportTimingChecks: '确定性时序检查', reportNone: '无',
-        modelObservations: '模型观察', modelSummary: '模型摘要', modelDimensions: '模型维度判断',
-        modelObservationNotice: '以下内容是模型的观察和解释。模型判断为 pass，不会覆盖前面的策略结论或证据缺口。',
-        policyPassedNotice: '本次录制场景已通过策略验收。',
-        policyNotPassedNotice: '策略验收尚未通过，玩法等价性尚未得到验证。',
-        deterministicNotice: '以下覆盖范围和时序检查由确定性规则计算。即使模型判断为 pass，缺失证据的部分仍未得到验证。',
-        interactionUnverified: '交互尚未完整验证：必需的因果或对照证据缺失或不确定。',
-        timingUnverified: '时序尚未完整验证：证据精度或覆盖不足，无法满足策略容差。',
-        reasonReferenceKindMissing: '参考分析缺少必需的事件类型。',
-        reasonEventPairMissing: '参考视频与候选视频缺少达到置信度要求的事件配对。',
-        reasonDimensionUncertain: '模型对该维度的判断不确定，或未达到置信度要求。',
-        reasonDimensionEventMissing: '该维度尚未覆盖必需事件。',
-        reasonProgressionEvidenceMissing: '事件进展的时序证据缺失或不足。',
-        reasonTimingPrecisionInsufficient: '时序证据的精度或覆盖不足，无法按策略容差得出结论。',
-        reasonTimingFailureUnverified: '模型报告的时序失败尚未得到确定性时序检查的确认。',
-        reasonRequiredEffectsMissing: '必需的玩法结果尚未关联到录制输入步骤。',
-        reasonControlRuntimeUncertain: '对照录制存在运行错误或网络请求失败。',
-        reasonControlEvidenceMissing: '必需的对照证据缺失、不确定，或未覆盖候选结果的时间窗口。',
-        reasonRequestsFailed: '候选录制存在网络请求失败。',
-        reportScope: '范围', reportModel: '模型', reportPolicy: '策略', reportRecording: '录制',
-        reportExpected: '预期', reportObserved: '实际', reportSuggestedFix: '修改建议',
-        reportConfidence: '置信度', reportEvidence: '证据', reportReference: '参考', reportCandidate: '候选',
-        reportRequired: '必需', reportEvaluated: '已评估', reportMissing: '缺失', reportTiming: '时序',
-        reportTolerance: '容差', reportRequested: '请求时刻', reportDecoded: '解码时刻', reportFrame: '帧',
-    },
-};
-export function comparisonMessage(key) {
-    const locale = process.env.PLAYCRAFT_LANGUAGE || process.env.LANG || 'en';
-    return messages[locale.startsWith('zh') ? 'zh' : 'en'][key];
-}
-export class ComparisonCliError extends Error {
-    code;
-    exitCode;
-    constructor(code, exitCode = 4) {
-        super(comparisonMessage(code));
-        this.code = code;
-        this.exitCode = exitCode;
-    }
-}

package/dist/video-replication/comparison-output.js

@@ -1,63 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { lstat, mkdir, realpath, rename, rm, writeFile } from 'node:fs/promises';
-import { dirname, extname, isAbsolute, join, parse, resolve, sep } from 'node:path';
-import { ComparisonCliError } from './comparison-messages.js';
-export async function comparisonOutputRoot(root, create = false) {
-    const absolute = resolve(root), prefix = parse(absolute).root;
-    let current = prefix;
-    for (const part of absolute.slice(prefix.length).split(sep).filter(Boolean)) {
-        current = join(current, part);
-        if (create)
-            await mkdir(current, { mode: 0o700 }).catch(error => { if (error.code !== 'EEXIST')
-                throw error; });
-        const stat = await lstat(current);
-        if (stat.isSymbolicLink()) {
-            // macOS exposes system-managed temporary directories through these aliases.
-            const systemAlias = process.platform === 'darwin' && ['/tmp', '/var'].includes(current)
-                && await realpath(current) === `/private${current}`;
-            if (!systemAlias)
-                throw new ComparisonCliError('unsafeOutput', 64);
-            current = await realpath(current);
-        }
-        else if (!stat.isDirectory())
-            throw new ComparisonCliError('unsafeOutput', 64);
-    }
-    return realpath(current);
-}
-/** Refuse linked output directories and files, including artifacts left before resume. */
-export async function comparisonOutputPath(root, relative) {
-    if (isAbsolute(relative) || relative.includes('\\') || relative.split('/').some(part => !part || part === '.' || part === '..'))
-        throw new ComparisonCliError('unsafeOutput', 64);
-    let current = await comparisonOutputRoot(root);
-    const parts = relative.split('/');
-    for (const part of parts.slice(0, -1)) {
-        current = join(current, part);
-        await mkdir(current, { mode: 0o700 }).catch(error => { if (error.code !== 'EEXIST')
-            throw error; });
-        const stat = await lstat(current);
-        if (!stat.isDirectory() || stat.isSymbolicLink())
-            throw new ComparisonCliError('unsafeOutput', 64);
-    }
-    const path = join(current, parts.at(-1));
-    const stat = await lstat(path).catch(error => { if (error.code === 'ENOENT')
-        return undefined; throw error; });
-    if (stat && (!stat.isFile() || stat.isSymbolicLink()))
-        throw new ComparisonCliError('unsafeOutput', 64);
-    return path;
-}
-/** Writers use a private random sibling and replace the destination without following it. */
-export async function writeComparisonArtifact(root, relative, writer) {
-    const target = await comparisonOutputPath(root, relative);
-    const temporary = join(dirname(target), `.comparison-${randomUUID()}.tmp${extname(target)}`);
-    try {
-        await writer(temporary);
-        await comparisonOutputPath(root, relative);
-        await rename(temporary, target);
-    }
-    finally {
-        await rm(temporary, { force: true });
-    }
-}
-export async function writeComparisonJson(root, relative, value) {
-    await writeComparisonArtifact(root, relative, temporary => writeFile(temporary, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600, flag: 'wx' }));
-}

package/dist/video-replication/comparison-preflight.js

@@ -1,66 +0,0 @@
-import { readFile } from 'node:fs/promises';
-import { dirname, resolve } from 'node:path';
-import { canonicalReplicaJson, replicaRecordingMetadataSchema, videoUnderstandingAnalysisSchema, validateVideoUnderstandingContent, } from '@playcraft/common/agent-tools';
-import { computeProjectInputDigest } from '../recording/project-digest.js';
-import { probeVideo } from './media.js';
-import { ComparisonCliError } from './comparison-messages.js';
-import { validateComparisonConsoleLog, validateComparisonInputLog } from './comparison-log.js';
-import { comparisonSha256, readComparisonJson, recordingArtifactPath, verifyRecordingArtifact } from './comparison-files.js';
-function sameSource(actual, expected) {
-    return actual.sha256 === expected.sha256 && actual.sizeBytes === expected.sizeBytes && actual.mimeType === expected.mimeType
-        && Math.abs(actual.durationMs - expected.durationMs) < 1 && actual.width === expected.width && actual.height === expected.height;
-}
-/** Validate hashes and the live checkout before any managed upload or model submission. */
-export async function preflightComparison(input) {
-    const probe = input.probe ?? probeVideo;
-    let recording;
-    let analysis;
-    try {
-        recording = replicaRecordingMetadataSchema.parse(await readComparisonJson(input.recording));
-        analysis = videoUnderstandingAnalysisSchema.parse(await readComparisonJson(input.analysis));
-        validateVideoUnderstandingContent({ summary: analysis.summary, observations: analysis.observations, events: analysis.events, evidence: analysis.evidence, inferences: analysis.inferences, unknowns: analysis.unknowns, reconstructionHints: analysis.reconstructionHints }, analysis.source);
-    }
-    catch {
-        throw new ComparisonCliError('invalidRecording', 64);
-    }
-    if (comparisonSha256(canonicalReplicaJson(recording.scenario)) !== recording.scenarioSha256)
-        throw new ComparisonCliError('invalidRecording', 64);
-    const cwd = resolve(input.cwd ?? process.cwd());
-    const root = dirname(resolve(input.recording));
-    const current = await computeProjectInputDigest(cwd, [root, resolve(input.out)]);
-    if (resolve(recording.project.root) !== current.root || recording.project.sha256 !== current.sha256 || recording.project.fileCount !== current.fileCount)
-        throw new ComparisonCliError('staleRecording', 64);
-    const reference = await probe(resolve(input.reference), input.signal);
-    if (!sameSource(reference.source, analysis.source))
-        throw new ComparisonCliError('comparisonContext', 64);
-    const candidatePath = await recordingArtifactPath(root, recording.candidate.video.path);
-    const candidate = await probe(resolve(input.candidate), input.signal);
-    if (candidate.path !== candidatePath || !sameSource(candidate.source, recording.candidate.video.source))
-        throw new ComparisonCliError('invalidRecording', 64);
-    const inputs = [{ id: 'reference', role: 'reference', video: reference }, { id: recording.candidate.id, role: 'candidate', video: candidate }];
-    for (const artifact of [recording.candidate, ...recording.controls]) {
-        input.signal.throwIfAborted();
-        const events = await verifyRecordingArtifact(root, artifact.events);
-        const consolePath = await verifyRecordingArtifact(root, artifact.console);
-        for (const shot of artifact.screenshots ?? [])
-            await verifyRecordingArtifact(root, shot, 16 * 1024 * 1024);
-        // Logs must contain structured records; an empty candidate input log cannot establish real interaction.
-        const text = await readFile(events, 'utf8');
-        try {
-            const records = text.trim() ? text.trim().split('\n').map(line => JSON.parse(line)) : [];
-            validateComparisonInputLog(records, recording.scenario, artifact);
-            const consoleText = await readFile(consolePath, 'utf8');
-            validateComparisonConsoleLog(consoleText.trim() ? consoleText.trim().split('\n').map(line => JSON.parse(line)) : [], artifact);
-        }
-        catch {
-            throw new ComparisonCliError('invalidRecording', 64);
-        }
-        if (artifact.kind !== 'candidate') {
-            const video = await probe(await recordingArtifactPath(root, artifact.video.path), input.signal);
-            if (!sameSource(video.source, artifact.video.source))
-                throw new ComparisonCliError('invalidRecording', 64);
-            inputs.push({ id: artifact.id, role: 'control', video });
-        }
-    }
-    return { recording, analysis, inputs };
-}