tracelattice 1.2.5

package/dist/core/InputNormalizer.d.ts

@@ -0,0 +1,139 @@
+/**
+ * Input normalization for common LLM field name mistakes.
+ *
+ * This module provides normalization logic to handle common mistakes
+ * that LLMs make when generating field names, such as using singular
+ * instead of plural forms (e.g., `recommended_tool` vs `recommended_tools`).
+ *
+ * It also fills in sensible defaults for missing fields in `previous_steps`,
+ * which LLMs naturally provide as partial/skeletal data (historical context).
+ *
+ * @module processor
+ */
+import type { ThoughtData } from './thought.js';
+/**
+ * Recursively sanitizes all string values within an unknown structure.
+ * Walks into plain objects and arrays to reach deeply nested strings.
+ * Non-plain objects (Date, RegExp, etc.) are returned as-is.
+ *
+ * @param value - The value to sanitize recursively
+ * @returns The sanitized value with all nested strings cleaned
+ *
+ * @example
+ * ```typescript
+ * sanitizeRecursive('<script>x</script>'); // 'x'
+ * sanitizeRecursive({ a: { b: '<iframe>y' } }); // { a: { b: 'y' } }
+ * sanitizeRecursive(['a\x00b', 42]); // ['ab', 42]
+ * ```
+ */
+export declare function sanitizeRecursive(value: unknown): unknown;
+/**
+ * Sanitizes and validates a branch ID to prevent path traversal attacks.
+ *
+ * @param branchId - The branch ID to sanitize
+ * @returns The sanitized branch ID
+ * @throws ValidationError if the branch ID contains invalid characters
+ *
+ * @example
+ * ```typescript
+ * sanitizeBranchId('my-branch_01'); // 'my-branch_01'
+ * sanitizeBranchId('../etc/passwd'); // throws ValidationError
+ * ```
+ */
+export declare function sanitizeBranchId(branchId: string): string;
+/**
+ * Sanitizes and validates a session ID.
+ *
+ * @param sessionId - The session ID to sanitize
+ * @returns The sanitized session ID, or undefined if invalid after sanitization
+ *
+ * @example
+ * ```typescript
+ * sanitizeSessionId('analysis-task-42'); // 'analysis-task-42'
+ * sanitizeSessionId('bad session!'); // undefined (stripped)
+ * ```
+ */
+export declare function sanitizeSessionId(sessionId: string): string | undefined;
+/**
+ * Normalizes reasoning-specific fields on a thought input object.
+ * Always applies reasoning normalization — reasoning is the default pipeline.
+ * Applies the following normalization rules:
+ * - Defaults `thought_type` to `'regular'` if not provided
+ * - Clamps `quality_score` to [0, 1] range
+ * - Clamps `confidence` to [0, 1] range
+ * - Sanitizes `hypothesis_id` using `sanitizeBranchId` pattern
+ * - Filters `synthesis_sources` to positive integers only
+ * - Filters `merge_from_thoughts` to positive integers only
+ * - Sanitizes each entry in `merge_branch_ids`
+ * - Defaults `reasoning_depth` to `'moderate'` for hypothesis/verification types
+ *
+ * @param input - The mutable normalized input object to apply reasoning defaults to
+ *
+ * @example
+ * ```typescript
+ * const input: Record<string, unknown> = { thought_type: 'hypothesis', quality_score: 1.5 };
+ * normalizeReasoningFields(input);
+ * // input.quality_score === 1, input.reasoning_depth === 'moderate'
+ * ```
+ */
+export declare function normalizeReasoningFields(input: Record<string, unknown>): void;
+/**
+ * Normalizes thought input data by fixing common LLM field name mistakes.
+ *
+ * This function handles cases where LLMs incorrectly use singular forms
+ * of field names that should be plural. It applies normalization to both
+ * `current_step` and `previous_steps` fields.
+ *
+ * The normalization is applied BEFORE schema validation, allowing the
+ * strict Valibot schema to remain correct while still being tolerant
+ * of common LLM mistakes.
+ *
+ * @param input - The raw thought input data to normalize
+ * @returns Normalized thought data with correct field names
+ *
+ * @remarks
+ * **Normalization Rules:**
+ * - `recommended_tool` (singular) → `recommended_tools` (plural)
+ * - `recommended_skill` (singular) → `recommended_skills` (plural)
+ * - Applied to `current_step` if present (strict mode)
+ * - Applied to all items in `previous_steps` if present (lenient mode with defaults)
+ *
+ * **Design Rationale:**
+ * LLMs sometimes use singular field names even when the schema explicitly
+ * defines plural forms. Rather than forcing the LLM to be perfect (which
+ * leads to cryptic validation errors), we normalize the input to handle
+ * these common mistakes gracefully.
+ *
+ * Additionally, LLMs naturally provide complete data for `current_step`
+ * but only partial/skeletal data for `previous_steps` (historical context).
+ * The lenient mode for `previous_steps` fills in sensible defaults:
+ * - `confidence`: 0.5 for missing tool recommendation confidence
+ * - `priority`: 999 for missing tool recommendation priority
+ * - `rationale`: empty string for missing tool recommendation rationale
+ * - `expected_outcome`: empty string for missing step expected outcome
+ *
+ * @example
+ * ```typescript
+ * const input = {
+ *   thought: 'I need to analyze the data',
+ *   thought_number: 1,
+ *   total_thoughts: 3,
+ *   next_thought_needed: true,
+ *   current_step: {
+ *     step_description: 'Read the data file',
+ *     recommended_tool: [{ tool_name: 'Read', confidence: 0.9, rationale: 'test', priority: 1 }],
+ *     expected_outcome: 'Data loaded'
+ *   },
+ *   previous_steps: [{
+ *     step_description: 'Previous step',
+ *     recommended_tools: [{ tool_name: 'Grep', rationale: 'Search code' }]
+ *   }]
+ * };
+ *
+ * const normalized = normalizeInput(input);
+ * // current_step: recommended_tools exists (plural form)
+ * // previous_steps[0]: confidence=0.5, priority=999, expected_outcome='' filled in
+ * ```
+ */
+export declare function normalizeInput(input: unknown): ThoughtData;
+//# sourceMappingURL=InputNormalizer.d.ts.map

package/dist/core/InputNormalizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InputNormalizer.d.ts","sourceRoot":"","sources":["../../src/core/InputNormalizer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAiBhD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAuBzD;AAcD;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CASzD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAQvE;AA6JD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAsD7E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,WAAW,CAiD1D"}

package/dist/core/InputNormalizer.js

@@ -0,0 +1,101 @@
+import { ValidationError } from "../errors.js";
+import { sanitizeString } from "../sanitize.js";
+const DEFAULT_TOOL_CONFIDENCE = 0.5;
+const DEFAULT_TOOL_PRIORITY = 999;
+const DEFAULT_TOOL_RATIONALE = '';
+const DEFAULT_STEP_OUTCOME = '';
+const DEFAULT_SKILL_CONFIDENCE = 0.5;
+const DEFAULT_SKILL_PRIORITY = 999;
+const DEFAULT_SKILL_RATIONALE = '';
+function sanitizeRecursive(value) {
+    if (null == value) return value;
+    if ('string' == typeof value) return sanitizeString(value);
+    if (Array.isArray(value)) return value.map((item)=>sanitizeRecursive(item));
+    if ('object' == typeof value) {
+        const proto = Object.getPrototypeOf(value);
+        if (proto !== Object.prototype && null !== proto) return value;
+        const result = {};
+        for (const [key, val] of Object.entries(value))result[key] = sanitizeRecursive(val);
+        return result;
+    }
+    return value;
+}
+const BRANCH_ID_PATTERN = /^[a-zA-Z0-9_-]{1,64}$/;
+const SESSION_ID_PATTERN = /^[a-zA-Z0-9_-]{1,100}$/;
+function sanitizeBranchId(branchId) {
+    if (!BRANCH_ID_PATTERN.test(branchId)) throw new ValidationError('branch_id', 'Invalid format - must be 1-64 alphanumeric characters, hyphens, or underscores only');
+    return branchId;
+}
+function sanitizeSessionId(sessionId) {
+    const cleaned = sanitizeString(sessionId);
+    if (!SESSION_ID_PATTERN.test(cleaned)) return;
+    return cleaned;
+}
+function normalizeToolRecommendation(tool) {
+    const normalized = {
+        ...tool
+    };
+    if (!('confidence' in normalized) || void 0 === normalized.confidence) normalized.confidence = DEFAULT_TOOL_CONFIDENCE;
+    if (!('priority' in normalized) || void 0 === normalized.priority) normalized.priority = DEFAULT_TOOL_PRIORITY;
+    if (!('rationale' in normalized) || void 0 === normalized.rationale) normalized.rationale = DEFAULT_TOOL_RATIONALE;
+    return normalized;
+}
+function normalizeSkillRecommendation(skill) {
+    const normalized = {
+        ...skill
+    };
+    if (!('confidence' in normalized) || void 0 === normalized.confidence) normalized.confidence = DEFAULT_SKILL_CONFIDENCE;
+    if (!('priority' in normalized) || void 0 === normalized.priority) normalized.priority = DEFAULT_SKILL_PRIORITY;
+    if (!('rationale' in normalized) || void 0 === normalized.rationale) normalized.rationale = DEFAULT_SKILL_RATIONALE;
+    return normalized;
+}
+function normalizeStepRecommendation(step, lenient) {
+    const normalized = {
+        ...step
+    };
+    if ('recommended_tool' in normalized && !('recommended_tools' in normalized)) {
+        normalized.recommended_tools = normalized.recommended_tool;
+        delete normalized.recommended_tool;
+    }
+    if ('recommended_skill' in normalized && !('recommended_skills' in normalized)) {
+        normalized.recommended_skills = normalized.recommended_skill;
+        delete normalized.recommended_skill;
+    }
+    if (Array.isArray(normalized.recommended_tools)) normalized.recommended_tools = normalized.recommended_tools.map((tool)=>'object' == typeof tool && null !== tool ? normalizeToolRecommendation(tool) : tool);
+    if (Array.isArray(normalized.recommended_skills)) normalized.recommended_skills = normalized.recommended_skills.map((skill)=>'object' == typeof skill && null !== skill ? normalizeSkillRecommendation(skill) : skill);
+    if (lenient && !('expected_outcome' in normalized)) normalized.expected_outcome = DEFAULT_STEP_OUTCOME;
+    return normalized;
+}
+function normalizeReasoningFields(input) {
+    if (!('thought_type' in input) || void 0 === input.thought_type) input.thought_type = 'regular';
+    if ('number' == typeof input.quality_score) input.quality_score = Math.max(0, Math.min(1, input.quality_score));
+    if ('number' == typeof input.confidence) input.confidence = Math.max(0, Math.min(1, input.confidence));
+    if ('string' == typeof input.hypothesis_id) input.hypothesis_id = sanitizeBranchId(input.hypothesis_id);
+    if (Array.isArray(input.synthesis_sources)) input.synthesis_sources = input.synthesis_sources.filter((v)=>'number' == typeof v && Number.isInteger(v) && v > 0);
+    if (Array.isArray(input.merge_from_thoughts)) input.merge_from_thoughts = input.merge_from_thoughts.filter((v)=>'number' == typeof v && Number.isInteger(v) && v > 0);
+    if (Array.isArray(input.merge_branch_ids)) input.merge_branch_ids = input.merge_branch_ids.map((id)=>{
+        if ('string' == typeof id) return sanitizeBranchId(id);
+        return id;
+    });
+    if (('hypothesis' === input.thought_type || 'verification' === input.thought_type) && !('reasoning_depth' in input)) input.reasoning_depth = 'moderate';
+}
+function normalizeInput(input) {
+    if ('object' != typeof input || null === input) return input;
+    const normalized = {
+        ...input
+    };
+    if (normalized.current_step && 'object' == typeof normalized.current_step) normalized.current_step = normalizeStepRecommendation(normalized.current_step, false);
+    if (Array.isArray(normalized.previous_steps) && normalized.previous_steps.length > 0) normalized.previous_steps = normalized.previous_steps.map((step)=>'object' == typeof step && null !== step ? normalizeStepRecommendation(step, true) : step);
+    if ('string' == typeof normalized.branch_id) normalized.branch_id = sanitizeBranchId(normalized.branch_id);
+    if ('string' == typeof normalized.session_id) {
+        const sanitized = sanitizeSessionId(normalized.session_id);
+        if (void 0 === sanitized) delete normalized.session_id;
+        else normalized.session_id = sanitized;
+    }
+    normalizeReasoningFields(normalized);
+    const sanitized = sanitizeRecursive(normalized);
+    return sanitized;
+}
+export { normalizeInput, normalizeReasoningFields, sanitizeBranchId, sanitizeRecursive, sanitizeSessionId };
+
+//# sourceMappingURL=InputNormalizer.js.map

package/dist/core/InputNormalizer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"core/InputNormalizer.js","sources":["../../src/core/InputNormalizer.ts"],"sourcesContent":["/**\n * Input normalization for common LLM field name mistakes.\n *\n * This module provides normalization logic to handle common mistakes\n * that LLMs make when generating field names, such as using singular\n * instead of plural forms (e.g., `recommended_tool` vs `recommended_tools`).\n *\n * It also fills in sensible defaults for missing fields in `previous_steps`,\n * which LLMs naturally provide as partial/skeletal data (historical context).\n *\n * @module processor\n */\n\nimport { ValidationError } from '../errors.js';\nimport { sanitizeString } from '../sanitize.js';\nimport type { ThoughtData } from './thought.js';\n\n/**\n * Default values for missing partial tool recommendation fields.\n */\nconst DEFAULT_TOOL_CONFIDENCE = 0.5;\nconst DEFAULT_TOOL_PRIORITY = 999;\nconst DEFAULT_TOOL_RATIONALE = '';\nconst DEFAULT_STEP_OUTCOME = '';\n\n/**\n * Default values for missing skill recommendation fields.\n */\nconst DEFAULT_SKILL_CONFIDENCE = 0.5;\nconst DEFAULT_SKILL_PRIORITY = 999;\nconst DEFAULT_SKILL_RATIONALE = '';\n\n/**\n * Recursively sanitizes all string values within an unknown structure.\n * Walks into plain objects and arrays to reach deeply nested strings.\n * Non-plain objects (Date, RegExp, etc.) are returned as-is.\n *\n * @param value - The value to sanitize recursively\n * @returns The sanitized value with all nested strings cleaned\n *\n * @example\n * ```typescript\n * sanitizeRecursive('<script>x</script>'); // 'x'\n * sanitizeRecursive({ a: { b: '<iframe>y' } }); // { a: { b: 'y' } }\n * sanitizeRecursive(['a\\x00b', 42]); // ['ab', 42]\n * ```\n */\nexport function sanitizeRecursive(value: unknown): unknown {\n\tif (value === null || value === undefined) {\n\t\treturn value;\n\t}\n\tif (typeof value === 'string') {\n\t\treturn sanitizeString(value);\n\t}\n\tif (Array.isArray(value)) {\n\t\treturn value.map((item) => sanitizeRecursive(item));\n\t}\n\tif (typeof value === 'object') {\n\t\t// Only recurse into plain objects — skip Date, RegExp, Map, Set, etc.\n\t\tconst proto = Object.getPrototypeOf(value);\n\t\tif (proto !== Object.prototype && proto !== null) {\n\t\t\treturn value;\n\t\t}\n\t\tconst result: Record<string, unknown> = {};\n\t\tfor (const [key, val] of Object.entries(value as Record<string, unknown>)) {\n\t\t\tresult[key] = sanitizeRecursive(val);\n\t\t}\n\t\treturn result;\n\t}\n\treturn value;\n}\n\n/**\n * Valid branch ID pattern: alphanumeric, hyphens, underscores only.\n * Prevents path traversal attacks by rejecting special characters like / . \\ etc.\n */\nconst BRANCH_ID_PATTERN = /^[a-zA-Z0-9_-]{1,64}$/;\n\n/**\n * Valid session ID pattern: alphanumeric, hyphens, underscores, 1-100 chars.\n * Same as branch_id but with longer max length to allow compound identifiers.\n */\nconst SESSION_ID_PATTERN = /^[a-zA-Z0-9_-]{1,100}$/;\n\n/**\n * Sanitizes and validates a branch ID to prevent path traversal attacks.\n *\n * @param branchId - The branch ID to sanitize\n * @returns The sanitized branch ID\n * @throws ValidationError if the branch ID contains invalid characters\n *\n * @example\n * ```typescript\n * sanitizeBranchId('my-branch_01'); // 'my-branch_01'\n * sanitizeBranchId('../etc/passwd'); // throws ValidationError\n * ```\n */\nexport function sanitizeBranchId(branchId: string): string {\n\t// Validate format\n\tif (!BRANCH_ID_PATTERN.test(branchId)) {\n\t\tthrow new ValidationError(\n\t\t\t'branch_id',\n\t\t\t'Invalid format - must be 1-64 alphanumeric characters, hyphens, or underscores only'\n\t\t);\n\t}\n\treturn branchId;\n}\n\n/**\n * Sanitizes and validates a session ID.\n *\n * @param sessionId - The session ID to sanitize\n * @returns The sanitized session ID, or undefined if invalid after sanitization\n *\n * @example\n * ```typescript\n * sanitizeSessionId('analysis-task-42'); // 'analysis-task-42'\n * sanitizeSessionId('bad session!'); // undefined (stripped)\n * ```\n */\nexport function sanitizeSessionId(sessionId: string): string | undefined {\n\t// First sanitize control characters\n\tconst cleaned = sanitizeString(sessionId);\n\t// Validate format after sanitization\n\tif (!SESSION_ID_PATTERN.test(cleaned)) {\n\t\treturn undefined;\n\t}\n\treturn cleaned;\n}\n\n/**\n * Normalizes tool recommendation objects with default values.\n * Normalizes tool recommendation objects with default values.\n *\n * Fills in sensible defaults for missing optional fields:\n * - `confidence`: 0.5\n * - `priority`: 999\n * - `rationale`: empty string\n *\n * @param tool - The tool recommendation to normalize\n * @returns The normalized tool recommendation with defaults filled in\n *\n * @example\n * ```typescript\n * const input = { tool_name: 'Read', rationale: 'Read the file' };\n * const normalized = normalizeToolRecommendation(input);\n * // { tool_name: 'Read', rationale: 'Read the file', confidence: 0.5, priority: 999 }\n * ```\n */\nfunction normalizeToolRecommendation(tool: Record<string, unknown>): Record<string, unknown> {\n\tconst normalized: Record<string, unknown> = { ...tool };\n\n\t// Fill in default confidence if missing\n\tif (!('confidence' in normalized) || normalized.confidence === undefined) {\n\t\tnormalized.confidence = DEFAULT_TOOL_CONFIDENCE;\n\t}\n\n\t// Fill in default priority if missing\n\tif (!('priority' in normalized) || normalized.priority === undefined) {\n\t\tnormalized.priority = DEFAULT_TOOL_PRIORITY;\n\t}\n\n\t// Fill in default rationale if missing\n\tif (!('rationale' in normalized) || normalized.rationale === undefined) {\n\t\tnormalized.rationale = DEFAULT_TOOL_RATIONALE;\n\t}\n\n\treturn normalized;\n}\n\n/**\n * Normalizes skill recommendation objects with default values.\n *\n * Fills in sensible defaults for missing optional fields:\n * - `confidence`: 0.5\n * - `priority`: 999\n * - `rationale`: empty string\n *\n * @param skill - The skill recommendation to normalize\n * @returns The normalized skill recommendation with defaults filled in\n *\n * @example\n * ```typescript\n * const input = { skill_name: 'ast-grep' };\n * const normalized = normalizeSkillRecommendation(input);\n * // { skill_name: 'ast-grep', confidence: 0.5, priority: 999, rationale: '' }\n * ```\n */\nfunction normalizeSkillRecommendation(skill: Record<string, unknown>): Record<string, unknown> {\n\tconst normalized: Record<string, unknown> = { ...skill };\n\n\t// Fill in default confidence if missing\n\tif (!('confidence' in normalized) || normalized.confidence === undefined) {\n\t\tnormalized.confidence = DEFAULT_SKILL_CONFIDENCE;\n\t}\n\n\t// Fill in default priority if missing\n\tif (!('priority' in normalized) || normalized.priority === undefined) {\n\t\tnormalized.priority = DEFAULT_SKILL_PRIORITY;\n\t}\n\n\t// Fill in default rationale if missing\n\tif (!('rationale' in normalized) || normalized.rationale === undefined) {\n\t\tnormalized.rationale = DEFAULT_SKILL_RATIONALE;\n\t}\n\n\treturn normalized;\n}\n/**\n * Normalizes step recommendation objects.\n *\n * Handles common field name mistakes:\n * - `recommended_tool` (singular) → `recommended_tools` (plural)\n * - `recommended_skill` (singular) → `recommended_skills` (plural)\n *\n * Also normalizes tool recommendations within the step to fill in defaults.\n *\n * @param step - The step recommendation to normalize\n * @param lenient - Whether to use lenient mode (fill in defaults for missing fields)\n * @returns The normalized step recommendation\n *\n * @example\n * ```typescript\n * // Strict mode (for current_step)\n * const input = {\n *   step_description: 'Analyze data',\n *   recommended_tool: [{ tool_name: 'Read', confidence: 0.9, rationale: 'test', priority: 1 }],\n *   expected_outcome: 'Data analyzed'\n * };\n * const normalized = normalizeStepRecommendation(input, false);\n * // normalized.recommended_tools exists (plural form)\n *\n * // Lenient mode (for previous_steps)\n * const partialInput = {\n *   step_description: 'Read file',\n *   recommended_tools: [{ tool_name: 'Read', rationale: 'Read file' }]\n * };\n * const normalized = normalizeStepRecommendation(partialInput, true);\n * // confidence: 0.5, priority: 999, expected_outcome: '' filled in\n * ```\n */\nfunction normalizeStepRecommendation(\n\tstep: Record<string, unknown>,\n\tlenient: boolean\n): Record<string, unknown> {\n\tconst normalized: Record<string, unknown> = { ...step };\n\n\t// Transform `recommended_tool` (singular) → `recommended_tools` (plural)\n\tif ('recommended_tool' in normalized && !('recommended_tools' in normalized)) {\n\t\tnormalized.recommended_tools = normalized.recommended_tool;\n\t\tdelete normalized.recommended_tool;\n\t}\n\n\t// Transform `recommended_skill` (singular) → `recommended_skills` (plural)\n\tif ('recommended_skill' in normalized && !('recommended_skills' in normalized)) {\n\t\tnormalized.recommended_skills = normalized.recommended_skill;\n\t\tdelete normalized.recommended_skill;\n\t}\n\n\t// Normalize recommended_tools array if present\n\tif (Array.isArray(normalized.recommended_tools)) {\n\t\tnormalized.recommended_tools = normalized.recommended_tools.map((tool) =>\n\t\t\ttypeof tool === 'object' && tool !== null\n\t\t\t\t? normalizeToolRecommendation(tool as Record<string, unknown>)\n\t\t\t\t: tool\n\t\t);\n\t}\n\n\t// Normalize recommended_skills array if present\n\tif (Array.isArray(normalized.recommended_skills)) {\n\t\tnormalized.recommended_skills = normalized.recommended_skills.map((skill) =>\n\t\t\ttypeof skill === 'object' && skill !== null\n\t\t\t\t? normalizeSkillRecommendation(skill as Record<string, unknown>)\n\t\t\t\t: skill\n\t\t);\n\t}\n\t// In lenient mode, fill in default expected_outcome if missing\n\tif (lenient && !('expected_outcome' in normalized)) {\n\t\tnormalized.expected_outcome = DEFAULT_STEP_OUTCOME;\n\t}\n\n\treturn normalized;\n}\n\n\n/**\n * Normalizes reasoning-specific fields on a thought input object.\n * Always applies reasoning normalization — reasoning is the default pipeline.\n * Applies the following normalization rules:\n * - Defaults `thought_type` to `'regular'` if not provided\n * - Clamps `quality_score` to [0, 1] range\n * - Clamps `confidence` to [0, 1] range\n * - Sanitizes `hypothesis_id` using `sanitizeBranchId` pattern\n * - Filters `synthesis_sources` to positive integers only\n * - Filters `merge_from_thoughts` to positive integers only\n * - Sanitizes each entry in `merge_branch_ids`\n * - Defaults `reasoning_depth` to `'moderate'` for hypothesis/verification types\n *\n * @param input - The mutable normalized input object to apply reasoning defaults to\n *\n * @example\n * ```typescript\n * const input: Record<string, unknown> = { thought_type: 'hypothesis', quality_score: 1.5 };\n * normalizeReasoningFields(input);\n * // input.quality_score === 1, input.reasoning_depth === 'moderate'\n * ```\n */\nexport function normalizeReasoningFields(input: Record<string, unknown>): void {\n\t// Always apply reasoning field normalization — reasoning is the default pipeline\n\t// Default thought_type to 'regular'\n\n\tif (!('thought_type' in input) || input.thought_type === undefined) {\n\t\tinput.thought_type = 'regular';\n\t}\n\n\t// Clamp quality_score to [0, 1]\n\tif (typeof input.quality_score === 'number') {\n\t\tinput.quality_score = Math.max(0, Math.min(1, input.quality_score));\n\t}\n\n\t// Clamp confidence to [0, 1]\n\tif (typeof input.confidence === 'number') {\n\t\tinput.confidence = Math.max(0, Math.min(1, input.confidence));\n\t}\n\n\t// Sanitize hypothesis_id (same rules as branch_id)\n\tif (typeof input.hypothesis_id === 'string') {\n\t\tinput.hypothesis_id = sanitizeBranchId(input.hypothesis_id);\n\t}\n\n\t// Filter synthesis_sources to positive integers only\n\tif (Array.isArray(input.synthesis_sources)) {\n\t\tinput.synthesis_sources = input.synthesis_sources.filter(\n\t\t\t(v: unknown) => typeof v === 'number' && Number.isInteger(v) && v > 0\n\t\t);\n\t}\n\n\t// Filter merge_from_thoughts to positive integers only\n\tif (Array.isArray(input.merge_from_thoughts)) {\n\t\tinput.merge_from_thoughts = input.merge_from_thoughts.filter(\n\t\t\t(v: unknown) => typeof v === 'number' && Number.isInteger(v) && v > 0\n\t\t);\n\t}\n\n\t// Sanitize merge_branch_ids entries\n\tif (Array.isArray(input.merge_branch_ids)) {\n\t\tinput.merge_branch_ids = input.merge_branch_ids.map((id: unknown) => {\n\t\t\tif (typeof id === 'string') {\n\t\t\t\treturn sanitizeBranchId(id);\n\t\t\t}\n\t\t\treturn id;\n\t\t});\n\t}\n\n\t// Default reasoning_depth to 'moderate' for hypothesis/verification types\n\tif (\n\t\t(input.thought_type === 'hypothesis' || input.thought_type === 'verification') &&\n\t\t!('reasoning_depth' in input)\n\t) {\n\t\tinput.reasoning_depth = 'moderate';\n\t}\n}\n\n/**\n * Normalizes thought input data by fixing common LLM field name mistakes.\n *\n * This function handles cases where LLMs incorrectly use singular forms\n * of field names that should be plural. It applies normalization to both\n * `current_step` and `previous_steps` fields.\n *\n * The normalization is applied BEFORE schema validation, allowing the\n * strict Valibot schema to remain correct while still being tolerant\n * of common LLM mistakes.\n *\n * @param input - The raw thought input data to normalize\n * @returns Normalized thought data with correct field names\n *\n * @remarks\n * **Normalization Rules:**\n * - `recommended_tool` (singular) → `recommended_tools` (plural)\n * - `recommended_skill` (singular) → `recommended_skills` (plural)\n * - Applied to `current_step` if present (strict mode)\n * - Applied to all items in `previous_steps` if present (lenient mode with defaults)\n *\n * **Design Rationale:**\n * LLMs sometimes use singular field names even when the schema explicitly\n * defines plural forms. Rather than forcing the LLM to be perfect (which\n * leads to cryptic validation errors), we normalize the input to handle\n * these common mistakes gracefully.\n *\n * Additionally, LLMs naturally provide complete data for `current_step`\n * but only partial/skeletal data for `previous_steps` (historical context).\n * The lenient mode for `previous_steps` fills in sensible defaults:\n * - `confidence`: 0.5 for missing tool recommendation confidence\n * - `priority`: 999 for missing tool recommendation priority\n * - `rationale`: empty string for missing tool recommendation rationale\n * - `expected_outcome`: empty string for missing step expected outcome\n *\n * @example\n * ```typescript\n * const input = {\n *   thought: 'I need to analyze the data',\n *   thought_number: 1,\n *   total_thoughts: 3,\n *   next_thought_needed: true,\n *   current_step: {\n *     step_description: 'Read the data file',\n *     recommended_tool: [{ tool_name: 'Read', confidence: 0.9, rationale: 'test', priority: 1 }],\n *     expected_outcome: 'Data loaded'\n *   },\n *   previous_steps: [{\n *     step_description: 'Previous step',\n *     recommended_tools: [{ tool_name: 'Grep', rationale: 'Search code' }]\n *   }]\n * };\n *\n * const normalized = normalizeInput(input);\n * // current_step: recommended_tools exists (plural form)\n * // previous_steps[0]: confidence=0.5, priority=999, expected_outcome='' filled in\n * ```\n */\nexport function normalizeInput(input: unknown): ThoughtData {\n\tif (typeof input !== 'object' || input === null) {\n\t\treturn input as ThoughtData;\n\t}\n\n\tconst normalized = { ...input } as Record<string, unknown>;\n\n\t// Normalize current_step if present (strict mode - no defaults)\n\tif (normalized.current_step && typeof normalized.current_step === 'object') {\n\t\tnormalized.current_step = normalizeStepRecommendation(\n\t\t\tnormalized.current_step as Record<string, unknown>,\n\t\t\tfalse // strict mode\n\t\t);\n\t}\n\n\n\t// Normalize all items in previous_steps if present (lenient mode - with defaults)\n\tif (Array.isArray(normalized.previous_steps) && normalized.previous_steps.length > 0) {\n\t\tnormalized.previous_steps = normalized.previous_steps.map((step) =>\n\t\t\ttypeof step === 'object' && step !== null\n\t\t\t\t? normalizeStepRecommendation(step as Record<string, unknown>, true) // lenient mode\n\t\t\t\t: step\n\t\t);\n\t}\n\n\t// Sanitize branch_id to prevent path traversal attacks\n\tif (typeof normalized.branch_id === 'string') {\n\t\tnormalized.branch_id = sanitizeBranchId(normalized.branch_id);\n\t}\n\n\t// Sanitize session_id (same pattern as branch_id but allows 1-100 chars)\n\tif (typeof normalized.session_id === 'string') {\n\t\tconst sanitized = sanitizeSessionId(normalized.session_id);\n\t\tif (sanitized === undefined) {\n\t\t\tdelete normalized.session_id;\n\t\t} else {\n\t\t\tnormalized.session_id = sanitized;\n\t\t}\n\t}\n\n\t// Normalize reasoning fields\n\tnormalizeReasoningFields(normalized);\n\n\n\t// Sanitize all free-text string fields recursively (dangerous HTML tags + null bytes)\n\t// This was moved from schema transforms because v.transform() cannot be converted to JSON Schema\n\tconst sanitized = sanitizeRecursive(normalized);\n\n\treturn sanitized as unknown as ThoughtData;\n}\n"],"names":["DEFAULT_TOOL_CONFIDENCE","DEFAULT_TOOL_PRIORITY","DEFAULT_TOOL_RATIONALE","DEFAULT_STEP_OUTCOME","DEFAULT_SKILL_CONFIDENCE","DEFAULT_SKILL_PRIORITY","DEFAULT_SKILL_RATIONALE","sanitizeRecursive","value","sanitizeString","Array","item","proto","Object","result","key","val","BRANCH_ID_PATTERN","SESSION_ID_PATTERN","sanitizeBranchId","branchId","ValidationError","sanitizeSessionId","sessionId","cleaned","normalizeToolRecommendation","tool","normalized","undefined","normalizeSkillRecommendation","skill","normalizeStepRecommendation","step","lenient","normalizeReasoningFields","input","Math","v","Number","id","normalizeInput","sanitized"],"mappings":"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"}

package/dist/core/ThoughtEvaluator.d.ts

@@ -0,0 +1,127 @@
+/**
+ * Quality signal computation for sequential thinking.
+ *
+ * Provides the {@link ThoughtEvaluator} class — a stateless service that computes
+ * confidence signals and reasoning analytics from thought history. Follows the
+ * ThoughtFormatter pattern as a composed dependency of ThoughtProcessor.
+ *
+ * @module core/evaluator
+ */
+import type { ConfidenceSignals, PatternSignal, ReasoningStats } from './reasoning.js';
+import type { ThoughtData } from './thought.js';
+/**
+ * Stateless service that computes quality signals and reasoning analytics
+ * from thought history and branch data.
+ *
+ * @remarks
+ * All methods are pure computations — no side effects, no I/O, no internal state.
+ * Designed to be registered as transient in the DI container.
+ *
+ * @example
+ * ```typescript
+ * const evaluator = new ThoughtEvaluator();
+ *
+ * const signals = evaluator.computeConfidenceSignals(history, branches);
+ * console.log(signals.reasoning_depth); // 5
+ *
+ * const stats = evaluator.computeReasoningStats(history, branches);
+ * console.log(stats.total_thoughts); // 12
+ * ```
+ */
+export declare class ThoughtEvaluator {
+    /**
+     * Compute confidence signals from history context.
+     * Pure computation — no side effects, no I/O.
+     *
+     * @param history - All thoughts in the current session
+     * @param branches - Map of branch IDs to their thought arrays
+     * @returns Computed confidence signals reflecting reasoning quality
+     *
+     * @example
+     * ```typescript
+     * const evaluator = new ThoughtEvaluator();
+ * const signals = evaluator.computeConfidenceSignals(
+ *   [thought1, thought2, thought3],
+ *   { 'branch-a': [branchThought1] }
+ * );
+     *
+     * console.log(signals.reasoning_depth);   // 3
+     * console.log(signals.branch_count);      // 1
+     * console.log(signals.has_hypothesis);    // false
+     * console.log(signals.average_confidence); // 0.85 or null
+     * ```
+     */
+    computeConfidenceSignals(history: ThoughtData[], branches: Record<string, ThoughtData[]>): ConfidenceSignals;
+    /**
+     * Compute aggregated reasoning analytics.
+     * Pure computation from history + branches.
+     *
+     * @param history - All thoughts in the current session
+     * @param branches - Map of branch IDs to their thought arrays
+     * @returns Aggregated reasoning statistics for the session
+     *
+     * @example
+     * ```typescript
+     * const evaluator = new ThoughtEvaluator();
+     * const stats = evaluator.computeReasoningStats(
+     *   [thought1, thought2, hypothesisThought, verificationThought],
+     *   { 'explore-a': [branchThought] }
+     * );
+     *
+     * console.log(stats.total_thoughts);              // 4
+     * console.log(stats.total_branches);              // 1
+     * console.log(stats.hypothesis_count);            // 1
+     * console.log(stats.verified_hypothesis_count);   // 1
+     * console.log(stats.average_quality_score);       // 0.78 or null
+     * ```
+     */
+    computeReasoningStats(history: ThoughtData[], branches: Record<string, ThoughtData[]>): ReasoningStats;
+    /**
+ * Detect reasoning patterns (anti-patterns and positive signals) from history.
+ * Pure computation — no side effects, no I/O.
+ *
+ * Detected patterns:
+ * - `consecutive_without_verification` (warning) — 3+ consecutive regular thoughts without a verification step
+ * - `unverified_hypothesis` (warning) — hypothesis not verified within 3 subsequent thoughts
+ * - `no_alternatives_explored` (info) — 5+ thoughts with no critique and no branches
+ * - `monotonic_type` (info) — 4+ consecutive thoughts with the same thought_type (requires ≥1 explicit type and ≥5 thoughts)
+ * - `confidence_drift` (warning) — 3+ consecutive thoughts with strictly decreasing confidence
+ * - `healthy_verification` (info) — hypothesis verified within 3 subsequent thoughts
+ *
+ * @param history - All thoughts in the current session
+ * @param branches - Map of branch IDs to their thought arrays
+ * @returns Array of detected pattern signals, possibly empty
+ *
+ * @example
+ * ```typescript
+ * const evaluator = new ThoughtEvaluator();
+ * const patterns = evaluator.computePatternSignals(history, branches);
+ * const warnings = patterns.filter(p => p.severity === 'warning');
+ * ```
+ */
+    computePatternSignals(history: ThoughtData[], branches: Record<string, ThoughtData[]>): PatternSignal[];
+    /** Detect runs of 3+ consecutive thoughts without verification. */
+    private _detectConsecutiveWithoutVerification;
+    /** Detect hypothesis thoughts not verified within 3 subsequent thoughts. */
+    private _detectUnverifiedHypothesis;
+    /** Detect 5+ thoughts with no critique and no branches. */
+    private _detectNoAlternativesExplored;
+    /**
+     * Detect runs of 4+ consecutive thoughts with the same thought_type.
+     * Only fires when history has ≥5 thoughts and at least one explicitly set thought_type.
+     */
+    private _detectMonotonicType;
+    /** Detect runs of 3+ consecutive thoughts with strictly decreasing confidence. */
+    private _detectConfidenceDrift;
+    /** Detect hypothesis verified within 3 subsequent thoughts — positive signal. */
+    private _detectHealthyVerification;
+    /** Count thoughts by type across history. */
+    private _countByType;
+    /** Find longest sequential chain depth (contiguous thoughts without branching). */
+    private _computeChainDepth;
+    /** Compute composite structural quality score from history. */
+    private _computeStructuralQuality;
+    /** Compute confidence stability: 1 - stddev(confidences). */
+    private _computeConfidenceStability;
+}
+//# sourceMappingURL=ThoughtEvaluator.d.ts.map

package/dist/core/ThoughtEvaluator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ThoughtEvaluator.d.ts","sourceRoot":"","sources":["../../src/core/ThoughtEvaluator.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,aAAa,EAAE,cAAc,EAAe,MAAM,gBAAgB,CAAC;AACpG,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAYhD;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,gBAAgB;IAC5B;;;;;;;;;;;;;;;;;;;;;OAqBG;IACI,wBAAwB,CAC9B,OAAO,EAAE,WAAW,EAAE,EACtB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,EAAE,CAAC,GACrC,iBAAiB;IAgCpB;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACI,qBAAqB,CAC3B,OAAO,EAAE,WAAW,EAAE,EACtB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,EAAE,CAAC,GACrC,cAAc;IAuCjB;;;;;;;;;;;;;;;;;;;;;;GAsBE;IACK,qBAAqB,CAC3B,OAAO,EAAE,WAAW,EAAE,EACtB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,EAAE,CAAC,GACrC,aAAa,EAAE;IAalB,mEAAmE;IACnE,OAAO,CAAC,qCAAqC;IAwB7C,4EAA4E;IAC5E,OAAO,CAAC,2BAA2B;IAqBnC,2DAA2D;IAC3D,OAAO,CAAC,6BAA6B;IAmBrC;;;OAGG;IACH,OAAO,CAAC,oBAAoB;IA2C5B,kFAAkF;IAClF,OAAO,CAAC,sBAAsB;IAmE9B,iFAAiF;IACjF,OAAO,CAAC,0BAA0B;IAyBlC,6CAA6C;IAC7C,OAAO,CAAC,YAAY;IAgBpB,mFAAmF;IACnF,OAAO,CAAC,kBAAkB;IAmB1B,+DAA+D;IAC/D,OAAO,CAAC,yBAAyB;IAiEjC,6DAA6D;IAC7D,OAAO,CAAC,2BAA2B;CAUnC"}