@mevdragon/vidfarm-devcli 0.2.6 → 0.2.8

package/dist/src/services/storage.js

@@ -115,6 +115,19 @@ export class StorageService {
         }
         return readFileSync(path.join(this.localRoot, key), "utf8");
     }
+    async readBuffer(key) {
+        if (this.s3 && config.AWS_S3_BUCKET) {
+            const response = await this.s3.send(new GetObjectCommand({
+                Bucket: config.AWS_S3_BUCKET,
+                Key: key
+            }));
+            if (!response.Body) {
+                return null;
+            }
+            return Buffer.from(await response.Body.transformToByteArray());
+        }
+        return readFileSync(path.join(this.localRoot, key));
+    }
     async listKeys(prefix) {
         if (this.s3 && config.AWS_S3_BUCKET) {
             const keys = [];

package/dist/src/services/template-certification.js

@@ -13,11 +13,17 @@ export class TemplateCertificationService {
             typeof template.about.visual_dna === "string" &&
             Array.isArray(template.about.preview_media) &&
             template.about.preview_media.every((entry) => typeof entry === "string") &&
-            typeof template.about.link_to_original === "string"), "Template must define id, slugId, version, and complete about metadata.", {
+            typeof template.about.link_to_original === "string" &&
+            typeof template.about.proposal_generator === "string" &&
+            Array.isArray(template.about.sample_prompts) &&
+            template.about.sample_prompts.every((entry) => typeof entry === "string") &&
+            template.about.sample_prompts.length > 0), "Template must define id, slugId, version, and complete about metadata, including proposal_generator and sample prompts.", {
             templateId: template.id,
             slugId: template.slugId,
             version: template.version,
-            previewMediaCount: template.about?.preview_media?.length ?? 0
+            previewMediaCount: template.about?.preview_media?.length ?? 0,
+            hasProposalGenerator: typeof template.about?.proposal_generator === "string" && template.about.proposal_generator.length > 0,
+            samplePromptCount: template.about?.sample_prompts?.length ?? 0
         }));
         checks.push(this.check("template.operations", Object.keys(template.operations).length > 0, "Template must define at least one operation."));
         checks.push(this.checkSkill(skillPath));
@@ -124,6 +130,10 @@ function createSmokeContext(templateId) {
                 providerCalls += 1;
                 return { text: "certification text", usage: { inputTokens: 1, outputTokens: 1, costUsd: 0 } };
             },
+            async generateSpeech() {
+                providerCalls += 1;
+                return { bytes: Uint8Array.from([0, 1, 2, 3]), contentType: "audio/mpeg", usage: { inputTokens: 1, outputTokens: 1, costUsd: 0 } };
+            },
             async generateImage() {
                 providerCalls += 1;
                 return { bytes: MOCK_PNG_BYTES, contentType: "image/png", revisedPrompt: null };
@@ -136,6 +146,10 @@ function createSmokeContext(templateId) {
                     maxWidthPercent: 80,
                     justification: "Certification mock layout."
                 };
+            },
+            async transcribeSpeech() {
+                providerCalls += 1;
+                return { text: "certification transcript", usage: { inputTokens: 1, outputTokens: 1, costUsd: 0 } };
             }
         },
         remotion: {

package/dist/src/services/template-loader.js

@@ -4,11 +4,22 @@ export async function loadTemplateFromModule(modulePath) {
     const candidates = Object.values(loaded);
     for (const candidate of candidates) {
         if (isTemplateDefinition(candidate)) {
-            return candidate;
+            return normalizeTemplateDefinition(candidate);
         }
     }
     throw new Error(`No template definition export found in ${modulePath}`);
 }
+function normalizeTemplateDefinition(template) {
+    return {
+        ...template,
+        about: {
+            ...template.about,
+            // Older runtime template releases may predate proposal metadata fields.
+            proposal_generator: template.about.proposal_generator ?? "",
+            sample_prompts: template.about.sample_prompts ?? []
+        }
+    };
+}
 function isTemplateDefinition(value) {
     if (!value || typeof value !== "object") {
         return false;
@@ -20,6 +31,9 @@ function isTemplateDefinition(value) {
     const previewMedia = about && Array.isArray(about.preview_media)
         ? about.preview_media
         : null;
+    const samplePrompts = about && Array.isArray(about.sample_prompts)
+        ? about.sample_prompts
+        : null;
     return (typeof candidate.id === "string" &&
         typeof candidate.slugId === "string" &&
         typeof candidate.version === "string" &&
@@ -31,6 +45,8 @@ function isTemplateDefinition(value) {
         Array.isArray(previewMedia) &&
         previewMedia.every((entry) => typeof entry === "string") &&
         typeof about.link_to_original === "string" &&
+        (typeof about.proposal_generator === "string" || typeof about.proposal_generator === "undefined") &&
+        (samplePrompts === null || samplePrompts.every((entry) => typeof entry === "string")) &&
         typeof candidate.configSchema === "object" &&
         typeof candidate.operations === "object" &&
         typeof candidate.jobs === "object");

package/dist/src/services/template-sources.js

@@ -1,4 +1,6 @@
-import { existsSync, mkdirSync } from "node:fs";
+import { createHash, createHmac } from "node:crypto";
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import os from "node:os";
 import path from "node:path";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
@@ -9,7 +11,9 @@ import { defaultSkillPathForTemplateModule, deriveTemplateRootDirFromModulePath
 import { nowIso } from "../lib/time.js";
 import { loadTemplateFromModule } from "./template-loader.js";
 import { TemplateCertificationService } from "./template-certification.js";
+import { StorageService } from "./storage.js";
 const execFileAsync = promisify(execFile);
+const storage = new StorageService();
 export class TemplateSourceAlreadyRegisteredError extends Error {
     existingSource;
     conflictField;
@@ -22,11 +26,11 @@ export class TemplateSourceAlreadyRegisteredError extends Error {
 }
 export class TemplateSourceService {
     certification = new TemplateCertificationService();
-    listSources() {
-        return database.listTemplateSources();
+    listSources(status) {
+        return database.listTemplateSources(status);
     }
-    listReleases(templateId) {
-        return database.listTemplateReleases(templateId);
+    listReleases(input) {
+        return database.listTemplateReleases(input);
     }
     async registerSource(input) {
         deriveTemplateRootDirFromModulePath(input.templateModulePath);
@@ -61,12 +65,13 @@ export class TemplateSourceService {
         const buildCommand = input.buildCommand ?? "npm run build";
         const skillPath = input.skillPath ?? defaultSkillPathForTemplateModule(input.templateModulePath);
         if (existingSource) {
-            const nextSource = existingSource.repoUrl !== input.repoUrl ||
+            const metadataChanged = existingSource.repoUrl !== input.repoUrl ||
                 existingSource.branch !== branch ||
                 existingSource.templateModulePath !== input.templateModulePath ||
                 existingSource.skillPath !== skillPath ||
                 existingSource.installCommand !== installCommand ||
-                existingSource.buildCommand !== buildCommand
+                existingSource.buildCommand !== buildCommand;
+            const nextSource = metadataChanged
                 ? database.updateTemplateSource({
                     id: existingSource.id,
                     repoUrl: input.repoUrl,
@@ -74,7 +79,8 @@ export class TemplateSourceService {
                     templateModulePath: input.templateModulePath,
                     skillPath,
                     installCommand,
-                    buildCommand
+                    buildCommand,
+                    status: existingSource.status === "disabled" ? "disabled" : "pending_review"
                 })
                 : existingSource;
             return {
@@ -94,7 +100,7 @@ export class TemplateSourceService {
                 skillPath,
                 installCommand,
                 buildCommand,
-                status: "active"
+                status: "pending_review"
             });
             return {
                 source,
@@ -125,13 +131,26 @@ export class TemplateSourceService {
         if (!source) {
             throw new Error("Template source not found.");
         }
-        const commitSha = input.commitSha ?? await this.resolveBranchHead(source.repoUrl, source.branch);
+        const artifactManifest = input.artifactManifestKey
+            ? await this.loadAndVerifyArtifactManifest(input.artifactManifestKey, source)
+            : null;
+        const commitSha = artifactManifest?.commit_sha ?? input.commitSha ?? await this.resolveBranchHead(source.repoUrl, source.branch);
         const checkoutPath = path.join(config.TEMPLATE_SOURCE_ROOT, source.templateId, commitSha);
-        const skillPath = path.join(checkoutPath, source.skillPath);
+        const skillPath = path.join(checkoutPath, artifactManifest?.skill_path ?? source.skillPath);
+        const authRepoUrl = this.resolveGitRemoteUrl(source.repoUrl);
         if (!existsSync(checkoutPath)) {
             mkdirSync(path.dirname(checkoutPath), { recursive: true });
-            await this.runShell(["git", "clone", "--branch", source.branch, source.repoUrl, checkoutPath], process.cwd());
-            await this.runShell(["git", "checkout", commitSha], checkoutPath);
+            if (artifactManifest) {
+                await this.extractArtifactToCheckout({
+                    checkoutPath,
+                    artifactKey: artifactManifest.artifact_key,
+                    expectedSha256: artifactManifest.artifact_sha256
+                });
+            }
+            else {
+                await this.runShell(["git", "clone", "--branch", source.branch, authRepoUrl, checkoutPath], process.cwd());
+                await this.runShell(["git", "checkout", commitSha], checkoutPath);
+            }
             if (source.installCommand.trim()) {
                 await this.runCommandString(source.installCommand, checkoutPath);
             }
@@ -148,7 +167,7 @@ export class TemplateSourceService {
             throw new Error(`Imported template slug_id ${template.slugId} does not match source slug_id ${source.slugId}.`);
         }
         const certificationReport = await this.certification.certify({ template, skillPath });
-        const status = certificationReport.passed ? "certified" : "failed";
+        const status = certificationReport.passed ? "pending_approval" : "failed";
         return database.createTemplateRelease({
             id: createId("trel"),
             sourceId: source.id,
@@ -158,18 +177,183 @@ export class TemplateSourceService {
             checkoutPath,
             skillPath,
             modulePath,
+            artifactManifestKey: input.artifactManifestKey ?? null,
+            artifactKey: artifactManifest?.artifact_key ?? null,
             status,
             certificationReport,
             activatedAt: null
         });
     }
+    async publishRelease(input) {
+        const source = database.getTemplateSource(input.sourceId);
+        if (!source) {
+            throw new Error("Template source not found.");
+        }
+        if (source.status !== "approved") {
+            throw new Error("Template source must be approved before a developer can publish an update.");
+        }
+        const trimmedCommitSha = input.commitSha.trim();
+        if (!trimmedCommitSha) {
+            throw new Error("commit_sha is required.");
+        }
+        const existingRelease = database.getTemplateReleaseBySourceAndCommit(source.id, trimmedCommitSha);
+        if (existingRelease &&
+            (existingRelease.status === "pending_approval"
+                || existingRelease.status === "approved"
+                || existingRelease.status === "active")) {
+            return {
+                source,
+                release: existingRelease,
+                publishAction: "updated"
+            };
+        }
+        const release = await this.importRelease({
+            sourceId: source.id,
+            commitSha: trimmedCommitSha
+        });
+        return {
+            source,
+            release,
+            publishAction: existingRelease ? "updated" : "created"
+        };
+    }
+    async publishArtifactRelease(input) {
+        const source = database.getTemplateSource(input.sourceId);
+        if (!source) {
+            throw new Error("Template source not found.");
+        }
+        if (source.status !== "approved") {
+            throw new Error("Template source must be approved before a developer can publish an update.");
+        }
+        const trimmedCommitSha = input.commitSha.trim();
+        const trimmedArtifactSha256 = input.artifactSha256.trim().toLowerCase();
+        if (!trimmedCommitSha) {
+            throw new Error("commit_sha is required.");
+        }
+        if (!/^[0-9a-f]{64}$/i.test(trimmedArtifactSha256)) {
+            throw new Error("artifact_sha256 must be a 64-character hexadecimal SHA-256 hash.");
+        }
+        const existingRelease = database.getTemplateReleaseBySourceAndCommit(source.id, trimmedCommitSha);
+        if (existingRelease &&
+            (existingRelease.status === "pending_approval"
+                || existingRelease.status === "approved"
+                || existingRelease.status === "active")) {
+            return {
+                source,
+                release: existingRelease,
+                publishAction: "updated"
+            };
+        }
+        const { manifestKey } = await this.createSignedArtifactManifest({
+            source,
+            commitSha: trimmedCommitSha,
+            artifactSha256: trimmedArtifactSha256,
+            signedBy: input.signedBy
+        });
+        const release = await this.importRelease({
+            sourceId: source.id,
+            artifactManifestKey: manifestKey
+        });
+        return {
+            source,
+            release,
+            publishAction: existingRelease ? "updated" : "created"
+        };
+    }
+    async createDeveloperArtifactUpload(input) {
+        const source = database.getTemplateSource(input.sourceId);
+        if (!source) {
+            throw new Error("Template source not found.");
+        }
+        if (source.status !== "approved") {
+            throw new Error("Template source must be approved before a developer can publish an update.");
+        }
+        const trimmedCommitSha = input.commitSha.trim();
+        if (!trimmedCommitSha) {
+            throw new Error("commit_sha is required.");
+        }
+        const artifact = this.buildArtifactKeys(source, trimmedCommitSha);
+        const upload = await storage.createWriteUrl(artifact.artifactKey, {
+            contentType: "application/gzip",
+            publicRead: false,
+            expiresIn: 3600
+        });
+        return {
+            ...artifact,
+            upload
+        };
+    }
+    approveSource(input) {
+        const source = database.getTemplateSource(input.sourceId);
+        if (!source) {
+            throw new Error("Template source not found.");
+        }
+        return database.updateTemplateSource({
+            id: source.id,
+            repoUrl: source.repoUrl,
+            branch: source.branch,
+            templateModulePath: source.templateModulePath,
+            skillPath: source.skillPath,
+            installCommand: source.installCommand,
+            buildCommand: source.buildCommand,
+            status: "approved"
+        });
+    }
+    rejectSource(input) {
+        const source = database.getTemplateSource(input.sourceId);
+        if (!source) {
+            throw new Error("Template source not found.");
+        }
+        return database.updateTemplateSource({
+            id: source.id,
+            repoUrl: source.repoUrl,
+            branch: source.branch,
+            templateModulePath: source.templateModulePath,
+            skillPath: source.skillPath,
+            installCommand: source.installCommand,
+            buildCommand: source.buildCommand,
+            status: "rejected"
+        });
+    }
+    approveRelease(input) {
+        const release = database.getTemplateRelease(input.releaseId);
+        if (!release) {
+            throw new Error("Template release not found.");
+        }
+        if (release.status !== "pending_approval" && release.status !== "approved" && release.status !== "active") {
+            throw new Error("Only pending-approval releases can be approved.");
+        }
+        if (release.status === "active") {
+            return release;
+        }
+        database.updateTemplateReleaseStatus({
+            id: release.id,
+            status: "approved",
+            certificationReport: release.certificationReport,
+            activatedAt: null
+        });
+        return database.getTemplateRelease(release.id);
+    }
+    rejectRelease(input) {
+        const release = database.getTemplateRelease(input.releaseId);
+        if (!release) {
+            throw new Error("Template release not found.");
+        }
+        database.updateTemplateReleaseStatus({
+            id: release.id,
+            status: "rejected",
+            certificationReport: release.certificationReport,
+            activatedAt: null
+        });
+        return database.getTemplateRelease(release.id);
+    }
     async activateRelease(input) {
         const release = database.getTemplateRelease(input.releaseId);
         if (!release) {
             throw new Error("Template release not found.");
         }
-        if (release.status !== "certified" && release.status !== "active") {
-            throw new Error("Only certified releases can be activated.");
+        if (release.status !== "approved" && release.status !== "active") {
+            throw new Error("Only approved releases can be activated.");
         }
         const template = await loadTemplateFromModule(release.modulePath);
         const certificationReport = release.certificationReport ?? await this.certification.certify({
@@ -226,7 +410,7 @@ export class TemplateSourceService {
         }
     }
     async resolveBranchHead(repoUrl, branch) {
-        const { stdout } = await execFileAsync("git", ["ls-remote", repoUrl, branch], { cwd: process.cwd() });
+        const { stdout } = await execFileAsync("git", ["ls-remote", this.resolveGitRemoteUrl(repoUrl), branch], { cwd: process.cwd() });
         const line = stdout.trim().split("\n").find(Boolean);
         if (!line) {
             throw new Error(`Unable to resolve branch ${branch} for ${repoUrl}`);
@@ -248,6 +432,143 @@ export class TemplateSourceService {
             }
         });
     }
+    async loadAndVerifyArtifactManifest(manifestKey, source) {
+        const raw = await storage.readText(manifestKey);
+        if (!raw) {
+            throw new Error(`Artifact manifest not found: ${manifestKey}`);
+        }
+        const manifest = JSON.parse(raw);
+        if (manifest.version !== 1 || manifest.algorithm !== "hmac-sha256") {
+            throw new Error("Unsupported template artifact manifest version or algorithm.");
+        }
+        if (!config.ARTIFACT_SIGNING_SECRET) {
+            throw new Error("ARTIFACT_SIGNING_SECRET or SUPERAGENCY_KEY is required to verify artifact manifests.");
+        }
+        const expectedSignature = createHmac("sha256", config.ARTIFACT_SIGNING_SECRET)
+            .update(this.serializeArtifactManifestPayload({
+            version: 1,
+            algorithm: "hmac-sha256",
+            template_id: String(manifest.template_id ?? ""),
+            slug_id: String(manifest.slug_id ?? ""),
+            repo_url: String(manifest.repo_url ?? ""),
+            branch: String(manifest.branch ?? ""),
+            commit_sha: String(manifest.commit_sha ?? ""),
+            template_module_path: String(manifest.template_module_path ?? ""),
+            skill_path: String(manifest.skill_path ?? ""),
+            install_command: String(manifest.install_command ?? ""),
+            build_command: String(manifest.build_command ?? ""),
+            artifact_key: String(manifest.artifact_key ?? ""),
+            artifact_sha256: String(manifest.artifact_sha256 ?? ""),
+            created_at: String(manifest.created_at ?? ""),
+            signed_by: String(manifest.signed_by ?? "")
+        }))
+            .digest("hex");
+        if (manifest.signature !== expectedSignature) {
+            throw new Error("Template artifact manifest signature verification failed.");
+        }
+        if (manifest.template_id !== source.templateId || manifest.slug_id !== source.slugId) {
+            throw new Error("Template artifact manifest does not match the registered template identity.");
+        }
+        if (manifest.repo_url !== source.repoUrl || manifest.branch !== source.branch) {
+            throw new Error("Template artifact manifest does not match the registered repo URL or branch.");
+        }
+        if (manifest.template_module_path !== source.templateModulePath) {
+            throw new Error("Template artifact manifest does not match the registered template module path.");
+        }
+        if (manifest.skill_path !== source.skillPath) {
+            throw new Error("Template artifact manifest does not match the registered skill path.");
+        }
+        if (manifest.install_command !== source.installCommand || manifest.build_command !== source.buildCommand) {
+            throw new Error("Template artifact manifest does not match the registered install or build command.");
+        }
+        return manifest;
+    }
+    async extractArtifactToCheckout(input) {
+        const archive = await storage.readBuffer(input.artifactKey);
+        if (!archive) {
+            throw new Error(`Template artifact not found: ${input.artifactKey}`);
+        }
+        const actualSha256 = createHash("sha256").update(archive).digest("hex");
+        if (actualSha256 !== input.expectedSha256) {
+            throw new Error(`Template artifact hash mismatch for ${input.artifactKey}.`);
+        }
+        mkdirSync(input.checkoutPath, { recursive: true });
+        const tempArchivePath = path.join(os.tmpdir(), `vidfarm-template-${createId("tmp")}.tar.gz`);
+        writeFileSync(tempArchivePath, archive);
+        try {
+            await execFileAsync("tar", ["-xzf", tempArchivePath, "-C", input.checkoutPath], { cwd: process.cwd() });
+        }
+        finally {
+            rmSync(tempArchivePath, { force: true });
+        }
+    }
+    serializeArtifactManifestPayload(input) {
+        return JSON.stringify({
+            version: input.version,
+            algorithm: input.algorithm,
+            template_id: input.template_id,
+            slug_id: input.slug_id,
+            repo_url: input.repo_url,
+            branch: input.branch,
+            commit_sha: input.commit_sha,
+            template_module_path: input.template_module_path,
+            skill_path: input.skill_path,
+            install_command: input.install_command,
+            build_command: input.build_command,
+            artifact_key: input.artifact_key,
+            artifact_sha256: input.artifact_sha256,
+            created_at: input.created_at,
+            signed_by: input.signed_by
+        });
+    }
+    buildArtifactKeys(source, commitSha) {
+        return {
+            artifactKey: `template-artifacts/${source.templateId}/${commitSha}/source.tar.gz`,
+            manifestKey: `template-artifacts/${source.templateId}/${commitSha}/manifest.json`
+        };
+    }
+    async createSignedArtifactManifest(input) {
+        const artifact = this.buildArtifactKeys(input.source, input.commitSha);
+        const createdAt = nowIso();
+        const payload = {
+            version: 1,
+            algorithm: "hmac-sha256",
+            template_id: input.source.templateId,
+            slug_id: input.source.slugId,
+            repo_url: input.source.repoUrl,
+            branch: input.source.branch,
+            commit_sha: input.commitSha,
+            template_module_path: input.source.templateModulePath,
+            skill_path: input.source.skillPath,
+            install_command: input.source.installCommand,
+            build_command: input.source.buildCommand,
+            artifact_key: artifact.artifactKey,
+            artifact_sha256: input.artifactSha256,
+            created_at: createdAt,
+            signed_by: input.signedBy
+        };
+        const signature = createHmac("sha256", config.ARTIFACT_SIGNING_SECRET)
+            .update(this.serializeArtifactManifestPayload(payload))
+            .digest("hex");
+        await storage.putText(artifact.manifestKey, JSON.stringify({
+            ...payload,
+            signature
+        }, null, 2), "application/json");
+        return {
+            ...artifact,
+            signature
+        };
+    }
+    resolveGitRemoteUrl(repoUrl) {
+        const githubToken = config.VIDFARM_GITHUB_TOKEN || config.GITHUB_TOKEN;
+        if (!githubToken) {
+            return repoUrl;
+        }
+        if (!/^https:\/\/github\.com\//i.test(repoUrl)) {
+            return repoUrl;
+        }
+        return repoUrl.replace(/^https:\/\/github\.com\//i, `https://x-access-token:${encodeURIComponent(githubToken)}@github.com/`);
+    }
     resolveImportableModulePath(checkoutPath, declaredModulePath) {
         const sourceModulePath = path.join(checkoutPath, declaredModulePath);
         const extension = path.extname(sourceModulePath).toLowerCase();

package/{templates/template_0000 → dist/templates/vidfarm_template_0000}/src/remotion/Root.js

@@ -1,4 +1,5 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from "react";
 import { AbsoluteFill, Composition, Img, Sequence, interpolate, spring, useCurrentFrame, useVideoConfig } from "remotion";
 export const RemotionRoot = () => {
     return (_jsx(Composition, { id: "template-0000", component: TemplateVideo, width: 1080, height: 1920, fps: 30, durationInFrames: 120, defaultProps: { slides: [] }, calculateMetadata: ({ props }) => ({

package/dist/templates/{template_0000 → vidfarm_template_0000}/src/template.js

@@ -100,6 +100,12 @@ export const template0000Definition = defineTemplate({
         visual_dna: templateVisualDna,
         preview_media: [...TEMPLATE_PREVIEW_MEDIA],
         link_to_original: templateLinkToOriginal,
+        proposal_generator: "Given the director's product, customer, and angle, propose multiple slideshow concepts that fit this template's creator-native TikTok format. Return concrete post ideas that can either be used directly as single prompts or expanded into 10+ related prompts. Favor specific hooks, clear educational angles, founder stories, product proof, objections, comparisons, and repeatable series ideas.",
+        sample_prompts: [
+            "Make a 3-slide TikTok slideshow explaining why cold plunges feel so hard at first but get easier after a week. Use exact overlay text for each slide and generate matching cinematic background prompts.",
+            "Create a founder-story slideshow about launching a niche coffee brand, with one hook slide, one proof slide, and one CTA slide. Keep the tone creator-native and direct.",
+            "Build a product explainer slideshow for a posture-correcting desk setup. I want concise overlays, clean visual prompts, and output ready for optional Remotion rendering."
+        ],
     },
     skillPath,
     configSchema: z.object({
@@ -1407,7 +1413,7 @@ function resolveRemotionEntryPoint() {
 function resolveTemplateRuntimeConfig() {
     const candidates = [
         fileURLToPath(new URL("../template.config.json", import.meta.url)),
-        path.resolve(process.cwd(), "templates/template_0000/template.config.json"),
+        path.resolve(process.cwd(), "templates/vidfarm_template_0000/template.config.json"),
     ];
     for (const candidate of candidates) {
         if (!existsSync(candidate)) {
@@ -1422,13 +1428,13 @@ function resolveSkillPath() {
     if (existsSync(builtPath)) {
         return builtPath;
     }
-    return path.resolve(process.cwd(), "templates/template_0000/SKILL.md");
+    return path.resolve(process.cwd(), "templates/vidfarm_template_0000/SKILL.md");
 }
 function resolveOverlayFonts() {
     const resolved = Object.fromEntries(TEMPLATE_FONT_OPTIONS.map((option) => {
         const candidates = [
             fileURLToPath(new URL(`../assets/${option.assetFile}`, import.meta.url)),
-            path.resolve(process.cwd(), `templates/template_0000/assets/${option.assetFile}`),
+            path.resolve(process.cwd(), `templates/vidfarm_template_0000/assets/${option.assetFile}`),
         ];
         for (const candidate of candidates) {
             if (existsSync(candidate)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mevdragon/vidfarm-devcli",
-  "version": "0.2.6",
+  "version": "0.2.8",
   "description": "Developer CLI for running the Vidfarm local template platform.",
   "type": "module",
   "bin": {
@@ -9,8 +9,8 @@
   },
   "files": [
     "dist/src",
-    "dist/templates/template_0000",
-    "templates/template_0000",
+    "dist/templates/vidfarm_template_0000",
+    "templates/vidfarm_template_0000",
     "README.md",
     "SKILL.developer.md",
     "GETTING_STARTED.developers.md",
@@ -29,6 +29,7 @@
   "scripts": {
     "dev": "tsx watch src/index.ts",
     "dev:cli": "tsx src/cli.ts dev",
+    "operator:template-artifact": "node scripts/platform-operator-template-artifact.mjs",
     "deploy:prod-inplace": "bash scripts/deploy-prod-inplace.sh",
     "rollback:prod-inplace": "bash scripts/rollback-prod-inplace.sh",
     "build": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\" && tsc -p tsconfig.json",

package/templates/{template_0000 → vidfarm_template_0000}/README.md

@@ -23,6 +23,22 @@ Production integration settings are checked into `template.config.json`. AI agen
 - the template module path, which should be the TypeScript source entrypoint `src/template.ts`
 - the local Remotion composition settings used by the starter template
 
+## Required template contract
+
+Every new template copied from `template_0000` should keep the current required `defineTemplate(...)` contract intact.
+
+- `id`, `slugId`, and `version`
+- `about.title` and `about.description`
+- `about.viral_dna`, `about.visual_dna`, `about.preview_media`, and `about.link_to_original`
+- `about.proposal_generator`, which teaches a director or agent how to turn business context into template-native post proposals
+- `about.sample_prompts`, which shows multiple concrete high-signal prompts for the template
+- `configSchema`
+- at least one operation with a `smokeTestPayload`
+- a matching workflow implementation in `jobs`
+- a template-local `SKILL.md`
+
+The starter already ships with example `proposal_generator` and `sample_prompts` values in `src/template.ts`. When you adapt this template, replace them with instructions and examples that fit the new format instead of leaving the starter language in place.
+
 ## Included
 
 - `SKILL.md` for customer AI-agent usage
@@ -75,3 +91,10 @@ vidfarm analyze-visual-dna --template-dir .
 ```
 
 If you scaffold a template with `vidfarm generate-template` and provide `--source-preview-dir`, the CLI will run both analyzers automatically unless `--skip-dna-analysis` is set.
+
+After DNA analysis, review and customize the remaining human-authored metadata before calling the template ready:
+
+- refresh `about.proposal_generator`
+- refresh `about.sample_prompts`
+- update `SKILL.md` to match the actual operations and payload shapes
+- run `vidfarm validate-template --template-id <slug-or-id>` and at least one real local job

package/templates/{template_0000 → vidfarm_template_0000}/package.json

@@ -19,7 +19,6 @@
     "sharp": "^0.34.2"
   },
   "devDependencies": {
-    "@mevdragon/vidfarm-devcli": "^0.2.2",
     "@types/node": "^24.0.1",
     "@types/react": "^18.3.23",
     "@types/react-dom": "^18.3.7",