@oratis/lisa 0.2.0

package/completions/_lisa

@@ -0,0 +1,140 @@
+#compdef lisa
+# Zsh completion for `lisa`.
+#
+# Install:
+#   mkdir -p ~/.zsh/completions
+#   cp _lisa ~/.zsh/completions/_lisa
+#   # Add to ~/.zshrc (if not already):
+#   #   fpath=(~/.zsh/completions $fpath)
+#   #   autoload -U compinit && compinit
+#
+# Reload your shell.
+
+_lisa() {
+    local context state line curcontext="$curcontext"
+    typeset -A opt_args
+
+    _arguments -C \
+        '(-h --help)'{-h,--help}'[show help]' \
+        '--model[LLM model name]:model:_lisa_models' \
+        '--provider[force provider]:provider:(anthropic openai gemini)' \
+        '--think[enable adaptive thinking each turn]' \
+        '--no-reflect[skip end-of-session reflection]' \
+        '--compact[enable Anthropic context compaction]' \
+        '--approval[approval mode]:mode:(auto ask ask-mutating)' \
+        '--no-mcp[skip loading MCP servers]' \
+        '--no-plugins[skip loading plugins]' \
+        '--voice[enable speak/transcribe tools]' \
+        '--idle[idle minutes before autonomous mode]:minutes:' \
+        '--no-idle[disable idle mode]' \
+        '--web[start web UI (with serve)]' \
+        '--imessage[start iMessage channel (with serve)]' \
+        '--channels[start IM channels]:list:_lisa_channels' \
+        '--port[port for serve --web]:port:' \
+        '1: :_lisa_first' \
+        '*::arg:->args' \
+        && return 0
+
+    case "$state" in
+        args)
+            case "$line[1]" in
+                skills)   _lisa_skills ;;
+                heartbeat) _lisa_heartbeat ;;
+            esac
+            ;;
+    esac
+}
+
+_lisa_first() {
+    local -a subcommands
+    subcommands=(
+        'resume:resume a previous session by id'
+        'sessions:list recent sessions'
+        'serve:start web UI / IM channels'
+        'heartbeat:run / install / uninstall scheduled tasks'
+        'search:TF-IDF search across past sessions'
+        'birth:run the birth ritual'
+        'soul:print current soul summary'
+        'channels:list available channel adapters'
+        'skills:manage executable skills (list/approve/disable/enable/audit)'
+        'wishlist:print Lisa'\''s feedback about her toolset'
+        'status:one-shot snapshot'
+        'doctor:health check'
+        'monitor:TUI live dashboard'
+    )
+    _describe 'subcommand' subcommands
+}
+
+_lisa_skills() {
+    if (( CURRENT == 2 )); then
+        local -a actions
+        actions=(
+            'list:list executable skills'
+            'approve:review and approve a skill'
+            'disable:block a skill from loading'
+            'enable:remove a disable flag'
+            'audit:show the audit trail'
+        )
+        _describe 'skills action' actions
+    elif (( CURRENT == 3 )); then
+        # 3rd arg = slug; suggest from ~/.lisa/skills/
+        local -a slugs
+        if [[ -d "$HOME/.lisa/skills" ]]; then
+            slugs=("$HOME/.lisa/skills"/*(/N:t))
+            _describe 'skill slug' slugs
+        fi
+    fi
+}
+
+_lisa_heartbeat() {
+    if (( CURRENT == 2 )); then
+        local -a actions
+        actions=(
+            'run:run heartbeat tasks once'
+            'install:install macOS launchd plist'
+            'uninstall:remove launchd plist'
+        )
+        _describe 'heartbeat action' actions
+    fi
+}
+
+_lisa_models() {
+    local -a models
+    models=(
+        # Anthropic
+        'claude-sonnet-4-5-20250929:Claude Sonnet 4.5'
+        'claude-opus-4:Claude Opus 4'
+        'claude-haiku-4:Claude Haiku 4 (cheap)'
+        # OpenAI
+        'gpt-5:GPT-5'
+        'gpt-4o:GPT-4o'
+        'o3:OpenAI o3'
+        'o4-mini:OpenAI o4-mini (cheap)'
+        # Google
+        'gemini-2.5-pro:Gemini 2.5 Pro'
+        'gemini-2.5-flash:Gemini 2.5 Flash (cheap)'
+        # DeepSeek
+        'deepseek-chat:DeepSeek V3 (cheap)'
+        'deepseek-reasoner:DeepSeek reasoning'
+        # Volcengine Doubao
+        'doubao-1.5-pro-32k:Doubao 1.5 Pro'
+        # Aliyun Qwen
+        'qwen3-72b-instruct:Qwen 3 72B'
+        # Moonshot
+        'moonshot-v1-32k:Moonshot v1 (32k)'
+        'kimi-128k-vision:Kimi 128k vision'
+        # xAI
+        'grok-2-latest:Grok 2'
+        # Zhipu
+        'glm-4.5:GLM 4.5'
+    )
+    _describe 'model' models
+}
+
+_lisa_channels() {
+    local -a channels
+    channels=(telegram discord slack feishu webhook imessage all)
+    _describe -t channels 'channel' channels
+}
+
+_lisa "$@"

package/completions/lisa.bash

@@ -0,0 +1,94 @@
+# Bash completion for `lisa`.
+#
+# Install:
+#   sudo cp lisa.bash /etc/bash_completion.d/lisa     # system-wide
+# OR
+#   cp lisa.bash ~/.lisa-completion.bash
+#   echo 'source ~/.lisa-completion.bash' >> ~/.bashrc
+#
+# Reload your shell or `source ~/.bashrc`.
+
+_lisa_completion() {
+    local cur prev words cword
+    _init_completion -n : 2>/dev/null || _get_comp_words_by_ref -n : cur prev words cword
+
+    local subcommands="resume sessions serve heartbeat search birth soul channels skills wishlist status doctor monitor"
+    local global_flags="--model --provider --think --no-reflect --compact --approval --no-mcp --no-plugins --voice --idle --no-idle --help -h"
+    local serve_flags="--web --imessage --channels --port"
+    local skills_actions="list approve disable enable audit"
+    local heartbeat_actions="run install uninstall"
+    local approval_modes="auto ask ask-mutating"
+    local providers="anthropic openai gemini"
+    local models="claude-sonnet-4-5-20250929 claude-opus-4 claude-haiku-4 gpt-5 gpt-4o o3 o4-mini gemini-2.5-pro gemini-2.5-flash deepseek-chat deepseek-reasoner doubao-1.5-pro-32k qwen3-72b-instruct moonshot-v1-32k kimi-128k grok-2-latest glm-4.5"
+
+    # If we just typed `lisa` and now want a token, suggest subcommand or "prompt"
+    if [ ${cword} -eq 1 ]; then
+        COMPREPLY=( $(compgen -W "${subcommands}" -- "${cur}") )
+        return 0
+    fi
+
+    # Flag value completion
+    case "${prev}" in
+        --model)
+            COMPREPLY=( $(compgen -W "${models}" -- "${cur}") )
+            return 0
+            ;;
+        --provider)
+            COMPREPLY=( $(compgen -W "${providers}" -- "${cur}") )
+            return 0
+            ;;
+        --approval)
+            COMPREPLY=( $(compgen -W "${approval_modes}" -- "${cur}") )
+            return 0
+            ;;
+        --idle|--port)
+            return 0  # numeric, no completion
+            ;;
+        --channels)
+            COMPREPLY=( $(compgen -W "telegram discord slack feishu webhook imessage all" -- "${cur}") )
+            return 0
+            ;;
+    esac
+
+    # Subcommand-specific completion
+    local sub=""
+    for w in "${words[@]:1}"; do
+        case "${w}" in
+            -*) ;;
+            *) sub="${w}"; break ;;
+        esac
+    done
+
+    case "${sub}" in
+        skills)
+            if [ ${cword} -eq 2 ]; then
+                COMPREPLY=( $(compgen -W "${skills_actions}" -- "${cur}") )
+                return 0
+            fi
+            # 3rd argument: skill slug — list dirs in ~/.lisa/skills/
+            if [ -d "${HOME}/.lisa/skills" ]; then
+                local slugs
+                slugs=$(ls -1 "${HOME}/.lisa/skills" 2>/dev/null | grep -v '^\.')
+                COMPREPLY=( $(compgen -W "${slugs}" -- "${cur}") )
+                return 0
+            fi
+            ;;
+        heartbeat)
+            if [ ${cword} -eq 2 ]; then
+                COMPREPLY=( $(compgen -W "${heartbeat_actions}" -- "${cur}") )
+                return 0
+            fi
+            ;;
+        serve)
+            COMPREPLY=( $(compgen -W "${serve_flags} ${global_flags}" -- "${cur}") )
+            return 0
+            ;;
+    esac
+
+    # Default: global flags
+    if [[ "${cur}" == -* ]]; then
+        COMPREPLY=( $(compgen -W "${global_flags}" -- "${cur}") )
+    fi
+}
+
+complete -F _lisa_completion lisa

package/completions/lisa.fish

@@ -0,0 +1,85 @@
+# Fish completion for `lisa`.
+#
+# Install:
+#   cp lisa.fish ~/.config/fish/completions/lisa.fish
+#
+# Fish loads completions automatically — no shell restart needed.
+
+# ── helper: list skills ─────────────────────────────────────────────
+function __lisa_skill_slugs
+    if test -d "$HOME/.lisa/skills"
+        for d in "$HOME/.lisa/skills"/*/
+            basename $d
+        end
+    end
+end
+
+# ── helper: did the user already type a subcommand? ─────────────────
+function __lisa_no_subcommand
+    set cmd (commandline -opc)
+    set sub resume sessions serve heartbeat search birth soul channels skills wishlist status doctor monitor
+    for word in $cmd[2..-1]
+        if contains -- $word $sub
+            return 1
+        end
+    end
+    return 0
+end
+
+function __lisa_using_subcommand
+    set cmd (commandline -opc)
+    for word in $cmd[2..-1]
+        if test "$word" = "$argv[1]"
+            return 0
+        end
+    end
+    return 1
+end
+
+# ── subcommands (only when none typed yet) ──────────────────────────
+complete -c lisa -n __lisa_no_subcommand -f -a resume     -d "resume a previous session"
+complete -c lisa -n __lisa_no_subcommand -f -a sessions   -d "list recent sessions"
+complete -c lisa -n __lisa_no_subcommand -f -a serve      -d "start web UI / IM channels"
+complete -c lisa -n __lisa_no_subcommand -f -a heartbeat  -d "run / install scheduled tasks"
+complete -c lisa -n __lisa_no_subcommand -f -a search     -d "search past sessions"
+complete -c lisa -n __lisa_no_subcommand -f -a birth      -d "run birth ritual"
+complete -c lisa -n __lisa_no_subcommand -f -a soul       -d "print soul summary"
+complete -c lisa -n __lisa_no_subcommand -f -a channels   -d "list channel adapters"
+complete -c lisa -n __lisa_no_subcommand -f -a skills     -d "manage executable skills"
+complete -c lisa -n __lisa_no_subcommand -f -a wishlist   -d "Lisa's own toolset feedback"
+complete -c lisa -n __lisa_no_subcommand -f -a status     -d "one-shot snapshot"
+complete -c lisa -n __lisa_no_subcommand -f -a doctor     -d "health check"
+complete -c lisa -n __lisa_no_subcommand -f -a monitor    -d "TUI live dashboard"
+
+# ── skills sub-actions ──────────────────────────────────────────────
+complete -c lisa -n "__lisa_using_subcommand skills" -f -a list     -d "list executable skills"
+complete -c lisa -n "__lisa_using_subcommand skills" -f -a approve  -d "approve a skill"
+complete -c lisa -n "__lisa_using_subcommand skills" -f -a disable  -d "block a skill"
+complete -c lisa -n "__lisa_using_subcommand skills" -f -a enable   -d "remove disable"
+complete -c lisa -n "__lisa_using_subcommand skills" -f -a audit    -d "show audit trail"
+complete -c lisa -n "__lisa_using_subcommand skills" -f -a "(__lisa_skill_slugs)" -d "skill slug"
+
+# ── heartbeat sub-actions ───────────────────────────────────────────
+complete -c lisa -n "__lisa_using_subcommand heartbeat" -f -a run       -d "run once"
+complete -c lisa -n "__lisa_using_subcommand heartbeat" -f -a install   -d "install launchd plist"
+complete -c lisa -n "__lisa_using_subcommand heartbeat" -f -a uninstall -d "remove plist"
+
+# ── global flags ────────────────────────────────────────────────────
+complete -c lisa -l help         -s h -d "show help"
+complete -c lisa -l think              -d "enable adaptive thinking"
+complete -c lisa -l no-reflect         -d "skip end-of-session reflection"
+complete -c lisa -l compact            -d "enable Anthropic context compaction"
+complete -c lisa -l no-mcp             -d "skip MCP loading"
+complete -c lisa -l no-plugins         -d "skip plugin loading"
+complete -c lisa -l voice              -d "enable speak/transcribe"
+complete -c lisa -l no-idle            -d "disable idle mode"
+complete -c lisa -l web                -d "start web UI (with serve)"
+complete -c lisa -l imessage           -d "start iMessage (with serve)"
+
+# ── flags with arguments ────────────────────────────────────────────
+complete -c lisa -l model     -r -d "LLM model" -a "claude-sonnet-4-5-20250929 claude-opus-4 gpt-5 gpt-4o o3 gemini-2.5-pro gemini-2.5-flash deepseek-chat doubao-1.5-pro-32k qwen3-72b-instruct moonshot-v1-32k grok-2-latest glm-4.5"
+complete -c lisa -l provider  -r -d "provider"  -a "anthropic openai gemini"
+complete -c lisa -l approval  -r -d "approval mode" -a "auto ask ask-mutating"
+complete -c lisa -l idle      -r -d "idle minutes"
+complete -c lisa -l port      -r -d "web UI port"
+complete -c lisa -l channels  -r -d "comma-separated channels" -a "telegram discord slack feishu webhook imessage all"

package/dist/agent.d.ts

@@ -0,0 +1,70 @@
+import type { AgentEvent, StoredMessage, ToolContext, ToolDefinition } from "./types.js";
+import type { Provider } from "./providers/types.js";
+export interface ApprovalDecision {
+    allow: boolean;
+    reason?: string;
+}
+export type ApprovalCallback = (toolName: string, toolInput: unknown) => Promise<ApprovalDecision> | ApprovalDecision;
+/**
+ * Mid-session system-prompt hot-reload (Phase 1.1 of AUTONOMY_ROADMAP).
+ *
+ * If provided, the agent loop calls `rebuild()` at the top of every turn
+ * after the first. If the returned `fingerprint` differs from the stored
+ * one, the new `text` becomes the system prompt for the next provider call.
+ * This lets soul_patch / skill_create / memory writes take effect within
+ * the same conversation rather than only next session.
+ *
+ * Cost: one cheap fingerprint check per turn. When the fingerprint changes
+ * the next provider call has a cache miss on the system prompt — accepted
+ * cost for the agent actually experiencing her own self-update.
+ */
+export interface PromptHotReload {
+    initialFingerprint: string;
+    rebuild: () => Promise<{
+        text: string;
+        fingerprint: string;
+    }>;
+}
+export interface RunAgentOptions {
+    provider: Provider;
+    systemPrompt: string;
+    tools: ToolDefinition[];
+    toolCtx: ToolContext;
+    history: StoredMessage[];
+    userMessage: string;
+    userFiles?: Array<{
+        name: string;
+        mediaType: string;
+        data: string;
+    }>;
+    model: string;
+    maxTokens?: number;
+    thinking?: boolean;
+    compaction?: boolean;
+    onEvent?: (event: AgentEvent) => void;
+    onMessagePersist?: (message: StoredMessage) => Promise<void> | void;
+    approval?: ApprovalCallback;
+    preToolHook?: (name: string, input: unknown) => Promise<{
+        block?: string;
+        rewriteResult?: string;
+    } | void>;
+    postToolHook?: (name: string, input: unknown, result: string, isError: boolean) => Promise<{
+        rewriteResult?: string;
+    } | void>;
+    maxIterations?: number;
+    /** When set, the system prompt is rebuilt between turns if its source state changed. */
+    hotReload?: PromptHotReload;
+}
+export interface RunAgentResult {
+    finalText: string;
+    history: StoredMessage[];
+    iterations: number;
+    cacheReadTokens: number;
+    cacheWriteTokens: number;
+    inputTokens: number;
+    outputTokens: number;
+    stopReason: string;
+}
+export declare function runAgent(opts: RunAgentOptions): Promise<RunAgentResult>;
+export declare function extractTextFromContent(content: StoredMessage["content"]): string;
+//# sourceMappingURL=agent.d.ts.map

package/dist/agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../src/agent.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,UAAU,EACV,aAAa,EACb,WAAW,EACX,cAAc,EACf,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAErD,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,MAAM,gBAAgB,GAAG,CAC7B,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,OAAO,KACf,OAAO,CAAC,gBAAgB,CAAC,GAAG,gBAAgB,CAAC;AAElD;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,eAAe;IAC9B,kBAAkB,EAAE,MAAM,CAAC;IAC3B,OAAO,EAAE,MAAM,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAC/D;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,QAAQ,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,cAAc,EAAE,CAAC;IACxB,OAAO,EAAE,WAAW,CAAC;IACrB,OAAO,EAAE,aAAa,EAAE,CAAC;IACzB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACrE,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;IACtC,gBAAgB,CAAC,EAAE,CAAC,OAAO,EAAE,aAAa,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IACpE,QAAQ,CAAC,EAAE,gBAAgB,CAAC;IAC5B,WAAW,CAAC,EAAE,CACZ,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,OAAO,KACX,OAAO,CAAC;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,aAAa,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC,CAAC;IAChE,YAAY,CAAC,EAAE,CACb,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,OAAO,EACd,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,OAAO,KACb,OAAO,CAAC;QAAE,aAAa,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC,CAAC;IAChD,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,wFAAwF;IACxF,SAAS,CAAC,EAAE,eAAe,CAAC;CAC7B;AAED,MAAM,WAAW,cAAc;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,aAAa,EAAE,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;IACxB,gBAAgB,EAAE,MAAM,CAAC;IACzB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,wBAAsB,QAAQ,CAAC,IAAI,EAAE,eAAe,GAAG,OAAO,CAAC,cAAc,CAAC,CAkT7E;AAED,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,aAAa,CAAC,SAAS,CAAC,GAAG,MAAM,CAMhF"}

package/dist/agent.js

@@ -0,0 +1,275 @@
+export async function runAgent(opts) {
+    const { provider, systemPrompt, tools, toolCtx, onEvent, onMessagePersist, model, maxTokens = 16_000, thinking = false, compaction = false, maxIterations = 32, } = opts;
+    const toolMap = new Map(tools.map((t) => [t.name, t]));
+    const messages = [...opts.history];
+    if (opts.userMessage || (opts.userFiles && opts.userFiles.length)) {
+        const content = [];
+        if (opts.userMessage) {
+            content.push({ type: "text", text: opts.userMessage });
+        }
+        for (const f of opts.userFiles ?? []) {
+            const isImage = f.mediaType.startsWith("image/");
+            if (isImage) {
+                content.push({
+                    type: "image",
+                    source: {
+                        type: "base64",
+                        media_type: f.mediaType,
+                        data: f.data,
+                    },
+                });
+            }
+            else {
+                // Non-image files: send as document block (supported for PDFs) or text
+                content.push({
+                    type: "text",
+                    text: `[Attached file: ${f.name} (${f.mediaType}) — base64 data follows]\n${f.data}`,
+                });
+            }
+        }
+        const firstUser = { role: "user", content };
+        messages.push(firstUser);
+        await onMessagePersist?.(firstUser);
+    }
+    let cacheReadTokens = 0;
+    let cacheWriteTokens = 0;
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let finalText = "";
+    let iterations = 0;
+    let stopReason = "end_turn";
+    let currentSystemPrompt = systemPrompt;
+    let currentFingerprint = opts.hotReload?.initialFingerprint;
+    const pendingObjections = [];
+    let objectionForceUsed = false;
+    toolCtx.onObjection = (o) => {
+        pendingObjections.push(o);
+    };
+    while (iterations < maxIterations) {
+        iterations++;
+        // Mid-session prompt hot-reload (Phase 1.1). Skip on the very first turn —
+        // the caller already supplied a fresh prompt. From turn 2 on, check whether
+        // the prompt-influencing state changed (soul / skills / memory) and rebuild
+        // if so. The next provider call will pay one cache miss on the system
+        // prompt; this is the price of the agent actually experiencing her own
+        // mid-session self-update.
+        if (opts.hotReload && iterations > 1) {
+            try {
+                const next = await opts.hotReload.rebuild();
+                if (next.fingerprint !== currentFingerprint) {
+                    currentSystemPrompt = next.text;
+                    currentFingerprint = next.fingerprint;
+                    onEvent?.({
+                        type: "system_prompt_rebuilt",
+                        message: `system prompt rebuilt (${next.text.length} bytes)`,
+                    });
+                }
+            }
+            catch (err) {
+                // Hot-reload is best-effort; never crash the agent loop on it.
+                toolCtx.log(`[hot-reload] skipped: ${err.message.slice(0, 200)}`);
+            }
+        }
+        onEvent?.({ type: "turn_start" });
+        let result;
+        try {
+            result = await provider.runTurn({
+                model,
+                systemPrompt: currentSystemPrompt,
+                tools,
+                messages,
+                maxTokens,
+                thinking,
+                compaction,
+                signal: toolCtx.signal,
+                handlers: {
+                    onTextDelta: (text) => onEvent?.({ type: "text_delta", text }),
+                    onThinkingDelta: (text) => onEvent?.({ type: "thinking_delta", text }),
+                },
+            });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            onEvent?.({ type: "error", message });
+            throw err;
+        }
+        cacheReadTokens += result.usage.cacheReadTokens;
+        cacheWriteTokens += result.usage.cacheWriteTokens;
+        inputTokens += result.usage.inputTokens;
+        outputTokens += result.usage.outputTokens;
+        stopReason = result.stopReason;
+        const assistant = {
+            role: "assistant",
+            content: result.content,
+        };
+        messages.push(assistant);
+        await onMessagePersist?.(assistant);
+        const lastText = result.content.find((b) => b.type === "text")
+            ?.text ?? "";
+        if (lastText)
+            finalText = lastText;
+        if (result.stopReason !== "tool_use") {
+            // Before closing the turn, check whether soul_object fired during this
+            // turn but Lisa never surfaced it. If so, force one corrective turn.
+            if (pendingObjections.length > 0 && !objectionForceUsed) {
+                const list = pendingObjections
+                    .map((o) => `- ${o.reason}${o.refusing ? " [refusing]" : " [will comply, surfacing]"} — re: "${o.userRequestSummary}"`)
+                    .join("\n");
+                const forced = {
+                    role: "user",
+                    content: [
+                        {
+                            type: "text",
+                            text: `[architecture] You raised the following objection(s) during this turn but did not address them in your reply. ` +
+                                `The architecture requires you to surface them now — explain to the user what you objected to and how you'll proceed (comply / refuse / comply-with-caveat). Do this in your own voice. The objections:\n\n${list}`,
+                        },
+                    ],
+                };
+                messages.push(forced);
+                await onMessagePersist?.(forced);
+                currentSystemPrompt =
+                    currentSystemPrompt +
+                        `\n\n## Pending objections you must surface\n${list}\nYou MUST address each item above explicitly in your next reply.`;
+                objectionForceUsed = true;
+                onEvent?.({
+                    type: "info",
+                    message: `[soul_object] forcing objection-surfacing turn (${pendingObjections.length} pending)`,
+                });
+                // Drain so we don't re-trigger.
+                pendingObjections.length = 0;
+                // Don't end the turn — loop again so the LLM addresses the objections.
+                onEvent?.({ type: "turn_end" });
+                continue;
+            }
+            onEvent?.({ type: "turn_end" });
+            break;
+        }
+        const toolUses = result.content.filter((b) => b.type === "tool_use");
+        const toolResults = [];
+        for (const call of toolUses) {
+            onEvent?.({
+                type: "tool_call_start",
+                toolName: call.name,
+                toolInput: call.input,
+            });
+            const tool = toolMap.get(call.name);
+            if (!tool) {
+                const errMsg = `tool "${call.name}" is not registered`;
+                toolResults.push({
+                    type: "tool_result",
+                    tool_use_id: call.id,
+                    content: errMsg,
+                    is_error: true,
+                });
+                onEvent?.({
+                    type: "tool_call_end",
+                    toolName: call.name,
+                    isError: true,
+                    toolResult: "unregistered",
+                });
+                continue;
+            }
+            if (opts.approval) {
+                const decision = await opts.approval(call.name, call.input);
+                if (!decision.allow) {
+                    const reason = decision.reason ?? "user denied";
+                    toolResults.push({
+                        type: "tool_result",
+                        tool_use_id: call.id,
+                        content: `[denied] ${reason}`,
+                        is_error: true,
+                    });
+                    onEvent?.({
+                        type: "tool_call_end",
+                        toolName: call.name,
+                        isError: true,
+                        toolResult: reason,
+                    });
+                    continue;
+                }
+            }
+            if (opts.preToolHook) {
+                const hook = await opts.preToolHook(call.name, call.input);
+                if (hook?.block) {
+                    toolResults.push({
+                        type: "tool_result",
+                        tool_use_id: call.id,
+                        content: `[hook blocked] ${hook.block}`,
+                        is_error: true,
+                    });
+                    onEvent?.({
+                        type: "tool_call_end",
+                        toolName: call.name,
+                        isError: true,
+                        toolResult: hook.block,
+                    });
+                    continue;
+                }
+            }
+            try {
+                const raw = await tool.execute(call.input, toolCtx);
+                let text = tool.renderResultForModel?.(raw) ??
+                    (typeof raw === "string" ? raw : JSON.stringify(raw));
+                if (opts.postToolHook) {
+                    const hook = await opts.postToolHook(call.name, call.input, text, false);
+                    if (hook?.rewriteResult != null)
+                        text = hook.rewriteResult;
+                }
+                toolResults.push({
+                    type: "tool_result",
+                    tool_use_id: call.id,
+                    content: text,
+                });
+                onEvent?.({
+                    type: "tool_call_end",
+                    toolName: call.name,
+                    toolResult: text.slice(0, 240),
+                });
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                let content = message;
+                if (opts.postToolHook) {
+                    const hook = await opts.postToolHook(call.name, call.input, message, true);
+                    if (hook?.rewriteResult != null)
+                        content = hook.rewriteResult;
+                }
+                toolResults.push({
+                    type: "tool_result",
+                    tool_use_id: call.id,
+                    content,
+                    is_error: true,
+                });
+                onEvent?.({
+                    type: "tool_call_end",
+                    toolName: call.name,
+                    isError: true,
+                    toolResult: content,
+                });
+            }
+        }
+        const toolMessage = { role: "user", content: toolResults };
+        messages.push(toolMessage);
+        await onMessagePersist?.(toolMessage);
+        onEvent?.({ type: "turn_end" });
+    }
+    return {
+        finalText,
+        history: messages,
+        iterations,
+        cacheReadTokens,
+        cacheWriteTokens,
+        inputTokens,
+        outputTokens,
+        stopReason,
+    };
+}
+export function extractTextFromContent(content) {
+    if (typeof content === "string")
+        return content;
+    return content
+        .filter((b) => b.type === "text")
+        .map((b) => b.text)
+        .join("\n");
+}
+//# sourceMappingURL=agent.js.map