@cerebriline/core 4.100.240

package/dist/extensions/complexity/walker.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Cognitive complexity, SonarSource-style, over a tree-sitter parse.
+ *
+ * What it answers is "how hard is this code to follow", and the bound has to
+ * be said out loud wherever the number is: **it measures how hard code is to
+ * read, not how likely a model is to fix it.** It belongs in an escalation
+ * brief as context for the expert, and in the assessment as a tiebreaker. It
+ * is not evidence that escalation is warranted, and nothing here lets it act
+ * as one.
+ *
+ * Not cyclomatic complexity, which counts paths and rates a flat twenty-case
+ * switch as harder than three levels of nested conditionals. Cognitive
+ * complexity charges nesting, which is the thing that actually makes a
+ * minified `forEach(d=>{if(d){...}})` expensive to reason about.
+ *
+ * The node-type sets below are shared across grammars rather than written per
+ * language. Tree-sitter's naming is conventional enough that `if_statement`,
+ * `while_statement` and `catch_clause` mean the same thing in a dozen
+ * grammars, and a type this does not recognise scores nothing -- which is the
+ * safe direction for a number that is only ever a tiebreaker.
+ */
+import { type ParsedTree } from "./grammars";
+/**
+ * The scale, because an unbounded integer on its own says nothing.
+ *
+ * "This function scores 474" is not information. The reader's first question
+ * is *out of what*, and there is no out-of-what: the metric is a sum with no
+ * ceiling. A model handed a bare number has to score several functions itself,
+ * infer a distribution, and guess where the number sits in it -- so what it
+ * actually does is ignore the number. The bands are how the scale travels with
+ * the score instead of being left for the reader to reconstruct.
+ *
+ * The boundaries are anchored on the one published figure and then checked
+ * against measurement. SonarSource flags a **function** at 15; scoring 5,695
+ * functions across TypeScript, C, C++ and a minified HTML game puts that at
+ * the worst 6.8%, which is an independent vindication of their number rather
+ * than a coincidence worth ignoring. The rest of the ladder is the same
+ * distribution:
+ *
+ * ```
+ * p25  0     >=  5  21.6%   moderate
+ * p50  1     >= 15   6.8%   high        <- SonarSource's flag point
+ * p75  4     >= 25   3.2%   very high
+ * p90 10     >= 60   0.7%   extreme
+ * p95 18
+ * p99 50     max 452
+ * ```
+ */
+export type ComplexityBand = "simple" | "moderate" | "high" | "very high" | "extreme";
+export declare function bandFor(score: number): ComplexityBand;
+/**
+ * The ladder, written out, so the number is readable without a second lookup.
+ *
+ * Said in full every time on purpose. The alternative is a bare score plus an
+ * expectation that whoever reads it remembers a scale from somewhere else,
+ * and nothing downstream of here has a somewhere else.
+ */
+export declare const COMPLEXITY_SCALE = "0-4 simple, 5-14 moderate, 15-24 high, 25-59 very high, 60+ extreme; 15 is where SonarSource flags a function, and across 5,695 functions of real code 15+ is the worst 6.8% and 60+ the worst 0.7%";
+/**
+ * Where a file starts being worth raising unprompted.
+ *
+ * The worst function in it reaching `extreme`. Measured over 380 files of
+ * TypeScript, C and C++, that is 6.3% of them -- rare enough that saying
+ * something means something, common enough to fire on real code.
+ */
+export declare function isHighComplexity(score: ComplexityScore | undefined): boolean;
+export interface ComplexityScore {
+    /** The cognitive-complexity total for the span that was walked. */
+    score: number;
+    /** First and last line of that span, one-based. */
+    startLine: number;
+    endLine: number;
+    /** The function's name where the grammar names it, for the reader. */
+    name?: string;
+}
+/** Score a parsed tree, optionally narrowed to the function around one line. */
+export declare function scoreTree(tree: ParsedTree, options?: {
+    line?: number;
+}): ComplexityScore | undefined;
+/**
+ * How hard the code around a line is to follow, or nothing.
+ *
+ * Nothing means "not measured" and must never be read as "simple": a language
+ * with no grammar, a runtime that cannot load wasm, a file that will not parse.
+ * Every one of those is silence, not a low score.
+ */
+export declare function scoreComplexity(filePath: string, source: string, options?: {
+    line?: number;
+    grammarDir?: string;
+}): Promise<ComplexityScore | undefined>;
+/**
+ * Whether the file still parses, or nothing where that cannot be told.
+ *
+ * The same grammar and the same `MAX_ERROR_COVERAGE` the score uses, asked as
+ * a yes/no. It exists because "your last three edits were refused" and "the
+ * file you are editing no longer parses" are different facts and a model
+ * needs both: the first says the edits are not landing, the second says the
+ * ones that did land broke something. Nothing here counts errors -- the number
+ * of ERROR nodes a grammar produces is an artefact of its recovery strategy,
+ * not a count of the mistakes in the file -- so the answer is only ever
+ * whether the file is wholesale broken.
+ *
+ * `undefined` means not measured: no grammar, no wasm, nothing to say. It must
+ * never be read as "fine".
+ */
+export declare function fileParses(filePath: string, source: string, options?: {
+    grammarDir?: string;
+}): Promise<boolean | undefined>;
+/**
+ * The one sentence that must travel with the number.
+ *
+ * `check_file` states its own bound the same way, and for the same reason: a
+ * measurement handed over without it gets used as the thing it is not.
+ */
+export declare function describeComplexity(score: ComplexityScore, filePath: string): string;

package/dist/extensions/config/builtin-templates.d.ts

@@ -0,0 +1,10 @@
+import type { PromptTemplate } from "@cerebriline/shared";
+export declare function getBuiltinPromptTemplates(): PromptTemplate[];
+/**
+ * The markdown behind a builtin, by file name.
+ *
+ * A builtin has no path on disk, so "edit this template" has to write a copy
+ * somewhere first. This is what gets copied — the file verbatim, comments and
+ * all, so the copy reads like the original and diffs against it cleanly.
+ */
+export declare function getBuiltinPromptTemplateSource(fileName: string): string | undefined;

package/dist/extensions/config/builtin-templates.generated.d.ts

@@ -0,0 +1,5 @@
+export interface BuiltinPromptTemplateFile {
+    fileName: string;
+    raw: string;
+}
+export declare const BUILTIN_PROMPT_TEMPLATE_FILES: readonly BuiltinPromptTemplateFile[];

package/dist/extensions/config/index.d.ts

@@ -0,0 +1,15 @@
+export { getBuiltinPromptTemplateSource, getBuiltinPromptTemplates, } from "./builtin-templates";
+export { auditCompactionSections, BUILTIN_COMPACTION_PROMPTS, buildCompactionTranslationRequest, type CompactionPromptSources, resolveCompactionPromptSources, stripCompactionSections, } from "./prompt-template-compaction";
+export { createPromptTemplateHooks, type PromptTemplateHooksOptions, } from "./prompt-template-hooks";
+export { loadPromptTemplates, loadPromptTemplatesFromDirectory, PROMPT_TEMPLATES_DIRECTORY_NAME, type PromptTemplateDirectory, type PromptTemplateFileWarnings, type PromptTemplateLoadError, type PromptTemplateLoadResult, resolvePromptTemplateDirectories, } from "./prompt-template-loader";
+export { type PromptTemplateParseInput, type PromptTemplateParseResult, parsePromptTemplate, } from "./prompt-template-parser";
+export { type AuditPromptTemplateProposalArgs, auditPromptTemplateProposal, DEFAULT_REQUIRED_REWRITES, type GeneratePromptTemplateArgs, type GeneratePromptTemplateResult, generatePromptTemplate, type PromptTemplateProposalAudit, summarizeToolCallSignatures, type ToolCallSignature, } from "./prompt-template-review";
+export { describeResolvedPromptTemplate, resolveSessionPromptTemplateFrom, type SessionPromptTemplateRequest, type SessionPromptTemplateResult, } from "./prompt-template-session";
+export type { AvailableRuntimeCommand, ResolveRuntimeSlashCommandOptions, RuntimeCommandKind, } from "./runtime-commands";
+export { getShippedToolCallSignatures, HOST_TOOL_INPUT_SCHEMAS, } from "./shipped-tool-signatures";
+export type { UnifiedConfigDefinition, UnifiedConfigFileCandidate, UnifiedConfigFileContext, UnifiedConfigRecord, UnifiedConfigWatcherEvent, UnifiedConfigWatcherOptions, } from "./unified-config-file-watcher";
+export { UnifiedConfigFileWatcher } from "./unified-config-file-watcher";
+export type { CreateInstructionWatcherOptions, CreateRulesConfigDefinitionOptions, CreateSkillsConfigDefinitionOptions, CreateWorkflowsConfigDefinitionOptions, ParseMarkdownFrontmatterResult, RuleConfig, SkillConfig, UserInstructionConfig, UserInstructionConfigType, WorkflowConfig, } from "./user-instruction-config-loader";
+export { createRulesConfigDefinition, createSkillsConfigDefinition, createWorkflowsConfigDefinition, parseRuleConfigFromMarkdown, parseSkillConfigFromMarkdown, parseWorkflowConfigFromMarkdown, RULES_CONFIG_DIRECTORY_NAME, resolveRulesConfigSearchPaths, resolveSkillsConfigSearchPaths, resolveWorkflowsConfigSearchPaths, SKILLS_CONFIG_DIRECTORY_NAME, WORKFLOWS_CONFIG_DIRECTORY_NAME, } from "./user-instruction-config-loader";
+export type { CreateUserInstructionConfigServiceOptions, UserInstructionConfigRecord, UserInstructionConfigService, } from "./user-instruction-service";
+export { combineUserInstructionConfigServices, createUserInstructionConfigService, } from "./user-instruction-service";

package/dist/extensions/config/prompt-template-compaction.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Compaction prompts inside a generated template: what is asked for, what is
+ * checked, and what is thrown away when it fails the check.
+ *
+ * A tool description that reads badly costs a turn. A compaction prompt that
+ * reads badly costs the session: its output replaces the transcript, and
+ * nothing it drops can be recovered or checked against anything afterwards.
+ * So translating them is opt-in, and the audit is stricter than it is for a
+ * tool section in one respect -- a section that still fails after the repair
+ * rounds is REMOVED from the file rather than kept as "the best attempt". A
+ * removed section falls back to the built-in prompt, which is the safe answer;
+ * a kept broken one is not.
+ *
+ * What survives is still only a proposal: the generated file is the user's to
+ * review, edit, or strip before it is ever used.
+ */
+import { type PromptTemplateCompactionId, type PromptTemplateCompactionPrompts } from "@cerebriline/shared";
+/** The source text for each compaction id: what is used when nothing overrides it. */
+export declare const BUILTIN_COMPACTION_PROMPTS: Readonly<Record<PromptTemplateCompactionId, string>>;
+/** Which prompts to translate, and the text to translate from. */
+export type CompactionPromptSources = Readonly<Partial<Record<PromptTemplateCompactionId, string>>>;
+/**
+ * The sources for every compaction id: the user's own prompt where they set
+ * one, the built-in one otherwise. A custom prompt is what that user's session
+ * actually sends, so it is the one worth translating.
+ */
+export declare function resolveCompactionPromptSources(custom?: CompactionPromptSources): Record<PromptTemplateCompactionId, string>;
+/**
+ * A translation shorter than this share of its source is read as a collapse.
+ *
+ * These prompts are long on purpose: each paragraph is a rule a summary was
+ * observed to break without it. A rewrite at half the length has dropped
+ * rules, however well it reads.
+ */
+export declare const MIN_COMPACTION_LENGTH_RATIO = 0.5;
+/** The part of the generator's request that asks for the compaction sections. */
+export declare function buildCompactionTranslationRequest(sources: CompactionPromptSources): string;
+export interface CompactionSectionAudit {
+    problems: string[];
+    /** Ids whose section must not be kept as written. */
+    failing: Set<string>;
+    /**
+     * Ids whose section is the source copied through, exactly or nearly
+     * (`NEAR_COPY_SIMILARITY`). Not a failure -- the
+     * request allows it -- but not kept either: a copy is a snapshot, and the
+     * next edit to the built-in prompt would reach every model except this one.
+     * Leaving the section out is what "use the built-in" means.
+     */
+    unchanged: Set<string>;
+}
+/**
+ * A rewrite at least this similar to its source, by words, is a copy.
+ *
+ * Measured 2026-09-23 at temperature 0.7: qwen3.5:397b's "rewrite" of the
+ * reviewer prompt changed one word, "being deleted" to "being deleting", and
+ * glm-5.3-flash's full prompt moved one sentence up a paragraph. Both passed
+ * as translations because only an exact copy counted as unchanged -- and a
+ * near-copy is worse than an exact one: the same frozen snapshot, plus
+ * whatever the model broke. glm's real restructure of the replay prompt sat
+ * well below this.
+ */
+export declare const NEAR_COPY_SIMILARITY = 0.98;
+/**
+ * The same sentences in another order. glm-5.3-flash's "rewrite" of the full
+ * prompt was exactly this: one block moved up a paragraph, 0.95 by words,
+ * because a word LCS charges a move its whole length.
+ */
+export declare function isReordering(a: string, b: string): boolean;
+/**
+ * Word-level similarity, 2·LCS / (|a| + |b|): 1 for identical text, 0 for
+ * nothing in common. Order counts, so a moved sentence costs its length.
+ */
+export declare function wordSimilarity(a: string, b: string): number;
+/**
+ * Check the compaction sections a proposal carries against what was asked for.
+ *
+ * Every failing id is reported by name, so the repair round can fix it and
+ * the final strip can remove exactly those.
+ */
+export declare function auditCompactionSections(compaction: PromptTemplateCompactionPrompts | undefined, sources: CompactionPromptSources): CompactionSectionAudit;
+/**
+ * The compaction ids a list of audit problems names, from the parser's
+ * validation warnings (`In 'compaction: <id>': ...`).
+ */
+export declare function compactionIdsWithWarnings(problems: readonly string[]): string[];
+/**
+ * Remove the named `# compaction:` sections from a template file.
+ *
+ * Line-based on the same headings the parser reads, so a section's body runs
+ * to the next section heading and nothing else in the file moves.
+ */
+export declare function stripCompactionSections(raw: string, ids: ReadonlySet<string>): string;

package/dist/extensions/config/prompt-template-delta.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Regenerate individual `# tool:` sections instead of a whole template.
+ *
+ * Adding one tool used to mean a full-file rewrite of all ten shipped
+ * templates: ten model calls, ten files where every section could drift, and a
+ * diff in which the one section anyone wanted to read was buried. The cost is
+ * not the model time — it is that a full rewrite puts every *other* section at
+ * risk to add one, so a routine addition becomes a review of thirty sections
+ * per file.
+ *
+ * So the unit of work here is the section. The model is asked for the named
+ * sections and nothing else, and the result is spliced into the file it came
+ * from: every byte outside those sections is carried through unchanged, which
+ * a diff then proves.
+ *
+ * The audit is deliberately NOT relaxed to match. A delta is spliced first and
+ * audited second, as a complete file — so "every tool has a section" and every
+ * other whole-file guarantee still has to hold at the end. A partial answer is
+ * a smaller thing to ask for, not a smaller thing to check.
+ */
+export interface TemplateSection {
+    /** The heading line verbatim, or "" for the frontmatter and preamble. */
+    heading: string;
+    /** The tool this section is for, when the heading names one. */
+    name?: string;
+    /** Everything under the heading, trailing whitespace trimmed. */
+    body: string;
+    /**
+     * Newlines between the end of this section's text and the next heading.
+     *
+     * Not always 2. `kimi-k3.md` runs `{{DEFAULT}}` straight into the next
+     * `# tool:` heading with no blank line between them, in two places. Writing
+     * a uniform blank line back would edit two lines of a file nobody asked to
+     * touch — which is exactly the churn a section rewrite exists to avoid, so
+     * the separator is carried through rather than assumed.
+     */
+    gapAfter?: number;
+}
+/**
+ * Split a template into its sections, preserving order and everything else.
+ *
+ * The template parser gives back the sections' *text* but not the order they
+ * were written in, nor the frontmatter, nor a heading it does not recognise.
+ * All three have to survive a splice, so this walks the lines instead. The
+ * preamble — frontmatter plus any note above the first heading — comes back as
+ * a single leading section with an empty heading.
+ */
+export declare function splitTemplateSections(raw: string): TemplateSection[];
+/** Reassemble what {@link splitTemplateSections} produced. */
+export declare function joinTemplateSections(sections: readonly TemplateSection[]): string;
+export interface SpliceToolSectionsResult {
+    /** The whole file, with only the named sections changed. */
+    template: string;
+    /** Sections that existed and were rewritten. */
+    replaced: string[];
+    /** Sections that did not exist and were appended. */
+    added: string[];
+    /** Names asked for that the reply never supplied. */
+    missing: string[];
+}
+/**
+ * Put `sections` into `base`, changing nothing else.
+ *
+ * A tool the file already covers is rewritten in place, so its position in the
+ * file — which is editorial, and which a reader relies on — does not move. A
+ * tool it does not cover is appended, because there is no defensible place to
+ * guess and the end is at least predictable.
+ */
+export declare function spliceToolSections(base: string, sections: ReadonlyMap<string, string>): SpliceToolSectionsResult;
+/**
+ * Pull `# tool:` sections out of a reply that is not a whole template.
+ *
+ * A delta reply has no frontmatter and no `# system`, so it cannot go through
+ * the template parser — that would reject it for the very thing that makes it
+ * a delta. Anything the model wrote above the first heading is dropped, which
+ * is where a model puts "Here are the sections you asked for".
+ *
+ * `known` is the guard against a model inventing a tool: a section naming
+ * something that is not a real tool is reported rather than spliced, because
+ * splicing it would put a tool that does not exist into a shipped template.
+ */
+export declare function parseToolSectionsFromReply(reply: string, known: readonly string[]): {
+    sections: Map<string, string>;
+    unknown: string[];
+};
+export interface ToolSectionDeltaPromptArgs {
+    /** The file being amended, shown so the rewrite matches its voice. */
+    familyTemplate: string;
+    /** `default.md`'s section for each tool: the text being rewritten. */
+    defaultSections: ReadonlyMap<string, string>;
+    /** The tools to write sections for. */
+    tools: readonly string[];
+    /** Real call shapes for those tools, rendered into the prompt. */
+    signatureText?: string;
+    modelId: string;
+    family?: string;
+}
+/**
+ * Ask for only the named sections.
+ *
+ * The instruction is blunt about the output shape because the failure that
+ * matters is a model helpfully returning the whole template: that is not a
+ * delta, and splicing it would silently revert every hand-made change in the
+ * file. Asking twice — once in the rules, once in the closing line — is cheap
+ * next to that.
+ */
+export declare function buildToolSectionDeltaPrompt(args: ToolSectionDeltaPromptArgs): string;

package/dist/extensions/config/prompt-template-hooks.d.ts

@@ -0,0 +1,47 @@
+import type { AgentHooks, RenderedPromptTemplate } from "@cerebriline/shared";
+/**
+ * Put a session's rendered template on every model request.
+ *
+ * Two things are deliberately *not* happening here. Nothing is resolved: which
+ * template governs this session, and how it layers over `default.md`, was
+ * settled once by `renderPromptTemplate` when the session started, and this
+ * hook only carries the answer. And nothing is recomputed per request: the
+ * rewritten tool list is memoised against the list it was built from, so a
+ * fifty-turn conversation does the work once.
+ *
+ * `beforeModel` is still the seam, because it is the only one that sees every
+ * tool. Builtin tools are constructed in core, MCP tools arrive from a hub and
+ * the VS Code host injects its own; there is no single construction site to
+ * patch, but they all converge on `request.tools`.
+ */
+export interface PromptTemplateHooksOptions {
+    /** The session's rendered template, from `renderPromptTemplate`. */
+    rendered: RenderedPromptTemplate | undefined;
+    /**
+     * What this host is called — the same string the system prompt puts after
+     * `IDE:`, so `{{IDE_NAME}}` means one thing across the whole prompt.
+     *
+     * A host that omits it gets `the editor` in the descriptions that use the
+     * token. That is a wording default, not a behavioural one, which is why it
+     * is not required.
+     */
+    ideName?: string;
+    /**
+     * Where the rewrite is reported, once.
+     *
+     * The resolution line -- `[PromptTemplates] <model> (<family>) -> qwen over
+     * default` -- says which template won. It does not say whether the
+     * descriptions reached the request, and those are two different failures.
+     * This hook has to be merged into the host's config, and merging it wrongly
+     * dropped it before: silently, and completely under `--yolo`, where the
+     * runtime layer was `undefined` and the assignment erased everything. A
+     * session whose tools kept their built-in text looks identical from the
+     * outside to one where the template applied -- same log line, same prompt,
+     * different tools.
+     *
+     * So this names what actually went onto the request. A host that omits it
+     * loses the report, not the rewrite.
+     */
+    log?: (message: string) => void;
+}
+export declare function createPromptTemplateHooks(options: PromptTemplateHooksOptions): AgentHooks | undefined;

package/dist/extensions/config/prompt-template-loader.d.ts

@@ -0,0 +1,79 @@
+import type { PromptTemplate, PromptTemplateSource, PromptTemplateWarning } from "@cerebriline/shared";
+/**
+ * Load prompt templates from the three places they can live.
+ *
+ * Builtin templates ship with the package and are always present. A global
+ * directory holds the user's own, which is where most of them belong — a Qwen
+ * template is about Qwen, not about one repository. A workspace directory
+ * holds the ones a project wants to pin and commit, and those shadow the
+ * global templates of the same name.
+ *
+ * A file that fails to parse is reported and skipped, never thrown: one stray
+ * colon in one template must not stop a session from starting, and the
+ * settings UI needs the message to show which file is broken.
+ */
+/**
+ * Directory name for both the global and the workspace template stores —
+ * `<cline data dir>/templates` and `<workspace>/.clinerules/templates`. The
+ * host joins it onto the root it knows.
+ */
+export declare const PROMPT_TEMPLATES_DIRECTORY_NAME = "templates";
+export interface PromptTemplateLoadError {
+    filePath: string;
+    fileName: string;
+    source: PromptTemplateSource;
+    message: string;
+}
+/**
+ * A non-fatal problem in a template that loaded anyway.
+ *
+ * Carried per file rather than folded into one list, because the only useful
+ * thing to do with a warning is show it next to the file it came from and
+ * offer to open it.
+ */
+export interface PromptTemplateFileWarnings {
+    filePath: string;
+    fileName: string;
+    source: PromptTemplateSource;
+    warnings: PromptTemplateWarning[];
+}
+export interface PromptTemplateLoadResult {
+    templates: PromptTemplate[];
+    errors: PromptTemplateLoadError[];
+    warnings: PromptTemplateFileWarnings[];
+}
+export interface PromptTemplateDirectory {
+    path: string;
+    source: PromptTemplateSource;
+}
+/**
+ * Read one directory of `*.md` templates.
+ *
+ * A directory that does not exist is not an error — most users will never
+ * create one, and the builtin templates are enough on their own.
+ */
+export declare function loadPromptTemplatesFromDirectory(directory: PromptTemplateDirectory, options?: {
+    knownToolNames?: readonly string[];
+}): PromptTemplateLoadResult;
+/**
+ * Read every directory, nearest source last.
+ *
+ * Order matters downstream: `shadowPromptTemplates` keeps the last template of
+ * a given name, and `resolvePromptTemplate` breaks specificity ties towards the
+ * nearer source. Both agree that workspace beats global beats builtin, so the
+ * directories are read in that order and the list is left in it.
+ */
+export declare function loadPromptTemplates(directories: readonly PromptTemplateDirectory[], options?: {
+    knownToolNames?: readonly string[];
+}): PromptTemplateLoadResult;
+/**
+ * The directories a session reads, in the order it reads them.
+ *
+ * `builtinDir` is resolved by the host, because where the package's own assets
+ * land depends on how it was bundled, and core should not guess.
+ */
+export declare function resolvePromptTemplateDirectories(options: {
+    builtinDir?: string;
+    globalDir?: string;
+    workspaceDir?: string;
+}): PromptTemplateDirectory[];

package/dist/extensions/config/prompt-template-parser.d.ts

@@ -0,0 +1,56 @@
+import { type PromptTemplate, type PromptTemplateSource, type PromptTemplateWarning } from "@cerebriline/shared";
+/**
+ * Parser for the prompt template files under `~/.cline/templates/` and
+ * `<workspace>/.clinerules/templates/`.
+ *
+ * The format is deliberately the same shape as the cron specs and skills next
+ * to it — YAML frontmatter, markdown body — because it is edited by hand in
+ * the editor, and one more bespoke syntax is one more thing to get wrong at
+ * two in the morning.
+ *
+ * ```markdown
+ * ---
+ * name: gemma
+ * match:
+ *   family: [gemma*]
+ * ---
+ *
+ * # system
+ * You are Cline...
+ *
+ * # tool: editor
+ * Write a file. Use this instead of shell redirection...
+ * ```
+ *
+ * Like the cron parser, this never throws for a bad file: it returns an error
+ * string so the loader can show which template is broken and carry on with the
+ * others, rather than a session failing to start because of a stray colon.
+ */
+export interface PromptTemplateParseInput {
+    raw: string;
+    source: PromptTemplateSource;
+    /** Used for the template name when the frontmatter omits one. */
+    fileName: string;
+    filePath?: string;
+    /**
+     * Tool names this session has, so a section naming something else can be
+     * reported. Omitted by callers that only want to read the file.
+     */
+    knownToolNames?: readonly string[];
+}
+export type PromptTemplateParseResult = {
+    template: PromptTemplate;
+    error?: undefined;
+    /**
+     * Non-fatal problems: a mistyped placeholder, a missing one, a
+     * section for a tool that does not exist. The template still loads —
+     * these are things a person editing it needs told, not reasons to
+     * refuse the file.
+     */
+    warnings: PromptTemplateWarning[];
+} | {
+    template?: undefined;
+    error: string;
+    warnings?: undefined;
+};
+export declare function parsePromptTemplate(input: PromptTemplateParseInput): PromptTemplateParseResult;