@iworkforces/tracelattice 2.0.3

package/dist/persistence/FileSnapshotTypes.d.ts

@@ -0,0 +1,29 @@
+import type { BranchId, SessionId } from '../contracts/ids.js';
+import type { Summary } from '../core/compression/Summary.js';
+import type { Edge } from '../core/graph/Edge.js';
+import type { ThoughtData } from '../core/thought.js';
+export type ThoughtSessionV2 = {
+    readonly sessionId: SessionId;
+    readonly thoughts: readonly ThoughtData[];
+};
+export type BranchRecordV2 = {
+    readonly sessionId: SessionId;
+    readonly branchId: BranchId;
+    readonly thoughts: readonly ThoughtData[];
+};
+export type EdgeSessionV2 = {
+    readonly sessionId: SessionId;
+    readonly edges: readonly Edge[];
+};
+export type SummarySessionV2 = {
+    readonly sessionId: SessionId;
+    readonly summaries: readonly Summary[];
+};
+export type FileSnapshotV2 = {
+    readonly version: 2;
+    readonly thoughts: readonly ThoughtSessionV2[];
+    readonly branches: readonly BranchRecordV2[];
+    readonly edges: readonly EdgeSessionV2[];
+    readonly summaries: readonly SummarySessionV2[];
+};
+//# sourceMappingURL=FileSnapshotTypes.d.ts.map

package/dist/persistence/FileSnapshotTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FileSnapshotTypes.d.ts","sourceRoot":"","sources":["../../src/persistence/FileSnapshotTypes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAC/D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gCAAgC,CAAC;AAC9D,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AAClD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEtD,MAAM,MAAM,gBAAgB,GAAG;IAC9B,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;IAC9B,QAAQ,CAAC,QAAQ,EAAE,SAAS,WAAW,EAAE,CAAC;CAC1C,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC5B,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;IAC9B,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,SAAS,WAAW,EAAE,CAAC;CAC1C,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAAE,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE,CAAA;CAAE,CAAC;AAC/F,MAAM,MAAM,gBAAgB,GAAG;IAC9B,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;IAC9B,QAAQ,CAAC,SAAS,EAAE,SAAS,OAAO,EAAE,CAAC;CACvC,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC5B,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC;IACpB,QAAQ,CAAC,QAAQ,EAAE,SAAS,gBAAgB,EAAE,CAAC;IAC/C,QAAQ,CAAC,QAAQ,EAAE,SAAS,cAAc,EAAE,CAAC;IAC7C,QAAQ,CAAC,KAAK,EAAE,SAAS,aAAa,EAAE,CAAC;IACzC,QAAQ,CAAC,SAAS,EAAE,SAAS,gBAAgB,EAAE,CAAC;CAChD,CAAC"}

package/dist/persistence/FileSnapshotTypes.js

@@ -0,0 +1 @@
+export { };

package/dist/persistence/FileSnapshotV2.d.ts

@@ -0,0 +1,377 @@
+import * as v from 'valibot';
+import type { SessionId } from '../contracts/ids.js';
+import type { ThoughtData } from '../core/thought.js';
+import type { FileSnapshotV2 } from './FileSnapshotTypes.js';
+export declare const FileSnapshotV2Schema: v.StrictObjectSchema<{
+    readonly version: v.LiteralSchema<2, undefined>;
+    readonly thoughts: v.ArraySchema<v.StrictObjectSchema<{
+        readonly sessionId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>;
+        readonly thoughts: v.ArraySchema<v.ObjectSchema<{
+            readonly available_mcp_tools: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string[], "Array of MCP tool names available for use (e.g., [\"mcp-omnisearch\", \"mcp-turso-cloud\"])">]>, undefined>;
+            readonly available_skills: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string[], "Array of skill names available for use (e.g., [\"commit\", \"review-pr\", \"pdf\"])">]>, undefined>;
+            readonly thought: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Your current thinking step">]>;
+            readonly id: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 30, undefined>, v.DescriptionAction<string, "Unique identifier for this thought. Auto-generated if not provided.">]>, undefined>;
+            readonly next_thought_needed: v.OptionalSchema<v.SchemaWithPipe<readonly [v.BooleanSchema<undefined>, v.DescriptionAction<boolean, "Whether another thought step is needed (defaults to true if not provided)">]>, undefined>;
+            readonly thought_number: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 1, undefined>, v.DescriptionAction<number, "Current thought number">]>;
+            readonly total_thoughts: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 1, undefined>, v.DescriptionAction<number, "Estimated total thoughts needed">]>;
+            readonly is_revision: v.OptionalSchema<v.SchemaWithPipe<readonly [v.BooleanSchema<undefined>, v.DescriptionAction<boolean, "Whether this revises previous thinking">]>, undefined>;
+            readonly revises_thought: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 1, undefined>, v.DescriptionAction<number, "Which thought is being reconsidered">]>, undefined>;
+            readonly branch_from_thought: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 1, undefined>, v.DescriptionAction<number, "Branching point thought number">]>, undefined>;
+            readonly branch_id: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "Branch ID must contain only letters, numbers, hyphens, and underscores">, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 50, undefined>, v.DescriptionAction<string, "Branch identifier (alphanumeric, hyphens, underscores only, max 50 chars)">]>, undefined>;
+            readonly needs_more_thoughts: v.OptionalSchema<v.SchemaWithPipe<readonly [v.BooleanSchema<undefined>, v.DescriptionAction<boolean, "If more thoughts are needed">]>, undefined>;
+            readonly current_step: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
+                readonly step_description: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "What needs to be done">]>;
+                readonly recommended_tools: v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
+                    readonly tool_name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Name of the tool being recommended">]>;
+                    readonly confidence: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>, v.DescriptionAction<number, "0-1 indicating confidence in recommendation">]>;
+                    readonly rationale: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 2000, undefined>, v.DescriptionAction<string, "Why this tool is recommended">]>;
+                    readonly priority: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "Order in the recommendation sequence (default: 999)">]>, undefined>;
+                    readonly suggested_inputs: v.OptionalSchema<v.SchemaWithPipe<readonly [v.RecordSchema<v.StringSchema<undefined>, v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>, v.BooleanSchema<undefined>, v.NullSchema<undefined>], undefined>, undefined>, v.DescriptionAction<{
+                        [x: string]: string | number | boolean | null;
+                    }, "Optional suggested parameters (flat key-value pairs only)">]>, undefined>;
+                    readonly alternatives: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string[], "Alternative tools that could be used">]>, undefined>;
+                }, undefined>, undefined>, v.DescriptionAction<{
+                    tool_name: string;
+                    confidence: number;
+                    rationale: string;
+                    priority?: number | undefined;
+                    suggested_inputs?: {
+                        [x: string]: string | number | boolean | null;
+                    } | undefined;
+                    alternatives?: string[] | undefined;
+                }[], "Tools recommended for this step">]>;
+                readonly recommended_skills: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
+                    readonly skill_name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Name of the skill being recommended">]>;
+                    readonly confidence: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>, v.DescriptionAction<number, "0-1 indicating confidence in recommendation (default: 0.5)">]>, undefined>;
+                    readonly rationale: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 2000, undefined>, v.DescriptionAction<string, "Why this skill is recommended (default: empty string)">]>, undefined>;
+                    readonly priority: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "Order in the recommendation sequence (default: 999)">]>, undefined>;
+                    readonly alternatives: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string[], "Alternative skills that could be used">]>, undefined>;
+                    readonly allowed_tools: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string[], "Tools this skill is allowed to use (from skill frontmatter)">]>, undefined>;
+                    readonly user_invocable: v.OptionalSchema<v.SchemaWithPipe<readonly [v.BooleanSchema<undefined>, v.DescriptionAction<boolean, "Whether this skill can be user-invoked">]>, undefined>;
+                }, undefined>, undefined>, v.DescriptionAction<{
+                    skill_name: string;
+                    confidence?: number | undefined;
+                    rationale?: string | undefined;
+                    priority?: number | undefined;
+                    alternatives?: string[] | undefined;
+                    allowed_tools?: string[] | undefined;
+                    user_invocable?: boolean | undefined;
+                }[], "Skills recommended for this step">]>, undefined>;
+                readonly expected_outcome: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "What to expect from this step">]>;
+                readonly next_step_conditions: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string[], "Conditions to consider for the next step">]>, undefined>;
+            }, undefined>, v.DescriptionAction<{
+                step_description: string;
+                recommended_tools: {
+                    tool_name: string;
+                    confidence: number;
+                    rationale: string;
+                    priority?: number | undefined;
+                    suggested_inputs?: {
+                        [x: string]: string | number | boolean | null;
+                    } | undefined;
+                    alternatives?: string[] | undefined;
+                }[];
+                recommended_skills?: {
+                    skill_name: string;
+                    confidence?: number | undefined;
+                    rationale?: string | undefined;
+                    priority?: number | undefined;
+                    alternatives?: string[] | undefined;
+                    allowed_tools?: string[] | undefined;
+                    user_invocable?: boolean | undefined;
+                }[] | undefined;
+                expected_outcome: string;
+                next_step_conditions?: string[] | undefined;
+            }, "Current step recommendation">]>, undefined>;
+            readonly previous_steps: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
+                readonly step_description: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "What needs to be done">]>;
+                readonly recommended_tools: v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
+                    readonly tool_name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Name of the tool being recommended">]>;
+                    readonly rationale: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 2000, undefined>, v.DescriptionAction<string, "Why this tool is recommended (default: empty string)">]>, undefined>;
+                    readonly confidence: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>, v.DescriptionAction<number, "0-1 indicating confidence in recommendation (default: 0.5)">]>, undefined>;
+                    readonly priority: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "Order in the recommendation sequence (default: 999)">]>, undefined>;
+                    readonly suggested_inputs: v.OptionalSchema<v.SchemaWithPipe<readonly [v.RecordSchema<v.StringSchema<undefined>, v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>, v.BooleanSchema<undefined>, v.NullSchema<undefined>], undefined>, undefined>, v.DescriptionAction<{
+                        [x: string]: string | number | boolean | null;
+                    }, "Optional suggested parameters (flat key-value pairs only)">]>, undefined>;
+                    readonly alternatives: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string[], "Alternative tools that could be used">]>, undefined>;
+                }, undefined>, undefined>, v.DescriptionAction<{
+                    tool_name: string;
+                    rationale?: string | undefined;
+                    confidence?: number | undefined;
+                    priority?: number | undefined;
+                    suggested_inputs?: {
+                        [x: string]: string | number | boolean | null;
+                    } | undefined;
+                    alternatives?: string[] | undefined;
+                }[], "Tools recommended for this step">]>;
+                readonly recommended_skills: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
+                    readonly skill_name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Name of the skill being recommended">]>;
+                    readonly confidence: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>, v.DescriptionAction<number, "0-1 indicating confidence in recommendation (default: 0.5)">]>, undefined>;
+                    readonly rationale: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 2000, undefined>, v.DescriptionAction<string, "Why this skill is recommended (default: empty string)">]>, undefined>;
+                    readonly priority: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "Order in the recommendation sequence (default: 999)">]>, undefined>;
+                    readonly alternatives: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string[], "Alternative skills that could be used">]>, undefined>;
+                    readonly allowed_tools: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string[], "Tools this skill is allowed to use (from skill frontmatter)">]>, undefined>;
+                    readonly user_invocable: v.OptionalSchema<v.SchemaWithPipe<readonly [v.BooleanSchema<undefined>, v.DescriptionAction<boolean, "Whether this skill can be user-invoked">]>, undefined>;
+                }, undefined>, undefined>, v.DescriptionAction<{
+                    skill_name: string;
+                    confidence?: number | undefined;
+                    rationale?: string | undefined;
+                    priority?: number | undefined;
+                    alternatives?: string[] | undefined;
+                    allowed_tools?: string[] | undefined;
+                    user_invocable?: boolean | undefined;
+                }[], "Skills recommended for this step">]>, undefined>;
+                readonly expected_outcome: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "What to expect from this step (default: empty string)">]>, undefined>;
+                readonly next_step_conditions: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string[], "Conditions to consider for the next step">]>, undefined>;
+            }, undefined>, undefined>, v.DescriptionAction<{
+                step_description: string;
+                recommended_tools: {
+                    tool_name: string;
+                    rationale?: string | undefined;
+                    confidence?: number | undefined;
+                    priority?: number | undefined;
+                    suggested_inputs?: {
+                        [x: string]: string | number | boolean | null;
+                    } | undefined;
+                    alternatives?: string[] | undefined;
+                }[];
+                recommended_skills?: {
+                    skill_name: string;
+                    confidence?: number | undefined;
+                    rationale?: string | undefined;
+                    priority?: number | undefined;
+                    alternatives?: string[] | undefined;
+                    allowed_tools?: string[] | undefined;
+                    user_invocable?: boolean | undefined;
+                }[] | undefined;
+                expected_outcome?: string | undefined;
+                next_step_conditions?: string[] | undefined;
+            }[], "Steps already recommended (lenient schema - allows partial data with defaults)">]>, undefined>;
+            readonly remaining_steps: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string[], "High-level descriptions of upcoming steps">]>, undefined>;
+            readonly thought_type: v.OptionalSchema<v.SchemaWithPipe<readonly [v.PicklistSchema<["regular", "hypothesis", "verification", "critique", "synthesis", "meta", "tool_call", "tool_observation", "assumption", "decomposition", "backtrack"], undefined>, v.DescriptionAction<"regular" | "hypothesis" | "verification" | "critique" | "synthesis" | "meta" | "tool_call" | "tool_observation" | "assumption" | "decomposition" | "backtrack", "Classified purpose: regular (default), hypothesis, verification, critique, synthesis, meta, tool_call (requires toolInterleave), tool_observation (requires toolInterleave), assumption (requires newThoughtTypes), decomposition (requires newThoughtTypes), backtrack (requires newThoughtTypes)">]>, undefined>;
+            readonly quality_score: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>, v.DescriptionAction<number, "Self-assessed quality score (0-1)">]>, undefined>;
+            readonly confidence: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>, v.DescriptionAction<number, "Explicit confidence in correctness (0-1)">]>, undefined>;
+            readonly hypothesis_id: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "Hypothesis ID must contain only letters, numbers, hyphens, and underscores">, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 50, undefined>, v.DescriptionAction<string, "Identifier linking hypothesis to verification thoughts">]>, undefined>;
+            readonly verification_target: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 1, undefined>, v.DescriptionAction<number, "Thought number being verified or critiqued">]>, undefined>;
+            readonly verification_result: v.OptionalSchema<v.SchemaWithPipe<readonly [v.UnionSchema<[v.LiteralSchema<0, undefined>, v.LiteralSchema<1, undefined>], undefined>, v.DescriptionAction<0 | 1, "Exact verification outcome label: 0 for incorrect, 1 for correct">]>, undefined>;
+            readonly synthesis_sources: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 1, undefined>]>, undefined>, v.DescriptionAction<number[], "Thought numbers being synthesized">]>, undefined>;
+            readonly merge_from_thoughts: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 1, undefined>]>, undefined>, v.DescriptionAction<number[], "Thought numbers from other branches being merged (DAG)">]>, undefined>;
+            readonly merge_branch_ids: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>, v.MaxLengthAction<string, 50, undefined>]>, undefined>, v.DescriptionAction<string[], "Branch IDs being merged into current context">]>, undefined>;
+            readonly meta_observation: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Metacognitive observation about reasoning process">]>, undefined>;
+            readonly reasoning_depth: v.OptionalSchema<v.SchemaWithPipe<readonly [v.PicklistSchema<["shallow", "moderate", "deep"], undefined>, v.DescriptionAction<"shallow" | "moderate" | "deep", "Effort signal: how deep reasoning should go">]>, undefined>;
+            readonly session_id: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "Session ID must contain only letters, numbers, hyphens, and underscores">, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 100, undefined>, v.DescriptionAction<string, "Optional session identifier for state isolation. When provided, thought history, branches, and statistics are scoped to this session. Omitting preserves global behavior.">]>, undefined>;
+            readonly reset_state: v.OptionalSchema<v.SchemaWithPipe<readonly [v.BooleanSchema<undefined>, v.DescriptionAction<boolean, "When true, clears all state for the target session before processing this thought. The thought is then processed as the first in a fresh session.">]>, undefined>;
+            readonly tool_name: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.DescriptionAction<string, "Name of the tool being invoked (for tool_call thoughts)">]>, undefined>;
+            readonly tool_arguments: v.OptionalSchema<v.SchemaWithPipe<readonly [v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, v.DescriptionAction<{
+                [x: string]: unknown;
+            }, "Arguments passed to the tool (for tool_call thoughts)">]>, undefined>;
+            readonly tool_result: v.OptionalSchema<v.SchemaWithPipe<readonly [v.UnknownSchema, v.DescriptionAction<unknown, "Result returned by the tool (for tool_observation thoughts)">]>, undefined>;
+            readonly continuation_token: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.DescriptionAction<string, "Token for resuming long-running tool invocations">]>, undefined>;
+            readonly decomposition_children: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string[], "Child thought IDs produced by decomposition">]>, undefined>;
+            readonly backtrack_target: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>, v.DescriptionAction<number, "Thought number to backtrack to. When the parent thought has thought_type=backtrack, this thought is logically retracted: it remains in history but is excluded from quality signals and reasoning stats.">]>, undefined>;
+            readonly register_branch_id: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "register_branch_id must contain only letters, numbers, hyphens, and underscores">, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 50, undefined>, v.DescriptionAction<string, "Pre-declares a branch ID for this session before any thoughts reference it. Useful so that subsequent thoughts using merge_branch_ids can target a branch that has not yet received any thoughts.">]>, undefined>;
+        }, undefined>, undefined>;
+    }, undefined>, undefined>;
+    readonly branches: v.ArraySchema<v.StrictObjectSchema<{
+        readonly sessionId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>;
+        readonly branchId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>;
+        readonly thoughts: v.ArraySchema<v.ObjectSchema<{
+            readonly available_mcp_tools: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string[], "Array of MCP tool names available for use (e.g., [\"mcp-omnisearch\", \"mcp-turso-cloud\"])">]>, undefined>;
+            readonly available_skills: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string[], "Array of skill names available for use (e.g., [\"commit\", \"review-pr\", \"pdf\"])">]>, undefined>;
+            readonly thought: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Your current thinking step">]>;
+            readonly id: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 30, undefined>, v.DescriptionAction<string, "Unique identifier for this thought. Auto-generated if not provided.">]>, undefined>;
+            readonly next_thought_needed: v.OptionalSchema<v.SchemaWithPipe<readonly [v.BooleanSchema<undefined>, v.DescriptionAction<boolean, "Whether another thought step is needed (defaults to true if not provided)">]>, undefined>;
+            readonly thought_number: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 1, undefined>, v.DescriptionAction<number, "Current thought number">]>;
+            readonly total_thoughts: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 1, undefined>, v.DescriptionAction<number, "Estimated total thoughts needed">]>;
+            readonly is_revision: v.OptionalSchema<v.SchemaWithPipe<readonly [v.BooleanSchema<undefined>, v.DescriptionAction<boolean, "Whether this revises previous thinking">]>, undefined>;
+            readonly revises_thought: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 1, undefined>, v.DescriptionAction<number, "Which thought is being reconsidered">]>, undefined>;
+            readonly branch_from_thought: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 1, undefined>, v.DescriptionAction<number, "Branching point thought number">]>, undefined>;
+            readonly branch_id: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "Branch ID must contain only letters, numbers, hyphens, and underscores">, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 50, undefined>, v.DescriptionAction<string, "Branch identifier (alphanumeric, hyphens, underscores only, max 50 chars)">]>, undefined>;
+            readonly needs_more_thoughts: v.OptionalSchema<v.SchemaWithPipe<readonly [v.BooleanSchema<undefined>, v.DescriptionAction<boolean, "If more thoughts are needed">]>, undefined>;
+            readonly current_step: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
+                readonly step_description: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "What needs to be done">]>;
+                readonly recommended_tools: v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
+                    readonly tool_name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Name of the tool being recommended">]>;
+                    readonly confidence: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>, v.DescriptionAction<number, "0-1 indicating confidence in recommendation">]>;
+                    readonly rationale: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 2000, undefined>, v.DescriptionAction<string, "Why this tool is recommended">]>;
+                    readonly priority: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "Order in the recommendation sequence (default: 999)">]>, undefined>;
+                    readonly suggested_inputs: v.OptionalSchema<v.SchemaWithPipe<readonly [v.RecordSchema<v.StringSchema<undefined>, v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>, v.BooleanSchema<undefined>, v.NullSchema<undefined>], undefined>, undefined>, v.DescriptionAction<{
+                        [x: string]: string | number | boolean | null;
+                    }, "Optional suggested parameters (flat key-value pairs only)">]>, undefined>;
+                    readonly alternatives: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string[], "Alternative tools that could be used">]>, undefined>;
+                }, undefined>, undefined>, v.DescriptionAction<{
+                    tool_name: string;
+                    confidence: number;
+                    rationale: string;
+                    priority?: number | undefined;
+                    suggested_inputs?: {
+                        [x: string]: string | number | boolean | null;
+                    } | undefined;
+                    alternatives?: string[] | undefined;
+                }[], "Tools recommended for this step">]>;
+                readonly recommended_skills: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
+                    readonly skill_name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Name of the skill being recommended">]>;
+                    readonly confidence: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>, v.DescriptionAction<number, "0-1 indicating confidence in recommendation (default: 0.5)">]>, undefined>;
+                    readonly rationale: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 2000, undefined>, v.DescriptionAction<string, "Why this skill is recommended (default: empty string)">]>, undefined>;
+                    readonly priority: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "Order in the recommendation sequence (default: 999)">]>, undefined>;
+                    readonly alternatives: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string[], "Alternative skills that could be used">]>, undefined>;
+                    readonly allowed_tools: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string[], "Tools this skill is allowed to use (from skill frontmatter)">]>, undefined>;
+                    readonly user_invocable: v.OptionalSchema<v.SchemaWithPipe<readonly [v.BooleanSchema<undefined>, v.DescriptionAction<boolean, "Whether this skill can be user-invoked">]>, undefined>;
+                }, undefined>, undefined>, v.DescriptionAction<{
+                    skill_name: string;
+                    confidence?: number | undefined;
+                    rationale?: string | undefined;
+                    priority?: number | undefined;
+                    alternatives?: string[] | undefined;
+                    allowed_tools?: string[] | undefined;
+                    user_invocable?: boolean | undefined;
+                }[], "Skills recommended for this step">]>, undefined>;
+                readonly expected_outcome: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "What to expect from this step">]>;
+                readonly next_step_conditions: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string[], "Conditions to consider for the next step">]>, undefined>;
+            }, undefined>, v.DescriptionAction<{
+                step_description: string;
+                recommended_tools: {
+                    tool_name: string;
+                    confidence: number;
+                    rationale: string;
+                    priority?: number | undefined;
+                    suggested_inputs?: {
+                        [x: string]: string | number | boolean | null;
+                    } | undefined;
+                    alternatives?: string[] | undefined;
+                }[];
+                recommended_skills?: {
+                    skill_name: string;
+                    confidence?: number | undefined;
+                    rationale?: string | undefined;
+                    priority?: number | undefined;
+                    alternatives?: string[] | undefined;
+                    allowed_tools?: string[] | undefined;
+                    user_invocable?: boolean | undefined;
+                }[] | undefined;
+                expected_outcome: string;
+                next_step_conditions?: string[] | undefined;
+            }, "Current step recommendation">]>, undefined>;
+            readonly previous_steps: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
+                readonly step_description: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "What needs to be done">]>;
+                readonly recommended_tools: v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
+                    readonly tool_name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Name of the tool being recommended">]>;
+                    readonly rationale: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 2000, undefined>, v.DescriptionAction<string, "Why this tool is recommended (default: empty string)">]>, undefined>;
+                    readonly confidence: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>, v.DescriptionAction<number, "0-1 indicating confidence in recommendation (default: 0.5)">]>, undefined>;
+                    readonly priority: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "Order in the recommendation sequence (default: 999)">]>, undefined>;
+                    readonly suggested_inputs: v.OptionalSchema<v.SchemaWithPipe<readonly [v.RecordSchema<v.StringSchema<undefined>, v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>, v.BooleanSchema<undefined>, v.NullSchema<undefined>], undefined>, undefined>, v.DescriptionAction<{
+                        [x: string]: string | number | boolean | null;
+                    }, "Optional suggested parameters (flat key-value pairs only)">]>, undefined>;
+                    readonly alternatives: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string[], "Alternative tools that could be used">]>, undefined>;
+                }, undefined>, undefined>, v.DescriptionAction<{
+                    tool_name: string;
+                    rationale?: string | undefined;
+                    confidence?: number | undefined;
+                    priority?: number | undefined;
+                    suggested_inputs?: {
+                        [x: string]: string | number | boolean | null;
+                    } | undefined;
+                    alternatives?: string[] | undefined;
+                }[], "Tools recommended for this step">]>;
+                readonly recommended_skills: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
+                    readonly skill_name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Name of the skill being recommended">]>;
+                    readonly confidence: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>, v.DescriptionAction<number, "0-1 indicating confidence in recommendation (default: 0.5)">]>, undefined>;
+                    readonly rationale: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 2000, undefined>, v.DescriptionAction<string, "Why this skill is recommended (default: empty string)">]>, undefined>;
+                    readonly priority: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "Order in the recommendation sequence (default: 999)">]>, undefined>;
+                    readonly alternatives: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string[], "Alternative skills that could be used">]>, undefined>;
+                    readonly allowed_tools: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string[], "Tools this skill is allowed to use (from skill frontmatter)">]>, undefined>;
+                    readonly user_invocable: v.OptionalSchema<v.SchemaWithPipe<readonly [v.BooleanSchema<undefined>, v.DescriptionAction<boolean, "Whether this skill can be user-invoked">]>, undefined>;
+                }, undefined>, undefined>, v.DescriptionAction<{
+                    skill_name: string;
+                    confidence?: number | undefined;
+                    rationale?: string | undefined;
+                    priority?: number | undefined;
+                    alternatives?: string[] | undefined;
+                    allowed_tools?: string[] | undefined;
+                    user_invocable?: boolean | undefined;
+                }[], "Skills recommended for this step">]>, undefined>;
+                readonly expected_outcome: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "What to expect from this step (default: empty string)">]>, undefined>;
+                readonly next_step_conditions: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string[], "Conditions to consider for the next step">]>, undefined>;
+            }, undefined>, undefined>, v.DescriptionAction<{
+                step_description: string;
+                recommended_tools: {
+                    tool_name: string;
+                    rationale?: string | undefined;
+                    confidence?: number | undefined;
+                    priority?: number | undefined;
+                    suggested_inputs?: {
+                        [x: string]: string | number | boolean | null;
+                    } | undefined;
+                    alternatives?: string[] | undefined;
+                }[];
+                recommended_skills?: {
+                    skill_name: string;
+                    confidence?: number | undefined;
+                    rationale?: string | undefined;
+                    priority?: number | undefined;
+                    alternatives?: string[] | undefined;
+                    allowed_tools?: string[] | undefined;
+                    user_invocable?: boolean | undefined;
+                }[] | undefined;
+                expected_outcome?: string | undefined;
+                next_step_conditions?: string[] | undefined;
+            }[], "Steps already recommended (lenient schema - allows partial data with defaults)">]>, undefined>;
+            readonly remaining_steps: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string[], "High-level descriptions of upcoming steps">]>, undefined>;
+            readonly thought_type: v.OptionalSchema<v.SchemaWithPipe<readonly [v.PicklistSchema<["regular", "hypothesis", "verification", "critique", "synthesis", "meta", "tool_call", "tool_observation", "assumption", "decomposition", "backtrack"], undefined>, v.DescriptionAction<"regular" | "hypothesis" | "verification" | "critique" | "synthesis" | "meta" | "tool_call" | "tool_observation" | "assumption" | "decomposition" | "backtrack", "Classified purpose: regular (default), hypothesis, verification, critique, synthesis, meta, tool_call (requires toolInterleave), tool_observation (requires toolInterleave), assumption (requires newThoughtTypes), decomposition (requires newThoughtTypes), backtrack (requires newThoughtTypes)">]>, undefined>;
+            readonly quality_score: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>, v.DescriptionAction<number, "Self-assessed quality score (0-1)">]>, undefined>;
+            readonly confidence: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>, v.DescriptionAction<number, "Explicit confidence in correctness (0-1)">]>, undefined>;
+            readonly hypothesis_id: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "Hypothesis ID must contain only letters, numbers, hyphens, and underscores">, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 50, undefined>, v.DescriptionAction<string, "Identifier linking hypothesis to verification thoughts">]>, undefined>;
+            readonly verification_target: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 1, undefined>, v.DescriptionAction<number, "Thought number being verified or critiqued">]>, undefined>;
+            readonly verification_result: v.OptionalSchema<v.SchemaWithPipe<readonly [v.UnionSchema<[v.LiteralSchema<0, undefined>, v.LiteralSchema<1, undefined>], undefined>, v.DescriptionAction<0 | 1, "Exact verification outcome label: 0 for incorrect, 1 for correct">]>, undefined>;
+            readonly synthesis_sources: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 1, undefined>]>, undefined>, v.DescriptionAction<number[], "Thought numbers being synthesized">]>, undefined>;
+            readonly merge_from_thoughts: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 1, undefined>]>, undefined>, v.DescriptionAction<number[], "Thought numbers from other branches being merged (DAG)">]>, undefined>;
+            readonly merge_branch_ids: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>, v.MaxLengthAction<string, 50, undefined>]>, undefined>, v.DescriptionAction<string[], "Branch IDs being merged into current context">]>, undefined>;
+            readonly meta_observation: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Metacognitive observation about reasoning process">]>, undefined>;
+            readonly reasoning_depth: v.OptionalSchema<v.SchemaWithPipe<readonly [v.PicklistSchema<["shallow", "moderate", "deep"], undefined>, v.DescriptionAction<"shallow" | "moderate" | "deep", "Effort signal: how deep reasoning should go">]>, undefined>;
+            readonly session_id: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "Session ID must contain only letters, numbers, hyphens, and underscores">, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 100, undefined>, v.DescriptionAction<string, "Optional session identifier for state isolation. When provided, thought history, branches, and statistics are scoped to this session. Omitting preserves global behavior.">]>, undefined>;
+            readonly reset_state: v.OptionalSchema<v.SchemaWithPipe<readonly [v.BooleanSchema<undefined>, v.DescriptionAction<boolean, "When true, clears all state for the target session before processing this thought. The thought is then processed as the first in a fresh session.">]>, undefined>;
+            readonly tool_name: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.DescriptionAction<string, "Name of the tool being invoked (for tool_call thoughts)">]>, undefined>;
+            readonly tool_arguments: v.OptionalSchema<v.SchemaWithPipe<readonly [v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, v.DescriptionAction<{
+                [x: string]: unknown;
+            }, "Arguments passed to the tool (for tool_call thoughts)">]>, undefined>;
+            readonly tool_result: v.OptionalSchema<v.SchemaWithPipe<readonly [v.UnknownSchema, v.DescriptionAction<unknown, "Result returned by the tool (for tool_observation thoughts)">]>, undefined>;
+            readonly continuation_token: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.DescriptionAction<string, "Token for resuming long-running tool invocations">]>, undefined>;
+            readonly decomposition_children: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string[], "Child thought IDs produced by decomposition">]>, undefined>;
+            readonly backtrack_target: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>, v.DescriptionAction<number, "Thought number to backtrack to. When the parent thought has thought_type=backtrack, this thought is logically retracted: it remains in history but is excluded from quality signals and reasoning stats.">]>, undefined>;
+            readonly register_branch_id: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "register_branch_id must contain only letters, numbers, hyphens, and underscores">, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 50, undefined>, v.DescriptionAction<string, "Pre-declares a branch ID for this session before any thoughts reference it. Useful so that subsequent thoughts using merge_branch_ids can target a branch that has not yet received any thoughts.">]>, undefined>;
+        }, undefined>, undefined>;
+    }, undefined>, undefined>;
+    readonly edges: v.ArraySchema<v.StrictObjectSchema<{
+        readonly sessionId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>;
+        readonly edges: v.ArraySchema<v.ObjectSchema<{
+            readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 30, undefined>]>;
+            readonly from: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 30, undefined>]>;
+            readonly to: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 30, undefined>]>;
+            readonly kind: v.UnionSchema<[v.LiteralSchema<"sequence", undefined>, v.LiteralSchema<"branch", undefined>, v.LiteralSchema<"merge", undefined>, v.LiteralSchema<"verifies", undefined>, v.LiteralSchema<"critiques", undefined>, v.LiteralSchema<"derives_from", undefined>, v.LiteralSchema<"tool_invocation", undefined>, v.LiteralSchema<"revises", undefined>], undefined>;
+            readonly sessionId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+            readonly createdAt: v.NumberSchema<undefined>;
+            readonly metadata: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, undefined>;
+        }, undefined>, undefined>;
+    }, undefined>, undefined>;
+    readonly summaries: v.ArraySchema<v.StrictObjectSchema<{
+        readonly sessionId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>;
+        readonly summaries: v.ArraySchema<v.ObjectSchema<{
+            readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 64, undefined>]>;
+            readonly sessionId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 100, undefined>]>;
+            readonly branchId: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 64, undefined>]>, undefined>;
+            readonly rootThoughtId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 64, undefined>]>;
+            readonly coveredIds: v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 64, undefined>]>, undefined>;
+            readonly coveredRange: v.SchemaWithPipe<readonly [v.ArraySchema<v.NumberSchema<undefined>, undefined>, v.LengthAction<number[], 2, undefined>]>;
+            readonly topics: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+            readonly aggregateConfidence: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>;
+            readonly createdAt: v.NumberSchema<undefined>;
+            readonly meta: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, undefined>;
+        }, undefined>, undefined>;
+    }, undefined>, undefined>;
+}, undefined>;
+export declare const EMPTY_FILE_SNAPSHOT_V2: FileSnapshotV2;
+export declare function parseFileSnapshotV2(content: string, sourcePath: string): FileSnapshotV2;
+export declare function serializeFileSnapshotV2(snapshot: FileSnapshotV2, sourcePath: string): string;
+export declare function sessionsInSnapshot(snapshot: FileSnapshotV2): SessionId[];
+export declare function sessionForThought(thought: ThoughtData): SessionId;
+//# sourceMappingURL=FileSnapshotV2.d.ts.map

package/dist/persistence/FileSnapshotV2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FileSnapshotV2.d.ts","sourceRoot":"","sources":["../../src/persistence/FileSnapshotV2.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAC;AAC7B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAGrD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAItD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AA4B7D,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAM/B,CAAC;AAEH,eAAO,MAAM,sBAAsB,EAAE,cAMpC,CAAC;AAEF,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,cAAc,CAmCvF;AAED,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAuB5F;AAED,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,cAAc,GAAG,SAAS,EAAE,CAWxE;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,WAAW,GAAG,SAAS,CAEjE"}

package/dist/persistence/FileSnapshotV2.js

@@ -0,0 +1,124 @@
+import { GLOBAL_SESSION_ID, asSessionId } from "../contracts/ids.js";
+import { SummarySchema } from "../core/compression/Summary.js";
+import { PersistenceCompatibilityError, PersistenceCorruptionError } from "../errors.js";
+import { EdgeSchema, SequentialThinkingSchema } from "../schema.js";
+import { parseEdge, parseSummary, parseThoughtData } from "./PersistenceCodec.js";
+import { compareCodePoint, compareCreatedThenId, parsePersistenceBranchId } from "./PersistenceScope.js";
+import { validateFileSnapshotV2 } from "./FileSnapshotValidation.js";
+import * as __rspack_external_valibot from "valibot";
+const SessionIdStringSchema = __rspack_external_valibot.pipe(__rspack_external_valibot.string(), __rspack_external_valibot.regex(/^[A-Za-z0-9_-]{1,100}$/));
+const BranchIdStringSchema = __rspack_external_valibot.pipe(__rspack_external_valibot.string(), __rspack_external_valibot.regex(/^[A-Za-z0-9_-]{1,50}$/));
+const ThoughtSessionV2Schema = __rspack_external_valibot.strictObject({
+    sessionId: SessionIdStringSchema,
+    thoughts: __rspack_external_valibot.array(SequentialThinkingSchema)
+});
+const BranchRecordV2Schema = __rspack_external_valibot.strictObject({
+    sessionId: SessionIdStringSchema,
+    branchId: BranchIdStringSchema,
+    thoughts: __rspack_external_valibot.array(SequentialThinkingSchema)
+});
+const EdgeSessionV2Schema = __rspack_external_valibot.strictObject({
+    sessionId: SessionIdStringSchema,
+    edges: __rspack_external_valibot.array(EdgeSchema)
+});
+const SummarySessionV2Schema = __rspack_external_valibot.strictObject({
+    sessionId: SessionIdStringSchema,
+    summaries: __rspack_external_valibot.array(SummarySchema)
+});
+const FileSnapshotV2Schema = __rspack_external_valibot.strictObject({
+    version: __rspack_external_valibot.literal(2),
+    thoughts: __rspack_external_valibot.array(ThoughtSessionV2Schema),
+    branches: __rspack_external_valibot.array(BranchRecordV2Schema),
+    edges: __rspack_external_valibot.array(EdgeSessionV2Schema),
+    summaries: __rspack_external_valibot.array(SummarySessionV2Schema)
+});
+const EMPTY_FILE_SNAPSHOT_V2 = {
+    version: 2,
+    thoughts: [],
+    branches: [],
+    edges: [],
+    summaries: []
+};
+function parseFileSnapshotV2(content, sourcePath) {
+    let raw;
+    try {
+        raw = JSON.parse(content);
+    } catch (error) {
+        throw new PersistenceCorruptionError(sourcePath, error);
+    }
+    try {
+        const parsed = __rspack_external_valibot.parse(FileSnapshotV2Schema, raw);
+        const snapshot = {
+            version: 2,
+            thoughts: parsed.thoughts.map((record)=>({
+                    sessionId: asSessionId(record.sessionId),
+                    thoughts: record.thoughts.map((thought)=>parseThoughtData(thought, sourcePath))
+                })),
+            branches: parsed.branches.map((record)=>({
+                    sessionId: asSessionId(record.sessionId),
+                    branchId: parsePersistenceBranchId(record.branchId, sourcePath),
+                    thoughts: record.thoughts.map((thought)=>parseThoughtData(thought, sourcePath))
+                })),
+            edges: parsed.edges.map((record)=>({
+                    sessionId: asSessionId(record.sessionId),
+                    edges: record.edges.map(parseEdge)
+                })),
+            summaries: parsed.summaries.map((record)=>({
+                    sessionId: asSessionId(record.sessionId),
+                    summaries: record.summaries.map((summary)=>parseSummary(summary, sourcePath))
+                }))
+        };
+        validateFileSnapshotV2(snapshot, sourcePath);
+        return snapshot;
+    } catch (error) {
+        if (error instanceof PersistenceCompatibilityError) throw error;
+        throw new PersistenceCompatibilityError(sourcePath, 'document does not match File v2', error);
+    }
+}
+function serializeFileSnapshotV2(snapshot, sourcePath) {
+    const canonical = {
+        version: 2,
+        thoughts: [
+            ...snapshot.thoughts
+        ].sort((left, right)=>compareCodePoint(left.sessionId, right.sessionId)),
+        branches: [
+            ...snapshot.branches
+        ].sort((left, right)=>compareCodePoint(left.sessionId, right.sessionId) || compareCodePoint(left.branchId, right.branchId)),
+        edges: [
+            ...snapshot.edges
+        ].sort((left, right)=>compareCodePoint(left.sessionId, right.sessionId)).map((record)=>({
+                ...record,
+                edges: [
+                    ...record.edges
+                ].sort(compareCreatedThenId)
+            })),
+        summaries: [
+            ...snapshot.summaries
+        ].sort((left, right)=>compareCodePoint(left.sessionId, right.sessionId)).map((record)=>({
+                ...record,
+                summaries: [
+                    ...record.summaries
+                ].sort(compareCreatedThenId)
+            }))
+    };
+    validateFileSnapshotV2(canonical, sourcePath);
+    return `${JSON.stringify(canonical, null, 2)}\n`;
+}
+function sessionsInSnapshot(snapshot) {
+    const sessions = new Set();
+    for (const records of [
+        snapshot.thoughts,
+        snapshot.branches,
+        snapshot.edges,
+        snapshot.summaries
+    ])for (const record of records)sessions.add(record.sessionId);
+    return [
+        ...sessions
+    ].sort(compareCodePoint);
+}
+function sessionForThought(thought) {
+    return thought.session_id ?? GLOBAL_SESSION_ID;
+}
+export { EMPTY_FILE_SNAPSHOT_V2, FileSnapshotV2Schema, parseFileSnapshotV2, serializeFileSnapshotV2, sessionForThought, sessionsInSnapshot };
+
+//# sourceMappingURL=FileSnapshotV2.js.map

package/dist/persistence/FileSnapshotV2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"persistence/FileSnapshotV2.js","sources":["../../src/persistence/FileSnapshotV2.ts"],"sourcesContent":["import * as v from 'valibot';\nimport type { SessionId } from '../contracts/ids.js';\nimport { asSessionId, GLOBAL_SESSION_ID } from '../contracts/ids.js';\nimport { SummarySchema } from '../core/compression/Summary.js';\nimport type { ThoughtData } from '../core/thought.js';\nimport { PersistenceCompatibilityError, PersistenceCorruptionError } from '../errors.js';\nimport { EdgeSchema, SequentialThinkingSchema } from '../schema.js';\nimport { parseEdge, parseSummary, parseThoughtData } from './PersistenceCodec.js';\nimport type { FileSnapshotV2 } from './FileSnapshotTypes.js';\nimport {\n\tcompareCodePoint,\n\tcompareCreatedThenId,\n\tparsePersistenceBranchId,\n} from './PersistenceScope.js';\nimport { validateFileSnapshotV2 } from './FileSnapshotValidation.js';\n\nconst SessionIdStringSchema = v.pipe(v.string(), v.regex(/^[A-Za-z0-9_-]{1,100}$/));\nconst BranchIdStringSchema = v.pipe(v.string(), v.regex(/^[A-Za-z0-9_-]{1,50}$/));\nconst ThoughtSessionV2Schema = v.strictObject({\n\tsessionId: SessionIdStringSchema,\n\tthoughts: v.array(SequentialThinkingSchema),\n});\nconst BranchRecordV2Schema = v.strictObject({\n\tsessionId: SessionIdStringSchema,\n\tbranchId: BranchIdStringSchema,\n\tthoughts: v.array(SequentialThinkingSchema),\n});\nconst EdgeSessionV2Schema = v.strictObject({\n\tsessionId: SessionIdStringSchema,\n\tedges: v.array(EdgeSchema),\n});\nconst SummarySessionV2Schema = v.strictObject({\n\tsessionId: SessionIdStringSchema,\n\tsummaries: v.array(SummarySchema),\n});\n\nexport const FileSnapshotV2Schema = v.strictObject({\n\tversion: v.literal(2),\n\tthoughts: v.array(ThoughtSessionV2Schema),\n\tbranches: v.array(BranchRecordV2Schema),\n\tedges: v.array(EdgeSessionV2Schema),\n\tsummaries: v.array(SummarySessionV2Schema),\n});\n\nexport const EMPTY_FILE_SNAPSHOT_V2: FileSnapshotV2 = {\n\tversion: 2,\n\tthoughts: [],\n\tbranches: [],\n\tedges: [],\n\tsummaries: [],\n};\n\nexport function parseFileSnapshotV2(content: string, sourcePath: string): FileSnapshotV2 {\n\tlet raw: unknown;\n\ttry {\n\t\traw = JSON.parse(content);\n\t} catch (error) {\n\t\tthrow new PersistenceCorruptionError(sourcePath, error);\n\t}\n\ttry {\n\t\tconst parsed = v.parse(FileSnapshotV2Schema, raw);\n\t\tconst snapshot: FileSnapshotV2 = {\n\t\t\tversion: 2,\n\t\t\tthoughts: parsed.thoughts.map((record) => ({\n\t\t\t\tsessionId: asSessionId(record.sessionId),\n\t\t\t\tthoughts: record.thoughts.map((thought) => parseThoughtData(thought, sourcePath)),\n\t\t\t})),\n\t\t\tbranches: parsed.branches.map((record) => ({\n\t\t\t\tsessionId: asSessionId(record.sessionId),\n\t\t\t\tbranchId: parsePersistenceBranchId(record.branchId, sourcePath),\n\t\t\t\tthoughts: record.thoughts.map((thought) => parseThoughtData(thought, sourcePath)),\n\t\t\t})),\n\t\t\tedges: parsed.edges.map((record) => ({\n\t\t\t\tsessionId: asSessionId(record.sessionId),\n\t\t\t\tedges: record.edges.map(parseEdge),\n\t\t\t})),\n\t\t\tsummaries: parsed.summaries.map((record) => ({\n\t\t\t\tsessionId: asSessionId(record.sessionId),\n\t\t\t\tsummaries: record.summaries.map((summary) => parseSummary(summary, sourcePath)),\n\t\t\t})),\n\t\t};\n\t\tvalidateFileSnapshotV2(snapshot, sourcePath);\n\t\treturn snapshot;\n\t} catch (error) {\n\t\tif (error instanceof PersistenceCompatibilityError) throw error;\n\t\tthrow new PersistenceCompatibilityError(sourcePath, 'document does not match File v2', error);\n\t}\n}\n\nexport function serializeFileSnapshotV2(snapshot: FileSnapshotV2, sourcePath: string): string {\n\tconst canonical: FileSnapshotV2 = {\n\t\tversion: 2,\n\t\tthoughts: [...snapshot.thoughts].sort((left, right) =>\n\t\t\tcompareCodePoint(left.sessionId, right.sessionId)\n\t\t),\n\t\tbranches: [...snapshot.branches].sort(\n\t\t\t(left, right) =>\n\t\t\t\tcompareCodePoint(left.sessionId, right.sessionId) ||\n\t\t\t\tcompareCodePoint(left.branchId, right.branchId)\n\t\t),\n\t\tedges: [...snapshot.edges]\n\t\t\t.sort((left, right) => compareCodePoint(left.sessionId, right.sessionId))\n\t\t\t.map((record) => ({ ...record, edges: [...record.edges].sort(compareCreatedThenId) })),\n\t\tsummaries: [...snapshot.summaries]\n\t\t\t.sort((left, right) => compareCodePoint(left.sessionId, right.sessionId))\n\t\t\t.map((record) => ({\n\t\t\t\t...record,\n\t\t\t\tsummaries: [...record.summaries].sort(compareCreatedThenId),\n\t\t\t})),\n\t};\n\tvalidateFileSnapshotV2(canonical, sourcePath);\n\treturn `${JSON.stringify(canonical, null, 2)}\\n`;\n}\n\nexport function sessionsInSnapshot(snapshot: FileSnapshotV2): SessionId[] {\n\tconst sessions = new Set<SessionId>();\n\tfor (const records of [\n\t\tsnapshot.thoughts,\n\t\tsnapshot.branches,\n\t\tsnapshot.edges,\n\t\tsnapshot.summaries,\n\t]) {\n\t\tfor (const record of records) sessions.add(record.sessionId);\n\t}\n\treturn [...sessions].sort(compareCodePoint);\n}\n\nexport function sessionForThought(thought: ThoughtData): SessionId {\n\treturn thought.session_id ?? GLOBAL_SESSION_ID;\n}\n"],"names":["SessionIdStringSchema","v","BranchIdStringSchema","ThoughtSessionV2Schema","SequentialThinkingSchema","BranchRecordV2Schema","EdgeSessionV2Schema","EdgeSchema","SummarySessionV2Schema","SummarySchema","FileSnapshotV2Schema","EMPTY_FILE_SNAPSHOT_V2","parseFileSnapshotV2","content","sourcePath","raw","JSON","error","PersistenceCorruptionError","parsed","snapshot","record","asSessionId","thought","parseThoughtData","parsePersistenceBranchId","parseEdge","summary","parseSummary","validateFileSnapshotV2","PersistenceCompatibilityError","serializeFileSnapshotV2","canonical","left","right","compareCodePoint","compareCreatedThenId","sessionsInSnapshot","sessions","Set","records","sessionForThought","GLOBAL_SESSION_ID"],"mappings":"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"}