# Introduction Palabre is a CLI/TUI orchestrator for AI agents already installed on your machine. The goal is simple: you give a subject, Palabre orchestrates the agents, displays their responses in the terminal, then exports a complete Markdown record. Debate and Ask modes can also produce a final summary. Three modes are available: - `chat`: you work with one active agent and can explicitly request a second opinion with `/consult`; - `debate`: two agents take turns discussing a subject; - `ask`: several agents answer the same request independently, then a summary agent faithfully summarizes each response and compares them. Palabre does not replace Claude Code, Codex CLI, Antigravity CLI, OpenCode, Mistral Vibe, or Ollama. It drives them. You therefore keep your tools, subscriptions, default models, and terminal habits. Palabre runs locally on your machine. It does not send any data to a server owned by Palabre. Prompts, files, and transcripts are only transmitted to the agents you choose to use. Privacy therefore depends on the agents selected. Before sending code, documents, or sensitive data to Claude Code, Codex CLI, Antigravity CLI, OpenCode, Mistral Vibe, Ollama, or any other configured agent, check their own privacy policies and your account settings. ## What is Palabre for? Palabre is useful for: - maintaining a continued conversation with one agent and requesting a second opinion without losing context; - comparing two agents on the same question; - comparing several independent answers with Ask mode; - getting a critical review of an idea; - pitting a local Ollama model against a more powerful CLI; - producing a shareable Markdown transcript; - turning an AI discussion into consensus, disagreements, proposed actions, and conclusion. ## What Palabre does Palabre: - detects CLIs available on your machine; - opens a TUI by default with `palabre` in an interactive terminal; - launches agents in batch mode; - injects the subject, session context, and useful history into each call; - maintains a stateless Chat with one active agent and bounded history; - can run Ask requests without conversation between agents; - can add project files or folders to the context; - generates a final summary; - exports the session to a `.debate.md`, `.chat.md`, or `.ask.md` file. ## What Palabre does not do Palabre does not provide paid access to models. It does not create a Claude, OpenAI, Google, or Ollama account. Each agent must be installed and authenticated separately. Palabre also does not keep an interactive session open with the CLIs. Each response is produced by a batch call. Continuity comes from the transcript Palabre injects: the complete debate history in Debate mode, and at most the six most recent messages in Chat. ## Next Start by [installing Palabre](https://palab.re/en/get-started/installation), then [run your first session](https://palab.re/en/get-started/first-debate). The [configuration guide](https://palab.re/en/get-started/configuration) explains the details when you want more control. # Installation ## Prerequisites Palabre requires: - Node.js 20 or higher; - at least one agent already installed on your machine among Claude Code, Codex CLI, Antigravity CLI, OpenCode, Mistral Vibe, or Ollama. Two or more agents are recommended: debates need a pair, and Ask mode is most useful when comparing several independent answers. ## Install Palabre Palabre is published as a Node.js package on npm. Install it globally with your preferred package manager: ```bash # npm npm install --global palabre # pnpm pnpm add --global palabre # Yarn yarn global add palabre # Bun bun add --global palabre ``` Palabre is not a Python package, so `pip` cannot install it. There is no official `curl` installer either; do not use an undocumented `curl ... | sh` command. Then verify that the command is available: ```bash palabre --version palabre --help ``` ## Install from the source repository This section is for people who want to test Palabre from the Git repository. It requires `pnpm`. ```bash pnpm install pnpm build pnpm link --global palabre --version ``` Throughout the rest of this documentation, examples always use the final user command `palabre`. ## Install agents Palabre drives external tools. Install and authenticate the agents you want to use before launching Palabre. **OpenCode**, **Mistral Vibe**, and **Ollama** can be used with models or limits specific to their providers, while **Claude Code** and **Codex** generally require a subscription. **Ollama** is free for local use. If you use a cloud or remote offering, quotas and limits come from that offering, not from Palabre. Useful pages: - [Claude Code](https://palab.re/en/agents/claude-code) - [Codex](https://palab.re/en/agents/codex) - [Antigravity](https://palab.re/en/agents/antigravity) - [OpenCode](https://palab.re/en/agents/opencode) - [Mistral Vibe](https://palab.re/en/agents/vibe) - [Ollama](https://palab.re/en/agents/ollama) ## Next step Now run `palabre` in an interactive terminal. On first launch, Palabre creates the global configuration if needed, detects installed agents, and opens the TUI home screen. For explicit setup, scripts, or a project-local configuration, see [the configuration guide](https://palab.re/en/get-started/configuration). If you use VS Code, you can also install the [Palabre extension](https://palab.re/en/get-started/vscode-extension). To drive Palabre from an AI agent, install the [Palabre skill](https://palab.re/en/get-started/skill). # Run your first session The recommended path starts with one command: ```bash palabre ``` In an interactive terminal, Palabre creates the global configuration on first launch when needed, detects installed agents, and opens the TUI home screen. You do not need to memorize a full command to get started. ## 1. Start a Debate Debate is the primary mode. If needed, enter `/debate`, then choose the pair: ```text /agents codex claude ``` The first agent answers first; the second responds. `/agents` without arguments displays available choices. ## 2. Enter the subject ```text Review this technical plan and identify the highest-priority risks ``` To add project context: ```text Review this architecture --context src docs ``` The agents answer each other, then Palabre produces a final summary when enabled. ## 3. Find the result Palabre displays the path to the `.debate.md` export. Use `/history` to find Debate, Chat, and Ask exports. ## Try the other modes | Mode | Agents | Purpose | | ------ | ------------------------------- | ------------------------------------------------- | | Debate | 2 | Challenge two positions — primary mode. | | Chat | 1 active, optional consultation | Work with one agent and request a second opinion. | | Ask | 1 to 4 | Compare independent answers. | Switch to Chat with `/chat`, or to Ask with `/ask`. ## Direct commands They are useful for scripts, integrations, or advanced users: ```bash palabre codex-claude "Review this plan" --context src -t 4 palabre chat --agent-a codex palabre ask "Compare these approaches" --agents codex claude opencode ``` In a real terminal, they still use the TUI by default. Add `--terminal` for human-readable logs or `--renderer ndjson` for an integration. Continue with [Choose a mode](https://palab.re/en/usage/running-a-debate), [Use the TUI](https://palab.re/en/usage/tui), and [Exports](https://palab.re/en/usage/exports). # First configuration ## Automatic first configuration In an interactive terminal, the simplest first step is: ```bash palabre ``` If no configuration exists yet, Palabre creates the global configuration at: ```text ~/.palabre/palabre.config.json ``` It detects locally available tools, chooses useful defaults when possible, then opens the TUI home screen. ## Explicit initialization You can still initialize Palabre explicitly: ```bash palabre init ``` This creates the same global configuration: ```text ~/.palabre/palabre.config.json ``` It also detects locally available tools: Codex, Claude, Antigravity, OpenCode, Mistral Vibe, and Ollama. After creation, Palabre shows the active language and the quick command to switch to the other language. For a configuration specific to the current project: ```bash palabre init --local ``` ## Choose the language By default, Palabre uses French. To switch the interface and the prompts sent to agents to English: ```bash palabre config --language en ``` To switch back to French: ```bash palabre config --language fr ``` You can also choose the language directly during initialization: ```bash palabre init --language en ``` ## Verify the installation ```bash palabre doctor ``` `doctor` does not launch any AI agent. It checks the configuration, available commands, Ollama, and declared local models. ## View declared agents ```bash palabre agents ``` or: ```bash palabre -a ``` This command displays the agents present in your configuration and indicates whether they are detected on your machine. ## Choose default agents The simplest way is to use the assistant: ```bash palabre config ``` You can also set default agents directly: ```bash palabre config --set-defaults codex claude --summary-agent claude -t 4 ``` Here: - `codex` responds first; - `claude` responds second; - `claude` produces the final summary; - `-t 4` requests four turns in total. ## Add agents detected later If you install Antigravity, OpenCode, Mistral Vibe, or Ollama after creating the configuration: ```bash palabre config --sync-agents ``` This command adds missing detected known agents and refreshes known command names without overwriting your custom agents or existing defaults. The TUI home screen performs the same conservative synchronization automatically when it starts. ## Next step You can now [start your first session](https://palab.re/en/get-started/first-debate). # VS Code extension The VS Code extension adds a Palabre panel to the editor. It lets you prepare a subject, choose agents, add workspace context, follow a Debate, Chat, or Ask session, and open the matching Markdown export. **In Chat, you can switch the active agent, request a one-off opinion from another agent, or continue the conversation with that agent.** The extension remains a thin client: it launches `palabre` locally and consumes the public CLI contracts. Palabre CLI remains the source of truth for agents, presets, context, errors, and exports. ## Install the extension [Install Palabre for VS Code](https://marketplace.visualstudio.com/items?itemName=JuReyms.palabre-vscode){rel=""nofollow""} After installation, open the Palabre panel from the sidebar. ## Requirements - Palabre CLI installed on the same machine; - Palabre CLI `0.12.0` or newer recommended; - at least one available agent for Chat or Ask, two for Debate. ```bash palabre --version palabre doctor palabre presets --json ``` ## Current features - Debate, Chat, or Ask selection and available agents; - context selection through the official CLI scan; - NDJSON response, summary, and error rendering; - opening `.debate.md`, `.chat.md`, and `.ask.md` exports; - stopping Palabre and its child agents; - quick settings and diagnostics. For Chat, choose **Chat** in the extension. The CLI keeps the conversation state and exposes the same behavior through its public NDJSON contract. If the extension cannot find Palabre, check `palabre --version` and restart VS Code. If no agent appears, run `palabre doctor` and `palabre config`. # Palabre skill Palabre ships a ready-to-use skill that teaches an AI agent when and how to orchestrate a debate with the Palabre CLI. The agent then knows how to frame a subject, pick an agent pair, inject context, and retrieve the exported summary. The skill follows the open [agentskills.io](https://agentskills.io){rel=""nofollow""} standard, so it is portable across Hermes Agent, Claude, Codex, and any skills-compatible agent. The skill does not replace the CLI: it drives `palabre` locally. Palabre CLI remains the source of truth for agents, presets, and exports. ## Install the skill In **Hermes Agent**: ```bash hermes skills install JuReyms/Palabre/skills/palabre ``` For other agents (Claude desktop, Claude Code…), follow that agent's own skill-install procedure pointing at [`skills/palabre`](https://github.com/JuReyms/Palabre/tree/main/skills/palabre){rel=""nofollow""} in the repository. ## Requirements - Palabre CLI installed on the same machine (`npm install -g palabre`); - at least one compatible agent configured or detected by Palabre; two or more are recommended for comparisons; - a host agent compatible with the agentskills.io standard. Verify the installation from a terminal: ```bash palabre --version palabre doctor palabre agents ``` ## What the skill adds - automatic debate triggering when the user asks to compare two approaches, get a critical review, or a contradictory second opinion — the agent runs `palabre` without asking again, inferring the subject from context; - selection of a complementary agent pair (proposer / reviewer) and targeted context injection through `--files` or `--context`; - privacy guard: the agent warns before injecting sensitive code and can suggest a fully local pair (Ollama); - economy mode: recommends a local Ollama model when the topic does not warrant two premium agents; - language handling (`fr`/`en`) based on the user's language; - restitution: offers to display the full transcript directly in the conversation, or just the summary; - follow-up: turn actions into tasks, apply the consensus (agreed points only), dig into a disagreement, or export as a PR comment / ADR; - compatibility with integrations that maintain their own debate index, such as a VS Code extension index in `.palabre/`. # Agents A Palabre agent is a configuration entry that describes how to call an AI. Palabre supports two agent families: - CLI agents, such as Claude Code, Codex CLI, Antigravity CLI, OpenCode, or Mistral Vibe; - local agents, such as Ollama via its HTTP API. ## CLI agents A CLI agent is launched as a terminal command. Palabre sends it a prompt, retrieves its output, then closes the process. Each CLI keeps its own rules: authentication, default model, subscription, usage limits, and configuration options. Some CLIs can work with a free tier, a subscription, a local provider, or a cloud provider; in all cases, quotas and rate limit errors come from the agent being used, not from Palabre. ## Local agents A local agent like Ollama uses a model installed on your machine. This is useful for critic, exploration, or lightweight summary roles. If you configure Ollama with a cloud offer or a paid service, the associated limits remain those of Ollama or the chosen provider. Ollama does not read your files directly. To give it context, use `--files` or `--context`. ## View available agents ```bash palabre agents palabre agents --json ``` If an installed CLI does not appear in the configuration: ```bash palabre config --sync-agents ``` ## Roles Each agent has a role that influences the prompt: | Role | Usage | | ------------- | ----------------------------------------------- | | `implementer` | Propose a concrete solution. | | `reviewer` | Look for risks, regressions, and missing tests. | | `critic` | Challenge assumptions. | | `architect` | Structure technical options. | | `scout` | Quickly explore a topic. | | `summarizer` | Produce a faithful summary. | Roles do not change the model used. They change the instruction sent in the prompt. ## Using a role A persistent role is configured in `palabre.config.json`, in the agent entry, or with `palabre agent-role `. For a one-off run, use `--role-a`, `--role-b` in debate mode, or `--ask-role` to apply one shared role to Ask agents. Example: ```json "codex": { "type": "cli", "command": "codex", "role": "implementer" }, "claude": { "type": "cli", "command": "claude.exe", "role": "reviewer" } ``` With this configuration: ```bash palabre codex-claude "Critique this plan" -t 4 ``` Codex receives a concrete proposal instruction, while Claude receives a critical review instruction. To use two different behaviors with the same CLI, create two distinct agents in the configuration, for example `claude-reviewer` and `claude-summarizer`. ## Models passed as arguments When you use `--model-a`, `--model-b`, or `--summary-model`, Palabre does not verify the list of models available at the provider. The value is passed to the relevant CLI via its configured model option. If the model does not exist or is not authorized by your account, the CLI will return the error. # Claude Code Claude Code is Anthropic's CLI for working with Claude from the terminal. Palabre can use it as a debate agent or as a summary agent. ## Install before Palabre Install Claude Code from the official Anthropic documentation, then authenticate the CLI in your terminal. Official documentation: {rel=""nofollow""} Then verify that the command works: ```bash claude --version ``` On Windows, the detected command may be `claude.exe`. If Claude Code was installed after your first Palabre configuration, open `palabre` again or synchronize explicitly: ```bash palabre config --sync-agents ``` ## Subscription and limits Claude Code uses the access rules of your Anthropic or Claude account. Palabre does not bypass quotas, usage limits, or subscriptions. If Claude hits a limit, Palabre displays a short error and you can wait for your usage quota to reset or use a different agent pair. ## Windows Claude often works better with `claude.exe` and `shell: false`, since this binary is generally directly executable. This difference from Codex or OpenCode comes from the fact that those are often npm or PowerShell wrappers on Windows. ## Typical configuration ```json "claude": { "type": "cli", "command": "claude.exe", "args": ["--print", "--output-format", "text", "--no-session-persistence", "--tools", "Read,Glob,Grep"], "promptMode": "stdin", "shell": false, "role": "reviewer" } ``` Palabre's default limits Claude tools to `Read`, `Glob`, and `Grep`: the agent can inspect the project without changing files or running commands. Custom `args` remain unchanged. Claude often works well as `reviewer` or `summarizer`. ## Usage ```bash palabre codex-claude "Critique this plan" -t 4 palabre run -s "Summarize these options" --summary-agent claude ``` # Codex Codex CLI lets you use Codex from the terminal. Palabre can launch it as a debate agent, often as agent A to propose an initial solution. ## Install before Palabre Install and configure Codex CLI outside of Palabre. Consult the official documentation, then verify the command: Official documentation: {rel=""nofollow""} GitHub repository: {rel=""nofollow""} ```bash codex --version ``` If Codex was installed after your first Palabre configuration, open `palabre` again or synchronize explicitly: ```bash palabre config --sync-agents ``` ## Account, model, and limits Codex keeps its own configuration: provider, default model, sandbox, approvals, and usage limits. Palabre only passes the prompt. If you specify `--model-a` or `--model-b`, the value is passed to the CLI via its configured model argument. ## Typical configuration ```json "codex": { "type": "cli", "command": "codex", "args": ["exec", "--skip-git-repo-check", "--color", "never", "--sandbox", "read-only"], "promptMode": "stdin", "role": "implementer" } ``` On Windows, generated configuration enables `shell` for some npm or PowerShell wrappers. Palabre first tries the native executable, then the PowerShell `.ps1` shim; only force this option when your installation needs it. Claude is different in many Windows installations: `claude.exe` is generally called directly with `shell: false`. ## Usage ```bash palabre codex-claude "Critique this architecture" -t 4 palabre codex-opencode "Compare these two approaches" -t 3 ``` # Antigravity Antigravity CLI can be used as a Palabre agent through the `agy` command. Antigravity needs the `cli-pty` adapter: in testing, `agy --print` answers in a real console but does not produce capturable stdout when launched with plain Node pipes. ## Installation Install Antigravity CLI from Google's official documentation, then check that the command is available: ```bash agy --help ``` If Antigravity was installed after your first Palabre configuration, open `palabre` again or synchronize explicitly: ```bash palabre config --sync-agents ``` ## Gemini Transition Google announced the transition from Gemini CLI to Antigravity CLI for individual users, while Enterprise customers retain access according to their licenses. Official reference: [Transitioning Gemini CLI to Antigravity CLI](https://developers.googleblog.com/an-important-update-transitioning-gemini-cli-to-antigravity-cli/){rel=""nofollow""} Palabre no longer generates Gemini CLI in new configurations and no longer exposes it in presets. The old Gemini notes are kept in `docs/archive/gemini-en.md` for context. ## JSON Configuration The configuration generated by Palabre looks like this: ```json "antigravity": { "type": "cli-pty", "command": "agy", "args": ["--print-timeout", "5m0s", "--print"], "promptMode": "argument", "role": "reviewer", "tier": "primary", "timeoutMs": 300000 } ``` ## Examples ```bash palabre codex-antigravity "Compare this architecture approach" -t 4 palabre antigravity-ollama "Critique this migration plan" -t 3 ``` # OpenCode OpenCode is a development assistance CLI. Depending on your local configuration, it can use different models and providers. Palabre can use it as a CLI agent in the same way as Codex, Claude, or Antigravity. ## Install before Palabre Install OpenCode from the official documentation, then verify that the command works: Official documentation: {rel=""nofollow""} CLI reference: {rel=""nofollow""} ```bash opencode --version ``` If OpenCode was installed after your first Palabre configuration, open `palabre` again or synchronize explicitly: ```bash palabre config --sync-agents ``` ## Windows On Windows, generated configuration may enable `shell` for an npm or PowerShell wrapper. Palabre first tries the native executable, then the PowerShell `.ps1` shim; only force this option when your installation needs it. ## Plans and limits OpenCode can use free, paid, or local providers depending on your configuration. Quotas, subscriptions, and usage limits therefore depend on the provider configured in OpenCode, not on Palabre. ## Default model Palabre does not choose the OpenCode model for you. OpenCode uses its own default model, unless you configure a model argument in the Palabre agent. If you pass a model with `--model-a`, `--model-b`, or `--summary-model`, Palabre passes the value to OpenCode via the configured model option; OpenCode remains responsible for validating that model. ## Typical configuration ```json "opencode": { "type": "cli", "command": "opencode", "args": ["run", "--pure"], "promptMode": "stdin", "role": "reviewer" } ``` `--pure` prevents external plugins from loading. This OpenCode command does not currently expose a tool allowlist equivalent to Claude's or Vibe's. ## Usage ```bash palabre codex-opencode "Review this MVP" -t 4 palabre opencode-claude "Compare these options" -t 3 ``` # Ollama This is useful for adding a local, lower-cost perspective, or for assigning a small model a targeted role: critic, exploration, or lightweight summary. Ollama may have a slower response time than other agents, especially if the model is not already loaded. It is recommended to check that the model is loaded before starting a debate with Ollama. Or to be patient. ## Install before Palabre Install Ollama from the official documentation, then download a model. Official documentation: {rel=""nofollow""} CLI reference: {rel=""nofollow""} Then verify that the command works: ```bash ollama list ``` or: ```bash ollama ls ``` If Ollama was installed after your first Palabre configuration, open `palabre` again or synchronize explicitly: ```bash palabre config --sync-agents ``` If needed, start Ollama: ```bash ollama serve ``` ## Installing a model ```bash ollama pull gemma4:e4b ``` Choose a model appropriate for your machine. Large models may be too heavy for smooth use. In local use, the main limits come from your machine: memory, CPU/GPU, and response time. If you use a cloud, paid, or remote Ollama offering, quotas and limits come from that offering, not from Palabre. ## Choose the model used by Palabre Palabre reads the model from the `ollama-local` agent in your configuration. To list installed models and check whether the configured model still exists: ```bash palabre config --ollama-models --json ``` To change Palabre's default Ollama model: ```bash palabre config --set-ollama-model gemma4:e4b ``` If you removed the configured model and want Palabre to pick an installed model that is available: ```bash palabre config --sync-ollama-model ``` These commands update the Palabre configuration. For a one-off debate override, use `--model-a`, `--model-b`, or `--summary-model` depending on where the Ollama agent is used. ## Typical configuration ```json "ollama-local": { "type": "ollama", "baseUrl": "http://localhost:11434", "model": "gemma4:e4b", "role": "critic", "temperature": 0.2, "validateModel": true, "unloadOtherModels": true } ``` ## Use a remote Ollama server For one session, override the address of every Ollama agent: ```powershell palabre codex-ollama "Critique this plan" --ollama-url gpu-box:11434 ``` You can also define `OLLAMA_HOST` in the process environment: ```powershell $env:OLLAMA_HOST = "gpu-box:11434" palabre codex-ollama "Critique this plan" ``` Palabre accepts addresses with or without an HTTP scheme. The priority is: 1. `--ollama-url` 2. `OLLAMA_HOST` 3. `baseUrl` in the agent configuration 4. `http://localhost:11434` From the TUI, open `/config`, then use: ```text /ollama-url gpu-box:11434 /ollama-url default ``` This command persistently updates `baseUrl` for every configured Ollama agent. The flag and environment variable do not modify the configuration file. ## Check if a model is loaded in Ollama Ollama must load a model to respond quickly. ```bash ollama ps ``` ## Automatically download a missing model By default, Palabre does not install a model automatically. To allow it at startup: ```bash palabre codex-ollama "Critique this plan" --pull-models ``` You can also enable `autoPullModel` in the agent configuration. ## Give context to Ollama Ollama does not read your files directly. Use: ```bash palabre codex-ollama "Critique this module" --files src/module.ts ``` or: ```bash palabre codex-ollama "Critique the architecture" --context src docs ``` # Mistral Vibe Mistral Vibe is a development assistance CLI. Palabre uses it in programmatic mode with `--prompt`, then captures its text output. ## Install before Palabre Install and configure Mistral Vibe outside Palabre, then verify that the command works: ```bash vibe --version ``` If Mistral Vibe was installed after your first Palabre configuration, open `palabre` again or synchronize explicitly: ```bash palabre config --sync-agents ``` ## Windows On Windows, generated configuration may enable `shell` for a wrapper such as `vibe`. Palabre does not pass the prompt through `cmd.exe`: it prefers the native executable, then the PowerShell `.ps1` shim generated by npm or pnpm. Only force this option when your installation needs it; if neither safe path is available, startup is rejected with an actionable error. ## Default model Palabre does not choose the Mistral Vibe model for you. Vibe uses its own default configuration. If you pass a model with `--model-a`, `--model-b`, or `--summary-model`, Palabre passes the value through the configured model option. ## Typical configuration ```json "vibe": { "type": "cli", "command": "vibe", "args": ["--output", "text", "--trust", "--enabled-tools", "read", "--enabled-tools", "grep", "--prompt"], "promptMode": "argument", "modelArg": "--model", "role": "reviewer" } ``` `--enabled-tools read --enabled-tools grep` disables every other tool in programmatic mode. `--trust` only skips the working-directory trust prompt; it does not authorize additional tools. ## Usage ```bash palabre codex-vibe "Review this plan" -t 4 palabre vibe-claude "Compare these options" -t 3 ``` # Choose a mode Palabre provides three modes. **Debate remains the primary mode**: the home screen shows it first and it makes full use of contradictory orchestration. | Mode | Agents | Exchanges | Summary | Export | | ------ | ------------------------------- | ------------------------------------- | --------------- | ------------ | | Debate | 2 | Agents answer each other. | Yes, by default | `.debate.md` | | Chat | 1 active, optional consultation | The user talks with the active agent. | No | `.chat.md` | | Ask | 1 to 4 | Agents answer independently. | Yes, by default | `.ask.md` | ## Debate first Choose Debate to challenge a decision, find blind spots, or obtain a recommendation built from explicit disagreement. ```text /debate /agents codex claude Review this architecture and recommend a decision ``` See the [Debate mode guide](https://palab.re/en/usage/debate). ## Chat to continue Choose Chat when one agent is enough, with a second opinion through `/consult`. After Debate or Ask, it can carry over the subject and summary. See the [Chat guide](https://palab.re/en/usage/chat). ## Ask to compare without influence Choose Ask to collect up to four independent answers before comparing them. See the [Ask guide](https://palab.re/en/usage/ask). For human use, start with `palabre` and use the [TUI](https://palab.re/en/usage/tui). Extensions should consume the [integration contracts](https://palab.re/en/integrations/overview), not parse TUI output. ## Resume without replaying answers Add `--checkpoint` to a Debate or Ask request when a session should survive an interruption. Palabre records state under `.palabre/sessions/`; `palabre sessions` lists it and `palabre resume ` starts only the next step. Resume validates configuration and context before calling an agent; see the [CLI reference](https://palab.re/en/reference/cli#resume-a-session) for confirmations and targeted deletion. # Use multiple AI agents from the terminal Palabre is a multi-agent CLI that orchestrates the AI tools already installed on your machine. It can make two agents discuss a decision, compare several independent answers, or let you work with one agent while explicitly consulting a second opinion. Palabre is not an additional provider. Each agent keeps its own authentication, model, quotas, and access rules. ## Choose the right multi-agent mode | Mode | Agents | Interaction | Primary use | | ------ | -------------------------------- | ------------------------ | ------------------------------------------------------------ | | Debate | 2 | Agents answer each other | Challenge a decision and resolve disagreements | | Chat | 1 active, explicit consultations | Ongoing conversation | Work with one agent and request a second opinion when needed | | Ask | 1 to 4 | Independent answers | Compare analyses without mutual influence | ## Make two agents debate A debate injects the previous transcript into every new turn: ```bash palabre codex-claude "Review the risks in this architecture" -t 4 ``` Presets choose a pair and speaking order. They do not automatically change configured models or roles. See [Run a Codex and Claude Code debate](https://palab.re/en/usage/codex-claude-debate) for a complete workflow with roles and project context. ## Compare several answers with Ask Ask sends the same subject to several agents without sharing their intermediate answers: ```bash palabre ask "Compare these migration strategies" \ --agents codex claude opencode ``` An optional final summary can then present agreement and differences. Ask is particularly useful when you want to prevent the first response from influencing the next ones. ## Chat and consult another agent Open the TUI, then switch to Chat: ```bash palabre ``` ```text /chat /agents codex ``` Use `/consult` when you need a complementary opinion. Chat keeps bounded recent context and exports the session with `/end`. ## Add agents Palabre detects known CLIs and safely synchronizes the configuration: ```bash palabre config --sync-agents palabre agents --json palabre presets --json ``` Supported agents include [Codex](https://palab.re/en/agents/codex), [Claude Code](https://palab.re/en/agents/claude-code), [Antigravity](https://palab.re/en/agents/antigravity), OpenCode, Mistral Vibe, and Ollama. ## Give agents project context Add exact files with `--files` or scan a folder with `--context`: ```bash palabre codex-claude "Review this implementation" \ --context src tests \ -t 4 ``` CLI agents may also have their own workspace access depending on their tools. Ollama only sees context explicitly injected by Palabre. ## Keep an actionable record Every session produces a Markdown export under `.palabre/`: - `.debate.md` for Debate; - `.ask.md` for Ask; - `.chat.md` for Chat. These files preserve the subject, agents, transcript, and optional summary. They provide a shareable record and can be consumed by an integration such as the VS Code extension. Continue with [Choose a mode](https://palab.re/en/usage/running-a-debate), [Context and files](https://palab.re/en/usage/context-and-files), or the [agent overview](https://palab.re/en/agents/overview). # Use the TUI ```bash palabre ``` The TUI is the recommended interface for human use. It creates the global configuration on first launch, refreshes known agents, and keeps navigation context between sessions. ## Home screen The home screen summarizes the current session on two lines: mode, agents, roles, response count, and summary agent. It then shows essential shortcuts, the `--context` and `--files` syntaxes, and the working directory. If an agent required by the session is unavailable, a warning appears below the directory and points to `/agents` or `/config`, depending on the setting that needs attention. Enter a subject directly to run the current mode. Type `/` to open the contextual command list; use the arrow keys, `Tab`, or `→` to complete, then press `Enter` to run. `/help` groups commands around the user journey: start, prepare, continue, then navigate. `/config` first shows the active session and common settings; type `/` in its composer to reach advanced settings. An unknown command now produces an explicit message on every screen instead of silently changing views. `/update` opens a dedicated card: installed version, available npm version when Palabre comes from a package, detected channel, and the exact action. From a Git checkout, it simply identifies the checkout version and offers to synchronize it; it does not compare it with npm. Choose **Update now** or **Sync checkout** only after checking that action; **Not now** returns home. The card links to release notes for package installations. ## Compose a new session `/new` opens one guided flow for Chat, Debate, and Ask. Choose the mode, agents, and subject. Palabre then shows a compact summary and lets you launch, customize, or cancel the session. Customization covers the response count, model identifiers passed to agents, summary settings, context, and rendering options. Model identifiers belong to the relevant CLI; Palabre does not maintain a catalog of remote models. ## Main commands | Command | Effect | | ---------- | --------------------------------------------------------- | | `/` | Displays commands that are useful in the current view. | | `/new` | Composes a Chat, Debate, or Ask session step by step. | | `/debate` | Switches to the primary Debate mode. Alias: `/debat`. | | `/chat` | Opens a conversation. | | `/ask` | Switches to independent answers. | | `/agents` | Displays or changes agents. | | `/roles` | Displays or changes roles. | | `/config` | Opens settings. | | `/history` | Displays recent exports. | | `/update` | Checks and proposes the update matching the installation. | | `/help` | Displays all commands. | | `/home` | Returns home. | | `/quit` | Quits Palabre. | ## Add context ```text Review this module --files src/auth.ts README.md Review the architecture --context src docs ``` Paths containing spaces must be provided with a direct command. ## Ending Chat `/end` ends and saves; `/home` returns without saving; an error produces a partial transcript when possible. The export records the termination reason. Use `--terminal` for raw human output. For an integration, use `--renderer ndjson` and the [NDJSON documentation](https://palab.re/en/integrations/ndjson). # Debate mode Debate is Palabre's primary mode. Two agents answer each other on one subject with the context and previous responses. ## From the TUI ```bash palabre ``` Then: ```text /debate /agents codex claude /roles architect critic Review this plan and resolve the important disagreements ``` Each response receives the subject, context, injected files, and history. The final summary organizes consensus, disagreements, proposed actions, and a short conclusion. The response count is between 1 and 20. It is the total, not the count per agent. Palabre may stop after a complete round when explicit agreement is detected. ## Direct commands ```bash palabre codex-claude "Review this plan" -t 4 palabre run --subject "Review this plan" --agent-a codex --agent-b claude --turns 4 ``` Add `--no-early-stop`, `--no-summary`, or `--summary-agent ` as needed. `--dry-run` previews the session without calling an agent. The export uses `.debate.md`. # Chat mode Chat fits situations where one agent is enough, with the option to consult another agent when useful. ## From the TUI Run `palabre`, then `/chat`. Chat uses default agent A. `/agents codex` selects the active agent. | Command | Effect | | ----------------- | ------------------------------------------------------------- | | `/consult claude` | Requests a second opinion without replacing the active agent. | | `/use claude` | Continues with Claude. | | `/agents` | Displays available agents. | | `/end` | Saves and ends. | | `/home` | Returns without saving. | After Debate or Ask, `/chat` carries over the subject and final summary, or the six recent exchanges without a summary. ## Memory and limits Chat is stateless for external agents. Every response starts a batch call and reinjects at most six recent messages. It does not promise a persistent provider session, token streaming, or recovery after restart. ## Direct command ```bash palabre chat --agent-a codex ``` `--role-a`, `--model-a`, `--language`, `--files`, and `--context` remain available. The `.chat.md` export preserves the transcript, time, and termination reason, without an automatic summary. # Ask mode Ask sends the same subject and context to several agents. Each answers without seeing the others, then a summary agent summarizes and compares them. ## From the TUI ```text /ask /agents codex claude opencode Compare these two migration strategies ``` Ask accepts 1 to 4 agents. `/roles critic` applies one shared role to all active Ask agents. Use Ask to check convergence without mutual influence, compare strategies, or obtain several analyses before a summary. The answer count depends on selected agents; `--turns` does not apply. ## Direct command ```bash palabre ask "Compare these approaches" --agents codex claude opencode ``` Without `--agents`, Palabre uses `defaults.askAgents`, then the default debate pair. The export uses `.ask.md`. # Context and files Palabre can send project context to agents. This is essential for requesting a critique of code, architecture, or documentation. ## Two modes | Option | Usage | | ----------- | ------------------------------------------------------------------- | | `--files` | You explicitly choose the files. An invalid path stops the command. | | `--context` | Palabre scans text files or folders with limits and exclusions. | `--files` is strict: 64 KiB maximum per file and 192 KiB in total; a binary file, folder, or invalid path stops the session. `--context` is tolerant: it walks folders, ignores files it cannot retain, and reports warnings without cancelling the session. ## Explicit files ```bash palabre codex-claude "Review this module" --files src/auth.ts README.md ``` Use `--files` when you know exactly which files should be sent. ## Context scan ```bash palabre codex-claude "Critique this architecture" --context src docs ``` `--context` ignores common technical folders such as `.git`, `node_modules`, and `dist`. It keeps known text files and displays warnings for ignored files, unsupported extensions, oversized files, and missing paths. These warnings do not stop the session. ## From the TUI home The same options work directly in the home composer, at the end of the subject: ```text Critique this architecture --context src docs ``` Palabre strips `--context` and `--files` from the subject and injects the matching files. Paths containing spaces are not supported in this inline syntax: use the regular command line in that case. The session header confirms the number of injected files on the `Context` line. ## Preview the scan as JSON ```bash palabre context scan src docs --json ``` This command exposes the same scan as `--context`, without starting a session. It returns versioned JSON with the scanned root, requested paths, retained folders and files, and warnings. Integrations such as the VS Code extension should use this command instead of reimplementing exclusion or limit rules. ## Ollama and files Ollama does not read the filesystem on its own. It only receives the prompt built by Palabre. If an Ollama agent takes part in a session about your project, explicitly add context: ```bash palabre codex-ollama "Critique this module" --context src ``` ## View the prompt being sent ```bash palabre codex-claude "Subject" --context src --show-prompt ``` This command does not launch any agent. It lets you verify what Palabre will send on the first turn. # Summaries At the end of a debate or Ask request, Palabre can ask an agent to produce a final summary. ## Summary format The final summary requests four sections: 1. `Consensus` 2. `Disagreements / uncertainties` 3. `Proposed actions` 4. `Conclusion` The first three sections are structured as lists. `Conclusion` is a short prose paragraph for quickly understanding what to take away. ## Summary agent In debate mode, Palabre uses `defaults.summaryAgent` when it exists. Otherwise, it uses agent B. In Ask mode, Palabre uses `defaults.askSummaryAgent` when it exists, then `defaults.summaryAgent`, then the last Ask agent. To choose the summary agent for a command: ```bash palabre codex-claude "Critique this plan" --summary-agent claude ``` To configure a summary agent specific to Ask mode: ```bash palabre config --ask-summary-agent opencode ``` To also choose the model: ```bash palabre codex-ollama "Critique this plan" --summary-agent ollama-local --summary-model ``` ## Disable the summary ```bash palabre codex-claude "Critique this plan" --no-summary ``` ## Readability In the terminal, the standard rendering formats the summary headings to make them easier to scan. In the `.debate.md` or `.ask.md` export, the final summary is separated from the transcript or responses by a horizontal rule and begins with a table indicating the agent, role, and production date. # Exports Each session generates a Markdown export in the folder defined by `outputDir`: - `.debate.md` for a debate; - `.chat.md` for a conversation; - `.ask.md` for an Ask request. By default, exports are grouped in a `.palabre/` folder under the directory from which you run `palabre`. At the end of a TUI session, Palabre displays the exported file and its folder with clickable links in compatible terminals. The `/history` command lets you find recent exports again from the TUI home screen. ## Export contents The file contains: - a header table with the subject, agents, models, local date, and timezone; - the list of files injected into the context; - the full conversation or debate transcript, or independent agent responses in Ask mode; - the reason and time a Chat conversation ended, including the error message when it failed; - the final Debate or Ask summary if enabled. ## File name The name contains a short version of the subject and a timestamp. This makes debates easier to find while keeping a unique name: ```text palabre-critique-this-technical-plan-2026-05-06T08-52-43-000Z.debate.md palabre-clarify-this-architecture-2026-05-06T08-52-43-000Z.chat.md palabre-compare-these-approaches-2026-05-06T08-52-43-000Z.ask.md ``` If the subject contains no usable characters, Palabre uses `debate`, `chat`, or `ask` as the short name depending on the mode. ## Final summary In Debate and Ask, the summary is separated from the transcript by a horizontal rule. It begins with a short table: agent, role, and date. Chat does not add an automatic summary: it preserves the conversation and its termination reason. ## Windows preview Some Windows previews interpret `:**` as an emoji. Palabre replaces this sequence with `:**` in exported content. The Markdown rendering remains visually equivalent, but the Windows preview avoids emoji interpretation. ## Change the output folder In the advanced configuration: ```json { "outputDir": ".palabre" } ``` Future exports will be placed in this folder. ## History From the TUI: ```text /history ``` The history view displays recent `.debate.md`, `.chat.md`, and `.ask.md` exports, their mode, agents, turn or response count, file, and output folder. Outside the TUI, use `palabre history` or `palabre history --json`. # Run a Codex and Claude Code debate Palabre can make Codex CLI and Claude Code discuss a technical decision before you move to implementation. Each agent receives the same subject and context, then answers the previous analysis. Use this workflow to challenge an architecture, review a migration plan, compare two strategies, or uncover risks missed by the first proposal. ## Prepare Codex and Claude Code Install and authenticate both CLIs through their usual mechanisms. Palabre does not replace their accounts or subscriptions. Then verify availability: ```bash codex --version claude --version palabre config --sync-agents palabre doctor ``` The following command should report the preset as available: ```bash palabre presets --json ``` ## Start the debate The `codex-claude` preset makes Codex speak first and Claude Code second: ```bash palabre codex-claude "Compare these architectures and recommend the more robust option" -t 4 ``` The reverse variant makes Claude Code speak first: ```bash palabre claude-codex "Review this migration plan and resolve the disagreements" -t 4 ``` Position controls speaking order. Roles still come from your configuration unless you override them for the session. ## Assign complementary roles A pair is more useful when the agents do not receive exactly the same mission. For example: ```bash palabre run \ --subject "Should this service be split in two?" \ --agent-a codex \ --agent-b claude \ --role-a architect \ --role-b critic \ --turns 4 ``` Codex then structures an architecture proposal while Claude Code looks for fragile assumptions and unaddressed consequences. ## Add project context Use `--files` for a strict and reproducible selection: ```bash palabre codex-claude "Review this caching strategy" \ --files src/cache.ts src/config.ts \ -t 4 ``` Use `--context` to scan a folder tolerantly: ```bash palabre codex-claude "Propose an incremental migration" \ --context src docs/architecture \ -t 4 ``` Palabre marks files as untrusted data inside prompts. Size limits and exclusions are documented in [Context and files](https://palab.re/en/usage/context-and-files). ## Read the summary After the transcript, the summary agent organizes: - consensus points; - disagreements and uncertainty; - proposed actions; - a short conclusion. The session is exported under `.palabre/` as a `.debate.md` file. This export preserves the opposing arguments instead of keeping only the conclusion. ## Choose Debate or Ask Use Debate when agents should answer each other's objections. Use [Ask](https://palab.re/en/usage/ask) when you first want two independent answers without mutual influence. For a broader workflow overview, see [Use multiple AI agents from the terminal](https://palab.re/en/usage/multi-agent-cli) and [Debate mode](https://palab.re/en/usage/debate). # Configuration The configuration tells Palabre which agents exist, which agents to use by default, and where to write exports. If `outputDir` is not defined, `.debate.md`, `.chat.md`, and `.ask.md` files are created in the default `.palabre/` folder. ## Create a configuration In an interactive terminal, `palabre` creates the global configuration automatically on first launch when none exists, then opens the TUI home screen: ```bash palabre ``` The explicit command remains available for scripts, CI, or when you want to create a config without entering the TUI: ```bash palabre init ``` This command creates a global configuration at: ```text ~/.palabre/palabre.config.json ``` For a configuration specific to the current project: ```bash palabre init --local ``` This creates: ```text ./palabre.config.json ``` ## View useful configuration ```bash palabre palabre agents palabre doctor ``` From the TUI home screen, `/config` shows current settings and `/agents` lists available agents. Outside the TUI, `palabre agents` displays declared agents and their local detection. `palabre doctor` checks for common errors. When the TUI home screen starts, Palabre conservatively synchronizes known detected agents: it can add missing known agents and refresh known command names, but it does not overwrite custom agents, roles, models, or user defaults. ## Modify common settings ```bash palabre config ``` In the TUI, `/config` lets you define or remove default settings without leaving Palabre. The direct commands below also let you change a single setting from the terminal or a script. Useful direct commands: ```bash palabre config --set-defaults codex claude --summary-agent claude -t 4 palabre config --mode ask --ask-agents codex claude opencode --ask-summary-agent opencode palabre config --interface tui palabre config --language en palabre config -t 3 palabre config --summary-agent claude palabre config --clear-defaults palabre config --sync-agents palabre config --ollama-models --json palabre config --set-ollama-model palabre config --sync-ollama-model ``` In the TUI, the same common settings are available from `/config` with commands such as `/agents`, `/roles`, `/summary`, `/turns`, `/interface`, `/language`, `/mode`, `/ollama`, `/ollama-url `, `/ollama-model `, and `/ollama-sync`. Use `/home` to return to the home screen. ## Go further - [Default settings](https://palab.re/en/configuration/defaults) - [Local vs global configuration](https://palab.re/en/configuration/local-vs-global) - [Advanced JSON](https://palab.re/en/configuration/advanced-json) # Default settings Default settings are used when you start a session without specifying all agents or all options. They can be partial: you can define only the number of turns, only the summary, or a complete agent pair. ## Set default agents ```bash palabre config --set-defaults codex claude ``` After this command: ```bash palabre -s "Critique this plan" ``` uses `codex` as agent A and `claude` as agent B. ## Set the default summary ```bash palabre config --summary-agent claude ``` If no summary agent is defined, Palabre uses agent B. To remove this setting without deleting the other default settings: ```bash palabre config --summary-agent none ``` ## Set default Ask agents ```bash palabre config --ask-agents codex claude opencode ``` Ask mode accepts 1 to 4 agents. Without this setting, Palabre uses the default debate pair. To choose a summary agent specific to Ask mode: ```bash palabre config --ask-summary-agent opencode ``` This setting is separate from `--summary-agent`, so debate and Ask can use different summary agents. ## Set the default mode ```bash palabre config --mode chat ``` Accepted values are `debate`, `chat`, and `ask`. Debate remains the primary mode. Chat uses `defaults.agentA` as its initial active agent; Ask uses `defaults.askAgents`. In the TUI, switch modes with `/debate`, `/chat`, or `/ask` (`/debat` remains accepted as an alias). ## Set the number of turns ```bash palabre config -t 4 ``` `turns` is the total number of debate turns. Palabre accepts a value between 1 and 20. ## Set the language ```bash palabre config --language en ``` The configured language controls the Palabre interface and the prompts sent to agents. You can override it for one command with `--language `, `--lang `, or the `PALABRE_LANGUAGE` environment variable. In the TUI, open `/config`, then use: ```text /language fr /language en ``` The `/lang fr` alias is also accepted. ## Set the default interface ```bash palabre config --interface tui ``` `tui` is the recommended behavior when using Palabre in an interactive terminal. To use raw terminal rendering by default: ```bash palabre config --interface terminal ``` ## Clear default settings ```bash palabre config --clear-defaults ``` After that, use a preset or explicit agents: ```bash palabre codex-claude "Subject" -t 4 palabre run --subject "Subject" --agent-a codex --agent-b claude ``` # Local vs global configuration Palabre can use a global configuration for all your projects, or a local configuration for a specific project. ## Global configuration In an interactive terminal, `palabre` creates this global configuration automatically on first launch. ```bash palabre init ``` File created: ```text ~/.palabre/palabre.config.json ``` Use `palabre init` explicitly if you want to prepare the global config without opening the TUI, or if you want the same default agents everywhere. ## Local configuration ```bash palabre init --local ``` File created: ```text ./palabre.config.json ``` Use this option if a project needs its own agents, models, or export folder. A local configuration can run the commands declared by its agents and contact configured Ollama servers. Palabre therefore asks for approval before first use and records its fingerprint in `~/.palabre/trusted-configs.json`. Any external file change invalidates that approval. In a non-interactive workflow, review the file and use `--trust-config` once to record its new fingerprint. `palabre doctor` remains available before approval so you can inspect the configuration. In that case, it does not call Ollama URLs declared by the untrusted file. ## Resolution order Palabre looks for configuration in this order: 1. `./palabre.config.json` 2. `~/.palabre/palabre.config.json` You can force a specific file: ```bash palabre run -s "Subject" --config ./palabre.config.json palabre agents --config ./palabre.config.json ``` # Advanced JSON Most common settings can be done with `palabre config`. This page covers cases where you edit `palabre.config.json` directly. ## Minimal structure ```json { "outputDir": ".palabre", "defaults": { "agentA": "codex", "agentB": "claude", "summaryAgent": "claude", "turns": 4 }, "agents": { "codex": { "type": "cli", "command": "codex", "args": ["exec", "-"], "promptMode": "stdin", "role": "implementer" }, "claude": { "type": "cli", "command": "claude", "args": ["--print"], "promptMode": "stdin", "role": "reviewer" } } } ``` ## Main fields | Field | Description | | ----------------------- | ----------------------------------------------------------------------- | | `outputDir` | Destination folder for `.debate.md`, `.chat.md`, and `.ask.md` exports. | | `defaults.agentA` | Agent that responds first by default. | | `defaults.agentB` | Agent that responds second by default. | | `defaults.summaryAgent` | Agent used for the final summary by default. | | `defaults.turns` | Total number of turns, between 1 and 20. | | `agents` | List of available agents. It must contain at least one usable agent. | ## CLI agent ```json "claude": { "type": "cli", "command": "claude.exe", "args": ["--print", "--output-format", "text", "--no-session-persistence", "--tools", "Read,Glob,Grep"], "promptMode": "stdin", "shell": false, "role": "reviewer" } ``` Useful options: | Option | Description | | ---------------- | ------------------------------------------------------------------------------------------- | | `command` | Command to run. | | `args` | Arguments passed to the command. | | `promptMode` | `stdin` or `argument`. | | `modelArg` | Flag used to pass a model. | | `model` | Default model for this agent. | | `shell` | Useful on Windows for certain npm or PowerShell wrappers. | | `role` | Agent role. | | `timeoutMs` | Global timeout. | | `idleTimeoutMs` | Timeout if the CLI stays silent. | | `maxOutputBytes` | Maximum combined output size, 50 MiB by default. An invalid value restores this safe limit. | | `cols` / `rows` | Pseudo-terminal dimensions for `cli-pty` agents. | ## Ollama agent ```json "ollama-local": { "type": "ollama", "baseUrl": "http://localhost:11434", "model": "", "role": "critic", "validateModel": true, "unloadOtherModels": true } ``` Useful options: | Option | Description | | ------------------- | --------------------------------------------------------------- | | `model` | Ollama model used. | | `baseUrl` | Ollama API URL. | | `validateModel` | Verifies that the model is installed. | | `autoPullModel` | Allows automatic download. | | `pullTimeoutMs` | Download timeout. | | `unloadOtherModels` | Unloads other models before generation. | | `keepAlive` | Duration to keep the model loaded. | | `temperature` | Response variation. | | `maxOutputBytes` | Maximum size of each buffered HTTP response, 50 MiB by default. | # Integrate Palabre Palabre CLI is the source of truth for agents, presets, context, orchestration, errors, and exports. An integration launches the CLI as a child process and renders its public contracts, without parsing the TUI or reimplementing its decisions. | Need | Contract | | -------- | ------------------------------------------ | | Agents | `palabre agents --json` | | Pairs | `palabre presets --json` | | Context | `palabre context scan --json` | | History | `palabre history --json` | | Preview | `--dry-run --renderer ndjson` | | Session | `--renderer ndjson` | | Identity | `PALABRE_CLIENT`, `PALABRE_CLIENT_VERSION` | Outputs carry a `v` field. Optional additions remain compatible; removing, renaming, or changing a field's meaning requires a new version. ## Start a session ```bash palabre run --mode debate --subject "Subject" --agent-a codex --agent-b claude --renderer ndjson palabre run --mode ask --subject "Subject" --agents codex claude --renderer ndjson palabre chat --agent-a codex --renderer ndjson ``` Chat receives messages through stdin. An integration reads stdout line by line, keeps stderr separate, and waits for process termination. See [JSON catalogs](https://palab.re/en/integrations/json-contracts), [NDJSON v1](https://palab.re/en/integrations/ndjson), and [Lifecycle](https://palab.re/en/integrations/client-lifecycle). # JSON catalogs These commands write one JSON document to stdout and exit without starting an AI session. - `palabre agents --json` exposes `roles[]`, `agents[]`, and `defaults.askAgents[]`. Each agent provides its name, type, role, availability, and a reason when needed. - `palabre presets --json` exposes pairs, order, `available`, `missingAgents[]`, and `unavailableReasons[]`. - `palabre context scan src docs --json` exposes the root, requested paths, `items[]`, and `warnings[]`. - `palabre history --json` exposes the 10 most recent exports in `history[]`. An integration may request 1 to 100 entries with `--limit `. - `palabre sessions --json` exposes the 20 most recent checkpoints in `sessions[]`, with a limit from 1 to 100. A valid entry contains `valid`, `id`, `status`, `mode`, `topic`, `updatedAt`, `responses`, `nextPhase`, and `resumable`. A corrupted entry contains `valid: false`, `id`, `updatedAt`, and a stable `warning`, without raw contents or an absolute path. - `palabre sessions delete --yes --json` confirms the targeted deletion with `{ "v": 1, "deleted": { "id": "..." } }`. ## Consumption rules - check `v`; - ignore unknown fields; - accept missing optional fields; - do not recalculate availability or scanning rules; - display warnings without changing their meaning. # NDJSON v1 stream `--renderer ndjson` writes one valid JSON object per line to stdout. Every event contains `v: 1` and a `type` field. | Type | Purpose | | ------------------------------------ | --------------------------------------------------- | | `start` | Mode, subject, agents, context, and options. | | `notice`, `warning` | Information ordered in the stream. | | `thinking-start`, `thinking-end` | Agent waiting state. | | `turn-start`, `message` | Debate turn and answer. | | `ask-response-start`, `ask-response` | Ask answer. | | `summary-start`, `summary-message` | Summary. | | `dry-run` | Resolved preview without an agent call or export. | | `error` | Structured failure. | | `done` | Business completion and export path, possibly null. | Chat adds `chat-agents`, `chat-user-message`, `chat-message`, `chat-consultation-start`, `chat-consultation`, and `chat-agent-changed`. Its commands are sent through stdin one line at a time. For an integration, every Chat command must be a single-line v1 JSON object: | Command | Purpose | | -------------- | ------------------------------------------------------------------------- | | `chat-send` | Send `content` to the active agent. | | `chat-consult` | Request a one-off opinion from `agent` without changing the active agent. | | `chat-use` | Select `agent` as the active participant for subsequent messages. | | `chat-agents` | Request the available agent list again. | | `chat-end` | End the conversation and produce the `.chat.md` export. | ```json {"v":1,"type":"chat-send","content":"Review this approach"} {"v":1,"type":"chat-consult","agent":"vibe"} {"v":1,"type":"chat-use","agent":"vibe"} {"v":1,"type":"chat-end"} ``` Legacy text commands remain available for human use. Integrations should use JSON objects so message content can never be mistaken for a command. ```json {"v":1,"type":"thinking-start","agent":"codex","role":"implementer"} {"v":1,"type":"thinking-end"} {"v":1,"type":"message","turn":1,"agent":"codex","role":"implementer","content":"..."} {"v":1,"type":"done","outputPath":"C:\\project\\.palabre\\session.debate.md"} ``` stdout belongs to NDJSON. stderr may contain diagnostics and Ollama progress. Preserve order, ignore unknown types, wait for the exit code, and render agent content as untrusted text, never executable HTML. # Lifecycle, errors, and identity | Code | Meaning | | ----- | -------------------------------------------- | | `0` | Success. | | `1` | Validation, configuration, or runtime error. | | `130` | Cancellation. | Always wait for process termination. `error` describes the business failure; the code confirms final state. An `error` event may include phase, agent, role, turn, a stable `kind`, message, and details. Kinds include `command-not-found`, `spawn-failed`, `timeout`, `idle-timeout`, `output-too-large`, `empty-output`, `non-zero-exit`, `usage-limit`, `unsupported-model`, `model-unavailable`, `model-pull-failed`, `http-error`, and `cancelled`. For a `usage-limit`, `retryAfter` may be present: duration in seconds, ISO timestamp, or local `HH:mm` time. It is best-effort; branch on `kind`, not message text. Palabre attempts to preserve responses in a partial export after failure. Accept `done` with a path followed by a non-zero code. Cancellation must remain distinct from an error. ## Client identity ```text PALABRE_CLIENT=my-integration PALABRE_CLIENT_VERSION=2.3.0 ``` The name is open-ended. Palabre sanitizes these values and records them with its own version in exports. Without a declaration, the source is `direct-cli`. These fields are diagnostic, not a security boundary. # Troubleshooting Start by running the diagnostic: ```bash palabre doctor ``` `doctor` does not launch any AI agent. It displays a diagnostic by sections: configuration, local tools, agents, and items to check. It verifies declared agents, default settings, number of turns, `outputDir`, available CLIs, Ollama, and configured models. To get raw output suitable for logs or scripts: ```bash palabre doctor --terminal ``` ## Palabre cannot find my configuration Typical message: ```text [ERROR] Config missing: ... ``` In an interactive terminal, the simplest fix is to let Palabre create the global configuration: ```bash palabre ``` For scripts or setup without opening the TUI, initialize explicitly: ```bash palabre init ``` For a configuration local to the current project: ```bash palabre init --local ``` ## The configuration is unreadable Typical message: ```text [ERROR] Config unreadable: ... ``` Check that the JSON does not contain a trailing comma, that keys are quoted, and that the file is encoded in UTF-8. To start from a clean configuration: ```bash palabre init --config ./new-config.json ``` ## A default agent is unknown Typical message: ```text [ERROR] defaults.agentA points to an unknown agent: ... ``` List available agents: ```bash palabre agents ``` Then fix the default agents: ```bash palabre config --set-defaults codex claude ``` ## An installed agent does not appear in the config Typical message: ```text [WARN] Agent(s) detected but missing from config: opencode. ``` Open `palabre` again to let the TUI synchronize detected known agents, or synchronize explicitly: ```bash palabre config --sync-agents ``` This command adds missing known agents and refreshes known command names without overwriting your existing settings. ## The default number of turns is invalid Typical message: ```text [ERROR] defaults.turns invalid: 99. ``` Choose a number between 1 and 20: ```bash palabre config -t 4 ``` ## The export folder is problematic Typical message: ```text [ERROR] outputDir points to a file, not a folder: ... ``` Fix `outputDir` in `palabre.config.json`, or remove this field to write exports to the default `.palabre/` folder. ## A CLI is not found Typical message: ```text [WARN] Codex CLI: not detected in PATH. ``` Actions: - install the relevant CLI; - authenticate it outside of Palabre; - close and reopen the terminal; - run `palabre doctor` again; - fix `command` in the configuration if the command has a different name. On Windows, npm or PowerShell wrappers such as `codex`, `opencode`, and `vibe` may require `shell: true` in the configuration. Claude often works better with `claude.exe` and `shell: false`. ## Ollama is not responding Typical message: ```text [WARN] Ollama installed but API unreachable: http://localhost:11434 ``` Start Ollama: ```bash ollama serve ``` Then run again: ```bash palabre doctor ``` If Ollama uses a different URL, fix `baseUrl` in the Ollama agent configuration. ## The Ollama model is missing Typical message: ```text [WARN] ollama-local [ollama:critic] model=... missing. ``` Install the model: ```bash ollama pull the-model ``` or choose an already installed model for Palabre: ```bash palabre config --ollama-models --json palabre config --set-ollama-model installed-model ``` If you simply want to replace the missing configured model with an available installed model: ```bash palabre config --sync-ollama-model ``` or allow Palabre to download it at startup: ```bash palabre codex-ollama "Subject" --model-b the-model --pull-models ``` Some models are several GB. On a modest machine, prefer a reasonable local model. ## Ollama cannot see my files Ollama does not read the filesystem directly. Add context to the prompt: ```bash palabre codex-ollama "Critique this module" --files src/module.ts ``` or: ```bash palabre codex-ollama "Critique the architecture" --context src docs ``` ## A CLI hits a usage limit Typical message: ```text Error: codex has reached a usage limit: ... ``` Possible actions: - wait until the time indicated by the CLI; - change the model in the CLI or with `--model-a` / `--model-b`; - use a different agent pair; - temporarily disable the affected agent in your configuration. ## An agent's output is empty Typical message: ```text produced empty output ``` Test the command outside of Palabre, then check `args`, `promptMode`, `shell`, and timeouts in the configuration. `allowEmptyOutput` exists, but it is best kept disabled except for very specific cases. ## Update To check without changing the machine: ```bash palabre update --check ``` `palabre update` detects a Git checkout or global npm, pnpm, Yarn, or Bun installation and displays the exact action. In an interactive terminal, it asks once before any mutation. Use `--dry-run` to preview the steps or `--yes` in explicitly authorized automation. With recent pnpm versions, `palabre@latest` can temporarily stay on an older version because of supply-chain safeguards. Palabre therefore uses the exact npm version when it is available: ```bash pnpm add --global palabre@0.8.1 ``` Adapt the number to the version printed by `palabre update` or by: ```bash pnpm view palabre version ``` If the channel is unknown or ambiguous, Palabre changes nothing. Reinstall with the package manager used initially, for example: ```bash pnpm add --global palabre@latest ``` `--apply` remains a compatible alias for `--yes`. # Roadmap This page gives an overview of the planned evolution of Palabre. It helps users understand where the project is headed, without committing to delivery dates. ## Product direction Palabre helps you **make better decisions before acting**. It is a harness for orchestrated collective intelligence: it lets your chosen AI tools exchange views, organizes disagreement, and makes decisions explicit. Future improvements belong to one shared session rather than a growing set of separate modes: - **Consult**: talk with one agent, request several opinions, or run a debate; - **Decide**: synthesize, explore a conclusion further, prepare or review a plan; - **Act**: prepare an action and, only after explicit confirmation, delegate it to an appropriate tool. Acting is optional and remains under the user's control. Palabre is not intended to replace coding assistants or specialized tools: its role is to clarify a decision and provide a clean path to the next step when you choose it. ## Available today Palabre already lets you run debates between two agents installed on your machine, or Ask requests where several agents answer independently before a comparative summary: Claude Code, Codex CLI, Antigravity CLI, OpenCode, Mistral Vibe, or Ollama. The main features are available: - global or local configuration; - detection of installed agents; - automatic global configuration on first TUI launch, with conservative refresh of detected known agents; - TUI-first interface with `palabre`, `/agents`, `/roles`, `/config`, `/history`, and `/home`; - interactive assistant `palabre new`; - `ask` mode with 1 to 4 agents and `.ask.md` export; - stateless `chat` mode with one active agent, explicit consultation, bounded context, and `.chat.md` export; - presets such as `codex-claude`, `claude-antigravity`, `codex-antigravity`, or `opencode-ollama`; - French or English interface and prompts through `--language`, `--lang`, `PALABRE_LANGUAGE`, or configuration; - adding context with `--files` or `--context`; - previewing the context scan with `palabre context scan --json` for integrations; - final summary with consensus, disagreements, proposed actions, and conclusion; - Markdown export `.debate.md`, `.chat.md`, or `.ask.md` with a name based on the subject; - local export history with `palabre history`, `palabre history --json`, and `/history` in the TUI; - opt-in checkpoints for Debate and Ask, with `palabre sessions` and `palabre resume ` without replaying already accepted answers; - partial export preserved if an agent fails during the debate or final summary; - diagnostics with `palabre doctor`; - machine-readable output with `palabre agents --json`, `palabre presets --json`, `palabre context scan --json`, and the NDJSON renderer; - structured errors for integrations, with an NDJSON versioning policy; - a more robust CLI parser for boolean flags such as `--terminal`, `--json`, or `--no-summary`; - stricter runtime contracts: non-zero CLI exits are rejected, Ollama pull progress stays off NDJSON stdout, and missing `--context` paths are reported as warnings; - automated tests for the CLI adapter, parser, NDJSON renderer, presets, context scan, prompts, and output configuration without calling real AI services. ## Upcoming improvements ### More useful diagnostics `palabre doctor` is the first reflex when something goes wrong. It displays a readable diagnostic by sections and keeps `--terminal` for logs. Future improvements will continue to make its messages more actionable for common issues: agent not found, incomplete configuration, missing Ollama model, incorrect PATH, or provider quota reached. ### More robust integrations Palabre already exposes JSON contracts for presets, context scanning, and NDJSON debate rendering. Upcoming improvements will keep these contracts stable, well documented, and easier for the VS Code extension or other integrations to consume. ### Simpler configuration The `palabre config` command, the TUI `/config` view, first-run configuration, and known-agent synchronization already cover common settings: default agents, roles, number of turns, summary agent, default mode, default interface, and detected agent refresh. Future improvements will focus on clearer messages, better validation, and richer wizards for choices that benefit from discovery. ### Conversation after the debate After the final summary of a Debate or Ask session, `/chat` can now continue with one active agent. The transferred context records its provenance and carries over the subject with the final summary, or the six most recent exchanges when no summary exists. The conversation remains stateless and bounded; persistent Chat sessions and streaming remain separate future work. ### Tests and stability Reproducible tests already cover the CLI adapter, the NDJSON renderer, preset availability, and output directory resolution. The next step is to gradually expand this coverage to other sensitive behaviors, without calling real AI services during automated tests. ## Next These topics are considered after the CLI stabilizes: - resuming a debate from an existing Markdown export, distinct from `palabre resume`, which resumes a Palabre checkpoint; - OpenAI-compatible local provider for LM Studio, LocalAI, vLLM, or equivalent; - ongoing maintenance of the French and English documentation; - continued refinement of the multilingual French/English CLI interface, with a future interactive language choice in first-run or configuration flows; - more advanced TUI with scrolling, persistent panes, pause, and resume; - reliable model display when Palabre can know them without unnecessary noise. ## Philosophy Palabre will remain centered on a simple principle: drive the AI tools you already have installed, without replacing their accounts, models, subscriptions, or privacy policies. Its differentiator is organized disagreement, explicit synthesis, and controlled action. # Changelog This page is generated from Palabre's canonical French changelog on every release. ## 0.16.0 — 2026-08-31 A calmer, more consistent TUI, clearer recovery guidance, and hardened adapters and local config handling. **1 new feature · 2 changes · 2 fixes** [GitHub release](https://github.com/JuReyms/Palabre/releases/tag/v0.16.0){rel=""nofollow""} ## 0.15.0 — 2026-08-30 Resumable Debate and Ask sessions with atomic checkpoints, safe continuation, and explicit checkpoint management. **3 new features** [GitHub release](https://github.com/JuReyms/Palabre/releases/tag/v0.15.0){rel=""nofollow""} ## 0.14.0 — 2026-08-30 A redesigned /new flow for Chat, Debate, and Ask, a clearer TUI home, and faster, more reliable slash-command navigation. **3 new features · 3 changes · 4 fixes** [GitHub release](https://github.com/JuReyms/Palabre/releases/tag/v0.14.0){rel=""nofollow""} ## 0.13.0 — 2026-07-21 See the complete release notes. **2 new features · 1 change** [GitHub release](https://github.com/JuReyms/Palabre/releases/tag/v0.13.0){rel=""nofollow""} ## 0.12.0 — 2026-07-20 Stateless Chat joins Debate and Ask, with agent consultations, resilient exports, NDJSON integration events, dry-run previews, and diagnostic provenance. **4 new features · 1 change · 4 fixes** [GitHub release](https://github.com/JuReyms/Palabre/releases/tag/v0.12.0){rel=""nofollow""} ## 0.11.2 — 2026-07-11 See the complete release notes. **3 changes · 1 fix** [GitHub release](https://github.com/JuReyms/Palabre/releases/tag/v0.11.2){rel=""nofollow""} ## 0.11.1 — 2026-07-10 See the complete release notes. **1 fix** [GitHub release](https://github.com/JuReyms/Palabre/releases/tag/v0.11.1){rel=""nofollow""} ## 0.11.0 — 2026-07-10 See the complete release notes. **2 new features · 1 change · 2 fixes** [GitHub release](https://github.com/JuReyms/Palabre/releases/tag/v0.11.0){rel=""nofollow""} ## 0.10.2 — 2026-07-07 Safer local configs, hardened Windows agent launches, bounded Ollama responses, and protected terminal output. **3 changes · 5 fixes** [GitHub release](https://github.com/JuReyms/Palabre/releases/tag/v0.10.2){rel=""nofollow""} ## 0.10.1 — 2026-07-02 Smoother TUI navigation, a clearer guided setup, and useful next actions after every session. **4 changes · 2 fixes** [GitHub release](https://github.com/JuReyms/Palabre/releases/tag/v0.10.1){rel=""nofollow""} ## 0.10.0 — 2026-07-02 A redesigned TUI, inline context from the composer, localized adapter errors, and safer Antigravity quota detection. **1 new feature · 4 changes · 2 fixes** [GitHub release](https://github.com/JuReyms/Palabre/releases/tag/v0.10.0){rel=""nofollow""} ## 0.9.1 — 2026-07-01 A cleaner CLI architecture with centralized summary resolution and stronger regression coverage. **3 changes** [GitHub release](https://github.com/JuReyms/Palabre/releases/tag/v0.9.1){rel=""nofollow""} ## 0.9.0 — 2026-07-01 Remote Ollama support, agent availability for integrations, and smoother TUI update and configuration flows. **4 new features · 1 fix** [GitHub release](https://github.com/JuReyms/Palabre/releases/tag/v0.9.0){rel=""nofollow""} ## 0.8.1 — 2026-06-19 See the complete release notes. **5 new features · 5 changes · 7 fixes** [GitHub release](https://github.com/JuReyms/Palabre/releases/tag/v0.8.1){rel=""nofollow""} ## 0.8.0 — 2026-06-17 See the complete release notes. **6 new features · 4 changes · 2 fixes** [GitHub release](https://github.com/JuReyms/Palabre/releases/tag/v0.8.0){rel=""nofollow""} ## 0.7.0 — 2026-06-10 See the complete release notes. **4 new features · 2 changes · 2 fixes** [GitHub release](https://github.com/JuReyms/Palabre/releases/tag/v0.7.0){rel=""nofollow""} ## 0.6.4 — 2026-06-09 See the complete release notes. **3 fixes** [GitHub release](https://github.com/JuReyms/Palabre/releases/tag/v0.6.4){rel=""nofollow""} ## 0.6.3 — 2026-06-09 See the complete release notes. **3 changes · 6 fixes** [GitHub release](https://github.com/JuReyms/Palabre/releases/tag/v0.6.3){rel=""nofollow""} ## 0.6.2 — 2026-06-08 See the complete release notes. **1 new feature · 1 fix** [GitHub release](https://github.com/JuReyms/Palabre/releases/tag/v0.6.2){rel=""nofollow""} ## 0.6.1 — 2026-05-31 See the complete release notes. **1 change** [GitHub release](https://github.com/JuReyms/Palabre/releases/tag/v0.6.1){rel=""nofollow""} ## 0.6.0 — 2026-05-21 See the complete release notes. **2 new features** [GitHub release](https://github.com/JuReyms/Palabre/releases/tag/v0.6.0){rel=""nofollow""} # Command reference This page lists the main Palabre commands. ## Startup commands | Command | Description | | --------------------------------------- | ----------------------------------------------------------------------------------------------------------------- | | `palabre` | Opens the TUI home screen, creates the global configuration on first launch, and refreshes detected known agents. | | `palabre init` | Explicitly creates the global configuration and detects agents. | | `palabre init --local` | Creates a configuration in the current folder. | | `palabre doctor` | Displays a diagnostic by sections: configuration, local tools, agents, and items to check. | | `palabre agents` | Lists declared agents and their local detection. | | `palabre -a` | Shortcut for `palabre agents`. | | `palabre history`, `palabre historique` | Lists recent Palabre Markdown exports. | | `palabre sessions` | Lists resume checkpoints in the current directory. | | `palabre context scan --json` | Previews the project context Palabre would retain. | ## Configuration The TUI home screen performs the same conservative known-agent synchronization as `palabre config --sync-agents`: it adds newly detected known agents and refreshes known command names while preserving custom agents and user defaults. | Command | Description | | --------------------------------------------------- | ------------------------------------------------------------------ | | `palabre config` | Opens the configuration assistant. | | `palabre config --set-defaults codex claude` | Sets the default agents. | | `palabre agent-role claude critic` | Sets one agent persistent role. | | `palabre config -t 4` | Sets the default number of turns. | | `palabre config --summary-agent claude` | Sets the default summary agent. | | `palabre config --summary-agent none` | Removes the default summary agent. | | `palabre config --ask-summary-agent opencode` | Sets the default summary agent for ask mode. | | `palabre config --mode chat` | Sets the default mode (`chat`, `debate`, or `ask`). | | `palabre config --ask-agents codex claude opencode` | Sets the default ask agents, 4 maximum. | | `palabre config --interface tui` | Sets the default interface (`tui` or `terminal`). | | `palabre config --language en` | Sets the Palabre and agent prompt language. | | `palabre config --clear-defaults` | Removes default settings. | | `palabre config --sync-agents` | Adds missing detected agents and refreshes known commands. | | `palabre config --ollama-models --json` | Lists installed Ollama models and the configured model status. | | `palabre config --set-ollama-model ` | Sets the model for the `ollama-local` agent. | | `palabre config --sync-ollama-model` | Replaces the configured Ollama model if it is no longer installed. | ## Debates | Command | Description | | ----------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------- | | `palabre new` | Composes a Chat, Debate, or Ask session, shows its summary, and then lets you launch or customize it. | | `palabre -s "Subject" -t 4` | Launches with default agents. | | `palabre codex-claude "Subject" -t 4` | Launches with a preset. | | `palabre run --subject "Subject" --agent-a codex --agent-b claude` | Launches with explicit agents. | | `palabre run --subject "Subject" --agent-a codex --agent-b claude --role-a architect --role-b critic` | Launches with temporary roles. | | `palabre ask "Subject" --agents codex claude` | Runs a request with independent responses. | | `palabre chat --agent-a codex` | Opens a continued conversation with one agent. | ## Resume a session Add `--checkpoint` to a Debate or Ask request to save atomic state under `.palabre/sessions/`. Palabre then prints the session id and matching resume command. ```bash palabre codex-claude "Compare two options" --checkpoint palabre sessions palabre resume palabre sessions delete ``` Resume keeps every complete response and calls only the next Debate turn, remaining Ask agents, or the summary. Before any call, Palabre verifies that the configuration is still trusted and unchanged, then compares the context file fingerprints. Any difference blocks resume so the decision cannot change silently. Interactive terminals ask for confirmation; use `--yes` for non-interactive execution. A completed session cannot be resumed. `palabre sessions` shows the 20 most recent checkpoints by default, including their status, mode, response count, and next phase. `--limit <1-100>` bounds the list. A corrupted JSON file is reported as invalid without hiding other entries. Deletion displays the exact target and asks for confirmation; non-interactive use requires `--yes`. It never removes Markdown exports or sibling checkpoints. ## Conversation with one agent `palabre chat --agent-a ` opens a terminal conversation. The first message becomes its initial context; `"Subject"` remains accepted as an optional way to prefill that context. For every message, Palabre starts a new call to the selected CLI and injects the accumulated history into it. The result can therefore remain coherent in the current session without relying on a persistent interactive session inside Codex, Claude, or another tool. Unlike Ask, which collects one or more independent answers to a single question before an optional summary, Chat maintains a multi-turn conversation with one active agent. Use `/agents` to show available agents. `/end` saves the conversation in `.palabre/`, shows its file and folder, then returns home; `/home` returns without saving. `/consult ` explicitly requests a second opinion on the six most recent retained messages; that opinion is added to the conversation. `/use ` then switches the active agent, or you can continue with the initial agent. `--role-a`, `--model-a`, `--language`, `--files`, and `--context` remain available. Without `--agent-a`, Palabre uses the configured default agent A. This first version remains stateless and performs no action. The context sent with each call is bounded to the six most recent messages; Palabre reports when older messages are no longer sent. Consultation remains explicit: an agent may suggest it, but the user keeps the initiative. After a Debate or Ask completes in the TUI, `/chat` directly opens a conversation whose context shows its provenance and carries over the subject with the final summary, or the six recent exchanges when no summary is available. ## TUI Commands These commands are available from the TUI home screen or from `/config` depending on context. | Command | Description | | --------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------- | | `/` | Displays the contextual list of canonical commands; arrow keys, `Tab`, or `→` complete the selection. | | `/new` | Opens the guided flow for composing a Chat, Debate, or Ask session. | | `/chat` | Opens a conversation with the default agent A. `/home` or `/exit` returns to the home screen. | | `/ask` | Switches the TUI home screen to Ask mode. | | `/debate` | Switches the TUI home screen to debate mode. Alias: `/debat`. | | `/agents` | Displays available agents or updates active agents when names are provided. | | `/roles` | Displays available roles or updates active roles when roles are provided. In Ask mode, a single role such as `/roles critic` applies to all Ask agents. | | `/config` | Opens TUI settings. | | `/history` | Shows recent Markdown exports. Alias: `/historique`. | | `/update` | Opens the update screen for the detected installation channel. | | `/ollama` | Displays the configured Ollama model and installed models from `/config`. | | \`/ollama-url \\` | | `/ollama-model ` | Changes the configured `ollama-local` model from `/config`. | | `/ollama-sync` | Replaces the configured Ollama model with an installed model when the current one is missing. | | `/language fr`, `/language en` | Changes the language from `/config`. Alias: `/lang`. | | `/interface tui`, `/interface terminal` | Changes the default interface from `/config`. | | `/home` | Returns to the TUI home screen. Alias: `/back`. | | `/quit` | Exits the TUI. | ## Integrations An integration launching Palabre can declare its identity in the child process environment: ```text PALABRE_CLIENT=palabre-vscode PALABRE_CLIENT_VERSION=1.7.1 ``` Palabre records this information, together with its own version, in `.debate.md`, `.chat.md`, and `.ask.md` exports. Client names are open so future integrations can identify themselves without a hard-coded registry. When no client is declared, the invocation source is `direct-cli`. | Command | Description | | --------------------------------------------------- | ------------------------------------------------------------------------------ | | `palabre agents --json` | Lists configured agents, their role, type, and availability as JSON v1. | | `palabre presets --json` | Lists presets and their local availability. | | `palabre history --json` | Lists the 10 most recent Markdown exports as JSON v1. | | `palabre history --json --limit 30` | Lists up to 30 exports (maximum: 100). | | `palabre sessions --json` | Lists up to 20 valid or invalid checkpoints as JSON v1. | | `palabre sessions --json --limit 30` | Lists up to 30 checkpoints (maximum: 100). | | `palabre sessions delete --yes --json` | Deletes exactly one checkpoint and confirms its id as JSON v1. | | `palabre config --ollama-models --json` | Returns local Ollama state as JSON v1 for integrations. | | `palabre context scan [paths...] --json` | Returns the folders, files, and warnings from the `--context` scan as JSON v1. | ## General options | Option | Description | | ------------------------------------------- | ---------------------------------------------------------------------------------------- | | `-h`, `--help` | Displays help. | | `-v`, `--version` | Displays the version. | | `--config ` | Uses an explicit configuration file. | | `--trust-config` | Trusts the local configuration fingerprint after its contents have been reviewed. | | `--language `, `--lang ` | Forces the Palabre and agent prompt language for this command. | | `--tui` | Forces the TUI interface, even if configuration asks for terminal rendering. | | `--terminal`, `--no-tui` | Uses raw terminal rendering. Also useful with `palabre doctor` for logs. | | `--plain` | Historical alias for `--terminal`. | | `--json` | Requests JSON output from commands that support it, or the resolved `dry-run` object. | | `--renderer ` | Selects the terminal or integration renderer. `tui` enables the full-terminal interface. | ## Debate options | Option | Description | | ------------------------- | ------------------------------------------------------------------------------------ | | `-s`, `--subject ` | Session subject. | | `--topic ` | Compatible alias for `--subject`. | | `--preset ` | Selects an agent pair. | | `--agent-a ` | First agent. | | `--agent-b ` | Second agent. | | `--role-a ` | Temporary role for the first agent, without editing config. | | `--role-b ` | Temporary role for the second agent, without editing config. | | `--ask-role ` | Temporary shared role applied to all Ask agents. | | `--mode ` | Selects the orchestration mode. | | `--agents ` | Ask mode agents, 4 maximum. | | `-t`, `--turns ` | Total number of turns, between 1 and 20. | | `--no-early-stop` | Disables early stopping. | | `--model-a ` | Model passed to agent A. | | `--model-b ` | Model passed to agent B. | | `--ollama-url ` | Overrides the address of every Ollama agent for this session. | | `--pull-models` | Allows Ollama to download a missing model. | | `--checkpoint` | Saves versioned machine state under `.palabre/sessions/` for future resume. | | `--yes` | Explicitly confirms `palabre resume` or checkpoint deletion in non-interactive mode. | | `--summary-agent ` | Summary agent. | | `--summary-model ` | Summary model. | | `--no-summary` | Disables the final summary. | | `--files ` | Injects specific files. | | `--context ` | Scans text files or folders. | | `--show-prompt` | Displays the first turn prompt without calling any agent. | | `--dry-run` | Previews the resolved session without calling agents or writing an export. | ## Update | Command | Description | | -------------------------- | ---------------------------------------------------------------------- | | `palabre update` | Displays the plan then asks for TTY confirmation before a safe update. | | `palabre update --check` | Checks the version and channel without changing the machine. | | `palabre update --dry-run` | Displays the exact steps without running them. | | `palabre update --yes` | Applies a safe plan without interactive confirmation. | | `palabre update --apply` | Compatible alias for `--yes`. | # Configuration file reference This page serves as a quick reference for `palabre.config.json`. For a step-by-step explanation, start with [Configuration](https://palab.re/en/configuration/overview). ## Full example ```json { "language": "en", "outputDir": ".palabre", "defaults": { "mode": "debate", "agentA": "codex", "agentB": "claude", "askAgents": ["codex", "claude"], "summaryAgent": "claude", "askSummaryAgent": "claude", "turns": 4, "interface": "tui" }, "agents": { "codex": { "type": "cli", "command": "codex", "args": ["exec", "--skip-git-repo-check", "--color", "never", "--sandbox", "read-only"], "promptMode": "stdin", "role": "implementer" }, "claude": { "type": "cli", "command": "claude.exe", "args": ["--print", "--output-format", "text", "--no-session-persistence", "--tools", "Read,Glob,Grep"], "promptMode": "stdin", "shell": false, "role": "reviewer" } } } ``` ## Root | Field | Type | Description | | ----------- | ------------ | ------------------------------------------------------------------------------------------------------------- | | `language` | `fr` or `en` | Palabre and agent prompt language. Can be overridden for one command with `--language` or `PALABRE_LANGUAGE`. | | `outputDir` | string | Export folder for `.debate.md`, `.chat.md`, and `.ask.md` files. | ## `defaults` | Field | Type | Description | | ----------------- | -------------------------- | -------------------------------------------------------------------- | | `mode` | `debate`, `chat`, or `ask` | Default mode when no mode is provided. | | `agentA` | string | Agent that responds first in Debate and is initially active in Chat. | | `agentB` | string | Agent that responds second. | | `askAgents` | string [] | Default ask mode agents, 4 maximum. | | `summaryAgent` | string | Final summary agent for debate mode, and fallback for ask mode. | | `askSummaryAgent` | string | Ask-specific final summary agent. | | `turns` | number | Total number of turns, between 1 and 20. | | `interface` | `tui` or `terminal` | Default interface for interactive sessions. | ## CLI agent | Field | Type | Description | | ------------------ | --------------------- | ----------------------------------------------------------------------------------------------------- | | `type` | `cli` or `cli-pty` | Agent type. | | `command` | string | Command to run. | | `args` | string [] | Arguments passed. | | `promptMode` | `stdin` or `argument` | How the prompt is passed. | | `shell` | boolean | Runs through the system shell. Generated configuration only enables it for selected Windows wrappers. | | `role` | string | Agent role. | | `model` | string | Optional default model. | | `modelArg` | string | Optional model flag. | | `timeoutMs` | number | Global timeout. | | `idleTimeoutMs` | number | Idle timeout. | | `maxOutputBytes` | number | Maximum combined stdout and stderr size, 50 MiB by default. | | `allowEmptyOutput` | boolean | Exceptionally allows an empty CLI response. | | `cols` / `rows` | number | Pseudo-terminal dimensions for `cli-pty`. | ## Ollama agent | Field | Type | Description | | ------------------- | -------- | --------------------------------------------------------------- | | `type` | `ollama` | Agent type. | | `baseUrl` | string | Ollama API URL. | | `model` | string | Local model. | | `role` | string | Agent role. | | `validateModel` | boolean | Verifies that the model exists. | | `autoPullModel` | boolean | Downloads the model if missing. | | `pullTimeoutMs` | number | Download timeout. | | `unloadOtherModels` | boolean | Unloads other models. | | `keepAlive` | string | Duration to keep the model loaded. | | `temperature` | number | Response variation. | | `maxOutputBytes` | number | Maximum size of each buffered HTTP response, 50 MiB by default. | # Presets Presets let you quickly select an agent pair. ## Short syntax ```bash palabre codex-claude "Subject" -t 4 ``` This command is equivalent to choosing `codex` as agent A and `claude` as agent B. ## Common presets | Preset | Typical use | | -------------------- | ------------------------------------- | | `codex-claude` | Codex proposes, Claude reviews. | | `claude-codex` | Claude proposes, Codex reviews. | | `codex-antigravity` | Codex vs. Antigravity comparison. | | `claude-antigravity` | Claude vs. Antigravity comparison. | | `codex-opencode` | Codex vs. OpenCode. | | `opencode-claude` | OpenCode vs. Claude. | | `codex-vibe` | Codex vs. Mistral Vibe. | | `vibe-claude` | Mistral Vibe first, Claude reviewing. | | `codex-ollama` | Powerful CLI agent vs. local model. | | `ollama-claude` | Local model first, Claude reviewing. | `palabre presets --json` includes local availability metadata for integrations. A preset is marked unavailable when an agent is missing from the config, when a known CLI is not detected, or when the configured Ollama model is not installed. ## Choosing models Models can be passed without Palabre listing them: ```bash palabre codex-claude "Subject" --model-a --model-b ``` For Ollama: ```bash palabre codex-ollama "Subject" --model-b ``` ## When to use a preset? Use a preset when you want a short and explicit command. Use default agents when you frequently run the same pair. Use `--agent-a` and `--agent-b` when writing a script or precise documentation. # Introduction Palabre est un orchestrateur CLI/TUI pour agents IA déjà installés sur votre machine. L'objectif est simple : vous donnez un sujet, Palabre orchestre les agents, affiche leurs réponses dans le terminal, puis exporte une trace Markdown complète. Les modes Débat et Ask peuvent aussi produire une synthèse finale. Trois modes sont disponibles : - `debate` : deux agents dialoguent tour à tour sur un sujet ; - `chat` : vous échangez avec un agent actif et pouvez demander ponctuellement un second avis avec `/consult` ; - `ask` : plusieurs agents répondent indépendamment à la même demande, puis un agent de synthèse résume fidèlement chaque réponse et les compare. Palabre ne remplace pas Claude Code, Codex CLI, Antigravity CLI, OpenCode, Mistral Vibe ou Ollama. Il les pilote. Vous gardez donc vos outils, vos abonnements, vos modèles par défaut et vos habitudes de terminal. Palabre s'exécute localement sur votre machine. Il n'envoie aucune donnée à un serveur appartenant à Palabre. Les prompts, fichiers et transcripts sont transmis uniquement aux agents que vous choisissez d'utiliser. La confidentialité dépend donc des agents sélectionnés. Avant d'envoyer du code, des documents ou des données sensibles à Claude Code, Codex CLI, Antigravity CLI, OpenCode, Mistral Vibe, Ollama ou tout autre agent configuré, vérifiez leurs propres politiques de confidentialité et les paramètres de votre compte. ## À quoi sert Palabre ? Palabre est utile pour : - mener une conversation suivie avec un agent et demander un second avis sans perdre le fil ; - comparer deux agents sur une même question ; - comparer plusieurs réponses indépendantes avec le mode Ask ; - obtenir une relecture critique d'une idée ; - confronter un modèle local Ollama à une CLI plus puissante ; - produire un transcript Markdown partageable ; - transformer une discussion IA en consensus, désaccords, actions proposées et conclusion. ## Ce que Palabre fait Palabre : - détecte les CLIs disponibles sur votre machine ; - ouvre une interface TUI par défaut avec `palabre` dans un terminal interactif ; - lance les agents en mode batch ; - injecte le sujet, le contexte de session et l'historique utile dans chaque appel ; - entretient un Chat stateless avec un agent actif et un historique borné ; - peut lancer des demandes Ask sans conversation entre agents ; - peut ajouter des fichiers ou dossiers de projet au contexte ; - génère une synthèse finale ; - exporte la session dans un fichier `.debate.md`, `.chat.md` ou `.ask.md`. ## Ce que Palabre ne fait pas Palabre ne fournit pas d'accès payant aux modèles. Il ne crée pas de compte Claude, OpenAI, Google ou Ollama. Chaque agent doit être installé et authentifié séparément. Palabre ne garde pas non plus une session interactive ouverte avec les CLIs. Chaque réponse est produite par un appel batch. La continuité vient du transcript que Palabre réinjecte : tout le débat pour le mode Débat, et au maximum les six messages récents pour Chat. ## Suite Commencez par [installer Palabre](https://palab.re/fr/get-started/installation), puis [lancez une première session](https://palab.re/fr/get-started/first-debate). La page [configuration](https://palab.re/fr/get-started/configuration) explique les détails quand vous voulez plus de contrôle. # Installation ## Prérequis Palabre nécessite : - Node.js 20 ou plus ; - au moins un agent déjà installé sur votre machine parmi Claude Code, Codex CLI, Antigravity CLI, OpenCode, Mistral Vibe ou Ollama. Deux agents ou plus sont recommandés : un débat a besoin d'une paire, et le mode Ask devient surtout utile quand plusieurs réponses indépendantes sont comparées. ## Installer Palabre Palabre est publié comme package Node.js sur npm. Installez-le globalement avec le gestionnaire de paquets de votre choix : ```bash # npm npm install --global palabre # pnpm pnpm add --global palabre # Yarn yarn global add palabre # Bun bun add --global palabre ``` Palabre n'est pas un package Python : `pip` ne peut pas l'installer. Il n'existe pas non plus d'installateur officiel via `curl` ; n'utilisez pas de commande `curl ... | sh` non documentée. Vérifiez ensuite que la commande est disponible : ```bash palabre --version palabre --help ``` ## Installer depuis le dépôt source Cette section concerne les personnes qui veulent tester Palabre depuis le dépôt Git. Elle nécessite `pnpm`. ```bash pnpm install pnpm build pnpm link --global palabre --version ``` Dans le reste de cette documentation, les exemples utilisent toujours la commande utilisateur finale `palabre`. ## Installer les agents Palabre pilote des outils externes. Installez et authentifiez les agents que vous souhaitez utiliser avant de lancer Palabre. **OpenCode**, **Mistral Vibe** et **Ollama** peuvent être utilisés avec des modèles ou limites propres à leurs providers, tandis que **Claude Code** et **Codex** nécessitent généralement un abonnement. **Ollama** est gratuit en utilisation locale. Si vous utilisez une offre cloud ou distante, les quotas et limites viennent de cette offre, pas de Palabre. Pages utiles : - [Claude Code](https://palab.re/fr/agents/claude-code) - [Codex](https://palab.re/fr/agents/codex) - [Antigravity](https://palab.re/fr/agents/antigravity) - [OpenCode](https://palab.re/fr/agents/opencode) - [Mistral Vibe](https://palab.re/fr/agents/vibe) - [Ollama](https://palab.re/fr/agents/ollama) ## Étape suivante Lancez maintenant `palabre` dans un terminal interactif. Au premier lancement, Palabre crée la configuration globale si nécessaire, détecte les agents installés et ouvre l'accueil TUI. Pour un setup explicite, des scripts ou une configuration locale au projet, consultez [la configuration](https://palab.re/fr/get-started/configuration). Si vous utilisez VS Code, vous pouvez aussi installer [l'extension Palabre](https://palab.re/fr/get-started/vscode-extension). Pour piloter Palabre depuis un agent IA, installez [le skill Palabre](https://palab.re/fr/get-started/skill). # Lancer une première session Le parcours recommandé tient en une commande : ```bash palabre ``` Dans un terminal interactif, Palabre crée la configuration globale au premier lancement si nécessaire, détecte les agents installés et ouvre l'accueil TUI. Vous n'avez pas besoin de mémoriser une commande complète pour commencer. ## 1. Lancer un Débat Débat est le mode principal. Si nécessaire, saisissez `/debat`, puis choisissez la paire : ```text /agents codex claude ``` Le premier agent répond en premier ; le second lui répond. `/agents` sans argument affiche les choix disponibles. ## 2. Saisir le sujet ```text Critique ce plan technique et identifie les risques prioritaires ``` Pour ajouter du contexte projet : ```text Critique cette architecture --context src docs ``` Les agents se répondent, puis Palabre produit une synthèse finale lorsqu'elle est activée. ## 3. Retrouver le résultat Palabre affiche le chemin de l'export `.debate.md`. Utilisez ensuite `/history` pour retrouver les exports Débat, Chat et Ask. ## Essayer les autres modes | Mode | Agents | Usage | | ----- | --------------------------------- | ------------------------------------------------- | | Débat | 2 | Confronter deux positions — mode principal. | | Chat | 1 actif, consultation facultative | Avancer avec un agent et demander un second avis. | | Ask | 1 à 4 | Comparer des réponses indépendantes. | Passez à Chat avec `/chat`, ou à Ask avec `/ask`. ## Commandes directes Elles sont utiles pour les scripts, les intégrations ou les utilisateurs avancés : ```bash palabre codex-claude "Critique ce plan" --context src -t 4 palabre chat --agent-a codex palabre ask "Compare ces approches" --agents codex claude opencode ``` Dans un vrai terminal, elles utilisent encore la TUI par défaut. Ajoutez `--terminal` pour des logs humains ou `--renderer ndjson` pour une intégration. Continuez avec [Choisir un mode](https://palab.re/fr/usage/running-a-debate), [Utiliser la TUI](https://palab.re/fr/usage/tui) et [Exports](https://palab.re/fr/usage/exports). # Première configuration ## Première configuration automatique Dans un terminal interactif, le plus simple est de lancer : ```bash palabre ``` Si aucune configuration n'existe encore, Palabre crée la configuration globale : ```text ~/.palabre/palabre.config.json ``` Il détecte les outils disponibles localement, choisit des paramètres utiles quand c'est possible, puis ouvre l'accueil TUI. ## Initialisation explicite Vous pouvez toujours initialiser Palabre explicitement : ```bash palabre init ``` Cette commande crée la même configuration globale : ```text ~/.palabre/palabre.config.json ``` Elle détecte aussi les outils disponibles localement : Codex, Claude, Antigravity, OpenCode, Mistral Vibe et Ollama. Après la création, Palabre affiche la langue active et la commande rapide pour basculer vers l'autre langue. Pour une configuration propre au projet courant : ```bash palabre init --local ``` ## Choisir la langue Par défaut, Palabre utilise le français. Pour passer l'interface et les prompts envoyés aux agents en anglais : ```bash palabre config --language en ``` Pour revenir au français : ```bash palabre config --language fr ``` Vous pouvez aussi choisir la langue directement à l'initialisation : ```bash palabre init --language en ``` ## Vérifier l'installation ```bash palabre doctor ``` `doctor` ne lance aucun agent IA. Il vérifie la configuration, les commandes disponibles, Ollama et les modèles locaux déclarés. ## Voir les agents déclarés ```bash palabre agents ``` ou : ```bash palabre -a ``` Cette commande affiche les agents présents dans votre configuration et indique s'ils sont détectés sur votre machine. ## Choisir des agents par défaut Le plus simple est d'utiliser l'assistant : ```bash palabre config ``` Vous pouvez aussi définir directement les agents par défaut : ```bash palabre config --set-defaults codex claude --summary-agent claude -t 4 ``` Ici : - `codex` répond en premier ; - `claude` répond en second ; - `claude` produit la synthèse finale ; - `-t 4` demande quatre réponses au total. ## Ajouter des agents détectés plus tard Si vous installez Antigravity, OpenCode, Mistral Vibe ou Ollama après avoir créé la configuration : ```bash palabre config --sync-agents ``` Cette commande ajoute les agents connus détectés manquants et rafraîchit les noms de commandes connus sans écraser vos agents custom ni vos defaults existants. L'accueil TUI effectue la même synchronisation prudente automatiquement au démarrage. ## Étape suivante Vous pouvez maintenant [lancer une première session](https://palab.re/fr/get-started/first-debate). # Extension VS Code L'extension VS Code ajoute un panneau Palabre dans l'éditeur. Elle permet de préparer un sujet, choisir des agents, ajouter du contexte workspace, suivre une session Débat, Chat ou Ask et ouvrir l'export Markdown correspondant. **En Chat, vous pouvez changer l'agent actif, demander ponctuellement l'avis d'un autre agent ou poursuivre la conversation avec lui.** L'extension reste un client mince : elle lance `palabre` en local et consomme les contrats publics du CLI. Palabre CLI demeure la source de vérité pour les agents, presets, contexte, erreurs et exports. ## Installer l'extension [Installer Palabre pour VS Code](https://marketplace.visualstudio.com/items?itemName=JuReyms.palabre-vscode){rel=""nofollow""} Après installation, ouvrez le panneau Palabre depuis la barre latérale. ## Prérequis - Palabre CLI installé sur la même machine ; - Palabre CLI `0.12.0` ou plus récent recommandé ; - au moins un agent disponible pour Chat ou Ask, deux pour Débat. ```bash palabre --version palabre doctor palabre presets --json ``` ## Fonctionnalités actuelles - choix Débat, Chat ou Ask et des agents disponibles ; - sélection de contexte via le scan officiel du CLI ; - rendu des réponses, synthèses et erreurs NDJSON ; - ouverture des exports `.debate.md`, `.chat.md` et `.ask.md` ; - arrêt du processus Palabre et de ses agents enfants ; - réglages rapides et accès au diagnostic. Pour Chat, choisissez **Chat** dans l'extension. La CLI conserve l'état de la conversation et expose le même comportement via son contrat NDJSON public. Si l'extension ne trouve pas Palabre, vérifiez `palabre --version` puis redémarrez VS Code. Si aucun agent n'apparaît, lancez `palabre doctor` et `palabre config`. # Skill Palabre Palabre fournit un skill prêt à l'emploi qui apprend à un agent IA quand et comment orchestrer un débat avec la CLI Palabre. L'agent sait alors cadrer un sujet, choisir une paire d'agents, injecter le contexte et récupérer la synthèse exportée. Le skill suit le standard ouvert [agentskills.io](https://agentskills.io){rel=""nofollow""} : il est donc portable entre Hermes Agent, Claude, Codex et tout agent compatible skills. Le skill ne remplace pas la CLI : il pilote `palabre` en local. Palabre CLI reste la source de vérité pour les agents, les presets et les exports. ## Installer le skill Dans **Hermes Agent** : ```bash hermes skills install JuReyms/Palabre/skills/palabre ``` Pour les autres agents (Claude desktop, Claude Code…), suivez la procédure d'installation de skills propre à l'agent en pointant vers [`skills/palabre`](https://github.com/JuReyms/Palabre/tree/main/skills/palabre){rel=""nofollow""} dans le dépôt. ## Prérequis - Palabre CLI installé sur la même machine (`npm install -g palabre`) ; - au moins un agent compatible configuré ou détecté par Palabre ; deux ou plus sont recommandés pour les comparaisons ; - un agent hôte compatible avec le standard agentskills.io. Vérifiez l'installation depuis un terminal : ```bash palabre --version palabre doctor palabre agents ``` ## Ce que le skill apporte - déclenchement automatique du débat quand l'utilisateur demande de confronter deux approches, d'obtenir une relecture critique ou une seconde opinion contradictoire — l'agent lance `palabre` sans redemander, en déduisant le sujet du contexte ; - choix d'une paire d'agents complémentaires (proposeur / reviewer) et injection ciblée du contexte via `--files` ou `--context` ; - garde-fou confidentialité : l'agent prévient avant d'injecter du code sensible et peut proposer une paire 100 % locale (Ollama) ; - mode économique : recommandation d'un modèle local Ollama quand le sujet ne justifie pas deux agents premium ; - gestion de la langue (`fr`/`en`) selon la langue de l'utilisateur ; - restitution : proposition d'afficher le transcript complet directement dans la conversation, ou la synthèse seule ; - suite du débat : transformer les actions en tâches, appliquer le consensus (uniquement les points d'accord), approfondir un désaccord, ou exporter en commentaire de PR / ADR ; - compatibilité avec les intégrations qui maintiennent leur propre index de débats, par exemple un index d'extension VS Code dans `.palabre/`. # Agents Un agent Palabre est une entrée de configuration qui décrit comment appeler une IA. Palabre supporte deux familles d'agents : - les agents CLI, comme Claude Code, Codex CLI, Antigravity CLI, OpenCode ou Mistral Vibe ; - les agents locaux, comme Ollama via son API HTTP. ## Agents CLI Un agent CLI est lancé comme une commande de terminal. Palabre lui envoie un prompt, récupère sa sortie, puis ferme le process. Chaque CLI garde ses propres règles : authentification, modèle par défaut, abonnement, limites d'usage et options de configuration. Certaines CLIs peuvent fonctionner avec une offre gratuite, un abonnement, un provider local ou un provider cloud ; dans tous les cas, les quotas et erreurs de limite viennent de l'agent utilisé, pas de Palabre. ## Agents locaux Un agent local comme Ollama utilise un modèle installé sur votre machine. C'est utile pour des rôles de critique, d'exploration ou de synthèse légère. Si vous configurez Ollama avec une offre cloud ou un service payant, les limites associées restent celles d'Ollama ou du provider choisi. Ollama ne lit pas vos fichiers directement. Pour lui donner du contexte, utilisez `--files` ou `--context`. ## Voir les agents disponibles ```bash palabre agents palabre agents --json ``` Si une CLI installée n'apparaît pas dans la configuration : ```bash palabre config --sync-agents ``` ## Rôles Chaque agent a un rôle qui influence le prompt : | Rôle | Usage | | ------------- | ----------------------------------------------------- | | `implementer` | Proposer une solution concrète. | | `reviewer` | Chercher les risques, régressions et tests manquants. | | `critic` | Challenger les hypothèses. | | `architect` | Structurer les options techniques. | | `scout` | Explorer rapidement un sujet. | | `summarizer` | Produire une synthèse fidèle. | Les rôles ne changent pas le modèle utilisé. Ils changent la consigne envoyée dans le prompt. ## Utiliser un rôle Un rôle durable se configure dans `palabre.config.json`, dans l'entrée de l'agent, ou avec `palabre agent-role `. Pour un lancement ponctuel, utilisez `--role-a`, `--role-b` en mode débat, ou `--ask-role` pour appliquer un rôle commun aux agents Ask. Exemple : ```json "codex": { "type": "cli", "command": "codex", "role": "implementer" }, "claude": { "type": "cli", "command": "claude.exe", "role": "reviewer" } ``` Avec cette configuration : ```bash palabre codex-claude "Critique ce plan" -t 4 ``` Codex reçoit une consigne de proposition concrète, tandis que Claude reçoit une consigne de relecture critique. Pour utiliser deux comportements différents avec la même CLI, créez deux agents distincts dans la configuration, par exemple `claude-reviewer` et `claude-summarizer`. ## Modèles passés en commande Quand vous utilisez `--model-a`, `--model-b` ou `--summary-model`, Palabre ne vérifie pas la liste des modèles disponibles chez le provider. La valeur est transmise à la CLI concernée via son option modèle configurée. Si le modèle n'existe pas ou n'est pas autorisé par votre compte, c'est la CLI qui renvoie l'erreur. # Claude Code Claude Code est la CLI d'Anthropic pour travailler avec Claude depuis le terminal. Palabre peut l'utiliser comme agent de débat ou comme agent de synthèse. ## À installer avant Palabre Installez Claude Code depuis la documentation officielle d'Anthropic, puis authentifiez la CLI dans votre terminal. Documentation officielle : {rel=""nofollow""} Vérifiez ensuite que la commande fonctionne : ```bash claude --version ``` Sur Windows, la commande détectée peut être `claude.exe`. Si Claude Code a été installé après votre première configuration Palabre, relancez `palabre` ou synchronisez explicitement : ```bash palabre config --sync-agents ``` ## Abonnement et limites Claude Code utilise les règles d'accès de votre compte Anthropic ou Claude. Palabre ne contourne pas les quotas, limites d'usage ou abonnements. Si Claude atteint une limite, Palabre affiche une erreur courte et vous pouvez attendre que votre quota d'utilisation soit réinitialisé ou utiliser une autre paire d'agents. ## Windows Claude fonctionne souvent mieux avec `claude.exe` et `shell: false`, car ce binaire est généralement directement exécutable. Cette différence avec Codex ou OpenCode vient du fait que ces derniers sont souvent des wrappers npm ou PowerShell sur Windows. ## Configuration typique ```json "claude": { "type": "cli", "command": "claude.exe", "args": ["--print", "--output-format", "text", "--no-session-persistence", "--tools", "Read,Glob,Grep"], "promptMode": "stdin", "shell": false, "role": "reviewer" } ``` Le default Palabre limite les outils Claude à `Read`, `Glob` et `Grep` : l'agent peut inspecter le projet sans modifier de fichier ni lancer de commande. Une configuration `args` personnalisée reste inchangée. Claude fonctionne souvent bien comme `reviewer` ou `summarizer`. ## Utilisation ```bash palabre codex-claude "Critique ce plan" -t 4 palabre run -s "Synthétise ces options" --summary-agent claude ``` # Codex Codex CLI permet d'utiliser Codex depuis le terminal. Palabre peut le lancer comme agent de débat, souvent en agent A pour proposer une première solution. ## À installer avant Palabre Installez et configurez Codex CLI hors de Palabre. Consultez la documentation officielle, puis vérifiez la commande : Documentation officielle : {rel=""nofollow""} Dépôt GitHub : {rel=""nofollow""} ```bash codex --version ``` Si Codex a été installé après votre première configuration Palabre, relancez `palabre` ou synchronisez explicitement : ```bash palabre config --sync-agents ``` ## Compte, modèle et limites Codex garde sa propre configuration : fournisseur, modèle par défaut, sandbox, approbations et limites d'usage. Palabre transmet seulement le prompt. Si vous indiquez `--model-a` ou `--model-b`, la valeur est transmise à la CLI via son argument modèle configuré. ## Configuration typique ```json "codex": { "type": "cli", "command": "codex", "args": ["exec", "--skip-git-repo-check", "--color", "never", "--sandbox", "read-only"], "promptMode": "stdin", "role": "implementer" } ``` Sur Windows, la configuration générée active `shell` pour certains wrappers npm ou PowerShell. Palabre tente d'abord l'exécutable natif, puis le shim PowerShell `.ps1` ; ne forcez cette option que si votre installation en a besoin. Claude est différent dans beaucoup d'installations Windows : `claude.exe` est généralement appelé directement avec `shell: false`. ## Utilisation ```bash palabre codex-claude "Critique cette architecture" -t 4 palabre codex-opencode "Compare ces deux approches" -t 3 ``` # Antigravity Antigravity CLI peut être utilisé comme agent Palabre via la commande `agy`. Antigravity nécessite l'adapter `cli-pty` : lors des tests, `agy --print` répond dans une vraie console, mais ne produit pas de stdout capturable quand il est lancé avec de simples pipes Node. ## Installation Installez Antigravity CLI depuis la documentation officielle de Google, puis vérifiez que la commande est disponible : ```bash agy --help ``` Si Antigravity a été installé après votre première configuration Palabre, relancez `palabre` ou synchronisez explicitement : ```bash palabre config --sync-agents ``` ## Transition Gemini Google a annoncé la transition de Gemini CLI vers Antigravity CLI pour les utilisateurs individuels, tandis que les clients Enterprise conservent un accès selon leurs licences. Référence officielle : [Transitioning Gemini CLI to Antigravity CLI](https://developers.googleblog.com/an-important-update-transitioning-gemini-cli-to-antigravity-cli/){rel=""nofollow""} Palabre ne génère plus Gemini CLI dans les nouvelles configurations et ne le propose plus dans les presets. Les anciennes notes Gemini sont conservées dans `docs/archive/gemini-fr.md` pour contexte. ## Configuration JSON La configuration générée par Palabre ressemble à ceci : ```json "antigravity": { "type": "cli-pty", "command": "agy", "args": ["--print-timeout", "5m0s", "--print"], "promptMode": "argument", "role": "reviewer", "tier": "primary", "timeoutMs": 300000 } ``` ## Exemples ```bash palabre codex-antigravity "Compare cette approche d'architecture" -t 4 palabre antigravity-ollama "Critique ce plan de migration" -t 3 ``` # OpenCode OpenCode est une CLI d'assistance au développement. Selon votre configuration locale, elle peut utiliser différents modèles et providers. Palabre peut l'utiliser comme agent CLI au même titre que Codex, Claude ou Antigravity. ## À installer avant Palabre Installez OpenCode depuis la documentation officielle, puis vérifiez que la commande fonctionne : Documentation officielle : {rel=""nofollow""} Référence CLI : {rel=""nofollow""} ```bash opencode --version ``` Si OpenCode a été installé après votre première configuration Palabre, relancez `palabre` ou synchronisez explicitement : ```bash palabre config --sync-agents ``` ## Windows Sur Windows, la configuration générée peut activer `shell` pour un wrapper npm ou PowerShell. Palabre tente d'abord l'exécutable natif, puis le shim PowerShell `.ps1` ; ne forcez cette option que si votre installation en a besoin. ## Offres et limites OpenCode peut utiliser des providers gratuits, payants ou locaux selon votre configuration. Les quotas, abonnements et limites d'usage dépendent donc du provider configuré dans OpenCode, pas de Palabre. ## Modèle par défaut Palabre ne choisit pas le modèle OpenCode à votre place. OpenCode utilise son propre modèle par défaut, sauf si vous configurez un argument modèle dans l'agent Palabre. Si vous passez un modèle avec `--model-a`, `--model-b` ou `--summary-model`, Palabre transmet la valeur à OpenCode via l'option modèle configurée ; OpenCode reste responsable de valider ce modèle. ## Configuration typique ```json "opencode": { "type": "cli", "command": "opencode", "args": ["run", "--pure"], "promptMode": "stdin", "role": "reviewer" } ``` `--pure` empêche le chargement de plugins externes. OpenCode ne fournit pas encore, via cette commande, une allowlist d'outils équivalente à celles de Claude ou Vibe. ## Utilisation ```bash palabre codex-opencode "Relis ce MVP" -t 4 palabre opencode-claude "Compare ces options" -t 3 ``` # Ollama C'est utile pour ajouter un regard local, moins coûteux, ou pour confier à un petit modèle un rôle ciblé : critique, exploration ou synthèse légère. Ollama peut avoir un temps de réponse plus lent que les autres agents, surtout si le modèle n'est pas déjà chargé. Il est recommandé de vérifier que le modèle est chargé avant de lancer un débat avec Ollama. Ou de patienter. ## À installer avant Palabre Installez Ollama depuis la documentation officielle, puis téléchargez un modèle. Documentation officielle : {rel=""nofollow""} Référence CLI : {rel=""nofollow""} Vérifiez ensuite que la commande fonctionne : ```bash ollama list ``` ou : ```bash ollama ls ``` Si Ollama a été installé après votre première configuration Palabre, relancez `palabre` ou synchronisez explicitement : ```bash palabre config --sync-agents ``` Si nécessaire, démarrez Ollama : ```bash ollama serve ``` ## Installer un modèle ```bash ollama pull gemma4:e4b ``` Adaptez le modèle à votre machine. Les gros modèles peuvent être trop lourds pour un usage fluide. En usage local, les limites principales viennent de votre machine : mémoire, CPU/GPU et temps de réponse. Si vous utilisez une offre cloud, payante ou distante d'Ollama, les quotas et limites associées viennent de cette offre, pas de Palabre. ## Choisir le modèle utilisé par Palabre Palabre lit le modèle dans l'agent `ollama-local` de votre configuration. Pour voir les modèles installés et savoir si le modèle configuré existe encore : ```bash palabre config --ollama-models --json ``` Pour changer le modèle par défaut de Palabre : ```bash palabre config --set-ollama-model gemma4:e4b ``` Si vous avez supprimé le modèle configuré et que vous voulez laisser Palabre choisir un modèle installé disponible : ```bash palabre config --sync-ollama-model ``` Ces commandes modifient la configuration Palabre. Pour un changement ponctuel sur un débat, utilisez plutôt `--model-a`, `--model-b` ou `--summary-model` selon la place de l'agent Ollama. ## Configuration typique ```json "ollama-local": { "type": "ollama", "baseUrl": "http://localhost:11434", "model": "gemma4:e4b", "role": "critic", "temperature": 0.2, "validateModel": true, "unloadOtherModels": true } ``` ## Utiliser un serveur Ollama distant Pour une seule session, surchargez l'adresse de tous les agents Ollama : ```powershell palabre codex-ollama "Critique ce plan" --ollama-url gpu-box:11434 ``` Vous pouvez aussi définir `OLLAMA_HOST` dans l'environnement du processus : ```powershell $env:OLLAMA_HOST = "gpu-box:11434" palabre codex-ollama "Critique ce plan" ``` Palabre accepte les adresses avec ou sans schéma HTTP. La priorité est : 1. `--ollama-url` 2. `OLLAMA_HOST` 3. `baseUrl` dans la configuration de l'agent 4. `http://localhost:11434` Depuis la TUI, ouvrez `/config`, puis utilisez : ```text /ollama-url gpu-box:11434 /ollama-url default ``` Cette commande met à jour durablement `baseUrl` pour tous les agents Ollama configurés. Le flag et la variable d'environnement ne modifient pas le fichier de configuration. ## Vérifier si un modèle est chargé dans Ollama Ollama doit charger un modèle pour répondre rapidement. ```bash ollama ps ``` ## Télécharger automatiquement un modèle manquant Par défaut, Palabre n'installe pas de modèle automatiquement. Pour l'autoriser au lancement : ```bash palabre codex-ollama "Critique ce plan" --pull-models ``` Vous pouvez aussi activer `autoPullModel` dans la configuration de l'agent. ## Donner du contexte à Ollama Ollama ne lit pas vos fichiers directement. Utilisez : ```bash palabre codex-ollama "Critique ce module" --files src/module.ts ``` ou : ```bash palabre codex-ollama "Critique l'architecture" --context src docs ``` # Mistral Vibe Mistral Vibe est une CLI d'assistance au développement. Palabre l'utilise en mode programmatique avec `--prompt`, puis récupère sa sortie texte. ## À installer avant Palabre Installez et configurez Mistral Vibe hors de Palabre, puis vérifiez que la commande fonctionne : ```bash vibe --version ``` Si Mistral Vibe a été installé après votre première configuration Palabre, relancez `palabre` ou synchronisez explicitement : ```bash palabre config --sync-agents ``` ## Windows Sur Windows, la configuration générée peut activer `shell` pour un wrapper comme `vibe`. Palabre évite toutefois de transmettre le prompt via `cmd.exe` : il préfère l'exécutable natif, puis le shim PowerShell `.ps1` généré par npm ou pnpm. Ne forcez cette option que si votre installation en a besoin ; si aucun chemin sûr n'est disponible, le lancement est refusé avec une erreur actionnable. ## Modèle par défaut Palabre ne choisit pas le modèle Mistral Vibe à votre place. Vibe utilise sa propre configuration par défaut. Si vous passez un modèle avec `--model-a`, `--model-b` ou `--summary-model`, Palabre transmet la valeur via l'option modèle configurée. ## Configuration typique ```json "vibe": { "type": "cli", "command": "vibe", "args": ["--output", "text", "--trust", "--enabled-tools", "read", "--enabled-tools", "grep", "--prompt"], "promptMode": "argument", "modelArg": "--model", "role": "reviewer" } ``` `--enabled-tools read --enabled-tools grep` désactive les autres outils en mode programmatique. `--trust` évite uniquement le prompt de confiance du dossier ; il n'autorise pas de nouveaux outils. ## Utilisation ```bash palabre codex-vibe "Relis ce plan" -t 4 palabre vibe-claude "Compare ces options" -t 3 ``` # Choisir un mode Palabre propose trois modes. **Débat reste le mode principal** : l'accueil le présente en premier et il exploite pleinement l'orchestration contradictoire. | Mode | Agents | Échanges | Synthèse | Export | | ----- | --------------------------------- | ----------------------------------------- | --------------- | ------------ | | Débat | 2 | Les agents se répondent. | Oui, par défaut | `.debate.md` | | Chat | 1 actif, consultation facultative | L'utilisateur échange avec l'agent actif. | Non | `.chat.md` | | Ask | 1 à 4 | Les agents répondent indépendamment. | Oui, par défaut | `.ask.md` | ## Débat en premier Choisissez Débat pour challenger une décision, rechercher des angles morts ou obtenir une recommandation issue d'un désaccord explicite. ```text /debat /agents codex claude Critique cette architecture et propose une décision ``` Consultez le [guide du mode Débat](https://palab.re/fr/usage/debate). ## Chat pour poursuivre Choisissez Chat lorsqu'un agent suffit, avec un second avis ponctuel via `/consult`. Après un Débat ou un Ask, il peut reprendre le sujet et la synthèse. Consultez le [guide Chat](https://palab.re/fr/usage/chat). ## Ask pour comparer sans influence Choisissez Ask pour recueillir jusqu'à quatre réponses indépendantes avant leur comparaison. Consultez le [guide Ask](https://palab.re/fr/usage/ask). Pour une utilisation humaine, commencez par `palabre` et utilisez la [TUI](https://palab.re/fr/usage/tui). Les extensions doivent utiliser les [contrats d'intégration](https://palab.re/fr/integrations/overview), pas analyser le rendu TUI. ## Reprendre sans rejouer les réponses Ajoutez `--checkpoint` à un Débat ou à une demande Ask si la session doit pouvoir reprendre après un arrêt. Palabre enregistre l'état sous `.palabre/sessions/`, puis `palabre sessions` le liste et `palabre resume ` relance uniquement la prochaine étape. La reprise vérifie la configuration et le contexte avant d'appeler un agent ; consultez la [référence CLI](https://palab.re/fr/reference/cli#reprendre-une-session) pour les confirmations et la suppression ciblée. # Utiliser plusieurs agents IA dans le terminal Palabre est une CLI multi-agents qui orchestre les outils IA déjà installés sur votre machine. Il peut faire dialoguer deux agents, comparer plusieurs réponses indépendantes ou vous laisser converser avec un agent tout en consultant ponctuellement un second avis. Palabre n'est pas un provider supplémentaire. Chaque agent conserve son authentification, son modèle, ses quotas et ses règles d'accès. ## Choisir le bon mode multi-agent | Mode | Agents | Interaction | Usage principal | | ----- | --------------------------------- | ----------------------- | ---------------------------------------------------------- | | Débat | 2 | Les agents se répondent | Challenger une décision et résoudre des désaccords | | Chat | 1 actif, consultations explicites | Conversation suivie | Avancer avec un agent et demander un second avis au besoin | | Ask | 1 à 4 | Réponses indépendantes | Comparer plusieurs analyses sans influence mutuelle | ## Faire débattre deux agents Un débat réinjecte l'historique dans chaque nouveau tour : ```bash palabre codex-claude "Évalue les risques de cette architecture" -t 4 ``` Les presets choisissent une paire et son ordre de parole. Ils ne changent pas automatiquement les modèles ou les rôles configurés. Consultez le guide [Faire débattre Codex et Claude Code](https://palab.re/fr/usage/codex-claude-debate) pour un workflow complet avec rôles et contexte projet. ## Comparer plusieurs réponses avec Ask Ask envoie le même sujet à plusieurs agents sans partager leurs réponses intermédiaires : ```bash palabre ask "Compare ces stratégies de migration" \ --agents codex claude opencode ``` Une synthèse finale peut ensuite présenter les convergences et les différences. Ask est particulièrement utile lorsque vous voulez éviter qu'une première réponse influence les suivantes. ## Converser et consulter un autre agent Ouvrez la TUI, puis passez en Chat : ```bash palabre ``` ```text /chat /agents codex ``` Utilisez `/consult` lorsque vous souhaitez un avis complémentaire. Chat garde une mémoire bornée des échanges récents et exporte la session avec `/end`. ## Ajouter des agents Palabre détecte les CLIs connues et synchronise prudemment la configuration : ```bash palabre config --sync-agents palabre agents --json palabre presets --json ``` Les agents supportés incluent notamment [Codex](https://palab.re/fr/agents/codex), [Claude Code](https://palab.re/fr/agents/claude-code), [Antigravity](https://palab.re/fr/agents/antigravity), OpenCode, Mistral Vibe et Ollama. ## Donner du contexte aux agents Ajoutez des fichiers précis avec `--files` ou scannez un dossier avec `--context` : ```bash palabre codex-claude "Relis cette implémentation" \ --context src tests \ -t 4 ``` Les agents CLI peuvent aussi avoir leur propre accès au workspace selon leurs outils. Ollama ne voit que le contexte explicitement injecté par Palabre. ## Conserver une trace exploitable Chaque session produit un export Markdown sous `.palabre/` : - `.debate.md` pour Débat ; - `.ask.md` pour Ask ; - `.chat.md` pour Chat. Ces fichiers conservent le sujet, les agents, le transcript et la synthèse éventuelle. Ils constituent une trace partageable et peuvent être consommés par une intégration comme l'extension VS Code. Continuez avec [Choisir un mode](https://palab.re/fr/usage/running-a-debate), [Contexte et fichiers](https://palab.re/fr/usage/context-and-files) ou la [présentation des agents](https://palab.re/fr/agents/overview). # Utiliser la TUI ```bash palabre ``` La TUI est l'interface recommandée pour une utilisation humaine. Elle crée la configuration globale au premier lancement, rafraîchit les agents connus et conserve le contexte de navigation entre les sessions. ## Accueil L'accueil résume la session courante sur deux lignes : mode, agents, rôles, nombre de réponses et agent de synthèse. Il affiche ensuite les raccourcis essentiels, les syntaxes `--context` et `--files`, puis le dossier courant. Si un agent nécessaire à la session n'est pas disponible, un avertissement apparaît sous le dossier et indique `/agents` ou `/config` selon le réglage à corriger. Saisissez un sujet directement pour lancer le mode courant. Tapez `/` pour ouvrir la liste contextuelle des commandes ; utilisez les flèches, `Tab` ou `→` pour compléter, puis `Entrée` pour lancer. `/help` regroupe les commandes selon le parcours utilisateur : démarrer, préparer, continuer puis naviguer. `/config` montre d'abord la session active et les réglages courants ; tapez `/` dans son composeur pour accéder aux réglages avancés. Une commande inconnue affiche un message explicite dans chaque écran au lieu de changer de vue silencieusement. `/update` ouvre une carte dédiée : version installée, version npm disponible quand Palabre vient d'un package, canal détecté et action exacte. Depuis un checkout Git, elle indique simplement la version du dépôt et propose de le synchroniser ; elle ne le compare pas à npm. Choisissez **Mettre à jour maintenant** ou **Synchroniser le checkout** uniquement après avoir vérifié cette action ; **Pas maintenant** revient à l'accueil. Les notes de release sont liées depuis les installations package. ## Composer une nouvelle session `/new` ouvre un parcours guidé commun à Chat, Débat et Ask. Choisissez le mode, les agents puis le sujet. Palabre affiche un récapitulatif compact et propose ensuite de lancer la session, de la personnaliser ou de l'annuler. La personnalisation donne accès au nombre de réponses, aux modèles transmis aux agents, à la synthèse, au contexte et aux options de rendu. Les identifiants de modèle restent ceux de la CLI concernée ; Palabre ne maintient pas de catalogue de modèles distants. ## Commandes principales | Commande | Effet | | ---------- | ------------------------------------------------------------- | | `/` | Affiche les commandes utiles dans la vue courante. | | `/new` | Compose une session Chat, Débat ou Ask pas à pas. | | `/debat` | Passe au mode principal Débat. | | `/chat` | Ouvre une conversation. | | `/ask` | Passe aux réponses indépendantes. | | `/agents` | Affiche ou modifie les agents. | | `/roles` | Affiche ou modifie les rôles. | | `/config` | Ouvre les réglages. | | `/history` | Affiche les exports récents. | | `/update` | Vérifie puis propose la mise à jour adaptée à l'installation. | | `/help` | Affiche toutes les commandes. | | `/home` | Revient à l'accueil. | | `/quit` | Quitte Palabre. | ## Ajouter du contexte ```text Relis ce module --files src/auth.ts README.md Critique l'architecture --context src docs ``` Les chemins contenant des espaces doivent être fournis avec une commande directe. ## Fin d'un Chat `/end` termine et enregistre ; `/home` revient sans enregistrer ; une erreur produit une transcription partielle quand cela est possible. L'export indique la raison de fin. Utilisez `--terminal` pour un rendu humain brut. Pour une intégration, utilisez `--renderer ndjson` et la [documentation NDJSON](https://palab.re/fr/integrations/ndjson). # Mode Débat Débat est le mode principal de Palabre. Deux agents se répondent sur un même sujet avec le contexte et l'historique des réponses précédentes. ## Depuis la TUI ```bash palabre ``` Puis : ```text /debat /agents codex claude /roles architect critic Critique ce plan et tranche les désaccords importants ``` Chaque réponse reçoit le sujet, le contexte, les fichiers injectés et l'historique. La synthèse finale organise le consensus, les désaccords, les actions proposées et une conclusion courte. Le nombre de réponses est compris entre 1 et 20. Il s'agit du total, pas du nombre par agent. Palabre peut s'arrêter après un tour complet lorsqu'un accord explicite est détecté. ## Commandes directes ```bash palabre codex-claude "Critique ce plan" -t 4 palabre run --subject "Critique ce plan" --agent-a codex --agent-b claude --turns 4 ``` Ajoutez `--no-early-stop`, `--no-summary` ou `--summary-agent ` selon le besoin. `--dry-run` prévisualise la session sans appeler d'agent. L'export utilise `.debate.md`. # Mode Chat Chat convient lorsqu'un seul agent suffit, avec la possibilité de consulter ponctuellement un autre agent. ## Depuis la TUI Lancez `palabre`, puis `/chat`. Chat utilise l'agent A par défaut. `/agents codex` choisit l'agent actif. | Commande | Effet | | ----------------- | ---------------------------------------------------- | | `/consult claude` | Demande un second avis sans remplacer l'agent actif. | | `/use claude` | Continue avec Claude. | | `/agents` | Affiche les agents disponibles. | | `/end` | Enregistre et termine. | | `/home` | Revient sans enregistrer. | Après un Débat ou un Ask, `/chat` reprend le sujet et la synthèse finale, ou les six échanges récents sans synthèse. ## Mémoire et limites Chat est stateless côté agents externes. Chaque réponse lance un appel batch et réinjecte au maximum les six messages récents. Il ne promet ni session provider persistante, ni streaming token par token, ni reprise après redémarrage. ## Commande directe ```bash palabre chat --agent-a codex ``` `--role-a`, `--model-a`, `--language`, `--files` et `--context` restent disponibles. L'export `.chat.md` conserve le transcript, l'heure et la raison de fin, sans synthèse automatique. # Mode Ask Ask envoie le même sujet et le même contexte à plusieurs agents. Chacun répond sans voir les autres réponses, puis un agent de synthèse les résume et les compare. ## Depuis la TUI ```text /ask /agents codex claude opencode Compare ces deux stratégies de migration ``` Ask accepte de 1 à 4 agents. `/roles critic` applique un rôle commun à tous les agents Ask actifs. Ask sert à vérifier une convergence sans influence mutuelle, comparer des stratégies ou obtenir plusieurs analyses avant synthèse. Le nombre de réponses dépend des agents ; `--turns` ne s'applique pas. ## Commande directe ```bash palabre ask "Compare ces approches" --agents codex claude opencode ``` Sans `--agents`, Palabre utilise `defaults.askAgents`, puis la paire de débat par défaut. L'export utilise `.ask.md`. # Contexte et fichiers Palabre peut envoyer du contexte projet aux agents. C'est indispensable pour demander une critique de code, d'architecture ou de documentation. ## Deux modes | Option | Usage | | ----------- | ---------------------------------------------------------------------------------- | | `--files` | Vous choisissez explicitement les fichiers. Un chemin invalide arrête la commande. | | `--context` | Palabre scanne des fichiers ou dossiers texte avec des limites et des exclusions. | `--files` est strict : 64 Kio maximum par fichier et 192 Kio au total ; un fichier binaire, un dossier ou un chemin invalide arrête la session. `--context` est tolérant : il parcourt les dossiers, ignore les fichiers non retenus et affiche des avertissements sans annuler la session. ## Fichiers explicites ```bash palabre codex-claude "Relis ce module" --files src/auth.ts README.md ``` Utilisez `--files` quand vous savez exactement quels fichiers doivent être envoyés. ## Scan de contexte ```bash palabre codex-claude "Critique cette architecture" --context src docs ``` `--context` ignore les dossiers techniques courants comme `.git`, `node_modules` et `dist`. Il garde les fichiers texte connus et affiche des avertissements pour les fichiers ignorés, les extensions non supportées, les fichiers trop gros et les chemins manquants. Ces avertissements n'arrêtent pas la session. ## Depuis l'accueil TUI Les mêmes options fonctionnent directement dans le composer de l'accueil, à la fin du sujet : ```text Critique cette architecture --context src docs ``` Palabre retire `--context` et `--files` du sujet et injecte les fichiers correspondants. Les chemins contenant des espaces ne sont pas supportés dans cette syntaxe inline : utilisez la ligne de commande classique dans ce cas. L'en-tête de session confirme le nombre de fichiers injectés sur la ligne `Contexte`. ## Prévisualiser le scan en JSON ```bash palabre context scan src docs --json ``` Cette commande expose le même scan que `--context`, sans lancer de session. Elle renvoie un JSON versionné avec la racine scannée, les chemins demandés, les dossiers et fichiers retenus, ainsi que les avertissements. Les intégrations comme l'extension VS Code doivent utiliser cette commande au lieu de réimplémenter les règles d'exclusion ou de limite. ## Ollama et les fichiers Ollama ne lit pas le filesystem par lui-même. Il reçoit seulement le prompt construit par Palabre. Si un agent Ollama participe à une session sur votre projet, ajoutez explicitement du contexte : ```bash palabre codex-ollama "Critique ce module" --context src ``` ## Voir le prompt envoyé ```bash palabre codex-claude "Sujet" --context src --show-prompt ``` Cette commande ne lance aucun agent. Elle permet de vérifier ce que Palabre enverra au premier tour. # Synthèses À la fin d'un débat ou d'une demande Ask, Palabre peut demander à un agent de produire une synthèse finale. ## Format de synthèse La synthèse finale demande quatre sections : 1. `Consensus` 2. `Desaccords / incertitudes` 3. `Actions proposees` 4. `Conclusion` Les trois premières sections sont structurées en listes. `Conclusion` est un court paragraphe en prose pour comprendre rapidement ce qu'il faut retenir. ## Agent de synthèse En mode débat, Palabre utilise `defaults.summaryAgent` quand il existe. Sinon, il utilise l'agent B. En mode Ask, Palabre utilise `defaults.askSummaryAgent` quand il existe, puis `defaults.summaryAgent`, puis le dernier agent Ask. Pour choisir l'agent de synthèse sur une commande : ```bash palabre codex-claude "Critique ce plan" --summary-agent claude ``` Pour configurer un agent de synthèse spécifique au mode Ask : ```bash palabre config --ask-summary-agent opencode ``` Pour choisir aussi le modèle : ```bash palabre codex-ollama "Critique ce plan" --summary-agent ollama-local --summary-model ``` ## Désactiver la synthèse ```bash palabre codex-claude "Critique ce plan" --no-summary ``` ## Lisibilité Dans le terminal, le rendu standard met en forme les titres de synthèse pour les rendre plus faciles à scanner. Dans l'export `.debate.md` ou `.ask.md`, la synthèse finale est séparée du transcript ou des réponses par une ligne horizontale et commence par une table indiquant l'agent, le rôle et la date de production. # Exports Chaque session génère un export Markdown dans le dossier défini par `outputDir` : - `.debate.md` pour un débat ; - `.chat.md` pour une conversation ; - `.ask.md` pour une demande Ask. Par défaut, les exports sont regroupés dans un dossier `.palabre/` sous le dossier depuis lequel vous lancez `palabre`. À la fin d'une session TUI, Palabre affiche le fichier exporté et son dossier avec des liens cliquables dans les terminaux compatibles. La commande `/history` permet de retrouver les derniers exports depuis l'accueil TUI. ## Contenu de l'export Le fichier contient : - une table d'en-tête avec le sujet, les agents, les modèles, la date locale et le fuseau horaire ; - la liste des fichiers injectés dans le contexte ; - le transcript complet de la conversation ou du débat, ou les réponses indépendantes des agents en mode Ask ; - la raison et l'heure de fin d'une conversation Chat, avec le message d'erreur lorsqu'elle a échoué ; - la synthèse finale de Débat ou Ask si elle est activée. ## Nom du fichier Le nom contient une version courte du sujet et un horodatage. Cela rend les débats plus faciles à retrouver tout en gardant un nom unique : ```text palabre-critique-ce-plan-technique-2026-05-06T08-52-43-000Z.debate.md palabre-clarifie-cette-architecture-2026-05-06T08-52-43-000Z.chat.md palabre-compare-ces-approches-2026-05-06T08-52-43-000Z.ask.md ``` Si le sujet ne contient aucun caractère exploitable, Palabre utilise `debat`, `chat` ou `ask` comme nom court selon le mode. ## Synthèse finale En Débat et Ask, la synthèse est séparée du transcript par une ligne horizontale. Elle commence par une table courte : agent, rôle et date. Chat n'ajoute pas de synthèse automatique : il conserve la conversation et sa raison de fin. ## Aperçu Windows Certains aperçus Windows interprètent `:**` comme un émoji. Palabre remplace cette séquence par `:**` dans les contenus exportés. Le rendu Markdown reste visuellement équivalent, mais l'aperçu Windows évite l'interprétation en émoji. ## Changer le dossier de sortie Dans la configuration avancée : ```json { "outputDir": ".palabre" } ``` Les prochains exports seront placés dans ce dossier. ## Historique Depuis la TUI : ```text /history ``` La vue historique affiche les derniers exports `.debate.md`, `.chat.md` et `.ask.md`, leur mode, les agents, le nombre de tours ou réponses, le fichier et le dossier de sortie. Hors TUI, utilisez `palabre history` ou `palabre history --json`. # Faire débattre Codex et Claude Code Palabre peut faire dialoguer Codex CLI et Claude Code sur une décision technique avant que vous ne passiez à l'implémentation. Chaque agent reçoit le même sujet et le même contexte, puis répond à l'analyse précédente. Ce workflow est utile pour challenger une architecture, relire un plan de migration, comparer deux stratégies ou rechercher les risques oubliés par une première proposition. ## Préparer Codex et Claude Code Installez et authentifiez les deux CLIs avec leurs mécanismes habituels. Palabre ne remplace pas leurs comptes ni leurs abonnements. Vérifiez ensuite leur disponibilité : ```bash codex --version claude --version palabre config --sync-agents palabre doctor ``` La commande suivante doit afficher le preset comme disponible : ```bash palabre presets --json ``` ## Lancer le débat Le preset `codex-claude` place Codex en premier et Claude Code en second : ```bash palabre codex-claude "Compare ces deux architectures et recommande la plus robuste" -t 4 ``` La variante inverse fait parler Claude Code en premier : ```bash palabre claude-codex "Relis ce plan de migration et tranche les désaccords" -t 4 ``` La position détermine l'ordre de parole. Les rôles restent ceux de votre configuration, sauf override explicite pour la session. ## Donner des rôles complémentaires Une paire fonctionne mieux lorsque les agents ne reçoivent pas exactement la même mission. Par exemple : ```bash palabre run \ --subject "Faut-il séparer ce service en deux ?" \ --agent-a codex \ --agent-b claude \ --role-a architect \ --role-b critic \ --turns 4 ``` Codex structure alors une proposition d'architecture, tandis que Claude Code cherche les hypothèses fragiles et les conséquences non traitées. ## Ajouter le contexte du projet Utilisez `--files` pour une sélection stricte et reproductible : ```bash palabre codex-claude "Évalue cette stratégie de cache" \ --files src/cache.ts src/config.ts \ -t 4 ``` Utilisez `--context` pour scanner un dossier de manière tolérante : ```bash palabre codex-claude "Propose une migration progressive" \ --context src docs/architecture \ -t 4 ``` Palabre marque les fichiers comme des données non fiables dans les prompts. Les limites de taille et les exclusions sont détaillées dans [Contexte et fichiers](https://palab.re/fr/usage/context-and-files). ## Lire la synthèse Après le transcript, l'agent de synthèse organise : - les points de consensus ; - les désaccords et incertitudes ; - les actions proposées ; - une conclusion courte. La session est exportée dans `.palabre/` sous la forme d'un fichier `.debate.md`. Cet export garde les arguments contradictoires, pas seulement la conclusion. ## Choisir Débat ou Ask Utilisez Débat lorsque les agents doivent répondre aux objections de l'autre. Utilisez [Ask](https://palab.re/fr/usage/ask) si vous voulez d'abord obtenir deux réponses indépendantes sans influence mutuelle. Pour une vue plus large des workflows disponibles, consultez [Utiliser plusieurs agents IA dans le terminal](https://palab.re/fr/usage/multi-agent-cli) et le [mode Débat](https://palab.re/fr/usage/debate). # Configuration La configuration indique à Palabre quels agents existent, quels agents utiliser par défaut et où écrire les exports. Si `outputDir` n'est pas défini, les fichiers `.debate.md`, `.chat.md` et `.ask.md` sont créés dans le dossier `.palabre/` par défaut. ## Créer une configuration Dans un terminal interactif, `palabre` crée automatiquement la configuration globale au premier lancement quand elle n'existe pas encore, puis ouvre l'accueil TUI : ```bash palabre ``` La commande explicite reste disponible pour les scripts, la CI, ou quand vous voulez créer une config sans entrer dans la TUI : ```bash palabre init ``` Cette commande crée une configuration globale : ```text ~/.palabre/palabre.config.json ``` Pour une configuration propre au projet courant : ```bash palabre init --local ``` Cela crée : ```text ./palabre.config.json ``` ## Voir la configuration utile ```bash palabre palabre agents palabre doctor ``` Depuis l'accueil TUI, `/config` affiche les réglages courants et `/agents` liste les agents disponibles. Hors TUI, `palabre agents` affiche les agents déclarés et leur détection locale. `palabre doctor` vérifie les erreurs courantes. Au démarrage de l'accueil TUI, Palabre synchronise prudemment les agents connus détectés : il peut ajouter les agents connus manquants et rafraîchir les noms de commandes connus, mais il n'écrase pas les agents custom, les rôles, les modèles ni les defaults utilisateur. ## Modifier les paramètres courants ```bash palabre config ``` Dans la TUI, `/config` permet de définir ou supprimer les paramètres par défaut sans quitter Palabre. Les commandes directes ci-dessous permettent aussi de modifier un seul réglage depuis le terminal ou un script. Commandes directes utiles : ```bash palabre config --set-defaults codex claude --summary-agent claude -t 4 palabre config --mode ask --ask-agents codex claude opencode --ask-summary-agent opencode palabre config --interface tui palabre config --language en palabre config -t 3 palabre config --summary-agent claude palabre config --clear-defaults palabre config --sync-agents palabre config --ollama-models --json palabre config --set-ollama-model palabre config --sync-ollama-model ``` Dans la TUI, les mêmes réglages courants sont accessibles depuis `/config` avec des commandes comme `/agents`, `/roles`, `/summary`, `/turns`, `/interface`, `/language`, `/mode`, `/ollama`, `/ollama-url `, `/ollama-model ` et `/ollama-sync`. Utilisez `/home` pour revenir à l'accueil. ## Aller plus loin - [Paramètres par défaut](https://palab.re/fr/configuration/defaults) - [Configuration locale ou globale](https://palab.re/fr/configuration/local-vs-global) - [JSON avancé](https://palab.re/fr/configuration/advanced-json) # Paramètres par défaut Les paramètres par défaut sont utilisés quand vous lancez une session sans préciser tous les agents ou toutes les options. Ils peuvent être partiels : vous pouvez définir seulement le nombre de tours, seulement la synthèse, ou une paire d'agents complète. ## Définir les agents par défaut ```bash palabre config --set-defaults codex claude ``` Après cette commande : ```bash palabre -s "Critique ce plan" ``` utilise `codex` en agent A et `claude` en agent B. ## Définir la synthèse par défaut ```bash palabre config --summary-agent claude ``` Si aucun agent de synthèse n'est défini, Palabre utilise l'agent B. Pour retirer ce réglage sans supprimer les autres paramètres par défaut : ```bash palabre config --summary-agent none ``` ## Définir les agents Ask par défaut ```bash palabre config --ask-agents codex claude opencode ``` Le mode Ask accepte 1 à 4 agents. Sans ce réglage, Palabre utilise la paire de débat par défaut. Pour choisir un agent de synthèse spécifique au mode Ask : ```bash palabre config --ask-summary-agent opencode ``` Ce réglage est séparé de `--summary-agent`, afin de pouvoir garder une synthèse différente entre débat et Ask. ## Définir le mode par défaut ```bash palabre config --mode chat ``` Les valeurs acceptées sont `debate`, `chat` et `ask`. Débat reste le mode principal. Chat utilise `defaults.agentA` comme agent actif initial ; Ask utilise `defaults.askAgents`. Dans la TUI, changez de mode avec `/debat`, `/chat` ou `/ask`. ## Définir le nombre de tours ```bash palabre config -t 4 ``` `turns` est le nombre total de tours du débat. Palabre accepte une valeur entre 1 et 20. ## Définir la langue ```bash palabre config --language en ``` La langue configurée contrôle l'interface Palabre et les prompts envoyés aux agents. Vous pouvez la forcer pour une commande avec `--language `, `--lang ` ou la variable d'environnement `PALABRE_LANGUAGE`. Dans la TUI, ouvrez `/config`, puis utilisez : ```text /language fr /language en ``` Les alias `/lang fr` et `/langue fr` sont aussi acceptés. ## Définir l'interface par défaut ```bash palabre config --interface tui ``` `tui` est le comportement recommandé pour utiliser Palabre dans un terminal interactif. Pour retrouver le rendu brut par défaut : ```bash palabre config --interface terminal ``` ## Supprimer les paramètres par défaut ```bash palabre config --clear-defaults ``` Après cela, utilisez un preset ou des agents explicites : ```bash palabre codex-claude "Sujet" -t 4 palabre run --subject "Sujet" --agent-a codex --agent-b claude ``` # Configuration locale ou globale Palabre peut utiliser une configuration globale pour tous vos projets, ou une configuration locale pour un projet précis. ## Configuration globale Dans un terminal interactif, `palabre` crée automatiquement cette configuration globale au premier lancement. ```bash palabre init ``` Fichier créé : ```text ~/.palabre/palabre.config.json ``` Utilisez `palabre init` explicitement si vous voulez préparer la config globale sans ouvrir la TUI, ou si vous voulez les mêmes agents par défaut partout. ## Configuration locale ```bash palabre init --local ``` Fichier créé : ```text ./palabre.config.json ``` Utilisez cette option si un projet doit avoir ses propres agents, modèles ou dossier d'export. Une configuration locale peut lancer les commandes déclarées dans ses agents et contacter les serveurs Ollama configurés. Palabre demande donc une approbation avant sa première utilisation et enregistre son empreinte dans `~/.palabre/trusted-configs.json`. Toute modification externe du fichier invalide cette approbation. Dans un flux non interactif, vérifiez le fichier puis utilisez `--trust-config` une fois pour enregistrer sa nouvelle empreinte. `palabre doctor` reste utilisable avant l'approbation pour examiner la configuration. Dans ce cas, il n'appelle pas les URLs Ollama déclarées par le fichier non fiable. ## Ordre de résolution Palabre cherche la configuration dans cet ordre : 1. `./palabre.config.json` 2. `~/.palabre/palabre.config.json` Vous pouvez forcer un fichier : ```bash palabre run -s "Sujet" --config ./palabre.config.json palabre agents --config ./palabre.config.json ``` # JSON avancé La plupart des réglages courants peuvent se faire avec `palabre config`. Cette page concerne les cas où vous éditez directement `palabre.config.json`. ## Structure minimale ```json { "outputDir": ".palabre", "defaults": { "agentA": "codex", "agentB": "claude", "summaryAgent": "claude", "turns": 4 }, "agents": { "codex": { "type": "cli", "command": "codex", "args": ["exec", "-"], "promptMode": "stdin", "role": "implementer" }, "claude": { "type": "cli", "command": "claude", "args": ["--print"], "promptMode": "stdin", "role": "reviewer" } } } ``` ## Champs principaux | Champ | Description | | ----------------------- | ------------------------------------------------------------------------------ | | `outputDir` | Dossier de destination des exports `.debate.md`, `.chat.md` et `.ask.md`. | | `defaults.agentA` | Agent qui répond en premier par défaut. | | `defaults.agentB` | Agent qui répond en second par défaut. | | `defaults.summaryAgent` | Agent utilisé pour la synthèse finale par défaut. | | `defaults.turns` | Nombre total de réponses, entre 1 et 20. | | `agents` | Liste des agents disponibles. Elle doit contenir au moins un agent utilisable. | ## Agent CLI ```json "claude": { "type": "cli", "command": "claude.exe", "args": ["--print", "--output-format", "text", "--no-session-persistence", "--tools", "Read,Glob,Grep"], "promptMode": "stdin", "shell": false, "role": "reviewer" } ``` Options utiles : | Option | Description | | ---------------- | -------------------------------------------------------------------------------------------------------- | | `command` | Commande à lancer. | | `args` | Arguments transmis à la commande. | | `promptMode` | `stdin` ou `argument`. | | `modelArg` | Flag utilisé pour transmettre un modèle. | | `model` | Modèle par défaut de cet agent. | | `shell` | Utile sur Windows pour certains wrappers npm ou PowerShell. | | `role` | Rôle de l'agent. | | `timeoutMs` | Timeout global. | | `idleTimeoutMs` | Timeout si la CLI reste silencieuse. | | `maxOutputBytes` | Taille maximale cumulée de la sortie, 50 Mio par défaut. Une valeur invalide rétablit cette limite sûre. | | `cols` / `rows` | Dimensions du pseudo-terminal pour les agents `cli-pty`. | ## Agent Ollama ```json "ollama-local": { "type": "ollama", "baseUrl": "http://localhost:11434", "model": "", "role": "critic", "validateModel": true, "unloadOtherModels": true } ``` Options utiles : | Option | Description | | ------------------- | --------------------------------------------------------------------- | | `model` | Modèle Ollama utilisé. | | `baseUrl` | URL de l'API Ollama. | | `validateModel` | Vérifie que le modèle est installé. | | `autoPullModel` | Autorise le téléchargement automatique. | | `pullTimeoutMs` | Timeout du téléchargement. | | `unloadOtherModels` | Décharge les autres modèles avant génération. | | `keepAlive` | Durée de maintien du modèle chargé. | | `temperature` | Variation des réponses. | | `maxOutputBytes` | Taille maximale de chaque réponse HTTP bufferisée, 50 Mio par défaut. | # Intégrer Palabre Palabre CLI est la source de vérité pour les agents, presets, contexte, orchestration, erreurs et exports. Une intégration lance le CLI comme processus enfant et rend ses contrats publics, sans analyser la TUI ni réimplémenter ses décisions. | Besoin | Contrat | | ---------------- | ------------------------------------------ | | Agents | `palabre agents --json` | | Paires | `palabre presets --json` | | Contexte | `palabre context scan --json` | | Historique | `palabre history --json` | | Prévisualisation | `--dry-run --renderer ndjson` | | Session | `--renderer ndjson` | | Identité | `PALABRE_CLIENT`, `PALABRE_CLIENT_VERSION` | Les sorties portent un champ `v`. Les ajouts optionnels restent compatibles ; toute suppression, renommage ou modification de sens exige une nouvelle version. ## Lancer une session ```bash palabre run --mode debate --subject "Sujet" --agent-a codex --agent-b claude --renderer ndjson palabre run --mode ask --subject "Sujet" --agents codex claude --renderer ndjson palabre chat --agent-a codex --renderer ndjson ``` Chat reçoit les messages sur stdin. Une intégration lit stdout ligne par ligne, conserve stderr séparément et attend la fermeture du processus. Consultez [Catalogues JSON](https://palab.re/fr/integrations/json-contracts), [NDJSON v1](https://palab.re/fr/integrations/ndjson) et [Cycle de vie](https://palab.re/fr/integrations/client-lifecycle). # Catalogues JSON Ces commandes écrivent un document JSON sur stdout et terminent sans lancer de session IA. - `palabre agents --json` expose `roles[]`, `agents[]` et `defaults.askAgents[]`. Chaque agent fournit son nom, type, rôle, disponibilité et une raison si nécessaire. - `palabre presets --json` expose les paires, leur ordre, `available`, `missingAgents[]` et `unavailableReasons[]`. - `palabre context scan src docs --json` expose la racine, les chemins demandés, `items[]` et `warnings[]`. - `palabre history --json` expose les 10 exports les plus récents dans `history[]`. Une intégration peut demander de 1 à 100 entrées avec `--limit `. - `palabre sessions --json` expose les 20 checkpoints les plus récents dans `sessions[]`, avec une limite de 1 à 100. Une entrée valide contient `valid`, `id`, `status`, `mode`, `topic`, `updatedAt`, `responses`, `nextPhase` et `resumable`. Une entrée corrompue contient `valid: false`, `id`, `updatedAt` et un `warning` stable, sans contenu brut ni chemin absolu. - `palabre sessions delete --yes --json` confirme la suppression ciblée avec `{ "v": 1, "deleted": { "id": "..." } }`. ## Règles de consommation - vérifier `v` ; - ignorer les champs inconnus ; - accepter l'absence des champs optionnels ; - ne pas recalculer la disponibilité ou les règles de scan ; - afficher les avertissements sans en modifier le sens. # Flux NDJSON v1 `--renderer ndjson` écrit un objet JSON valide par ligne sur stdout. Chaque événement contient `v: 1` et un champ `type`. | Type | Usage | | ------------------------------------ | ------------------------------------------------------ | | `start` | Mode, sujet, agents, contexte et options. | | `notice`, `warning` | Informations ordonnées dans le flux. | | `thinking-start`, `thinking-end` | État d'attente d'un agent. | | `turn-start`, `message` | Tour et réponse Débat. | | `ask-response-start`, `ask-response` | Réponse Ask. | | `summary-start`, `summary-message` | Synthèse. | | `dry-run` | Prévisualisation résolue sans appel d'agent ni export. | | `error` | Échec structuré. | | `done` | Fin métier et chemin d'export, éventuellement nul. | Chat ajoute `chat-agents`, `chat-user-message`, `chat-message`, `chat-consultation-start`, `chat-consultation` et `chat-agent-changed`. Ses commandes sont envoyées sur stdin, une ligne à la fois. Pour une intégration, chaque commande Chat doit être un objet JSON v1 sur une seule ligne : | Commande | Usage | | -------------- | ---------------------------------------------------------------------- | | `chat-send` | Envoyer `content` à l'agent actif. | | `chat-consult` | Demander un avis ponctuel à `agent` sans changer l'agent actif. | | `chat-use` | Choisir `agent` comme interlocuteur actif pour les prochains messages. | | `chat-agents` | Redemander la liste des agents disponibles. | | `chat-end` | Terminer la conversation et produire l'export `.chat.md`. | ```json {"v":1,"type":"chat-send","content":"Analyse cette approche"} {"v":1,"type":"chat-consult","agent":"vibe"} {"v":1,"type":"chat-use","agent":"vibe"} {"v":1,"type":"chat-end"} ``` Les commandes texte historiques restent acceptées pour les usages humains. Une intégration doit utiliser les objets JSON afin que le contenu d'un message ne puisse pas être confondu avec une commande. ```json {"v":1,"type":"thinking-start","agent":"codex","role":"implementer"} {"v":1,"type":"thinking-end"} {"v":1,"type":"message","turn":1,"agent":"codex","role":"implementer","content":"..."} {"v":1,"type":"done","outputPath":"C:\\project\\.palabre\\session.debate.md"} ``` stdout appartient au NDJSON. stderr peut contenir les diagnostics et la progression Ollama. Conservez l'ordre, ignorez les types inconnus, attendez le code de sortie et rendez le contenu agent comme texte non fiable, jamais comme HTML exécutable. # Cycle de vie, erreurs et identité | Code | Signification | | ----- | ------------------------------------------------- | | `0` | Succès. | | `1` | Erreur de validation, configuration ou exécution. | | `130` | Annulation. | Attendez toujours la fermeture du processus. `error` décrit l'échec métier ; le code confirme l'état final. Un événement `error` peut contenir la phase, l'agent, le rôle, le tour, un `kind` stable, un message et des détails. Les kinds incluent notamment `command-not-found`, `spawn-failed`, `timeout`, `idle-timeout`, `output-too-large`, `empty-output`, `non-zero-exit`, `usage-limit`, `unsupported-model`, `model-unavailable`, `model-pull-failed`, `http-error` et `cancelled`. Pour un `usage-limit`, `retryAfter` est parfois présent : durée en secondes, timestamp ISO ou heure locale `HH:mm`. Il est best-effort ; branchez la logique sur `kind`, pas sur le texte du message. Palabre tente de conserver les réponses dans un export partiel après un échec. Acceptez donc `done` avec un chemin suivi d'un code non nul. Une annulation doit rester distincte d'une erreur. ## Identité du client ```text PALABRE_CLIENT=mon-integration PALABRE_CLIENT_VERSION=2.3.0 ``` Le nom est libre. Palabre nettoie ces valeurs et les inscrit avec sa propre version dans les exports. Sans déclaration, la source est `direct-cli`. Ces champs sont diagnostiques, pas une frontière de sécurité. # Dépannage Commencez par lancer le diagnostic : ```bash palabre doctor ``` `doctor` ne lance aucun agent IA. Il affiche un diagnostic par sections : configuration, outils locaux, agents et points à vérifier. Il contrôle les agents déclarés, les paramètres par défaut, le nombre de tours, `outputDir`, les CLIs disponibles, Ollama et les modèles configurés. Pour obtenir une sortie brute adaptée aux logs ou aux scripts : ```bash palabre doctor --terminal ``` ## Palabre ne trouve pas ma configuration Message typique : ```text [ERREUR] Config absente: ... ``` Dans un terminal interactif, le plus simple est de laisser Palabre créer la configuration globale : ```bash palabre ``` Pour les scripts ou un setup sans ouvrir la TUI, initialisez explicitement : ```bash palabre init ``` Pour une configuration locale au projet courant : ```bash palabre init --local ``` ## La configuration est illisible Message typique : ```text [ERREUR] Config illisible: ... ``` Vérifiez que le JSON ne contient pas de virgule finale, que les clés sont entre guillemets et que le fichier est bien encodé en UTF-8. Pour repartir d'une configuration propre : ```bash palabre init --config ./nouvelle-config.json ``` ## Un agent par défaut est inconnu Message typique : ```text [ERREUR] defaults.agentA pointe vers un agent inconnu: ... ``` Listez les agents disponibles : ```bash palabre agents ``` Puis corrigez les agents par défaut : ```bash palabre config --set-defaults codex claude ``` ## Un agent installé n'apparaît pas dans la config Message typique : ```text [WARN] Agent(s) detecte(s) mais absent(s) de la config: opencode. ``` Relancez `palabre` pour laisser la TUI synchroniser les agents connus détectés, ou synchronisez explicitement : ```bash palabre config --sync-agents ``` Cette commande ajoute les agents connus manquants et rafraîchit les noms de commandes connus sans écraser vos réglages existants. ## Le nombre de tours par défaut est invalide Message typique : ```text [ERREUR] defaults.turns invalide: 99. ``` Choisissez un nombre entre 1 et 20 : ```bash palabre config -t 4 ``` ## Le dossier d'export pose problème Message typique : ```text [ERREUR] outputDir pointe vers un fichier, pas un dossier: ... ``` Corrigez `outputDir` dans `palabre.config.json`, ou supprimez ce champ pour écrire les exports dans le dossier `.palabre/` par défaut. ## Une CLI est introuvable Message typique : ```text [WARN] Codex CLI: non détecté dans PATH. ``` Actions : - installez la CLI concernée ; - authentifiez-la hors de Palabre ; - fermez et rouvrez le terminal ; - relancez `palabre doctor` ; - corrigez `command` dans la configuration si la commande porte un autre nom. Sur Windows, les wrappers npm ou PowerShell comme `codex`, `opencode` et `vibe` peuvent nécessiter `shell: true` dans la configuration. Claude fonctionne souvent mieux avec `claude.exe` et `shell: false`. ## Ollama ne répond pas Message typique : ```text [WARN] Ollama installé mais API non joignable: http://localhost:11434 ``` Démarrez Ollama : ```bash ollama serve ``` Puis relancez : ```bash palabre doctor ``` Si Ollama utilise une autre URL, corrigez `baseUrl` dans l'agent Ollama. ## Le modèle Ollama est absent Message typique : ```text [WARN] ollama-local [ollama:critic] model=... absent. ``` Installez le modèle : ```bash ollama pull le-modele ``` ou choisissez un modèle déjà installé pour Palabre : ```bash palabre config --ollama-models --json palabre config --set-ollama-model le-modele-installe ``` Si vous voulez simplement remplacer le modèle configuré absent par un modèle installé disponible : ```bash palabre config --sync-ollama-model ``` ou autorisez Palabre à le télécharger au lancement : ```bash palabre codex-ollama "Sujet" --model-b le-modele --pull-models ``` Certains modèles pèsent plusieurs Go. Sur une machine modeste, privilégiez un modèle local raisonnable. ## Ollama ne voit pas mes fichiers Ollama ne lit pas le filesystem directement. Ajoutez le contexte au prompt : ```bash palabre codex-ollama "Critique ce module" --files src/module.ts ``` ou : ```bash palabre codex-ollama "Critique l'architecture" --context src docs ``` ## Une CLI atteint une limite d'usage Message typique : ```text Erreur: codex a atteint une limite d'utilisation: ... ``` Actions possibles : - attendez l'heure indiquée par la CLI ; - changez de modèle dans la CLI ou avec `--model-a` / `--model-b` ; - utilisez une autre paire d'agents ; - désactivez temporairement l'agent concerné dans votre configuration. ## La sortie d'un agent est vide Message typique : ```text produced empty output ``` Testez la commande hors de Palabre, puis vérifiez `args`, `promptMode`, `shell` et les timeouts dans la configuration. `allowEmptyOutput` existe, mais il vaut mieux le garder désactivé sauf cas très spécifique. ## Mise à jour Pour vérifier sans modifier la machine : ```bash palabre update --check ``` `palabre update` détecte le checkout Git, npm, pnpm, Yarn ou Bun global et affiche l'action exacte. Dans un terminal interactif, il demande une confirmation unique avant toute mutation. Utilisez `--dry-run` pour prévisualiser les étapes ou `--yes` en automatisation explicitement autorisée. Avec les versions récentes de pnpm, `palabre@latest` peut parfois rester temporairement sur une ancienne version à cause des garde-fous de chaîne d'approvisionnement. Palabre utilise donc la version npm exacte quand elle est disponible : ```bash pnpm add --global palabre@0.8.1 ``` Adaptez le numéro à la version affichée par `palabre update` ou par : ```bash pnpm view palabre version ``` Si le canal est inconnu ou ambigu, Palabre ne modifie rien. Réinstallez alors avec le gestionnaire utilisé initialement, par exemple : ```bash pnpm add --global palabre@latest ``` `--apply` reste un alias compatible de `--yes`. # Roadmap Cette page donne une vue d'ensemble des évolutions prévues pour Palabre. Elle aide les utilisateurs à comprendre où va le projet, sans promettre de date de livraison. ## Direction du produit Palabre aide à **mieux décider avant d’agir**. C’est un harnais d’intelligence collective orchestrée : il fait dialoguer les outils IA que vous avez choisis, organise les avis contradictoires et rend les décisions explicites. Les évolutions futures s’inscrivent dans une même session, plutôt que dans une multiplication de modes indépendants : - **Consulter** : discuter avec un agent, demander plusieurs avis ou lancer un débat ; - **Décider** : synthétiser, approfondir une conclusion, préparer ou faire relire un plan ; - **Agir** : préparer une action et, seulement après confirmation explicite, la déléguer à un outil adapté. L’action reste optionnelle et sous le contrôle de l’utilisateur. Palabre n’a pas vocation à remplacer les assistants de code ou les outils spécialisés : son rôle est d’éclairer une décision et d’enchaîner proprement vers l’étape suivante quand vous le souhaitez. ## Disponible aujourd'hui Palabre permet déjà de lancer des débats entre deux agents installés sur votre machine, ou des demandes Ask où plusieurs agents répondent indépendamment avant une synthèse comparative : Claude Code, Codex CLI, Antigravity CLI, OpenCode, Mistral Vibe ou Ollama. Les fonctionnalités principales sont disponibles : - configuration globale ou locale ; - détection des agents installés ; - configuration globale automatique au premier lancement TUI, avec rafraîchissement prudent des agents connus détectés ; - interface TUI-first avec `palabre`, `/agents`, `/roles`, `/config`, `/history` et `/home` ; - assistant interactif `palabre new` ; - mode `ask` avec 1 à 4 agents et export `.ask.md` ; - mode `chat` stateless avec un agent actif, consultation explicite, contexte borné et export `.chat.md` ; - presets comme `codex-claude`, `claude-antigravity`, `codex-antigravity` ou `opencode-ollama` ; - interface et prompts en français ou en anglais avec `--language`, `--lang`, `PALABRE_LANGUAGE` ou la configuration ; - ajout de contexte avec `--files` ou `--context` ; - prévisualisation du scan de contexte avec `palabre context scan --json` pour les intégrations ; - synthèse finale avec consensus, désaccords, actions proposées et conclusion ; - export Markdown `.debate.md`, `.chat.md` ou `.ask.md` avec nom basé sur le sujet ; - historique local des exports avec `palabre history`, `palabre history --json` et `/history` dans la TUI ; - checkpoints opt-in pour Débat et Ask, avec `palabre sessions` et `palabre resume ` sans rejouer les réponses déjà validées ; - export partiel conservé si un agent plante pendant le débat ou la synthèse ; - diagnostic avec `palabre doctor` ; - sortie machine-readable avec `palabre agents --json`, `palabre presets --json`, `palabre context scan --json` et le renderer NDJSON ; - erreurs structurées pour les intégrations, avec une politique de versioning NDJSON ; - parser CLI plus robuste pour les flags booléens comme `--terminal`, `--json` ou `--no-summary` ; - contrats runtime plus stricts : les exits CLI non nuls sont rejetés, la progression de pull Ollama reste hors stdout NDJSON, et les chemins `--context` manquants deviennent des warnings ; - tests automatisés de l'adapter CLI, du parser, du renderer NDJSON, des presets, du scan de contexte, des prompts et de la configuration de sortie, sans appeler de vrais services IA. ## Prochaines améliorations ### Diagnostic plus utile `palabre doctor` est le premier réflexe quand quelque chose ne fonctionne pas. Il affiche un diagnostic lisible par sections et garde `--terminal` pour les logs. Les prochaines améliorations continueront à rendre ses messages plus actionnables pour les problèmes courants : agent introuvable, configuration incomplète, modèle Ollama manquant, PATH incorrect ou quota atteint côté provider. ### Intégrations plus robustes Palabre expose déjà des contrats JSON pour les presets, le scan de contexte et le rendu NDJSON des débats. Les prochaines améliorations viseront à garder ces contrats stables, mieux documentés et plus faciles à consommer par l'extension VS Code ou d'autres intégrations. ### Configuration plus simple La commande `palabre config`, la vue TUI `/config`, la configuration de premier lancement et la synchronisation des agents connus couvrent déjà les réglages courants : agents par défaut, rôles, nombre de tours, agent de synthèse, mode par défaut, interface par défaut et rafraîchissement des agents détectés. Les prochaines améliorations viseront surtout des messages plus clairs, de meilleures validations et des wizards plus complets pour les choix qui méritent de la découverte. ### Conversation après le débat Après la synthèse finale d'un débat ou d'un Ask, `/chat` permet maintenant de poursuivre avec un agent actif. Le contexte transmis indique sa provenance et reprend le sujet avec la synthèse finale, ou les six échanges récents lorsqu'aucune synthèse n'existe. La conversation reste stateless et bornée ; les sessions Chat persistantes et le streaming restent des évolutions distinctes. ### Tests et stabilité Les tests reproductibles couvrent déjà l'adapter CLI, le renderer NDJSON, la disponibilité des presets et la résolution du dossier d'export. La suite consiste à élargir progressivement cette couverture aux autres comportements sensibles, sans appeler de vrais services IA pendant les tests automatisés. ## Ensuite Ces sujets sont envisagés après stabilisation du CLI : - reprise d'un débat depuis un export Markdown existant, distincte de `palabre resume` qui reprend un checkpoint Palabre ; - provider compatible OpenAI local pour LM Studio, LocalAI, vLLM ou équivalent ; - maintenance continue de la documentation française et anglaise ; - interface CLI multilingue français/anglais à continuer d'affiner, avec un futur choix interactif de langue dans les flows de premier lancement ou de configuration ; - TUI plus avancée avec scrolling, panneaux persistants, pause et reprise ; - affichage fiable des modèles quand Palabre pourra les connaître sans bruit inutile. ## Philosophie Palabre restera centré sur un principe simple : piloter les outils IA que vous avez déjà installés, sans remplacer leurs comptes, leurs modèles, leurs abonnements ou leurs règles de confidentialité. Son différenciateur est le désaccord organisé, la synthèse explicite et l’action sous contrôle. # Changelog Cette page est générée depuis le changelog canonique du dépôt Palabre à chaque publication. ## [0.16.0] - 2026-08-31 ### Added - Les erreurs d'agent peuvent désormais indiquer un délai de reprise structuré (`retryAfter`), y compris dans les événements NDJSON destinés aux intégrations. ### Changed - Les écrans TUI, leur fil d'Ariane, leurs cartes et le composer partagent une navigation et une présentation cohérentes ; l'accueil met plus clairement en avant la session, les commandes essentielles et l'ajout de contexte. - Les guides français et anglais décrivent les comportements actuels des agents, de la configuration, du contexte et des contrats d'intégration. ### Fixed - Les écritures de configuration, la confiance associée et les lancements d'agents locaux sont plus robustes, notamment face aux shims Windows, aux sorties et aux erreurs d'adapters variables. - Les diagnostics Ollama, le scan de contexte, les exports et les événements NDJSON conservent leurs limites et leurs messages utiles dans davantage de cas limites. ## [0.15.0] - 2026-08-30 ### Added - `--checkpoint` conserve explicitement un état machine versionné et atomique sous `.palabre/sessions/`, avant le premier appel, après chaque réponse complète et à la fin d'une session Débat ou Ask. - `palabre resume ` reprend explicitement le prochain tour, les réponses Ask restantes ou la synthèse, après validation stricte de la configuration, du contexte et confirmation utilisateur. - `palabre sessions` liste les checkpoints récents, y compris les entrées invalides, et `palabre sessions delete ` supprime uniquement le checkpoint explicitement confirmé. ## [0.14.0] - 2026-08-30 ### Added - `/new` propose un parcours guidé commun à Chat, Débat et Ask, avec choix des agents, récapitulatif de session, lancement immédiat ou personnalisation des options avancées. - Le composer affiche une liste contextuelle et documentée dès la saisie de `/`, navigable avec les flèches, `Tab` ou `→`, sans dupliquer les alias d'une même commande. - `palabre history --json --limit <1-100>` permet aux intégrations de borner explicitement le nombre d'exports retournés. ### Changed - L'accueil TUI résume la session active dans une carte compacte, met en avant les raccourcis essentiels et signale seulement les agents requis qui sont indisponibles. - Les commandes proposées sont ordonnées selon le parcours utilisateur, masquent le mode déjà actif et se réduisent à la navigation essentielle dans les vues informatives. - Les guides français et anglais documentent le nouvel accueil, le picker contextuel et la composition guidée d'une session. ### Fixed - La navigation dans les listes TUI ne duplique plus leur rendu après l'utilisation des flèches et annule les rafraîchissements différés lors de la validation d'une commande. - Le focus revient correctement au composer après une vue secondaire ou un retour avec `Ctrl+C`. - Les diagnostics Codex privilégient l'erreur JSON terminale utile au lieu du bruit de prompt ou de démarrage MCP. - Le dry-run reflète les rôles temporaires réellement appliqués à la session. ### Removed - Gemini n'est plus généré, détecté ni proposé comme agent connu ou preset actif ; les anciennes configurations peuvent encore le conserver comme CLI personnalisée, tandis qu'Antigravity reste l'intégration Google de référence. ## [0.13.0] - 2026-07-21 ### Added - Ajoute un protocole stdin JSON v1 pour piloter Chat depuis une intégration avec `chat-send`, `chat-consult`, `chat-use`, `chat-agents` et `chat-end`. - Émet le message utilisateur avant l'appel agent afin que les clients puissent l'afficher immédiatement pendant la réflexion. ### Changed - Conserve les commandes texte historiques de Chat pour le terminal tout en réservant le protocole structuré aux intégrations. ## [0.12.0] - 2026-07-20 ### Added - Le mode Chat stateless permet de converser avec un agent, d'en consulter un autre avec `/consult`, de changer d'interlocuteur avec `/use` et d'exporter la session en `.chat.md`. - Le renderer NDJSON v1 expose les événements Chat nécessaires aux intégrations sans modifier le sens des contrats Debate et Ask. - `--dry-run` fournit un aperçu structuré de l'exécution sans lancer les agents. - Les exports `.debate.md`, `.ask.md` et `.chat.md` indiquent désormais la version du CLI et la provenance déclarée par une intégration. Merci à [@ccoelhofize](https://github.com/ccoelhofize){rel=""nofollow""} pour le diagnostic détaillé et la proposition dans [#30](https://github.com/JuReyms/Palabre/issues/30){rel=""nofollow""}. ### Changed - L'accueil et la configuration TUI traitent Chat comme un mode de session officiel, avec un agent actif unique et des overrides temporaires correctement isolés. ### Fixed - Le compositeur Chat conserve un lecteur partagé, accepte les collages multilignes et ne perd plus la saisie après plusieurs navigations TUI. - Une consultation affiche désormais l'identité réelle de l'agent consulté pendant la connexion et la réflexion. - Les conversations terminées par `/end` ou interrompues par une erreur inscrivent leur cause de fin ; une erreur conserve automatiquement une transcription partielle. - Les processus agents Node/Python reçoivent un environnement UTF-8 cohérent afin d'éviter les réponses corrompues sous Windows. ## [0.11.2] - 2026-07-11 ### Changed - Les posts Bluesky de release annoncent explicitement `Palabre CLI vX.Y.Z` pour les distinguer des releases de l'extension VS Code. - Le README met en avant l'extension VS Code avec un badge Marketplace statique et une section dédiée en anglais/français. - Le README présente plus clairement `palabre` comme l'expérience TUI principale, avec les exemples CLI relégués à l'usage scriptable. ### Fixed - Les titres Markdown collés dans les sorties PTY d'Antigravity sont séparés avant le rendu et l''export, afin de préserver la structure des synthèses. ## [0.11.1] - 2026-07-10 ### Fixed - Les shims PowerShell npm/pnpm utilisent un hôte résolu sous `System32` quand le processus appelant possède un PATH réduit, notamment depuis VS Code. ## [0.11.0] - 2026-07-10 ### Added - Rôles de session : `--role-a`, `--role-b` et `--ask-role` appliquent des rôles temporaires sans modifier la configuration. `palabre agent-role ` actualise explicitement le rôle durable pour un agent. - Le contrat v1 `palabre agents --json` expose désormais `roles`, le catalogue canonique utilisable par les intégrations. ### Changed - Les configurations Codex historiques sont migrées en mémoire vers le mode `exec` lecture seule actuel lors du chargement. ### Fixed - Sous Windows, les alias Codex de `WindowsApps` ne sont plus préférés au shim PowerShell npm/pnpm, ce qui évite les erreurs `spawn EPERM`. - Les sorties CLI encodées en Windows-1252 sont décodées correctement lorsque UTF-8 est invalide, notamment pour Mistral Vibe. ## [0.10.2] - 2026-07-07 ### Changed - Les configs projet implicites exigent désormais une approbation liée à leur chemin et à leur empreinte ; les configs générées par Palabre sont approuvées automatiquement. - Les agents Claude, OpenCode et Vibe générés par défaut utilisent des capacités de lecture plus contraintes, et les prompts identifient explicitement le contexte et les transcripts comme données non fiables. - La résolution des exécutables Windows est centralisée et réutilise les binaires natifs ou les shims PowerShell sûrs pour les prompts transmis en argument. ### Fixed - Les adapters CLI et PTY refusent les lancements Windows susceptibles de réinterpréter un prompt ou un modèle via `cmd.exe`, sans casser Vibe lorsqu'un shim PowerShell est disponible. - Les réponses Ollama et la discovery `/api/tags` sont bornées avant parsing ; les erreurs JSON, limites de taille et noms de modèles sont classés et assainis de façon cohérente. - Les sorties agents, erreurs distantes, métadonnées d'historique et diagnostics `doctor` ne peuvent plus injecter de séquences de contrôle dans le terminal. - Les caractères UTF-8 produits par les agents CLI restent intacts lorsqu'ils sont répartis sur plusieurs blocs `stdout` ou `stderr`. - `palabre doctor` peut examiner une config projet non approuvée sans contacter les URLs Ollama qu'elle déclare. ## [0.10.1] - 2026-07-02 ### Changed - L'assistant `/new` adopte le design du TUI avec un en-tête, des indications plus lisibles et un choix de mode encadré. - Le logo de l'accueil utilise un violet légèrement plus sombre. - Le panneau de fin de session présente désormais `/retry`, `/new`, `/history`, `/config`, `/help` et la commande permettant de basculer vers l'autre mode. - Les guides d'installation documentent npm, pnpm, Yarn et Bun, ainsi que l'absence d'installation officielle via `pip` ou `curl`. ### Fixed - Un premier `Ctrl+C` depuis `/help`, `/history`, `/update` ou le composer revient à l'accueil ; un second `Ctrl+C` rapide ferme toujours la TUI. - L'annulation de `/new` depuis la TUI revient à l'accueil au lieu de fermer Palabre. ## [0.10.0] - 2026-07-02 ### Added - Le composer de l'accueil TUI accepte `--context ` et `--files ` à la fin du sujet, puis confirme les fichiers injectés dans l'en-tête de session. ### Changed - Le rendu TUI adopte un design unifié avec logo d'accueil, écrans spécialisés, cadres cohérents, couleurs sémantiques et blocs de conversation alignés à gauche. - Le renderer TUI historique est découpé en modules dédiés au thème, aux écrans, aux prompts et aux événements de session. - Les messages des adapters et de `palabre config --ollama-models` utilisent désormais les dictionnaires FR/EN. - Les duplications de l'orchestrateur, des adapters et du point d'entrée CLI sont factorisées sans modifier les contrats publics. ### Fixed - L'adapter PTY classe les diagnostics autonomes de quota Antigravity en `usage-limit`, y compris avec un exit code 0, sans confondre une réponse normale qui explique les rate limits. - Le repli `PALABRE_ASCII=1` utilise uniquement des glyphes ASCII, y compris pour le marqueur de succès. ## [0.9.1] - 2026-07-01 ### Changed - Le point d'entrée CLI délègue maintenant les commandes leaf, la résolution des options de session et le contrôleur TUI à des modules dédiés, sans modifier les contrats publics. - L'agent de synthèse est résolu une seule fois à la frontière CLI puis transmis comme option obligatoire aux renderers et à l'orchestrateur. - La résolution des options de débat et du mode Ask dispose désormais de tests directs couvrant les priorités entre flags, presets et defaults. ## [0.9.0] - 2026-07-01 ### Added - `palabre agents --json` expose un contrat v1 pour les intégrations avec les agents configurés actifs, leur disponibilité locale et la sélection Ask par défaut ; les agents retirés comme Gemini restent exclus même s'ils existent dans une ancienne config. - Ollama distant : `--ollama-url`, `OLLAMA_HOST` et `palabre config --ollama-url` permettent de surcharger ou de persister l'adresse du serveur, avec normalisation et validation des URL. - Configuration TUI : `/ollama-url ` modifie l'adresse de tous les agents Ollama sans éditer le JSON. - Accueil TUI : vérification de la dernière version npm à chaque ouverture, avertissement non bloquant et commande `/update` affichant les instructions adaptées. ### Fixed - Discovery, presets et doctor évaluent chaque agent Ollama avec son propre serveur et ses propres modèles, au lieu de réutiliser la détection de `ollama-local`. ## [0.8.1] - 2026-06-19 ### Added - Premier lancement TUI : `palabre` crée maintenant la configuration globale si aucune config n'existe, puis ouvre directement l'accueil. - Accueil TUI : synchronisation prudente des agents connus détectés à chaque ouverture, avec ajout des agents manquants et rafraîchissement des commandes connues. - Configuration TUI : `/ollama`, `/ollama-model ` et `/ollama-sync` permettent de consulter et changer le modèle `ollama-local` sans quitter Palabre. - TUI : `/history` affiche les derniers exports Markdown, avec liens fichier/dossier quand le terminal les supporte. - TUI : `/home` ramène à l'accueil depuis les vues secondaires et après une session. ### Changed - `palabre config --sync-agents` persiste aussi les rafraîchissements de commandes connues même lorsqu'aucun nouvel agent n'est ajouté. - Les guides et l'aide CLI recommandent désormais `palabre` comme entrée de première utilisation, avec `palabre init` réservé au setup explicite ou local. - Les cartes TUI de session, de fin de session, d'historique et d'aide utilisent un rendu plus homogène et gardent le header Palabre. - Les synthèses exposent le rôle runtime `summarizer`, même si l'agent configuré possède un autre rôle par défaut. - Vibe n'utilise plus le mode `plan` par défaut pour éviter des réponses mal adaptées à Palabre. ### Fixed - Adapters CLI et PTY : un exit code non nul est maintenant rejeté même si l'agent a écrit une sortie partielle. - Adapter Ollama : la progression de `--pull-models` est écrite sur stderr afin de préserver stdout pour le NDJSON. - `--context` : les chemins absents ou inaccessibles produisent un warning au lieu d'interrompre la session. - Parser CLI : `--agents` et `palabre config --ask-agents` conservent toutes les valeurs afin que la validation métier signale correctement le dépassement de 4 agents. - Débat TUI : les defaults Ask ne contaminent plus le lancement d'un débat. - Windows : les arguments des agents CLI sont quotés plus strictement quand ils passent par le shell. - TUI : les messages d'erreur et d'arrêt anticipé sont centrés comme les autres cartes runtime. ## [0.8.0] - 2026-06-17 ### Added - Mode `ask` : plusieurs agents peuvent répondre indépendamment au même sujet avant une synthèse comparative fidèle. - Interface TUI-first : `palabre` ouvre un accueil interactif avec composer, mode courant, agents, rôles, synthèse, dossier courant et version. - Configuration TUI native : `/config` permet de régler les agents, rôles, synthèse, tours, mode et interface sans sortir de Palabre. - Commandes TUI `/agents` et `/roles` avec vue d'aide/wizard quand elles sont lancées sans arguments, et commande rapide quand les valeurs sont fournies directement. - Affichage des agents disponibles dans la vue `/config`. - Options CLI `--tui`, `--terminal` et `defaults.interface` pour choisir l'interface par défaut. ### Changed - Les sessions interactives utilisent la TUI par défaut quand stdout est un terminal. - Les rôles deviennent plus visibles dans l'accueil, la config et les exports TUI. - `Ctrl+C` dans les wizards TUI remonte d'un niveau comme `/back`, et un double `Ctrl+C` quitte directement. - `palabre update` affiche aussi une commande pnpm avec la version npm exacte quand elle est disponible, afin de contourner les cas ou `palabre@latest` reste temporairement sur une ancienne version avec les politiques de securite pnpm recentes. ### Fixed - Le rendu TUI evite les doublons d'export Markdown en fin de session. - Les réponses et synthèses TUI utilisent une largeur plus cohérente et des séparateurs colorés par agent. ## [0.7.0] - 2026-06-10 ### Added - Configuration Ollama : `palabre config --ollama-models --json` expose le modele configure, sa disponibilite et les modeles installes pour les integrations. - Configuration Ollama : `palabre config --set-ollama-model ` valide un modele installe puis met a jour l'agent `ollama-local`. - Configuration Ollama : `palabre config --sync-ollama-model` remplace le modele Ollama configure quand il a disparu et qu'un autre modele installe est disponible. - Doctor affiche la version du CLI Palabre et signale quand une mise a jour semble disponible. ### Changed - `palabre config --sync-agents` rafraichit aussi les commandes des agents connus deja presents dans la config quand la detection locale trouve un meilleur executable. - `palabre presets --json` tient compte du modele Ollama configure absent, afin que les integrations masquent les presets Ollama non utilisables. ### Fixed - Annulation : `SIGINT` / `SIGTERM` interrompent maintenant les appels adapters en cours et terminent avec le code `130`. - Adapter CLI/PTTY/Ollama : les annulations sont propagees via `AbortSignal`, ce qui evite qu'un debat continue apres une demande d'arret. ## [0.6.4] - 2026-06-09 ### Fixed - Adapter CLI : les erreurs de modele non supporte sont maintenant classees `unsupported-model` meme quand la CLI termine avec une sortie vide et l'erreur uniquement sur stderr, au lieu d'apparaitre comme un `empty-output` deroutant. - Suggestions d'erreur : `unsupported-model` conseille aussi de mettre a jour la CLI de l'agent, en plus de verifier le modele, l'abonnement ou les flags `--model-*`. - Discovery : Antigravity est detecte via `agy` ou `antigravity`, afin que `doctor`, `presets --json`, la generation de config et les integrations consomment la meme source de verite CLI. ## [0.6.3] - 2026-06-09 ### Fixed - Prompts agents : `--language fr|en` ajoute maintenant une consigne explicite de langue de reponse dans le debat et la synthese, pour reduire les syntheses qui basculent ponctuellement dans l'autre langue avec de vraies CLIs IA. - Parser CLI : un flag booleen (`--plain`, `--no-summary`, `--no-early-stop`, `--json`, `--show-prompt`, `--pull-models`, ...) n'avale plus l'argument positionnel suivant. `palabre --plain codex-claude "sujet"` conserve desormais le preset au lieu de le perdre. - Arret anticipe du debat : les phrases d'accord suivent la langue d'interface. Ajout de motifs anglais cibles pour que `--language en` puisse declencher l'arret sur accord clair. - Message systeme par defaut des agents Ollama localise selon la langue d'interface au lieu d'etre fige en francais. - `palabre doctor` reconnait desormais les commandes d'agent en `.ps1` (normalisation de nom de commande alignee sur le reste du code). - Erreur actionnable si la config chargee est structurellement invalide (racine non-objet, bloc `agents` absent ou vide), au lieu d'un echec opaque pendant le debat. ### Changed - Refactor interne : extraction du parseur d'arguments dans `src/args.ts` avec une table centrale d'arite des flags (`boolean` / `single` / `multi`), couverte par des tests dedies (`tests/cli-args.test.ts`). - Refactor interne : registre d'agents centralise (`src/agentRegistry.ts`) qui unifie la normalisation de nom de commande, le mapping commande -> decouverte et la liste des agents detectes, jusqu'ici duplique dans `index.ts`, `presets.ts`, `doctor.ts`, `new.ts` et `config.ts`. Ajouter un agent CLI connu se fait desormais en un seul endroit. - Refactor interne : utilitaires d'adapter partages (`src/adapters/cli-shared.ts`, `src/exec.ts`) pour `withModelArgs`, les constantes de timeout/taille de sortie et la resolution d'extensions executables, jusqu'ici dupliques entre `cli.ts`, `cli-pty.ts` et `discovery.ts`. ## [0.6.2] - 2026-06-08 ### Fixed - Nettoyage des sorties parasites `taskkill` Windows dans l'adapter CLI, notamment le bruit localise francais/mojibake que Codex peut emettre apres l'arret de process enfants. ### Added - Ajout de `pnpm smoke:real-presets`, un smoke test de release qui lance de vrais debats sur les presets prioritaires disponibles et verifie le flux agent -> NDJSON -> export Markdown. ## [0.6.1] - 2026-05-31 ### Changed - Mise a jour de maintenance CLI et documentation associee. ## [0.6.0] - 2026-05-21 ### Added - Contrats d'integration stabilises pour l'extension VS Code : renderer NDJSON v1, `palabre presets --json`, `palabre context scan --json`, erreurs structurees et exports partiels. - Support des workflows de contexte et des presets exposes dynamiquement aux integrations. # Référence des commandes Cette page liste les commandes principales de Palabre. ## Commandes de démarrage | Commande | Description | | --------------------------------------- | ----------------------------------------------------------------------------------------------------------------- | | `palabre` | Ouvre l'accueil TUI, crée la configuration globale au premier lancement et rafraîchit les agents connus détectés. | | `palabre init` | Crée explicitement la configuration globale et détecte les agents. | | `palabre init --local` | Crée une configuration dans le dossier courant. | | `palabre doctor` | Affiche un diagnostic par sections : configuration, outils locaux, agents et points à vérifier. | | `palabre agents` | Liste les agents déclarés et leur détection locale. | | `palabre -a` | Raccourci de `palabre agents`. | | `palabre history`, `palabre historique` | Liste les derniers exports Markdown Palabre. | | `palabre sessions` | Liste les checkpoints de reprise du dossier courant. | | `palabre context scan --json` | Prévisualise le contexte projet que Palabre retiendrait. | ## Configuration L'accueil TUI applique la même synchronisation prudente des agents connus que `palabre config --sync-agents` : il ajoute les agents connus nouvellement détectés et rafraîchit leurs commandes sans toucher aux agents custom ni aux defaults utilisateur. | Commande | Description | | --------------------------------------------------- | ------------------------------------------------------------------------- | | `palabre config` | Ouvre l'assistant de configuration. | | `palabre config --set-defaults codex claude` | Définit les agents par défaut. | | `palabre agent-role claude critic` | Définit durablement le rôle d'un agent. | | `palabre config -t 4` | Définit le nombre de tours par défaut. | | `palabre config --summary-agent claude` | Définit l'agent de synthèse par défaut. | | `palabre config --summary-agent none` | Retire l'agent de synthèse par défaut. | | `palabre config --ask-summary-agent opencode` | Définit l'agent de synthèse par défaut du mode ask. | | `palabre config --mode chat` | Définit le mode par défaut (`chat`, `debate` ou `ask`). | | `palabre config --ask-agents codex claude opencode` | Définit les agents par défaut du mode ask, 4 maximum. | | `palabre config --interface tui` | Définit l'interface par défaut (`tui` ou `terminal`). | | `palabre config --language en` | Définit la langue de Palabre et des prompts agents. | | `palabre config --clear-defaults` | Supprime les paramètres par défaut. | | `palabre config --sync-agents` | Ajoute les agents détectés manquants et rafraîchit les commandes connues. | | `palabre config --ollama-models --json` | Liste les modèles Ollama installés et l'état du modèle configuré. | | `palabre config --set-ollama-model ` | Définit le modèle de l'agent `ollama-local`. | | `palabre config --sync-ollama-model` | Remplace le modèle Ollama configuré s'il n'est plus installé. | ## Débats | Commande | Description | | --------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------- | | `palabre new` | Compose une session Chat, Débat ou Ask, affiche son récapitulatif puis permet de la lancer ou de personnaliser ses options. | | `palabre -s "Sujet" -t 4` | Lance avec les agents par défaut. | | `palabre codex-claude "Sujet" -t 4` | Lance avec un preset. | | `palabre run --subject "Sujet" --agent-a codex --agent-b claude` | Lance avec des agents explicites. | | `palabre run --subject "Sujet" --agent-a codex --agent-b claude --role-a architect --role-b critic` | Lance avec des rôles temporaires. | | `palabre ask "Sujet" --agents codex claude` | Lance une demande avec des réponses indépendantes. | | `palabre chat --agent-a codex` | Ouvre une conversation suivie avec un seul agent. | ## Reprendre une session Ajoutez `--checkpoint` à un Débat ou à une demande Ask pour enregistrer son état atomique sous `.palabre/sessions/`. Palabre affiche alors l'identifiant et la commande de reprise correspondante. ```bash palabre codex-claude "Comparer deux options" --checkpoint palabre sessions palabre resume palabre sessions delete ``` La reprise conserve les réponses complètes et relance uniquement le prochain tour, les agents Ask restants ou la synthèse. Avant tout appel, Palabre vérifie que la configuration est toujours approuvée et inchangée, puis compare les empreintes des fichiers de contexte. Une différence bloque la reprise afin de ne pas modifier silencieusement la décision. Le terminal demande confirmation ; utilisez `--yes` pour un lancement non interactif. Une session déjà terminée ne peut pas être reprise. `palabre sessions` affiche les 20 checkpoints les plus récents par défaut, avec leur état, mode, nombre de réponses et prochaine phase. `--limit <1-100>` borne la liste. Un JSON corrompu est signalé comme invalide sans empêcher l'affichage des autres. La suppression montre le fichier exact et demande confirmation ; en mode non interactif, `--yes` est obligatoire. Elle ne supprime jamais les exports Markdown ni les autres checkpoints. ## Conversation avec un agent `palabre chat --agent-a ` ouvre une conversation dans le terminal. Le premier message devient son contexte initial ; `"Sujet"` reste accepté en option pour préremplir ce contexte. À chaque message, Palabre lance un nouvel appel à la CLI sélectionnée et lui réinjecte l'historique déjà accumulé. Le résultat reste donc cohérent dans la session courante, sans dépendre d'une session interactive persistante chez Codex, Claude ou un autre outil. Contrairement à Ask, qui recueille une ou plusieurs réponses indépendantes à une question unique avant une éventuelle synthèse, Chat entretient une conversation multi-tours avec un agent actif. Utilisez `/agents` pour afficher les agents disponibles. `/end` enregistre la conversation dans `.palabre/`, affiche le fichier et le dossier puis revient à l'accueil ; `/home` revient sans enregistrer. `/consult ` demande explicitement un second avis sur les six derniers messages retenus ; cet avis est ajouté à la conversation. `/use ` bascule ensuite l'agent actif, ou vous pouvez continuer avec l'agent initial. `--role-a`, `--model-a`, `--language`, `--files` et `--context` restent disponibles. Si aucun `--agent-a` n'est donné, Palabre utilise l'agent A configuré par défaut. Cette première version reste stateless et n'exécute aucune action. Le contexte envoyé à chaque appel est borné aux six messages les plus récents ; Palabre signale lorsque des messages plus anciens ne sont plus transmis. La consultation reste explicite : l'agent peut la proposer, mais l'utilisateur garde l'initiative. Après un débat ou un Ask terminé dans la TUI, `/chat` ouvre directement une conversation dont le contexte indique sa provenance et reprend le sujet avec la synthèse finale, ou les six échanges récents si aucune synthèse n'est disponible. ## Commandes TUI Ces commandes sont disponibles dans l'accueil TUI ou dans `/config` selon le contexte. | Commande | Description | | --------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `/` | Affiche la liste contextuelle des commandes canoniques ; les flèches, `Tab` ou `→` complètent la sélection. | | `/new` | Ouvre le parcours guidé de composition d'une session Chat, Débat ou Ask. | | `/chat` | Ouvre une conversation avec l'agent A par défaut. `/home` ou `/exit` revient à l'accueil. | | `/ask` | Passe l'accueil TUI en mode Ask. | | `/debat` | Passe l'accueil TUI en mode débat. | | `/agents` | Affiche les agents disponibles ou modifie les agents actifs si des noms sont fournis. | | `/roles` | Affiche les rôles disponibles ou modifie les rôles actifs si des rôles sont fournis. En mode Ask, un seul rôle comme `/roles critic` s'applique à tous les agents Ask. | | `/config` | Ouvre les réglages TUI. | | `/history` | Affiche les derniers exports Markdown. Alias : `/historique`. | | `/update` | Ouvre l'écran de mise à jour adapté au canal d'installation détecté. | | `/ollama` | Affiche le modèle Ollama configuré et les modèles installés depuis `/config`. | | \`/ollama-url \\` | | `/ollama-model ` | Change le modèle configuré de `ollama-local` depuis `/config`. | | `/ollama-sync` | Remplace le modèle Ollama configuré par un modèle installé quand le modèle courant est absent. | | `/language fr`, `/language en` | Change la langue depuis `/config`. Alias : `/lang`, `/langue`. | | `/interface tui`, `/interface terminal` | Change l'interface par défaut depuis `/config`. | | `/home` | Revient à l'accueil TUI. Alias : `/back`. | | `/quit` | Quitte la TUI. | ## Intégrations Une intégration qui lance Palabre peut déclarer son identité dans l'environnement du processus enfant : ```text PALABRE_CLIENT=palabre-vscode PALABRE_CLIENT_VERSION=1.7.1 ``` Palabre inscrit ces informations, ainsi que sa propre version, dans les exports `.debate.md`, `.chat.md` et `.ask.md`. Le nom du client est libre afin de supporter de futures intégrations. Sans déclaration, la source indiquée est `direct-cli`. | Commande | Description | | --------------------------------------------------- | ------------------------------------------------------------------------------------------ | | `palabre agents --json` | Liste les agents configurés, leur rôle, leur type et leur disponibilité au format JSON v1. | | `palabre presets --json` | Liste les presets et leur disponibilité locale. | | `palabre history --json` | Liste les 10 derniers exports Markdown au format JSON v1. | | `palabre history --json --limit 30` | Liste jusqu'à 30 exports (maximum : 100). | | `palabre sessions --json` | Liste jusqu'à 20 checkpoints au format JSON v1, valides ou invalides. | | `palabre sessions --json --limit 30` | Liste jusqu'à 30 checkpoints (maximum : 100). | | `palabre sessions delete --yes --json` | Supprime exactement un checkpoint et confirme son identifiant au format JSON v1. | | `palabre config --ollama-models --json` | Renvoie l'état Ollama local au format JSON v1 pour les intégrations. | | `palabre context scan [paths...] --json` | Renvoie les dossiers, fichiers et avertissements du scan `--context` au format JSON v1. | ## Options générales | Option | Description | | ------------------------------------------- | ------------------------------------------------------------------------------------------- | | `-h`, `--help` | Affiche l'aide. | | `-v`, `--version` | Affiche la version. | | `--config ` | Utilise un fichier de configuration explicite. | | `--trust-config` | Approuve l'empreinte de la configuration locale après vérification de son contenu. | | `--language `, `--lang ` | Force la langue de Palabre et des prompts agents pour la commande. | | `--tui` | Force l'interface TUI, même si la configuration demande le rendu terminal. | | `--terminal`, `--no-tui` | Utilise un rendu terminal brut. Aussi utile avec `palabre doctor` pour les logs. | | `--plain` | Alias historique de `--terminal`. | | `--json` | Demande la sortie JSON des commandes qui la proposent, ou l'objet résolu de `dry-run`. | | `--renderer ` | Choisit le renderer terminal ou intégration. `tui` active l'interface terminal plein écran. | ## Options de débat | Option | Description | | ------------------------- | ------------------------------------------------------------------------------------------------ | | `-s`, `--subject ` | Sujet de la session. | | `--topic ` | Alias compatible de `--subject`. | | `--preset ` | Choisit une paire d'agents. | | `--agent-a ` | Premier agent. | | `--agent-b ` | Second agent. | | `--role-a ` | Rôle temporaire du premier agent, sans modifier la config. | | `--role-b ` | Rôle temporaire du second agent, sans modifier la config. | | `--ask-role ` | Rôle commun temporaire appliqué à tous les agents Ask. | | `--mode ` | Choisit le mode d'orchestration. | | `--agents ` | Agents du mode ask, 4 maximum. | | `-t`, `--turns ` | Nombre total de réponses, entre 1 et 20. | | `--no-early-stop` | Désactive l'arrêt anticipé. | | `--model-a ` | Modèle transmis à l'agent A. | | `--model-b ` | Modèle transmis à l'agent B. | | `--ollama-url ` | Surcharge l'adresse de tous les agents Ollama pour cette session. | | `--pull-models` | Autorise Ollama à télécharger un modèle manquant. | | `--checkpoint` | Conserve un état machine versionné sous `.palabre/sessions/` pour une future reprise. | | `--yes` | Confirme explicitement `palabre resume` ou une suppression de checkpoint en mode non interactif. | | `--summary-agent ` | Agent de synthèse. | | `--summary-model ` | Modèle de synthèse. | | `--no-summary` | Désactive la synthèse finale. | | `--files ` | Injecte des fichiers précis. | | `--context ` | Scanne fichiers ou dossiers texte. | | `--show-prompt` | Affiche le prompt du premier tour sans appeler d'agent. | | `--dry-run` | Prévisualise la session résolue sans appeler d'agent ni écrire d'export. | ## Mise à jour | Commande | Description | | -------------------------- | ----------------------------------------------------------------------------- | | `palabre update` | Affiche le plan puis demande une confirmation TTY avant une mise à jour sûre. | | `palabre update --check` | Vérifie la version et le canal sans modifier la machine. | | `palabre update --dry-run` | Affiche les étapes exactes sans les lancer. | | `palabre update --yes` | Applique un plan sûr sans confirmation interactive. | | `palabre update --apply` | Alias compatible de `--yes`. | # Référence du fichier de configuration Cette page sert de référence rapide pour `palabre.config.json`. Pour une explication progressive, commencez par [Configuration](https://palab.re/fr/configuration/overview). ## Exemple complet ```json { "language": "fr", "outputDir": ".palabre", "defaults": { "mode": "debate", "agentA": "codex", "agentB": "claude", "askAgents": ["codex", "claude"], "summaryAgent": "claude", "askSummaryAgent": "claude", "turns": 4, "interface": "tui" }, "agents": { "codex": { "type": "cli", "command": "codex", "args": ["exec", "--skip-git-repo-check", "--color", "never", "--sandbox", "read-only"], "promptMode": "stdin", "role": "implementer" }, "claude": { "type": "cli", "command": "claude.exe", "args": ["--print", "--output-format", "text", "--no-session-persistence", "--tools", "Read,Glob,Grep"], "promptMode": "stdin", "shell": false, "role": "reviewer" } } } ``` ## Racine | Champ | Type | Description | | ----------- | ------------ | ----------------------------------------------------------------------------------------------------------------------------- | | `language` | `fr` ou `en` | Langue de Palabre et des prompts envoyés aux agents. Peut être forcée ponctuellement avec `--language` ou `PALABRE_LANGUAGE`. | | `outputDir` | string | Dossier d'export des fichiers `.debate.md`, `.chat.md` et `.ask.md`. | ## `defaults` | Champ | Type | Description | | ----------------- | ------------------------- | -------------------------------------------------------------------- | | `mode` | `debate`, `chat` ou `ask` | Mode lancé par défaut quand aucun mode n'est fourni. | | `agentA` | string | Agent qui répond en premier en Débat et agent actif initial en Chat. | | `agentB` | string | Agent qui répond en second. | | `askAgents` | string [] | Agents par défaut du mode ask, 4 maximum. | | `summaryAgent` | string | Agent de synthèse finale du mode débat, et fallback du mode ask. | | `askSummaryAgent` | string | Agent de synthèse finale spécifique au mode ask. | | `turns` | number | Nombre total de réponses, entre 1 et 20. | | `interface` | `tui` ou `terminal` | Interface par défaut pour les sessions interactives. | ## Agent CLI | Champ | Type | Description | | ------------------ | --------------------- | ------------------------------------------------------------------------------------------------------- | | `type` | `cli` ou `cli-pty` | Type de l'agent. | | `command` | string | Commande à lancer. | | `args` | string [] | Arguments transmis. | | `promptMode` | `stdin` ou `argument` | Manière de transmettre le prompt. | | `shell` | boolean | Lance via le shell système. La configuration générée l'active seulement pour certains wrappers Windows. | | `role` | string | Rôle de l'agent. | | `model` | string | Modèle par défaut optionnel. | | `modelArg` | string | Flag modèle optionnel. | | `timeoutMs` | number | Timeout global. | | `idleTimeoutMs` | number | Timeout d'inactivité. | | `maxOutputBytes` | number | Taille maximale cumulée de stdout et stderr, 50 Mio par défaut. | | `allowEmptyOutput` | boolean | Autorise exceptionnellement une réponse CLI vide. | | `cols` / `rows` | number | Dimensions du pseudo-terminal pour `cli-pty`. | ## Agent Ollama | Champ | Type | Description | | ------------------- | -------- | --------------------------------------------------------------------- | | `type` | `ollama` | Type de l'agent. | | `baseUrl` | string | URL de l'API Ollama. | | `model` | string | Modèle local. | | `role` | string | Rôle de l'agent. | | `validateModel` | boolean | Vérifie que le modèle existe. | | `autoPullModel` | boolean | Télécharge le modèle si absent. | | `pullTimeoutMs` | number | Timeout de téléchargement. | | `unloadOtherModels` | boolean | Décharge les autres modèles. | | `keepAlive` | string | Maintien du modèle chargé. | | `temperature` | number | Variation des réponses. | | `maxOutputBytes` | number | Taille maximale de chaque réponse HTTP bufferisée, 50 Mio par défaut. | # Presets Les presets permettent de choisir rapidement une paire d'agents. ## Syntaxe courte ```bash palabre codex-claude "Sujet" -t 4 ``` Cette commande équivaut à choisir `codex` en agent A et `claude` en agent B. ## Presets courants | Preset | Usage typique | | -------------------- | --------------------------------------------- | | `codex-claude` | Codex propose, Claude relit. | | `claude-codex` | Claude propose, Codex relit. | | `codex-antigravity` | Comparaison Codex / Antigravity. | | `claude-antigravity` | Comparaison Claude / Antigravity. | | `codex-opencode` | Codex face à OpenCode. | | `opencode-claude` | OpenCode face à Claude. | | `codex-vibe` | Codex face à Mistral Vibe. | | `vibe-claude` | Mistral Vibe en premier, Claude en relecture. | | `codex-ollama` | Agent CLI puissant face à modèle local. | | `ollama-claude` | Modèle local en premier, Claude en relecture. | `palabre presets --json` inclut maintenant des métadonnées de disponibilité locale pour les intégrations. Un preset est marqué indisponible si un agent manque dans la config, si une CLI connue n'est pas détectée, ou si le modèle Ollama configuré n'est pas installé. ## Choisir les modèles Les modèles peuvent être transmis sans que Palabre les liste : ```bash palabre codex-claude "Sujet" --model-a --model-b ``` Pour Ollama : ```bash palabre codex-ollama "Sujet" --model-b ``` ## Quand utiliser un preset ? Utilisez un preset quand vous voulez une commande courte et explicite. Utilisez les agents par défaut quand vous lancez souvent la même paire. Utilisez `--agent-a` et `--agent-b` quand vous écrivez un script ou une documentation très précise.