@playcraft/cli 0.1.37-beta → 0.1.39-prod

package/dist/skill-registry/platform-package.js

@@ -1,100 +0,0 @@
-import { constants, promises as fs } from 'node:fs';
-import { extractBundleArchive } from '@playcraft/common/project-skills';
-import yaml from 'js-yaml';
-import { MAX_BUNDLE_BYTES, packSkillDirectory, parseSkillReference, sha256, } from './package.js';
-import { message, RegistryError } from './messages.js';
-const NATIVE_REFS = new Set([
-    'remix/playcraft-video-understanding',
-    'remix/playcraft-replica-validation',
-]);
-/** Preserve native manifest bytes; the server remains the authoritative bundle validator. */
-export function inspectNativePlatformArchive(archive) {
-    const invalid = () => {
-        throw new RegistryError('invalid_platform_bundle', message('invalidPlatformBundle'));
-    };
-    if (archive.length > MAX_BUNDLE_BYTES)
-        invalid();
-    const extracted = extractBundleArchive(archive, {
-        maxArchiveBytes: MAX_BUNDLE_BYTES,
-        maxExpandedBytes: MAX_BUNDLE_BYTES + 8 * 1024 * 1024,
-    });
-    if (extracted.issues.length || extracted.files.length > 512)
-        invalid();
-    let total = 0;
-    for (const file of extracted.files) {
-        total += file.data.length;
-        if (file.data.length > 16 * 1024 * 1024 || total > MAX_BUNDLE_BYTES)
-            invalid();
-    }
-    let manifest;
-    let frontmatter;
-    try {
-        manifest = JSON.parse(extracted.files.find((file) => file.path === 'manifest.json').data.toString('utf8'));
-        const markdown = extracted.files
-            .find((file) => file.path === 'SKILL.md')
-            .data.toString('utf8');
-        const block = markdown.match(/^---[ \t]*\r?\n([\s\S]*?)\r?\n---/);
-        frontmatter = yaml.load(block[1]);
-    }
-    catch {
-        return invalid();
-    }
-    const standalone = (value) => Array.isArray(value) && value.length === 1 && value[0] === 'sandbox-agent';
-    if (!manifest ||
-        !frontmatter ||
-        typeof manifest.skillRef !== 'string' ||
-        !NATIVE_REFS.has(manifest.skillRef) ||
-        typeof manifest.version !== 'string' ||
-        manifest.schemaVersion !== 2 ||
-        manifest.kind !== 'platform' ||
-        manifest.name !== manifest.skillRef.split('/')[1] ||
-        !standalone(manifest.surfaces) ||
-        !standalone(frontmatter.surfaces) ||
-        frontmatter.name !== manifest.name ||
-        frontmatter.version !== manifest.version ||
-        [manifest.imports, manifest.relationships].some((value) => value !== undefined && (!Array.isArray(value) || value.length !== 0)))
-        invalid();
-    const { skillRef, version } = parseSkillReference(`${manifest.skillRef}@${manifest.version}`, true);
-    return {
-        skillRef,
-        version: version,
-        archive,
-        uploadHash: sha256(archive),
-        files: extracted.files.map((file) => ({ path: file.path, size: file.data.length })),
-    };
-}
-export async function packNativePlatformSource(source, options = {}) {
-    const stat = await fs.lstat(source);
-    if (stat.isSymbolicLink())
-        throw new RegistryError('invalid_platform_bundle', message('invalidPlatformBundle'));
-    if (stat.isDirectory()) {
-        const bundle = await packSkillDirectory(source, { ...options, preserveManifest: true });
-        return inspectNativePlatformArchive(bundle.archive);
-    }
-    if (!stat.isFile() || stat.nlink !== 1 || stat.size > MAX_BUNDLE_BYTES)
-        throw new RegistryError('invalid_platform_bundle', message('invalidPlatformBundle'));
-    const handle = await fs.open(source, constants.O_RDONLY | constants.O_NOFOLLOW);
-    try {
-        const opened = await handle.stat();
-        if (opened.ino !== stat.ino || opened.dev !== stat.dev || opened.size !== stat.size)
-            throw new RegistryError('invalid_platform_bundle', message('invalidPlatformBundle'));
-        const archive = Buffer.alloc(stat.size + 1);
-        let length = 0;
-        while (length < archive.length) {
-            const read = await handle.read(archive, length, archive.length - length, null);
-            if (!read.bytesRead)
-                break;
-            length += read.bytesRead;
-        }
-        if (length !== stat.size)
-            throw new RegistryError('invalid_platform_bundle', message('invalidPlatformBundle'));
-        const bundle = inspectNativePlatformArchive(archive.subarray(0, length));
-        if ((options.ref && options.ref !== bundle.skillRef) ||
-            (options.version && options.version !== bundle.version))
-            throw new RegistryError('manifest_conflict', message('manifestConflict'));
-        return bundle;
-    }
-    finally {
-        await handle.close();
-    }
-}

package/dist/utils/environment-endpoints.js

@@ -1,17 +0,0 @@
-function publicBase(value) {
-    const base = new URL(value);
-    if (!['http:', 'https:'].includes(base.protocol) || base.username || base.password || base.search || base.hash) {
-        throw new Error('invalid_environment_endpoint');
-    }
-    base.pathname = base.pathname.replace(/\/+$/, '');
-    return base;
-}
-function append(base, path) {
-    return new URL(`${base.toString().replace(/\/+$/, '')}/${path.replace(/^\/+/, '')}`);
-}
-/** Accept either a public deployment base or its /api endpoint, without duplicating /api. */
-export function businessEndpoint(apiUrl, path) {
-    const base = publicBase(apiUrl);
-    base.pathname = base.pathname.replace(/\/api$/, '');
-    return append(base, path);
-}

package/dist/utils/tool-operation-journal.js

@@ -1,124 +0,0 @@
-import { createHash, randomUUID } from 'node:crypto';
-import { mkdirSync, readdirSync, readFileSync, writeFileSync, renameSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { isAbsolute, join } from 'node:path';
-import { isAgentToolRequestId } from '@playcraft/common/agent-tools';
-/** Operations this process is sending now; never continued by another call of this process. */
-const inFlight = new Set();
-/** Linux start time of a process, so a reused pid is not taken for the process that held it. */
-function startOf(pid) {
-    try {
-        const stat = readFileSync(`/proc/${pid}/stat`, 'utf8');
-        return stat.slice(stat.lastIndexOf(')') + 2).split(' ')[19] ?? null;
-    }
-    catch {
-        return null;
-    }
-}
-function holderAlive(holder) {
-    if (!holder || holder.pid === process.pid)
-        return false;
-    try {
-        process.kill(holder.pid, 0);
-    }
-    catch (error) {
-        if (error.code !== 'EPERM')
-            return false;
-    }
-    return holder.start === null || startOf(holder.pid) === holder.start;
-}
-/** Persist an identity before sending. Store neither credentials nor request/response bodies. */
-export function beginToolOperation(path, serializedBody, recoverId, options = {}) {
-    const directory = process.env.PLAYCRAFT_TOOL_REQUEST_DIR ?? join(homedir(), '.playcraft', 'tool-requests');
-    if (!isAbsolute(directory))
-        throw new Error('PLAYCRAFT_TOOL_REQUEST_DIR must be an absolute path');
-    mkdirSync(directory, { recursive: true, mode: 0o700 });
-    const inputHash = createHash('sha256').update(serializedBody).digest('hex');
-    // Rerunning the same command while its outcome is unknown continues that operation: the server
-    // answers the same identity with its receipt instead of running it again.
-    const unconfirmed = recoverId === undefined && !options.newRequest
-        ? findUnconfirmed(directory, path, inputHash)
-        : undefined;
-    const identifier = recoverId ?? unconfirmed?.requestId ?? randomUUID();
-    if (!isAgentToolRequestId(identifier))
-        throw new Error('Invalid PLAYCRAFT_TOOL_REQUEST_ID');
-    const requestId = identifier.toLowerCase();
-    const file = join(directory, `${requestId}.json`);
-    const now = new Date().toISOString();
-    const holder = { pid: process.pid, start: startOf(process.pid) };
-    const entry = {
-        version: 1,
-        requestId,
-        path,
-        inputHash,
-        state: 'unconfirmed',
-        holder,
-        createdAt: now,
-        updatedAt: now,
-    };
-    let createdNew = false;
-    try {
-        writeFileSync(file, JSON.stringify(entry), { flag: 'wx', mode: 0o600 });
-        createdNew = true;
-    }
-    catch (error) {
-        if (error.code !== 'EEXIST')
-            throw error;
-        const previous = JSON.parse(readFileSync(file, 'utf8'));
-        if (previous.version !== 1 ||
-            previous.requestId !== requestId ||
-            previous.path !== path ||
-            previous.inputHash !== inputHash)
-            throw new Error(`Tool request ${requestId} conflicts with its durable local record`);
-    }
-    const update = (change) => {
-        const current = JSON.parse(readFileSync(file, 'utf8'));
-        const temporary = `${file}.${randomUUID()}.tmp`;
-        writeFileSync(temporary, JSON.stringify({ ...current, ...change, updatedAt: new Date().toISOString() }), { flag: 'wx', mode: 0o600 });
-        renameSync(temporary, file);
-    };
-    // Only the sender holds an operation; a concurrent run of the same command gets its own.
-    inFlight.add(requestId);
-    if (unconfirmed || recoverId !== undefined)
-        update({ holder });
-    return {
-        requestId,
-        /** This call created the identity; a refusal cannot settle an older unknown operation. */
-        createdNew,
-        /** An explicit recovery, or a server that did not acknowledge the identity, reads only. */
-        settledOnly: recoverId !== undefined || unconfirmed?.receiptOnly === true,
-        file,
-        complete: () => update({ state: 'completed' }),
-        /** A definite refusal: the request was not carried out, so a rerun is a new operation. */
-        reject: () => update({ state: 'rejected' }),
-        /** The outcome stays unknown and a rerun may only read the receipt. */
-        requireReceipt: () => update({ receiptOnly: true }),
-        /** This call is done with the operation; a later run of the command may continue it. */
-        release: () => inFlight.delete(requestId),
-    };
-}
-function findUnconfirmed(directory, path, inputHash) {
-    let latest;
-    for (const name of readdirSync(directory)) {
-        if (!name.endsWith('.json'))
-            continue;
-        try {
-            const entry = JSON.parse(readFileSync(join(directory, name), 'utf8'));
-            if (entry.version === 1 &&
-                entry.state === 'unconfirmed' &&
-                entry.path === path &&
-                entry.inputHash === inputHash &&
-                isAgentToolRequestId(entry.requestId) &&
-                (!latest || entry.updatedAt > latest.updatedAt) &&
-                // Still being sent, here or by another live process: that run is not interrupted.
-                // Checked last, so only this command's candidates cost a process probe.
-                !inFlight.has(entry.requestId) &&
-                !holderAlive(entry.holder))
-                latest = entry;
-        }
-        catch {
-            // A torn or foreign file is not an operation of this command.
-        }
-    }
-    return latest;
-}

package/dist/utils/video-evidence-git.js

@@ -1,81 +0,0 @@
-import { constants } from 'node:fs';
-import { lstat, mkdir, open, realpath } from 'node:fs/promises';
-import { dirname, join } from 'node:path';
-const ENTRY = '/.playcraft/video-replication/';
-/** Keep local analysis evidence out of a repository without changing its tracked ignore rules. */
-export async function ensureVideoEvidenceGitExcluded(directory) {
-    let root = await realpath(directory);
-    while (true) {
-        const marker = await lstat(join(root, '.git')).catch((error) => {
-            if (error.code === 'ENOENT')
-                return undefined;
-            throw error;
-        });
-        if (marker) {
-            // Cloud workspaces own a real .git directory; never follow a redirected Git metadata tree.
-            if (!marker.isDirectory() || marker.isSymbolicLink())
-                return false;
-            try {
-                await appendExclude(root);
-                return true;
-            }
-            catch (error) {
-                if (['EACCES', 'EPERM', 'EROFS'].includes(error.code ?? ''))
-                    return false;
-                throw error;
-            }
-        }
-        const parent = dirname(root);
-        if (parent === root)
-            return true;
-        root = parent;
-    }
-}
-async function appendExclude(root) {
-    const flags = constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW;
-    const handles = [];
-    let file;
-    try {
-        const directory = await open(root, flags);
-        handles.push(directory);
-        const pinned = (handle, fallback) => process.platform === 'linux' ? `/proc/self/fd/${handle.fd}` : fallback;
-        const git = await open(join(pinned(directory, root), '.git'), flags);
-        handles.push(git);
-        const gitPath = pinned(git, join(root, '.git'));
-        await mkdir(join(gitPath, 'info')).catch((error) => {
-            if (error.code !== 'EEXIST')
-                throw error;
-        });
-        const info = await open(join(gitPath, 'info'), flags);
-        handles.push(info);
-        const exclude = join(pinned(info, join(root, '.git/info')), 'exclude');
-        const readable = await open(exclude, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK)
-            .catch((error) => { if (error.code === 'ENOENT')
-            return undefined; throw error; });
-        if (readable) {
-            try {
-                const stat = await readable.stat();
-                if (!stat.isFile() || stat.nlink !== 1 || stat.size > 1024 * 1024)
-                    throw new Error('invalid_git_exclude');
-                if ((await readable.readFile('utf8')).split('\n').some(line => line.trim() === ENTRY))
-                    return;
-            }
-            finally {
-                await readable.close();
-            }
-        }
-        file = await open(exclude, constants.O_RDWR | constants.O_CREAT | constants.O_APPEND | constants.O_NOFOLLOW | constants.O_NONBLOCK, 0o666);
-        const stat = await file.stat();
-        if (!stat.isFile() || stat.nlink !== 1 || stat.size > 1024 * 1024)
-            throw new Error('invalid_git_exclude');
-        const current = await file.readFile('utf8');
-        if (!current.split('\n').some(line => line.trim() === ENTRY)) {
-            await file.writeFile(`${current && !current.endsWith('\n') ? '\n' : ''}${ENTRY}\n`);
-        }
-    }
-    finally {
-        await file?.close();
-        for (const handle of handles.reverse())
-            await handle.close();
-    }
-}

package/dist/video-replication/client.js

@@ -1,222 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { readFile, stat } from 'node:fs/promises';
-import { basename, dirname, join, resolve } from 'node:path';
-import { setTimeout as delay } from 'node:timers/promises';
-import { videoAnalysisRequestSchema, videoAnalysisRunSchema, videoMediaInitResultSchema, videoMediaResultSchema, videoModelCatalogSchema, videoUnderstandingAnalysisSchema, } from '@playcraft/common/agent-tools';
-import { VideoCliError, videoMessage } from './messages.js';
-import { openVideo, verifyVideo } from './media.js';
-import { loadSavedRequest, prepareArtifactDirectory, writeJsonAtomic, } from './evidence.js';
-const uuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-export function requireVideoId(value) {
-    if (!uuid.test(value))
-        throw new VideoCliError('invalidArguments', 64);
-    return value.toLowerCase();
-}
-export async function resolveVideoWorkspace(explicit, cwd = process.cwd()) {
-    let context;
-    for (let path = resolve(cwd);; path = dirname(path)) {
-        try {
-            const file = join(path, '.playcraft/workspace-context.json');
-            if ((await stat(file)).size > 8192)
-                throw new VideoCliError('workspaceMissing', 64);
-            const value = JSON.parse(await readFile(file, 'utf8'));
-            if (value.schemaVersion !== 'playcraft.workspace-context.v1' || typeof value.workspaceId !== 'string')
-                throw new VideoCliError('workspaceMissing', 64);
-            context = requireVideoId(value.workspaceId);
-            break;
-        }
-        catch (error) {
-            if (error.code !== 'ENOENT')
-                throw error;
-        }
-        if (dirname(path) === path)
-            break;
-    }
-    const workspace = explicit === undefined ? context : requireVideoId(explicit);
-    if (!workspace)
-        throw new VideoCliError('workspaceMissing', 64);
-    if (context && explicit && context !== workspace)
-        throw new VideoCliError('workspaceMismatch', 64);
-    return workspace;
-}
-export function parseVideoPolicy(options) {
-    const processing = options.processing ?? 'auto';
-    if (!['auto', 'agentic', 'static'].includes(processing))
-        throw new VideoCliError('invalidArguments', 64);
-    const fps = options.fps === undefined ? undefined : Number(options.fps);
-    if (fps !== undefined && ![1, 2, 4, 8].includes(fps))
-        throw new VideoCliError('invalidArguments', 64);
-    let clip;
-    if (options.clip !== undefined) {
-        if (!/^\d+(?:\.\d+)?:\d+(?:\.\d+)?$/.test(options.clip))
-            throw new VideoCliError('invalidArguments', 64);
-        const [startMs, endMs] = options.clip.split(':').map(value => Number(value) * 1000);
-        if (!Number.isFinite(endMs) || endMs <= startMs)
-            throw new VideoCliError('invalidArguments', 64);
-        clip = { startMs, endMs };
-    }
-    if (processing === 'agentic' && (fps !== undefined || clip))
-        throw new VideoCliError('invalidArguments', 64);
-    return { processing: processing, ...(fps !== undefined && { fps: fps }), ...(clip && { clip }) };
-}
-export function videoTimeout(options) {
-    const seconds = options.timeout === undefined ? 600 : Number(options.timeout);
-    if (!Number.isFinite(seconds) || seconds <= 0 || seconds > 86_400)
-        throw new VideoCliError('invalidArguments', 64);
-    return seconds * 1000;
-}
-async function readContext(path, video) {
-    if (!path)
-        return undefined;
-    try {
-        if ((await stat(path)).size > 2 * 1024 * 1024)
-            throw new Error('large');
-        const analysis = videoUnderstandingAnalysisSchema.parse(JSON.parse(await readFile(path, 'utf8')));
-        if (analysis.source.sha256 !== video.source.sha256)
-            throw new Error('different video');
-        return analysis;
-    }
-    catch {
-        throw new VideoCliError('invalidContext', 64);
-    }
-}
-export async function uploadVideo(video, workspaceId, deps, signal) {
-    const mediaId = randomUUID();
-    const init = videoMediaInitResultSchema.parse(await deps.client.post('/video-media/init', {
-        workspaceId, mediaId, filename: basename(video.path), sha256: video.source.sha256,
-        sizeBytes: video.source.sizeBytes, mimeType: video.source.mimeType, contentMd5: video.contentMd5,
-    }, { signal }));
-    if (init.mediaId !== mediaId || Date.parse(init.upload.expiresAt) <= Date.now())
-        throw new VideoCliError('uploadFailed');
-    const file = await openVideo(video.path);
-    try {
-        await verifyVideo(file, video.source);
-        const stream = file.createReadStream({ start: 0, autoClose: false });
-        if (init.upload.authenticated) {
-            await deps.client.putVideoMedia(init.upload.url, stream, init.upload.headers, signal);
-        }
-        else {
-            const url = new URL(init.upload.url);
-            const allowed = new Set(['content-type', 'content-md5', 'content-length', 'x-cos-acl']);
-            if (url.protocol !== 'https:' || url.username || url.password || url.hash || Object.entries(init.upload.headers).some(([key, value]) => !allowed.has(key.toLowerCase()) || (key.toLowerCase() === 'x-cos-acl' && value !== 'private')))
-                throw new VideoCliError('uploadFailed');
-            const response = await fetch(url, { method: 'PUT', redirect: 'error', signal, headers: init.upload.headers, body: stream, duplex: 'half' });
-            if (!response.ok) {
-                await response.body?.cancel();
-                throw new VideoCliError('uploadFailed');
-            }
-            await response.body?.cancel();
-        }
-        await verifyVideo(file, video.source);
-    }
-    finally {
-        await file.close();
-    }
-    const finalized = videoMediaResultSchema.parse(await deps.client.post('/video-media/finalize', { workspaceId, mediaId }, { signal }));
-    if (finalized.mediaId !== mediaId || finalized.source.sha256 !== video.source.sha256 || finalized.source.sizeBytes !== video.source.sizeBytes)
-        throw new VideoCliError('sourceChanged');
-    return mediaId;
-}
-export async function readVideoRun(client, runId, workspaceId, signal) {
-    const run = videoAnalysisRunSchema.parse(await client.get(`/video-analysis/${runId}`, { workspaceId }, { signal }));
-    if (run.runId !== runId || run.workspaceId !== workspaceId || (run.analysis && run.analysis.runId !== runId))
-        throw new VideoCliError('invalidResult');
-    return run;
-}
-async function waitForVideoRun(run, deps, signal) {
-    while (['pending', 'uploading', 'submitting', 'running'].includes(run.state)) {
-        deps.progress('waiting');
-        await delay(Math.max(250, Math.min(run.pollAfterMs, 10_000)), undefined, { signal });
-        run = await readVideoRun(deps.client, run.runId, run.workspaceId, signal);
-    }
-    return run;
-}
-export async function executeVideoUnderstanding(options, signal, deps) {
-    let runId;
-    let out;
-    let saved;
-    let submitted = false;
-    try {
-        const workspaceId = await resolveVideoWorkspace(options.workspace);
-        const policy = parseVideoPolicy(options);
-        if (options.question !== undefined && (!options.question.trim() || options.question.length > 8000))
-            throw new VideoCliError('invalidArguments', 64);
-        if (options.resume && [options.video, options.question, options.context, options.processing, options.fps, options.clip, options.modelConfig].some(value => value !== undefined))
-            throw new VideoCliError('invalidArguments', 64);
-        if (!options.resume && !options.video)
-            throw new VideoCliError('invalidArguments', 64);
-        runId = options.resume ? requireVideoId(options.resume) : randomUUID();
-        out = resolve(options.out ?? join('.playcraft/video-replication', runId));
-        await prepareArtifactDirectory(out, runId, !!options.resume);
-        let run;
-        if (options.resume) {
-            saved = await loadSavedRequest(out, runId, workspaceId);
-            submitted = true;
-            // Recovery only reads the existing task. No upload or POST can be triggered here.
-            run = await readVideoRun(deps.client, runId, workspaceId, signal);
-            if (saved.request && run.mediaId !== saved.request.mediaId)
-                throw new VideoCliError('invalidResult');
-        }
-        else {
-            deps.progress('probing');
-            const video = await deps.probe(resolve(options.video), signal);
-            if (policy.clip && policy.clip.endMs > video.source.durationMs)
-                throw new VideoCliError('invalidArguments', 64);
-            const context = await readContext(options.context, video);
-            const catalog = videoModelCatalogSchema.parse(await deps.client.get('/video-models', { workspaceId }, { signal }));
-            const configId = options.modelConfig ? requireVideoId(options.modelConfig) : catalog.defaultConfigId;
-            const model = catalog.models.find(item => item.configId === configId);
-            const mode = policy.processing === 'auto'
-                ? policy.fps !== undefined || policy.clip || !model?.processing.includes('agentic') ? 'static' : 'agentic'
-                : policy.processing;
-            if (!model || !model.processing.includes(mode))
-                throw new VideoCliError('modelUnavailable', 64);
-            saved = { schemaVersion: 'playcraft.video-request.v1', runId, workspaceId, videoPath: video.path, out, state: 'uploading', createdAt: new Date().toISOString() };
-            await writeJsonAtomic(join(out, 'request.json'), saved);
-            deps.progress('uploading');
-            const mediaId = await uploadVideo(video, workspaceId, deps, signal);
-            const request = videoAnalysisRequestSchema.parse({
-                workspaceId, runId, mediaId, modelConfigId: configId, ...policy,
-                ...(options.question && { question: options.question }), ...(context && { context }),
-            });
-            saved = { ...saved, request, state: 'submitting' };
-            await writeJsonAtomic(join(out, 'request.json'), saved);
-            deps.progress('submitting');
-            submitted = true;
-            run = videoAnalysisRunSchema.parse(await deps.client.post('/video-analysis', request, {
-                signal,
-                onPrepared: async (operation) => {
-                    saved = { ...saved, requestId: operation.requestId };
-                    await writeJsonAtomic(join(out, 'request.json'), saved);
-                },
-            }));
-            if (run.runId !== runId || run.workspaceId !== workspaceId || run.mediaId !== mediaId)
-                throw new VideoCliError('invalidResult');
-        }
-        run = await waitForVideoRun(run, deps, signal);
-        await writeJsonAtomic(join(out, 'task.json'), run);
-        if (run.state === 'uncertain')
-            throw new VideoCliError('uncertain', 75);
-        if (run.state !== 'completed')
-            return {
-                exitCode: 4, envelope: { schemaVersion: 'playcraft.video-cli.v1', command: 'video understand', runId, state: run.state, ok: false, artifacts: { request: join(out, 'request.json') }, error: { code: run.error?.code ?? 'remoteFailed', message: videoMessage('remoteFailed') } },
-            };
-        if (!run.analysis || !saved || run.analysis.runId !== runId ||
-            (saved.request?.modelConfigId && run.analysis.model.configId !== saved.request.modelConfigId))
-            throw new VideoCliError('invalidResult');
-        deps.progress('extracting');
-        const artifacts = await deps.materialize({ analysis: run.analysis, sourcePath: saved.videoPath, out, request: saved.request, signal });
-        await writeJsonAtomic(join(out, 'request.json'), { ...saved, state: 'completed' });
-        return { exitCode: 0, envelope: { schemaVersion: 'playcraft.video-cli.v1', command: 'video understand', runId, state: 'completed', ok: true, artifacts } };
-    }
-    catch (error) {
-        const timeout = signal.aborted && signal.reason?.name === 'TimeoutError';
-        const interrupted = signal.aborted && !timeout;
-        const known = error instanceof VideoCliError;
-        const code = timeout ? 'timeoutReached' : interrupted ? 'interrupted' : known ? error.code : submitted ? 'uncertain' : 'failed';
-        const exitCode = timeout ? 75 : interrupted ? 130 : known ? error.exitCode : submitted ? 75 : 4;
-        if (saved && out && submitted && (exitCode === 75 || exitCode === 130))
-            await writeJsonAtomic(join(out, 'request.json'), { ...saved, state: 'uncertain' }).catch(() => { });
-        return { exitCode, envelope: { schemaVersion: 'playcraft.video-cli.v1', command: 'video understand', runId, state: exitCode === 75 || exitCode === 130 ? 'uncertain' : 'failed', ok: false, ...(saved && out && { artifacts: { request: join(out, 'request.json') } }), error: { code, message: videoMessage(code), ...(interrupted && { remoteCancellationConfirmed: false }) } } };
-    }
-}