Create a new session. Bootstraps the data store on first use.

    Without `mode`, returns a mode-required directive payload. With a
    valid `mode`, the session is created with that mode already set and
    the tool proceeds immediately -- no separate `set_session_mode`
    call needed. `stages` accepts a JSON array or a comma/newline
    list; `overrides` a JSON object or its string form (tolerant input,
    Task 13).
    

Set a session's mode. Only succeeds if no mode is set yet -- once set, mode is immutable for the life of the session.

Return both modes' descriptions + recommendations, for the model to relay to the user.

Return a session's persisted state.

List every session in the index.

Wipe a session: deletes its file and removes it from the index.

Mark a session finalized. Returns the finalize+move payload: where the session is saved, the canned human_prompt asking whether to move it, and the two tools (move_session, keep_here) that answer that question.

Move a session's file to new_path.

    `new_path` must be an absolute path (`~` is expanded). If it names
    an existing directory, the session moves into that directory under
    its current filename. Fails cleanly -- without touching the
    session or the filesystem -- if the destination already exists
    (unless `force=true`), isn't writable, or doesn't exist. `force`
    accepts a real bool or a word ("true"/"yes"/...) -- tolerant input.
    

Record that the user declined to move the session. No filesystem change.

Advance the session's stage cursor to the next stage in its expected_stages. Fails cleanly with a directive payload pointing at finalize_session if the session is already at its final stage -- there is nowhere further to advance to.

Draft a new thought in the session's current stage. Fails with a directive if a thought is already in progress (commit it first). tags/axioms accept a JSON array or a comma/newline list.

Open a critique round and return the lens template to apply. Omit lens to let the server pick a stage-appropriate one and rotate through the library. The response places the current draft content immediately before the lens template (adjacency contract).

Record the critique produced by applying the current lens.

Rewrite the thought to address the critique. The server records the new version and its normalized edit distance vs. the prior one. challenged_assumptions accepts a JSON array or a comma/newline list.

Self-score the refined thought across the 7 utility dimensions (partial input is tolerated -- missing dims carry forward). scores accepts a JSON object, fenced JSON, or "correctness: 0.8, ..." text. Returns the convergence verdict: whether to commit or run another lens.

Lock the current thought (writing its final refined content back as the thought's content) and clear the current-thought cursor. Fails with a directive if no critique round has completed yet.

Start a subagent thought. With engine="necort" this runs the first Nash equilibrium round via the vendored core over the configured specialist framings (needs an endpoint; when none is configured it points at the manual path). With engine="manual" (T13) this hands back specialist #1's prompt for the calling model to voice itself -- no endpoint, no network, no NECoRT code. Fails with a directive if a thought is already in progress.

Advance the subagent thought by one step.

    `engine="necort"`: runs the next Nash round, re-seeding the current
    best candidate (`candidate`/`scores` are ignored). `engine="manual"`
    (T13): records the current specialist's `candidate` + 7-dim `scores`
    (tolerant input -- JSON or "correctness: 0.8, ..." text) and hands the
    next specialist's prompt, or -- when the roster is exhausted -- runs
    the deterministic selection and returns the round result. Calling with
    no `candidate` at a round boundary (re)starts the next round's first
    specialist. The round budget (`subagent.max_rounds`) is enforced here.
    

Return the current Nash scoring state: the latest round's per-candidate utility vectors, equilibrium states, and selected winner. Read-only (no engine mutation, no network).

Accept the current equilibrium: lock the winning candidate as the thought's content and clear the current-thought cursor. Fails with a directive if no Nash round has run yet.

Authoritative resolver: given this session's persisted state and mode, return the exact next tool to call and a one-line directive. Safe to call at any point in a session's lifecycle -- before a mode is set, mid-critique-loop, right after a thought commits, at the final stage, or once finalized.

Deterministic extractive digest of this session's committed thoughts. scope="stage" (default) covers only the current stage; scope="all" covers every stage. No LLM calls -- this is text extraction, not summarization by inference.

Deterministic extractive digest of prior stages' committed thoughts, capped at target_tokens (a cheap len(text)//4 heuristic -- no tokenizer dependency). The current stage is left out; its detail is already visible via the live loop tools/ summarize_session. For small-context local models that can't hold a whole session's history.

Return this session's complete state as a JSON-serializable dict, suitable for handing straight to import_session.

Recreate a session from a previous export_session payload (a dict, or its JSON string form). Validated on the way in. If the imported session's id collides with one already on this install, a fresh id (and save path) is assigned automatically rather than overwriting the existing session -- collision-safe import.