dsh-model-everything 0.0.0-stage → 0.2.0

package/lib/types/engine.d.ts

@@ -0,0 +1,494 @@
+export declare const ENGINE_SCHEMA_VERSION = 1;
+export type VarValue = number | boolean;
+export type GuardOp = '==' | '!=' | '<' | '<=' | '>' | '>=';
+export interface LeafGuard {
+    variable: string;
+    op: GuardOp;
+    value: VarValue;
+}
+export interface AllGuard {
+    all: GuardNode[];
+}
+export interface AnyGuard {
+    any: GuardNode[];
+}
+export interface NotGuard {
+    not: GuardNode;
+}
+export type GuardNode = LeafGuard | AllGuard | AnyGuard | NotGuard;
+export interface StateSpec {
+    id: string;
+    terminal?: boolean;
+    /** Actions fired automatically when the state is entered. They do not change state or variables; checks such as A4 Pair Symmetry treat them as implicit acquire/release events so lock/unlock hidden inside entry actions is verified. */
+    onEntry?: string[];
+    /** Actions fired automatically when the state is left. Same semantics as onEntry. */
+    onExit?: string[];
+    /** Deadline (A14): the state must be left within this many declared tick events of entering it. */
+    maxTicks?: number;
+}
+export interface UpdateSpec {
+    variable: string;
+    op: 'set' | 'inc' | 'dec';
+    value?: number;
+}
+export interface TransitionSpec {
+    from: string;
+    event: string;
+    to: string;
+    /** Absent guard is the else/default branch for the same (from, event) group. */
+    guard?: GuardNode;
+    updates?: UpdateSpec[];
+    /** Execution cost of firing this transition (e.g. cycles, microseconds). Absent cost defaults to 1, so an unannotated machine keeps step-count semantics. Checked by A12 against budget invariants. */
+    cost?: number;
+    /** Relative probability weight when a probability invariant is declared (DTMC interpretation). Absent weight = 1; weight 0 means the branch never fires probabilistically. */
+    weight?: number;
+}
+export interface TransitionScenarioSpec {
+    from: string;
+    event: string;
+    /** Natural language: what this (state, event) combination represents in the real scenario. */
+    scenario: string;
+}
+export interface ModelNarrative {
+    /** Natural-language meaning of each state id. */
+    states?: Record<string, string>;
+    /** Natural-language meaning of each event id. */
+    events?: Record<string, string>;
+    /** Natural-language scenario for each distinct (from, event) combination. */
+    scenarios?: TransitionScenarioSpec[];
+}
+export interface VariableSpec {
+    name: string;
+    kind: 'integer' | 'boolean';
+    init: number | boolean;
+    min?: number;
+    max?: number;
+    monotonic?: 'inc' | 'dec';
+}
+/**
+ * Scope filter for a state-predicate invariant (see `InvariantSpec`): the range is
+ * only required to hold in runtime states that satisfy the filter. Exactly one of
+ * `state` / guard-node form must be present.
+ */
+export interface StateGuard {
+    /** Only runtime states whose id is this state are checked. */
+    state: string;
+}
+/** A `when` filter: either a single-state scope or the ordinary guard language. */
+export type InvariantWhen = StateGuard | GuardNode;
+export declare function isStateGuard(when: InvariantWhen): when is StateGuard;
+export type InvariantSpec = {
+    id: string;
+    description: string;
+    kind: 'never-states';
+    states: string[];
+} | {
+    id: string;
+    description: string;
+    kind: 'var-in-range';
+    variable: string;
+    min?: number;
+    max?: number;
+    /**
+     * Optional scope. `when` is evaluated against the POST-state of every transition
+     * (and, for the `{ state }` form, against the initial state regardless), so a
+     * `{ state }` scope is sound: for every reachable runtime state inside the scope
+     * the variable is in range. A guard-node scope that references the constrained
+     * variable can mask its own violation — prefer `{ state }` or an independent
+     * control variable. Not offered on trace-property kinds (leads-to, sequence, ...),
+     * whose scope over a path would be ambiguous.
+     */
+    when?: InvariantWhen;
+} | {
+    id: string;
+    description: string;
+    kind: 'event-before-state';
+    event: string;
+    state: string;
+} | {
+    id: string;
+    description: string;
+    kind: 'leads-to';
+    from: string;
+    to: string | string[];
+} | {
+    id: string;
+    description: string;
+    kind: 'sequence';
+    events: string[];
+} | {
+    id: string;
+    description: string;
+    kind: 'atomicity';
+    events: string[];
+    commit: string;
+    rollback?: string;
+} | {
+    id: string;
+    description: string;
+    kind: 'budget';
+    budget: number;
+} | {
+    id: string;
+    description: string;
+    kind: 'probability';
+    target: string;
+    op: '>=' | '<=' | '>' | '<';
+    p: number;
+};
+export interface ResourcePairSpec {
+    resource: string;
+    acquireEvent: string;
+    releaseEvent: string;
+    failEvent?: string;
+}
+export interface BoundaryCheckSpec {
+    variable: string;
+    values: number[];
+}
+export interface LogicModelV1 {
+    schemaVersion: 1;
+    init: string;
+    states: StateSpec[];
+    transitions: TransitionSpec[];
+    variables?: VariableSpec[];
+    invariants?: InvariantSpec[];
+    concurrentPairs?: [string, string][];
+    boundaryChecks?: BoundaryCheckSpec[];
+    resourcePairs?: ResourcePairSpec[];
+    idempotentEvents?: string[];
+    /** Events that advance the discrete clock by one tick; used by A14 deadline checks. */
+    tickEvents?: string[];
+    /** Natural-language descriptions of states, events, and (state, event) scenarios. */
+    narrative?: ModelNarrative;
+}
+export interface VerificationOptions {
+    maxStates?: number;
+    maxPermutationEvents?: number;
+    beforeModel?: unknown;
+    stateMapping?: Record<string, string>;
+    /** Hash specification used for modelHash. Defaults to the current published spec (`v1`). */
+    hashSpec?: HashSpec;
+}
+export interface PathStep {
+    from: string;
+    event: string;
+    to: string;
+}
+export interface Finding {
+    code: string;
+    /**
+     * `info` is a note, not a defect: it is reported so a machine-readable reader can see it,
+     * and it never contributes to `verdict`, `summary.errors` or `summary.warnings`.
+     */
+    severity: 'error' | 'warning' | 'info';
+    message: string;
+    /** Longer explanation: the shortest-path note, the per-machine reasons, the quoted source lines. */
+    detail?: string;
+    /** The artefact the finding is about (a diagram name, a file path) — set when one report covers several. */
+    file?: string;
+    /** 1-based line in that artefact, when the check knows it. */
+    line?: number;
+    path?: PathStep[];
+    evidence?: Record<string, unknown>;
+}
+export interface CheckResult {
+    id: string;
+    name: string;
+    status: 'pass' | 'fail' | 'skip';
+    detail: string;
+    findings: Finding[];
+}
+export interface VerificationReport {
+    /**
+     * The engine ran and the input was well-formed enough to produce this report.
+     * It does NOT mean the review passed — read `verdict` for that.
+     */
+    ok: boolean;
+    /** The tool executed and produced a report. False only when a tool refused the request before the engine ran. */
+    ran: boolean;
+    /** The review outcome. `ok: true` with `verdict: "fail"` is a failing review, not a passing one. */
+    verdict: Verdict;
+    /** Why the verdict came out that way, e.g. `2 error finding(s) (first error: S2_NO_TRANSITIONS)`. */
+    verdictReason: string;
+    /** The versioned report contract this result follows. */
+    schema: ReportSchema;
+    schemaVersion: 1;
+    /** Which published specification `modelHash` follows (see references/hash-spec.md). */
+    hashSpec: HashSpec;
+    modelHash: string;
+    /** Every hash this report carries, in one place, for a baseline diff or an archive record. */
+    hashes: {
+        hashSpec: HashSpec;
+        modelHash: string;
+        beforeModelHash?: string;
+        afterModelHash?: string;
+    };
+    /** Paths of the `_`-prefixed metadata keys found in the input and ignored by the schema. */
+    metadataKeys?: string[];
+    /** How much of the model the narrative documents; absent when there is no narrative. */
+    narrativeCoverage?: NarrativeCoverage;
+    /** Echo of the model's natural-language narrative, when present. */
+    narrative?: ModelNarrative;
+    summary: {
+        states: number;
+        transitions: number;
+        errors: number;
+        warnings: number;
+        checksRun: number;
+        truncated?: boolean;
+        /** Bounds that were replaced or clamped because they could not bound the search. */
+        boundNotes?: string[];
+    };
+    checks: CheckResult[];
+    comparison?: ComparisonSummary;
+    /** What to do next, derived from the findings — never empty. */
+    nextSteps: string[];
+    /** Informational notes about semantic dimensions this model references (timing, preemption)
+     * that this engine does not verify. Heuristic, vocabulary-based — never a substitute for the checks. */
+    coverageNotes?: string[];
+}
+export interface ComparisonSummary {
+    beforeModelHash: string;
+    afterModelHash: string;
+    stateMapping: Record<string, string>;
+    beforeStates: number;
+    beforeTransitions: number;
+    afterStates: number;
+    afterTransitions: number;
+    addedStates: string[];
+    removedStates: string[];
+    addedEvents: string[];
+    removedEvents: string[];
+    addedTransitions: TransitionSpec[];
+    removedTransitions: TransitionSpec[];
+}
+export interface RuntimeState {
+    state: string;
+    vars: Record<string, VarValue>;
+}
+/**
+ * The hash of any model this plugin carries: the same normalization as `modelHash`,
+ * over whatever object the family defines. A use case diagram and a state machine are
+ * hashed by one rule, so a report can name either.
+ */
+export declare function valueHash(value: unknown, spec?: HashSpec): string;
+export declare function modelHash(model: LogicModelV1, spec?: HashSpec): string;
+/**
+ * Deterministic JSON (sorted keys, no insignificant whitespace) — the serialization the
+ * hash specification is defined over. Exported so every report hashes inputs the same way.
+ */
+export declare function canonicalJson(value: unknown): string;
+/**
+ * Published model-hash specifications. The full normalization rules, the list of
+ * excluded keys and a one-line recompute command are in `references/hash-spec.md`.
+ *
+ * - `v1` (1.0.0) drops every `_`-prefixed metadata key at every level before hashing,
+ *   so archiving `_source` / `_verified` next to a model cannot change its hash.
+ * - `v0` is the pre-1.0.0 behaviour (no metadata filtering), kept so an archived hash
+ *   can still be checked against the old engine.
+ *
+ * For a model that carries no `_` keys the two specs are byte-identical.
+ */
+export type HashSpec = 'v0' | 'v1';
+export declare const PUBLISHED_HASH_SPECS: readonly HashSpec[];
+export declare const DEFAULT_HASH_SPEC: HashSpec;
+/**
+ * Versioned report contracts. Every tool result carries `schema`, so a consumer can
+ * branch on the contract instead of sniffing fields, and a change to a report's shape
+ * is a version bump here rather than a silent break. `findings[]` keeps the same
+ * stable core in every family: `{code, severity, message, detail?, evidence?, path?}`.
+ */
+export declare const REPORT_SCHEMAS: {
+    readonly verify: 'model-everything/verify/v1';
+    readonly compose: 'model-everything/compose/v1';
+    readonly datamodel: 'model-everything/datamodel/v1';
+    readonly concurrency: 'model-everything/concurrency/v1';
+    readonly export: 'model-everything/export/v1';
+    readonly umlRender: 'model-everything/uml/render/v1';
+    readonly umlParse: 'model-everything/uml/parse/v1';
+    readonly umlReview: 'model-everything/uml/review/v1';
+    readonly umlExplainLabels: 'model-everything/uml/explain-labels/v1';
+    readonly umlRefusal: 'model-everything/uml/refusal/v1';
+    readonly structure: 'model-everything/structure/v1';
+    readonly granularity: 'model-everything/granularity/v1';
+    readonly design: 'model-everything/design/v1';
+    readonly baseline: 'model-everything/baseline/v1';
+};
+export type ReportSchema = typeof REPORT_SCHEMAS[keyof typeof REPORT_SCHEMAS];
+/**
+ * How much of the model the `narrative` block actually documents, as `covered/total`
+ * per dimension. A partial narrative is valid — writing the states first and the
+ * events later is the natural order — so this is a coverage report, not a gate.
+ * `scenarios` counts distinct modelled (from, event) groups: one scenario per group.
+ */
+export interface NarrativeCoverage {
+    states: string;
+    events: string;
+    scenarios: string;
+}
+export declare function narrativeCoverageOf(model: LogicModelV1): NarrativeCoverage | undefined;
+/** True when every dimension of the coverage is fully described. */
+export declare function narrativeComplete(coverage: NarrativeCoverage | undefined): boolean;
+/**
+ * The review outcome, kept separate from `ok` (= "the tool ran"). Collapsing the two
+ * is how a failed review gets read as a passing one.
+ */
+export type Verdict = 'pass' | 'pass_with_findings' | 'fail';
+export interface VerdictSummary {
+    verdict: Verdict;
+    verdictReason: string;
+}
+/** A tool that refused the request before running anything: it neither passed nor failed a review. */
+export declare function refusalVerdict(reason: string): VerdictSummary;
+/**
+ * Decide the verdict from finding counts. Any error-severity finding fails the review
+ * even though the tool ran successfully — that gap is exactly what `verdict` closes.
+ */
+export declare function verdictOf(errors: number, warnings: number, firstCode?: string): VerdictSummary;
+export declare function verdictOfFindings(findings: Array<{
+    code: string;
+    severity: string;
+}>): VerdictSummary;
+/**
+ * Paths of every `_`-prefixed key in the input, sorted (`_source`, `_verified`,
+ * `states[0]._note`; a metadata key's own children are not listed, since the subtree is
+ * metadata as a whole). The schema ignores these keys as annotation metadata; echoing
+ * them in the report makes the ignored metadata auditable instead of invisible.
+ *
+ * Iterative, with an explicit stack: this runs before validation on whatever the caller passed, so
+ * a recursive walk overflowed the stack on a deeply nested model and the `RangeError` arrived
+ * instead of any report at all. A guard nested ten thousand deep is nonsense, and it has to be
+ * refused rather than crash the walk that was going to refuse it.
+ */
+export declare function metadataKeysOf(input: unknown): string[];
+/**
+ * The exact payload a hash spec hashes. Exported so the specification has one
+ * implementation and the documentation can be checked against it.
+ */
+export declare function hashPayload(model: unknown, spec?: HashSpec): unknown;
+export declare function validateModel(input: unknown): {
+    ok: true;
+    model: LogicModelV1;
+} | {
+    ok: false;
+    errors: string[];
+};
+/**
+ * Event names in the adversarial declarations that no transition and no entry/exit action
+ * declares.
+ *
+ * The robustness audit called this the dominant defect class: a misspelled name made a check
+ * skip and then report its all-clear - "All pairs balanced", "No race conditions detected", "All
+ * deadlines respected" - for a model it never ran on. A reader cannot tell an empty check from a
+ * passing one, which is what a verifier must never do.
+ *
+ * A name that resolves to nothing is reported by the check that would have used it, not refused
+ * by validation, because for some fields the absence IS the defect: a
+ * `resourcePairs[].releaseEvent` naming a step nobody built is what `A4_NO_RELEASE_EVENT` says,
+ * and refusing it would replace a finding that names the missing step with a generic one.
+ */
+export declare function unresolvedEventNames(root: Record<string, unknown>): Array<{
+    path: string;
+    value: string;
+    check: string;
+}>;
+/**
+ * Every variable a guard names, total and iterative for the same reasons as
+ * `walkGuardReferences`.
+ */
+export declare function guardVariables(guard: GuardNode | undefined): string[];
+export declare function runVerification(input: unknown, options?: VerificationOptions): VerificationReport;
+export interface CompositionStep {
+    event: string;
+    /** Indices of the machines that advanced together on this step. */
+    machines: number[];
+}
+/** A location two machines can both touch. Without one, a composition shares nothing. */
+export interface SharedLocation {
+    id: string;
+    /** Initial value, for the reader only: the checks below decide on declarations, not on values. */
+    initial?: string | number | boolean;
+}
+/** How one machine event touches a shared location. */
+export interface SharedAccess {
+    /** Machine index, as given in the composition's `machines` array. */
+    machine: number;
+    event: string;
+    location: string;
+    /**
+     * `read-write` is a read-modify-write: the value read is written back, so two of them that
+     * are not mutually exclusive lose an update.
+     */
+    kind: 'read' | 'write' | 'read-write';
+    /**
+     * The lock both sides name when the operation is guarded. Two accesses that name the SAME
+     * lock are treated as mutually exclusive. This checks that the two sides agree on the lock,
+     * not that the lock is held across the whole operation - that is a single-machine question,
+     * and `model_verify` is the tool that can answer it.
+     */
+    protectedBy?: string;
+}
+export interface CompositionOptions {
+    /** Events that require a synchronized multi-machine step (handshake). */
+    rendezvous?: string[];
+    /** Locations both machines can touch. Declaring none means the composition shares nothing. */
+    shared?: SharedLocation[];
+    /** Which machine events touch which shared locations, and how. */
+    accesses?: SharedAccess[];
+    maxStates?: number;
+    /** Hash specification used for the per-machine modelHash. Defaults to the current published spec (`v1`). */
+    hashSpec?: HashSpec;
+}
+export interface CompositionSummary {
+    machineCount: number;
+    machines: Array<{
+        modelHash: string;
+        states: number;
+        transitions: number;
+    }>;
+    compositeStates: number;
+    errors: number;
+    warnings: number;
+    truncated: boolean;
+}
+export interface CompositionReport {
+    /**
+     * Historical meaning: the composition has no error-severity finding. Read `verdict` for the review
+     * outcome.
+     *
+     * This field does NOT mean the same thing across the report families, which is why nothing should
+     * route on it: a failing verification report carries `ok: true`, and a failing composition carries
+     * `ok: false`, for the same verdict. The robustness review of the report-reading guide measured
+     * both. `docs/report-reading/guide.md` says so, and `tests/report-reading` holds it.
+     */
+    ok: boolean;
+    ran: boolean;
+    verdict: Verdict;
+    verdictReason: string;
+    /** The versioned report contract this result follows. */
+    schema: ReportSchema;
+    /** Which published specification the per-machine `modelHash` values follow. */
+    hashSpec: HashSpec;
+    /** Every hash this report carries, in one place. */
+    hashes: {
+        hashSpec: HashSpec;
+        machines: string[];
+    };
+    summary: CompositionSummary;
+    checks: CheckResult[];
+    /** What to do next, derived from the findings — never empty. */
+    nextSteps: string[];
+}
+/**
+ * N-machine composition semantics (documented in dsh-model-schema.md):
+ * - a non-rendezvous event advances exactly ONE non-terminal machine that fires it;
+ * - a rendezvous event (handshake) fires only when AT LEAST TWO machines declare it in
+ *   their alphabet and EVERY such non-terminal machine has it enabled (guards held);
+ *   all participants then advance simultaneously. A machine that is terminal, or whose
+ *   alphabet does not include the event, does not participate;
+ * - a terminal machine is stopped and takes no further part.
+ * Checks: C1 composition deadlock (reachable node where no machine can advance while at
+ * least one is not terminal) and C2 rendezvous that can never fire.
+ */
+export declare function runCompositionVerification(machinesInput: unknown[], options?: CompositionOptions): CompositionReport;

package/lib/types/export-tool.d.ts

@@ -0,0 +1,7 @@
+export declare const EXPORT_TOOL_NAME = "model_export";
+/**
+ * DSH tool wrapping the external-tool exporters: turn a LogicModelV1 machine into
+ * native input for the tool this plugin routes to (UPPAAL / TLA+ / PRISM / SPIN).
+ * v1 translates the core machine; unrepresentable invariants become warnings.
+ */
+export declare const modelExportTool: import("@deepseek-ai/dsh-tools").ToolDefinition;

package/lib/types/exporters.d.ts

@@ -0,0 +1,37 @@
+import { type LogicModelV1 } from './engine.js';
+export type ExportFormat = 'uppaal' | 'tla' | 'prism' | 'spin';
+export interface ExportResult {
+    format: ExportFormat;
+    primary: string;
+    extras?: Record<string, string>;
+    warnings: string[];
+}
+export interface ExportedModel {
+    model: LogicModelV1;
+    stateIds: string[];
+    indexOf: Map<string, number>;
+    initId: string;
+    stateIdOf: Map<string, string>;
+}
+export declare function prepareModel(input: unknown): ExportedModel;
+/**
+ * Every format this exporter can produce, in one place.
+ *
+ * The absence of this list is what made an unknown format dangerous: the function ended with
+ * `return exportSpin(ex)`, so `'mermaid'`, `42`, `''` and `undefined` all produced Promela and
+ * reported `format: 'spin'`. A caller who named a notation this exporter cannot write received a
+ * different notation's output and a report naming a format they had not asked for.
+ */
+export declare const EXPORT_FORMATS: readonly ExportFormat[];
+export declare function isExportFormat(value: unknown): value is ExportFormat;
+/**
+ * A refusal an exporter knows by name.
+ *
+ * The tool mapped every throw onto `MODEL_INVALID`, so "this valid model is too large for the PRISM encoding" came
+ * back as "your model is invalid" - a claim about the caller's work made by a limit of the exporter.
+ */
+export declare class ExportError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+export declare function exportModel(input: unknown, format: unknown): ExportResult;

package/lib/types/gate.d.ts

@@ -0,0 +1,91 @@
+/**
+ * The gate: one optional routing message, injected once per session.
+ *
+ * Why it exists. Routing works through text: the measured result is that a session asked
+ * to check something loads the skill whose catalog line matches. What that measurement
+ * also showed is the limit - a session that never decides to load anything is never routed,
+ * and the catalog line is cut at 500 characters, so the tail of a long line is invisible at
+ * the moment of choosing. This component carries the routing in a message instead of in the
+ * line, for a deployment that wants the decision made for it.
+ *
+ * Why it is a separate row. The plugin's doctrine is that a capability is discoverable
+ * through its own tool description or skill text. Injection departs from that, so it is
+ * opt-in and mounted as its own component: install it, disable it, or never enable it,
+ * without touching the tools or the skills. `enabled` is a live switch, so the Web Plugins
+ * page flips it inside a running host.
+ *
+ * Why it is off by default. It costs tokens in every session that turns it on, to fix a
+ * problem text-only routing was measured not to have once the session engages. A deployment
+ * that wants it says so; the default pays nothing.
+ *
+ * What it does not do. It routes; it checks nothing. It cannot make a skill load, and it
+ * does not restate the doctrine - the skill bodies carry that, and duplicating them here
+ * would spend the session's context on a second copy.
+ *
+ * @module dsh-model-everything-gate
+ */
+import type { Context, Volatile } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+import type { ContextFormed } from '@deepseek-ai/dsh-llm';
+declare module '@deepseek-ai/dsh-llm' {
+    interface MessageSourceMap {
+        'plugin:dsh-model-everything-gate': {
+            kind: 'plugin:dsh-model-everything-gate';
+        } & ContextFormed;
+    }
+}
+export declare const name = "dsh-model-everything-gate";
+/**
+ * The skills this package actually ships, read from disk when the module loads.
+ *
+ * The table below advertises only these. A row for a skill that is not in the package sends the
+ * model to a name that resolves to nothing, which is the one failure a routing message must not
+ * have; a skill added without a row still gets an entry, reading "see its catalog line", so the
+ * table can be incomplete but never wrong.
+ */
+export declare function shippedSkills(): string[];
+/**
+ * The text, rendered from the skills that ship.
+ *
+ * The rule is stated at both ends, in different words. That is a measured change, not a stylistic
+ * one: with a single statement, the one case that needed the plugin - a migration question the
+ * session believed it could answer from memory - loaded no skill and ran no tool. Stated at the
+ * start and restated at the end, it did both, and a control task was not over-triggered.
+ *
+ * The shape follows a neighbouring plugin's injected section: a table that chooses between near-equals,
+ * rows only for what is installed, and a rule against degrading silently when a tool refuses.
+ *
+ * @param skills - the skills to advertise; defaults to the ones on disk.
+ * @param extraGuidance - a deployment's own sentence, appended last.
+ */
+export declare function renderGateText(skills?: string[], extraGuidance?: string): string;
+/** The shipped default: every row the package can advertise, no deployment guidance. */
+export declare const DEFAULT_GATE_TEXT: string;
+export interface Config {
+    /** Whether the gate is injected. Read through {@link injectionEnabled}. On unless a deployment says otherwise. */
+    enabled: Volatile<boolean> | boolean;
+    /** The text to inject. Override in the profile's `cordis.patch.yml` row, not in a GUI form. */
+    gateContent: string;
+    /** A deployment's own sentence, appended to whatever text is injected. */
+    extraGuidance: string;
+}
+export declare const Config: z<Schemastery.ObjectS<NoInfer<{
+    enabled: z<boolean, boolean, "defined">;
+    gateContent: z<string, string, "defined">;
+    extraGuidance: z<string, string, "defined">;
+}>>, Schemastery.ObjectT<NoInfer<{
+    enabled: z<boolean, boolean, "defined">;
+    gateContent: z<string, string, "defined">;
+    extraGuidance: z<string, string, "defined">;
+}>>, "plain">;
+/**
+ * Mount the gate.
+ *
+ * The listener is registered whether or not the switch is on: the switch is volatile, so
+ * `apply` runs once and the value behind it can turn on later from the Plugins page.
+ * Returning early here would freeze the decision for the lifetime of the mount.
+ *
+ * @param ctx - the plugin context.
+ * @param config - the resolved plugin configuration.
+ */
+export declare function apply(ctx: Context, config: Config): void;