harness-multitool

Constraints

Rules, limits and constants. Unlike a principle, a constraint is not weighed against anything; unlike an invariant, it is a choice that could have been different and is recorded as one.

Technology

IdConstraint
CON-1The harness is written in Rust, stable toolchain.
CON-2A plugin is a crate that implements an interface trait. It is compiled into the binary of a local build and selected by name in the configuration.
CON-3No dynamically loaded Rust libraries as plugins (Rust has no stable ABI).
CON-4Out-of-process plugins (any language, over stdio) are not part of v1. They may be added later as another way to implement the same interfaces.
CON-5Build targets: Linux x86_64 and arm64, macOS arm64, Windows x86_64, and wasm32-unknown-unknown for the browser demo.
CON-6The terminal interface is built on ratatui.

Providers and authentication

IdConstraint
CON-10v1 providers: the Anthropic API, OpenAI-compatible APIs (OpenAI, OpenRouter and the like), and local models served over an OpenAI-compatible endpoint.
CON-11Shipped Auth implementations: API keys (from the environment, the config, or the OS keychain on native targets) and gpt-subscription (CON-55). See INV-9 for what is not shipped.

Memory and sessions

IdConstraint
CON-20The default Memory implementation is a local daemon that owns a project journal (entries with categories, tags, flags and links, lexical search, CON-119), mind maps and flowcharts. The same daemon is the single entry point of callbacks to agents, with a callback URL for every open agent window (IF-13). In the browser, the same interface is implemented over browser storage.
CON-21Journal flags include work items (todo, question, wait-for-decision (CON-178), problem, bugreport, reminder, unverified, disputed) and marks (research (CON-179), specification, constraint, important, idea, concept, comment, verified, deprecated); an entry carries any number of them.
CON-22One journal per project; a project is identified by its repository remote, or its directory when it has none.
CON-23Callback triggers (IF-13) are configuration of the project, versioned with it; every callback names its type (IF-13), and the harness types are notification (a callback delivered into the agent's input, its stdin — the inbound CALLBACK card the TUI shows; /callback publishes one), journal (only writes a journal entry from the event; no agent turn), flowstate_update (changes the state of one instance of a flowchart — a pass keyed by the client's pipeline id, never the reference chart; no agent turn) and skill (starts a run of a named skill with the event as input; kept as a concept, may be dropped); product types are any string, with custom handlers (IF-16); a flowchart's binding to a process and to its watching sessions is configuration too. A callback whose type has no handler reaches no agent: it is logged and the caller gets 400 (ADR 0015). Neither a journal nor a flowstate_update callback starts a model turn.
CON-24Step-debug runs are stored in the target project, in an SQLite database under .harness/debug/: one run per cycle, saved when the run reaches a terminal block of its flowchart.
CON-25Step-debug code in a target project (debug router, step waits, the mode's callbacks) is active strictly behind the environment gate MULTITOOL_DEBUG_MODE=1 and only with authorization — checked by the app itself or by a token issued by the harness daemon; without the gate the code is inert and the pipeline runs as uninstrumented (ADR 0013).
CON-26A project's response policies (reliability monitoring) are Markdown files under .harness/policies/ in the project; conditions link their paths (ADR 0014).
CON-27The step-debug router of a target app is always built by one contract, an OpenAPI-style specification the harness ships: an approve route that lets the app go to its next step; a step back route only where stepping back is really possible — otherwise not implemented at all, no stubs; the app's other product routes as the product needs (ADR 0013).
CON-28A debug-router route for debugging product behaviour or invariants imports and calls the functions the real code calls; it implements no business logic of its own. A route that reimplements logic instead of calling the code it debugs breaks the contract (ADR 0013).
CON-29A step-debug pipeline waiting after a callback advances only on the agent's approve: no timeout, no default action, nothing on its own if the agent or its session is gone (ADR 0013).

Browser build

IdConstraint
CON-30The browser build has no shell, no processes and no daemon: files live in an in-memory or origin-private file system, network goes through fetch, storage through IndexedDB.
CON-31The user's key in the browser build is entered by the user and stored only in that browser.

Project

IdConstraint
CON-40The repository is self-contained: it does not refer to, depend on or name the project it grew out of.
CON-41Every spec item, invariant and constraint has a stable id; ids are never reused.
CON-42A change to a principle, invariant, constraint or interface contract goes through a decision record in docs/decisions/.
CON-43Once a project has its docs tree (created by the project-init skill), its journal, mind maps and flowcharts are mirrored into Markdown files in its repository — README, architecture, spec (principles, interfaces, invariants, constraints, open questions, roadmap), decisions, flowchart pages — and kept consistent with them in the same change; the agent writes the files, prompted by a PostToolUse hook on every memory write; a disagreement is a finding settled before work goes on (ADR 0017).
CON-44Project initialization (project-init) creates the docs tree and the .harness/ folder; it never overwrites an existing file. Everything in .harness/ is committed with the project, for now. The harness asks about it once, at the first start in a project without docs/ and .harness/ (ADR 0017).
CON-45The docs-mirror check is advisory and structural: a built-in hook plugin on typed memory-write events, linked by doc id (the file named by the category contains the id; settled and deprecated items are marked); a Stop hook adds one reminder per turn and never vetoes, forces continuation or loops; the same checker runs as multitool docs check and in CI. It does not judge whether the prose agrees (ADR 0017).
CON-46The documentation files are a storefront: only the current, settled state, written to be read. No drafts, work notes, scratch text, TODO placeholders, half-written sections, superseded variants kept for history, or assumptions written as facts; work in progress lives in the journal, maps and charts, history in git. What is not settled appears only in its declared form: an open question, an ADR with status proposed or concept, a labelled proposal (ADR 0017).

Plugins and callbacks

IdConstraint
CON-50A hot reload swaps the binary only at a safe point — no model turn streaming, no tool call in flight — and never loses the view: everything held only in memory goes to a hand-off file the new process restores; a failed build swaps nothing (ADR 0015).
CON-51A project's .harness/acceptance.toml runs only in the exact text the user approved; any change, by anyone, asks again. Commands the user gives for a task need no approval. Commands in journal entries never run.
CON-52The Telegram channel delivers only messages from allowed_users, as the user's own words (CON-158) under a label a callback cannot claim. Its token is the harness's own, and appears in no log, status or error. No token means nothing polls. A reply goes to the chat of the last allowed message and asks permission first. An empty list delivers nothing; anyone else is dropped and counted, their text never logged or stored; the list changes only in the configuration file, never through the channel. telegram_send asks permission like any outward action, sends only to the chat of the last allowed message or the configured chat, splits text over 4096 characters, and answers an error when neither chat is known.
CON-53In plan mode the engine refuses writes and every command but a single known read-only one, before hooks and policy, so no answer can approve them (ADR 0016). The exception is writing under docs/ (CON-65). Only the user ends the mode. The read-only commands are: one command, no shell operators, redirection or substitution; ls, cat, head, tail, wc, grep, rg, pwd, stat, du, df, git status/log/diff/show/blame. Options that write or run something (--output, --pre, --ext-diff) are refused, and anything unknown is, so the list fails closed. These still ask permission under the policy.
CON-54A permission prompt takes only Deny for its first 800 ms on screen: it can open at any moment, started by a callback or a channel, and keys meant for the composer must not approve it.
CON-55A ChatGPT plan is reached only by OpenAI's documented flow for open-source apps: the harness registers a client of its own, the user signs in on OpenAI's page, the ID token and the plan scope are validated before anything is saved, tokens are owner-only and in no log, and requests go to POST /v1/responses with store false and stream true.
CON-56Claude subscription credentials are not supported: Anthropic does not permit third-party apps to offer Claude.ai login or to collect, store or route its tokens (its terms). The claude-subscription adapter exists only to refuse: it holds no token logic, the settings list it and answer with a toast. Anthropic models take a Console API key or a cloud provider.
CON-57The Claude Code delegate runs the unmodified claude binary, signed in by the user through Anthropic's own flow, and says so on screen. The harness never reads, stores or passes its credentials, and neither replaces its system prompt nor its tools. It is in the default build, behind the cargo feature claude-code that --no-default-features (and --no-claude-code in the installers) leaves out; Q-33 was settled by the owner on 2026-11-19, against Anthropic's published terms (journal#1437, ADR 0020).
CON-58Delegate mode oneshot: claude -p with stream-json per message, the prompt on stdin, --resume with the stored session id. Nothing runs between messages.
CON-59Delegate mode session: one process per tab with stream-json on stdin. It ends after 10 idle minutes and at a hot reload, and comes back with --resume. A process that dies mid-run is an error card; the session stays.
CON-60A delegate's tool that would prompt goes to the harness's own prompt; no answer is a denial. A task's Verifier still decides done. Its limits reach the user and are not retried in a loop. On a subscription its cost shows as included and charges no budget.
CON-61By default the nested claude runs only the harness's MCP configuration and no user hooks, if the flags keep the login; otherwise the delegate says on screen what it inherits. CON-69 is the opt-in exception.
CON-62Building an app, a prototype or a project, a feature, a fix or any change that is not trivial starts in plan mode, even if nobody said plan; nothing is built before the plan is approved (ADR 0021). Answers, reading, diagnosis and work in an approved plan are exempt.
CON-63A planned fix goes on in debug mode, reproduced before it is changed and verified after; a planned feature is built and run, then debugged in debug mode the same way; only a pipeline gets a router and instrumentation. Work ends with evidence in the journal.
CON-64The behaviour rules are in every session's system prompt. The hook mode-guide acts on the first write in a message with no plan made in the session: plan_first is remind, enforce or off. It never touches reads or memory and cannot loop.
CON-65While planning, a path under the project's docs/ may be written; a path that climbs out of it may not. Every other write stays refused (ADR 0021).
CON-66mode-guide says the step of the cycle that is due, for one turn: at each user message and at each change of mode. A plan_exit with no journal entry, map or flowchart goes back once, or under enforce until they exist. Stopping after an approved plan or in debug mode continues the run once per message.
CON-67ask_user shows a question with up to 9 options and ends the run; the answer is the user's next message: a chosen label or their own words. A message queued meanwhile is that answer. Each option is a label with an optional description; the panel above the composer takes Up/Down and Enter or a digit, and typed text answers instead.
CON-68The same call failing the same way within one user message gets a reminder the third time and ends the run with a visible error the fifth. A new message starts the count over.
CON-69A delegate row with environment = "user" runs claude with the user's own settings, hooks, servers and environment; only the markers of a running session are removed. Opt-in (ADR 0022).
CON-70A delegate row with permissions = "skip" runs with no permission prompts. It is only ever the user's own setting: the harness never turns it on, and no answer or message can.
CON-71What the harness adds to a provider's form is only ever appended, on the form's own chain: every byte already there stays as it was. A conversation goes on under its own id, with no fork (ADR 0025).
CON-72An import keeps each tool result to 4 KiB and no images: the whole stays in the source's own record. Lines it cannot read are counted and passed over; a rewound branch or a subagent's lines are not part of the conversation.
CON-73The harness's event log is the conversation. Any provider can go on with any session: what it is sent is valid for it whatever made the log, with roles alternating and every call answered, and what a provider signs for itself goes to no other (ADR 0023).
CON-74A session that goes on through a provider keeping its own conversations and has no form there is written in that provider's form first, as a new one, and is linked to it. A linked form stays current through any other provider's turns.
CON-75A conversation runs in the daemon, which alone writes its log. A frontend is a client. Only a scripted run, multitool run, and a window with no daemon to be had run a session themselves (ADR 0024).
CON-76A window that goes away leaves its runs to finish in the daemon (as CON-181 now says how; its prompt is no longer a denial). A window that has not polled for 30 seconds is gone.
CON-77One writer to a log: a session open in a window still there does not open in another, and the window says so. From a window that went away (silent for 5 seconds) the session comes to the one opening it, with its run if one is on.
CON-78One writer to a form: while the provider's own program has a conversation open, the harness reads it but refuses to send, naming the program. Which program holds what is read from the provider's own record of its running sessions. The harness cannot stop that program from opening a conversation in the middle of a harness run: not doing so is the user's part.
CON-79Changing the adapter or model is done in the harness's settings and saved by the harness; no file needs editing. It reconnects the active tab's conversation at once (CON-94), and the daemon brings its form for that adapter in line, creating it if there is none. While any of them has a run on or a prompt waiting, the controls are disabled and say why, and the daemon refuses such a change.
CON-80The context window is chosen from a dropdown in the settings, per provider, and saved by the harness. Auto takes what the server or the model reports; a chosen value wins over a report, and compaction goes by it.
CON-81While the daemon brings a form in line or reads one (on a change of adapter, or on opening a conversation), the window shows the moon-phase spinner and takes no input, until the daemon signals success or failure. The daemon's work does not hold up its other windows. Replaced in part by CON-136: only the conversation being brought in line is held, never the whole window.
CON-82With no session to deliver to, a Telegram message goes to the window that most recently polled the daemon within the last 60 s, which starts one. With none, the update stays unconfirmed so it is not lost. After delivery the offset advances and is stored, so a restart does not repeat it. Flood control's retry_after is respected.
CON-83A message sent during a run is shown above the composer and reaches the model at the next boundary, after the tool results before it, in order and once; its card appears then. If the run ends first it starts the next one. Up on an empty composer takes the last back, and it is never delivered. Esc stops, and the queue then runs at once. A rebind keeps the queue, tabs keep theirs apart, and a task's message waits its turn.
CON-84What an agent backend runs in the background shows above the composer while it runs: a moon, what it is, for how long, at most three and the rest counted, and a card with its summary when it ends. Between runs the backend's stream is still read: a turn it begins by itself is a run like any other, shown at once, taking messages, and a reload waits for it. A result that came before a run's own prompt came back does not end that run. A log read back shows no task on, since the process that held them is gone.
CON-85multitool debug screenshot draws the open window as it is now, overlays included, into a PNG the caller names, with the renderer of multitool screen, and waits up to 10 s for it. It shows the harness's own state only, never the desktop.
CON-86In a session, Ctrl+C stops the run in the active tab, as Esc does, and what is queued goes to the agent at once; a second press cancels that answer too, and what was queued reaches the agent with the next message. With no run on, the first press says Ctrl+C again to quit and a second within 2 s quits. On the splash and start pages it quits at once. /exit always quits.
CON-87One bot token serves any number of sessions. A chat, or a forum topic, is bound to one session, in a file of the daemon's that survives a restart; one session holds one binding, and a new bind moves it. /agents and /start list the open sessions with buttons, /switch with a number or words of a title binds, /whoami says what is bound; these reach no session, and unknown commands do. A message goes straight to the bound session. Unbound with one session open, it binds to that and says so. Unbound with several, or bound to one not open, it is held, the sender is told and offered the buttons, and it goes on when one is chosen; never dropped in silence, at most 20 per chat. telegram_send from a session goes to its binding. /id answers anyone with their own user id and nothing else, keeps nothing and reaches no session, so one can learn it before being allowed. Another poller on the token is named as the error. The token and the allowed users are set on the settings page, which never shows a saved token, and saving restarts the channel at once.
CON-88A session registers with the daemon by being open, and goes by a nick set with /nick in its window, by the agent itself, or with /nick in its bound chat. The daemon keeps the nicks across restarts. /switch finds a session by number, by exact nick, or by words of its title. A binding follows the session, not the nick.
CON-89Speech to text is chosen and installed in the settings, section Speech to text: an engine (whisper or parakeet), a model of it, a download fetching a runtime and the model on the user's word, and a test from the microphone that shows the level and the words. Nothing else fetches them, and nothing is built in. An allowed Telegram user's voice note is transcribed on this machine and reaches its bound session as a voice message. With no engine set up, the user is told, in the window and in the chat, and the agent is not: it is the user's to set up. A stranger's note is never fetched. Any other failure, or a message neither text nor voice, is told to the sender. Transcribing holds up no other chat.
CON-90install.sh and install.ps1 build from source, from a checkout with --local or a temporary clone, and put the binary on the PATH. They install no speech engine, which is the settings' (CON-89). Build dependencies are named with the exact command and installed only on the user's word. They touch no shell profile. --uninstall removes the binary and keeps the user's data.
CON-91A journal entry can be blocked by another: while that one is not closed, the blocked one cannot be closed, nor a todo whose branch holds it. An agent that meets a problem which cannot be solved until another in the journal is solved sets this, and works on the blocker first; it says so in the tool's own description. Abandoning is not refused, since dropped work waits for nothing. What could never close is refused when set: a cycle at any depth, itself, a blocker with nothing open, an entry with nothing to close.
CON-92The Speech to text page chooses the input device from what the system lists when the dropdown opens, monitors left out, with Default chosen until the user says otherwise. It governs that page's test: voice notes arrive as files.
CON-93The journal's agenda lists what waits for an open blocker apart from what can be taken now. Closing an entry answers with what that set free. A blocker abandoned instead of solved does release, and the entry that waited is listed for re-reading until the link is lifted or it closes, since what it needed is still not there.
CON-94A conversation has its own adapter and model, kept by the daemon through reloads and restarts. The settings choose for the active tab's conversation and for conversations not started yet; other tabs and windows do not move. A change is refused only while that conversation runs or waits on a prompt.
CON-95What a conversation does on an agent backend it does on the native loop too. A stop ends the running command and cuts the model's stream at once, with the history left valid. The shell tool can run in the background, shown above the composer, its end told to the agent.
CON-96Harness modes are not utilities. They live under the namespace mode__ (mcp__mode__ on an agent backend), the system prompt says what a mode is, and every tool and mode has a description an agent can act on, all documented in docs/tools.md, held by a test.
CON-97An agent's behaviour is deterministic: a situation brings the same action every time, on every adapter, proven by a checker over the session's log. Journaling, spec-first through the journal, maps and flowcharts are mandatory.
CON-98The agent workflow specification is part of the harness, not of a project. A hook gives the agent the path to its file at session start, after a compaction and on a resume, and it can be read with no prompt.
CON-99Agents talk through the daemon with agent_list and agent_send, by nick or id. A message reaches the other as data from outside, with the sender's own name, which it cannot claim falsely. An agent does not message itself, and a conversation sends at most 60 in 10 minutes.
CON-100Orchestration mode adds to the agent's prompt the tools it now has, and they exist only in the mode. The master starts agents as tabs of its group, on authorized adapters and models it chooses, in the same project and git, with the journal and all tools. A hook tells each it is a slave working for the master, explains those are only technical terms, and asks it to report ready. A slave messages only its master; the master, any of its slaves, as the user's message. A slave's ask_user goes to its master, not the user. In the window the group is set off together, with (M) and (S) on the titles. A slave's questions, plan and permission requests go to its master, by the user's own decision. A slave cannot spawn; at most 8.
CON-101A journal is evidence-first unless a project turns it off: a verification must point at a proof, a kept file, log, screenshot or URL, and a todo closes only on one. A claim that something works is checked as the user will meet it.
CON-102/version in the TUI displays the harness package version in a VERSION card in the current transcript, not a toast. It uses the workspace package version, is listed in /help, and sends no model request.
CON-103A slave reads and writes files inside the folder it works in, runs reading commands, and builds and tests with cargo, with no one asked, also in chains joined by ;, &&, `
CON-104A new tab takes no adapter and no model from the tab it is opened from. Its ADAPTER and MODEL are its own conversation's: until its first turn it shows the default it will run on, and from then what it runs on. Opening or changing a tab never changes another tab's adapter or model.
CON-105Isolation between tabs: opening a tab (open_tab) never copies or changes another tab's ADAPTER or MODEL, and the other status fields carry over unchanged, except TOKENS, COST and MODE, which a new tab resets.
CON-106On an agent backend the plan and debug modes come over the mode MCP server. Leaving plan mode there takes the user's words, quoted and checked, and refuses a plan with no journal entry, mind map or flowchart. The harness cannot refuse that program's own writes: plan mode holds from its next message.
CON-107/tabs in the TUI publishes a TABS card in the current transcript: one row per open tab, in order, with its number, title, and its own ADAPTER and MODEL (a dash when none is set), the active tab marked. It is local and read-only: no tab changes, no daemon call, no model request.
CON-108A slave on an agent backend always runs isolated (CON-61), whatever its adapter's row says: none of the user's settings, hooks, rules or servers, and never with permissions = "skip". It never runs under the program's own plan mode: the harness holds the mode, and decides what the program asks by CON-103's basics and its own plan rules, at once on entering and leaving. Every request beyond them goes to its master with the tool and its arguments, and the program waits: mode__agent_answer, which exists only in orchestration mode, answers once, always or deny. No answer in 30 minutes, or no master, is a deny. CON-69 and CON-70 hold for the user's own conversations.
CON-109An agent of an orchestra is bound to a journal entry. mode__agent_spawn takes task, an open entry, and refuses without one. The agent's system prompt names it and it starts at once. When done, with evidence, it asks its master to close the entry; only the master closes an agent's task. On approval it asks to close its session, and the master calls mode__agent_close, which stays the master's at any time.
CON-110While an agent of an orchestra lives, the harness reminds its master every 10 minutes to check on it, naming the agent, its task and whether it is running. It starts with the spawn and ends with the agent's session by itself.
CON-111An agent of an orchestra's plan holds, before it is approved, a mind map of its strategy (decisions, work, the proofs it will produce) pointing at its task, and a flowchart of the logic of what it builds. mode__plan_exit refuses a slave's plan until both exist; whether they are true is its master's to read.
CON-112Guaranteeing that its agents' work matches the specs is the orchestrator's duty. Before approving an agent's work it checks the change against the specifications and constraints that bear on it, not only against the agent's report. If the agent broke a spec, it does not close the entry and sends it back with agent_send, naming the rule and what breaks it. A spec that has to change goes by the user's word.
CON-113Drawing never takes a session down. A card that cannot be drawn shows a line saying so, its error goes to a log file, and the window goes on; a whole frame's panic is caught the same way. An item may be 4000 rows tall; what is past that is said on screen, with how much.
CON-114mindmap_add and flowchart_add refuse a node past the map's limit, naming it. The limit is the map_max_nodes setting, on the settings page, 200 by default and 0 for none.
CON-115invariant and principle are journal flags like specification and constraint: marks, binding, checked against docs/spec/invariants.md and docs/spec/principles.md and in the prompt's binding entries. A category of those names sets the flag.
CON-116A message from Telegram, a callback or another agent during a run goes into the queue of CON-83: shown above the composer with its source, reaching the model at the next boundary in order of arrival, once, or starting the next run. It stays data from outside, never the user's message, and Up does not take it back.
CON-117Every agent's plan holds, besides the journal, a mind map of its strategy (decisions, work, the proofs it will produce) and a flowchart of the logic branches of the planned behaviour. mode__plan_exit refuses a plan with an empty map or chart, on the native loop and over MCP. A slave's map also points at its task (CON-111).
CON-118journal_search and journal_get answer each entry with its graph: the entries linked to it, each only as its id, a title of at most 80 characters taken from the start of its text, and the link that reaches it, out to depth hops, 2 by default, nearest first, each entry once in an answer. An answer holds a page of at most search_max_linked linked entries, a setting on the settings page, 100 by default and 0 for no paging. When more remain it says how many and gives next_offset, and the same call with offset answers the next page, so the whole graph can be read. It only reads.
CON-119Journal search is lexical. There is no encoder and no model to download, and search by meaning is not offered. If it comes later it is an option the user turns on, never the default, and only after benchmarks with it on and off.
CON-120Every setting lives in a profile (ADR 0026), except the cross-profile ones of CON-124. A profile is a named, whole configuration in its own folder, ~/.harness/profiles/<name>/, global to the user's machine and independent of any project folder: its settings in profile.toml, in today's config format, beside its sign-in (CON-122). It holds provider, adapter and its settings, model, memory, router, callbacks, frontend, and its sign-in (CON-122). No profile is layered over another: a window runs on exactly what one file says. Names are lowercase letters, digits and -, at most 32. A fresh install starts with the profile default, which always exists and cannot be deleted; like every profile it has a Claude Code directory of its own, signed in separately, and until it is signed in it runs on the user's own Claude Code directory, so nothing stops working (CON-126); the first start after profiles exist copies config.toml into it once, its Telegram and voice sections into ~/.harness/shared.toml, and leaves the file where it is for older builds still running; no build with profiles reads it again. Files are owner-only (0600).
CON-121Replaced by CON-127.
CON-122Profiles are isolated: a session sees only its own profile's sign-in. The Claude Code delegate runs with its profile's Claude Code configuration directory as CLAUDE_CONFIG_DIR and its ANTHROPIC_PROFILE if one is set; the ChatGPT credential is in ~/.harness/profiles/<profile>/chatgpt/, default's included: the first start of a build with profiles moves the one of before there, once, never copying it; API keys come from the variables or keys the profile names. They reach a session only through the window's environment held in memory (INV-6). Two windows on different profiles run at once in one daemon and neither's credential reaches the other's sessions.
CON-123A Claude account of a profile is signed in by Anthropic's own flow only (CON-56 holds): multitool login claude-code --profile <name>, or the profile's Sign in button, hands the terminal to the unmodified claude auth login run with that profile's CLAUDE_CONFIG_DIR. The harness never reads, stores, passes on or asks for a Claude.ai token; claude setup-token and CLAUDE_CODE_OAUTH_TOKEN are not supported. From claude auth status --json the harness reads whether a profile is signed in and, to show which account, its email and plan; nothing else of the answer is kept or logged.
CON-124What is one per machine is shared across profiles: the daemon, the journals and maps by project, the callbacks' entry and the orchestra. Telegram is cross-profile: one bot for the daemon (CON-87), its settings in their own file, ~/.harness/shared.toml, belonging to no profile, default included; the Telegram page is the same whichever profile a window runs on, and a change there reaches every window. Voice goes with it, since what it sets is how the daemon transcribes Telegram voice notes. A slave starts on its master's profile, and mode__agent_models lists what is signed in under it.
CON-125Settings have a Profiles tab: on the left the profiles as one large list, a line each with its name, whether its Claude Code and ChatGPT are signed in, its adapter and model; on the right the buttons Add, Edit, Delete and Use. Enter on a line is Use, CON-121's switch for this window. Under the list the line under the cursor is described in text. The tab signs nothing in or out: Edit moves the window onto the profile and opens the Provider page, where its Claude Code (claude auth login or logout in its directory) and ChatGPT sign-ins are. Add makes a new profile under a name the user gives, entirely clean: the harness's built-in defaults, nothing taken from another profile, no key and no sign-in, and a new empty Claude Code directory of its own, ~/.harness/profiles/<name>/claude/, its projects linked as CON-126 says; Delete asks first, naming the sign-ins that go with it, refuses default and a profile a window runs on, signs its Claude account out with the unmodified claude auth logout in its directory, and then removes the profile's folder.
CON-126Profiles do not own conversations (ADR 0026). A profile isolates the harness's configuration and its sign-ins; a conversation is the daemon's (INV-15) whatever profile opens it. Claude Code keeps its login and its transcripts in one directory, so a profile's Claude Code directory holds its own login, and its projects/ is a link the harness makes to the user's own Claude Code conversation store: the CLAUDE_CONFIG_DIR of the environment that started the harness, else ~/.claude. So plain claude, an older harness and every profile list, resume and append to the same transcripts under the same ids (INV-19, INV-21). Nothing under the user's own store is created, changed or moved; a projects/ that is already a folder in a profile is never replaced. Where a link cannot be made, the profile says so and runs on the user's own directory.
CON-127A window runs on one profile. Bare multitool starts on the profile last chosen with Use in the settings, kept as profile in shared.toml (CON-124), else default; a kept name that no longer exists starts on default. multitool --profile <name> starts on that profile for this run only and keeps nothing, for autostart; an unknown name refuses to start and lists the names. Use, or Enter, on the Profiles tab moves the window and every tab in it onto the profile, started tabs included, whatever their adapter: each tab's conversation goes on with its history under the new profile's sign-ins from its next message, and a tab whose run is on moves when that run ends. Every tab's status line then shows the new profile. Use also keeps the name for the next bare start. Settings changed in a window are saved to the profile it runs on.
CON-128multitool daemon restart stops the running daemon and starts the installed build's in its place, detached, on the same port when it is free, and prints the old and new pid and port. Runs going on in it are stopped and counted; their conversations are not lost, since every open window finds the new daemon and reopens its tabs' conversations with their history. With no daemon running it starts one. multitool daemon stop stops it and starts none. Before a daemon exits, every delegate process it started (Claude Code, Codex) is ended: SIGTERM, then SIGKILL after 3 s, so none outlives it (journal#1021, journal#1032). A daemon tries its last port for up to 5 s before taking another, since the old one's port can stay taken a moment after it stops (journal#1054).
CON-129A reload (/reload, plugins_reload) in a window that does not run a local build's output, such as the installed multitool, builds nothing and restarts the window on the binary installed now, by CON-50's rules otherwise: at a safe point, the view handed over, every tab back with its conversation. The agent that asked is told it was a restart without a build. A window from target/ rebuilds first, and MULTITOOL_RELOAD_BUILD still replaces the build command.
CON-130Windows talk to the daemon over one local socket, AF_UNIX on every OS (Windows 10 1803 and later included), <data dir>/daemon/daemon.sock beside address.json, which names it, readable only by its user, with no token; a path too long for a socket address refuses to start and says so. Messages are newline-delimited JSON: a client opens with hello (protocol number, build, role) and is answered welcome (protocol, pid); requests carry an id and are answered with it; the daemon pushes a window's events on its connection. Every connection has its own reader, writer and queue, so no client waits on another. A window and a daemon work together when their protocol numbers match, whatever their builds; a daemon of another protocol is replaced when idle; while it runs other windows' conversations a window waits for it, saying so in its reconnecting toast, and asks it every 2 s to stop if idle, never running its own conversations instead. A request already written when the connection drops is answered with an error and not resent; one not yet written waits for the next connection. A reload never waits on the daemon. Outside callbacks stay HTTP on the daemon's port.
CON-131A client of the daemon that loses its connection tries again every 2 seconds, forever, finding the daemon afresh each time; it never gives up or falls back for that reason. A window shows a toast every time the connection is lost and every time one is made, the first included, and while it is down a second toast of its own with a pulsing bar and the attempts so far, naming the reason when there is one. While a window is down, whatever its user sends is refused at once with a toast and nothing is queued; a typed message stays in the composer. Clients that are not windows wait through a loss, and what they sent goes once it is back, in order and once. Every tab reopens its conversation on the next connection.
CON-132A window never hangs on the daemon. A call from the window's own thread fails at once when there is no connection; a connected one waits at most 2 seconds for its reply, and a daemon that does not answer in that time counts as lost, so later calls fail at once until it is back. A call that timed out is not sent again.
CON-133The harness always runs Claude Code with --chrome, on every row and in every way: the user's own environment or the isolated one, a user's tab or a slave of an orchestra. No setting turns it off.
CON-134The daemon turns a conversation from any provider's form into any other's (INV-16, INV-18, INV-20, ADR 0025). When a conversation moves to another adapter or profile, the daemon makes it, from its log, in the form the target program reads (for Codex, its own session files), and the target goes on with the whole history. The form of the program it left falls behind meanwhile. When it moves back, the daemon compares a hash of what that form holds with a hash of the log up to the same point: equal, nothing is written; different, it appends only what the form lacks when the form is a prefix of the log, and writes the whole conversation into that form again otherwise. The hash is taken over the messages as the log holds them, the same for every form. No move loses or doubles a message.
CON-135The harness has no plugin system of its own: Claude Code's plugins are used natively, shared across profiles as projects/ is (CON-126): each profile's Claude Code directory links plugins/ to the user's own. Sign-ins stay apart.
CON-136While the daemon makes or brings up to date a conversation's form for another adapter or profile (CON-134), whole or by delta, the window shows a toast with a progress bar that fills as the work goes: what is being done, how many messages are written out of how many, and the share as a bar. It goes when the daemon says the form is ready or failed; a failure keeps the adapter the conversation was on and says why. The daemon reports progress at least every 200 ms. Only that conversation is held: sending into it is refused with a toast; every other tab, scrolling, reading and the settings stay usable, and nothing blocks the whole window (this replaces CON-81's window-wide spinner).
CON-137The harness runs the unmodified codex binary as a delegate on a row of kind codex: one codex exec --json per message and resume <thread> for the next, the prompt on stdin, the harness's MCP servers given for the run. A profile's Codex runs in its own folder (CODEX_HOME = <profile>/codex), whose sessions links the user's own; default runs on the user's own Codex folder until its own is signed in. Codex is signed in only by its own codex login in that folder (multitool login codex, or the Provider page's button); the harness never reads, stores or passes its tokens. The harness's own ChatGPT-plan adapter stays.
CON-138Sharpens CON-134 (journal#931, journal#934). The hash of a conversation is its digest: in order, one stable 64-bit FNV-1a hash per run of one role, over the role and the texts of its messages. Messages with no text are passed over and do not break a run; tool calls and results never count, because a program's stream and its form record one turn's calls differently, and a form joins messages of one role into one. A user message counts by its last paragraph, since what the harness sends a delegate may come before the user's words after a blank line. A form's link keeps the digest of the log up to the point the form holds, taken when the daemon last made them agree. On a move, after what the form gained outside is taken in (INV-20), a form that stands where the daemon left it is not read: its stored digest stands for it. One that changed behind the daemon's back is read whole: gone, shorter, refusing an append, or linked with no digest. Since Claude Code and Codex only append, a shorter form is never taken in as new. Equal to the whole log, nothing is written; equal to the log up to the form's point, only the rest is appended; otherwise the whole conversation is written again under a new id, the old file left as it was. Each move says in the log which it was.
CON-139A project's journal goes to GitHub issues only when (1) a GitHub account is connected through the gh CLI on Settings > Journal, (2) that tab's option "send journal entries to issues" is on (off by default), and (3) the project's working folder is a git repository with a GitHub remote; otherwise nothing is sent and the tab says which is missing. The daemon sends, never a window or an agent; writing to the journal never waits on GitHub: issue work is queued and retried (journal#936).
CON-140While CON-139 holds: a todo opens an issue (title its first line, body the entry and its id); every entry linked to it (its branch and the entries citing it) is a comment on that issue; closing the todo closes the issue with the resolution; reopening reopens it, abandoning closes it as not planned. The daemon keeps the todo-to-issue map so nothing is opened or sent twice, across restarts too (journal#937).
CON-141gh is connected only by its own unmodified gh auth login; the harness never reads, stores or passes a GitHub token, never runs gh auth switch, and names GH_CONFIG_DIR on every gh call. The repository is the one the project's remote names. The tab shows the login and whether the repository is public; on a public one, turning the option on asks once (journal#938).
CON-142The Journal tab's settings, the gh account and the option, are per project (the journal's project: its repository, shared by its checkouts), kept by the daemon beside that project's journal in <data dir>/journal-github/<project>/, never in the repository; one project may send issues while another does not. The tab shows and changes the settings of the window's project and names it (journal#940).
CON-143Journal todos go to an issue tracker through one interface, an adapter per tracker: open an issue (answering its id), comment, close (done or not planned), reopen, say whether it is connected and as whom, and whether the project's place there takes issues. The queue, the todo-to-issue map, the linked entries and the retries are the daemon's, the same for every tracker. GitHub (gh CLI, CON-141) is implemented; GitLab, Asana and ClickUp exist with empty bodies that answer "not implemented yet" and are listed as not available. The tracker is chosen per project on Settings > Journal (CON-142) (journal#941).
CON-144Details of CON-136 (journal#950). The progress toast shows in every case the window waited before: a tab moved to another adapter or profile, a Claude Code conversation opened from the start page, a stored one caught up on opening. One toast per moving conversation (at most 3, then "+N more"): the tab's name, what is done, done/total with its unit (messages, or MB while a whole copy is read) and share as a filled bar; a bar with no total yet pulses. Progress comes at least every 200 ms and is not written to the log. Only that conversation is held: what is sent into it, and a second change of its adapter or profile, is refused at once with a toast naming where it is going, the typed text kept; an inbound message for it waits. On ready the toast goes; on failure it goes, a toast says why, and the conversation stays on its adapter.
CON-145A delegate run by multitool, on any profile, has what the user set up in that program: MCP servers, plugins and marketplaces (installed and enabled), skills, agents, commands, hooks, rules and instructions; Claude Code from the user's ~/.claude and ~/.claude.json, Codex from ~/.codex, any later delegate likewise. A profile's login is never shared: Claude Code's credentials and the login-carrying keys of settings.json (env, apiKeyHelper, awsAuthRefresh, awsCredentialExport, otelHeadersHelper, forceLoginMethod, forceLoginOrgUUID), Codex's auth.json, every sign-in stay the profile's (CON-56, CON-123, CON-137). A server's env never goes on a command line. The harness never writes the user's own files: it links to them or copies from them into the profile's folder, moving aside, never deleting, what the profile had. An isolated slave keeps --strict-mcp-config until the owner decides (journal#965). The user's own Claude Code and Codex folders are those the first multitool of a chain found: it notes them in MULTITOOL_OWN_CLAUDE_CONFIG_DIR and MULTITOOL_OWN_CODEX_HOME (empty when there were none) before it sets its profile's, and every multitool started from it (a reload, a daemon, one run by an agent) reads those first (journal#1025).
CON-146A proof kept in a file lives in the project's own .harness/proofs/ (journal#928, owner's word 2026-11-11, agent's decisions journal#984). journal_add takes a proof_file there by its path in the project; one from elsewhere is copied into .harness/proofs/journal/ (the same file is one copy, another of its name gets a number) and the entry names the copy; a folder, or a file over 50 MB, is refused saying why. The journal_get and journal_branch of an entry answer proof_files: every proof file of its branch, with the entry that gave it. Entries from before keep their proofs as they were.
CON-147A game between agents has no time limit on a turn (journal#1006, owner's word 2026-11-12: a game is played at leisure, and an agent may be busy). A turn waits for its player however long it takes; the rules act (check if it can, else fold) only for a player who has left the table, at each of its turns. Replaces the 120 s time to act of ADR 0029.
CON-148Replaced by CON-150 and CON-151 (journal#1014, journal#1015): the hand's history has its own tool.
CON-149Every hand of a game has its own SQLite database, <data dir>/games/tables/<table>/hand-<n>.sqlite (journal#1008, owner's word 2026-11-12): the hand's meta (table, game, hand, seed, players, rules), every action taken (a timeout the rules took for one who left included) and every event the rules gave, private ones with their player. They are the source of truth for the table's state: the game replayed from hand 1's meta with every hand's actions in order. A step is applied to a copy, written with its events in one transaction across the hands it touches, and only then taken; a failed write refuses it. game_state answers from them; the table's JSON keeps no engine, which is rebuilt from them when the daemon starts.
CON-150game_state is the current state of the hand (deal to winner) as the asking player may see it, read from the hands' databases (journal#1014, owner's word 2026-11-12): the hand's number and street, the board, the pot and each pot with who can win it, the current bet, the button and the blinds, who is to act, how many players are still in the hand and in the game, and for each player the stack, what was put in this round and in this hand, folded, all in, out and the role; you: your cards, stack, what you have put in this round and this hand, to call, the legal actions, the least raise-to and the most you can put in, your position. Never another player's cards. Replaces CON-148. The pots count only what is matched: a bet not yet called is shown apart as uncalled; the answer's table is the seating and rules only (journal#1030, journal#1033).
CON-151game_history gives what has happened in the hand being played now, and only in it (journal#1018, owner's word 2026-11-12; replaces journal#1015): from that hand's own database, its events in order from the deal to the winner as {seq, kind, text, data, at_ms}, the public ones and the asking player's own cards, never another's; the table's start and the prompts to act are left out. game_state too is the current hand only. Earlier hands stay in their databases, and no agent tool reads them.
CON-152The dashboard's Games tab shows a table as a poker client does, in a design of the harness's own (no other product's brand or look copied): an oval felt table, seats placed around it by their number with avatar, name, stack and state, the button and blinds, face-down cards for players in the hand, bets as chips, the board dealt and turned with animations, the pot and side pots, a bubble on each action, the winner lit and the pot moving to it, the showdown's cards turned up; public data only, each animation once per new event; one self-contained HTML file (journal#1037). Updates are pushed by the daemon on a WebSocket, /dashboard/ws, never polled; a table's DOM is built once and changed in place (journal#1039).
CON-153An agent invites others to a game with its own tool, game_invite (journal#1049): the nicks or ids of agents online, as agent_list shows them; the table is made with the inviter and them at the games' settings, the inviter joined at once, each other told by its game message; refused, saying why, when games are off, when a name is no agent online (listing those online), or for fewer than 2 or more than 9 players.
CON-154Any player leaves a table when it wants with game_leave (journal#1050): while inviting it declines; during a hand it is folded at once if to act, else at its turn, its cards never shown; at the hand's end it is out of the game with its stack, in the standings; the leave is recorded as its action {"do":"leave"} in the hand's database and replays; the others are told; with fewer than 2 left the game ends at that hand's end. Replaces CON-147's folding for a player gone at every turn.
CON-155A daemon serves its data directory only while it is the daemon that directory publishes (journal#1096, for journal#1095): every 5 s it reads <data dir>/daemon/address.json, and when the file is missing, unreadable or names another daemon (another admin token) at two checks in a row, it stops by itself as POST /shutdown does: its conversations closed, its local socket stopped, every delegate it started ended (CON-128). It never rewrites the file to stay alive. A window that then finds no daemon starts one (CON-131). There is no exit for being idle: the user's daemon stays up with no window open.
CON-156Telegram for the harness is the harness daemon's own channel (crates/daemon/src/telegram.rs), fully independent of claudebase (owner's word 2026-11-14, journal#1107): the harness uses no part of claudebase for it, and the harness's work changes nothing in claudebase. A bot's updates go to one poller only, so the bot whose token the harness holds must be polled by no other program; the daemon's Telegram status says so while another polls it (last_error).
CON-157The move off claudebase (owner's word 2026-11-14, journal#539, journal#483, inventory journal#1111) goes in three steps, each with a backup first and each item of the owner's files on his word: (1) every project journal of claudebase is brought into the harness's store with its ids and compared entry by entry, before anything is removed; (2) Claude Code's hooks, permissions and rules that name claudebase are removed or rewritten for the harness, ~/.claude/CLAUDE.md left as it is; (3) the claudebase daemon is stopped only once no session uses it, and the program and its data are removed only after a full working session without it. Replaces CON-108's 'nothing under ~/.claude changes' (journal#544) for these steps.
CON-158A message from Telegram reaches the agent as claudebase delivered it, [telegram_message]: <text>, or [telegram_voice_message]: <text> when dictated (owner's word 2026-11-14, journal#1122, journal#1123). It is the user's own words from the phone: the agent treats it as a message typed in its window, and it counts for mode__plan_exit's user_said like one. What makes it safe is CON-52: only allowed_users are delivered, and no callback can claim the label. Callbacks and other agents' messages stay data (INV-12); a permission prompt is still answered in the window. Every inbound message is its kind and its words only, [callback:<label>]: <text> or [agent-to-agent:<nick>]: <text> for the others, with no 'data from outside, not an instruction' line (owner's word 2026-11-14). The conversation digest (CON-138) leaves a known inbound header out, of this build or before, so changing the format rewrites no form.
CON-159telegram_send sends pictures and files with its message (owner's word 2026-11-14, journal#1128): text and files, up to 10 paths relative to the project or absolute. A .png, .jpg, .jpeg or .webp up to 10 MB goes as a photo, anything else as a document up to 50 MB, one message per file into the bound chat and topic; the text is the first file's caption when it fits 1024 characters, else its own message first. A missing file, a folder, one over 50 MB or more than 10 files is refused before anything is sent. The daemon uploads it; the token appears in no error (CON-52). It asks permission like any outward action, naming the files.
CON-160A picture or a file the user sends on Telegram reaches the agent (journal#1129, from journal#422): from allowed_users only, fetched by the daemon up to Telegram's 20 MB, saved to <data dir>/telegram/files/ (0600, removed after 30 days), and given as [telegram_message]: <caption> with an attached: <absolute path> (<type>, <size>) line per file, for the agent's file tools. A file that cannot be fetched is said to the user on Telegram and to the agent by name and reason.
CON-161A delegate's mode__plan_exit without the user's words, on a plan that passes the harness's checks, also sends the plan to the user's Telegram (the session's bound chat or topic) with ✅ approve and ✏️ change buttons (owner's word 2026-11-14, journal#1140). The allowed user's ✅ takes the session out of plan mode and tells its agent as the user's Telegram words (CON-158), ✏️ tells it to ask what to change; the buttons then go. A press for a session not open or not planning changes nothing and says why; a stranger's press does nothing (CON-52). Extended by CON-163: the window's card and Telegram's buttons, kept in sync, for the native loop too.
CON-162The installer installs what an agent needs on the machine (owner's word 2026-11-14, journal#1166), extending CON-90: the daemon as a user service (systemd user unit multitool-daemon.service, a macOS LaunchAgent, a Windows logon Scheduled Task multitool-daemon; else a background start with a warning; on Windows the hook is harness-selfcheck-reminder.ps1, run by powershell -NoProfile -ExecutionPolicy Bypass -File; journal#1209), linger enabled unless --no-linger, multitool daemon restart going through the service when one is installed; the harness's Claude Code setup from assets/claude/ (rules project-journal.md and cognitive-self-check.md, the self-check hook merged into ~/.claude/settings.json), each differing file backed up first; build dependencies checked and installed only on the user's word; a verify step before claiming success; --yes, --no-service, --no-agent-setup; --uninstall removes the service and what it added, keeping data and backups.
CON-163A plan waiting for approval is asked in two places at once, for a delegate and the native loop alike (owner's word 2026-11-15, journal#1178): a card in the window like the permission card, showing the plan with approve and reject, and the plan with ✅/✏️ buttons on Telegram (CON-161). The first answer decides; the other place follows: answered in the window, the Telegram message loses its buttons and says where it was decided; answered on Telegram, the window's card is withdrawn (an ask_withdrawn event carrying the outcome) so it can never answer a later question, and a toast says it: "✅ План одобрен в Telegram" or "✏️ План не одобрен в Telegram" (amended by the owner's word 2026-11-15, journal#1188). A late answer on the other side says it is decided already and changes nothing. A slave's plan stays its master's.
CON-164Every multitool session (conversation) has a callback URL of its own (owner's word 2026-11-15, journal#1195): http://127.0.0.1:<port>/callback/<token>, the token a random UUID the daemon keeps per conversation in daemon/session_callbacks.json, the same across tabs, windows, reloads, daemon restarts and moves between adapters and profiles. IF-13's contract, as a tab's URL: notification, journal, the project's condition types and custom handlers; flowstate_update stays on the tab's URL (400). Delivered to the session wherever it is open, starting a run of an idle agent, as [callback:<label>]: <text> (data, INV-12); a session not open keeps it in order (500 at most, 7 days) and gets it when it opens, the caller told queued. The agent knows it from its system prompt and the callback_url tool, which also gives how to use it with a curl example (journal#1200); nothing else shows the token.
CON-165An agent checks its own callbacks with callback_check (owner's word 2026-11-15, journal#1204): with send (the default) the daemon POSTs a test notification to the session's own URL over HTTP, label callback-check, and answers the reply, the agent then receiving [callback:callback-check]: ...; and it answers this session's last trigger log entries (10 by default, 50 at most: time, uuid, type, outcome, detail), what waits in its queue, and its URL. Only this session's entries, never the token; no permission is asked.
CON-166Every delegate program runs in a systemd user scope of its own (owner's word 2026-11-16, journal#1223): on Linux with a reachable user manager, systemd-run --user --scope --collect --slice=multitool-agents.slice --unit=multitool-agent-<adapter>-<random> -- <program>, in the same process, so its MCP servers and builds are counted apart from the daemon and the service's memory is the daemon's; elsewhere, or when the check fails once, the program starts as before. The daemon still ends its delegates itself at a stop. daemon --status gives the daemon's own rss_mb and peak_mb.
CON-167The harness from Telegram (owner's word 2026-11-16, journal#1232), for allowed users only: the daemon keeps a register of every conversation it hosted (daemon/known.json: root, title, nick, adapter, last open); /restart restarts the daemon through its service after a ✅ (it ends the runs going on); /reload reloads every open window; /open lists the register by project, an open conversation to switch to and a closed one to open in a new terminal window in its root (multitool --resume <id>, in a systemd scope of its own), where it keeps its Telegram binding; /new opens a new session in a chosen project (multitool --new). The terminal is [telegram] terminal, else xdg-terminal-exec, ptyxis, gnome-terminal, x-terminal-emulator; Linux only for now. /restart and /reload end with a word in the chat that asked when they are done (journal#1243). Nothing a user sends waits on a reload or a switch: held messages follow CON-168. /journal follows when its interface is chosen.
CON-168Nothing a user sends on Telegram waits on a reload, a restart, a switch or a next message to be delivered (owner's word 2026-11-16, journal#1248): a message for a chat whose bound session is not open goes by itself as soon as that session is open again, and a chat bound to none takes the only session open; what is delivered after waiting says so, (sent <local time>, held until now) <text>, and the chat is told each message's time and first words; what waited more than 24 h is dropped and said, never delivered as new; every release and drop is in triggers.jsonl.
CON-169Every chat the bot serves has a persistent 🛠 Service button (a reply keyboard, sent once per chat and with /start and /service; owner's word 2026-11-16, journal#1249): pressing it reaches no agent and answers with inline buttons for Open, New, Reload windows, Restart daemon, Sessions and Which session, each doing what its command does.
CON-170A multitool window names its terminal tab after its agent (owner's word 2026-11-16, journal#1262): it sets the terminal's title (OSC 0) to <name> · <project folder>, <name> being the active tab's agent nick, else the tab's title, and multitool on the start page; set again whenever a nick is set (by the agent, /nick or Telegram) or another tab becomes active, and only when it changed.
CON-171A conversation is dumped and loaded whole (owner's word 2026-11-16, journal#1266): multitool chat dump and the Settings 'Chats' tab write a .zip into the project's folder, never over a file, with a manifest, the multitool log, the linked Claude Code form whole (transcript, subagents, tool-results, file-history) and the project's journal with its mind maps and flowcharts; multitool chat load and the tab bring it into the folder they are called in, under new ids every time (CON-175 replaced the kept ids and the refusal), moving cwd fields under the project, and adding the journal's entries and maps once, with new ids and remapped refs. The tab lists this project's conversations, grouped by adapter.
CON-172A dump and a load show their progress (owner's word 2026-11-16, journal#1276): in the window a toast with a bar like the reconnecting one, 'Dumping ' / 'Loading ', 'done / total MB · N%', counted in bytes inside each file, reported at most every 100 ms; over the Settings too, one per job (3 shown), holding no tab; when it ends the toast goes and the outcome is on the Chats page, or in a system toast when Chats is not open. multitool chat dump|load prints the same on stderr when it is a terminal. A dump with no --out goes to <project>/multitool_dumps/<name>-<id>-<yyyy-mm-dd-hh-mm-ss>.zip (journal#1288, journal#1284), and when that is taken -2, -3… after it: never over a file (journal#1278).
CON-173The Chats tab works by buttons (owner's word 2026-11-16, journal#1295): a click on a conversation shows [ Dump ] under it; [ Load… ] is always on the page's header line (its copy box gone with CON-175); Load opens the system's file picker (zenity, kdialog, osascript, PowerShell's OpenFileDialog, the first found), filtered to *.zip and starting in multitool_dumps/, off the window's thread; a cancel says 'No archive chosen.'; with no picker or no graphical session the page says why and offers the in-window list. Keys d, l, n and Enter do the same.
CON-174A busy window shows a moon in its terminal tab (owner's word 2026-11-16, journal#1300): while some tab's agent is generating or has a background task running, the title is ' · ', the moon stepping 🌑🌒🌓🌔🌕🌖🌗🌘 every 150 ms; idle, it is CON-170's title.
CON-175Every load gives new ids (owner's word 2026-11-16, journal#1304), replacing CON-171's kept ids and refusal and CON-173's 'as a copy' box: the session becomes loaded-<8 hex>-<ms> and the linked Claude Code conversation a new UUID, renamed wherever written; a load is never refused for being here already, the same archive twice is two conversations; the journal still comes in once. multitool chat load has no --new-id.
CON-176The installer minds working agents and names optional tools (2026-11-16, journal#1309), amending CON-162: before it restarts the daemon it reads conversations.busy from multitool daemon --status; with agents working it asks (default no), or with --yes waits for them to be idle (5 s polls, up to 15 min) and otherwise leaves the daemon for a later multitool daemon restart; --force restarts at once. The verify step warns, Linux only, of a missing file picker (zenity or kdialog, CON-173), terminal for Telegram's /open (CON-167) and systemd-run --user (CON-166).
CON-177A background task lives as long as its process (journal#1315, fixing journal#1311): a session resumed from its log whose last background list is not empty ends it with an empty list, as a cut-off tool call is ended; the Claude Code delegate that replaces a process it had does the same; a task said done (or stopped with its process) leaves the window's strip at once. The strip and the CON-174 moon follow.
CON-178A journal flag wait-for-decision (owner's word 2026-11-17, journal#1321): a work item, open until journal_close gives the decision as its resolution; it shows in the agenda and keeps its entry; the entry waits for a choice only its decider (usually the owner) makes, and the work that depends on it does not go on meanwhile. Unlike question, it is not something to find out but a choice to be made.
CON-179A journal flag research (owner's word 2026-11-17, journal#1328): a passive mark for the result of any research or analysis, not open work and not on the agenda, kept by its salience; the entry stands alone with the question, the method, its sources named exactly, the result and how sure it is. Before a research an agent looks for earlier ones (journal_list flags research, journal_search) and does not redo what still holds; after it, it journals the result so flagged.
CON-180Four more light themes (owner's word 2026-11-17, journal#1334): paper (cool white, indigo), sand (warm beige, teal), blossom (pale pink, plum), mist (pale blue-grey, cyan-blue), original palettes, kind light, the brand as in every theme; F2 cycles dark, light, paper, sand, blossom, mist, nord, monokai, cyan. Floors, checked by tools/theme_contrast.py: text on background and surface ≥ 7:1; text_muted on background and surface_raised ≥ 4.5:1; accent_text on accent, accent and the status colours as text on background ≥ 4.5:1; accent_line on background and surface ≥ 3:1.
CON-181An agent outlives its window (owner's word 2026-11-17, journal#1345; replaces CON-76's denial of an unanswered prompt). A window leaves its conversations in one of four ways: 1 stop now; 2 let the tool call under way finish, then stop; 3 finish the work: the run and what is queued go on until the agent stops on its own, then end; 4 keep: they stay open in the daemon with no window, and Telegram, callbacks and agents start runs. With no window a question (permission, ask_user, plan approval) waits in the conversation, not denied; a window that opens the conversation takes it over with its question. /exit and the Ctrl+C quit ask with a dialog (1–4, 'Remember my choice'), unless Settings > Behaviour 'On exit' is set; an accidental loss (killed, ssh drop, silent 30 s) does 'On an accidental loss', 3 by default. A Local window can only stop.
CON-182No delegate outlives the daemon that started it (journal#1357, fixing journal#1356): the daemon ends on SIGTERM and SIGINT as on /shutdown, its delegates ended (journal#1021); multitool daemon reap stops every multitool-agent---.scope whose daemon pid is no running multitool daemon, and runs at each daemon's start and as the service's ExecStopPost.
CON-183Custom callbacks are project handlers (owner's word 2026-11-19, journal#1366 as amended by journal#1370, journal#1372, journal#1373 and journal#1382; amends ADR 0015 for custom types; ADR 0031, docs/callbacks.md): .harness/callbacks/<name>/ holds config.toml (description, types, args, timeout_s, handler) and its handler. A handler is a compiled Rust program on the harness-callback crate (crates/callback-sdk), made by multitool callback new and built by multitool callback build to target/release/<name>; a file starting with #! is refused, and the handler's own logic may run any other language. It runs only once approved, pinned by its SHA-256, so a new build is approved again: in Settings > Callbacks one Enter on its row approves it when needed and subscribes the conversation, and Enter again unsubscribes (journal#1382). Each conversation subscribes to the project's callbacks in Settings > Callbacks; the daemon keeps a registry, conversation → type → handler, in hash tables (O(1) per callback), and standard types stay native. A custom callback enters the daemon as a default one does (a session's URL, uuid and type, a repeated uuid runs nothing); the daemon answers 202 at once and starts the handler asynchronously in a scope of its own, killed at timeout_s, with the callback on stdin, its args, the session in its environment and a reply URL of that run alone. The handler POSTs its results there ({deliver: message, journal or none, text, label}), never on stdout, and the daemon delivers them to that session alone (403 for another, 410 past its time). Not subscribed: 400; not approved or changed: 409. Agents read the state with callback_handlers; approving and subscribing stay the user's.
CON-184The project's site, https://harness-multitool.dev (owner's word 2026-11-19, journal#1392 as amended by journal#1400). It lives in its own repository, codefather-labs/harness-multitool.dev, as a Rust server on actix-web; its design and its page description (docs/site.md) are there. The first screen has the logo as the brand mark, the slogan and the install line curl --proto '=https' --tlsv1.2 -sSf https://harness-multitool.dev/install.sh | sh. Directly under it is the real terminal interface: frontend-tui compiled to wasm32 (so frontend-tui must keep building for wasm32, checked in CI here). A real agent loop runs on a scripted model, with a Demo mode and an Explore mode. A documentation section is rendered from this repository's docs/, with no copy. Hosting and the installer: journal#1390.

This page's source