@humain/humain-code-contracts 0.3.2 → 0.4.0

package/dist/flow-sizing.js

@@ -0,0 +1,568 @@
+export const UNIFIED_CLASSIFIER_POLICY_ID = "unified-regex-v4";
+// ─── Lane signals (moved verbatim from packages/ai/src/intent/classifier.ts) ───
+// Lane order mirrors the router lane rubric: DEBUG is checked first, then
+// MECHANICAL, then CREATIVE; FALLBACK catches the rest.
+const DEBUG_SIGNALS = /\b(404|500|broken|bug|crash(?:es|ed|ing)?|debug(?:s|ged|ging)?|diagnos(?:e|es|ed|ing)|doesn'?t work|error|exception|fail(?:s|ed|ing)?|failing|flaky|null|not working|regression|root cause|stack trace|troubleshoot(?:s|ed|ing)?|undefined|unexpected|wrong (?:output|result|value))\b/i;
+const MECHANICAL_SIGNALS = /\b(alphabetize|async\/await|bump|comment out|convert|delete unused|explain|extract (?:component|function)|inline|move (?:file|folder|component)|re-?format|re-?order|remove unused|rename|sort imports|typo|uncomment)\b/i;
+const CREATIVE_SIGNALS = /\b(add|build|component|create|dashboard|design|enhance|feature|flow|generate|implement|improve|integrate|interface|landing|new|page|portal|redesign|screen|section|tool|view|widget|workflow)\b/i;
+const NAMED_MODE_OVERRIDES = new Set(["production-ready", "add-tests", "code-review", "create-prd"]);
+// ─── Depth signals (moved verbatim from apps/web/lib/ai-modes.ts) ───
+const COMPLEX_BUILD_RE = /\b(admin|analytics|api|auth|authentication|authorization|backend|calendar|charts?|crud|dashboard|database|deploy|deployment|e2e|end[-\s]?to[-\s]?end|full[-\s]?stack|integration|kanban|multi[-\s]?page|permissions?|production|reports?|roles?|security|tests?|workflow)\b/i;
+const EXPLICIT_THOROUGH_BUILD_RE = /\b(use\s+opus|opus[-\s]?level|thorough|deep(?:est)?\s+reasoning|deep\s+review|architecture\s+review)\b/i;
+const HIGH_RISK_BUILD_RE = /\b(threat\s+model|security\s+review|compliance|regulated|hipaa|soc\s*2|gdpr|pci|data\s+retention|data\s+migration|schema\s+migration|tenant\s+isolation|multi[-\s]?tenant\s+authorization|authorization\s+architecture|incident\s+recovery|rollback\s+plan|payments?|billing)\b/i;
+const SUBSTANTIVE_CHANGE_ACTION_SOURCE = "add|build|change|connect|configure|create|design|develop|enable|enhance|extend|fix|generate|implement|improve|integrate|introduce|make|redesign|refactor|remove|rename|replace|set\\s+up|support|update|wire";
+const FOLLOW_UP_CHANGE_ACTION_SOURCE = `${SUBSTANTIVE_CHANGE_ACTION_SOURCE}|allow|automate|calculate|delete|display|export|give|handle|hide|import|invite|launch|let|localize|manage|move|permit|process|provide|rename|search|share|show|sync|track|trigger|unlock`;
+const FOLLOW_UP_CHANGE_BOUNDARY_SOURCE = "(?:\\b(?:and|also|plus|additionally|then)\\b|[,;:.!?]|\\s(?:/|-|–|—)\\s)";
+const FOLLOW_UP_CHANGE_BOUNDARY_RE = new RegExp(FOLLOW_UP_CHANGE_BOUNDARY_SOURCE, "i");
+const LOCATION_REFERENCE_CONJUNCTION_RE = /^and$/i;
+const REQUEST_DISCOURSE_MODIFIER_SOURCE = "(?:(?:just|kindly|only|please|simply)\\s+)*";
+// Regex hardening (linear time): adjacent modifier runs are merged because `M* M*` is ambiguous, and
+// `\s+.+\s+TAIL` spans use `spacedSpan` below. Every rewrite keeps the original language; see test/flow-sizing.test.ts.
+const LINE_TERMINATORS = "\\n\\r\\u2028\\u2029";
+/**
+ * Linear form of `\s+.+\s+TAIL` where TAIL starts with a non-space and `.` excludes line terminators: either the
+ * span starts and ends on non-space characters (the whitespace runs absorb everything else), or it is a single
+ * horizontal space inside one whitespace run.
+ */
+const spacedSpan = (tail) => `(?:\\s+\\S(?:[^${LINE_TERMINATORS}]*\\S)?\\s+|\\s[${LINE_TERMINATORS}]*[^\\S${LINE_TERMINATORS}]\\s+)${tail}`;
+const SUBSTANTIVE_CHANGE_REQUEST_RE = new RegExp(`^${REQUEST_DISCOURSE_MODIFIER_SOURCE}(?:(?:(?:can|could|should|would|will)\\s+(?:you|we)\\s+|(?:i|we)(?:['’]d| would)?\\s+${REQUEST_DISCOURSE_MODIFIER_SOURCE}like(?:\\s+you)?\\s+to\\s+|i\\s+${REQUEST_DISCOURSE_MODIFIER_SOURCE}want(?:\\s+you)?\\s+to\\s+|we\\s+${REQUEST_DISCOURSE_MODIFIER_SOURCE}(?:need(?:\\s+you)?\\s+to|should|must)\\s+|let['’]?s\\s+)${REQUEST_DISCOURSE_MODIFIER_SOURCE})?(${SUBSTANTIVE_CHANGE_ACTION_SOURCE})\\b`, "i");
+const DESIRED_STATE_REQUEST_RES = [
+    new RegExp(`^${REQUEST_DISCOURSE_MODIFIER_SOURCE}(?:i|we)(?:['’]d\\s+${REQUEST_DISCOURSE_MODIFIER_SOURCE}like|\\s+${REQUEST_DISCOURSE_MODIFIER_SOURCE}(?:want|need|would\\s+${REQUEST_DISCOURSE_MODIFIER_SOURCE}like))\\s+(?=\\S)(.+)$`, "i"),
+    new RegExp(`^${REQUEST_DISCOURSE_MODIFIER_SOURCE}can\\s+(?:we|you)\\s+${REQUEST_DISCOURSE_MODIFIER_SOURCE}have\\s+(?=\\S)(.+)$`, "i"),
+    new RegExp(`^${REQUEST_DISCOURSE_MODIFIER_SOURCE}(?:allow|enable|let)${spacedSpan("to\\b")}`, "i"),
+    new RegExp(`^${REQUEST_DISCOURSE_MODIFIER_SOURCE}(?:give|provide)${spacedSpan("(?:a\\s+way|the\\s+ability)\\s+to\\b")}`, "i"),
+    new RegExp(`^${REQUEST_DISCOURSE_MODIFIER_SOURCE}(?!i\\b|we\\b|you\\b)(?:[\\w-]+\\s+){1,5}(?:should|must|need(?:s)?\\s+to)\\s+be\\s+able\\s+to\\b`, "i"),
+    new RegExp(`^${REQUEST_DISCOURSE_MODIFIER_SOURCE}(?:a|an|the)${spacedSpan("(?:should|must|need(?:s)?\\s+to)\\s+(?:be\\s+(?:added|built|created|implemented|integrated|introduced|supported)\\b|(?:allow|enable|have|include|provide|support)\\b)")}`, "i"),
+];
+const NON_IMPLEMENTATION_DESIRE_BOUNDARY_SOURCE = "(?=[.!?]*$|\\s+(?:about|of|on|regarding|whether)\\b|\\s*(?:[,;:]|\\b(?:and|also|plus|additionally|then)\\b)|\\s+(?:-|–|—)\\s+)";
+const NON_IMPLEMENTATION_DESIRE_RE = new RegExp(`^(?:to\\s+(?:consider|decide|discuss|explore|know|learn|review|understand|wonder)\\b|help\\s+(?:with\\s+)?(?:considering|deciding|discussing|exploring|learning|reviewing|understanding)\\b|(?:advice|feedback)${NON_IMPLEMENTATION_DESIRE_BOUNDARY_SOURCE}|(?:a|an|the)\\s+(?:analysis|conversation|discussion|explanation|overview|review|summary)${NON_IMPLEMENTATION_DESIRE_BOUNDARY_SOURCE})`, "i");
+const NON_IMPLEMENTATION_TOPIC_RE = /^(?:(?:advice|feedback)|(?:a|an|the)\s+(?:analysis|conversation|discussion|explanation|overview|review|summary))\s+(?:about|of|on|regarding|whether)\b/i;
+const LEADING_ADVISORY_REQUEST_RE = new RegExp(`^${REQUEST_DISCOURSE_MODIFIER_SOURCE}(?:(?:can|could|would|will)\\s+(?:you|we)\\s+${REQUEST_DISCOURSE_MODIFIER_SOURCE})?(?:analy[sz]e|assess|describe|discuss|explain|explore|review|summarize|tell\\s+(?:me|us)|walk\\s+(?:me|us)\\s+through|give\\s+(?:me|us)\\s+(?:advice|feedback)|provide\\s+(?:me|us)\\s+(?:advice|feedback)|help\\s+(?:me|us)\\s+understand)\\b`, "i");
+const ADVISORY_OUTPUT_ACTIONS = new Set(["give", "provide", "show"]);
+const ADVISORY_TOPIC_COMPOUND_ACTION_RE = /^(?:build|change|create|design|export|import|process|search|support|update)$/;
+const ADVISORY_TOPIC_COMPOUND_HEAD_RE = /^(?:approach|architecture|consistency|conventions?|coverage|experience|flows?|governance|management|patterns?|performance|process(?:es)?|quality|reliability|security|standards?|strategy|structure|tooling|usability|workflows?)\b/i;
+const EXPLICIT_FOLLOW_UP_REQUEST_RE = /\b(?:just|kindly|only|please|simply|then)\b|[;:]|(?:can|could|would|will)\s+(?:you|we)\b/i;
+const ADVISORY_OUTPUT_TARGET_RE = /^(?:(?:me|us)\s+)?(?:(?:a|an|more|some|the|your)\s+)?(?:(?:advice|analysis|assessment|conversation|discussion|explanation|feedback|findings?|next\s+steps|options?|overview|recommendations?|review|suggestions?|summary|thoughts?|trade[-\s]?offs?)(?:\s+(?:about|of|on|regarding)\s+(?=\S).+)?|(?:how|what|whether|why)\b.+)$/i;
+const ADVISORY_OUTPUT_REQUEST_RE = /^(?:give|provide|show)\s+(?=\S)(.+)$/i;
+const FOLLOW_UP_PREFIX_RE = /^[\s,:;.!?/–—-]*(?:(?:and|also|plus|additionally|then)\b[\s,:;.!?/–—-]*)*(?:(?:just|kindly|only|please|simply)\s+)*/i;
+const COURTESY_ONLY_RE = /^(?:please|thanks|thank\s+you)[.!?]*$/i;
+// Tail of a follow-up change clause, matched (sticky) where the punctuation/space run after a boundary ends.
+const FOLLOW_UP_CHANGE_TAIL_RE = new RegExp(`${REQUEST_DISCOURSE_MODIFIER_SOURCE}(?:(?:can|could|would|will)\\s+(?:you|we)\\s+${REQUEST_DISCOURSE_MODIFIER_SOURCE})?(${FOLLOW_UP_CHANGE_ACTION_SOURCE})\\b(?=\\s+\\S)`, "iy");
+const LEADING_SUBSTANTIVE_CHANGE_VALUE_RE = new RegExp(`^(?:${FOLLOW_UP_CHANGE_ACTION_SOURCE})\\b\\s+\\S+`, "i");
+const BOUNDED_COPY_CONNECTOR_RE = /\b(?:and|by|or)\b/i;
+const BOUNDED_LOCATION_PURPOSE_RE = new RegExp(`\\b(?:in\\s+order\\s+)?to\\s+(?:${FOLLOW_UP_CHANGE_ACTION_SOURCE})\\b`, "i");
+const FUNCTIONAL_PURPOSE_CLAUSE_RE = /\b(?:so(?:\s+that)?\s+\S+(?:\s+\S+){0,2}\s+(?:can|could|may|might|will|would)\s+\S+|that\s+(?:allows?|enables?|lets?)\s+\S+\s+\S+|for\s+\S+(?:\s+\S+){0,2}\s+to\s+\S+)\b/i;
+const POTENTIALLY_BOUNDED_ACTIONS = new Set([
+    "add",
+    "change",
+    "fix",
+    "improve",
+    "make",
+    "remove",
+    "rename",
+    "replace",
+    "update",
+]);
+const BOUNDED_EDIT_TARGET_SOURCE = "alignment|border|caption|color|copy|description|font|gap|heading|icon|label|link|margin|padding|placeholder|punctuation|radius|shadow|size|spacing|subtitle|text|title|tooltip|typo|weight|wording";
+const BOUNDED_EDIT_TARGET_RE = new RegExp(`^(?:(?:the|a|an)\\s+)?((?:[\\w-]+\\s+){0,5})(${BOUNDED_EDIT_TARGET_SOURCE})\\b(.*)$`, "i");
+const COORDINATED_BOUNDED_EDIT_TARGET_TAIL_RE = new RegExp(`(?:(?:and|also|plus|additionally)\\s+)?(?:(?:the|a|an)\\s+)?(?:[\\w-]+\\s+){0,5}(?:${BOUNDED_EDIT_TARGET_SOURCE})\\b`, "iy");
+const BOUNDED_UI_SURFACE_MODIFIER_RE = /\b(app|application|badge|banner|breadcrumb|button|card|chip|control|dialog|drawer|dropdown|field|footer|form|header|hero|input|list|logo|menu|modal|nav|navbar|navigation|page|panel|popover|row|screen|search|section|select|shell|sidebar|switch|tab|table|tile|toast|toggle|toolbar)\b/i;
+const CAPABILITY_CONTAINER_MODIFIER_RE = /\b(assistant|builder|center|editor|engine|feature|flow|integration|manager|module|platform|service|system|tool|workflow)\b/i;
+const BOUNDED_PRESENTATION_ADJECTIVE_RE = /^(?:(?:a\s+(?:bit|little)|much|slightly)\s+)?(?:bolder|brighter|clearer|cooler|darker|friendlier|larger|lighter|longer|looser|rounder|sharper|shorter|smaller|softer|stronger|thicker|thinner|tighter|warmer|weaker|more\s+(?:compact|concise|descriptive|prominent|readable|specific|visible))[.!?]*$/i;
+const BOUNDED_LOCATION_RE = /^(?:after|around|at|before|below|beside|between|by|in|inside|near|next\s+to|on|outside|right\s+next\s+to|under|within)\s+(?=\S)(.+)$/i;
+const BOUNDED_LOCATION_BOUNDARY_RE = /\b(?:after|around|at|before|below|beside|between|by|in|inside|near|next\s+to|on|outside|right\s+next\s+to|under|within)\s+/i;
+const BOUNDED_CONTENT_VALUE_RE = /^(?:read|say)\s+(?=\S)(.+)$/i;
+const BOUNDED_TO_VALUE_RE = /^to\s+(?=\S)(.+)$/i;
+const BOUNDED_FROM_TO_HEAD_RE = /^from\s+(?=\S)/i;
+const BOUNDED_PRESENTATION_PAYLOAD_RE = /^with\s+(?=\S)(.+)$/i;
+const BOUNDED_PASSIVE_VALUE_RE = /^(?:changed|fixed|renamed|replaced|set|updated)\s+(?:to|with)\s+(?=\S)(.+)$/i;
+const BOUNDED_PASSIVE_FROM_TO_HEAD_RE = /^(?:changed|renamed|replaced|updated)\s+from\s+(?=\S)/i;
+const FROM_TO_SEPARATOR_RE = /(?<=\S)\s+to\s+(?=\S)/gi;
+const BOUNDED_PASSIVE_COMPLETED_RE = /^(?:changed|fixed|renamed|replaced|set|updated)[.!?]*$/i;
+const BOUNDED_PASSIVE_PRESENTATION_RE = /^made\s+(?=\S)(.+)$/i;
+const BOUNDED_PASSIVE_REMOVAL_RE = /^(?:deleted|removed)[.!?]*$/i;
+const BUILD_CONJUNCTION_RE = /\b(and|also|plus|additionally)\b/i;
+const LIST_SEPARATOR_RE = /[,;،]/u;
+const NON_LATIN_RE = /[^\p{Script=Latin}\p{Script=Common}\p{Script=Inherited}]/u;
+const ARABIC_COMPLEX_BUILD_RE = /(اختبارات|إعدادات|بيانات|تقارير|تحكم|صلاحيات|لوحة)/u;
+const BUILD_IMPERATIVE_RES = [
+    "build",
+    "create",
+    "generate",
+    "change",
+    "make",
+    "add",
+    "remove",
+    "delete",
+    "update",
+    "move",
+    "replace",
+    "fix",
+    "implement",
+    "wire",
+].map((value) => new RegExp(`\\b${value}\\b`, "gi"));
+function matchSignals(prompt, pattern) {
+    const global = new RegExp(pattern.source, "gi");
+    return Array.from(new Set(Array.from(prompt.matchAll(global), (match) => match[0].toLowerCase())));
+}
+function classifyLane(input) {
+    const namedMode = input.mode?.trim();
+    if (namedMode && NAMED_MODE_OVERRIDES.has(namedMode)) {
+        return {
+            lane: "creative",
+            decisionSource: "mode-override",
+            matchedSignals: [`mode:${namedMode}`],
+        };
+    }
+    const prompt = input.prompt.trim();
+    if (!prompt)
+        return { lane: "fallback", decisionSource: "default", matchedSignals: [] };
+    const lanes = [
+        { lane: "debug", pattern: DEBUG_SIGNALS },
+        { lane: "mechanical", pattern: MECHANICAL_SIGNALS },
+        { lane: "creative", pattern: CREATIVE_SIGNALS },
+    ];
+    for (const { lane, pattern } of lanes) {
+        const matchedSignals = matchSignals(prompt, pattern);
+        if (matchedSignals.length > 0) {
+            return { lane, decisionSource: "keyword-classifier", matchedSignals };
+        }
+    }
+    return { lane: "fallback", decisionSource: "default", matchedSignals: [] };
+}
+function imperativeCount(prompt) {
+    return BUILD_IMPERATIVE_RES.reduce((count, re) => {
+        const matches = prompt.match(re);
+        return count + (matches?.length ?? 0);
+    }, 0);
+}
+function hasMultiChangePrompt(prompt) {
+    if (!BUILD_CONJUNCTION_RE.test(prompt))
+        return false;
+    return imperativeCount(prompt) >= 2;
+}
+function hasNonLatinComplexitySignal(prompt) {
+    if (!NON_LATIN_RE.test(prompt))
+        return false;
+    if (ARABIC_COMPLEX_BUILD_RE.test(prompt))
+        return true;
+    return LIST_SEPARATOR_RE.test(prompt) && prompt.length > 48;
+}
+function isShortBoundedPhrase(value, maxWords) {
+    const trimmed = value.trim();
+    if (!trimmed || trimmed.length > 80 || /[\r\n;]/.test(trimmed))
+        return false;
+    const withoutTerminalPunctuation = trimmed.replace(/[.!?]+$/, "").trim();
+    if (!withoutTerminalPunctuation || /[.!?]\s/.test(withoutTerminalPunctuation))
+        return false;
+    return withoutTerminalPunctuation.split(/\s+/).length <= maxWords;
+}
+const QUOTE_PAIRS = {
+    '"': '"',
+    "'": "'",
+    "`": "`",
+    "“": "”",
+    "‘": "’",
+};
+function isWordCharacterAt(value, index) {
+    const character = value[index];
+    return character !== undefined && /[\p{L}\p{N}_]/u.test(character);
+}
+function maskQuotedText(value) {
+    const masked = value.split("");
+    // An opener whose scan found no closer before the end of its line proves every later opener of the same
+    // kind on that line also fails (closer validity does not depend on the opener), so it is skipped.
+    const noCloserBefore = new Map();
+    for (let openingIndex = 0; openingIndex < value.length; openingIndex += 1) {
+        const opening = value[openingIndex] ?? "";
+        const closing = QUOTE_PAIRS[opening];
+        if (!closing)
+            continue;
+        const isSingleQuote = opening === "'" || opening === "‘";
+        if (isSingleQuote &&
+            (isWordCharacterAt(value, openingIndex - 1) ||
+                !value[openingIndex + 1] ||
+                /[\s\r\n]/.test(value[openingIndex + 1] ?? ""))) {
+            continue;
+        }
+        if ((noCloserBefore.get(opening) ?? -1) > openingIndex)
+            continue;
+        let closingIndex = openingIndex + 1;
+        for (; closingIndex < value.length; closingIndex += 1) {
+            const character = value[closingIndex];
+            if (character === "\r" || character === "\n")
+                break;
+            if (character !== closing)
+                continue;
+            if (isSingleQuote &&
+                isWordCharacterAt(value, closingIndex - 1) &&
+                isWordCharacterAt(value, closingIndex + 1)) {
+                continue;
+            }
+            for (let index = openingIndex; index <= closingIndex; index += 1) {
+                masked[index] = " ";
+            }
+            openingIndex = closingIndex;
+            break;
+        }
+        if (closingIndex >= value.length || value[closingIndex] === "\r" || value[closingIndex] === "\n") {
+            noCloserBefore.set(opening, closingIndex);
+        }
+    }
+    return masked.join("");
+}
+function isEntireQuotedLiteral(value) {
+    const trimmed = value.trim();
+    const opening = trimmed[0] ?? "";
+    const closing = QUOTE_PAIRS[opening];
+    return Boolean(closing && trimmed.length >= 2 && trimmed.at(-1) === closing);
+}
+const FOLLOW_UP_BOUNDARY_G_RE = new RegExp(FOLLOW_UP_CHANGE_BOUNDARY_SOURCE, "gi");
+const BOUNDARY_FILL_Y_RE = /[\s,:;.!?/–—-]*/y;
+/**
+ * Linear form of `BOUNDARY [\s,:;.!?/–—-]* TAIL` searched leftmost-first and non-overlapping. Every boundary inside one
+ * punctuation/space run reaches the same run end, and a tail never starts inside the run except at a hyphen
+ * (where starting at the run end matches whenever starting at the hyphen does), so each run is scanned once.
+ * `onMatch` receives the boundary start, the match end and the tail match; return true to stop.
+ */
+function scanAfterBoundary(text, tail, onMatch) {
+    FOLLOW_UP_BOUNDARY_G_RE.lastIndex = 0;
+    let failedRunEnd = -1;
+    for (let boundary = FOLLOW_UP_BOUNDARY_G_RE.exec(text); boundary; boundary = FOLLOW_UP_BOUNDARY_G_RE.exec(text)) {
+        if (boundary.index + boundary[0].length <= failedRunEnd)
+            continue;
+        BOUNDARY_FILL_Y_RE.lastIndex = boundary.index + boundary[0].length;
+        BOUNDARY_FILL_Y_RE.exec(text);
+        const runEnd = BOUNDARY_FILL_Y_RE.lastIndex;
+        tail.lastIndex = runEnd;
+        const tailMatch = tail.exec(text);
+        if (!tailMatch) {
+            failedRunEnd = runEnd;
+            continue;
+        }
+        const end = runEnd + tailMatch[0].length;
+        if (onMatch(boundary.index, end, tailMatch))
+            return;
+        FOLLOW_UP_BOUNDARY_G_RE.lastIndex = end;
+        failedRunEnd = -1;
+    }
+}
+function hasCoordinatedBoundedEditTarget(target) {
+    const maskedTarget = maskQuotedText(target);
+    const firstBoundary = FOLLOW_UP_CHANGE_BOUNDARY_RE.exec(maskedTarget);
+    const location = BOUNDED_LOCATION_BOUNDARY_RE.exec(maskedTarget);
+    if (firstBoundary &&
+        location &&
+        (location.index ?? 0) < (firstBoundary.index ?? 0) &&
+        LOCATION_REFERENCE_CONJUNCTION_RE.test(firstBoundary[0]) &&
+        isBoundedEditTarget(maskedTarget.slice(0, location.index).trim(), "change")) {
+        return false;
+    }
+    let found = false;
+    scanAfterBoundary(maskedTarget, COORDINATED_BOUNDED_EDIT_TARGET_TAIL_RE, () => {
+        found = true;
+        return true;
+    });
+    return found;
+}
+function hasFollowUpSubstantiveChange(value) {
+    let found = false;
+    scanAfterBoundary(maskQuotedText(value), FOLLOW_UP_CHANGE_TAIL_RE, () => {
+        found = true;
+        return true;
+    });
+    return found;
+}
+function isShortLiteralValue(value) {
+    const trimmed = value.trim();
+    if (trimmed.length <= 80 && !/[\r\n]/.test(trimmed) && isEntireQuotedLiteral(trimmed)) {
+        return true;
+    }
+    if (!isShortBoundedPhrase(trimmed, 8) || hasFollowUpSubstantiveChange(trimmed)) {
+        return false;
+    }
+    const withoutTerminalPunctuation = trimmed.replace(/[.!?]+$/, "").trim();
+    if (/^(?:[/#@]|https?:\/\/)/i.test(withoutTerminalPunctuation))
+        return true;
+    if (/^[A-Z0-9]/.test(withoutTerminalPunctuation))
+        return true;
+    if (BOUNDED_COPY_CONNECTOR_RE.test(withoutTerminalPunctuation))
+        return true;
+    return !LEADING_SUBSTANTIVE_CHANGE_VALUE_RE.test(trimmed);
+}
+function isShortLocation(value) {
+    return (isShortBoundedPhrase(value, 8) &&
+        !hasFollowUpSubstantiveChange(value) &&
+        !BOUNDED_LOCATION_PURPOSE_RE.test(value) &&
+        !FUNCTIONAL_PURPOSE_CLAUSE_RE.test(value));
+}
+/**
+ * Linear form of `^HEAD(.+?)\s+to\s+(.+)$` on trimmed input: first separator whose left side and right side hold no line
+ * break. The regex's only extra parse (an all-whitespace left side) classifies as not-a-literal, same as no match.
+ */
+function matchFromTo(value, head) {
+    const headMatch = head.exec(value);
+    if (!headMatch)
+        return null;
+    const start = headMatch[0].length;
+    const relativeBreak = value.slice(start).search(/[\n\r\u2028\u2029]/);
+    const firstBreak = relativeBreak === -1 ? Number.POSITIVE_INFINITY : start + relativeBreak;
+    const lastBreak = Math.max(value.lastIndexOf("\n"), value.lastIndexOf("\r"), value.lastIndexOf("\u2028"), value.lastIndexOf("\u2029"));
+    FROM_TO_SEPARATOR_RE.lastIndex = start;
+    for (let match = FROM_TO_SEPARATOR_RE.exec(value); match; match = FROM_TO_SEPARATOR_RE.exec(value)) {
+        if (match.index > firstBreak)
+            return null;
+        const rightStart = match.index + match[0].length;
+        if (lastBreak < rightStart)
+            return [value.slice(start, match.index), value.slice(rightStart)];
+        FROM_TO_SEPARATOR_RE.lastIndex = match.index + 1;
+    }
+    return null;
+}
+function isBoundedEditTarget(target, action) {
+    const match = BOUNDED_EDIT_TARGET_RE.exec(target);
+    if (!match)
+        return false;
+    const modifiers = match[1]?.trim() ?? "";
+    if ((!action || action === "add") &&
+        CAPABILITY_CONTAINER_MODIFIER_RE.test(modifiers) &&
+        !BOUNDED_UI_SURFACE_MODIFIER_RE.test(modifiers)) {
+        return false;
+    }
+    const remainder = match[3]?.trim() ?? "";
+    if (hasFollowUpSubstantiveChange(remainder))
+        return false;
+    if (!remainder || /^[.!?]+$/.test(remainder))
+        return true;
+    if (BOUNDED_PRESENTATION_ADJECTIVE_RE.test(remainder))
+        return true;
+    if (BOUNDED_PASSIVE_REMOVAL_RE.test(remainder))
+        return true;
+    if (BOUNDED_PASSIVE_COMPLETED_RE.test(remainder))
+        return true;
+    const passiveFromToMatch = matchFromTo(remainder, BOUNDED_PASSIVE_FROM_TO_HEAD_RE);
+    if (passiveFromToMatch) {
+        return isShortLiteralValue(passiveFromToMatch[0]) && isShortLiteralValue(passiveFromToMatch[1]);
+    }
+    const passiveValueMatch = BOUNDED_PASSIVE_VALUE_RE.exec(remainder);
+    if (passiveValueMatch)
+        return isShortLiteralValue(passiveValueMatch[1] ?? "");
+    const passivePresentationMatch = BOUNDED_PASSIVE_PRESENTATION_RE.exec(remainder);
+    if (passivePresentationMatch) {
+        return BOUNDED_PRESENTATION_ADJECTIVE_RE.test(passivePresentationMatch[1] ?? "");
+    }
+    const fromToMatch = matchFromTo(remainder, BOUNDED_FROM_TO_HEAD_RE);
+    if (fromToMatch)
+        return isShortLiteralValue(fromToMatch[0]) && isShortLiteralValue(fromToMatch[1]);
+    const contentValueMatch = BOUNDED_CONTENT_VALUE_RE.exec(remainder);
+    if (contentValueMatch)
+        return isShortLiteralValue(contentValueMatch[1] ?? "");
+    const toValueMatch = BOUNDED_TO_VALUE_RE.exec(remainder);
+    if (toValueMatch)
+        return isShortLiteralValue(toValueMatch[1] ?? "");
+    const presentationPayloadMatch = BOUNDED_PRESENTATION_PAYLOAD_RE.exec(remainder);
+    if (presentationPayloadMatch) {
+        return isBoundedEditTarget(presentationPayloadMatch[1] ?? "", "change");
+    }
+    const locationMatch = BOUNDED_LOCATION_RE.exec(remainder);
+    return locationMatch ? isShortLocation(locationMatch[1] ?? "") : false;
+}
+function matchDesiredStateRequest(prompt) {
+    for (const pattern of DESIRED_STATE_REQUEST_RES) {
+        const match = pattern.exec(prompt);
+        if (match)
+            return { target: match[1]?.trimStart() ?? null };
+    }
+    return null;
+}
+function firstChangeClauseTarget(target) {
+    const boundary = FOLLOW_UP_CHANGE_BOUNDARY_RE.exec(maskQuotedText(target));
+    return target.slice(0, boundary?.index ?? target.length).trim();
+}
+function desiredStateContinuation(target) {
+    const boundary = FOLLOW_UP_CHANGE_BOUNDARY_RE.exec(maskQuotedText(target));
+    if (!boundary)
+        return null;
+    return target
+        .slice((boundary.index ?? 0) + boundary[0].length)
+        .replace(FOLLOW_UP_PREFIX_RE, "")
+        .trim();
+}
+function isAdvisoryContinuation(target) {
+    if (!target || COURTESY_ONLY_RE.test(target) || ADVISORY_OUTPUT_TARGET_RE.test(target)) {
+        return true;
+    }
+    const outputRequest = ADVISORY_OUTPUT_REQUEST_RE.exec(target);
+    if (outputRequest && ADVISORY_OUTPUT_TARGET_RE.test(outputRequest[1] ?? ""))
+        return true;
+    return LEADING_ADVISORY_REQUEST_RE.test(target);
+}
+function classifyConjoinedChangeRequest(target, options = {}) {
+    const maskedTarget = maskQuotedText(target);
+    const matches = [];
+    scanAfterBoundary(maskedTarget, FOLLOW_UP_CHANGE_TAIL_RE, (start, end, tailMatch) => {
+        matches.push({ start, end, action: tailMatch[1] ?? "" });
+        return false;
+    });
+    let requestKind = "none";
+    for (const match of matches) {
+        const action = match.action.toLowerCase();
+        if (!action)
+            return "substantive";
+        // Masking a suffix equals the suffix of the masked text: no quote span can cross the action word.
+        const editStart = match.end + target.slice(match.end).search(/\S|$/);
+        const editTarget = target.slice(editStart);
+        const nextBoundary = FOLLOW_UP_CHANGE_BOUNDARY_RE.exec(maskedTarget.slice(editStart));
+        const clauseTarget = editTarget.slice(0, nextBoundary?.index ?? editTarget.length).trim();
+        const matchedText = maskedTarget.slice(match.start, match.end);
+        if (options.advisoryTopic &&
+            ADVISORY_TOPIC_COMPOUND_ACTION_RE.test(action) &&
+            ADVISORY_TOPIC_COMPOUND_HEAD_RE.test(clauseTarget) &&
+            !EXPLICIT_FOLLOW_UP_REQUEST_RE.test(matchedText)) {
+            continue;
+        }
+        if (ADVISORY_OUTPUT_ACTIONS.has(action) && ADVISORY_OUTPUT_TARGET_RE.test(clauseTarget)) {
+            continue;
+        }
+        if (!POTENTIALLY_BOUNDED_ACTIONS.has(action))
+            return "substantive";
+        if (!isBoundedEditTarget(clauseTarget, action))
+            return "substantive";
+        if (hasCoordinatedBoundedEditTarget(editTarget))
+            return "substantive";
+        if (requestKind === "bounded")
+            return "substantive";
+        requestKind = "bounded";
+    }
+    return requestKind;
+}
+function classifyNonImplementationDesire(target) {
+    if (!NON_IMPLEMENTATION_DESIRE_RE.test(target))
+        return null;
+    const advisoryTopic = NON_IMPLEMENTATION_TOPIC_RE.test(target);
+    const conjoinedRequest = classifyConjoinedChangeRequest(target, { advisoryTopic });
+    if (conjoinedRequest !== "none")
+        return conjoinedRequest;
+    if (advisoryTopic)
+        return "none";
+    const continuation = desiredStateContinuation(target);
+    return continuation && !isAdvisoryContinuation(continuation) ? "substantive" : "none";
+}
+function hasNonImplementationDesire(prompt) {
+    const request = matchDesiredStateRequest(prompt);
+    if (!request?.target)
+        return false;
+    const requestKind = classifyNonImplementationDesire(request.target);
+    return requestKind !== null && requestKind !== "substantive";
+}
+function classifyChangeRequest(prompt) {
+    const match = SUBSTANTIVE_CHANGE_REQUEST_RE.exec(prompt);
+    if (match) {
+        const action = match[1]?.toLowerCase();
+        if (!action || !POTENTIALLY_BOUNDED_ACTIONS.has(action))
+            return "substantive";
+        const target = prompt.slice(match[0].length).trimStart();
+        const conjoinedRequest = classifyConjoinedChangeRequest(prompt);
+        if (!isBoundedEditTarget(firstChangeClauseTarget(target), action)) {
+            return action === "rename" && conjoinedRequest === "none" && !hasCoordinatedBoundedEditTarget(target)
+                ? "none"
+                : "substantive";
+        }
+        if (hasCoordinatedBoundedEditTarget(target))
+            return "substantive";
+        return conjoinedRequest === "none" ? "bounded" : "substantive";
+    }
+    if (LEADING_ADVISORY_REQUEST_RE.test(prompt)) {
+        const conjoinedRequest = classifyConjoinedChangeRequest(prompt);
+        if (conjoinedRequest !== "none")
+            return conjoinedRequest;
+    }
+    const desiredStateRequest = matchDesiredStateRequest(prompt);
+    if (!desiredStateRequest)
+        return "none";
+    const { target } = desiredStateRequest;
+    if (target) {
+        const nonImplementationRequest = classifyNonImplementationDesire(target);
+        if (nonImplementationRequest !== null)
+            return nonImplementationRequest;
+    }
+    return target && isBoundedEditTarget(target) ? "bounded" : "substantive";
+}
+function resolvePromptExecutionDepth(trimmed, signalText, imperativeTotal, changeRequestKind) {
+    if (!trimmed)
+        return "quick";
+    if (EXPLICIT_THOROUGH_BUILD_RE.test(signalText))
+        return "thorough";
+    if (HIGH_RISK_BUILD_RE.test(signalText) && (COMPLEX_BUILD_RE.test(signalText) || imperativeTotal >= 2)) {
+        return "thorough";
+    }
+    if (signalText.length > 600 && imperativeTotal >= 3)
+        return "thorough";
+    if (hasNonImplementationDesire(trimmed))
+        return "quick";
+    if (changeRequestKind === "bounded")
+        return "quick";
+    if (COMPLEX_BUILD_RE.test(signalText))
+        return "balanced";
+    if (changeRequestKind === "substantive")
+        return "balanced";
+    if (hasNonLatinComplexitySignal(signalText))
+        return "balanced";
+    if (signalText.length > 180 && imperativeTotal >= 2)
+        return "balanced";
+    if (hasMultiChangePrompt(signalText))
+        return "balanced";
+    return "quick";
+}
+// Independent of the resolved depth: a prompt can carry a risk signal (e.g.
+// a high-risk domain term) even on a turn where the overall heuristic above
+// settles on 'balanced' because no other arm fired. Consumers that gate on
+// risk (e.g. the review pass) rely on that independence rather than
+// re-deriving reasons from `depth`.
+function computeRiskReasons(trimmed, imperativeTotal) {
+    const reasons = [];
+    if (EXPLICIT_THOROUGH_BUILD_RE.test(trimmed))
+        reasons.push("explicit-thorough-request");
+    if (HIGH_RISK_BUILD_RE.test(trimmed))
+        reasons.push("high-risk-domain-term");
+    if (trimmed.length > 600 && imperativeTotal >= 3)
+        reasons.push("long-multi-imperative");
+    return reasons;
+}
+export function classifyPromptLanguageBucket(prompt) {
+    return NON_LATIN_RE.test(prompt) ? "non-latin" : "latin";
+}
+export function classifyPromptSignals(input) {
+    const trimmed = input.prompt.trim();
+    const signalText = maskQuotedText(trimmed);
+    const imperativeTotal = imperativeCount(signalText);
+    const changeRequestKind = classifyChangeRequest(trimmed);
+    const laneResult = classifyLane({
+        prompt: changeRequestKind === "bounded" ? signalText : trimmed,
+        mode: input.mode,
+    });
+    return {
+        lane: laneResult.lane,
+        laneDecisionSource: laneResult.decisionSource,
+        laneMatchedSignals: laneResult.matchedSignals,
+        depth: resolvePromptExecutionDepth(trimmed, signalText, imperativeTotal, changeRequestKind),
+        riskReasons: computeRiskReasons(signalText, imperativeTotal),
+        policyId: UNIFIED_CLASSIFIER_POLICY_ID,
+    };
+}
+/**
+ * Maps a classifier depth to a Flow size: quick -> small, balanced -> medium, thorough -> large.
+ * When `thresholds` and a finite numeric `score` are both given, the score decides instead:
+ * score >= largeAt -> large, score >= mediumAt -> medium, else small.
+ */
+export function sizeFromDepth(depth, thresholds, score) {
+    if (thresholds !== undefined && typeof score === "number" && Number.isFinite(score)) {
+        if (score >= thresholds.largeAt)
+            return "large";
+        return score >= thresholds.mediumAt ? "medium" : "small";
+    }
+    if (depth === "thorough")
+        return "large";
+    return depth === "balanced" ? "medium" : "small";
+}
+//# sourceMappingURL=flow-sizing.js.map