/**
 * Shipped skills that live outside `project-files.ts` — the trailer skill because that file was at
 * the 2000-line ESLint cap when it was written, and `publishing-a-game` / `working-with-the-creator`
 * because they were carved out of AGENTS.md rather than added to it (see the length budget in
 * `__tests__/project-files.test.ts`: a fact whose failure is loud belongs in a skill, and both of
 * those were 116 lines of loud facts riding in every request's context).
 *
 * Same contract as the renderers there: each is a pure function returning the file's contents,
 * registered in `SHIPPED_SKILLS` (project.ts) so `bitmagic init` writes it and `bitmagic upgrade`
 * refreshes it — the only path by which an existing project learns about a new capability.
 * `project-files.test.ts` enforces the frontmatter (name == directory) and that AGENTS.md names
 * every shipped skill. The same template-literal rule applies: the markdown is full of backticks,
 * so every one inside is escaped as \` and the test checks the rendered output.
 *
 * One renderer here breaks the template-literal rule on purpose: `renderTrailerCraftReference`
 * reads `assets/skills/trailer-craft.md`, because that file is the SOURCE OF TRUTH for trailer
 * craft in two places at once — the skill scaffolded into a creator's project, and the monorepo's
 * own `make-trailer` skill, which symlinks to the same file. Craft is the half of trailer guidance
 * that is not about commands, so both readers need all of it and neither owns it; a second copy
 * would drift the moment either was edited, and the drift is silent (both files still look like
 * guidance). A shipped asset is the only shape that lets a symlink do the sharing.
 */
import type { SkillRenderContext } from './project-files.js';
/**
 * `.kiro/steering/bitmagic.md` — Kiro's startup instructions, and the only per-agent extra file
 * this scaffold writes besides Claude Code's.
 *
 * Kiro is the one supported agent that does not read the root `AGENTS.md` on its own: its
 * convention is `.kiro/steering/*.md`, markdown loaded into context by an `inclusion` mode declared
 * in YAML front matter that must start at byte zero (`inclusion: always` loads it into every
 * interaction, and a file with no front matter at all is treated as always). That much is
 * documented; what Kiro does with a root `AGENTS.md` is not, which is exactly why this file is a
 * POINTER and not a second copy of the guidance. A copy would be another thing to keep current, and
 * `agent-targets.ts` explains why nothing here may depend on an unverified integration point:
 * worst case, Kiro ignores this file and its creator is no worse off than before it existed.
 *
 * The two commands are repeated rather than left to AGENTS.md because they are what a cold start
 * gets wrong — an agent that has not yet opened AGENTS.md still needs `bitmagic dev` running and
 * still needs to reload when it stops.
 */
export declare function renderKiroSteering(): string;
/**
 * The one shipped skill whose text is directory-specific, and so the one that reads its render
 * context: it names the directory it is sitting in, and the sibling copies it is not.
 */
export declare function renderSkillsReadme({ skillsDir, skillDirs }: SkillRenderContext): string;
/**
 * `<skills dir>/making-a-trailer/SKILL.md` — the whole trailer flow, and the craft that makes a
 * cut watchable.
 *
 * Two kinds of knowledge live here on purpose, and they are split across two files. The FLOW
 * (record → make → look → publish) is plain command routing an agent could read off \`--help\`,
 * and it is what SKILL.md carries. The CRAFT — ordering, pacing, the five variety axes, the
 * selection rules earlier trailer reviews paid for — is not derivable from any command, and
 * without it the agent's "tuning" is random; it lives in \`references/trailer-craft.md\`
 * (\`renderTrailerCraftReference\`) because it is longer than the flow and read once per trailer
 * rather than once per command. The tuning table at the end is the part the creator actually
 * experiences: a prompt in, a shots.json edit out, one command to see it.
 */
export declare function renderTrailerSkill(): string;
/**
 * `<skills dir>/making-a-trailer/references/trailer-craft.md` — the only shipped skill file that is
 * read from disk rather than written as a template literal.
 *
 * It is a shipped asset (`assets/skills/`, listed in package.json's `files`) because two skills
 * need the same bytes: this one, and the monorepo's own `.claude/skills/make-trailer/`, whose copy
 * is a SYMLINK to the asset. Trailer craft is editing knowledge — it says nothing about the CLI, so
 * neither reader owns it and neither can be given an abridgement without going stale against the
 * other. The same reasoning as the repo's `.agents/skills -> ../.claude/skills` link: a link is not
 * a copy, so there is nothing to keep in step and no check to forget to run.
 *
 * Resolved from this module's own location the way `defaultTitleFont` resolves the bundled font:
 * `../../assets/` is the same hop from `src/scaffold/` and from `dist/scaffold/`, so it works run
 * from source and from an installed package alike.
 */
export declare function renderTrailerCraftReference(): string;
/**
 * `<skills dir>/publishing-a-game/SKILL.md` — the whole ship-it path, and every way it refuses.
 *
 * This is the largest block that came out of AGENTS.md, and it is the clearest case for the split:
 * an agent about to publish KNOWS it is publishing, and an agent staring at a non-zero exit code
 * knows it needs the table. Neither failure is silent, so neither has to ride in every request's
 * context. What stayed behind in AGENTS.md is only the part an agent cannot discover by trying:
 * the verify-then-don't-edit order, that a bare publish leaves the game private, that the QR image
 * exists, and that the project is uploaded to a public URL (a fact needed BEFORE a credential is
 * written, not when publish is run).
 */
export declare function renderPublishingSkill(): string;
/**
 * `<skills dir>/working-with-the-creator/SKILL.md` — the dev view as a two-way channel.
 *
 * The creator is not only watching: they drag gizmos into `world.json`, they paste frames from
 * their running game, and one editor action (`hq.requested`) is a job handed to the agent. Reading
 * `.bitmagic/edit/events.jsonl` is a deliberate act with a stated trigger, and the event shapes are
 * reference material — so the format table lives here, while AGENTS.md keeps only the three facts
 * an agent must hold without being asked: re-read `world.json`, a pasted image is probably live,
 * and that file may be asking you for something.
 */
export declare function renderCreatorCollaborationSkill(): string;