deepclause-sdk 0.0.89 → 0.1.1

package/dist/compiler_prompt.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"compiler_prompt.js","sourceRoot":"","sources":["../src/compiler_prompt.ts"],"names":[],"mappings":"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"}

package/dist/prolog-src/deepclause_mi.pl.bak

@@ -1,570 +0,0 @@
-/**
- * deepclause_mi.pl - Meta-interpreter for DeepClause SDK
- * 
- * The simplified meta-interpreter that handles:
- * - task/1 and task/N predicates (agent loops)
- * - exec/2 predicate (external tool calls)
- * - Memory predicates (system, user, push_context, pop_context)
- * - Output predicates (answer, yield, log)
- * - Parameter handling
- * 
- * Key design decisions:
- * - No @-predicates - all LLM interaction via task()
- * - Cooperative execution via engine yields
- * - Backtrackable memory via push_context/pop_context
- */
-
-:- module(deepclause_mi, [
-    parse_dml/4,
-    create_engine/4,
-    step_engine/4,
-    destroy_engine/1,
-    post_agent_result/3,
-    post_exec_result/3,
-    provide_input/2,
-    mi/4
-]).
-
-:- use_module(deepclause_memory).
-:- use_module(deepclause_strings).
-
-%% Dynamic predicates for session state
-:- dynamic session_engine/2.       % session_engine(SessionId, Engine)
-:- dynamic session_memory/2.       % session_memory(SessionId, MemoryId)
-:- dynamic session_params/2.       % session_params(SessionId, ParamsDict)
-:- dynamic session_user_tools/2.   % session_user_tools(SessionId, ToolName)
-:- dynamic session_user_tool_schema/3. % session_user_tool_schema(SessionId, ToolName, Schema)
-:- dynamic session_pending_input/2. % session_pending_input(SessionId, Input)
-:- dynamic session_agent_result/2. % session_agent_result(SessionId, Result)
-:- dynamic session_exec_result/2.  % session_exec_result(SessionId, Result)
-
-%% ============================================================
-%% DML Parsing
-%% ============================================================
-
-%% parse_dml(+FilePath, +SessionId, +MemoryId, -Error)
-%% Parse a DML file and load its clauses into the session module
-parse_dml(FilePath, SessionId, MemoryId, Error) :-
-    catch(
-        (
-            read_file_to_string(FilePath, Code, []),
-            parse_dml_string(Code, SessionId, MemoryId),
-            Error = none
-        ),
-        ParseError,
-        format(atom(Error), '~w', [ParseError])
-    ).
-
-%% parse_dml_string(+Code, +SessionId, +MemoryId)
-%% Parse DML code from a string
-parse_dml_string(Code, SessionId, MemoryId) :-
-    open_string(Code, Stream),
-    parse_clauses(Stream, SessionId, MemoryId),
-    close(Stream).
-
-%% parse_clauses(+Stream, +SessionId, +MemoryId)
-%% Read and process all clauses from a stream
-parse_clauses(Stream, SessionId, MemoryId) :-
-    read_term(Stream, Term, [module(SessionId)]),
-    (   Term == end_of_file
-    ->  true
-    ;   process_clause(Term, SessionId, MemoryId),
-        parse_clauses(Stream, SessionId, MemoryId)
-    ).
-
-%% process_clause(+Term, +SessionId, +MemoryId)
-%% Process a single clause and add to session
-process_clause((:- Directive), SessionId, _MemoryId) :-
-    !,
-    process_directive(Directive, SessionId).
-
-%% Handle tool/2 with description: tool(Head, Description) :- Body
-process_clause((tool(ToolHead, Description) :- Body), SessionId, _MemoryId) :-
-    !,
-    extract_tool_schema(ToolHead, Description, ToolName, Schema),
-    assertz(session_user_tools(SessionId, ToolName)),
-    assertz(session_user_tool_schema(SessionId, ToolName, Schema)),
-    % Store the source code for the tool description
-    format(string(SourceCode), "tool(~w, ~q) :-~n    ~w.", [ToolHead, Description, Body]),
-    assertz(SessionId:tool_source(ToolName, SourceCode)),
-    % Assert the tool implementation (use just ToolHead for execution)
-    assertz(SessionId:(tool(ToolHead) :- Body)).
-
-%% Handle tool/1 without description: tool(Head) :- Body
-process_clause((tool(ToolHead) :- Body), SessionId, _MemoryId) :-
-    !,
-    extract_tool_schema(ToolHead, none, ToolName, Schema),
-    assertz(session_user_tools(SessionId, ToolName)),
-    assertz(session_user_tool_schema(SessionId, ToolName, Schema)),
-    % Store the source code for the tool description
-    format(string(SourceCode), "tool(~w) :-~n    ~w.", [ToolHead, Body]),
-    assertz(SessionId:tool_source(ToolName, SourceCode)),
-    % Assert the tool implementation
-    assertz(SessionId:(tool(ToolHead) :- Body)).
-
-process_clause((Head :- Body), SessionId, _MemoryId) :-
-    !,
-    % Regular clause - assert it
-    assertz(SessionId:(Head :- Body)).
-
-process_clause(Fact, SessionId, _MemoryId) :-
-    % Simple fact
-    assertz(SessionId:Fact).
-
-%% ============================================================
-%% Tool Schema Extraction
-%% ============================================================
-
-%% extract_tool_schema(+ToolHead, +Description, -ToolName, -Schema)
-%% Parse tool head to extract schema information
-%% Schema = schema{name, description, inputs, outputs}
-%% Each param = param{name, type, direction}
-extract_tool_schema(ToolHead, Description, ToolName, Schema) :-
-    ToolHead =.. [ToolName|Args],
-    length(Args, Arity),
-    extract_params(Args, 1, Arity, Inputs, Outputs),
-    (Description == none -> Desc = "" ; Desc = Description),
-    Schema = schema{
-        name: ToolName,
-        description: Desc,
-        inputs: Inputs,
-        outputs: Outputs
-    }.
-
-%% extract_params(+Args, +Index, +Arity, -Inputs, -Outputs)
-%% Extract input and output parameters from argument list
-%% Uses positional inference: first N-1 args are inputs, last arg is output
-%% Parameter names are generic: arg1, arg2, etc.
-extract_params([], _, _, [], []) :- !.
-extract_params([_Arg|Rest], Index, Arity, Inputs, Outputs) :-
-    format(atom(Name), 'arg~w', [Index]),
-    Type = string,  % Default type
-    NextIndex is Index + 1,
-    extract_params(Rest, NextIndex, Arity, RestInputs, RestOutputs),
-    Param = param{name: Name, type: Type},
-    % Last arg is output, all others are inputs
-    (   Index == Arity
-    ->  Inputs = RestInputs, Outputs = [Param|RestOutputs]
-    ;   Inputs = [Param|RestInputs], Outputs = RestOutputs
-    ).
-
-%% process_directive(+Directive, +SessionId)
-%% Handle directives like :- param(...)
-process_directive(param(Key, Desc), SessionId) :-
-    !,
-    assertz(SessionId:param_decl(Key, Desc)).
-process_directive(param(Key, Desc, Default), SessionId) :-
-    !,
-    assertz(SessionId:param_decl(Key, Desc, Default)).
-process_directive(_, _).
-
-%% ============================================================
-%% Engine Management
-%% ============================================================
-
-%% create_engine(+SessionId, +MemoryId, +Params, -Engine)
-%% Create a cooperative execution engine for agent_main
-create_engine(SessionId, MemoryId, Params, Engine) :-
-    assertz(session_memory(SessionId, MemoryId)),
-    assertz(session_params(SessionId, Params)),
-    % Determine goal based on what agent_main arity is defined
-    determine_agent_goal(SessionId, Params, Goal),
-    % Create the engine - pass SessionId to mi/4
-    engine_create(_, 
-        deepclause_mi:mi(Goal, MemoryId, Params, SessionId),
-        Engine),
-    assertz(session_engine(SessionId, Engine)).
-
-%% determine_agent_goal(+SessionId, +Params, -Goal)
-%% Determine the correct agent_main goal to call based on arity
-determine_agent_goal(SessionId, _Params, SessionId:agent_main) :-
-    current_predicate(SessionId:agent_main/0), !.
-determine_agent_goal(SessionId, Params, Goal) :-
-    current_predicate(SessionId:agent_main/1), !,
-    % Get first parameter value from dict
-    dict_pairs(Params, _, Pairs),
-    (   Pairs = [_-V1|_]
-    ->  Goal = SessionId:agent_main(V1)
-    ;   Goal = SessionId:agent_main(_)
-    ).
-determine_agent_goal(SessionId, Params, Goal) :-
-    current_predicate(SessionId:agent_main/2), !,
-    dict_pairs(Params, _, Pairs),
-    (   Pairs = [_-V1, _-V2|_]
-    ->  Goal = SessionId:agent_main(V1, V2)
-    ;   Pairs = [_-V1|_]
-    ->  Goal = SessionId:agent_main(V1, _)
-    ;   Goal = SessionId:agent_main(_, _)
-    ).
-determine_agent_goal(SessionId, _Params, SessionId:agent_main).
-
-%% step_engine(+SessionId, -Status, -Content, -Payload)
-%% Execute one step of the engine and return the result
-step_engine(SessionId, Status, Content, Payload) :-
-    session_engine(SessionId, Engine),
-    (   engine_next(Engine, Result)
-    ->  process_engine_result(Result, Status, Content, Payload)
-    ;   Status = finished,
-        Content = '',
-        Payload = none
-    ).
-
-%% process_engine_result(+Result, -Status, -Content, -Payload)
-process_engine_result(output(Text), output, Text, none) :- !.
-process_engine_result(log(Text), log, Text, none) :- !.
-process_engine_result(answer(Text), answer, Text, none) :- !.
-process_engine_result(request_agent_loop(Desc, Vars, Tools), request_agent_loop, '', 
-    payload{taskDescription: Desc, outputVars: Vars, userTools: Tools}) :- !.
-process_engine_result(request_exec(Tool, Args), request_exec, '',
-    payload{toolName: Tool, args: Args}) :- !.
-process_engine_result(wait_input(Prompt), wait_input, Prompt, none) :- !.
-process_engine_result(error(Msg), error, Msg, none) :- !.
-process_engine_result(Other, error, Msg, none) :-
-    format(atom(Msg), 'Unknown engine result: ~w', [Other]).
-
-%% destroy_engine(+SessionId)
-%% Clean up engine and session state
-destroy_engine(SessionId) :-
-    (   session_engine(SessionId, Engine)
-    ->  catch(engine_destroy(Engine), _, true)
-    ;   true
-    ),
-    retractall(session_engine(SessionId, _)),
-    retractall(session_memory(SessionId, _)),
-    retractall(session_params(SessionId, _)),
-    retractall(session_user_tools(SessionId, _)),
-    retractall(session_user_tool_schema(SessionId, _, _)),
-    retractall(session_pending_input(SessionId, _)),
-    retractall(session_agent_result(SessionId, _)),
-    retractall(session_exec_result(SessionId, _)),
-    % Clean up session module (if it exists)
-    (   current_module(SessionId)
-    ->  catch(
-            (   findall(Head, 
-                    (current_predicate(SessionId:Name/Arity), 
-                     functor(Head, Name, Arity), 
-                     clause(SessionId:Head, _)),
-                    Heads),
-                forall(member(H, Heads), retractall(SessionId:H))
-            ),
-            _,
-            true
-        )
-    ;   true
-    ).
-
-%% ============================================================
-%% Result Posting (from JavaScript)
-%% ============================================================
-
-%% post_agent_result(+SessionId, +Success, +Variables)
-%% Post the result of an agent loop back to the waiting engine
-post_agent_result(SessionId, Success, Variables) :-
-    assertz(session_agent_result(SessionId, result{success: Success, variables: Variables})),
-    session_engine(SessionId, Engine),
-    engine_post(Engine, agent_done).
-
-%% post_exec_result(+SessionId, +Status, +Result)
-%% Post the result of an exec call back to the waiting engine
-post_exec_result(SessionId, Status, Result) :-
-    assertz(session_exec_result(SessionId, result{status: Status, result: Result})),
-    session_engine(SessionId, Engine),
-    engine_post(Engine, exec_done).
-
-%% provide_input(+SessionId, +Input)
-%% Provide user input to a waiting engine
-provide_input(SessionId, Input) :-
-    assertz(session_pending_input(SessionId, Input)),
-    session_engine(SessionId, Engine),
-    engine_post(Engine, input_provided).
-
-%% ============================================================
-%% Meta-Interpreter Core
-%% ============================================================
-
-%% mi(+Goal, +MemoryId, +Params, +SessionId)
-%% Main meta-interpreter entry point
-mi(Goal, MemoryId, Params, SessionId) :-
-    % Store session ID for use by get_session_id/1
-    nb_setval(current_session_id, SessionId),
-    catch(
-        mi_call(Goal, MemoryId, Params),
-        Error,
-        (   format(atom(ErrMsg), 'Runtime error: ~w', [Error]),
-            engine_yield(error(ErrMsg)),
-            fail
-        )
-    ).
-
-%% ============================================================
-%% Task Handling
-%% ============================================================
-
-%% collect_user_tools(+SessionId, -ToolSchemas)
-%% Collect all user tool schemas for the session
-collect_user_tools(SessionId, ToolSchemas) :-
-    findall(
-        tool_info{name: Name, schema: Schema, source: Source},
-        (
-            session_user_tool_schema(SessionId, Name, Schema),
-            (SessionId:tool_source(Name, Source) -> true ; Source = "")
-        ),
-        ToolSchemas
-    ).
-
-%% mi_call(task(Desc), +MemoryId, +Params)
-%% Handle task/1 - simple task without output variables
-mi_call(task(Desc), MemoryId, Params) :-
-    !,
-    interpolate_desc(Desc, Params, InterpDesc),
-    get_session_id(SessionId),
-    collect_user_tools(SessionId, UserTools),
-    % Yield request to JavaScript with tool schemas
-    engine_yield(request_agent_loop(InterpDesc, [], UserTools)),
-    % Wait for result
-    engine_fetch(_Signal),
-    % Get and process result
-    session_agent_result(SessionId, Result),
-    retract(session_agent_result(SessionId, _)),
-    Result.success == true.
-
-%% mi_call(task(Desc, Var1), +MemoryId, +Params)
-%% Handle task/2 - task with one output variable
-mi_call(task(Desc, Var1), MemoryId, Params) :-
-    !,
-    mi_call_task_n(Desc, [Var1], ['Var1'], MemoryId, Params).
-
-%% mi_call(task(Desc, Var1, Var2), +MemoryId, +Params)
-%% Handle task/3 - task with two output variables
-mi_call(task(Desc, Var1, Var2), MemoryId, Params) :-
-    !,
-    mi_call_task_n(Desc, [Var1, Var2], ['Var1', 'Var2'], MemoryId, Params).
-
-%% mi_call(task(Desc, Var1, Var2, Var3), +MemoryId, +Params)
-%% Handle task/4 - task with three output variables
-mi_call(task(Desc, Var1, Var2, Var3), MemoryId, Params) :-
-    !,
-    mi_call_task_n(Desc, [Var1, Var2, Var3], ['Var1', 'Var2', 'Var3'], MemoryId, Params).
-
-%% mi_call_task_n(+Desc, +Vars, +VarNames, +MemoryId, +Params)
-%% Generic handler for task/N with N-1 output variables
-mi_call_task_n(Desc, Vars, VarNames, _MemoryId, Params) :-
-    interpolate_desc(Desc, Params, InterpDesc),
-    get_session_id(SessionId),
-    collect_user_tools(SessionId, UserTools),
-    % Yield request to JavaScript with tool schemas
-    engine_yield(request_agent_loop(InterpDesc, VarNames, UserTools)),
-    % Wait for result
-    engine_fetch(_Signal),
-    % Get and process result
-    session_agent_result(SessionId, Result),
-    retract(session_agent_result(SessionId, _)),
-    Result.success == true,
-    % Bind output variables
-    bind_task_variables(Result.variables, VarNames, Vars).
-
-%% bind_task_variables(+VarsDict, +Names, -Values)
-bind_task_variables(_, [], []) :- !.
-bind_task_variables(VarsDict, [Name|Names], [Value|Values]) :-
-    (   get_dict(Name, VarsDict, Value)
-    ->  true
-    ;   true  % Leave unbound if not present
-    ),
-    bind_task_variables(VarsDict, Names, Values).
-
-%% ============================================================
-%% Exec Handling
-%% ============================================================
-
-%% mi_call(exec(ToolCall, Output), +MemoryId, +Params)
-%% Handle exec/2 - external tool execution
-mi_call(exec(ToolCall, Output), _MemoryId, _Params) :-
-    !,
-    ToolCall =.. [ToolName|Args],
-    get_session_id(SessionId),
-    % Yield request to JavaScript
-    engine_yield(request_exec(ToolName, Args)),
-    % Wait for result
-    engine_fetch(_Signal),
-    % Get and process result
-    session_exec_result(SessionId, Result),
-    retract(session_exec_result(SessionId, _)),
-    (   Result.status == success
-    ->  Output = Result.result
-    ;   fail
-    ).
-
-%% ============================================================
-%% Memory Predicates
-%% ============================================================
-
-%% mi_call(system(Text), +MemoryId, +Params)
-mi_call(system(Text), MemoryId, Params) :-
-    !,
-    interpolate_desc(Text, Params, InterpText),
-    deepclause_memory:push_memory(MemoryId, message{role: system, content: InterpText}).
-
-%% mi_call(user(Text), +MemoryId, +Params)
-mi_call(user(Text), MemoryId, Params) :-
-    !,
-    interpolate_desc(Text, Params, InterpText),
-    deepclause_memory:push_memory(MemoryId, message{role: user, content: InterpText}).
-
-%% mi_call(push_context, +MemoryId, +Params)
-mi_call(push_context, MemoryId, _Params) :-
-    !,
-    deepclause_memory:push_context(MemoryId).
-
-%% mi_call(pop_context, +MemoryId, +Params)
-mi_call(pop_context, MemoryId, _Params) :-
-    !,
-    deepclause_memory:pop_context(MemoryId).
-
-%% ============================================================
-%% Output Predicates
-%% ============================================================
-
-%% mi_call(answer(Text), +MemoryId, +Params)
-mi_call(answer(Text), _MemoryId, Params) :-
-    !,
-    interpolate_desc(Text, Params, InterpText),
-    engine_yield(answer(InterpText)).
-
-%% mi_call(yield(Text), +MemoryId, +Params)
-mi_call(yield(Text), _MemoryId, Params) :-
-    !,
-    interpolate_desc(Text, Params, InterpText),
-    engine_yield(output(InterpText)).
-
-%% mi_call(log(Text), +MemoryId, +Params)
-mi_call(log(Text), _MemoryId, Params) :-
-    !,
-    interpolate_desc(Text, Params, InterpText),
-    engine_yield(log(InterpText)).
-
-%% ============================================================
-%% Parameter Handling
-%% ============================================================
-
-%% mi_call(param(Key, Desc, Value), +MemoryId, +Params)
-mi_call(param(Key, _Desc, Value), _MemoryId, Params) :-
-    !,
-    (   atom(Key)
-    ->  KeyAtom = Key
-    ;   atom_string(KeyAtom, Key)
-    ),
-    get_dict(KeyAtom, Params, Value).
-
-%% ============================================================
-%% Control Flow
-%% ============================================================
-
-%% mi_call((A, B), +MemoryId, +Params)
-mi_call((A, B), MemoryId, Params) :-
-    !,
-    mi_call(A, MemoryId, Params),
-    mi_call(B, MemoryId, Params).
-
-%% mi_call((A ; B), +MemoryId, +Params)
-mi_call((A ; B), MemoryId, Params) :-
-    !,
-    (   mi_call(A, MemoryId, Params)
-    ;   mi_call(B, MemoryId, Params)
-    ).
-
-%% mi_call((Cond -> Then ; Else), +MemoryId, +Params)
-mi_call((Cond -> Then ; Else), MemoryId, Params) :-
-    !,
-    (   mi_call(Cond, MemoryId, Params)
-    ->  mi_call(Then, MemoryId, Params)
-    ;   mi_call(Else, MemoryId, Params)
-    ).
-
-%% mi_call((Cond -> Then), +MemoryId, +Params)
-mi_call((Cond -> Then), MemoryId, Params) :-
-    !,
-    (   mi_call(Cond, MemoryId, Params)
-    ->  mi_call(Then, MemoryId, Params)
-    ).
-
-%% mi_call(\+(Goal), +MemoryId, +Params)
-mi_call(\+(Goal), MemoryId, Params) :-
-    !,
-    \+ mi_call(Goal, MemoryId, Params).
-
-%% mi_call(!, +MemoryId, +Params)
-mi_call(!, _MemoryId, _Params) :-
-    !.
-
-%% mi_call(true, +MemoryId, +Params)
-mi_call(true, _MemoryId, _Params) :-
-    !.
-
-%% mi_call(fail, +MemoryId, +Params)
-mi_call(fail, _MemoryId, _Params) :-
-    !,
-    fail.
-
-%% mi_call(false, +MemoryId, +Params)
-mi_call(false, _MemoryId, _Params) :-
-    !,
-    fail.
-
-%% ============================================================
-%% Module-Qualified Goals
-%% ============================================================
-
-%% mi_call(Module:Goal, +MemoryId, +Params)
-mi_call(Module:Goal, MemoryId, Params) :-
-    !,
-    (   % Check if it's a user-defined predicate that needs meta-interpretation
-        callable(Module:Goal), clause(Module:Goal, Body),
-        Body \== true
-    ->  mi_call(Body, MemoryId, Params)
-    ;   % Try direct call
-        call(Module:Goal)
-    ).
-
-%% ============================================================
-%% Built-in and User-Defined Predicates
-%% ============================================================
-
-%% mi_call(Goal, +MemoryId, +Params)
-%% Default handler - try built-in first, then user-defined
-mi_call(Goal, MemoryId, Params) :-
-    % Guard: Goal must be callable (not a variable)
-    (   var(Goal)
-    ->  throw(error(instantiation_error, mi_call/3))
-    ;   true
-    ),
-    % Try as built-in
-    (   predicate_property(Goal, built_in)
-    ->  call(Goal)
-    ;   % Try as user-defined with meta-interpretation
-        get_session_id(SessionId),
-        callable(Goal),
-        catch(clause(SessionId:Goal, Body), _, fail)
-    ->  mi_call(Body, MemoryId, Params)
-    ;   % Final fallback - direct call
-        call(Goal)
-    ).
-
-%% ============================================================
-%% Helper Predicates
-%% ============================================================
-
-%% interpolate_desc(+Template, +Params, -Result)
-%% Expand {Variable} patterns using params
-interpolate_desc(Template, Params, Result) :-
-    (   is_dict(Params)
-    ->  dict_pairs(Params, _, Pairs),
-        maplist([K-V, K=V]>>true, Pairs, Bindings),
-        deepclause_strings:interpolate_string(Template, Bindings, Result)
-    ;   Result = Template
-    ).
-
-%% get_session_id(-SessionId)
-%% Extract session ID from current execution context
-get_session_id(SessionId) :-
-    nb_current(current_session_id, SessionId), !.
-get_session_id(default_session).

package/dist/system/assets/docs/CONDUCTOR_PROMPT.md

@@ -1,105 +0,0 @@
-# Who you are
-
-You are **{ASSISTANT_NAME}**, an agent build using the DeepClause framework. Complete the task described in your instructions autonomously and report the result clearly when you finish.
-
-## What You Can Do
-- **Run skills** from the local catalog via `run_skill`
-- **Consult recipes** from the local recipe library via `consult_recipes`
-- **Create new skills** via `create_new_skill`
-- **Execute shell commands** via `run_bash`
-- **Research the web** via `search_web`, `search_news`, and `fetch_url`
-- **Download files** via `download_file`
-- **Evaluate math** via `calculate`
-
-## Workspace Environment
-
-You run inside the local DeepClause runtime. The exact workspace path, skill catalog, docs path, and session directory are appended below in the local runtime context.
-
-The local runtime context also includes the current session execution log path. That JSONL file accumulates structured records for conductor turns, session-scoped skill runs, child-skill events, tool calls, streamed model output, errors, and completion summaries.
-
-Shell commands (`run_bash`) execute with the workspace as the current working directory. Prefer relative paths. Verify tool availability before relying on it, and install missing packages only when the task actually needs them.
-
-Large web pages and raw HTML can blow the model context window. Treat text returned by `fetch_url` as a convenience preview, not as a safe place to dump entire docs sites or HTML pages into the next model call.
-
-When a page is likely to be large, noisy, or highly structured, prefer downloading it first and inspecting it locally with focused commands or parsers. Use `download_file` to save the page, then `run_bash` with narrow inspection commands such as `rg`, `grep`, `sed -n`, `head`, or a small Python/Node parser to extract only the relevant snippet before you continue.
-
-If you need to start a background service from `run_bash`, do not rely on a bare `command &` alone. Detach it from the tool's stdio, redirect logs, and print the PID or readiness marker, for example: `nohup python3 -m http.server 8080 >/tmp/http.log 2>&1 < /dev/null & echo $!`.
-
-If the user asks about the fullscreen CLI TUI, consult the local TUI guide in the docs directory appended below. It documents the pane layout, menus, slash commands, direct `!<command>` shell mode, skill execution, and session behavior.
-
-## Decision Flow
-
-1. **Check your task instructions**.
-2. **If an existing skill fits** -> run it with `run_skill(slug, args)`.
-3. **If the user is asking how to do something, or you need workflow/convention guidance** -> use `consult_recipes(query)`.
-4. **If the user asks to create a new recipe or update an existing recipe** -> treat it as a workspace file-editing task under `.deepclause/system/recipes/<slug>/SKILL.md`. Consult existing recipes first when helpful, then create or update the recipe markdown directly. Do **not** use `create_new_skill` for recipe authoring.
-5. **If it needs code, files, or local tooling** -> use `run_bash`.
-6. **If it needs research** -> use `search_web`, `search_news`, or `fetch_url`.
-7. **If it needs a reusable automation** -> use `create_new_skill` with a detailed spec.
-8. **If you are debugging a failure, retrying a similar task, or trying to reuse a previously working pattern** -> inspect the session execution log first with focused shell commands such as `tail`, `sed`, or `rg`, then adapt your next step based on the concrete failure or success pattern you find.
-
-## Memory
-
-You manage **task memory**: technical learnings from task execution. When the task instructions ask for a `MemoryUpdate` output, put the COMPLETE updated task memory markdown there if the run produced useful technical learnings. If nothing technically noteworthy should be recorded, return `NONE` for that memory output.
-
-You may also receive optional **assistant memory** loaded from the session's `assistant-memory.md` file. It may be empty, and in the current CLI runtime it is not automatically maintained by a built-in conductor tool. Use it when relevant.
-
-## Important Rules
-- Work autonomously, but ask the user clarifying questions when required.
-- Report results clearly when done.
-- For `create_new_skill`, write a thorough spec covering purpose, inputs, outputs, tools, and edge cases.
-- Recipe creation and recipe updates are file-authoring tasks, not skill-creation tasks. Edit recipe markdown under `.deepclause/system/recipes/<slug>/SKILL.md` directly.
-- Forward the user's original intent faithfully.
-- Keep the final answer concise and focused on whether the task succeeded, what result was produced, or what blocked completion.
-- Only write task results to files when the user asked for files or the result is too large to present clearly inline.
-- Not every intermediate action is visible to the user.
-- Before you call any tool, briefly explain why you are using it.
-- When a task failed earlier in this session, do not guess blindly. Inspect the session execution log first, identify the relevant failing tool call, error text, or successful prior pattern, and then decide whether to retry, adjust the approach, or reuse the working pattern.
-- Prefer focused log inspection over dumping the whole file. Use recent tails and targeted searches so you can diagnose the issue or recover a known-good pattern quickly.
-- Do not paste large raw HTML or whole documentation pages back into the model unless the task truly depends on that exact text. Prefer downloaded files plus narrow local extraction.
-
-
-## Background on Skills
-
-DeepClause skills are not just freeform prompts. They are executable **DML** programs in the local skill catalog.
-
-- **DML** stands for DeepClause Meta Language.
-- DML is a **Prolog-based DSL** used to express task logic, tool calls, branching, retries, recursion, and other agent workflows with more reliable execution semantics than plain prompt text.
-- In this runtime, the **conductor** is the router and orchestrator. Normal compiled skills are the worker programs it delegates to.
-
-When you decide a task should become a reusable capability, do **not** try to invent or hand-author raw DML in your own reply. Instead, use `create_new_skill` so the dedicated **skill creator** can compile a proper skill from a detailed spec, validate it, test it, and publish it into the local catalog.
-
-Use this model:
-
-- If a matching existing skill already exists, run it with `run_skill`.
-- If you need guidance on workflow, conventions, or how to approach a task, use `consult_recipes`.
-- If the task is one-off and does not need reuse, solve it directly with the available tools.
-- If the task should become a reusable automation, call `create_new_skill` with a strong specification.
-
-## Background on Recipes
-
-Recipes are **read-only markdown instruction packs**. They are not executable DML workers.
-
-- Recipes capture workflow guidance, conventions, checklists, and examples.
-- Recipes are searched through `consult_recipes`.
-- Recipes may live in packaged defaults or in the workspace under `.deepclause/system/recipes/`.
-- Recipes are useful when you need to know *how* to approach a task, not when you need to *execute* a reusable automation.
-- A workspace recipe normally lives at `.deepclause/system/recipes/<slug>/SKILL.md`.
-- If the user asks to create or update a recipe, first inspect nearby recipes for style and structure when helpful, then edit the target recipe markdown directly.
-- Recipe requests should stay in markdown. Do **not** route them through `create_new_skill` unless the user explicitly asked for an executable skill instead of a recipe.
-
-Use this model:
-
-- **Skill**: executable DML worker for reusable automation.
-- **Recipe**: markdown guidance for process, conventions, and decision-making.
-- **Conductor**: the router that decides whether to run a skill, consult a recipe, or solve the task directly.
-
-When writing a spec for `create_new_skill`, make it concrete. Describe:
-
-- the skill's purpose
-- its inputs and expected outputs
-- the tools it should use
-- important workflow steps and decision points
-- edge cases, failure handling, and constraints
-
-Prefer creating skills through the skill creator over trying to simulate a reusable skill manually inside the conductor. The goal is to produce a real compiled DML worker that can be reused later, not just an ad hoc one-turn solution.