frameyard 0.7.0 → 0.9.0

package/dist/cli.js

@@ -1,20 +1,53 @@
 #!/usr/bin/env node
 import { access, mkdir, readFile, rmdir, stat, writeFile } from "node:fs/promises";
+import { cpus, freemem, loadavg, totalmem } from "node:os";
 import path from "node:path";
+import { createInterface } from "node:readline/promises";
 import { isPlainObject } from "./contracts.js";
 import { FrameyardError, errorMessage, isFrameyardError } from "./errors.js";
 import { loadProject, resolveProjectRoot } from "./project.js";
+import { assertOperationAllowed, assertOverwriteAllowed, assertPolicyTier, assertProfileLimit, assertStillFrameLimit, describePolicy, loadResourcePolicy, lowerProcessPriority, MAX_STILL_FRAMES, policyDetails, resolveProfile, SHARED_CPU_MAX_CONCURRENCY, SHARED_CPU_MAX_WORKERS, shouldLowerPriority, } from "./policy.js";
+import { lintComposition, lintResolvedTimeline, lintTimeline } from "./lint.js";
+import { buildProjectContext } from "./context.js";
+import { analyzeRgba, compareRgba, decodeRgba, probeImage } from "./inspect.js";
+import { findTemplate, listTemplates, templateRegistration } from "./templates.js";
+import { planTimelineRender } from "./timeline/plan.js";
+import { resolveProjectTimeline } from "./timeline/resolve.js";
 import { checkComposition, captureStills, MAX_RENDER_CONCURRENCY, renderComposition, validateRenderConcurrency, } from "./renderer/index.js";
 import { MAX_TIMELINE_WORKERS, captureTimelineStills, checkTimeline, renderTimeline, } from "./renderer/timeline.js";
 import { assertContainerCodec, CONTAINER_EXTENSION, defaultCodecForContainer, encoderNameFor, } from "./renderer/ffmpeg.js";
 import { startPreviewServer } from "./server/server.js";
-import { scaffoldFiles, SCAFFOLD_NEXT } from "./scaffold.js";
+import { localModelScaffoldFiles, scaffoldFiles, SCAFFOLD_NEXT } from "./scaffold.js";
 import { VERSION } from "./version.js";
 import { transcribeAudio } from "./assets/transcribe.js";
 import { synthesizeSpeech } from "./assets/tts.js";
+import { isSupertonicLanguage, parseSupertonicSpeaker, resolveSupertonicModelFiles, SUPERTONIC_LANGUAGES, } from "./assets/tts-supertonic.js";
 import { resolveManifestPath } from "./assets/provenance.js";
 import { runDoctor } from "./doctor.js";
-const COMMANDS = new Set(["init", "dev", "check", "still", "render", "tts", "transcribe", "doctor", "help"]);
+import { addLocalFont, removeFont } from "./fonts/add.js";
+import { addFontsource, addUrlFont, searchFontsource } from "./fonts/fontsource.js";
+import { fontManifestPath, readFontManifest } from "./fonts/manifest.js";
+import { parseFontStyle, parseFontWeight } from "./fonts/options.js";
+import { summarizeFont } from "./fonts/summary.js";
+import { assertFontIntegrity, fontStatuses, verifyFontManifest } from "./fonts/verify.js";
+import { emptyFontManifest } from "./fonts/types.js";
+const COMMANDS = new Set([
+    "init",
+    "dev",
+    "context",
+    "lint",
+    "check",
+    "still",
+    "inspect",
+    "compare",
+    "render",
+    "tts",
+    "transcribe",
+    "add",
+    "font",
+    "doctor",
+    "help",
+]);
 const VALUE_FLAGS = new Set([
     "project",
     "props",
@@ -29,6 +62,8 @@ const VALUE_FLAGS = new Set([
     "container",
     "text-file",
     "speaker",
+    "engine",
+    "model-dir",
     "talker-model",
     "codec-model",
     "style",
@@ -39,10 +74,38 @@ const VALUE_FLAGS = new Set([
     "export",
     "manifest",
     "qwen-tts",
+    "sherpa-onnx-tts",
     "whisper-cli",
+    "profile",
+    "template",
+    "file",
+    "family",
+    "id",
+    "weight",
+    "subset",
+    "unicode-range",
+    "license",
+    "license-file",
+    "category",
+    "limit",
+    "url",
+    "sha256",
+]);
+const BOOLEAN_FLAGS = new Set([
+    "json",
+    "overwrite",
+    "force",
+    "words",
+    "dry-run",
+    "low-priority",
+    "list",
+    "local-models",
+    "keep-files",
+    "static",
+    "variable",
+    "help",
+    "version",
 ]);
-const BOOLEAN_FLAGS = new Set(["json", "overwrite", "force", "words", "help", "version"]);
-const MAX_STILL_FRAMES = 32;
 function usage(message = "Invalid command line.") {
     throw new FrameyardError("USAGE", message);
 }
@@ -108,15 +171,47 @@ function parseArgs(argv) {
 }
 function allowedFlags(command) {
     const common = new Set(["project", "json", "help"]);
+    const resource = ["profile", "low-priority"];
     switch (command) {
         case "init":
-            return new Set(["json", "help"]);
+            return new Set(["json", "local-models", "help"]);
         case "dev":
             return new Set(["project", "port", "help"]);
-        case "check":
+        case "context":
+            return new Set(common);
+        case "lint":
             return new Set([...common, "props"]);
+        case "inspect":
+            return new Set(["json", "help"]);
+        case "compare":
+            return new Set(["json", "help"]);
+        case "add":
+            return new Set([...common, "template", "list"]);
+        case "font":
+            return new Set([
+                ...common,
+                "file",
+                "family",
+                "id",
+                "weight",
+                "style",
+                "subset",
+                "unicode-range",
+                "license",
+                "license-file",
+                "category",
+                "limit",
+                "url",
+                "sha256",
+                "static",
+                "variable",
+                "force",
+                "keep-files",
+            ]);
+        case "check":
+            return new Set([...common, "props", ...resource]);
         case "still":
-            return new Set([...common, "props", "out", "frame", "overwrite"]);
+            return new Set([...common, "props", "out", "frame", "overwrite", ...resource]);
         case "render":
             return new Set([
                 ...common,
@@ -129,12 +224,16 @@ function allowedFlags(command) {
                 "encoder",
                 "codec",
                 "container",
+                "dry-run",
+                ...resource,
             ]);
         case "tts":
             return new Set([
                 ...common,
                 "text-file",
                 "speaker",
+                "engine",
+                "model-dir",
                 "talker-model",
                 "codec-model",
                 "out",
@@ -144,11 +243,35 @@ function allowedFlags(command) {
                 "executable",
                 "manifest",
                 "force",
+                "dry-run",
+                ...resource,
             ]);
         case "transcribe":
-            return new Set([...common, "out", "model", "words", "export", "language", "executable", "manifest", "force"]);
+            return new Set([
+                ...common,
+                "out",
+                "model",
+                "words",
+                "export",
+                "language",
+                "executable",
+                "manifest",
+                "force",
+                "dry-run",
+                ...resource,
+            ]);
         case "doctor":
-            return new Set([...common, "manifest", "qwen-tts", "whisper-cli", "talker-model", "codec-model", "model"]);
+            return new Set([
+                ...common,
+                "manifest",
+                "qwen-tts",
+                "sherpa-onnx-tts",
+                "whisper-cli",
+                "talker-model",
+                "codec-model",
+                "model-dir",
+                "model",
+            ]);
         case "help":
             return new Set(["help"]);
         default:
@@ -170,7 +293,7 @@ function validateArgs(parsed) {
             usage(`Option --${flag} is not valid for "${parsed.command}".`);
         }
     }
-    if (["dev", "help", "doctor", "tts"].includes(parsed.command)) {
+    if (["dev", "help", "doctor", "tts", "context"].includes(parsed.command)) {
         if (parsed.positionals.length > 0) {
             usage(`"${parsed.command}" does not take a positional argument.`);
         }
@@ -180,13 +303,218 @@ function validateArgs(parsed) {
             usage(`"${parsed.command}" accepts at most 1 positional argument.`);
         }
     }
+    else if (parsed.command === "inspect") {
+        if (parsed.positionals.length !== 1) {
+            usage('"inspect" requires an image path.');
+        }
+    }
+    else if (parsed.command === "compare") {
+        if (parsed.positionals.length !== 2) {
+            usage('"compare" requires two image paths.');
+        }
+    }
+    else if (parsed.command === "add") {
+        if (parsed.flags.has("list")) {
+            if (parsed.positionals.length > 0) {
+                usage('"add --list" does not take positional arguments.');
+            }
+            if (parsed.flags.has("template")) {
+                usage("--template is only valid when adding an entry.");
+            }
+        }
+        else if (parsed.positionals[0] === "local-models") {
+            if (parsed.positionals.length !== 1) {
+                usage('"add local-models" does not take an id.');
+            }
+            if (parsed.flags.has("template")) {
+                usage('--template is not valid for "add local-models".');
+            }
+        }
+        else {
+            if (parsed.positionals.length !== 2) {
+                usage('"add" requires <composition|timeline> <id> and --template <name>, or "add local-models".');
+            }
+            const kind = parsed.positionals[0];
+            if (kind !== "composition" && kind !== "timeline") {
+                usage('"add" kind must be "composition", "timeline", or "local-models".');
+            }
+            const templateName = parsed.flags.get("template");
+            if (typeof templateName !== "string") {
+                usage('"add" requires --template <name>.');
+            }
+            const template = findTemplate(templateName);
+            if (!template) {
+                usage(`Unknown template "${templateName}". Available: ${listTemplates()
+                    .map((entry) => entry.name)
+                    .join(", ")}.`);
+            }
+            if (template.kind !== kind) {
+                usage(`Template "${templateName}" is a ${template.kind} template, not ${kind}.`);
+            }
+        }
+    }
+    else if (parsed.command === "font") {
+        const action = parsed.positionals[0];
+        if (action === "search") {
+            if (parsed.positionals.length > 2) {
+                usage('"font search" accepts at most one query.');
+            }
+            const query = parsed.positionals[1] ?? "";
+            const hasFilter = parsed.flags.has("category") ||
+                parsed.flags.has("subset") ||
+                parsed.flags.has("style") ||
+                parsed.flags.has("variable");
+            if (query.length === 0 && !hasFilter) {
+                usage('"font search" requires a query or a --category, --subset, --style, or --variable filter.');
+            }
+            for (const flag of [
+                "file",
+                "family",
+                "id",
+                "weight",
+                "url",
+                "license",
+                "license-file",
+                "sha256",
+                "force",
+                "keep-files",
+                "static",
+            ]) {
+                if (parsed.flags.has(flag)) {
+                    usage(`--${flag} is not valid for "font search".`);
+                }
+            }
+            const limit = parsed.flags.get("limit");
+            if (limit !== undefined &&
+                (typeof limit !== "string" || !/^\d+$/.test(limit) || Number(limit) < 1 || Number(limit) > 100)) {
+                usage("--limit must be an integer between 1 and 100.");
+            }
+        }
+        else if (action === "add") {
+            const file = typeof parsed.flags.get("file") === "string";
+            const url = typeof parsed.flags.get("url") === "string";
+            if (file && url) {
+                usage('"font add" accepts only one source: --file, --url, or a Fontsource id.');
+            }
+            if (parsed.flags.has("category") || parsed.flags.has("limit") || parsed.flags.has("variable")) {
+                usage('--category, --limit, and --variable are only valid for "font search".');
+            }
+            if (parsed.flags.has("keep-files")) {
+                usage('--keep-files is only valid for "font remove".');
+            }
+            if (parsed.flags.has("static") && file) {
+                usage("--static is only valid for a Fontsource id.");
+            }
+            if (parsed.flags.has("static") && url) {
+                usage("--static is only valid for a Fontsource id.");
+            }
+            if (file) {
+                if (parsed.positionals.length !== 1) {
+                    usage('"font add --file" does not take an id; use --id to override the derived font id.');
+                }
+                if (typeof parsed.flags.get("family") !== "string") {
+                    usage('"font add --file" requires --family <name>.');
+                }
+                if (parsed.flags.has("sha256")) {
+                    usage("--sha256 is only valid with --url.");
+                }
+            }
+            else if (url) {
+                if (parsed.positionals.length !== 1) {
+                    usage('"font add --url" does not take an id; use --id to override the derived font id.');
+                }
+                if (typeof parsed.flags.get("family") !== "string") {
+                    usage('"font add --url" requires --family <name>.');
+                }
+            }
+            else {
+                if (parsed.positionals.length !== 2) {
+                    usage('"font add" requires a Fontsource id, or --file/--url with --family.');
+                }
+                if (parsed.flags.has("id")) {
+                    usage("The Fontsource id is positional; --id is only valid with --file or --url.");
+                }
+                if (parsed.flags.has("license") || parsed.flags.has("license-file")) {
+                    usage("Fontsource supplies the license; --license/--license-file are only valid with --file or --url.");
+                }
+                if (parsed.flags.has("sha256")) {
+                    usage("--sha256 is only valid with --url.");
+                }
+                if (parsed.flags.has("unicode-range")) {
+                    usage("--unicode-range is only valid with --file or --url.");
+                }
+            }
+        }
+        else if (action === "list" || action === "verify") {
+            if (parsed.positionals.length !== 1) {
+                usage(`"font ${action}" does not take positional arguments.`);
+            }
+            for (const flag of [
+                "file",
+                "family",
+                "id",
+                "weight",
+                "style",
+                "subset",
+                "unicode-range",
+                "license",
+                "license-file",
+                "category",
+                "limit",
+                "url",
+                "sha256",
+                "static",
+                "variable",
+                "force",
+                "keep-files",
+            ]) {
+                if (parsed.flags.has(flag)) {
+                    usage(`--${flag} is not valid for "font ${action}".`);
+                }
+            }
+        }
+        else if (action === "remove") {
+            if (parsed.positionals.length !== 2) {
+                usage('"font remove" requires a font id.');
+            }
+            for (const flag of [
+                "file",
+                "family",
+                "id",
+                "weight",
+                "style",
+                "subset",
+                "unicode-range",
+                "license",
+                "license-file",
+                "category",
+                "limit",
+                "url",
+                "sha256",
+                "static",
+                "variable",
+                "force",
+            ]) {
+                if (parsed.flags.has(flag)) {
+                    usage(`--${flag} is not valid for "font remove".`);
+                }
+            }
+        }
+        else {
+            usage('"font" requires one of: search, add, list, verify, remove.');
+        }
+    }
     else if (parsed.positionals.length !== 1) {
         usage(`"${parsed.command}" requires a ${parsed.command === "transcribe"
             ? "source path"
-            : parsed.command === "render"
+            : parsed.command === "render" || parsed.command === "lint"
                 ? "composition or timeline id"
                 : "composition id"}.`);
     }
+    const profile = parsed.flags.get("profile");
+    if (profile !== undefined && profile !== "shared-cpu") {
+        usage('--profile must be "shared-cpu".');
+    }
     if (parsed.command === "still" && !parsed.flags.has("frame")) {
         usage('"still" requires --frame <spec>.');
     }
@@ -194,9 +522,47 @@ function validateArgs(parsed) {
         validateRenderConcurrency(Number(parsed.flags.get("concurrency")));
     }
     if (parsed.command === "tts") {
-        for (const required of ["speaker", "talker-model", "codec-model", "out"]) {
-            if (!parsed.flags.has(required)) {
-                usage(`"tts" requires --${required}.`);
+        const requestedEngine = parsed.flags.get("engine");
+        let engine = "qwen";
+        if (requestedEngine !== undefined) {
+            if (typeof requestedEngine !== "string" || (requestedEngine !== "qwen" && requestedEngine !== "supertonic")) {
+                usage('--engine must be "qwen" or "supertonic".');
+            }
+            engine = requestedEngine;
+        }
+        if (engine === "supertonic") {
+            for (const required of ["speaker", "model-dir", "language", "out"]) {
+                if (!parsed.flags.has(required)) {
+                    usage(`"tts" requires --${required} with --engine supertonic.`);
+                }
+            }
+            for (const forbidden of ["talker-model", "codec-model", "style", "device"]) {
+                if (parsed.flags.has(forbidden)) {
+                    usage(`--${forbidden} is not valid with --engine supertonic.`);
+                }
+            }
+            const speaker = parsed.flags.get("speaker");
+            if (typeof speaker === "string") {
+                try {
+                    parseSupertonicSpeaker(speaker);
+                }
+                catch (error) {
+                    usage(error instanceof Error ? error.message : String(error));
+                }
+            }
+            const language = parsed.flags.get("language");
+            if (typeof language === "string" && !isSupertonicLanguage(language)) {
+                usage(`--language must be one of: ${SUPERTONIC_LANGUAGES.join(", ")}.`);
+            }
+        }
+        else {
+            for (const required of ["speaker", "talker-model", "codec-model", "out"]) {
+                if (!parsed.flags.has(required)) {
+                    usage(`"tts" requires --${required}.`);
+                }
+            }
+            if (parsed.flags.has("model-dir")) {
+                usage("--model-dir is only valid with --engine supertonic.");
             }
         }
     }
@@ -234,81 +600,140 @@ function printHelp() {
 Local-first, deterministic video compositions authored with HTML, CSS, and JavaScript.
 
 Usage:
-  frameyard init [directory]
+  frameyard init [directory] [--local-models]
   frameyard dev [--port <port>] [--project <dir>]
-  frameyard check <composition-id> [--props <file>] [--project <dir>] [--json]
-  frameyard still <composition-or-timeline-id> --frame <spec> [--out <file-or-dir>] [--props <file>] [--project <dir>] [--json]
-  frameyard render <composition-or-timeline-id> [--out <video>] [--props <file>] [--project <dir>] [--concurrency <n>] [--workers <n>] [--encoder <name>] [--codec <name>] [--container <name>] [--scratch <dir>] [--overwrite] [--json]
-  frameyard tts --speaker <name> --talker-model <gguf> --codec-model <gguf> --out <file.wav> [--text-file <file>] [--style <text>] [--language <lang>] [--device <name>] [--executable <path>] [--manifest <file>] [--force] [--json]
-  frameyard transcribe <source> --model <gguf> --out <file.json> [--words] [--export srt,vtt] [--language <lang>] [--executable <path>] [--manifest <file>] [--force] [--json]
-  frameyard doctor [--qwen-tts <path>] [--whisper-cli <path>] [--talker-model <gguf>] [--codec-model <gguf>] [--model <gguf>] [--manifest <file>] [--project <dir>] [--json]
+  frameyard context [--project <dir>] [--json]
+  frameyard lint <composition-or-timeline-id> [--props <file>] [--project <dir>] [--json]
+  frameyard check <composition-id> [--props <file>] [--project <dir>] [--profile <name>] [--low-priority] [--json]
+  frameyard still <composition-or-timeline-id> --frame <spec> [--out <file-or-dir>] [--props <file>] [--project <dir>] [--profile <name>] [--low-priority] [--json]
+  frameyard inspect <image> [--json]
+  frameyard compare <first-image> <second-image> [--json]
+  frameyard render <composition-or-timeline-id> [--out <file>] [--props <file>] [--project <dir>] [--concurrency <n>] [--workers <n>] [--encoder <name>] [--codec <name>] [--container <name>] [--scratch <dir>] [--overwrite] [--dry-run] [--profile <name>] [--low-priority] [--json]
+  frameyard tts [--engine qwen] --speaker <name> --talker-model <gguf> --codec-model <gguf> --out <file.wav> [--text-file <file>] [--style <text>] [--language <lang>] [--device <name>] [--executable <path>] [--manifest <file>] [--force] [--dry-run] [--profile <name>] [--low-priority] [--json]
+  frameyard tts --engine supertonic --speaker <sid> --model-dir <dir> --language <code> --out <file.wav> [--text-file <file>] [--executable <path>] [--manifest <file>] [--force] [--dry-run] [--profile <name>] [--low-priority] [--json]
+  frameyard transcribe <source> --model <gguf> --out <file.json> [--words] [--export srt,vtt] [--language <lang>] [--executable <path>] [--manifest <file>] [--force] [--dry-run] [--profile <name>] [--low-priority] [--json]
+  frameyard add --list [--json]
+  frameyard add local-models [--project <dir>] [--json]
+  frameyard add <composition|timeline> <id> --template <name> [--project <dir>] [--json]
+  frameyard font search [query] [--category <category>] [--subset <subset>] [--style <normal|italic>] [--variable] [--limit <n>] [--json]
+  frameyard font add <fontsource-id> [--family <alias>] [--subset <subset>] [--style <normal|italic>] [--weight <n>] [--static] [--force] [--project <dir>] [--json]
+  frameyard font add --file <path> --family <name> [--id <id>] [--weight <n|n-n>] [--style normal|italic] [--subset <name>] [--license <id>] [--license-file <path>] [--force] [--project <dir>] [--json]
+  frameyard font add --url <https-url> --family <name> [--id <id>] [--weight <n|n-n>] [--style normal|italic] [--license <id>] [--license-file <path>] [--sha256 <hash>] [--force] [--project <dir>] [--json]
+  frameyard font list|verify [--project <dir>] [--json]
+  frameyard font remove <id> [--keep-files] [--project <dir>] [--json]
+  frameyard doctor [--qwen-tts <path>] [--sherpa-onnx-tts <path>] [--whisper-cli <path>] [--talker-model <gguf>] [--codec-model <gguf>] [--model-dir <dir>] [--model <gguf>] [--manifest <file>] [--project <dir>] [--json]
 
 Options:
   --project <dir>        Use a project other than the current directory.
   --props <file>         Composition props, or a { "<clip-id>": {...} } override map for a timeline.
-  --out <path>           Output path for still, render, tts, or transcribe. For still, one frame uses a .png file and multiple frames use a directory. Render defaults to out/<id>.mp4 in the project.
+  --out <path>           Output path for still, render, tts, or transcribe. For still, one frame uses a .png file and multiple frames use a directory. Render defaults to out/<id>.mp4 for video and out/<id>.png for a static composition.
   --frame <spec>         Still frames: n, n-m, or a comma-separated list (maximum 32 unique frames).
-  --concurrency <n>      Parallel browser sessions for composition render, 1-${MAX_RENDER_CONCURRENCY} (default: 1).
+  --concurrency <n>      Parallel browser sessions for animated composition render, 1-${MAX_RENDER_CONCURRENCY} (default: 1).
   --workers <n>          Parallel segment workers for timeline render, 1-${MAX_TIMELINE_WORKERS} (default: 8).
   --encoder <name>       Encoder: auto, software, nvenc, or qsv (default: auto).
   --codec <name>         Delivery codec for render: h264, hevc, or vp9 (default: h264; vp9 for webm).
   --container <name>     Delivery container: mp4, mov, mkv, or webm (default: mp4).
   --scratch <dir>        Scratch directory for timeline intermediates (default: system temp).
-  --overwrite            Replace an existing still or render output.
-  --force                Replace existing generated assets and manifest entries.
+  --overwrite            Replace an existing still or render output when the resource policy allows it.
+  --force                Replace existing generated assets and manifest entries when the resource policy allows it.
+  --dry-run              Validate and print the plan and handoff command without rendering, synthesizing, transcribing, or writing outputs.
+  --profile <name>       Resource profile for shared machines. shared-cpu caps workers at 2, concurrency at 1, and lowers process priority.
+  --low-priority         Lower the process priority without changing worker caps.
+  --local-models         With init, also install the optional local-model host scaffold.
+  --template <name>      Template for "add": static-poster, title-card, lower-third, or slideshow.
+  --list                 List add templates and scaffolds without writing files.
+  --file <path>          Local font file for "font add": .woff2, .woff, .ttf, or .otf.
+  --url <https-url>      Download a font from HTTPS (loopback HTTP is allowed for tests).
+  --family <name>        CSS font-family name or alias for "font add".
+  --id <id>              Override the font manifest id derived from the family name.
+  --weight <value>       Font weight or variable range; comma-separated weights for Fontsource --static.
+  --style <value>        qwen style instruction, or normal|italic (comma list for Fontsource).
+  --subset <name>        Font subset label; comma-separated for Fontsource.
+  --unicode-range <r>    CSS unicode-range for a local or URL font face.
+  --license <id>         License identifier for --file/--url; warns when omitted.
+  --license-file <path>  Copy a license file into the font directory.
+  --sha256 <hash>        Expected SHA-256 for --url; the computed hash is always recorded.
+  --category <name>      Fontsource category filter for "font search".
+  --limit <n>            Fontsource result limit for "font search", 1-100 (default: 20).
+  --variable             Fontsource search filter: only variable fonts.
+  --static               Install static Fontsource weights instead of the variable face.
+  --keep-files           Keep font files when removing a font from the manifest.
   --text-file <file>     Text to synthesize. Reads stdin when omitted.
-  --speaker <name>       Named speaker for CustomVoice speech synthesis.
-  --talker-model <gguf>  Talker GGUF model path.
-  --codec-model <gguf>   Codec GGUF model path.
-  --style <text>         Optional style instruction for speech synthesis.
-  --language <lang>      Spoken language, when known.
+  --speaker <value>      Named speaker for qwen, or the numeric speaker id for Supertonic.
+  --engine <name>        Speech engine: qwen or supertonic (default: qwen).
+  --model-dir <dir>      Supertonic model directory from the sherpa-onnx archive.
+  --talker-model <gguf>  Talker GGUF model path for qwen.
+  --codec-model <gguf>   Codec GGUF model path for qwen.
+  --style <value>        Optional qwen style instruction, or normal|italic for "font add".
+  --language <lang>      Spoken language. Supertonic requires one of its 31 upstream language codes.
   --device <name>        Compute device for qwen-tts, such as CPU or CUDA0.
   --model <gguf>         Whisper GGML model path.
   --words                Request measured word timings during transcription.
   --export srt,vtt       Derived subtitle exports next to the transcript.
-  --executable <path>    Explicit qwen-tts or whisper-cli executable.
-  --manifest <file>      Provenance manifest path (default: frameyard.assets.json).
+  --executable <path>    Explicit qwen-tts, sherpa-onnx-offline-tts, or whisper-cli executable.
+  --manifest <file>      Provenance manifest path (default: fy.assets.json).
   --qwen-tts <path>      qwen-tts executable to inspect with doctor.
+  --sherpa-onnx-tts <path>  sherpa-onnx-offline-tts executable to inspect with doctor.
   --whisper-cli <path>   whisper-cli executable to inspect with doctor.
   --json                 Print a structured result to stdout.
   --help, -h             Show this help.
   --version, -v          Print the version.
+
+Resource policy: the nearest fy.policy.json from the working directory upward sets light, authoring, or full; FRAMEYARD_POLICY overrides it. tts, transcribe, and render are blocked outside full. font add requires authoring or full; font remove and font add --force require full. Use --dry-run to validate and produce a handoff command without doing heavy work.
 `);
 }
 function printCommandHelp(command) {
     switch (command) {
         case "init":
-            process.stdout.write("Usage: frameyard init [directory]\nScaffold a minimal Frameyard project.\n");
+            process.stdout.write("Usage: frameyard init [directory] [--local-models]\nScaffold a minimal Frameyard project. Without a directory, init asks for a project name (default: my-video) and creates that directory; non-interactive and --json runs use the default. --local-models also installs the optional policy, OpenCode, and Pi scaffold.\n");
             return;
         case "dev":
             process.stdout.write("Usage: frameyard dev [--port <port>] [--project <dir>]\nStart the browser preview server.\n");
             return;
+        case "context":
+            process.stdout.write("Usage: frameyard context [--project <dir>] [--json]\nPrint a compact digest of the project, resolved timelines, assets, diagnostics, active policy, and next commands. It never launches Chromium.\n");
+            return;
+        case "lint":
+            process.stdout.write("Usage: frameyard lint <composition-or-timeline-id> [--props <file>] [--project <dir>] [--json]\nRun static validation, timeline resolution, scene and keyframe projection for every timeline frame, and a controller determinism scan without launching Chromium. It does not run validateProps or capture frames; use check for the full gate.\n");
+            return;
         case "check":
-            process.stdout.write("Usage: frameyard check <composition-id> [--props <file>] [--project <dir>] [--json]\nValidate props, assets, audio, and every frame without encoding.\n");
+            process.stdout.write("Usage: frameyard check <composition-id> [--props <file>] [--project <dir>] [--profile <name>] [--low-priority] [--json]\nValidate props, assets, audio, and every frame without encoding. The authoring policy lowers process priority for check.\n");
             return;
         case "still":
-            process.stdout.write("Usage: frameyard still <composition-or-timeline-id> --frame <spec> [--out <path>] [--props <file>] [--project <dir>] [--overwrite] [--json]\nCapture one or more frames through the production rendering path. <spec> is a frame number, an inclusive range like 2-12, or a comma-separated list, with at most 32 unique frames per invocation. With one frame, --out is a .png file; with multiple frames, --out is a directory.\n");
+            process.stdout.write("Usage: frameyard still <composition-or-timeline-id> --frame <spec> [--out <path>] [--props <file>] [--project <dir>] [--overwrite] [--profile <name>] [--low-priority] [--json]\nCapture one or more frames through the production rendering path. <spec> is a frame number, an inclusive range like 2-12, or a comma-separated list; the policy caps unique frames per invocation. With one frame, --out is a .png file; with multiple frames, --out is a directory. A static composition exposes only frame 0.\n");
+            return;
+        case "inspect":
+            process.stdout.write("Usage: frameyard inspect <image> [--json]\nDecode the first frame and report dimensions, alpha coverage, blank detection, background and dominant colors, content bbox, a coarse luminance grid, and edge density. It never launches Chromium.\n");
+            return;
+        case "compare":
+            process.stdout.write("Usage: frameyard compare <first-image> <second-image> [--json]\nCompare two decoded images pixel by pixel and by 3×3 region. Exits 1 when the images differ; the JSON result still has ok: true and identical: false.\n");
             return;
         case "render":
-            process.stdout.write(`Usage: frameyard render <composition-or-timeline-id> [--out <video>] [--props <file>] [--project <dir>] [--concurrency <n>] [--workers <n>] [--encoder <name>] [--codec <name>] [--container <name>] [--scratch <dir>] [--overwrite] [--json]\nRender an MP4, MOV, MKV, or WebM with H.264, HEVC, or VP9 video and AAC or Opus audio. The default output is out/<id>.<extension> in the project. Composition concurrency is 1-${MAX_RENDER_CONCURRENCY}; timeline workers are 1-${MAX_TIMELINE_WORKERS}. Encoder choices are auto, software, nvenc, and qsv; the default auto probes NVENC, then Quick Sync, then the codec's software encoder. WebM and VP9 use Opus audio, and HEVC in MP4/MOV keeps the hvc1 sample entry.\n`);
+            process.stdout.write(`Usage: frameyard render <composition-or-timeline-id> [--out <file>] [--props <file>] [--project <dir>] [--concurrency <n>] [--workers <n>] [--encoder <name>] [--codec <name>] [--container <name>] [--scratch <dir>] [--overwrite] [--dry-run] [--profile <name>] [--low-priority] [--json]\nRender an MP4, MOV, MKV, or WebM with H.264, HEVC, or VP9 video and AAC or Opus audio, or a PNG for a static composition. The default output is out/<id>.<extension> for video and out/<id>.png for a static composition. Animated composition concurrency is 1-${MAX_RENDER_CONCURRENCY}; timeline workers are 1-${MAX_TIMELINE_WORKERS}. The shared-cpu profile caps workers at 2 and concurrency at 1. Encoder choices are auto, software, nvenc, and qsv; the default auto probes NVENC, then Quick Sync, then the codec's software encoder. WebM and VP9 use Opus audio, and HEVC in MP4/MOV keeps the hvc1 sample entry. A static composition rejects --concurrency, --container, --codec, and --encoder. With --dry-run, validates and prints the plan and handoff command without writing outputs or launching Chromium.\n`);
             return;
         case "tts":
-            process.stdout.write("Usage: frameyard tts --speaker <name> --talker-model <gguf> --codec-model <gguf> --out <file.wav> [--text-file <file>] [--style <text>] [--language <lang>] [--device <name>] [--executable <path>] [--manifest <file>] [--force] [--json]\nProduce one frozen 24 kHz mono WAV with local qwentts.cpp CustomVoice synthesis.\n");
+            process.stdout.write("Usage: frameyard tts [--engine qwen] --speaker <name> --talker-model <gguf> --codec-model <gguf> --out <file.wav> [--text-file <file>] [--style <text>] [--language <lang>] [--device <name>] [--executable <path>] [--manifest <file>] [--force] [--dry-run] [--profile <name>] [--low-priority] [--json]\n       frameyard tts --engine supertonic --speaker <sid> --model-dir <dir> --language <code> --out <file.wav> [--text-file <file>] [--executable <path>] [--manifest <file>] [--force] [--dry-run] [--profile <name>] [--low-priority] [--json]\nProduce one frozen 24 kHz mono WAV with local qwentts.cpp CustomVoice or sherpa-onnx Supertonic 3 synthesis. Supertonic language codes: ar, bg, cs, da, de, el, en, es, et, fi, fr, hi, hr, hu, id, it, ja, ko, lt, lv, nl, pl, pt, ro, ru, sk, sl, sv, tr, uk, vi. With --dry-run, validates inputs and prints the plan and command without loading a model.\n");
             return;
         case "transcribe":
-            process.stdout.write("Usage: frameyard transcribe <source> --model <gguf> --out <file.json> [--words] [--export srt,vtt] [--language <lang>] [--executable <path>] [--manifest <file>] [--force] [--json]\nProduce a canonical Frameyard transcript, optionally with word timings and subtitle exports.\n");
+            process.stdout.write("Usage: frameyard transcribe <source> --model <gguf> --out <file.json> [--words] [--export srt,vtt] [--language <lang>] [--executable <path>] [--manifest <file>] [--force] [--dry-run] [--profile <name>] [--low-priority] [--json]\nProduce a canonical Frameyard transcript, optionally with word timings and subtitle exports. With --dry-run, validates inputs and prints the plan and command without loading a model.\n");
+            return;
+        case "add":
+            process.stdout.write("Usage: frameyard add --list [--json]\n       frameyard add local-models [--project <dir>] [--json]\n       frameyard add <composition|timeline> <id> --template <name> [--project <dir>] [--json]\nWrite a valid template entry and print the exact fy.config.js registration snippet, or install the optional local-model host scaffold. Templates are static-poster, title-card, lower-third, and slideshow. The command refuses to overwrite an existing file or an already registered id.\n");
+            return;
+        case "font":
+            process.stdout.write("Usage: frameyard font search [query] [--category <name>] [--subset <name>] [--style normal|italic] [--variable] [--limit <n>] [--json]\n       frameyard font add <fontsource-id> [--family <alias>] [--subset <name>] [--style normal|italic] [--weight <n>] [--static] [--force] [--project <dir>] [--json]\n       frameyard font add --file <path> --family <name> [--id <id>] [--weight <n|n-n>] [--style normal|italic] [--subset <name>] [--unicode-range <range>] [--license <id>] [--license-file <path>] [--force] [--project <dir>] [--json]\n       frameyard font add --url <https-url> --family <name> [--id <id>] [--weight <n|n-n>] [--style normal|italic] [--subset <name>] [--unicode-range <range>] [--license <id>] [--license-file <path>] [--sha256 <hash>] [--force] [--project <dir>] [--json]\n       frameyard font list|verify [--project <dir>] [--json]\n       frameyard font remove <id> [--keep-files] [--project <dir>] [--json]\nSearch Fontsource, vendor a Fontsource/local/URL font into assets/fonts/<id>/, and manage fy.fonts.json. The server serves the generated @font-face sheet at /__frameyard/fonts.css. Project policy allows search/list/verify everywhere, add in authoring and full, and remove or --force only in full. A --url import without --license also requires full.\n");
             return;
         case "doctor":
-            process.stdout.write("Usage: frameyard doctor [--qwen-tts <path>] [--whisper-cli <path>] [--talker-model <gguf>] [--codec-model <gguf>] [--model <gguf>] [--manifest <file>] [--project <dir>] [--json]\nInspect core requirements, optional integrations, model readability, and provenance integrity without changing the environment.\n");
+            process.stdout.write("Usage: frameyard doctor [--qwen-tts <path>] [--sherpa-onnx-tts <path>] [--whisper-cli <path>] [--talker-model <gguf>] [--codec-model <gguf>] [--model-dir <dir>] [--model <gguf>] [--manifest <file>] [--project <dir>] [--json]\nInspect core requirements, optional integrations, model readability, and provenance integrity without changing the environment.\n");
             return;
         default:
             printHelp();
     }
 }
-async function projectFromFlag(flags) {
+async function projectFromFlag(flags, options = {}) {
     const requested = flags.get("project");
     const root = typeof requested === "string" ? path.resolve(process.cwd(), requested) : await resolveProjectRoot(process.cwd());
-    return loadProject(root);
+    return loadProject(root, options);
 }
 /** Resolves the directory that anchors the project-local provenance manifest. */
 async function assetRootFromFlag(flags) {
@@ -452,10 +877,138 @@ function printDiagnostics(diagnostics) {
 function printJson(value) {
     process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
 }
+async function pathExists(filePath) {
+    try {
+        await stat(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function shellQuote(value) {
+    return /^[A-Za-z0-9_./:@%+=,-]+$/.test(value) ? value : `'${value.replaceAll("'", "'\\''")}'`;
+}
+function handoffCommand(args) {
+    return ["npx", "frameyard", ...args].map(shellQuote).join(" ");
+}
+function collectPrerequisites(timeline) {
+    const values = new Set();
+    const visit = (current) => {
+        for (const clip of current.clips) {
+            const source = clip.source;
+            if (source.kind === "video" || source.kind === "image" || source.kind === "audio") {
+                values.add(source.src);
+            }
+            else if (source.kind === "composition") {
+                values.add(source.entry);
+                for (const audio of source.audioClips) {
+                    values.add(audio.src);
+                }
+                for (const transcript of source.transcriptClips) {
+                    values.add(transcript.src);
+                }
+            }
+            else if (source.kind === "timeline") {
+                visit(source.timeline);
+            }
+        }
+    };
+    visit(timeline);
+    return [...values].sort();
+}
+function printDryRun(label, plan, commandLine, prerequisites, blockers) {
+    process.stdout.write(`${label} dry run\n`);
+    process.stdout.write(`  plan: ${JSON.stringify(plan)}\n`);
+    process.stdout.write(`  command: ${commandLine}\n`);
+    if (prerequisites.length > 0) {
+        process.stdout.write(`  prerequisites: ${prerequisites.join(", ")}\n`);
+    }
+    for (const blocker of blockers) {
+        process.stdout.write(`  blocker [${blocker.code}]: ${blocker.message}\n`);
+    }
+}
+async function prerequisiteBlockers(items) {
+    const blockers = [];
+    for (const item of items) {
+        let info;
+        try {
+            info = await stat(item.path);
+        }
+        catch {
+            blockers.push({
+                code: "ASSET_NOT_FOUND",
+                message: `${item.label} does not exist: ${item.path}`,
+                suggestion: "Check the path before running the heavy operation.",
+            });
+            continue;
+        }
+        if (item.directory === true ? !info.isDirectory() : !info.isFile()) {
+            blockers.push({
+                code: "ASSET_NOT_FOUND",
+                message: `${item.label} is not a ${item.directory === true ? "directory" : "file"}: ${item.path}`,
+                suggestion: "Check the path before running the heavy operation.",
+            });
+        }
+    }
+    return blockers;
+}
+const DEFAULT_INIT_PROJECT_NAME = "my-video";
+function assertProjectDirectoryName(name) {
+    if (name === "." || name === ".." || name.includes("/") || name.includes("\\") || name.includes("\0")) {
+        usage(`Project name must be a directory name without path separators; received "${name}".`);
+    }
+}
+/**
+ * Asks for the project name on an interactive terminal. EOF accepts the
+ * default; Ctrl+C cancels the command.
+ */
+async function promptProjectName(defaultName) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    let interrupted = false;
+    rl.on("SIGINT", () => {
+        interrupted = true;
+        rl.close();
+    });
+    try {
+        const closed = new Promise((resolve) => {
+            rl.once("close", () => resolve(null));
+        });
+        const answer = await Promise.race([rl.question(`Project name (${defaultName}): `), closed]);
+        if (interrupted) {
+            throw new FrameyardError("CANCELLED", "Project creation cancelled.");
+        }
+        const name = (answer ?? "").trim();
+        return name === "" ? defaultName : name;
+    }
+    finally {
+        rl.close();
+    }
+}
+/**
+ * `init <directory>` scaffolds into that directory. A bare `init` asks for a
+ * project name on an interactive terminal and creates a directory with it;
+ * non-interactive and `--json` runs use the default name without prompting.
+ */
+async function resolveInitTarget(parsed) {
+    const positional = parsed.positionals[0];
+    if (positional !== undefined) {
+        return path.resolve(process.cwd(), positional);
+    }
+    const interactive = parsed.flags.has("json") !== true && process.stdin.isTTY === true;
+    const name = interactive ? await promptProjectName(DEFAULT_INIT_PROJECT_NAME) : DEFAULT_INIT_PROJECT_NAME;
+    assertProjectDirectoryName(name);
+    return path.resolve(process.cwd(), name);
+}
 async function runInit(parsed) {
-    const target = path.resolve(process.cwd(), parsed.positionals[0] ?? ".");
+    const target = await resolveInitTarget(parsed);
     const json = parsed.flags.has("json") === true;
-    const files = scaffoldFiles(path.basename(target) || "frameyard-project");
+    const localModels = parsed.flags.has("local-models") === true;
+    const files = {
+        ...scaffoldFiles(path.basename(target) || "frameyard-project"),
+        ...(localModels ? localModelScaffoldFiles() : {}),
+    };
+    const next = localModels ? [...SCAFFOLD_NEXT, "Review .pi/settings.json and run pi --approve"] : [...SCAFFOLD_NEXT];
     for (const relativePath of Object.keys(files)) {
         try {
             await access(path.join(target, relativePath));
@@ -481,7 +1034,8 @@ async function runInit(parsed) {
         command: "init",
         project: target,
         files: Object.keys(files),
-        next: [...SCAFFOLD_NEXT],
+        next,
+        ...(localModels ? { localModels: true } : {}),
     };
     if (json) {
         printJson(result);
@@ -491,7 +1045,7 @@ async function runInit(parsed) {
         for (const file of Object.keys(files)) {
             process.stdout.write(`  ${file}\n`);
         }
-        process.stdout.write("Next: " + SCAFFOLD_NEXT.slice(0, 2).join(" && ") + "\n");
+        process.stdout.write("Next: " + next.slice(0, 2).join(" && ") + "\n");
     }
     return 0;
 }
@@ -519,8 +1073,573 @@ async function runDev(parsed) {
     await server.close();
     return 0;
 }
-async function runCheck(parsed, signal) {
+async function runContext(parsed, signal, policy) {
+    assertOperationAllowed(policy, "context");
+    const project = await projectFromFlag(parsed.flags);
+    const result = await buildProjectContext({ project, policy, signal });
+    const json = parsed.flags.has("json") === true;
+    if (json) {
+        printJson({ ok: true, command: "context", ...result });
+        return 0;
+    }
+    process.stdout.write(`Frameyard project: ${result.root}\n`);
+    if (result.format !== undefined) {
+        process.stdout.write(`format: ${result.format.width}×${result.format.height} @ ${result.format.fps} fps\n`);
+    }
+    process.stdout.write(`policy: ${describePolicy(policy)}\n`);
+    process.stdout.write(`compositions: ${result.compositions.length}\n`);
+    for (const composition of result.compositions) {
+        const metadata = composition.metadata;
+        const detail = metadata === undefined
+            ? composition.kind
+            : metadata.static === true
+                ? `static ${metadata.width}×${metadata.height}`
+                : `${metadata.width}×${metadata.height} @ ${metadata.fps} fps, ${metadata.durationInFrames} frames`;
+        process.stdout.write(`  ${composition.id}: ${detail}, ${composition.props.length} props, ${composition.diagnostics.errors} errors/${composition.diagnostics.warnings} warnings\n`);
+    }
+    process.stdout.write(`timelines: ${result.timelines.length}\n`);
+    for (const timeline of result.timelines) {
+        const detail = timeline.durationInFrames === undefined
+            ? "unresolved"
+            : `${timeline.durationInFrames} frames (${timeline.durationSeconds?.toFixed(1)}s), ${timeline.tracks} tracks, ${timeline.clips?.length ?? 0} clips, ${timeline.transitions} transitions, ${timeline.audio} audio, ${timeline.transcripts} transcripts`;
+        process.stdout.write(`  ${timeline.id}: ${detail}, ${timeline.diagnostics.errors} errors/${timeline.diagnostics.warnings} warnings\n`);
+    }
+    process.stdout.write(`assets: ${result.assets.length}\n`);
+    process.stdout.write(`fonts: ${result.fonts.length}\n`);
+    for (const font of result.fonts) {
+        const subsets = font.subsets.length === 0 ? "no subset" : font.subsets.join(",");
+        process.stdout.write(`  ${font.id}: ${font.family} (${font.provider}${font.version ? ` ${font.version}` : ""}), ${subsets}, ${font.styles.join("/")}, ${font.license}, ${font.files} files, ${font.status}\n`);
+    }
+    process.stdout.write(`next:\n`);
+    for (const command of result.next) {
+        process.stdout.write(`  ${command}\n`);
+    }
+    return 0;
+}
+async function runInspect(parsed) {
+    const startedAt = performance.now();
+    const filePath = path.resolve(process.cwd(), parsed.positionals[0]);
+    const probed = await probeImage(filePath);
+    const pixels = await decodeRgba(filePath, probed.width, probed.height);
+    const stats = analyzeRgba(pixels, probed.width, probed.height);
+    const json = parsed.flags.has("json") === true;
+    const result = {
+        ok: true,
+        command: "inspect",
+        path: filePath,
+        bytes: probed.bytes,
+        ...stats,
+        elapsedMs: performance.now() - startedAt,
+    };
+    if (json) {
+        printJson(result);
+        return 0;
+    }
+    process.stdout.write(`Inspected ${filePath} (${stats.width}×${stats.height}, ${probed.bytes} bytes)\n`);
+    process.stdout.write(`  blank: ${stats.blank}; alpha ${stats.alpha.min}..${stats.alpha.max}, coverage ${(stats.alpha.coverage * 100).toFixed(1)}%\n`);
+    process.stdout.write(`  background: ${stats.background.hex} (${(stats.background.share * 100).toFixed(1)}%); content: ${stats.content.pixels} px (${(stats.content.share * 100).toFixed(1)}%)${stats.content.bbox === null ? "" : ` at ${stats.content.bbox.x},${stats.content.bbox.y} ${stats.content.bbox.width}×${stats.content.bbox.height}`}\n`);
+    process.stdout.write(`  colors: ${stats.colors.map((color) => `${color.hex} ${(color.share * 100).toFixed(1)}%`).join(", ") || "(none)"}\n`);
+    process.stdout.write(`  edge density: ${stats.edgeDensity}\n`);
+    return 0;
+}
+async function runCompare(parsed) {
+    const startedAt = performance.now();
+    const firstPath = path.resolve(process.cwd(), parsed.positionals[0]);
+    const secondPath = path.resolve(process.cwd(), parsed.positionals[1]);
+    const [first, second] = await Promise.all([probeImage(firstPath), probeImage(secondPath)]);
+    if (first.width !== second.width || first.height !== second.height) {
+        throw new FrameyardError("IMAGE_INVALID", `Images have different dimensions: ${firstPath} is ${first.width}×${first.height}, ${secondPath} is ${second.width}×${second.height}.`, { details: { first: firstPath, second: secondPath } });
+    }
+    const [firstPixels, secondPixels] = await Promise.all([
+        decodeRgba(firstPath, first.width, first.height),
+        decodeRgba(secondPath, second.width, second.height),
+    ]);
+    const stats = compareRgba(firstPixels, secondPixels, first.width, first.height);
+    const json = parsed.flags.has("json") === true;
+    const result = {
+        ok: true,
+        command: "compare",
+        first: firstPath,
+        second: secondPath,
+        ...stats,
+        elapsedMs: performance.now() - startedAt,
+    };
+    if (json) {
+        printJson(result);
+    }
+    else if (stats.identical) {
+        process.stdout.write(`${firstPath} and ${secondPath} are pixel-identical (${stats.width}×${stats.height}).\n`);
+    }
+    else {
+        process.stdout.write(`${firstPath} and ${secondPath} differ:\n`);
+        process.stdout.write(`  dimensions: ${stats.width}×${stats.height}\n`);
+        process.stdout.write(`  differing pixels: ${stats.differingPixels} / ${stats.totalPixels} (${stats.percent}%)\n`);
+        process.stdout.write(`  max channel delta: ${stats.maxChannelDelta}; mean ${stats.meanChannelDelta}\n`);
+        process.stdout.write(`  bounding box: ${stats.bbox === null ? "(none)" : `x=${stats.bbox.x}..${stats.bbox.x + stats.bbox.width - 1}, y=${stats.bbox.y}..${stats.bbox.y + stats.bbox.height - 1}`}\n`);
+    }
+    return stats.identical ? 0 : 1;
+}
+async function runAdd(parsed) {
+    const json = parsed.flags.has("json") === true;
+    if (parsed.flags.has("list")) {
+        const templates = listTemplates().map((template) => ({
+            name: template.name,
+            kind: template.kind,
+            description: template.description,
+            ...(template.prerequisites !== undefined ? { prerequisites: template.prerequisites } : {}),
+        }));
+        const scaffolds = [
+            {
+                name: "local-models",
+                description: "Optional policy, OpenCode permissions, and Pi settings for a shared local model.",
+            },
+        ];
+        if (json) {
+            printJson({ ok: true, command: "add", templates, scaffolds });
+        }
+        else {
+            for (const template of templates) {
+                process.stdout.write(`${template.kind}\t${template.name}\t${template.description}\n`);
+            }
+            for (const scaffold of scaffolds) {
+                process.stdout.write(`scaffold\t${scaffold.name}\t${scaffold.description}\n`);
+            }
+        }
+        return 0;
+    }
+    if (parsed.positionals[0] === "local-models") {
+        const root = await assetRootFromFlag(parsed.flags);
+        const files = localModelScaffoldFiles();
+        const conflicts = [];
+        for (const relative of Object.keys(files)) {
+            if (await pathExists(path.join(root, relative))) {
+                conflicts.push(relative);
+            }
+        }
+        if (conflicts.length > 0) {
+            throw new FrameyardError("OUTPUT_EXISTS", `Refusing to overwrite local-model scaffold files: ${conflicts.join(", ")}.`, { details: { conflicts } });
+        }
+        for (const [relative, content] of Object.entries(files)) {
+            const target = path.join(root, relative);
+            await mkdir(path.dirname(target), { recursive: true });
+            await writeFile(target, content, { flag: "wx" });
+        }
+        const result = {
+            ok: true,
+            command: "add",
+            kind: "scaffold",
+            scaffold: "local-models",
+            path: root,
+            files: Object.keys(files),
+            next: [
+                "Review .opencode/opencode.jsonc and .pi/settings.json",
+                "Run pi --approve in the project",
+                "Run npx frameyard context --json from the project",
+            ],
+        };
+        if (json) {
+            printJson(result);
+        }
+        else {
+            process.stdout.write(`Installed local-model scaffold in ${root}\n`);
+            for (const file of result.files) {
+                process.stdout.write(`  ${file}\n`);
+            }
+            process.stdout.write(`Next: ${result.next[0]}\n`);
+        }
+        return 0;
+    }
+    const kind = parsed.positionals[0];
+    const id = parsed.positionals[1];
+    const templateName = flagString(parsed.flags, "template");
+    const template = findTemplate(templateName);
+    if (template === undefined) {
+        usage(`Unknown template "${templateName}".`);
+    }
+    if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(id)) {
+        throw new FrameyardError("CONFIG_INVALID", `Invalid id "${id}". Use letters, digits, dots, underscores, or hyphens, starting with a letter or digit.`);
+    }
     const project = await projectFromFlag(parsed.flags);
+    if (project.compositions.has(id) || project.timelines.has(id)) {
+        throw new FrameyardError("OUTPUT_EXISTS", `Project id "${id}" is already registered in fy.config.js.`);
+    }
+    if (project.format === undefined) {
+        throw new FrameyardError("CONFIG_INVALID", "Project templates inherit the project format. Add format { width, height, fps } to fy.config.js first.");
+    }
+    const entry = template.entry(id);
+    const targetPath = path.resolve(project.root, entry);
+    if (await pathExists(targetPath)) {
+        throw new FrameyardError("OUTPUT_EXISTS", `Refusing to overwrite ${targetPath}.`);
+    }
+    try {
+        await mkdir(path.dirname(targetPath), { recursive: true });
+        await writeFile(targetPath, template.content, { flag: "wx" });
+    }
+    catch (error) {
+        throw new FrameyardError("OUTPUT_FAILED", `Could not write ${targetPath}: ${errorMessage(error)}`, {
+            cause: error,
+        });
+    }
+    const registration = templateRegistration(template, id);
+    const register = Object.fromEntries(Object.entries(registration).filter(([, value]) => value !== undefined));
+    const result = {
+        ok: true,
+        command: "add",
+        kind,
+        id,
+        template: template.name,
+        entry,
+        path: targetPath,
+        register,
+        prerequisites: template.prerequisites ?? [],
+        next: ["Add the register entry to fy.config.js", `npx frameyard lint ${id} --json`],
+    };
+    if (json) {
+        printJson(result);
+    }
+    else {
+        process.stdout.write(`Created ${targetPath}\n`);
+        const key = kind === "composition" ? "compositions" : "timelines";
+        process.stdout.write(`Add to fy.config.js:\n  ${key}: { "${id}": "./${entry}" }\n`);
+        if ((template.prerequisites ?? []).length > 0) {
+            process.stdout.write(`Provide: ${(template.prerequisites ?? []).join(", ")}\n`);
+        }
+    }
+    return 0;
+}
+function splitFontList(value, flag) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const parts = value
+        .split(",")
+        .map((part) => part.trim())
+        .filter((part) => part.length > 0);
+    if (parts.length === 0) {
+        usage(`--${flag} requires at least one value.`);
+    }
+    return parts;
+}
+function parseFontsourceWeights(value) {
+    const parts = splitFontList(value, "weight");
+    if (parts === undefined) {
+        return undefined;
+    }
+    return parts.map((part) => {
+        const weight = Number(part);
+        if (!Number.isInteger(weight) || weight < 1 || weight > 1000) {
+            usage(`--weight entries must be integers between 1 and 1000; received "${part}".`);
+        }
+        return weight;
+    });
+}
+function parseFontsourceStyles(value) {
+    const parts = splitFontList(value, "style");
+    return parts?.map((part) => parseFontStyle(part));
+}
+function printFontAddResult(result, json) {
+    if (json) {
+        printJson({ ok: true, command: "font", action: "add", ...result });
+        return;
+    }
+    for (const warning of result.warnings) {
+        process.stderr.write(`⚠ ${warning.code}: ${warning.message}\n`);
+    }
+    process.stdout.write(`✓ font ${result.font.id}: ${result.font.family} (${result.font.provider}${result.font.version ? ` ${result.font.version}` : ""}), ${result.font.files} file${result.font.files === 1 ? "" : "s"}, ${result.font.bytes} bytes\n`);
+    process.stdout.write(`  manifest: ${result.manifest}\n`);
+    process.stdout.write(`  css: /__frameyard/fonts.css\n`);
+    process.stdout.write(`  use: font-family: "${result.font.family}", system-ui, sans-serif\n`);
+}
+async function runFont(parsed, signal, policy) {
+    const action = parsed.positionals[0];
+    const json = parsed.flags.has("json") === true;
+    assertOperationAllowed(policy, "font");
+    if (action === "search") {
+        const query = parsed.positionals[1] ?? "";
+        const category = flagString(parsed.flags, "category");
+        const subset = flagString(parsed.flags, "subset");
+        const styleValue = flagString(parsed.flags, "style");
+        const style = styleValue === undefined ? undefined : parseFontStyle(styleValue);
+        const variable = parsed.flags.has("variable") ? true : undefined;
+        const limitValue = flagString(parsed.flags, "limit");
+        const limit = limitValue === undefined ? undefined : Number(limitValue);
+        const result = await searchFontsource({
+            query,
+            ...(category !== undefined ? { category } : {}),
+            ...(subset !== undefined ? { subset } : {}),
+            ...(style !== undefined ? { style } : {}),
+            ...(variable !== undefined ? { variable } : {}),
+            ...(limit !== undefined ? { limit } : {}),
+            signal,
+        });
+        if (json) {
+            printJson({ ok: true, command: "font", action: "search", ...result });
+        }
+        else {
+            process.stdout.write(`fontsource: ${result.results.length} result${result.results.length === 1 ? "" : "s"}${result.truncated ? " (truncated)" : ""}\n`);
+            for (const item of result.results) {
+                process.stdout.write(`  ${item.id}: ${item.family} [${item.category}]${item.variable ? " variable" : ""}, weights ${item.weights.join(",")}, ${item.styles.join("/")}, subsets ${item.subsets.join(",")}, ${item.license}\n`);
+            }
+        }
+        return 0;
+    }
+    if (action === "add") {
+        assertPolicyTier(policy, "authoring", "font add");
+        if (typeof parsed.flags.get("url") === "string" &&
+            !parsed.flags.has("license") &&
+            !parsed.flags.has("license-file")) {
+            assertPolicyTier(policy, "full", "font add --url without --license");
+        }
+    }
+    if (action === "remove") {
+        assertPolicyTier(policy, "full", "font remove");
+    }
+    if (parsed.flags.has("force")) {
+        assertOverwriteAllowed(policy, "force");
+    }
+    const project = await projectFromFlag(parsed.flags, { fonts: false });
+    let manifest;
+    try {
+        manifest = await readFontManifest(project.root);
+    }
+    catch (error) {
+        if (action === "verify" && isFrameyardError(error)) {
+            const verification = {
+                manifest: fontManifestPath(project.root),
+                fonts: 0,
+                files: 0,
+                bytes: 0,
+                diagnostics: [
+                    {
+                        severity: "error",
+                        code: error.code,
+                        message: error.message,
+                    },
+                ],
+                valid: false,
+            };
+            if (json) {
+                printJson({ ok: true, command: "font", action: "verify", ...verification });
+            }
+            else {
+                process.stderr.write(`✗ ${error.code}: ${error.message}\n`);
+            }
+            return 1;
+        }
+        throw error;
+    }
+    if (action === "add") {
+        const file = flagString(parsed.flags, "file");
+        const url = flagString(parsed.flags, "url");
+        const family = flagString(parsed.flags, "family");
+        const id = flagString(parsed.flags, "id");
+        const weightValue = flagString(parsed.flags, "weight");
+        const styleValue = flagString(parsed.flags, "style");
+        const subsetValue = flagString(parsed.flags, "subset");
+        const force = parsed.flags.has("force") === true;
+        if (file !== undefined) {
+            printFontAddResult(await addLocalFont({
+                projectRoot: project.root,
+                ...(manifest !== undefined ? { manifest } : {}),
+                file,
+                family: family,
+                ...(id !== undefined ? { id } : {}),
+                weight: weightValue === undefined ? 400 : parseFontWeight(weightValue),
+                style: styleValue === undefined ? "normal" : parseFontStyle(styleValue),
+                ...(subsetValue !== undefined ? { subset: subsetValue } : {}),
+                ...(flagString(parsed.flags, "unicode-range") !== undefined
+                    ? { unicodeRange: flagString(parsed.flags, "unicode-range") }
+                    : {}),
+                ...(flagString(parsed.flags, "license") !== undefined
+                    ? { license: flagString(parsed.flags, "license") }
+                    : {}),
+                ...(flagString(parsed.flags, "license-file") !== undefined
+                    ? { licenseFile: flagString(parsed.flags, "license-file") }
+                    : {}),
+                force,
+            }), json);
+            return 0;
+        }
+        if (url !== undefined) {
+            printFontAddResult(await addUrlFont({
+                projectRoot: project.root,
+                ...(manifest !== undefined ? { manifest } : {}),
+                url,
+                family: family,
+                ...(id !== undefined ? { id } : {}),
+                weight: weightValue === undefined ? 400 : parseFontWeight(weightValue),
+                style: styleValue === undefined ? "normal" : parseFontStyle(styleValue),
+                ...(subsetValue !== undefined ? { subset: subsetValue } : {}),
+                ...(flagString(parsed.flags, "unicode-range") !== undefined
+                    ? { unicodeRange: flagString(parsed.flags, "unicode-range") }
+                    : {}),
+                ...(flagString(parsed.flags, "license") !== undefined
+                    ? { license: flagString(parsed.flags, "license") }
+                    : {}),
+                ...(flagString(parsed.flags, "license-file") !== undefined
+                    ? { licenseFile: flagString(parsed.flags, "license-file") }
+                    : {}),
+                ...(flagString(parsed.flags, "sha256") !== undefined
+                    ? { sha256: flagString(parsed.flags, "sha256") }
+                    : {}),
+                force,
+                signal,
+            }), json);
+            return 0;
+        }
+        printFontAddResult(await addFontsource({
+            projectRoot: project.root,
+            ...(manifest !== undefined ? { manifest } : {}),
+            id: parsed.positionals[1],
+            ...(family !== undefined ? { family } : {}),
+            ...(subsetValue !== undefined ? { subsets: splitFontList(subsetValue, "subset") } : {}),
+            ...(styleValue !== undefined ? { styles: parseFontsourceStyles(styleValue) } : {}),
+            ...(weightValue !== undefined ? { weights: parseFontsourceWeights(weightValue) } : {}),
+            static: parsed.flags.has("static") === true,
+            force,
+            signal,
+        }), json);
+        return 0;
+    }
+    if (action === "list") {
+        const verification = manifest === undefined
+            ? undefined
+            : await verifyFontManifest({
+                projectRoot: project.root,
+                manifest,
+                hashes: false,
+                licenses: false,
+                orphans: false,
+            });
+        const statuses = verification === undefined ? new Map() : fontStatuses(verification);
+        const fonts = (manifest?.fonts ?? [])
+            .map((font) => summarizeFont(font, statuses.get(font.id) ?? "ok"))
+            .sort((left, right) => left.family.localeCompare(right.family));
+        const result = {
+            ok: true,
+            command: "font",
+            action: "list",
+            manifest: fontManifestPath(project.root),
+            fonts,
+        };
+        if (json) {
+            printJson(result);
+        }
+        else {
+            if (fonts.length === 0) {
+                process.stdout.write("No project fonts are installed.\n");
+            }
+            else {
+                process.stdout.write(`fonts: ${fonts.length}\n`);
+                for (const font of fonts) {
+                    const subsets = font.subsets.length === 0 ? "no subset" : font.subsets.join(", ");
+                    process.stdout.write(`  ${font.id}: ${font.family} (${font.provider}${font.version ? ` ${font.version}` : ""}), ${subsets}, ${font.styles.join("/")}, ${font.license}, ${font.files} files, ${font.bytes} bytes, ${font.status}\n`);
+                }
+            }
+        }
+        return 0;
+    }
+    if (action === "verify") {
+        const verification = await verifyFontManifest({
+            projectRoot: project.root,
+            manifest: manifest ?? emptyFontManifest(),
+            hashes: true,
+            licenses: true,
+            orphans: true,
+        });
+        if (json) {
+            printJson({ ok: true, command: "font", action: "verify", ...verification });
+        }
+        else {
+            if (verification.fonts === 0) {
+                process.stdout.write("No project fonts are installed.\n");
+            }
+            else {
+                process.stdout.write(`${verification.valid ? "✓" : "✗"} font manifest: ${verification.fonts} fonts, ${verification.files} files, ${verification.bytes} bytes\n`);
+                process.stdout.write(`  ${verification.manifest}\n`);
+            }
+            for (const diagnostic of verification.diagnostics) {
+                const marker = diagnostic.severity === "error" ? "✗" : "⚠";
+                process.stderr.write(`${marker} ${diagnostic.code}: ${diagnostic.message}${diagnostic.file !== undefined ? ` (${diagnostic.file})` : ""}\n`);
+            }
+        }
+        return verification.valid ? 0 : 1;
+    }
+    if (action === "remove") {
+        const result = await removeFont({
+            projectRoot: project.root,
+            ...(manifest !== undefined ? { manifest } : {}),
+            id: parsed.positionals[1],
+            keepFiles: parsed.flags.has("keep-files") === true,
+        });
+        if (json) {
+            printJson({ ok: true, command: "font", action: "remove", ...result });
+        }
+        else {
+            process.stdout.write(`Removed font ${result.id} (${result.family}).\n`);
+            if (result.keptFiles) {
+                process.stdout.write(`  kept files: ${result.files.join(", ")}\n`);
+            }
+        }
+        return 0;
+    }
+    usage(`Unknown font action "${action}". Use add, list, verify, or remove.`);
+}
+async function runLint(parsed, signal, policy) {
+    const project = await projectFromFlag(parsed.flags);
+    await assertFontIntegrity(project.root, project.fonts, { hashes: false });
+    const props = await readPropsFile(parsed.flags);
+    const targetId = parsed.positionals[0];
+    const json = parsed.flags.has("json") === true;
+    if (project.timelines.has(targetId)) {
+        if (props !== undefined && !isPlainObject(props)) {
+            usage("Timeline --props must be a JSON object keyed by composition clip id.");
+        }
+        const result = await lintTimeline({
+            project,
+            timelineId: targetId,
+            ...(props !== undefined ? { propsOverrides: props } : {}),
+            signal,
+        });
+        printDiagnostics(result.diagnostics);
+        if (json) {
+            printJson({ ok: true, command: "lint", policy: policyDetails(policy), ...result });
+        }
+        else {
+            process.stdout.write(`✓ lint timeline ${targetId}: ${result.framesProjected} frames projected, ${result.segments} segment${result.segments === 1 ? "" : "s"}, ${result.tracks} track${result.tracks === 1 ? "" : "s"}, ${result.clips} clip${result.clips === 1 ? "" : "s"}\n`);
+            process.stdout.write(`  policy: ${describePolicy(policy)}; lint does not replace check (props hooks and frame runtime are not evaluated)\n`);
+        }
+        return 0;
+    }
+    const compositionId = targetId;
+    const result = await lintComposition({
+        project,
+        compositionId,
+        props,
+        signal,
+    });
+    printDiagnostics(result.diagnostics);
+    if (json) {
+        printJson({ ok: true, command: "lint", policy: policyDetails(policy), ...result });
+    }
+    else if (result.metadata.static === true) {
+        process.stdout.write(`✓ lint ${compositionId}: static ${result.metadata.width}×${result.metadata.height}; controller and document validated\n`);
+        process.stdout.write(`  policy: ${describePolicy(policy)}; lint does not replace check\n`);
+    }
+    else {
+        process.stdout.write(`✓ lint ${compositionId}: document and controller validated for ${result.metadata.durationInFrames} frames; frame runtime is not evaluated\n`);
+        process.stdout.write(`  policy: ${describePolicy(policy)}; use check for props hooks and every frame\n`);
+    }
+    return 0;
+}
+async function runCheck(parsed, signal, policy) {
+    assertOperationAllowed(policy, "check");
+    const profile = resolveProfile(policy, flagString(parsed.flags, "profile"));
+    if (shouldLowerPriority(policy, profile, parsed.flags.has("low-priority") === true)) {
+        lowerProcessPriority();
+    }
+    const project = await projectFromFlag(parsed.flags);
+    await assertFontIntegrity(project.root, project.fonts, { hashes: true });
     const props = await readPropsFile(parsed.flags);
     const targetId = parsed.positionals[0];
     const json = parsed.flags.has("json") === true;
@@ -540,7 +1659,7 @@ async function runCheck(parsed, signal) {
             printJson({ ok: true, command: "check", ...result });
         }
         else {
-            process.stdout.write(`✓ timeline ${targetId}: ${result.framesChecked} frames, ${result.format.width}×${result.format.height} @ ${result.format.fps} fps (${formatDuration(result.durationInFrames / result.format.fps)}), ${result.tracks} track${result.tracks === 1 ? "" : "s"}, ${result.clips} clip${result.clips === 1 ? "" : "s"}\n`);
+            process.stdout.write(`✓ timeline ${targetId}: ${result.framesChecked} frames, ${result.format.width}×${result.format.height} @ ${result.format.fps} fps (${formatDuration(result.durationInFrames / result.format.fps)}), ${result.tracks} track${result.tracks === 1 ? "" : "s"}, ${result.clips} clip${result.clips === 1 ? "" : "s"}, ${result.transitions} transition${result.transitions === 1 ? "" : "s"}\n`);
             process.stdout.write(`  audio: ${result.audio.clips} clip${result.audio.clips === 1 ? "" : "s"}\n`);
             if (result.transcripts.clips > 0) {
                 process.stdout.write(`  transcripts: ${result.transcripts.clips} asset${result.transcripts.clips === 1 ? "" : "s"}\n`);
@@ -559,6 +1678,9 @@ async function runCheck(parsed, signal) {
     if (json) {
         printJson({ ok: true, command: "check", ...result });
     }
+    else if (result.kind === "static") {
+        process.stdout.write(`✓ ${compositionId}: static ${result.metadata.width}×${result.metadata.height}\n`);
+    }
     else {
         const meta = result.metadata;
         process.stdout.write(`✓ ${compositionId}: ${result.framesChecked} frames, ${meta.width}×${meta.height} @ ${meta.fps} fps (${formatDuration(meta.durationInFrames / meta.fps)})\n`);
@@ -695,8 +1817,17 @@ function printStillResult(result, targetId, timeline, json) {
         process.stdout.write(`Wrote ${result.frames.length} frames of ${target} to ${directory} (${result.width}×${result.height})\n`);
     }
 }
-async function runStill(parsed, signal) {
+async function runStill(parsed, signal, policy) {
+    assertOperationAllowed(policy, "still");
+    if (parsed.flags.has("overwrite")) {
+        assertOverwriteAllowed(policy, "overwrite");
+    }
+    const profile = resolveProfile(policy, flagString(parsed.flags, "profile"));
+    if (shouldLowerPriority(policy, profile, parsed.flags.has("low-priority") === true)) {
+        lowerProcessPriority();
+    }
     const project = await projectFromFlag(parsed.flags);
+    await assertFontIntegrity(project.root, project.fonts, { hashes: true });
     const props = await readPropsFile(parsed.flags);
     const targetId = parsed.positionals[0];
     const frameValue = parsed.flags.get("frame");
@@ -704,6 +1835,7 @@ async function runStill(parsed, signal) {
         usage('"still" requires --frame <spec>.');
     }
     const frames = parseFrameSpec(frameValue);
+    assertStillFrameLimit(policy, frames.length);
     const outputPlan = await resolveStillOutputs({
         targetId,
         frames,
@@ -748,13 +1880,24 @@ async function runStill(parsed, signal) {
         throw error;
     }
 }
-async function runRender(parsed, signal) {
+async function runRender(parsed, signal, policy) {
+    const dryRun = parsed.flags.has("dry-run") === true;
+    const profile = resolveProfile(policy, flagString(parsed.flags, "profile"));
+    if (!dryRun) {
+        assertOperationAllowed(policy, "render");
+    }
+    if (parsed.flags.has("overwrite")) {
+        assertOverwriteAllowed(policy, "overwrite");
+    }
     const project = await projectFromFlag(parsed.flags);
+    await assertFontIntegrity(project.root, project.fonts, { hashes: true });
     const props = await readPropsFile(parsed.flags);
     const encoder = encoderChoice(parsed.flags);
-    const container = containerChoice(parsed.flags) ?? "mp4";
+    const containerValue = containerChoice(parsed.flags);
+    const container = containerValue ?? "mp4";
     // WebM is a VP9/Opus container; every other container defaults to H.264.
-    const codec = codecChoice(parsed.flags) ?? defaultCodecForContainer(container);
+    const codecValue = codecChoice(parsed.flags);
+    const codec = codecValue ?? defaultCodecForContainer(container);
     assertContainerCodec(container, codec);
     if (encoder !== undefined && encoder !== "auto") {
         // Rejects codec/vendor mismatches such as --codec hevc --encoder libx264.
@@ -762,9 +1905,8 @@ async function runRender(parsed, signal) {
     }
     const targetId = parsed.positionals[0];
     const outValue = flagString(parsed.flags, "out");
-    const outPath = outValue === undefined
-        ? path.join(project.root, "out", `${targetId}.${CONTAINER_EXTENSION[container]}`)
-        : path.resolve(process.cwd(), outValue);
+    const explicitOutPath = outValue === undefined ? undefined : path.resolve(process.cwd(), outValue);
+    const timelineOutPath = explicitOutPath ?? path.join(project.root, "out", `${targetId}.${CONTAINER_EXTENSION[container]}`);
     const json = parsed.flags.has("json") === true;
     if (project.timelines.has(targetId)) {
         if (parsed.flags.has("concurrency")) {
@@ -783,11 +1925,113 @@ async function runRender(parsed, signal) {
         }
         const scratchValue = flagString(parsed.flags, "scratch");
         const scratchDir = scratchValue === undefined ? undefined : path.resolve(process.cwd(), scratchValue);
+        let effectiveWorkers = workers;
+        if (profile === "shared-cpu") {
+            if (workers !== undefined) {
+                assertProfileLimit(profile, "workers", workers, SHARED_CPU_MAX_WORKERS);
+            }
+            effectiveWorkers = workers ?? SHARED_CPU_MAX_WORKERS;
+        }
+        if (dryRun) {
+            const projectTimeline = project.timelines.get(targetId);
+            if (!projectTimeline) {
+                throw new FrameyardError("TIMELINE_NOT_FOUND", `Timeline "${targetId}" is not listed in fy.config.js.`);
+            }
+            const resolved = await resolveProjectTimeline({
+                project,
+                timeline: projectTimeline,
+                ...(props !== undefined ? { propsOverrides: props } : {}),
+                signal,
+            });
+            const firstError = resolved.diagnostics.find((diagnostic) => diagnostic.severity === "error");
+            if (!resolved.timeline || firstError) {
+                throw new FrameyardError(firstError?.code ?? "TIMELINE_INVALID", firstError?.message ?? "Timeline resolution failed.", { diagnostics: resolved.diagnostics });
+            }
+            const lintResult = await lintResolvedTimeline({
+                timeline: resolved.timeline,
+                projectRoot: project.root,
+                diagnostics: resolved.diagnostics,
+                signal,
+            });
+            const lintError = lintResult.diagnostics.find((diagnostic) => diagnostic.severity === "error");
+            if (lintError) {
+                throw new FrameyardError(lintError.code, lintError.message, { diagnostics: lintResult.diagnostics });
+            }
+            const plan = planTimelineRender(resolved.timeline);
+            const planWorkers = effectiveWorkers ?? 8;
+            const planDetails = {
+                kind: "video",
+                frames: resolved.timeline.durationInFrames,
+                durationSeconds: resolved.timeline.durationInFrames / resolved.timeline.format.fps,
+                segments: plan.segments.length,
+                workers: planWorkers,
+                encoder: encoder ?? "auto",
+                codec,
+                container,
+                probed: false,
+                ...(scratchDir !== undefined ? { scratch: scratchDir } : {}),
+            };
+            const outputExists = await pathExists(timelineOutPath);
+            const blockers = outputExists
+                ? [
+                    {
+                        code: "OUTPUT_EXISTS",
+                        message: `Output already exists: ${timelineOutPath}.`,
+                        suggestion: policy.allowOverwrite
+                            ? "Pass --overwrite to replace it."
+                            : "Choose a new --out path or ask the user to run with FRAMEYARD_POLICY=full.",
+                    },
+                ]
+                : [];
+            const prerequisites = collectPrerequisites(resolved.timeline);
+            const args = ["render", targetId];
+            if (outValue !== undefined)
+                args.push("--out", outValue);
+            const propsValue = flagString(parsed.flags, "props");
+            if (propsValue !== undefined)
+                args.push("--props", propsValue);
+            args.push("--workers", String(planWorkers));
+            if (encoder !== undefined)
+                args.push("--encoder", encoder);
+            args.push("--codec", codec, "--container", container);
+            if (scratchValue !== undefined)
+                args.push("--scratch", scratchValue);
+            if (profile !== undefined)
+                args.push("--profile", profile);
+            if (parsed.flags.has("low-priority"))
+                args.push("--low-priority");
+            const prefix = policy.tier === "full" ? "" : "FRAMEYARD_POLICY=full ";
+            const commandLine = prefix + handoffCommand(args);
+            printDiagnostics(lintResult.diagnostics);
+            if (json) {
+                printJson({
+                    ok: true,
+                    command: "render",
+                    dryRun: true,
+                    deferred: true,
+                    policy: policyDetails(policy),
+                    ...(profile !== undefined ? { profile } : {}),
+                    plan: planDetails,
+                    commandLine,
+                    prerequisites,
+                    blockers,
+                    diagnostics: lintResult.diagnostics,
+                    output: { path: timelineOutPath, exists: outputExists },
+                });
+            }
+            else {
+                printDryRun("render", planDetails, commandLine, prerequisites, blockers);
+            }
+            return 0;
+        }
+        if (shouldLowerPriority(policy, profile, parsed.flags.has("low-priority") === true)) {
+            lowerProcessPriority();
+        }
         const result = await renderTimeline({
             project,
             timelineId: targetId,
-            outPath,
-            ...(workers !== undefined ? { workers } : {}),
+            outPath: timelineOutPath,
+            ...(effectiveWorkers !== undefined ? { workers: effectiveWorkers } : {}),
             ...(scratchDir !== undefined ? { scratchDir } : {}),
             ...(encoder !== undefined ? { encoder } : {}),
             codec,
@@ -811,16 +2055,111 @@ async function runRender(parsed, signal) {
     }
     const compositionId = targetId;
     const concurrencyValue = parsed.flags.get("concurrency");
-    const concurrency = validateRenderConcurrency(typeof concurrencyValue === "string" ? Number(concurrencyValue) : undefined);
+    const concurrency = typeof concurrencyValue === "string" ? validateRenderConcurrency(Number(concurrencyValue)) : undefined;
+    let effectiveConcurrency = concurrency;
+    if (profile === "shared-cpu") {
+        if (concurrency !== undefined) {
+            assertProfileLimit(profile, "concurrency", concurrency, SHARED_CPU_MAX_CONCURRENCY);
+        }
+        effectiveConcurrency = concurrency ?? SHARED_CPU_MAX_CONCURRENCY;
+    }
+    if (dryRun) {
+        const lintResult = await lintComposition({ project, compositionId, props, signal });
+        const metadata = lintResult.metadata;
+        const staticTarget = metadata.static === true;
+        if (staticTarget &&
+            (parsed.flags.has("concurrency") ||
+                parsed.flags.has("container") ||
+                parsed.flags.has("codec") ||
+                parsed.flags.has("encoder"))) {
+            usage("A static composition render rejects --concurrency, --container, --codec, and --encoder.");
+        }
+        const compositionOutPath = explicitOutPath ??
+            path.join(project.root, "out", staticTarget ? `${compositionId}.png` : `${compositionId}.${CONTAINER_EXTENSION[container]}`);
+        const outputExists = await pathExists(compositionOutPath);
+        const blockers = outputExists
+            ? [
+                {
+                    code: "OUTPUT_EXISTS",
+                    message: `Output already exists: ${compositionOutPath}.`,
+                    suggestion: policy.allowOverwrite
+                        ? "Pass --overwrite to replace it."
+                        : "Choose a new --out path or ask the user to run with FRAMEYARD_POLICY=full.",
+                },
+            ]
+            : [];
+        const planDetails = metadata.static === true
+            ? {
+                kind: "image",
+                width: metadata.width,
+                height: metadata.height,
+                frames: 1,
+            }
+            : {
+                kind: "video",
+                frames: metadata.durationInFrames,
+                durationSeconds: metadata.durationInFrames / metadata.fps,
+                concurrency: effectiveConcurrency ?? 1,
+                encoder: encoder ?? "auto",
+                codec,
+                container,
+                probed: false,
+            };
+        const args = ["render", compositionId];
+        if (outValue !== undefined)
+            args.push("--out", outValue);
+        const propsValue = flagString(parsed.flags, "props");
+        if (propsValue !== undefined)
+            args.push("--props", propsValue);
+        if (!staticTarget) {
+            args.push("--concurrency", String(effectiveConcurrency ?? 1));
+            if (encoder !== undefined)
+                args.push("--encoder", encoder);
+            if (codecValue !== undefined)
+                args.push("--codec", codecValue);
+            if (containerValue !== undefined)
+                args.push("--container", containerValue);
+        }
+        if (profile !== undefined)
+            args.push("--profile", profile);
+        if (parsed.flags.has("low-priority"))
+            args.push("--low-priority");
+        const prefix = policy.tier === "full" ? "" : "FRAMEYARD_POLICY=full ";
+        const commandLine = prefix + handoffCommand(args);
+        printDiagnostics(lintResult.diagnostics);
+        if (json) {
+            printJson({
+                ok: true,
+                command: "render",
+                dryRun: true,
+                deferred: true,
+                policy: policyDetails(policy),
+                ...(profile !== undefined ? { profile } : {}),
+                plan: planDetails,
+                commandLine,
+                prerequisites: [],
+                blockers,
+                diagnostics: lintResult.diagnostics,
+                output: { path: compositionOutPath, exists: outputExists },
+            });
+        }
+        else {
+            printDryRun("render", planDetails, commandLine, [], blockers);
+        }
+        return 0;
+    }
+    if (shouldLowerPriority(policy, profile, parsed.flags.has("low-priority") === true)) {
+        lowerProcessPriority();
+    }
     const result = await renderComposition({
         project,
         compositionId,
         props,
-        outPath,
-        concurrency,
+        ...(explicitOutPath !== undefined ? { outPath: explicitOutPath } : {}),
+        ...(concurrency !== undefined ? { concurrency } : {}),
         ...(encoder !== undefined ? { encoder } : {}),
-        codec,
-        container,
+        ...(codecValue !== undefined ? { codec: codecValue } : {}),
+        ...(containerValue !== undefined ? { container: containerValue } : {}),
         overwrite: parsed.flags.has("overwrite") === true,
         signal,
         onProgress: progressPrinter("Rendering"),
@@ -829,20 +2168,30 @@ async function runRender(parsed, signal) {
     if (json) {
         printJson({ ok: true, command: "render", ...result });
     }
+    else if (result.kind === "image") {
+        process.stdout.write(`Rendered ${compositionId} to ${result.path} (${result.width}×${result.height}, ${result.bytes} bytes)\n`);
+    }
     else {
         process.stdout.write(`Rendered ${compositionId} to ${result.path} (${result.framesRendered} frames, ${formatDuration(result.durationSeconds)}, ${result.audio.clips} audio clip${result.audio.clips === 1 ? "" : "s"}, ${result.encoder} encoder)\n`);
     }
     return 0;
 }
-async function runTts(parsed, signal) {
+async function runTts(parsed, signal, policy) {
+    const dryRun = parsed.flags.has("dry-run") === true;
+    const profile = resolveProfile(policy, flagString(parsed.flags, "profile"));
+    if (!dryRun) {
+        assertOperationAllowed(policy, "tts");
+    }
+    if (parsed.flags.has("force")) {
+        assertOverwriteAllowed(policy, "force");
+    }
     const projectRoot = await assetRootFromFlag(parsed.flags);
     const json = parsed.flags.has("json") === true;
+    const engine = (flagString(parsed.flags, "engine") ?? "qwen");
     const speaker = flagString(parsed.flags, "speaker");
-    const talkerModel = flagString(parsed.flags, "talker-model");
-    const codecModel = flagString(parsed.flags, "codec-model");
     const outValue = flagString(parsed.flags, "out");
-    if (!speaker || !talkerModel || !codecModel || !outValue) {
-        usage('"tts" requires --speaker, --talker-model, --codec-model, and --out.');
+    if (!speaker || !outValue) {
+        usage('"tts" requires --speaker and --out.');
     }
     const textFile = flagString(parsed.flags, "text-file");
     let text;
@@ -861,39 +2210,157 @@ async function runTts(parsed, signal) {
         }
         text = await readStdin();
     }
-    const result = await synthesizeSpeech({
-        projectRoot,
-        text,
-        speaker,
-        talkerModelPath: path.resolve(process.cwd(), talkerModel),
-        codecModelPath: path.resolve(process.cwd(), codecModel),
-        outPath: path.resolve(process.cwd(), outValue),
-        ...(flagString(parsed.flags, "style") !== undefined ? { style: flagString(parsed.flags, "style") } : {}),
-        ...(flagString(parsed.flags, "language") !== undefined
-            ? { language: flagString(parsed.flags, "language") }
-            : {}),
-        ...(flagString(parsed.flags, "device") !== undefined
-            ? { device: flagString(parsed.flags, "device") }
-            : {}),
-        ...(flagString(parsed.flags, "executable") !== undefined
-            ? { executable: flagString(parsed.flags, "executable") }
-            : {}),
-        ...(flagString(parsed.flags, "manifest") !== undefined
-            ? { manifestPath: flagString(parsed.flags, "manifest") }
-            : {}),
-        force: parsed.flags.has("force") === true,
-        signal,
-    });
+    const outPath = path.resolve(process.cwd(), outValue);
+    const force = parsed.flags.has("force") === true;
+    const manifestPath = resolveManifestPath(projectRoot, flagString(parsed.flags, "manifest"));
+    if (dryRun) {
+        if (text.trim().length === 0) {
+            throw new FrameyardError("TTS_FAILED", "Speech synthesis requires non-empty text.");
+        }
+        if (!outPath.toLowerCase().endsWith(".wav")) {
+            throw new FrameyardError("TTS_FAILED", `Speech output must use a .wav extension: ${outPath}`);
+        }
+        const executableValue = flagString(parsed.flags, "executable");
+        const prerequisites = engine === "supertonic"
+            ? [
+                {
+                    label: "Supertonic model directory",
+                    path: path.resolve(process.cwd(), flagString(parsed.flags, "model-dir")),
+                    directory: true,
+                },
+                ...(executableValue !== undefined ? [{ label: "TTS executable", path: executableValue }] : []),
+            ]
+            : [
+                {
+                    label: "talker model",
+                    path: path.resolve(process.cwd(), flagString(parsed.flags, "talker-model")),
+                },
+                {
+                    label: "codec model",
+                    path: path.resolve(process.cwd(), flagString(parsed.flags, "codec-model")),
+                },
+                ...(executableValue !== undefined ? [{ label: "TTS executable", path: executableValue }] : []),
+            ];
+        const blockers = await prerequisiteBlockers(prerequisites);
+        if (engine === "supertonic") {
+            try {
+                await resolveSupertonicModelFiles(path.resolve(process.cwd(), flagString(parsed.flags, "model-dir")));
+            }
+            catch (error) {
+                blockers.push({
+                    code: isFrameyardError(error) ? error.code : "TTS_FAILED",
+                    message: errorMessage(error),
+                    suggestion: "Check --model-dir and the seven Supertonic model files.",
+                });
+            }
+        }
+        const outputExists = await pathExists(outPath);
+        if (outputExists) {
+            blockers.push({
+                code: "OUTPUT_EXISTS",
+                message: `Output already exists: ${outPath}.`,
+                suggestion: policy.allowOverwrite
+                    ? "Pass --force to replace it."
+                    : "Choose a new --out path or ask the user to run with FRAMEYARD_POLICY=full.",
+            });
+        }
+        const plan = {
+            kind: "tts",
+            engine,
+            speaker,
+            textCharacters: text.length,
+            out: outPath,
+            manifest: manifestPath,
+            probed: false,
+        };
+        const args = process.argv.slice(2).filter((argument) => argument !== "--dry-run" && argument !== "--json");
+        const prefix = policy.tier === "full" ? "" : "FRAMEYARD_POLICY=full ";
+        const commandLine = prefix + handoffCommand(args);
+        if (json) {
+            printJson({
+                ok: true,
+                command: "tts",
+                dryRun: true,
+                deferred: true,
+                policy: policyDetails(policy),
+                ...(profile !== undefined ? { profile } : {}),
+                plan,
+                commandLine,
+                prerequisites: prerequisites.map((item) => item.path),
+                blockers,
+                output: { path: outPath, exists: outputExists },
+            });
+        }
+        else {
+            printDryRun("tts", plan, commandLine, prerequisites.map((item) => item.path), blockers);
+        }
+        return 0;
+    }
+    if (shouldLowerPriority(policy, profile, parsed.flags.has("low-priority") === true)) {
+        lowerProcessPriority();
+    }
+    const result = engine === "supertonic"
+        ? await synthesizeSpeech({
+            engine: "supertonic",
+            projectRoot,
+            text,
+            speaker,
+            modelDir: path.resolve(process.cwd(), flagString(parsed.flags, "model-dir")),
+            language: flagString(parsed.flags, "language"),
+            outPath,
+            ...(flagString(parsed.flags, "executable") !== undefined
+                ? { executable: flagString(parsed.flags, "executable") }
+                : {}),
+            ...(flagString(parsed.flags, "manifest") !== undefined
+                ? { manifestPath: flagString(parsed.flags, "manifest") }
+                : {}),
+            force,
+            signal,
+        })
+        : await synthesizeSpeech({
+            engine: "qwen",
+            projectRoot,
+            text,
+            speaker,
+            talkerModelPath: path.resolve(process.cwd(), flagString(parsed.flags, "talker-model")),
+            codecModelPath: path.resolve(process.cwd(), flagString(parsed.flags, "codec-model")),
+            outPath,
+            ...(flagString(parsed.flags, "style") !== undefined
+                ? { style: flagString(parsed.flags, "style") }
+                : {}),
+            ...(flagString(parsed.flags, "language") !== undefined
+                ? { language: flagString(parsed.flags, "language") }
+                : {}),
+            ...(flagString(parsed.flags, "device") !== undefined
+                ? { device: flagString(parsed.flags, "device") }
+                : {}),
+            ...(flagString(parsed.flags, "executable") !== undefined
+                ? { executable: flagString(parsed.flags, "executable") }
+                : {}),
+            ...(flagString(parsed.flags, "manifest") !== undefined
+                ? { manifestPath: flagString(parsed.flags, "manifest") }
+                : {}),
+            force,
+            signal,
+        });
     if (json) {
         printJson({ ok: true, command: "tts", ...result });
     }
     else {
-        process.stdout.write(`Wrote 24 kHz mono WAV to ${result.path} (${(result.bytes / (1024 * 1024)).toFixed(2)} MB)\n`);
+        process.stdout.write(`Wrote 24 kHz mono WAV to ${result.path} (${(result.bytes / (1024 * 1024)).toFixed(2)} MB, ${result.engine})\n`);
         process.stdout.write(`Updated provenance manifest ${result.manifest}\n`);
     }
     return 0;
 }
-async function runTranscribe(parsed, signal) {
+async function runTranscribe(parsed, signal, policy) {
+    const dryRun = parsed.flags.has("dry-run") === true;
+    const profile = resolveProfile(policy, flagString(parsed.flags, "profile"));
+    if (!dryRun) {
+        assertOperationAllowed(policy, "transcribe");
+    }
+    if (parsed.flags.has("force")) {
+        assertOverwriteAllowed(policy, "force");
+    }
     const projectRoot = await assetRootFromFlag(parsed.flags);
     const json = parsed.flags.has("json") === true;
     const outValue = flagString(parsed.flags, "out");
@@ -901,13 +2368,82 @@ async function runTranscribe(parsed, signal) {
     if (!outValue || !modelValue) {
         usage('"transcribe" requires --out and --model.');
     }
+    const outPath = path.resolve(process.cwd(), outValue);
+    const sourcePath = path.resolve(process.cwd(), parsed.positionals[0]);
+    const modelPath = path.resolve(process.cwd(), modelValue);
+    const formats = parseSubtitleFormats(parsed.flags.get("export"));
+    const exports = formats.map((format) => ({
+        format,
+        path: `${outPath.toLowerCase().endsWith(".json") ? outPath.slice(0, -5) : outPath}.${format}`,
+    }));
+    const force = parsed.flags.has("force") === true;
+    const manifestPath = resolveManifestPath(projectRoot, flagString(parsed.flags, "manifest"));
+    if (dryRun) {
+        if (!outPath.toLowerCase().endsWith(".json")) {
+            throw new FrameyardError("TRANSCRIPT_INVALID", `Transcript output must use a .json extension: ${outPath}`);
+        }
+        const executableValue = flagString(parsed.flags, "executable");
+        const prerequisites = [
+            { label: "transcription source", path: sourcePath },
+            { label: "Whisper model", path: modelPath },
+            ...(executableValue !== undefined ? [{ label: "transcribe executable", path: executableValue }] : []),
+        ];
+        const blockers = await prerequisiteBlockers(prerequisites);
+        for (const destination of [outPath, ...exports.map((entry) => entry.path)]) {
+            if (await pathExists(destination)) {
+                blockers.push({
+                    code: "OUTPUT_EXISTS",
+                    message: `Output already exists: ${destination}.`,
+                    suggestion: policy.allowOverwrite
+                        ? "Pass --force to replace it."
+                        : "Choose a new --out path or ask the user to run with FRAMEYARD_POLICY=full.",
+                });
+            }
+        }
+        const plan = {
+            kind: "transcribe",
+            source: sourcePath,
+            model: modelPath,
+            words: parsed.flags.has("words") === true,
+            exports: formats,
+            out: outPath,
+            manifest: manifestPath,
+            probed: false,
+        };
+        const args = process.argv.slice(2).filter((argument) => argument !== "--dry-run" && argument !== "--json");
+        const prefix = policy.tier === "full" ? "" : "FRAMEYARD_POLICY=full ";
+        const commandLine = prefix + handoffCommand(args);
+        if (json) {
+            printJson({
+                ok: true,
+                command: "transcribe",
+                dryRun: true,
+                deferred: true,
+                policy: policyDetails(policy),
+                ...(profile !== undefined ? { profile } : {}),
+                plan,
+                commandLine,
+                prerequisites: prerequisites.map((item) => item.path),
+                blockers,
+                output: { path: outPath, exists: await pathExists(outPath) },
+                exports,
+            });
+        }
+        else {
+            printDryRun("transcribe", plan, commandLine, prerequisites.map((item) => item.path), blockers);
+        }
+        return 0;
+    }
+    if (shouldLowerPriority(policy, profile, parsed.flags.has("low-priority") === true)) {
+        lowerProcessPriority();
+    }
     const result = await transcribeAudio({
         projectRoot,
-        sourcePath: path.resolve(process.cwd(), parsed.positionals[0]),
-        outPath: path.resolve(process.cwd(), outValue),
-        modelPath: path.resolve(process.cwd(), modelValue),
+        sourcePath,
+        outPath,
+        modelPath,
         words: parsed.flags.has("words") === true,
-        exports: parseSubtitleFormats(parsed.flags.get("export")),
+        exports: formats,
         ...(flagString(parsed.flags, "language") !== undefined
             ? { language: flagString(parsed.flags, "language") }
             : {}),
@@ -917,7 +2453,7 @@ async function runTranscribe(parsed, signal) {
         ...(flagString(parsed.flags, "manifest") !== undefined
             ? { manifestPath: flagString(parsed.flags, "manifest") }
             : {}),
-        force: parsed.flags.has("force") === true,
+        force,
         signal,
     });
     if (json) {
@@ -933,6 +2469,19 @@ async function runTranscribe(parsed, signal) {
     return 0;
 }
 async function runDoctorCommand(parsed, signal) {
+    let policy;
+    let policyError;
+    try {
+        policy = await loadResourcePolicy({ cwd: process.cwd(), env: process.env });
+    }
+    catch (error) {
+        if (isFrameyardError(error) && error.code === "POLICY_INVALID") {
+            policyError = error;
+        }
+        else {
+            throw error;
+        }
+    }
     const projectRoot = await assetRootFromFlag(parsed.flags);
     const manifestPath = resolveManifestPath(projectRoot, flagString(parsed.flags, "manifest"));
     const json = parsed.flags.has("json") === true;
@@ -942,6 +2491,9 @@ async function runDoctorCommand(parsed, signal) {
         ...(flagString(parsed.flags, "qwen-tts") !== undefined
             ? { qwenTts: flagString(parsed.flags, "qwen-tts") }
             : {}),
+        ...(flagString(parsed.flags, "sherpa-onnx-tts") !== undefined
+            ? { sherpaOnnxTts: flagString(parsed.flags, "sherpa-onnx-tts") }
+            : {}),
         ...(flagString(parsed.flags, "whisper-cli") !== undefined
             ? { whisperCli: flagString(parsed.flags, "whisper-cli") }
             : {}),
@@ -951,13 +2503,32 @@ async function runDoctorCommand(parsed, signal) {
         ...(flagString(parsed.flags, "codec-model") !== undefined
             ? { codecModel: flagString(parsed.flags, "codec-model") }
             : {}),
+        ...(flagString(parsed.flags, "model-dir") !== undefined
+            ? { supertonicModelDir: flagString(parsed.flags, "model-dir") }
+            : {}),
         ...(flagString(parsed.flags, "model") !== undefined
             ? { whisperModel: flagString(parsed.flags, "model") }
             : {}),
         signal,
     });
+    const policyReport = policy !== undefined
+        ? { status: "ok", ...policyDetails(policy) }
+        : {
+            status: "error",
+            code: policyError?.code ?? "POLICY_INVALID",
+            detail: policyError?.message ?? "Resource policy could not be loaded.",
+        };
+    const resources = {
+        platform: process.platform,
+        arch: process.arch,
+        cpus: cpus().length,
+        loadAverage: loadavg(),
+        totalMemoryBytes: totalmem(),
+        freeMemoryBytes: freemem(),
+    };
+    const report = { ...result, policy: policyReport, resources };
     if (json) {
-        printJson({ ok: true, command: "doctor", ...result });
+        printJson({ ok: true, command: "doctor", ...report });
     }
     else {
         for (const check of result.checks) {
@@ -965,7 +2536,11 @@ async function runDoctorCommand(parsed, signal) {
             const suffix = check.required ? "" : " (optional)";
             process.stdout.write(`${mark} ${check.name}${suffix}: ${check.detail}\n`);
         }
-        for (const integration of [result.integrations.tts, result.integrations.transcribe]) {
+        for (const integration of [
+            result.integrations.tts,
+            result.integrations.transcribe,
+            result.integrations.sherpaOnnxTts,
+        ]) {
             const mark = integration.status === "ok" ? "✓" : integration.status === "missing" && !integration.requested ? "○" : "✗";
             const detail = integration.detail ? ` — ${integration.detail}` : "";
             const version = integration.version ? ` ${integration.version}` : "";
@@ -976,13 +2551,23 @@ async function runDoctorCommand(parsed, signal) {
             const detail = model.detail ? ` — ${model.detail}` : "";
             process.stdout.write(`${mark} model ${model.role}: ${model.path}${detail}\n`);
         }
+        const fontDetail = result.fonts.detail ? ` — ${result.fonts.detail}` : "";
+        process.stdout.write(`${result.fonts.valid ? "✓" : "✗"} fonts: ${result.fonts.exists ? `${result.fonts.fonts} installed, ${result.fonts.files} files, ${result.fonts.bytes} bytes` : "none"}${fontDetail}\n`);
+        if (policyReport.status === "ok") {
+            process.stdout.write(`✓ policy: ${policyReport.policy}${policyReport.profile ? `, ${policyReport.profile}` : ""}, still ≤${policyReport.maxStillFrames}, ${policyReport.allowOverwrite ? "overwrite allowed" : "overwrite blocked"} (${policyReport.source})\n`);
+        }
+        else {
+            process.stdout.write(`✗ policy: ${policyReport.detail}\n`);
+        }
+        process.stdout.write(`resources: ${resources.cpus} cpus, load ${resources.loadAverage.map((value) => value.toFixed(2)).join(" ")}, ${(resources.totalMemoryBytes / 1024 ** 3).toFixed(1)} GB RAM\n`);
         process.stdout.write(`\ndoctor: ${result.healthy ? "healthy" : "problems found"}\n`);
     }
     return result.healthy ? 0 : 1;
 }
 function reportFailure(error, command, jsonRequested, signal) {
     const aborted = signal?.aborted === true;
-    const code = aborted ? "CANCELLED" : isFrameyardError(error) ? error.code : "INTERNAL";
+    const cancelled = aborted || (isFrameyardError(error) && error.code === "CANCELLED");
+    const code = cancelled ? "CANCELLED" : isFrameyardError(error) ? error.code : "INTERNAL";
     const message = aborted ? "Operation cancelled." : error instanceof Error ? error.message : String(error);
     const details = isFrameyardError(error) ? error.details : undefined;
     const diagnostics = isFrameyardError(error) ? error.diagnostics : undefined;
@@ -998,14 +2583,14 @@ function reportFailure(error, command, jsonRequested, signal) {
             ...(diagnostics !== undefined ? { diagnostics } : {}),
         });
     }
-    process.stderr.write(`${aborted ? "Cancelled" : `error [${code}]`}${aborted ? "" : `: ${message}`}\n`);
+    process.stderr.write(`${cancelled ? "Cancelled" : `error [${code}]`}${cancelled ? "" : `: ${message}`}\n`);
     if (diagnostics !== undefined) {
         printDiagnostics(diagnostics);
     }
     if (!aborted && !isFrameyardError(error) && process.env.FRAMEYARD_DEBUG === "1" && error instanceof Error) {
         process.stderr.write(`${error.stack ?? ""}\n`);
     }
-    if (aborted) {
+    if (cancelled) {
         return 130;
     }
     return code === "USAGE" ? 2 : 1;
@@ -1070,17 +2655,31 @@ async function main(argv) {
     process.on("SIGINT", interrupt);
     process.on("SIGTERM", interrupt);
     try {
+        const needsPolicy = !["doctor", "inspect", "compare", "add"].includes(parsed.command);
+        const policy = needsPolicy ? await loadResourcePolicy({ cwd: process.cwd(), env: process.env }) : undefined;
         switch (parsed.command) {
+            case "context":
+                return await runContext(parsed, controller.signal, policy);
+            case "lint":
+                return await runLint(parsed, controller.signal, policy);
             case "check":
-                return await runCheck(parsed, controller.signal);
+                return await runCheck(parsed, controller.signal, policy);
             case "still":
-                return await runStill(parsed, controller.signal);
+                return await runStill(parsed, controller.signal, policy);
+            case "inspect":
+                return await runInspect(parsed);
+            case "compare":
+                return await runCompare(parsed);
             case "render":
-                return await runRender(parsed, controller.signal);
+                return await runRender(parsed, controller.signal, policy);
             case "tts":
-                return await runTts(parsed, controller.signal);
+                return await runTts(parsed, controller.signal, policy);
             case "transcribe":
-                return await runTranscribe(parsed, controller.signal);
+                return await runTranscribe(parsed, controller.signal, policy);
+            case "font":
+                return await runFont(parsed, controller.signal, policy);
+            case "add":
+                return await runAdd(parsed);
             case "doctor":
                 return await runDoctorCommand(parsed, controller.signal);
             default: