@pugi/cli 0.1.0-beta.7 → 0.1.0-beta.87

package/dist/core/engine/context-prefix.js

@@ -0,0 +1,155 @@
+/** Hard cap on the rendered `<context>` block, bytes. */
+export const CONTEXT_PREFIX_MAX_BYTES = 5 * 1024;
+/** Hard cap on working-set entries surfaced in the prefix. */
+export const CONTEXT_PREFIX_MAX_WORKING_SET = 50;
+/** Hard cap on per-dir markdown files surfaced inline. */
+export const CONTEXT_PREFIX_MAX_MARKDOWN = 3;
+/** Per-markdown-file inline excerpt cap, bytes. Keeps any one file from dominating. */
+export const CONTEXT_PREFIX_MAX_PER_MARKDOWN_BYTES = 1024;
+/**
+ * Build the `<context>` block. Always returns a result — when there
+ * is nothing to surface (no cwd hint, no working set, no per-dir
+ * files), returns `{ block: '', bytes: 0, truncated: false, counts: ... }`
+ * so the caller can short-circuit the splice cleanly.
+ *
+ * Determinism: same input always produces byte-identical output. The
+ * working-set order comes from the caller's summary; we preserve it
+ * verbatim. Per-dir files are sorted by `distanceFromCwd` ascending
+ * (closest first) so two equal `TraversedMarkdown` arrays produce
+ * identical blocks.
+ */
+export function buildContextPrefix(input) {
+    const lines = [];
+    let bytes = 0;
+    let truncated = false;
+    // Walk a write-then-measure loop so we never overflow the byte cap.
+    // Each push checks budget; when full, set `truncated = true` and
+    // stop. The opener / closer tags always fit (small) — we reserve
+    // their byte cost up-front from the budget.
+    const opener = '<context>';
+    const closer = '</context>';
+    const reservedTagBytes = Buffer.byteLength(opener, 'utf8') + 1 + Buffer.byteLength(closer, 'utf8') + 1;
+    let budget = CONTEXT_PREFIX_MAX_BYTES - reservedTagBytes;
+    if (budget < 0) {
+        return {
+            block: '',
+            bytes: 0,
+            truncated: false,
+            counts: {
+                workingSetIncluded: 0,
+                workingSetTotal: input.workingSet?.length ?? 0,
+                markdownIncluded: 0,
+                markdownTotal: input.traversedMarkdown?.length ?? 0,
+            },
+        };
+    }
+    const pushLine = (line) => {
+        const lineBytes = Buffer.byteLength(line, 'utf8') + 1; // newline
+        if (lineBytes > budget) {
+            truncated = true;
+            return false;
+        }
+        lines.push(line);
+        budget -= lineBytes;
+        bytes += lineBytes;
+        return true;
+    };
+    // cwd — always cheap, always first.
+    pushLine(`cwd: ${input.cwdRelative || '.'}`);
+    // intent hint, if provided.
+    if (input.intentHint) {
+        pushLine(`intent: ${input.intentHint}`);
+    }
+    // Working set — render `open-files:` only when there is at least one entry.
+    const wsTotal = input.workingSet?.length ?? 0;
+    let wsIncluded = 0;
+    if (wsTotal > 0 && input.workingSet) {
+        const wsCap = Math.min(CONTEXT_PREFIX_MAX_WORKING_SET, wsTotal);
+        pushLine('open-files:');
+        for (let i = 0; i < wsCap; i += 1) {
+            const entry = input.workingSet[i];
+            if (!entry)
+                continue;
+            const ok = pushLine(` - ${entry.absPath}`);
+            if (!ok)
+                break;
+            wsIncluded += 1;
+        }
+        if (wsTotal > wsCap) {
+            pushLine(` ... (+${wsTotal - wsCap} more)`);
+            truncated = truncated || true;
+        }
+    }
+    // Per-dir markdown — closest-first, max 3, each capped to 1 KB excerpt.
+    const mdTotal = input.traversedMarkdown?.length ?? 0;
+    let mdIncluded = 0;
+    if (mdTotal > 0 && input.traversedMarkdown) {
+        const sorted = [...input.traversedMarkdown].sort((a, b) => a.distanceFromCwd - b.distanceFromCwd);
+        const top = sorted.slice(0, CONTEXT_PREFIX_MAX_MARKDOWN);
+        if (top.length > 0) {
+            pushLine('per-dir-conventions:');
+            for (const md of top) {
+                // Header line names the source file for traceability.
+                const header = ` [${md.resolvedPath}]`;
+                if (!pushLine(header))
+                    break;
+                // Excerpt: cap to 1 KB, single-line collapse (replace newlines
+                // with " | " so the YAML-ish block stays parseable by humans).
+                const excerpt = excerpt1KB(md.content);
+                // Indent two spaces so it nests under the file header.
+                const indented = excerpt.split('\n').map((l) => `   ${l}`).join('\n');
+                if (!pushLine(indented))
+                    break;
+                mdIncluded += 1;
+            }
+            if (mdTotal > top.length) {
+                pushLine(` ... (+${mdTotal - top.length} more files; closest-3 shown)`);
+                truncated = truncated || true;
+            }
+        }
+    }
+    if (lines.length === 0) {
+        return {
+            block: '',
+            bytes: 0,
+            truncated: false,
+            counts: {
+                workingSetIncluded: 0,
+                workingSetTotal: wsTotal,
+                markdownIncluded: 0,
+                markdownTotal: mdTotal,
+            },
+        };
+    }
+    const block = [opener, ...lines, closer].join('\n');
+    const totalBytes = Buffer.byteLength(block, 'utf8');
+    return {
+        block,
+        bytes: totalBytes,
+        truncated,
+        counts: {
+            workingSetIncluded: wsIncluded,
+            workingSetTotal: wsTotal,
+            markdownIncluded: mdIncluded,
+            markdownTotal: mdTotal,
+        },
+    };
+}
+/**
+ * Splice a built context block onto the front of a user message.
+ * Empty block → message returned verbatim (no leading blank line, no
+ * empty `<context>` tag).
+ */
+export function spliceContextPrefix(block, userMessage) {
+    if (block.length === 0)
+        return userMessage;
+    return `${block}\n\n${userMessage}`;
+}
+function excerpt1KB(content) {
+    const capped = content.length <= CONTEXT_PREFIX_MAX_PER_MARKDOWN_BYTES
+        ? content
+        : content.slice(0, CONTEXT_PREFIX_MAX_PER_MARKDOWN_BYTES);
+    // Trim trailing newlines so the YAML-ish render stays tight.
+    return capped.replace(/\s+$/g, '');
+}
+//# sourceMappingURL=context-prefix.js.map

package/dist/core/engine/index.js

@@ -5,7 +5,7 @@ export * from './noop.js';
 export * from './prompts.js';
 export * from './tool-bridge.js';
 // Subagent dispatch helper. Engine adapter code calls this from a
-// future `task_dispatch` tool (alpha-5.7 REPL); the re-export keeps the
+// future `task_dispatch` tool ; the re-export keeps the
 // import path stable so adapter code does not have to reach into the
 // subagents submodule.
 export { spawnSubagent } from '../subagents/spawn.js';

package/dist/core/engine/intensity.js

@@ -0,0 +1,158 @@
+/**
+ * Intensity dial — single knob that derives max_turns, token budget,
+ * model tag, and parallel-agent posture for `pugi code/fix/build/plan/explain`.
+ *
+ * Spec: Pugi backlog. Pattern lifted from Karpathy's nanochat
+ * `--depth` flag — one dial that captures "how much do you want me to
+ * spend on this turn?" so operators do not have to tune four separate
+ * knobs in lockstep.
+ *
+ * Four discrete levels were chosen over a free-form integer:
+ *
+ *  - operators have a mental model for "quick / standard / deep / marathon"
+ *  - discrete tiers let us tune model + parallel-agent posture per tier
+ *    without exposing a continuous knob that has no meaning above 200 turns
+ *  - keeps env override (`PUGI_INTENSITY`) trivially parseable
+ *
+ * Defaults are conservative — the operator can always override any
+ * individual knob via the per-command flag (`--max-turns`, `--max-tokens`,
+ * `PUGI_ENGINE_MODEL_<COMMAND>`) and the explicit flag wins.
+ *
+ *  | level   | max_turns | budget tokens | model   | parallel agents |
+ *  |----------|-----------|---------------|----------|------------------|
+ *  | quick   |        3 |       30 000 | haiku   | off             |
+ *  | standard |       15 |       80 000 | sonnet  | off             |
+ *  | deep    |       50 |      200 000 | sonnet  | up to 3         |
+ *  | marathon |      200 |      800 000 | opus    | up to 3         |
+ *
+ * Model tags are abstract (`light`/`standard`/`heavy`). The CLI maps
+ * each tag to a concrete model slug via env override
+ * (`PUGI_INTENSITY_MODEL_<TAG>`) OR falls back to the per-persona default
+ * resolved by the admin-api runtime. We do NOT hard-code Anthropic /
+ * OpenAI slugs here — those move per provider release and would couple
+ * the CLI to the runtime's routing table. Operators pin a concrete model
+ * via `PUGI_ENGINE_MODEL_<COMMAND>` when they need exact control.
+ */
+export const INTENSITY_LEVELS = [
+    'quick',
+    'standard',
+    'deep',
+    'marathon',
+];
+export const DEFAULT_INTENSITY = 'standard';
+const PROFILES = {
+    quick: {
+        level: 'quick',
+        maxTurns: 3,
+        budgetTokens: 30_000,
+        modelTag: 'light',
+        allowParallelAgents: false,
+        maxParallelAgents: 0,
+    },
+    standard: {
+        level: 'standard',
+        maxTurns: 15,
+        budgetTokens: 80_000,
+        modelTag: 'standard',
+        allowParallelAgents: false,
+        maxParallelAgents: 0,
+    },
+    deep: {
+        level: 'deep',
+        maxTurns: 50,
+        budgetTokens: 200_000,
+        modelTag: 'standard',
+        allowParallelAgents: true,
+        maxParallelAgents: 3,
+    },
+    marathon: {
+        level: 'marathon',
+        maxTurns: 200,
+        budgetTokens: 800_000,
+        modelTag: 'heavy',
+        allowParallelAgents: true,
+        maxParallelAgents: 3,
+    },
+};
+/**
+ * Look up the profile for a level. Pure — returns the same frozen
+ * object on every call so callers can reference-compare cheaply.
+ */
+export function profileFor(level) {
+    return PROFILES[level];
+}
+/**
+ * Resolve the effective per-task `maxTurns` cap.
+ *
+ * Precedence (triple-review P1 follow-up):
+ *  1. explicit `--max-turns=N` flag wins outright
+ *  2. otherwise the intensity profile's per-tier preset wins
+ *
+ * The function is pure so the CLI seam can call it inline and the test
+ * corpus can pin the precedence without spinning up a full adapter.
+ * Returning the resolved primitive instead of an object keeps the
+ * call site readable: `const turns = resolveMaxTurns(flags.maxTurns,
+ * profile);`. The CLI threads the result into `EngineTask.budget.turns`
+ * which the native-pugi adapter forwards to `EngineBudget.maxTurns` in
+ * the SDK loop.
+ */
+export function resolveMaxTurns(flagMaxTurns, profile) {
+    return flagMaxTurns ?? profile.maxTurns;
+}
+/**
+ * Type guard for the four-level enum. Rejects everything else,
+ * including capitalised variants — operators surface the typo at parse
+ * time rather than seeing the dial silently degrade to`standard`.
+ */
+export function isIntensityLevel(value) {
+    return (typeof value === 'string' &&
+        INTENSITY_LEVELS.includes(value));
+}
+/**
+ * Resolve the effective intensity level from CLI input + env fallback.
+ *
+ *  1. CLI `--intensity <level>` wins when supplied.
+ *  2. `PUGI_INTENSITY` env wins next when `envFallback` (default true).
+ *  3. `DEFAULT_INTENSITY` ('standard') is the final fallback.
+ *
+ * Explicit-flag typos throw — an operator who typed `--intensity marathn`
+ * gets an immediate, deterministic error rather than silently dropping
+ * to `standard`. This matches the rule for every other named CLI flag
+ * (single source of truth lives in `parseArgs`).
+ *
+ * Env-var typos WARN and fall back — `PUGI_INTENSITY` is shell state that
+ * can persist across many sessions (rc files, container env, CI matrix).
+ * A typo there used to throw on every invocation and prevent any `pugi`
+ * command from running at all; the warn-not-throw path keeps the CLI
+ * usable and surfaces the bad value once on stderr so the operator can
+ * fix their environment. Triple-review P1 follow-up .
+ *
+ * The `warn` hook is injectable so unit tests can capture the message
+ * without depending on `process.stderr`. Production callers pass nothing
+ * and the helper falls back to `process.stderr.write`.
+ */
+export function resolveIntensity(opts) {
+    if (opts.intensity !== undefined && opts.intensity !== '') {
+        if (!isIntensityLevel(opts.intensity)) {
+            throw new Error(`unknown --intensity "${opts.intensity}"; expected one of ${INTENSITY_LEVELS.join(', ')}`);
+        }
+        return opts.intensity;
+    }
+    const envFallback = opts.envFallback !== false;
+    if (envFallback) {
+        const fromEnv = process.env['PUGI_INTENSITY'];
+        if (fromEnv !== undefined && fromEnv !== '') {
+            if (!isIntensityLevel(fromEnv)) {
+                const message = `pugi: PUGI_INTENSITY="${fromEnv}" is not one of ${INTENSITY_LEVELS.join(', ')}; ignoring and using default (${DEFAULT_INTENSITY}).\n`;
+                const writer = opts.warn ?? ((m) => {
+                    process.stderr.write(m);
+                });
+                writer(message);
+                return DEFAULT_INTENSITY;
+            }
+            return fromEnv;
+        }
+    }
+    return DEFAULT_INTENSITY;
+}
+//# sourceMappingURL=intensity.js.map

package/dist/core/engine/intent.js

@@ -0,0 +1,260 @@
+/**
+ * β5a P1+P6 — CLI-side intent classifier: definitional vs operational.
+ *
+ * Background (CEO quality gate ≥80% vs the upstream tool): the
+ * .X Phase 2 comparative eval surfaced a high-frequency Pugi loss
+ * mode where the model interpreted EVERY user message as an operational
+ * task and reached for tools. Concrete reproducer: when an operator
+ * asks "What is grep?", pre-β5a Pugi would issue a `bash` tool call
+ * (`man grep`, `grep --help`, sometimes a `glob` over `**`) instead
+ * of answering explanatorily. the upstream tool answers in one paragraph,
+ * no tool calls. That single failure mode costs ~3 of the 23
+ * comparative fixtures.
+ *
+ * Root cause: the system prompt advertises tools as the primary way
+ * to make progress; without a counter-instruction, the model defaults
+ * to tools even for pure-knowledge questions. Prompt v2 (P6) adds
+ * definitional EXAMPLES in the prompt; this classifier is the
+ * deterministic safety net that flags definitional questions BEFORE
+ * the engine loop fires so we can:
+ *
+ *  1. Inject a one-line `<intent>definitional</intent>` marker into
+ *     the user message that the prompt explicitly teaches the model
+ *     to honour ("when you see this marker, answer in prose, do not
+ *     call tools").
+ *  2. Make the marker visible in the SSE stream so cabinet UI / eval
+ *     reports can show why a tool-free answer was correct.
+ *
+ * The classifier is intentionally simple — pure regex/keyword scoring,
+ * sub-millisecond, no LLM call, no fs reads. It must be:
+ *
+ *  - Deterministic (same input always → same output, the eval relies
+ *    on this for stable comparison runs).
+ *  - Conservative on the operational side. False-positive
+ *    definitional is mostly harmless (the model can still call tools
+ *    if needed — the marker is a hint, not a hard gate). False-
+ *    positive operational on a definitional question is what we are
+ *    fixing — biggest loss surface.
+ *
+ * Coverage: EN + RU (the two primary CLI languages per
+ * `feedback_chat_always_russian_no_drift.md`). Uses lowercase compare
+ * for keyword matches, anchored regex for prefix patterns. Stop-word
+ * agnostic — the question "what is X?" is the dominant template and
+ * survives every common stop-word filter.
+ *
+ * Out of scope: deciding WHICH tool to call when operational. That
+ * is the model's job. We only decide whether to suggest "no tools
+ * needed" up front.
+ */
+/**
+ * EN + RU definitional question openers. Anchored at start-of-string
+ * (after trim + lower) so a sentence-medial "what is" inside a larger
+ * operational sentence does not flip the verdict. Each entry is
+ * either a literal prefix or a RegExp matched against the lowercase
+ * trimmed input.
+ *
+ * Boundary policy: JS `\b` is ASCII-only — Cyrillic letters do not
+ * count as word characters, so `^объясни\b` matches "объясни" against
+ * a space follower BUT fails when the next char is a Cyrillic letter
+ * (which it never is at this position) and surprisingly fails on
+ * "объясни X" because `\b` between `и` (non-word in ASCII regex) and
+ * ` ` (non-word) is never a boundary. We use an explicit
+ * `(?=\s|$|[!?.,])` lookahead so Cyrillic prefixes match the same
+ * way ASCII ones do.
+ */
+const WB = '(?=\\s|$|[!?.,;:])';
+const DEFINITIONAL_PATTERNS = [
+    // EN
+    new RegExp(`^what\\s+(is|are|does|do)${WB}`),
+    new RegExp(`^who\\s+(is|are|was|were)${WB}`),
+    new RegExp(`^when\\s+(is|was|does|did)${WB}`),
+    new RegExp(`^where\\s+(is|are|does|did)${WB}`),
+    new RegExp(`^why\\s+(is|are|does|did)${WB}`),
+    new RegExp(`^how\\s+(does|do|did)\\s+\\S+\\s+work${WB}`),
+    new RegExp(`^explain\\s+(what|why|how)${WB}`),
+    new RegExp(`^define${WB}`),
+    new RegExp(`^tell\\s+me\\s+(what|about)${WB}`),
+    new RegExp(`^can\\s+you\\s+(tell\\s+me|explain|describe)${WB}`),
+    // RU
+    new RegExp(`^что\\s+(такое|это|значит)${WB}`),
+    new RegExp(`^кто\\s+(такой|такая|такие|это)${WB}`),
+    new RegExp(`^как\\s+работает${WB}`),
+    new RegExp(`^зачем${WB}`),
+    new RegExp(`^почему${WB}`),
+    new RegExp(`^объясни${WB}`),
+    new RegExp(`^расскажи\\s+(про|о|об)${WB}`),
+];
+/**
+ * Operational verbs that strongly imply a tool-use task. A match
+ * here overrides a weak definitional signal (e.g. "explain the bug
+ * and fix it" -> operational, not definitional).
+ */
+const OPERATIONAL_KEYWORDS = [
+    // EN
+    'fix', 'patch', 'add', 'remove', 'delete', 'create', 'build',
+    'implement', 'refactor', 'rename', 'migrate', 'deploy', 'install',
+    'run', 'test', 'debug', 'investigate', 'open a pr', 'commit',
+    'push', 'merge', 'review my', 'write a', 'write the', 'replace',
+    'update the', 'modify', 'edit', 'change the',
+    // RU
+    'почини', 'исправь', 'добавь', 'удали', 'создай', 'собери',
+    'реализуй', 'отрефактори', 'переименуй', 'мигрируй', 'задеплой',
+    'установи', 'запусти', 'протестируй', 'отладь', 'разберись',
+    'закоммить', 'смержи', 'напиши', 'замени', 'обнови', 'измени',
+    'отредактируй',
+];
+/**
+ * File-path / identifier signals that, when combined with any verb,
+ * push us toward operational regardless of question framing. A bare
+ * "what is" question that names a file (`what is in apps/admin-api/
+ * src/main.ts?`) reads as operational — the operator wants the file
+ * inspected, not a dictionary definition.
+ */
+const PATH_SIGNAL = /[./][a-z0-9_-]+\.(ts|tsx|js|jsx|json|md|yaml|yml|sh|py|prisma|css|scss|html|sql|env)\b/i;
+const CODE_SYMBOL_SIGNAL = /\b[A-Z][a-zA-Z0-9]+\.(prototype|find|create|run|build|register)\b/;
+/**
+ * Classify a single user message. Returns one of:
+ *
+ *  - `definitional` — high confidence the operator wants knowledge,
+ *    not edits. Prompt the model to answer in prose, no tools.
+ *  - `operational` — verbs / paths / explicit "fix X" framing.
+ *    Model decides tools as normal.
+ *  - `ambiguous` — neither side won decisively. The model gets no
+ *    extra hint; default behaviour applies. The marker is NOT
+ *    injected for ambiguous to keep the prompt cache stable.
+ *
+ * Confidence: rough heuristic — `1.0` when a pattern matched cleanly
+ * with no opposing signal; lower when both sides matched.
+ *
+ * Pure function, no side effects.
+ */
+export function classifyIntent(rawMessage) {
+    const trimmed = rawMessage.trim();
+    if (trimmed.length === 0) {
+        return {
+            intent: 'ambiguous',
+            confidence: 0,
+            matched: [],
+            rationale: 'empty input',
+        };
+    }
+    const lower = trimmed.toLowerCase();
+    const matched = [];
+    let definitionalScore = 0;
+    let operationalScore = 0;
+    let hasDefinitionalOpener = false;
+    for (const pattern of DEFINITIONAL_PATTERNS) {
+        if (pattern.test(lower)) {
+            // Three points — heavier than a single operational keyword
+            // match (two) so a definitional opener cannot be flipped by
+            // ONE incidental verb appearing as part of a noun phrase
+            // (e.g. "what does prisma MIGRATE do" — the verb "migrate"
+            // here names a subcommand, not an action the operator wants
+            // executed). Operational still wins when multiple operational
+            // signals stack (verb + path + imperative).
+            definitionalScore += 3;
+            matched.push(`def:${pattern.source}`);
+            hasDefinitionalOpener = true;
+            break; // a single anchored prefix is enough
+        }
+    }
+    // ?-terminated short utterance with no verbs is a strong
+    // definitional signal even without a what/who/why opener.
+    if (lower.endsWith('?') && lower.split(/\s+/).length <= 6) {
+        definitionalScore += 1;
+        matched.push('def:short-question');
+    }
+    // A definitional opener PLUS an explicit `?` terminator together
+    // form a pure question. Verbs mentioned inside ("what does prisma
+    // MIGRATE do?") are sub-noun-phrase references, not commands —
+    // boost definitional so the verb-keyword scoring below cannot tie.
+    if (hasDefinitionalOpener && lower.endsWith('?')) {
+        definitionalScore += 2;
+        matched.push('def:opener+question');
+    }
+    for (const keyword of OPERATIONAL_KEYWORDS) {
+        if (lower.includes(keyword)) {
+            operationalScore += 2;
+            matched.push(`op:${keyword}`);
+            break;
+        }
+    }
+    if (PATH_SIGNAL.test(trimmed)) {
+        operationalScore += 1;
+        matched.push('op:path-signal');
+    }
+    if (CODE_SYMBOL_SIGNAL.test(trimmed)) {
+        operationalScore += 1;
+        matched.push('op:code-symbol');
+    }
+    // Imperative ("do X") without any question framing is operational.
+    if (!lower.endsWith('?') && /^(please\s+)?(do|run|make|let'?s)\b/.test(lower)) {
+        operationalScore += 1;
+        matched.push('op:imperative');
+    }
+    // Decision.
+    if (definitionalScore === 0 && operationalScore === 0) {
+        return {
+            intent: 'ambiguous',
+            confidence: 0,
+            matched,
+            rationale: 'no rules matched',
+        };
+    }
+    if (definitionalScore > operationalScore + 1) {
+        return {
+            intent: 'definitional',
+            confidence: clamp01(definitionalScore / (definitionalScore + operationalScore + 1)),
+            matched,
+            rationale: `definitional ${definitionalScore} > operational ${operationalScore}`,
+        };
+    }
+    if (operationalScore >= definitionalScore) {
+        return {
+            intent: 'operational',
+            confidence: clamp01(operationalScore / (definitionalScore + operationalScore + 1)),
+            matched,
+            rationale: `operational ${operationalScore} >= definitional ${definitionalScore}`,
+        };
+    }
+    // Definitional won but margin is tight — keep but lower confidence.
+    return {
+        intent: 'definitional',
+        confidence: clamp01(definitionalScore / (definitionalScore + operationalScore + 1)) * 0.7,
+        matched,
+        rationale: `definitional ${definitionalScore} marginal over operational ${operationalScore}`,
+    };
+}
+/**
+ * Marker the engine wraps the user message in when the classifier
+ * picked `definitional`. The system prompt v2 teaches the model to
+ * answer in prose when it sees this marker.
+ *
+ * Format choice: angle-bracket pseudo-XML, matches the existing
+ * `<context>` / `<privacy-mode>` markers in the prompt — consistent
+ * marker grammar across the codebase keeps the model attentive.
+ */
+export const DEFINITIONAL_MARKER_OPEN = '<intent kind="definitional">';
+export const DEFINITIONAL_MARKER_CLOSE = '</intent>';
+/**
+ * Wrap a user message with the intent marker when the classifier
+ * fires `definitional`. Returns the original message verbatim for
+ * the `operational` and `ambiguous` cases — we never lie to the
+ * model about ambiguity, and we never restrict the model's tool
+ * use on an unrelated operational task.
+ */
+export function applyIntentMarker(message, intent) {
+    if (intent !== 'definitional')
+        return message;
+    return `${DEFINITIONAL_MARKER_OPEN}\n${message}\n${DEFINITIONAL_MARKER_CLOSE}`;
+}
+function clamp01(value) {
+    if (!Number.isFinite(value))
+        return 0;
+    if (value < 0)
+        return 0;
+    if (value > 1)
+        return 1;
+    return value;
+}
+//# sourceMappingURL=intent.js.map