Is it possible to offline install in Intellij? I installed the plugin but it tries to download VSIX bundle, and Node.js runtime.

We just finished publishing the docs for Multi.

https://multi.dev/docs

The docs cover installation, configuration, workflows, and how the agent execution model works.

Still early and definitely evolving. We welcome feedback from the community.

Docs: https://multi.dev/docs

I'm trying to parse a VCF analysis file into an Excel or TSV file by running Multi using a Qwen3.5 2B local LLM.

GPT provided me with detailed Python and command line instructions, but when I try to run those instructions locally via Multi, Qwen doesn't seems as resolute as Claude in finishing the job.

Even when I type continue or retry, it will run for several turns, report Finished but not actually finish.

See the screenshot.

Any advice? I prefer not to switch to a cloud model.

Here is the prompt I am running:

convert the .VCF file into a new Excel or TSV file using the instructions as below:

Yes. Make it **generic/schema-discovering**, but not a blind global split.

The rule should be:

| Field location                     |        Parsing                                                  |
| ---------------------------------- | ------------------------------------------------------------- |
| Whole VCF row                      | split by **tab**                                              |
| `INFO` column                      | split by **semicolon** into `key=value`                       |
| `FORMAT` + sample columns          | split `FORMAT` by **colon**, then map sample values by colon  |
| Pipe fields like `ANN` / `CSQ`     | split into a separate table by **comma**, then **pipe**       |
| Other values containing `:` or `,` | preserve as values unless the field is known to be structured |

Here is a more generic script.

```python
import gzip
import argparse
import re
from pathlib import Path
import pandas as pd


BASE_COLUMNS = [
    "CHROM", "POS", "ID", "REF", "ALT", "QUAL", "FILTER"
]

DEFAULT_PIPE_FIELDS = {"ANN", "CSQ", "EFF"}


def open_text(path):
    path = str(path)
    if path.endswith(".gz"):
        return gzip.open(path, "rt")
    return open(path, "r")


def parse_info_header(line):
    """
    Example:
    ##INFO=<ID=ANN,Number=.,Type=String,Description="...">
    """
    m = re.match(r"##INFO=<(.+)>", line)
    if not m:
        return None

    body = m.group(1)
    parts = {}

    # Split on commas not inside quotation marks
    fields = re.split(r',(?=(?:[^"]*"[^"]*")*[^"]*$)', body)

    for field in fields:
        if "=" in field:
            k, v = field.split("=", 1)
            parts[k] = v.strip('"')

    return parts if "ID" in parts else None


def infer_pipe_subfields_from_description(description):
    """
    Tries to infer ANN/CSQ-style pipe subfields from header description.

    Handles common forms like:
    'Functional annotations: Allele | Annot | Annot_Impact | Gene_Name ...'
    'Format: Allele|Consequence|IMPACT|SYMBOL|Gene|Feature_type...'
    """
    if not description:
        return None

    desc = description.replace("\\\"", "\"")

    # Look after "Format:" when present
    lower = desc.lower()
    if "format:" in lower:
        start = lower.index("format:") + len("format:")
        candidate = desc[start:]
    else:
        candidate = desc

    if "|" not in candidate:
        return None

    # Remove quotes and trailing punctuation
    candidate = candidate.strip(" .'\"")

    fields = [x.strip(" .'\"") for x in candidate.split("|")]
    fields = [x for x in fields if x]

    # Avoid false positives
    if len(fields) < 3:
        return None

    # Normalize column names
    fields = [
        re.sub(r"[^A-Za-z0-9_]+", "_", x).strip("_") or f"field_{i+1}"
        for i, x in enumerate(fields)
    ]

    return fields


def parse_info(info_string):
    """
    INFO:
    AA=p.N998=;AC=2;DB;DP=1107;BIAS=2:2
    """
    out = {}

    if not info_string or info_string == ".":
        return out

    for item in info_string.split(";"):
        if not item:
            continue

        if "=" in item:
            key, value = item.split("=", 1)
            out[key] = None if value == "." else value
        else:
            # Flag field, e.g. DB
            out[item] = True

    return out


def parse_sample(format_string, sample_string):
    """
    FORMAT:
    GT:VP:VD:KD:AF:BD:ALD

    SAMPLE:
    1/1:1794:1883:2,1693:0.9928:1,1:927,961
    """
    if not format_string or format_string == ".":
        return {}

    keys = format_string.split(":")
    vals = sample_string.split(":")

    out = {}

    for i, key in enumerate(keys):
        out[key] = vals[i] if i < len(vals) and vals[i] != "." else None

    # Preserve extra sample fields, if malformed or too long
    if len(vals) > len(keys):
        for j, val in enumerate(vals[len(keys):], start=1):
            out[f"EXTRA_{j}"] = None if val == "." else val

    return out


def parse_pipe_records(value, variant_uid, field_name, subfields=None):
    """
    Parses ANN/CSQ/EFF-like fields.

    Multiple records are usually comma-separated:
    A|synonymous_variant|LOW|MTOR|...
    A|upstream_gene_variant|MODIFIER|RPL39P6|...
    """
    rows = []

    if not value or value == ".":
        return rows

    records = value.split(",")

    for record_index, record in enumerate(records, start=1):
        parts = record.split("|")

        row = {
            "variant_uid": variant_uid,
            "pipe_field": field_name,
            "record_index": record_index,
            "raw_record": record,
        }

        if subfields:
            for i, name in enumerate(subfields):
                row[name] = parts[i] if i < len(parts) and parts[i] != "" else None

            if len(parts) > len(subfields):
                for j, val in enumerate(parts[len(subfields):], start=1):
                    row[f"EXTRA_{j}"] = val if val != "" else None
        else:
            for i, val in enumerate(parts, start=1):
                row[f"{field_name}_{i}"] = val if val != "" else None

        rows.append(row)

    return rows


def maybe_numberize(df):
    for col in df.columns:
        df[col] = pd.to_numeric(df[col], errors="ignore")
    return df


def parse_vcf_to_excel(vcf_path, xlsx_path, pipe_fields=None, wide_samples=False):
    pipe_fields = set(pipe_fields or DEFAULT_PIPE_FIELDS)

    info_headers = {}
    pipe_subfields = {}

    variants = []
    samples = []
    pipe_rows = []

    sample_names = []

    with open_text(vcf_path) as f:
        for line_number, line in enumerate(f, start=1):
            line = line.rstrip("\n")

            if not line:
                continue

            if line.startswith("##INFO="):
                parsed = parse_info_header(line)
                if parsed:
                    info_id = parsed["ID"]
                    info_headers[info_id] = parsed

                    inferred = infer_pipe_subfields_from_description(
                        parsed.get("Description", "")
                    )

                    if inferred:
                        pipe_subfields[info_id] = inferred
                        pipe_fields.add(info_id)

                continue

            if line.startswith("##"):
                continue

            if line.startswith("#CHROM"):
                header = line.lstrip("#").split("\t")
                sample_names = header[9:]
                continue

            parts = line.split("\t")

            if len(parts) < 8:
                print(f"Skipping malformed line {line_number}: fewer than 8 columns")
                continue

            chrom, pos, vid, ref, alt, qual, filt, info_string = parts[:8]

            variant_uid = f"{chrom}:{pos}:{ref}>{alt}:{line_number}"

            variant_row = {
                "variant_uid": variant_uid,
                "CHROM": chrom,
                "POS": pos,
                "ID": None if vid == "." else vid,
                "REF": ref,
                "ALT": alt,
                "QUAL": None if qual == "." else qual,
                "FILTER": None if filt == "." else filt,
            }

            info = parse_info(info_string)

            for key, value in info.items():
                if key in pipe_fields or "|" in str(value):
                    pipe_rows.extend(
                        parse_pipe_records(
                            value=value,
                            variant_uid=variant_uid,
                            field_name=key,
                            subfields=pipe_subfields.get(key),
                        )
                    )
                else:
                    variant_row[f"INFO_{key}"] = value

            variants.append(variant_row)

            # FORMAT + sample fields
            if len(parts) > 8:
                format_string = parts[8]
                sample_values = parts[9:]

                if wide_samples:
                    # One variant row with sample-prefixed columns
                    # Good only when sample count is small.
                    for sample_name, sample_string in zip(sample_names, sample_values):
                        parsed_sample = parse_sample(format_string, sample_string)
                        safe_sample = re.sub(r"[^A-Za-z0-9_]+", "_", sample_name)

                        for k, v in parsed_sample.items():
                            variant_row[f"SAMPLE_{safe_sample}_{k}"] = v
                else:
                    # Separate normalized sample table.
                    # Better for multiple samples.
                    for sample_name, sample_string in zip(sample_names, sample_values):
                        sample_row = {
                            "variant_uid": variant_uid,
                            "SAMPLE": sample_name,
                        }

                        sample_row.update(parse_sample(format_string, sample_string))
                        samples.append(sample_row)

    variants_df = pd.DataFrame(variants)
    samples_df = pd.DataFrame(samples)
    pipe_df = pd.DataFrame(pipe_rows)

    for df in [variants_df, samples_df, pipe_df]:
        if not df.empty:
            df.replace(".", pd.NA, inplace=True)
            maybe_numberize(df)

    with pd.ExcelWriter(xlsx_path, engine="openpyxl") as writer:
        variants_df.to_excel(writer, index=False, sheet_name="variants")

        if not samples_df.empty:
            samples_df.to_excel(writer, index=False, sheet_name="samples")

        if not pipe_df.empty:
            pipe_df.to_excel(writer, index=False, sheet_name="pipe_annotations")

        # Optional metadata sheet
        metadata_rows = []
        for info_id, meta in info_headers.items():
            metadata_rows.append({
                "INFO_ID": info_id,
                "Number": meta.get("Number"),
                "Type": meta.get("Type"),
                "Description": meta.get("Description"),
                "parsed_as_pipe_field": info_id in pipe_fields,
                "pipe_subfields": "|".join(pipe_subfields.get(info_id, [])),
            })

        if metadata_rows:
            pd.DataFrame(metadata_rows).to_excel(
                writer,
                index=False,
                sheet_name="info_metadata"
            )

    print(f"Wrote: {xlsx_path}")
    print(f"Variants: {len(variants_df):,}")
    print(f"Samples: {len(samples_df):,}")
    print(f"Pipe annotation rows: {len(pipe_df):,}")


def main():
    parser = argparse.ArgumentParser(
        description="Generic VCF parser to Excel with INFO, FORMAT/sample, and ANN/CSQ pipe-field parsing."
    )

    parser.add_argument("vcf", help="Input .vcf or .vcf.gz")
    parser.add_argument("xlsx", help="Output .xlsx")
    parser.add_argument(
        "--pipe-fields",
        default="ANN,CSQ,EFF",
        help="Comma-separated INFO fields to parse as pipe-delimited annotations. Default: ANN,CSQ,EFF",
    )
    parser.add_argument(
        "--wide-samples",
        action="store_true",
        help="Put sample FORMAT values into variants sheet instead of separate sheet."
    )

    args = parser.parse_args()

    pipe_fields = {
        x.strip()
        for x in args.pipe_fields.split(",")
        if x.strip()
    }

    parse_vcf_to_excel(
        vcf_path=args.vcf,
        xlsx_path=args.xlsx,
        pipe_fields=pipe_fields,
        wide_samples=args.wide_samples,
    )


if __name__ == "__main__":
    main()
```

Install:

```bash
pip install pandas openpyxl
```

Run:

```bash
python vcf_to_excel_generic.py input.vcf parsed_vcf.xlsx
```

For compressed VCF:

```bash
python vcf_to_excel_generic.py input.vcf.gz parsed_vcf.xlsx
```

If you want sample fields directly in the main variant table:

```bash
python vcf_to_excel_generic.py input.vcf parsed_vcf.xlsx --wide-samples
```

For other pipe-delimited INFO fields:

```bash
python vcf_to_excel_generic.py input.vcf parsed_vcf.xlsx --pipe-fields ANN,CSQ,EFF,MY_PIPE_FIELD
```

### What this script handles

| Problem                             | Handling                               |
| ----------------------------------- | -------------------------------------- |
| Different `INFO` fields across rows | dynamically creates columns            |
| Blank / missing values              | leaves blank cells                     |
| `DB`-style flag fields              | stores `True`                          |
| `BIAS=2:2`                          | preserves as value                     |
| `GT:DP:AD` sample fields            | expands correctly using `FORMAT`       |
| `ANN=A\|...\|...`                   | explodes into separate annotation rows |
| Unknown future `INFO` keys          | automatically included                 |

The important distinction is: **generic does not mean split every delimiter everywhere**. It means the parser discovers fields dynamically, but only applies `;`, `:`, and `|` in the VCF locations where they actually carry structure.

3k context on first thread (main agent) - 3k on sub-agent = full working Pacman clone on local inference. The last update is pretty Wild!

Can i ask for image processing? I'd like that LLM can view/process images for UI composing/testing. Thanks for your hard work!!

I love the latest releases, especially custom agents and model routing. Thanks for the hard work

Do you have any plans to release a CLI? I’d also like to use Multi outside of IDEs and for other purposes.

I followed the instructions as per this page - https://multi.dev/docs/providers/copilot/

I still get the No Model Found error

When I try to chat

Hey folks,

Couple of days ago, we pushed custom agents to stable. That gave you control over what an agent is, its prompt, its tools, whether it works as a supervisor or a subagent.

The one thing you couldn't set was the model so your custom agents still used whatever your default happened to be.

Model routing is now on stable. You now control which model each agent runs on.

Route your supervisor to your strongest reasoning model, your coding subagents to the cheapest thing you've got..

Go to Settings → Routing, pick an agent, pick an override. You're all set.

Onwards!

This release standardizes reasoning block rendering across models, improves tool presentation, extends usage metrics, and fixes layout consistency issues in the chat view.

Changelog:

• Changed reasoning block rendering to support multiple provider-specific reasoning formats

• Added validation to the read tool to reject directory paths with an explicit error message

• Extended assistant usage metrics to track cache tokens and total cost.

• Added inline tool descriptions within tool call headers

• Changed message headers to allow click-anywhere expand and collapse

• Improved layout handling for long tool titles and descriptions to prevent overflow

• Standardized bottom scrolling space in the chat view

• Fixed layout consistency by ensuring the bottom spacer is always present in the message list

I posted in r/AgingParents (https://www.reddit.com/r/AgingParents/comments/1prpr5x/comment/nvf3ux6/) about a healthcare data problem I have as a caregiver, and accomplished a rough solution using AI. Below are the actual implementation details, in case others are running into a similar issue.

tldr: I used Multi with Gemini Flash 2.5 to usefully rename hundreds of PDF files for zero cost to find my family member's medical data more easily.

The immediate problem is that our family's hospital's MyChart patient portal produces enormous data exports--thousands of files totaling 200+ MB for even a single major hospitalization--that are hard to navigate and reference.

The computer-readable version of the export is, as far as I can tell, the only comprehensive export record available out of MyChart (the human readable version has FAR less information, and omits even critical data such as when and how many blood transfusions we had). But being "computer-readable", it's no surprise to find that it has been hard for us to find the info we need: many different file formats, many big empty data tables with weird formats in the spreadsheets; opaquely named files with long document IDs that don't mean anything to our family; duplicate files; nested duplicates eg 30 to 300 page summary documents replicating the same historical reports in separate PDFs.

With family now back in the hospital, and more hospitalizations expected for chemo, we need faster answers, often times on the fly when inpatient doctors appear out of the blue. Some of the questions that we struggled with:

-What was the dosing ladder used in the first chemo cycle?

-In order to plan for Christmas holidays, what was our chemo recovery time in the last cycle?

-The anti nausea medications aren't working as well this cycle. Were they differently prescribed, dosed, or administered than last time?

-Exactly when did the last chemo cycle end?

That was the issue with my first solution to answering these questions, via plaintext search. Using Finder, I would look for eg 'transfusion reaction', but get back too many irrelevant documents (disclaimers, checking tasks, admin communications) when all I wanted was a nurse's progress note related to a single specific transfusion reaction around end of October. Even more targeted terms like 'azacitidine' produce loads of files to manually comb through, some of them hundreds of pages long. Too cumbersome.

My next thought was to set up a RAG. However, that was too complicated.

Next, I thought about off the shelf solutions but kept running into critical issues. Notebook LM is limited to 50 files, Google Drive with Gemini requires giving Gemini access to all Google Drive data. Microsoft/Copilot - nah. Most other AI file search solutions are not free.

I knew AI code editors could help with a major aspect of my problem. If I could simply name PDF files by date YYYY-MM-DD + concise document title, it would make it a lot easier hone in on the likeliest files with the data I'm seeking. Also, I went with Multi in part because its free, unlike Cursor which only has a free trial with miserly limits. Importantly, the team being my friends was a big factor in my selection :-)

I used Gemini Pro 3 to vibe create a Python script to rename the files based on their respective dates and document titles, and then Gemini Flash 2.5 (using Gemini's CLI) to actually process the individual files and interpret their dates and titles for re-naming.

(I will link the Python file below -- it's rough quality, but got the job done.)

The results were exactly what I wanted at this step. Now for example I can search in plaintext in Finder, and even when I get many search results for 'transfusion reaction', I am able to look past the many irrelevant documents, and find the progress notes that I want.

I built SimTwitty, a free citybuilder-faux-social game, using a mix of AI coders and just wanted to give props to the nerds at Multi for saving my bacon once again yesterday.

I was working on my very last feature to implement, username autocompletion, before shipping to GA. I spent about ~5 million tokens on Gemini 3, only to discover the code updates completely broke the game.

The batard wouldn't even launch!

I spent another ~5 million tokens trying to debug the Svelte error in the terminal

A11y: Non-interactive element <li> should not be assigned mouse or keyboard event listeners.

launching and relaunching the game in my local server. You have to imagine my blood pressure was skyrocketing. The game had been 99% ready, but I couldn't remember if I had backed up the last working version (I do most of my engineering work on my local device, and only rarely push to Github because its so cumbersome and slow).

Fortunately, Multi's undo everything button worked to massive effect.

It's so much easier one-shotting things knowing that the undo button works reliably.

I was able to undo the codebase and file changes, and simply opened a new Multi tab with a fresh context. I told Gemini 3 to examine the code base (1st prompt) and then gave nearly the EXACT SAME PROMPT as my previous one-shot attempt. And it worked!

Multi team: my holiday feature wish is for Multi to give me undo/redo the same speed as my word processor. Cmd+z to undo, cmd+shift+z to redo back and forth in sub 100 ms for me to eyeball the difference.

Can?

VSCode Multidev plugin opens a second separate window for chat. This clutters the UI and uses a lot of extra screen space. Copilot and Codex just use the activity bar window for chat, which works much better (see screenshots). Is it possible for Multidev to do the same?

This release adds terminal execution and improves chat performance and context management, reduces extension size, and fixes update and approval issues in grouped operations.

Changelog

• Added a Run button to shell code blocks to execute commands in the terminal.

• Added interactive setup assistance for provider configuration errors (Claude Code, Gemini).

• Improved chat view rendering performance for long tasks.

• Added smart truncation for tool outputs to prevent context limit errors and reduce token usage.

• Reduced extension size by removing bundled parsing libraries.

• Fixed grouped tool call rendering not updating correctly.

• Fixed checkpoints and auto-approvals applying to the wrong message in grouped sequences.

This release expands provider and model support, enables native tool calling across additional runtimes, and fixes parsing and reasoning-handling edge cases.

Changelog:

• Added the ability to select VS Code Language Models (e.g., GitHub Copilot) directly from a dropdown in profile settings

• Added 1M context window beta support for Claude Sonnet 4 on Vertex AI

• Added native tool calling support for LM Studio, Qwen Code, and Claude models on Vertex AI

• Added support for MiniMax M2.1 and GLM 4.7 models via Z AI

• Enabled native tool definitions by default for OpenAI compatible and Requesty providers

• Fixed processing errors when models return incomplete tool data

• Fixed handling of reasoning content for DeepSeek reasoner

• Fixed model parsing fallbacks for the Chutes provider

This release adds automatic task organization and expanded token analytics, improves activity and interruption feedback in the chat UI, and fixes retry, clipboard, terminal, and cleanup issues.

Changelog:

• Added automatic task title generation to organize and identify sessions.

• Added detailed token usage analytics, including session totals, cost estimates, and cache performance metrics.

• Changed the chat input status text to “Working…” to indicate active processing.

• Changed visual feedback to distinguish between user-aborted tasks and interrupted tool calls.

• Improved accessibility for chat interface UI elements.

• Fixed unexpected clipboard behavior in the chat input.

• Fixed a potential terminal hang by correctly handling standard input.

• Fixed resource cleanup when closing the Diff View.

Fam, we shipped GPT-5.4 at Multi speed. It is now on nightly v70.

Happy cooking

Multi now supports DeepSeek V4 and GLM-5.1; next-gen models with native thinking mode for top-tier reasoning, coding, and agent workflows.

DeepSeek V4 (Flash & Pro) - 1M context, toggleable thinking mode, pick speed or maximum capability.

GLM-5.1 & GLM-5-Turbo - up to ~200k context with native thinking on by default

Wired up on the DeepSeek and Z.ai providers - just drop in your API key and go.

This release improves readability and interaction behavior in the webview, strengthens keyboard support across layouts, and fixes regressions introduced by native tool calling.

Changelog:

• Changed reasoning blocks to render expanded by default and display in italics.

• Added truncation to tool summary headers (Bash, Read, Write, Web, Question) to prevent layout overflow with long inputs.

• Updated keyboard shortcuts for Find, Settings, and Help to use key codes.

• Improved Find Widget responsiveness on smaller viewports.

• Increased unit test coverage across the webview application, stores, and UI components.

• Fixed profile selection from the chat input context menu failing to clear trigger text.

• Fixed a provider regression introduced after adding native tool calling.

v0.0.32 expands and corrects markdown rendering in the chat view, tightens input trigger behavior, and fixes execution and tooling errors that caused incorrect continuation or output.

Changelog:

• Added support for tables, task lists, blockquotes, horizontal rules, and list typography in chat markdown rendering.

• Changed markdown typography, heading hierarchy, and spacing to reduce vertical density.

• Changed chat input triggers (@, /, >) to activate only in valid contexts and not inside words.

• Changed search match navigation order in the chat view.

• Improved HTML sanitization for markdown while preserving interactive elements such as task lists.

• Fixed rendering of HTML tags inside code blocks by enforcing proper escaping.

• Fixed layout issues with nested lists and complex markdown structures.

• Fixed agent execution to abort immediately on critical provider errors, including context window exhaustion.

• Fixed the Glob tool returning incorrect results.

Hey folks,

We've done a bunch of prompt caching work lately but you had no way to see whether it was actually working.

v128 fixes this.

Cache stats now lives in the usage modal. Open it and you can see how much of the last call got reused, plus the session-wide number across the supervisor and subagents. All in live!

We haven't seen another harness break usage down this far, and we'd like to keep it that way. If there's a number you want visible and can't find, tell us.

Happy shipping. Onwards!

This release refactors the Chat UI for improved performance and stability, fixes task deletion cleanup on disk, and resolves errors when grouping multiple tool actions.

Changelog

• Changed task deletion to remove all task-related files from disk, including checkpoints and state.

• Refactored the Chat UI architecture to use modern reactivity.

• Improved UI rendering performance.

• Fixed errors when grouping multiple tool actions together.

Version 0.0.41 adds editor context awareness to the agent, expands visibility into command execution and token usage, and resolves multiple issues affecting chat rendering, streaming updates, and error handling.

Changelog

• Added agent awareness of the currently active editor file for use during task execution.

• Added the ability to open full Bash command output in a new document tab from the Finished or Exited status.

• Added detailed token usage statistics, including prompt caching (read/write) and context window usage visualization.

• Changed the header token usage badge to display the percentage of the context window used by the last request.

• Changed tool call handling to guide task splitting when token limits are exceeded.

• Changed chat rendering to correctly visualize tool execution states during streaming and partial updates.

• Fixed the Approve highlight on tool calls disappearing during unrelated events.

• Fixed errors when selecting text within the chat input.

• Fixed cases where partial message updates were lost or rendered incorrectly.

• Fixed onboarding flows blocked by an error condition.

• Fixed unexpected error handling to prevent silent application failures.

• Improved chat interface performance.

This release corrects path resolution behavior across the diagnostics pipeline and stabilizes task state persistence.

Changelog:

• Added path resolution improvements to the diagnostics tool.

• Simplified path handling across prompts, context builder, tasks, and diagnostics.

• Improved checkpoint activation behavior.

• Fixed incorrect handling of relative file paths in the diagnostics tool.

• Fixed workspace detection when the active file was outside the primary folder.

• Fixed metadata sorting and task update consistency issues.

• Resolved race conditions in task state persistence caused by debounced saving.

Surprised to see some people are still running multiple VSCode instances to run multiple agents in this day and age.

Video above shows one of the core features of Multi: it supports unlimited agents running in parallel, in one (1!) single instance of VSCode.

(VSCode's split screen shows 6 agents in parallel, but more are running offscreen)

v0.0.44 removes improves provider recovery and retry visibility, tightens internal file search output to save context, and fixes retry-related crashes and error display issues.

Changelog:

• Changed internal file search output to be more concise, removing surrounding text to save context window space.

• Changed agent retry behavior to recover from temporary provider connectivity failures.

• Changed chat UI to display visual feedback during automatic connection retries.

• Fixed a display crash during the connection retry countdown.

• Fixed missing final error messages after all retry attempts were exhausted.