Skip to content

[0.1.3] - dash fixes and much more

Choose a tag to compare

@morpheuslord morpheuslord released this 07 Nov 09:37
· 59 commits to main since this release

[0.1.3] - 2026-11-06

Added

  • Resume a stopped run where it stopped.
    • Resume where it stopped on a halted, failed or cancelled run, or POST /runs/{id}/continue,
      starts a new run (resumed_from_id) with the same council, outputs and knowledge, optionally
      with changed guardrails.
    • Every agent task the old run finished (plan, steps, report stages, votes) is replayed from its
      recorded answer, with no model call and no step counted. Only unfinished work calls a model.
    • Citations keep their numbers. Notes and workspace files carry over.
    • Each finished task is now recorded as task.completed. For older runs, the plan and finished
      steps are recovered from their events, and the report is built again.
    • Before this, the only way on was Start a follow-up run, which began again from planning.
  • Budget reserve.
    • budget.buffer_usd / budget.buffer_tokens is spending approved in advance. The run draws it,
      without asking, when it reaches its budget, instead of halting. This works even with limit
      extensions off.
    • The report pipeline counts the reserve, so it no longer drops stages to fit the base budget.
    • Set it in the guardrails editor or Home's run settings (remembered per browser).
    • On a live run, the Budget control or POST /runs/{id}/budget raises the budget now
      (add_usd, add_tokens) or sets the reserve (buffer_usd, buffer_tokens).
  • The run timeline shows a resumed run's origin, a drawn reserve and budget changes at every
    density.
  • Council members talk to each other, and to you, over A2A.
    • Every seat gets the communication tools, whatever its role's tool list says (the run's
      tools.allow / tools.deny still apply): send_message, message_group, broadcast,
      publish / subscribe (topics), ask_agent, delegate_task, request_review,
      reply_to_user, and the board's notes_write / notes_read. They cover eight forms: direct,
      request, broadcast, group, delegate, topic, board and review.
    • ask_agent, delegate_task and request_review run the recipient on the request at once and
      bring its answer back. A run allows 40 of them, nested at most two deep. A review's verdict is
      also posted to the board.
    • Every member sees the shared board on every turn, and each finished step is posted to it.
      Messages from teammates arrive at the recipient's next turn.
    • Every exchange is an A2A Message (a delegation also an A2A Task), each member has an A2A
      agent card (argus://runs/{run}/agents/{member}, in-process transport), and each exchange is
      recorded in the ledger (protocol a2a, direction internal) and on the timeline as
      a2a.message / a2a.task events.
    • The run timeline shows each exchange as a row, and the map and heatmap draw it as an A2A edge.
    • Your messages during a run are A2A messages with role user. Addressed members get them at
      their next turn and keep them in their instructions for the rest of the run. They answer with
      reply_to_user, shown as Ben replied to you.
    • POST /runs/{id}/a2a takes an A2A message/send message (metadata.to: a member's name or
      role; omitted, the whole council) and returns the recorded message.
  • The council debates and concludes together. See the design.
    • Debate over A2A. Members make claims with evidence and a confidence (make_claim), and
      challenge a claim or a teammate (challenge), demanding proof, a counterexample or a
      clarification. The challenged member must defend, concede or revise
      (respond_to_challenge), and the challenger accepts or rejects the answer
      (resolve_challenge).
      • A defence of a proof demand that brings no evidence is marked unsupported and stays open.
      • A member cannot finish its work while challenges against it are open: it is sent back up to
        debate.max_nudges times.
      • A review that asks for a revision opens a challenge.
      • Every move is an A2A message with a data part. Each one is recorded in the ledger and on
        the timeline as debate.* events.
    • A collective conclusion. After the work come four phases. Every non-overseer member is a
      debater and a co-author.
      • Deliberate: rounds in which all debaters challenge at once, then answer at once.
      • Converge: every debater states a position, endorsing or objecting to each claim. Agreement
        is computed in code against debate.consensus (two thirds by default), and the debaters
        revise while claims stay contested.
      • Compile: a scribe (the writer seat, or else the chair) assembles only what was agreed,
        shows contested claims with both sides, records dissent, and adds How the council reached
        this
        .
      • Co-sign: every author signs, amends or blocks, with a quorum. Amendments that the consensus
        endorses are applied.
      • Co-signing replaces the vote, in report mode too, where the report's byline lists the
        council. debate.enabled: false restores one synthesis and a majority vote.
    • Debate cost. The debate saves without cutting rounds, participants or the threshold:
      • Light moves (a challenge, a position, a signature, an amendment vote) read a digest. They run
        as one call without tools, on the newest cheap model of the seat's own provider that still
        scores at least debate.light_min_reasoning (70) for reasoning. That is Claude Haiku 5.5 for
        a Claude seat, with the seat's model as the fallback.
      • Answers to challenges, which keep the read-only tools to fetch proof, and the compiled text
        stay on the seat's model.
      • A debater shown nothing new since its last challenge is not asked again.
      • Each phase reports its cost as debate.cost, and the Debate view shows the total.
      • debate.light_model: "seat" keeps every move on the seat's model.
    • A secret devil's advocate. At the start of a run, one debater (never an overseer or the
      chair) is picked at random in code to argue the other side and demand proof. The pick needs at
      least two debaters, and is skipped and recorded otherwise.
      • Only you know who it is. The run records council.role_assigned with secret: true, and the
        UI shows the badge with a private marker.
      • No agent is told. The stance never reaches a roster, agent card, board, inbox, digest, the
        graph or the deliverable.
      • Giveaway phrases are removed from everything the advocate says, writes or thinks into a
        shared place: messages, notes, claims, tool arguments, the live view and graph nodes.
      • A resumed run keeps the same advocate.
    • The Debate tab. It shows the phase and round, the numbered claims with their status and
      evidence, each challenge as a thread, a table of members' positions on the key claims, and the
      conclusion's signatures. From any claim or challenge you can message the member.
  • Truly parallel by default.
    • Eight agents work at once (max_parallel_agents was 4).
    • The read-only tools and council (A2A) tools an agent calls in one turn run concurrently, and
      their results come back in call order. A turn with a writing, shell or approval-gated tool
      keeps the calls in order.
    • Every member sees what its teammates are doing right now: a Working now section with the tail
      of each teammate's latest thought (member.live).
  • Runtime helpers. Any member can bring in helpers while it works with spawn_agents, waiting
    for them or collecting them later with await_agents.
    • A helper is a council member for as long as it lives. It is an A2A task with its own agent card.
      It sees the board, can make claims and challenge others while it works, can spawn helpers of
      its own, and can be held, corrected or messaged like a seat. It takes no position and does not
      co-sign: the conclusion belongs to the seated council.
    • The model is chosen for the role from the council's providers.
    • Helpers run in parallel through the run's slots. The limits are in guardrails.spawn
      (max_agents 8, max_depth 2, max_live 6).
    • The chair can add plan steps mid-run (add_step), and they start as soon as their
      dependencies are done.
    • Cancelling the run cancels its helpers. Resume replays both helpers and added steps.
  • Graph context: fewer tokens, and a council that remembers. Each council keeps a knowledge
    graph (tables graph_nodes and graph_edges, migration 0021).
    • The graph holds claims, evidence, results, entities, decisions and open questions, linked by
      supports, refutes, cites and derived-from edges.
    • It is built from the run's events with no model calls.
    • Instead of pasting up to 24k characters of earlier steps, a step gets a digest of each
      dependency: its summary and claims, with ids. Members read detail on demand with graph_read,
      search with graph_query and link nodes with graph_link.
    • The board is rendered from the graph.
    • A new run starts from what this council already knows: the nodes from its earlier runs that
      best match the topic.
    • On a two-step offline run, the dependent step's context fell from 8,247 to 1,792 characters.
      Each step reports its saving as context.saved, shown in the run header.
    • On Anthropic models, the stable part of the system prompt and the tools are sent with
      cache_control, so turns after the first read them from the prompt cache.
    • guardrails.graph turns this off or tunes it.
  • Shared knowledge between runs.
    • A new run inherits the board of the latest earlier run of the same council, or of your runs
      without a council. That's the newest 40 notes, marked (earlier run) and credited to their
      authors, and the run after inherits them again. graph.inherit_board: false turns this off.
    • Every note on the board is recorded as a board.note event.
    • Agents are told about all the knowledge they can search: the linked knowledge bases (searched
      first), every other knowledge base you added, and the research library. Before, they were told
      only about the linked ones.
  • A compressor, and budget pressure.
    • Older turns are summarised on the cheapest model of the seat's provider that scores at least
      context.compressor_min_reasoning (70) for reasoning, instead of the seat's own model.
    • Once a run has used context.pressure_start (60%) of its token ceiling, every agent's history
      budget shrinks, down to 40% at the ceiling, so turns cost less as the run nears it. The ceiling
      counts the limit, the raises still allowed and the reserve: 5,000,000 tokens by default.
    • The run records context.pressure once per tenth of the ceiling.
  • Recovery from context overflow. When a model refuses a prompt as too long, the agent halves
    its history budget, summarises and tries again, up to twice, as Claude Code does
    (context.compacted). Before, the step failed, and with it often the run.
  • See how each agent reasons. Thought cards gain a Reasoning section above the answer. It
    updates live, collapses once the answer arrives, and shows the token count.
    • oversight.reasoning:
      • auto (the default) records what the model returns, at no extra cost;
      • on asks Claude (adaptive thinking, summarized) and Gemini 2.5 (thoughts) for a readable
        summary;
      • off records none.
    • Reasoning is streamed as thought.reasoning.delta and kept on thought.completed.
    • It is shown only to you, never to another agent, and the secret advocate's reasoning is
      concealed like the rest.
  • Readable JSON replies. Plans render as numbered step lists. Debate moves, co-signatures,
    votes and reviews render as labelled rows with chips, and other JSON as a collapsible tree, each
    with View raw and Copy JSON.
  • Auto mode. With guardrails.auto_mode on, agents never stop to ask. Each approval request is
    still recorded, as approval.requested then approval.resolved {"decision": "approved", "by": "auto"}, and the workspace shows it as Auto-approved. guardrails.extensions.auto_approve
    does the same for raising the step, per-agent turn, runtime and token limits. It stays within
    extensions.limits and max_extensions, and only raises spend when budget.usd is listed. Both
    switches are on Home's run settings (remembered per browser) and in the council guardrails
    editor. POST /runs/{id}/auto-mode and an Auto mode control next to Pause change them on a
    live run; turning one on approves the requests already waiting that it covers. Hard blocks
    (tools.deny, destructive shell, content and network policy) are unchanged. Sub-councils
    inherit auto mode.
  • Palettes. Settings → Appearance, the header theme menu and the command palette offer six
    palettes, each in light and dark: Wine (default), Indigo (the original look), Graphite, Forest,
    Ocean and Ember. scripts/check-contrast.py checks every palette against WCAG AA.
  • The protocol ledger also records the agents' outbound web requests: web_fetch, web_search
    and the market and news tools, as protocol http. The live stream gets a protocol.call event
    for each request. The ledger page has an HTTP filter. Before this, the ledger stayed empty for
    anyone without MCP servers or remote agents.
  • web_fetch reads PDFs (up to 15 MB). It can render JavaScript-only pages in headless Chromium
    when ARGUS_WEB_FETCH_RENDER_JS=true and the optional browser extra (Playwright) is installed.
  • Released images on the GitHub Container Registry.
    • Every release publishes ghcr.io/lordprime/argus-council/{api,web,runner} as <version>,
      <major>.<minor> and latest. They are scanned with Trivy before they are pushed.
    • deploy/docker-compose.yml runs those images by default, so a server needs only that file and
      an .env: no checkout and no build. Each GitHub release attaches the compose file with its
      version pinned, and the .env example.
    • A release starts from a pushed v* tag, or from Actions → Release → Run workflow with a
      version (it creates the tag at ref, or with move_tag moves an existing one for a
      re-release). The version must match backend/pyproject.toml and frontend/package.json.
    • deploy.sh --release <version> and update.sh --release <version> pull a release instead of
      building, with the usual backup, migration step and automatic rollback.
    • Building from source still works: the scripts build local argus-council/* images as before,
      and deploy/docker-compose.build.yml adds the build sections back for plain Compose.

Changed

  • The schema gains runs.resumed_from_id (migration 0020).
  • notes_write posts to the council board, which is shown to every member on every turn; before,
    notes were seen only through notes_read.
  • Ledger entries can have direction internal (between members of one council), shown as
    Council in the ledger browser.
  • The Insights dashboard is rebuilt.
    • Each headline number shows its change against the previous window of the same length.
    • Runs per day are stacked by outcome, next to a Right now panel of live runs and the ones
      waiting for your approval.
    • Spend over time sits beside spend by model.
    • Tool reliability is now a table: error rate, calls, average time, and each tool's most
      common error.
    • It also has a model and provider health table, oversight with the auto-approved share, the
      run mix, top failures, guardrail violations, and the costliest runs.
    • GET /insights adds previous_totals, a per-hour or per-day series (computed on the
      server, no longer from the newest 200 runs), each tool's top_errors and
      oversight.approvals_auto.
    • Charts follow one set of rules: status colours mean status and nothing else, gridlines are
      solid, bars are thin, and headline numbers are set in the sans face.
  • The runs list includes pending_approvals for live runs, so Home's Needs you and the
    dashboard can tell which runs are waiting for an answer.
  • Home is a home page. The composer leads, and its configuration folds into one Run settings
    row that summarises the choices. Runs waiting for you come first. A side rail shows the last
    7 days, tools above 20% errors, and whether model providers are answering.
  • web_fetch extracts article text with trafilatura and sends ordinary browser request headers.
    It retries timeouts, 429 and 502–504 responses twice, with backoff, honouring Retry-After up
    to 5 s. On 401/403/404/410/429/451 or a bot-check page it falls back to the Internet Archive's
    closest snapshot. That goes through the same SSRF checks and only when the run's domain policy
    allows archive.org. Bot checks are reported, never bypassed. Every error says what to do next:
    for a 404, for example, search for the real address instead of guessing URLs.
  • knowledge_read finds a document by id, exact file name, the knowledge base/file form that
    knowledge_search cites (with or without #chunk), base name, title, or a close match.
    Knowledge base names match regardless of case. A miss lists the closest file names.
  • artifact_read accepts ./, /workspace/ and workspace/ prefixes, any case, a unique base
    name or a close match. A miss lists the workspace's files.
  • Failed tool calls end with a Recovery: line when the tool gave no guidance: the schema for bad
    arguments, "look it up first" for missing names, the available tools for an unknown tool.
    Read-only built-in tools get one automatic retry after a timeout or dropped connection.
  • The interface: badges and menu labels are in sentence case instead of all caps, status badges
    are square instead of pills, and the Insights KPI cards drop their tinted icon circles.

Fixed

  • Resuming a run with linked knowledge works. The old run's links are stored as strings and were
    compared with the database's UUIDs, so every such resume failed: with "Knowledge base not found"
    on Postgres, and an internal error on SQLite. They are normalised now, and a knowledge base deleted
    since is left out instead of refusing the resume.
  • A resumed run gets its whole board back. Before, it rebuilt only the notes written with
    notes_write, and lost the step results, reviews and helpers' results posted to the board.
  • Runs halted before this release resume too.
    • Their board is rebuilt from their A2A board posts (or, for older runs still, their
      notes_write calls).
    • Their saved guardrails take the new settings' defaults.
    • A run that failed to resume with "Knowledge base not found" can simply be resumed again.
  • Claude 5-family turns no longer fail on a stale thinking block.
    • On Claude Opus 5.5, Sonnet 5.5, Haiku 5.5 and Fable 5.1, a thinking block is bound to the
      conversation that produced it. A council member's prompt carries the live board and its history
      is compacted, so for accounts the API enforces (created on or after 2026-08-31), a turn could
      fail with "bound to a different conversation".
    • After the first such 400, the provider retries once with
      thinking.block_binding.prefix_mismatch_behavior: "drop_block" (beta
      thinking-binding-controls-2026-08-01), and keeps sending it for that provider. Stale blocks
      are dropped and the turn goes on.
    • Accounts that aren't enforced send their requests unchanged.
  • PDF exports no longer fail with internal_error. Two problems in a row caused it:
    • A table cell, callout or quote taller than one page made reportlab raise LayoutError on
      every render attempt. Those rows now split across pages.
    • The renderer's last fallback, the plain exporter, then crashed on the report's in-page links
      (#executive-summary in the table of contents). Only absolute links (http, https,
      mailto) become clickable now, and the others stay as text.
    • The last fallback can no longer fail; at worst it keeps the words as plain paragraphs. If an
      export still cannot be rendered, POST /runs/{id}/exports answers 422 export_failed with the
      reason, instead of a bare 500.
  • Section tabs (Connections, Settings, Insights) no longer show a stray vertical scrollbar at
    their right edge.

Full Changelog: v0.1.2...v0.1.3