deepclause-sdk 0.0.85 → 0.0.86

package/dist/prolog-src/deepclause_mi.pl

@@ -779,9 +779,9 @@ get_reasoning_effort(State, Effort) :-
 %% Recipe Context Helpers
 %% ============================================================
 
-%% load_recipe_content(+Query, -Content)
-load_recipe_content(Query, RecipeContent) :-
-    exec(consult_recipes(query: Query, max_results: 1), Result),
+%% load_recipe_content(+Query, +StateIn, -StateOut, -Content)
+load_recipe_content(Query, StateIn, StateOut, RecipeContent) :-
+    mi_call(exec(consult_recipes(query: Query, max_results: 1), Result), StateIn, StateOut),
     get_dict(matches, Result, Matches),
     (   Matches = [Match|_]
     ->  get_dict(content, Match, RecipeContent)
@@ -1484,8 +1484,8 @@ mi_call(with_reasoning(Goal, Effort), StateIn, StateOut) :-
 %% Run Goal with a recipe loaded as transient context (not persisted to memory).
 mi_call(with_recipe(Goal, Query), StateIn, StateOut) :-
     !,
-    load_recipe_content(Query, RecipeContent),
-    set_recipe_context(StateIn, RecipeContent, ScopedState),
+    load_recipe_content(Query, StateIn, StateAfterRecipeLoad, RecipeContent),
+    set_recipe_context(StateAfterRecipeLoad, RecipeContent, ScopedState),
     mi_call(Goal, ScopedState, StateWithRecipe),
     clear_recipe_context(StateWithRecipe, StateOut).
 

package/dist/system/assets/skills/deep-planner.dml

@@ -173,13 +173,19 @@ Note: There is no separate save_file or read_file tool. File operations go throu
 
 {ReasoningNote}
 
-Also specify a recipe query for each task if relevant (null otherwise).
-
-Return a JSON array of objects:
-[{\"description\": \"task description\", \"tools\": [\"tool_name\", ...], \"reasoning\": \"none|low|medium|high\", \"recipe\": \"query string or null\"}]
-
-Return ONLY the JSON array.", string(TasksJson)),
-    (   catch(parse_plan_json(TasksJson, Steps), _, fail)
+Also specify a recipe query for each task if relevant (NONE otherwise).
+
+Return four ordered lists aligned 1:1:
+- TaskDescriptions: plain task descriptions.
+- ToolSpecs: each item must be either ALL or a comma-separated list of exact tool names from the available tools list above.
+- ReasoningSpecs: each item must be exactly one of none, low, medium, high.
+- RecipeSpecs: each item must be either NONE or a recipe query string.
+
+Store the ordered task descriptions in TaskDescriptions.
+Store the ordered tool specs in ToolSpecs.
+Store the ordered reasoning specs in ReasoningSpecs.
+Store the ordered recipe specs in RecipeSpecs.", list(string(TaskDescriptions)), list(string(ToolSpecs)), list(string(ReasoningSpecs)), list(string(RecipeSpecs))),
+    (   build_plan_steps_from_specs(TaskDescriptions, ToolSpecs, ReasoningSpecs, RecipeSpecs, Steps)
     ->  true
     ;   fallback_plan_steps_from_strategy(Strategy, Steps)
     ).
@@ -196,44 +202,66 @@ valid_plan_tool(create_new_skill).
 valid_plan_tool(ask_user).
 valid_plan_tool(inform_user).
 
-%% tool_name_to_atom(+Raw, -Atom)
-tool_name_to_atom(Raw, Atom) :-
-    (   atom(Raw) -> Atom = Raw
-    ;   string(Raw) -> atom_string(Atom, Raw)
-    ;   Atom = Raw
+default_plan_tools([run_bash, run_skill, consult_recipes, search_web, search_news, fetch_url, download_file, create_new_skill, ask_user, inform_user]).
+
+build_plan_steps_from_specs([], [], [], [], []).
+build_plan_steps_from_specs([Desc|RestDesc], [ToolSpec|RestTools], [ReasoningSpec|RestReasoning], [RecipeSpec|RestRecipes], [plan_step{description: Desc, tools: Tools, reasoning: Reasoning, recipe: Recipe}|RestSteps]) :-
+    normalize_tools_spec(ToolSpec, Tools),
+    normalize_reasoning_spec(ReasoningSpec, Reasoning),
+    normalize_recipe_spec(RecipeSpec, Recipe),
+    build_plan_steps_from_specs(RestDesc, RestTools, RestReasoning, RestRecipes, RestSteps).
+
+normalize_tools_spec(Raw, Tools) :-
+    format(string(Text), "~w", [Raw]),
+    string_lower(Text, Lower),
+    (   Lower = "all"
+    ->  default_plan_tools(Tools)
+    ;   split_string(Text, ",", " []\t\n", Parts0),
+        include(non_empty_string, Parts0, Parts),
+        findall(ToolAtom,
+            ( member(Part, Parts),
+              tool_name_string_to_atom(Part, ToolAtom),
+              valid_plan_tool(ToolAtom)
+            ),
+            ValidTools),
+        (   ValidTools = []
+        ->  default_plan_tools(Tools)
+        ;   Tools = ValidTools
+        )
     ).
 
-%% parse_plan_json(+Json, -PlanSteps)
-parse_plan_json(Json, PlanSteps) :-
-    atom_json_dict(Json, JsonArray, []),
-    is_list(JsonArray),
-    maplist(parse_plan_step, JsonArray, PlanSteps).
-
-parse_plan_step(Dict, plan_step{description: Desc, tools: Tools, reasoning: Reasoning, recipe: Recipe}) :-
-    Desc = Dict.get(description),
-    (   Desc = null -> throw(parse_error) ; true ),
-    ToolsRaw = Dict.get(tools),
-    (   is_list(ToolsRaw)
-    ->  findall(TA, (member(TR, ToolsRaw), tool_name_to_atom(TR, TA), valid_plan_tool(TA)), ValidTools),
-        (   ValidTools = [] -> Tools = all ; Tools = ValidTools )
-    ;   Tools = all ),
-    ReasoningRaw = Dict.get(reasoning),
-    (   atom(ReasoningRaw) -> atom_string(ReasoningRaw, Reasoning)
-    ;   string(ReasoningRaw) -> Reasoning = ReasoningRaw
-    ;   Reasoning = "none"
-    ),
-    RecipeRaw = Dict.get(recipe),
-    (   (   RecipeRaw = null ; var(RecipeRaw) )
+normalize_reasoning_spec(Raw, Reasoning) :-
+    format(string(Text), "~w", [Raw]),
+    string_lower(Text, Lower),
+    normalize_reasoning_label(Lower, Reasoning).
+
+normalize_reasoning_label("high", "high").
+normalize_reasoning_label("medium", "medium").
+normalize_reasoning_label("low", "low").
+normalize_reasoning_label("none", "none").
+normalize_reasoning_label(_, "none").
+
+normalize_recipe_spec(Raw, Recipe) :-
+    format(string(Text0), "~w", [Raw]),
+    normalize_space(string(Text), Text0),
+    string_lower(Text, Lower),
+    (   Lower = ""
     ->  Recipe = "none"
-    ;   atom(RecipeRaw)
-    ->  atom_string(RecipeRaw, Recipe)
-    ;   string(RecipeRaw)
-    ->  Recipe = RecipeRaw
-    ;   Recipe = "none"
+    ;   Lower = "none"
+    ->  Recipe = "none"
+    ;   Recipe = Text
     ).
 
+tool_name_string_to_atom(Text, Atom) :-
+    string_lower(Text, Lower),
+    atom_string(Atom, Lower).
+
+non_empty_string(Text) :-
+    Text \= "".
+
 %% fallback_plan_steps_from_strategy(+Strategy, -Steps)
-fallback_plan_steps_from_strategy(Strategy, [plan_step{description: Strategy, tools: all, reasoning: "none", recipe: "none"}]).
+fallback_plan_steps_from_strategy(Strategy, [plan_step{description: Strategy, tools: Tools, reasoning: "none", recipe: "none"}]) :-
+    default_plan_tools(Tools).
 
 %% assemble_multi_strategy_dml(+StrategyPlans, +CodingWorkflowRecipe, -PlanDml)
 assemble_multi_strategy_dml(StrategyPlans, CodingWorkflowRecipe, PlanDml) :-
@@ -271,10 +299,7 @@ build_single_task_line(Step, Line) :-
     Reasoning = Step.reasoning,
     Recipe = Step.recipe,
 
-    (   Tools == all
-    ->  format(string(InnerTask), "task(~q)", [Desc])
-    ;   format(string(InnerTask), "with_tools(~w, task(~q))", [Tools, Desc])
-    ),
+    format(string(InnerTask), "with_tools(~w, task(~q))", [Tools, Desc]),
 
     (   Reasoning \= "none"
     ->  format(string(WithReasoning), "with_reasoning(~n        ~w~n    , ~w)", [InnerTask, Reasoning])

package/dist/system/assets/skills/plan.dml

@@ -172,16 +172,17 @@ Note: There is no separate save_file or read_file tool. File operations go throu
 
 {ReasoningNote}
 
-Also specify a recipe query for each task if relevant (null otherwise). Use natural language queries like 'testing patterns' or 'codebase analysis'.
+Also specify a recipe query for each task if relevant (NONE otherwise). Use natural language queries like 'testing patterns' or 'codebase analysis'.
 
-Return a JSON array of objects with these fields:
-- \"description\": the task description (copy from the plan above)
-- \"tools\": array of tool name strings from the available tools list above
-- \"reasoning\": one of \"none\", \"low\", \"medium\", \"high\"
-- \"recipe\": a recipe query string or null
+Return three ordered lists aligned 1:1 with Tasks:
+- ToolSpecs: each item must be either ALL or a comma-separated list of exact tool names from the available tools list above.
+- ReasoningSpecs: each item must be exactly one of none, low, medium, high.
+- RecipeSpecs: each item must be either NONE or a recipe query string.
 
-Return ONLY the JSON array, no other text.", string(AssignmentsJson)),
-    (   catch(parse_plan_json(AssignmentsJson, PlanSteps), _, fail)
+Store the ordered tool specs in ToolSpecs.
+Store the ordered reasoning specs in ReasoningSpecs.
+Store the ordered recipe specs in RecipeSpecs.", list(string(ToolSpecs)), list(string(ReasoningSpecs)), list(string(RecipeSpecs))),
+    (   build_plan_steps_from_specs(PlanTasks, ToolSpecs, ReasoningSpecs, RecipeSpecs, PlanSteps)
     ->  true
     ;   % Fallback: no tool/reasoning/recipe assignments
         fallback_plan_steps(PlanTasks, PlanSteps)
@@ -199,48 +200,68 @@ valid_plan_tool(create_new_skill).
 valid_plan_tool(ask_user).
 valid_plan_tool(inform_user).
 
-%% tool_name_to_atom(+Raw, -Atom)
-%% Converts a JSON string or atom to a Prolog atom
-tool_name_to_atom(Raw, Atom) :-
-    (   atom(Raw) -> Atom = Raw
-    ;   string(Raw) -> atom_string(Atom, Raw)
-    ;   Atom = Raw
+default_plan_tools([run_bash, run_skill, consult_recipes, search_web, search_news, fetch_url, download_file, create_new_skill, ask_user, inform_user]).
+
+build_plan_steps_from_specs([], [], [], [], []).
+build_plan_steps_from_specs([Desc|RestDesc], [ToolSpec|RestTools], [ReasoningSpec|RestReasoning], [RecipeSpec|RestRecipes], [plan_step{description: Desc, tools: Tools, reasoning: Reasoning, recipe: Recipe}|RestSteps]) :-
+    normalize_tools_spec(ToolSpec, Tools),
+    normalize_reasoning_spec(ReasoningSpec, Reasoning),
+    normalize_recipe_spec(RecipeSpec, Recipe),
+    build_plan_steps_from_specs(RestDesc, RestTools, RestReasoning, RestRecipes, RestSteps).
+
+normalize_tools_spec(Raw, Tools) :-
+    format(string(Text), "~w", [Raw]),
+    string_lower(Text, Lower),
+    (   Lower = "all"
+    ->  default_plan_tools(Tools)
+    ;   split_string(Text, ",", " []\t\n", Parts0),
+        include(non_empty_string, Parts0, Parts),
+        findall(ToolAtom,
+            ( member(Part, Parts),
+              tool_name_string_to_atom(Part, ToolAtom),
+              valid_plan_tool(ToolAtom)
+            ),
+            ValidTools),
+        (   ValidTools = []
+        ->  default_plan_tools(Tools)
+        ;   Tools = ValidTools
+        )
     ).
 
-%% parse_plan_json(+Json, -PlanSteps)
-parse_plan_json(Json, PlanSteps) :-
-    atom_json_dict(Json, JsonArray, []),
-    is_list(JsonArray),
-    maplist(parse_plan_step, JsonArray, PlanSteps).
-
-parse_plan_step(Dict, plan_step{description: Desc, tools: Tools, reasoning: Reasoning, recipe: Recipe}) :-
-    Desc = Dict.get(description),
-    (   Desc = null -> throw(parse_error) ; true ),
-    ToolsRaw = Dict.get(tools),
-    (   is_list(ToolsRaw)
-    ->  % Convert each tool name to atom, filter to valid tools
-        findall(TA, (member(TR, ToolsRaw), tool_name_to_atom(TR, TA), valid_plan_tool(TA)), ValidTools),
-        (   ValidTools = [] -> Tools = all ; Tools = ValidTools )
-    ;   Tools = all ),
-    ReasoningRaw = Dict.get(reasoning),
-    (   atom(ReasoningRaw) -> atom_string(ReasoningRaw, Reasoning)
-    ;   string(ReasoningRaw) -> Reasoning = ReasoningRaw
-    ;   Reasoning = "none"
-    ),
-    RecipeRaw = Dict.get(recipe),
-    (   (   RecipeRaw = null ; var(RecipeRaw) )
+normalize_reasoning_spec(Raw, Reasoning) :-
+    format(string(Text), "~w", [Raw]),
+    string_lower(Text, Lower),
+    normalize_reasoning_label(Lower, Reasoning).
+
+normalize_reasoning_label("high", "high").
+normalize_reasoning_label("medium", "medium").
+normalize_reasoning_label("low", "low").
+normalize_reasoning_label("none", "none").
+normalize_reasoning_label(_, "none").
+
+normalize_recipe_spec(Raw, Recipe) :-
+    format(string(Text0), "~w", [Raw]),
+    normalize_space(string(Text), Text0),
+    string_lower(Text, Lower),
+    (   Lower = ""
+    ->  Recipe = "none"
+    ;   Lower = "none"
     ->  Recipe = "none"
-    ;   atom(RecipeRaw)
-    ->  atom_string(RecipeRaw, Recipe)
-    ;   string(RecipeRaw)
-    ->  Recipe = RecipeRaw
-    ;   Recipe = "none"
+    ;   Recipe = Text
     ).
 
+tool_name_string_to_atom(Text, Atom) :-
+    string_lower(Text, Lower),
+    atom_string(Atom, Lower).
+
+non_empty_string(Text) :-
+    Text \= "".
+
 %% fallback_plan_steps(+PlanTasks, -PlanSteps)
 %% When JSON parsing fails, create steps with all tools and no reasoning/recipe.
 fallback_plan_steps([], []).
-fallback_plan_steps([Desc|Rest], [plan_step{description: Desc, tools: all, reasoning: "none", recipe: "none"}|RestSteps]) :-
+fallback_plan_steps([Desc|Rest], [plan_step{description: Desc, tools: Tools, reasoning: "none", recipe: "none"}|RestSteps]) :-
+    default_plan_tools(Tools),
     fallback_plan_steps(Rest, RestSteps).
 
 assemble_plan_dml(PlanSystemPrompt, PlanSteps, PlanDml) :-
@@ -289,10 +310,7 @@ build_step_review_lines([Step|RestSteps], StepNumber, StepLines) :-
     Desc = Step.description,
     Tools = Step.tools,
     Reasoning = Step.reasoning,
-    (   Tools == all
-    ->  format(string(CurrentStep), "~w. ~w [all tools, ~w]\n", [StepNumber, Desc, Reasoning])
-    ;   format(string(CurrentStep), "~w. ~w [tools: ~w, ~w]\n", [StepNumber, Desc, Tools, Reasoning])
-    ),
+    format(string(CurrentStep), "~w. ~w [tools: ~w, ~w]\n", [StepNumber, Desc, Tools, Reasoning]),
     NextStepNumber is StepNumber + 1,
     build_step_review_lines(RestSteps, NextStepNumber, RestStepLines),
     string_concat(CurrentStep, RestStepLines, StepLines).
@@ -309,19 +327,13 @@ build_single_task_line(Step, Line) :-
     Reasoning = Step.reasoning,
     Recipe = Step.recipe,
 
-    % Build inner task with tool scoping
-    (   Tools == all
-    ->  format(string(InnerTask), "task(~q)", [Desc])
-    ;   format(string(InnerTask), "with_tools(~w, task(~q))", [Tools, Desc])
-    ),
+    format(string(InnerTask), "with_tools(~w, task(~q))", [Tools, Desc]),
 
-    % Wrap in with_reasoning if reasoning != none
     (   Reasoning \= "none"
     ->  format(string(WithReasoning), "with_reasoning(~n        ~w~n    , ~w)", [InnerTask, Reasoning])
     ;   WithReasoning = InnerTask
     ),
 
-    % Wrap in with_recipe if recipe != none
     (   Recipe \= "none"
     ->  format(string(Line), "    with_recipe(~n        ~w~n    , '~w'),~n", [WithReasoning, Recipe])
     ;   format(string(Line), "    ~w,~n", [WithReasoning])

package/dist/system/assets/skills/security-planner.dml

@@ -93,6 +93,13 @@ generate_all_strategy_tasks(Request, [Strategy|RestStrategies], [plan{strategy:
 
 %% generate_strategy_tasks(+Request, +Strategy, -Steps)
 generate_strategy_tasks(Request, Strategy, Steps) :-
+    (   param(model_info, ModelInfo)
+    ->  (   get_dict(reasoning, ModelInfo, R), R == true
+        ->  ReasoningNote = "The execution model supports reasoning. Assign reasoning effort per task: none, low, medium, or high."
+        ;   ReasoningNote = "The execution model does not support reasoning. Set reasoning to 'none' for all tasks."
+        )
+    ;   ReasoningNote = "Set reasoning to 'none' for all tasks."
+    ),
     task("List 3 to 7 focused execution tasks for this security analysis strategy.
 
 Target: {Request}
@@ -100,13 +107,101 @@ Strategy: {Strategy}
 
 Each task should be one concrete analysis step. Be specific about what to look for and which files to examine.
 
-Store the list of task descriptions in TaskDescriptions.", list(string(TaskDescriptions))),
-    build_steps_from_descriptions(TaskDescriptions, Strategy, Steps).
+Available tools (use ONLY these exact names):
+- consult_recipes: Search recipe guidance and conventions
+- search_web: Search the web for advisories, docs, and references
+- search_news: Search recent news for relevant incidents or advisories
+- fetch_url: Fetch a specific advisory or documentation page
+- run_bash: Run grep, find, test, and scanner commands in the workspace
+- ask_user: Ask the user to narrow scope or clarify assumptions
+- inform_user: Send a status update
+
+{ReasoningNote}
+
+Also specify a recipe query for each task if relevant (NONE otherwise).
+
+Return four ordered lists aligned 1:1:
+- TaskDescriptions: plain task descriptions.
+- ToolSpecs: each item must be either ALL or a comma-separated list of exact tool names from the available tools list above.
+- ReasoningSpecs: each item must be exactly one of none, low, medium, high.
+- RecipeSpecs: each item must be either NONE or a recipe query string.
+
+Store the ordered task descriptions in TaskDescriptions.
+Store the ordered tool specs in ToolSpecs.
+Store the ordered reasoning specs in ReasoningSpecs.
+Store the ordered recipe specs in RecipeSpecs.", list(string(TaskDescriptions)), list(string(ToolSpecs)), list(string(ReasoningSpecs)), list(string(RecipeSpecs))),
+    (   build_steps_from_specs(TaskDescriptions, ToolSpecs, ReasoningSpecs, RecipeSpecs, Steps)
+    ->  true
+    ;   fallback_plan_steps_from_strategy(Strategy, Steps)
+    ).
+
+valid_plan_tool(consult_recipes).
+valid_plan_tool(search_web).
+valid_plan_tool(search_news).
+valid_plan_tool(fetch_url).
+valid_plan_tool(run_bash).
+valid_plan_tool(ask_user).
+valid_plan_tool(inform_user).
+
+default_plan_tools([consult_recipes, search_web, search_news, fetch_url, run_bash, ask_user, inform_user]).
+
+build_steps_from_specs([], [], [], [], []).
+build_steps_from_specs([Desc|RestDesc], [ToolSpec|RestTools], [ReasoningSpec|RestReasoning], [RecipeSpec|RestRecipes], [plan_step{description: Desc, tools: Tools, reasoning: Reasoning, recipe: Recipe}|RestSteps]) :-
+    normalize_tools_spec(ToolSpec, Tools),
+    normalize_reasoning_spec(ReasoningSpec, Reasoning),
+    normalize_recipe_spec(RecipeSpec, Recipe),
+    build_steps_from_specs(RestDesc, RestTools, RestReasoning, RestRecipes, RestSteps).
+
+normalize_tools_spec(Raw, Tools) :-
+    format(string(Text), "~w", [Raw]),
+    string_lower(Text, Lower),
+    (   Lower = "all"
+    ->  default_plan_tools(Tools)
+    ;   split_string(Text, ",", " []\t\n", Parts0),
+        include(non_empty_string, Parts0, Parts),
+        findall(ToolAtom,
+            ( member(Part, Parts),
+              tool_name_string_to_atom(Part, ToolAtom),
+              valid_plan_tool(ToolAtom)
+            ),
+            ValidTools),
+        (   ValidTools = []
+        ->  default_plan_tools(Tools)
+        ;   Tools = ValidTools
+        )
+    ).
+
+normalize_reasoning_spec(Raw, Reasoning) :-
+    format(string(Text), "~w", [Raw]),
+    string_lower(Text, Lower),
+    normalize_reasoning_label(Lower, Reasoning).
+
+normalize_reasoning_label("high", "high").
+normalize_reasoning_label("medium", "medium").
+normalize_reasoning_label("low", "low").
+normalize_reasoning_label("none", "none").
+normalize_reasoning_label(_, "none").
+
+normalize_recipe_spec(Raw, Recipe) :-
+    format(string(Text0), "~w", [Raw]),
+    normalize_space(string(Text), Text0),
+    string_lower(Text, Lower),
+    (   Lower = ""
+    ->  Recipe = "none"
+    ;   Lower = "none"
+    ->  Recipe = "none"
+    ;   Recipe = Text
+    ).
+
+tool_name_string_to_atom(Text, Atom) :-
+    string_lower(Text, Lower),
+    atom_string(Atom, Lower).
 
-%% build_steps_from_descriptions(+Descriptions, +Strategy, -Steps)
-build_steps_from_descriptions([], _, []).
-build_steps_from_descriptions([Desc|Rest], Strategy, [plan_step{description: Desc, tools: all, reasoning: "none", recipe: "none"}|RestSteps]) :-
-    build_steps_from_descriptions(Rest, Strategy, RestSteps).
+non_empty_string(Text) :-
+    Text \= "".
+
+fallback_plan_steps_from_strategy(Strategy, [plan_step{description: Strategy, tools: Tools, reasoning: "none", recipe: "none"}]) :-
+    default_plan_tools(Tools).
 
 %% assemble_multi_strategy_dml(+StrategyPlans, -PlanDml)
 assemble_multi_strategy_dml(StrategyPlans, PlanDml) :-
@@ -156,7 +251,19 @@ build_single_task_line(Step, Num, PrevSum, Line) :-
     Desc = Step.description,
     format(string(VarName), "Sum~w", [Num]),
     format(string(DescWithCtx), "~w. Store your findings summary in ~w.", [Desc, VarName]),
-    format(string(Line), "    task(~q, string(~w)),~n", [DescWithCtx, VarName]).
+    Tools = Step.tools,
+    Reasoning = Step.reasoning,
+    Recipe = Step.recipe,
+    format(string(BaseTask), "task(~q, string(~w))", [DescWithCtx, VarName]),
+    format(string(WithTools), "with_tools(~w, ~w)", [Tools, BaseTask]),
+    (   Reasoning \= "none"
+    ->  format(string(WithReasoning), "with_reasoning(~n        ~w~n    , ~w)", [WithTools, Reasoning])
+    ;   WithReasoning = WithTools
+    ),
+    (   Recipe \= "none"
+    ->  format(string(Line), "    with_recipe(~n        ~w~n    , '~w'),~n", [WithReasoning, Recipe])
+    ;   format(string(Line), "    ~w,~n", [WithReasoning])
+    ).
 
 %% build_review_message(+FilePath, +StrategyPlans, -ReviewMessage)
 build_review_message(FilePath, StrategyPlans, ReviewMessage) :-

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepclause-sdk",
-  "version": "0.0.85",
+  "version": "0.0.86",
   "description": "DeepClause CLI Tool, TUI and Typescript SDK",
   "type": "module",
   "main": "dist/index.js",

package/src/prolog-src/deepclause_mi.pl

@@ -779,9 +779,9 @@ get_reasoning_effort(State, Effort) :-
 %% Recipe Context Helpers
 %% ============================================================
 
-%% load_recipe_content(+Query, -Content)
-load_recipe_content(Query, RecipeContent) :-
-    exec(consult_recipes(query: Query, max_results: 1), Result),
+%% load_recipe_content(+Query, +StateIn, -StateOut, -Content)
+load_recipe_content(Query, StateIn, StateOut, RecipeContent) :-
+    mi_call(exec(consult_recipes(query: Query, max_results: 1), Result), StateIn, StateOut),
     get_dict(matches, Result, Matches),
     (   Matches = [Match|_]
     ->  get_dict(content, Match, RecipeContent)
@@ -1484,8 +1484,8 @@ mi_call(with_reasoning(Goal, Effort), StateIn, StateOut) :-
 %% Run Goal with a recipe loaded as transient context (not persisted to memory).
 mi_call(with_recipe(Goal, Query), StateIn, StateOut) :-
     !,
-    load_recipe_content(Query, RecipeContent),
-    set_recipe_context(StateIn, RecipeContent, ScopedState),
+    load_recipe_content(Query, StateIn, StateAfterRecipeLoad, RecipeContent),
+    set_recipe_context(StateAfterRecipeLoad, RecipeContent, ScopedState),
     mi_call(Goal, ScopedState, StateWithRecipe),
     clear_recipe_context(StateWithRecipe, StateOut).