@slatesvideo/shared 0.6.3 → 0.6.4

package/dist/operations/surface.d.ts

@@ -0,0 +1,69 @@
+import type { z } from 'zod';
+import type { OperationAnnotations, OperationGroup, OperationTier } from './index.js';
+/** Structural shape of an op, declared locally so this module never imports a
+ *  VALUE from the registry (which imports this one). */
+export interface SurfaceOp {
+    id: string;
+    description: string;
+    input: z.ZodType<unknown>;
+    billable?: boolean;
+    tier?: OperationTier;
+    group?: OperationGroup;
+    annotations?: OperationAnnotations;
+}
+/**
+ * Derive an op's four hints.
+ *
+ * `openWorldHint` means "reaches something outside this system": every billable
+ * op hits a provider, and every Blender op hits a separate process over a
+ * socket. Everything else touches only the user's own workspace.
+ */
+export declare function annotate(id: string, billable: boolean | undefined): OperationAnnotations;
+/**
+ * The deferred groups, by op id. Everything NOT listed here is `core`.
+ *
+ * The cut is "what a session needs to do the work" versus "what it needs once,
+ * when the user asks for that thing". Creating, generating, reviewing and
+ * shot-listing are core; tidying the library, cutting a timeline, renaming and
+ * deleting, and driving Blender are not — and each is a coherent thing a user
+ * asks for by name, which is what makes a group loadable in one call.
+ *
+ * 🚨 A GROUP IS A BUDGET, NOT A LAW. If `final_state` falls on timeline or
+ * library tasks after this shipped, move those ops back to core. The point is
+ * the per-turn byte count, and a deferral that costs a turn every time is not
+ * paying for itself.
+ */
+export declare const OPERATION_GROUPS: Record<OperationGroup, readonly string[]>;
+export declare function groupFor(id: string): OperationGroup | undefined;
+/** `extended` iff the op names a group. Absent from every group ⇒ `core`, so a
+ *  new op is visible until someone deliberately defers it. */
+export declare function tierFor(id: string): OperationTier;
+/** One-line summary of each group, for `slates_load_tools`' own description. */
+export declare const GROUP_SUMMARY: Record<OperationGroup, string>;
+export interface ToolDefinition {
+    name: string;
+    description: string;
+    /** JSON Schema. Both surfaces read the same object under their own key name. */
+    inputSchema: Record<string, unknown>;
+    annotations: OperationAnnotations;
+}
+/**
+ * Render one op's tool definition.
+ *
+ * `$refStrategy: 'none'` is the shape both surfaces now emit: inlined, so no
+ * client has to resolve a `$ref`, and byte-identical between them — which is
+ * what makes "the two surfaces expose the same tools" checkable rather than
+ * merely asserted about the id set.
+ */
+export declare function toolDefinition(op: SurfaceOp): ToolDefinition;
+/**
+ * Render a tool surface.
+ *
+ * `desktop` sends `core` plus whatever groups have been loaded this run; `mcp`
+ * sends everything, because a stdio server has no run to append to.
+ */
+export declare function toolDefinitions(ops: readonly SurfaceOp[], opts: {
+    surface: 'desktop' | 'mcp';
+    groups?: readonly OperationGroup[];
+}): ToolDefinition[];
+//# sourceMappingURL=surface.d.ts.map

package/dist/operations/surface.js

@@ -0,0 +1,227 @@
+// ============================================================
+// THE TOOL SURFACE: annotations, tiers, and the ONE schema renderer.
+//
+// Three jobs that all answer "what does a client see, and when":
+//
+//   1. ANNOTATIONS (MCP spec 2025-06-18). `readOnlyHint` / `destructiveHint` /
+//      `idempotentHint` / `openWorldHint`, so a host can auto-approve a read
+//      and warn on a delete. Without them `slates_list_assets` prompts exactly
+//      like `slates_delete_project`, every prompt looks the same, and the user
+//      learns to click through all of them.
+//
+//   2. TIERS. 90 ops is 112 KB of descriptions and JSON schemas on EVERY
+//      desktop Studio Agent turn. `core` is what a session needs to work;
+//      `extended` is deferred behind `slates_load_tools` and appended to the
+//      run's tool list once a group loads. The MCP server still registers
+//      everything — a stdio server has no run to append to, and Claude Code
+//      already defers stdio tool schemas through its own tool search.
+//
+//   3. ONE SCHEMA RENDERER. The desktop rendered `$refStrategy: 'none'` and
+//      the MCP server rendered `target: 'openApi3'`, so "the two surfaces
+//      expose the same tools" was true of the ID SET and unproven of the
+//      BYTES. `toolDefinitions()` is now the only renderer either one calls.
+//
+// 🚨 NOTHING HERE IS HAND-SET PER OP. Annotations are derived from the op id
+// by the rules below, and `scripts/agent-surface-lockstep-check.mjs` re-derives
+// them INDEPENDENTLY from each op's own transport verbs — a `readOnlyHint` on
+// an op whose `run` body posts is a lie that lets a host auto-approve a
+// mutation, so the check has to be able to catch it, and it is mutation-tested.
+// ============================================================
+import { zodToJsonSchema } from 'zod-to-json-schema';
+// ── 1. Annotations ──────────────────────────────────────────────────────────
+/** Ops that only read. Prefixes, because the verb IS the first word of the id. */
+const READ_ONLY_PREFIXES = [
+    'slates_get_',
+    'slates_list_',
+    'slates_estimate_',
+    'slates_blender_status',
+    'slates_blender_scene',
+    'slates_blender_docs',
+    'slates_blender_search_docs',
+];
+/**
+ * Ops whose effect a user cannot undo from inside Slates.
+ *
+ * Moves are here on purpose: `slates_move_assets_to_project` relocates files on
+ * disk, and an agent that guessed the wrong project has no "put it back"
+ * without knowing where they came from. A rename is recoverable; a move across
+ * projects, in practice, is not.
+ */
+const DESTRUCTIVE_IDS = new Set([
+    'slates_delete_project',
+    'slates_delete_asset',
+    'slates_delete_folder',
+    'slates_delete_character',
+    'slates_delete_environment',
+    'slates_delete_style',
+    'slates_delete_storyboard',
+    'slates_delete_scene',
+    'slates_delete_frame',
+    'slates_move_assets_to_folder',
+    'slates_move_assets_to_project',
+    'slates_move_entity_to_project',
+    'slates_merge_shots',
+    'slates_split_shot',
+]);
+/** Same input, same end state — `update`/`set`/`reorder`/`rename` all overwrite
+ *  rather than append, so re-running one is a no-op rather than a second edit. */
+const IDEMPOTENT_PREFIXES = [
+    'slates_update_',
+    'slates_set_',
+    'slates_reorder_',
+    'slates_rename_',
+    'slates_batch_update_',
+];
+const startsWithAny = (id, prefixes) => prefixes.some((p) => id.startsWith(p));
+/**
+ * Derive an op's four hints.
+ *
+ * `openWorldHint` means "reaches something outside this system": every billable
+ * op hits a provider, and every Blender op hits a separate process over a
+ * socket. Everything else touches only the user's own workspace.
+ */
+export function annotate(id, billable) {
+    const readOnlyHint = startsWithAny(id, READ_ONLY_PREFIXES);
+    return {
+        readOnlyHint,
+        // A read is never destructive, whatever the id looks like.
+        destructiveHint: !readOnlyHint && DESTRUCTIVE_IDS.has(id),
+        idempotentHint: readOnlyHint || startsWithAny(id, IDEMPOTENT_PREFIXES),
+        openWorldHint: !!billable || id.startsWith('slates_blender_'),
+    };
+}
+// ── 2. Tiers ────────────────────────────────────────────────────────────────
+/**
+ * The deferred groups, by op id. Everything NOT listed here is `core`.
+ *
+ * The cut is "what a session needs to do the work" versus "what it needs once,
+ * when the user asks for that thing". Creating, generating, reviewing and
+ * shot-listing are core; tidying the library, cutting a timeline, renaming and
+ * deleting, and driving Blender are not — and each is a coherent thing a user
+ * asks for by name, which is what makes a group loadable in one call.
+ *
+ * 🚨 A GROUP IS A BUDGET, NOT A LAW. If `final_state` falls on timeline or
+ * library tasks after this shipped, move those ops back to core. The point is
+ * the per-turn byte count, and a deferral that costs a turn every time is not
+ * paying for itself.
+ */
+export const OPERATION_GROUPS = {
+    // Folders, styles, and moving assets around. Reached when the user says
+    // "tidy this up", never while making the thing.
+    library: [
+        'slates_list_folders',
+        'slates_create_folder',
+        'slates_rename_folder',
+        'slates_delete_folder',
+        'slates_set_folder_cover',
+        'slates_move_assets_to_folder',
+        'slates_move_assets_to_project',
+        'slates_copy_assets_to_project',
+        'slates_move_entity_to_project',
+        'slates_list_styles',
+        'slates_create_style',
+        'slates_update_style',
+        'slates_delete_style',
+        'slates_get_project_directory',
+        'slates_reveal_file',
+    ],
+    // The cut and the export. A generation session never touches these.
+    timeline: [
+        'slates_get_timeline',
+        'slates_add_clip_to_timeline',
+        'slates_reorder_clips',
+        'slates_remove_clip',
+        'slates_add_timeline_track',
+        'slates_update_timeline_track',
+        'slates_remove_timeline_track',
+        'slates_update_timeline_settings',
+        'slates_export_video',
+        'slates_export_timeline_xml',
+        'slates_trim_video',
+    ],
+    // Rename, delete, reorder. The 63-op CRUD tail the review measured at 39.5 KB.
+    admin: [
+        'slates_update_project',
+        'slates_delete_project',
+        'slates_delete_asset',
+        'slates_update_character',
+        'slates_delete_character',
+        'slates_update_environment',
+        'slates_delete_environment',
+        'slates_update_storyboard',
+        'slates_delete_storyboard',
+        'slates_update_scene',
+        'slates_delete_scene',
+        'slates_reorder_scenes',
+        'slates_delete_frame',
+        'slates_batch_update_frames',
+        'slates_duplicate_shot',
+        'slates_split_shot',
+        'slates_merge_shots',
+    ],
+    // A third transport nobody without Blender installed can reach.
+    blender: [
+        'slates_blender_status',
+        'slates_blender_execute',
+        'slates_blender_scene',
+        'slates_blender_docs',
+        'slates_blender_search_docs',
+        'slates_blender_render_blocking',
+    ],
+};
+const GROUP_BY_OP = new Map();
+for (const [group, ids] of Object.entries(OPERATION_GROUPS)) {
+    for (const id of ids)
+        GROUP_BY_OP.set(id, group);
+}
+export function groupFor(id) {
+    return GROUP_BY_OP.get(id);
+}
+/** `extended` iff the op names a group. Absent from every group ⇒ `core`, so a
+ *  new op is visible until someone deliberately defers it. */
+export function tierFor(id) {
+    return GROUP_BY_OP.has(id) ? 'extended' : 'core';
+}
+/** One-line summary of each group, for `slates_load_tools`' own description. */
+export const GROUP_SUMMARY = {
+    library: 'folders, styles, moving and copying assets between projects, revealing files on disk',
+    timeline: 'the timeline (tracks, clips, settings), video export and NLE XML export, clip trimming',
+    admin: 'rename / delete / reorder for projects, characters, environments, storyboards, scenes and frames; shot duplicate, split and merge',
+    blender: 'the Blender previs bridge — scene inspection, bpy execution, API docs, grey-box render',
+};
+/**
+ * Render one op's tool definition.
+ *
+ * `$refStrategy: 'none'` is the shape both surfaces now emit: inlined, so no
+ * client has to resolve a `$ref`, and byte-identical between them — which is
+ * what makes "the two surfaces expose the same tools" checkable rather than
+ * merely asserted about the id set.
+ */
+export function toolDefinition(op) {
+    const schema = zodToJsonSchema(op.input, { $refStrategy: 'none' });
+    delete schema.$schema;
+    return {
+        name: op.id,
+        description: op.description,
+        inputSchema: schema,
+        annotations: op.annotations ?? annotate(op.id, op.billable),
+    };
+}
+/**
+ * Render a tool surface.
+ *
+ * `desktop` sends `core` plus whatever groups have been loaded this run; `mcp`
+ * sends everything, because a stdio server has no run to append to.
+ */
+export function toolDefinitions(ops, opts) {
+    const loaded = new Set(opts.groups ?? []);
+    return ops
+        .filter((op) => {
+        if (opts.surface === 'mcp')
+            return true;
+        const group = groupFor(op.id);
+        return group === undefined || loaded.has(group);
+    })
+        .map(toolDefinition);
+}
+//# sourceMappingURL=surface.js.map

package/dist/prompts/agent-doctrine.js

@@ -101,6 +101,7 @@ export const HARD_RULES = [
     fork(`- COST DISCIPLINE (slates-cost-discipline): never fire a billable generation outside an approved plan. Estimate before you promise. Batch related generations into one plan.`, `- COST DISCIPLINE (slates-cost-discipline): never fire a billable generation the user has not agreed to. Estimate before you promise. Batch related generations into one quote so the user approves a total, not a drip.`),
     both(`- CONTENT POLICY: before writing prompts involving real people/celebrities, minors, brands/logos, weapons, or gore, load slates-content-policy and build the scene safe from the first word. If a provider rejects (e.g. real-face detection), explain in plain language — refunds for provider rejections are automatic.`),
     both(`- PROMPT IS LAW (reference doctrine): references are cited inline by name and image number ("Marcus (images 1 and 2)"); the prompt text leads. Never write role-essays about what each reference is "for".`),
+    both(`- NAMES AND DESCRIPTIONS ARE THE USER'S UI, NOT YOUR NOTEPAD. A project, storyboard or shot name is rendered at the top of the user's screen at all times. Name it after the piece ("Kaiju selfie"), never after your process, and NEVER append your own status or housekeeping — no "shot list", no "v2", no "Written from IMG-A172 and IMG-A182", no "Delete freely", no "scratch". Leave the description empty unless the user gave you one worth keeping: a note-to-self at the top of the screen reads as part of the product, and the user has to look at it every day. Say that kind of thing in your reply to them instead.`),
     both(`- RESOLUTION DEFAULT IS UNIFORM: 1080p on the best available video model. Do not crank resolution the user didn't ask for.`),
     // ⛔ THE MODEL ROUTING BLOCK IS GONE FROM HERE, DELIBERATELY (2026-08-30).
     //
@@ -131,6 +132,12 @@ export const HARD_RULES = [
     // fabricate: what the generation LOOKS like.
     fork(`- REAL NUMBERS ONLY — NEVER approximate, estimate, or recall any figure. Every cost, balance, count, or duration you state must be copied verbatim from a tool result IN THIS SESSION: generation costs come from the cost_credits field in generate/status results (whole credits); the balance comes from a fresh slates_get_credit_balance call at summary time (never arithmetic you did yourself); orchestration cost is displayed by the app automatically — NEVER state or estimate it. No "approx", no "~", no rounded guesses. A number you cannot point to in a tool result is a number you do not say.`, `- REAL NUMBERS ONLY — NEVER approximate, estimate, or recall any figure. Every cost, balance, count, or duration you state must be copied verbatim from a tool result IN THIS SESSION: generation costs come from the cost_credits field in generate/status results (whole credits); the balance comes from a fresh slates_get_credit_balance call at summary time (never arithmetic you did yourself). No "approx", no "~", no rounded guesses. A number you cannot point to in a tool result is a number you do not say. The same rule covers what you SAW: never describe how a generation looks unless you fetched it this session with slates_get_asset_image / slates_get_asset_video_frames.`),
     both(`- MODEL IDS ARE FIXED: slates_generate_video takes exactly ${VIDEO_MODELS.join(' | ')}, with duration + videoResolution as separate params. slates_generate_audio takes exactly ${AUDIO_MODELS.join(' | ')}. Registry entries like "kling-v3-standard-8s" or "seed-audio-15s" are billing keys, not model ids.`),
+    // ONE LINE, NOT A SECTION. The counts themselves ride the op RESULT, where
+    // the agent is already reading — measured: a rule inlined into an op moved
+    // compliance 0/8 → 30/32, while the same guidance behind a guide fetch sat at
+    // 13% before and after. This sentence exists only to say the numbers are
+    // there and must be looked at; the craft is the skill.
+    both(`- READ THE VARIETY COUNTS BEFORE FIRING A SET: slates_list_shots and slates_get_storyboard_with_frames return the distribution (shot sizes, camera moves, runs of three or more) with the rows. If one bucket is the plurality, fix the board before you spend — slates-shot-variety is the craft.`),
     both(`- AUDIO LENGTH IS PROMPT-DRIVEN ON SEED AUDIO: it has no duration parameter, so the durationSeconds you pass is written into the prompt AND is what the user is charged, whatever comes back. Choose it deliberately and load slates-prompting-seed-audio before the first call.`),
 ];
 // ── Surface-only footers ───────────────────────────────────────────

package/dist/prompts/asset-label.d.ts

@@ -0,0 +1,23 @@
+/**
+ * A readable label for a generated asset, from its prompt.
+ *
+ * Strips a reference preamble, then takes the first CLAUSE rather than a fixed
+ * character slice — so the label ends on a word instead of mid-syllable.
+ * Returns null for a prompt with nothing usable in it; the caller decides what
+ * to show instead (a Shot name, "Untitled").
+ */
+export declare function labelFromPrompt(prompt: string | null | undefined): string | null;
+/**
+ * The caption for one asset row, in priority order: the label it was given, the
+ * Shot it came from, then the prompt reduced to a clause.
+ *
+ * The Shot name sits second because an author who named a Shot chose that word
+ * on purpose, and it is the word on the row in the storyboard — so the gallery
+ * and the document call the same thing the same thing.
+ */
+export declare function assetCaption(a: {
+    label?: string | null;
+    shotName?: string | null;
+    prompt?: string | null;
+}): string;
+//# sourceMappingURL=asset-label.d.ts.map

package/dist/prompts/asset-label.js

@@ -0,0 +1,70 @@
+// ============================================================
+// ASSET LABELS — what a generated thing is CALLED in a list.
+//
+// 🚨 THE FIRST 40 CHARACTERS OF A PROMPT IS NOT A LABEL, and on
+// reference-driven work it is actively misleading: every one of those prompts
+// opens with the same composed preamble, so a whole gallery reads
+// "Reference image 1 is a character ide" — the same string on every row, which
+// is worse than no label because it looks like information.
+//
+// One rule, two consumers: the op surface's `compactAsset` (what an agent reads
+// back from `slates_list_assets`) and the desktop gallery caption. A second
+// copy of this would drift the way every other hand-mirrored rule in this
+// workspace has.
+//
+// Dependency-free LEAF, same as `shot-grammar`: the desktop RENDERER imports it
+// directly, so it may never reach for `node:` anything.
+// ============================================================
+/**
+ * A composed prompt's reference preamble.
+ *
+ * The composer writes "Reference image 1 is a character identity sheet." — so
+ * the optional leading "Reference" has to be matched SEPARATELY from the noun,
+ * or the pattern only catches the bare "Image 1 is …" form and every real
+ * composed prompt walks straight past it. (It did, until the labels were
+ * exercised on actual prompts.)
+ */
+const REFERENCE_PREAMBLE_RE = /^\s*(?:reference\s*)?(?:image|video|audio|clip)?\s*\d*\s*is\b[^.;]*[.;]\s*/i;
+/** A sentence boundary always ends the label. */
+const SENTENCE_BOUNDARY_RE = /(?<=[.;:])\s/;
+/**
+ * An em-dash ends it too — but only once there is enough label to be worth
+ * keeping. Composed prompts join a subject to its treatment with one, and the
+ * subject alone is the label; a hand-written "wide shot — the barn at dawn"
+ * would otherwise be cut down to "wide shot", which names nothing.
+ */
+const DASH_BOUNDARY_RE = /\s—\s/;
+const MIN_BEFORE_DASH = 25;
+const MAX = 60;
+/**
+ * A readable label for a generated asset, from its prompt.
+ *
+ * Strips a reference preamble, then takes the first CLAUSE rather than a fixed
+ * character slice — so the label ends on a word instead of mid-syllable.
+ * Returns null for a prompt with nothing usable in it; the caller decides what
+ * to show instead (a Shot name, "Untitled").
+ */
+export function labelFromPrompt(prompt) {
+    if (!prompt)
+        return null;
+    const body = (prompt.replace(REFERENCE_PREAMBLE_RE, '').trim() || prompt).trim();
+    let clause = body.split(SENTENCE_BOUNDARY_RE)[0].trim();
+    const dash = clause.split(DASH_BOUNDARY_RE)[0].trim();
+    if (dash.length >= MIN_BEFORE_DASH)
+        clause = dash;
+    if (!clause)
+        return null;
+    return clause.length > MAX ? `${clause.slice(0, MAX - 1).trimEnd()}…` : clause;
+}
+/**
+ * The caption for one asset row, in priority order: the label it was given, the
+ * Shot it came from, then the prompt reduced to a clause.
+ *
+ * The Shot name sits second because an author who named a Shot chose that word
+ * on purpose, and it is the word on the row in the storyboard — so the gallery
+ * and the document call the same thing the same thing.
+ */
+export function assetCaption(a) {
+    return a.label?.trim() || a.shotName?.trim() || labelFromPrompt(a.prompt) || 'Untitled';
+}
+//# sourceMappingURL=asset-label.js.map

package/dist/prompts/banned-tokens.d.ts

@@ -10,8 +10,20 @@ export interface BannedToken {
 /** Every banned token, in skill-document order. Integrity asserted at load. */
 export declare const BANNED_PROMPT_TOKENS: readonly BannedToken[];
 export declare function bannedTokensFor(scope: BannedTokenScope): readonly BannedToken[];
-/** The tokens a submitted prompt actually contains. */
-export declare function findBannedTokens(prompt: string, scope: BannedTokenScope): BannedToken[];
+/** The never-use list a single skill declares. Empty for a skill with no block. */
+export declare function bannedTokensForSkill(skill: string): readonly BannedToken[];
+/**
+ * A single model's never-use list, for the estimate RESULT.
+ *
+ * Deliberately NOT the cross-model list — that one already rides the op
+ * description on every call. This is the half that could not: the quirk that is
+ * true of Veo and false of Kling.
+ */
+export declare function describeBannedTokensForSkill(skill: string): string;
+/** The tokens a submitted prompt actually contains. `skill` adds that model's
+ *  own list to the modality-wide one — the two overlap for nano-banana-2 and
+ *  seedance, so hits are deduplicated by token. */
+export declare function findBannedTokens(prompt: string, scope: BannedTokenScope, skill?: string): BannedToken[];
 /**
  * The list as it appears INSIDE an op description — always in context, on both
  * surfaces, with no call required to see it. Generated, never hand-typed.
@@ -24,5 +36,5 @@ export declare function describeBannedTokens(scope: BannedTokenScope): string;
  * rather than raised as an error. The generation proceeds either way: the
  * sandbox doctrine says make state visible, never block.
  */
-export declare function bannedTokenWarning(prompt: string, scope: BannedTokenScope): string;
+export declare function bannedTokenWarning(prompt: string, scope: BannedTokenScope, skill?: string): string;
 //# sourceMappingURL=banned-tokens.d.ts.map

package/dist/prompts/banned-tokens.js

@@ -30,18 +30,52 @@
 // ============================================================
 import { SKILLS } from '../skills/content.js';
 /**
- * Where each scope's list lives.
+ * Where each scope's CROSS-MODEL list lives.
  *
  * One skill per scope on purpose: these are the two lists that are GENERIC to
  * their modality (Stable-Diffusion-era tag soup for images, quality
- * incantations for video), not model-specific quirks. A per-model list would
- * mean the op description changed with the `model` argument, which it cannot —
- * a description is one static string for every call.
+ * incantations for video), not model-specific quirks. A per-model list cannot
+ * ride the op DESCRIPTION — a description is one static string for every call,
+ * so it cannot change with the `model` argument. That is what
+ * `bannedTokensForSkill` below is for: the per-model list rides the estimate
+ * RESULT, where the model has just been named.
  */
 const BANNED_TOKEN_SOURCES = [
     { skill: 'slates-prompting-nano-banana-2', scope: 'image' },
     { skill: 'slates-prompting-seedance', scope: 'video' },
 ];
+/**
+ * 🚨 THE ENFORCEMENT THAT WORKED COVERED TWO SKILLS OF FIFTEEN.
+ *
+ * `describeBannedTokens('image')` was Nano Banana's list and `('video')` was
+ * Seedance's, so a Veo, Kling, LTX, MiniMax, FLUX, Seedream, GPT-Image or audio
+ * generation was matched against another model's never-use list and its own was
+ * enforced by nothing — while four skills (content-policy, lip-sync,
+ * minimax-h3, motion-transfer) carried never-use prose with no markers at all,
+ * which is a rule an LLM has to notice.
+ *
+ * Every skill that carries an `@banned` block now contributes to a per-skill
+ * list, delivered on the estimate result beside the craft card. The two above
+ * stay ALSO on the op descriptions, because a modality-wide list is true of
+ * every call that op can make.
+ */
+function extractPerSkill() {
+    const out = new Map();
+    for (const [skill, content] of Object.entries(SKILLS)) {
+        // Cheap pre-test: only pay the regex for files that carry the marker.
+        if (!content.includes('@banned:start'))
+            continue;
+        const scope = inferScope(skill);
+        out.set(skill, extractFromSkill(skill).map((token) => ({ token, skill, scope })));
+    }
+    return out;
+}
+/** Image-lane skills prompt for pixels; everything else is a time-based lane.
+ *  Only used to tag a token for the warning text — the per-skill list is
+ *  matched by SKILL, never by scope, so a wrong guess here cannot mis-enforce. */
+function inferScope(skill) {
+    return /nano-banana|gpt-image|flux|seedream/.test(skill) ? 'image' : 'video';
+}
 const FENCE_RE = /<!--\s*@banned:start\s*-->([\s\S]*?)<!--\s*@banned:end\s*-->/g;
 const HTML_COMMENT_RE = /<!--[\s\S]*?-->/g;
 const BACKTICKED_RE = /`([^`\n]+)`/g;
@@ -115,9 +149,42 @@ for (const { token, skill } of BANNED_PROMPT_TOKENS) {
             `matcherFor() the new shape.`);
     }
 }
-/** The tokens a submitted prompt actually contains. */
-export function findBannedTokens(prompt, scope) {
-    return bannedTokensFor(scope).filter((b) => matcherFor(b.token).test(prompt));
+/** Every per-skill list, keyed by skill name. */
+const bySkill = extractPerSkill();
+/** The never-use list a single skill declares. Empty for a skill with no block. */
+export function bannedTokensForSkill(skill) {
+    return bySkill.get(skill) ?? [];
+}
+/**
+ * A single model's never-use list, for the estimate RESULT.
+ *
+ * Deliberately NOT the cross-model list — that one already rides the op
+ * description on every call. This is the half that could not: the quirk that is
+ * true of Veo and false of Kling.
+ */
+export function describeBannedTokensForSkill(skill) {
+    const list = bannedTokensForSkill(skill);
+    if (list.length === 0)
+        return '';
+    return (`NEVER put these in a ${skill.replace('slates-prompting-', '')} prompt: ` +
+        list.map((b) => `"${b.token}"`).join(', ') +
+        `. Describe specifically instead (${skill}).`);
+}
+/** The tokens a submitted prompt actually contains. `skill` adds that model's
+ *  own list to the modality-wide one — the two overlap for nano-banana-2 and
+ *  seedance, so hits are deduplicated by token. */
+export function findBannedTokens(prompt, scope, skill) {
+    const candidates = [...bannedTokensFor(scope), ...(skill ? bannedTokensForSkill(skill) : [])];
+    const seen = new Set();
+    const hits = [];
+    for (const b of candidates) {
+        if (seen.has(b.token))
+            continue;
+        seen.add(b.token);
+        if (matcherFor(b.token).test(prompt))
+            hits.push(b);
+    }
+    return hits;
 }
 /**
  * The list as it appears INSIDE an op description — always in context, on both
@@ -139,8 +206,8 @@ export function describeBannedTokens(scope) {
  * rather than raised as an error. The generation proceeds either way: the
  * sandbox doctrine says make state visible, never block.
  */
-export function bannedTokenWarning(prompt, scope) {
-    const hits = findBannedTokens(prompt, scope);
+export function bannedTokenWarning(prompt, scope, skill) {
+    const hits = findBannedTokens(prompt, scope, skill);
     if (hits.length === 0)
         return '';
     const skills = [...new Set(hits.map((b) => b.skill))].join(', ');

package/dist/prompts/character-sheet.d.ts

@@ -13,8 +13,6 @@
  * removal and must be SCOPED TO THE FACE rather than to the whole body.
  */
 export declare const CHARACTER_SHEET_PANELS_DESC: string;
-/** Panel identifiers, in sheet order. */
-export declare const BODY_POSE_LABELS: readonly ["portrait", "front", "back"];
 /**
  * The character identity sheet — one asset, three panels.
  *

package/dist/prompts/character-sheet.js

@@ -139,8 +139,6 @@ export const CHARACTER_SHEET_PANELS_DESC = 'a large chest-up portrait on the lef
     'a full-body front view in a relaxed A-pose in the centre, cropped at the collarbone — ' +
     'an invisible-mannequin presentation with just the face cropped out, ' +
     'and a full-body back view on the right with the head and hair fully visible';
-/** Panel identifiers, in sheet order. */
-export const BODY_POSE_LABELS = ['portrait', 'front', 'back'];
 // The sheet's style directive: a user transform REPLACES the inherit-source
 // instruction (so the model isn't told to both preserve the medium AND change
 // it); otherwise inherit the source medium.

package/dist/prompts/craft-cards.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Hard ceiling per card, in characters.
+ *
+ * A card is a CARD. The largest skill is 5,736 words and loading it whole is
+ * exactly the cost this mechanism exists to avoid — if a card needs more than
+ * this, the extra belongs in the body of the skill, which is one
+ * `slates_get_prompting_guide` call away. Asserted at load, so an over-long
+ * card fails the build rather than quietly inflating every estimate result.
+ */
+export declare const CRAFT_CARD_CEILING = 2400;
+/** Every card, keyed by skill name. Built once at load; integrity asserted. */
+export declare const CRAFT_CARDS: Readonly<Record<string, string>>;
+/** The card for a skill, or null when that skill carries none. */
+export declare function craftCard(skill: string): string | null;
+/**
+ * The card as it appears in an op RESULT: the body, plus one line naming where
+ * the rest lives so the agent knows the card is a summary and not the guide.
+ */
+export declare function describeCraftCard(skill: string): string;
+//# sourceMappingURL=craft-cards.d.ts.map