v0.2.0

Jouzu v0.2.0

Jouzu v0.2.0 upgrades the embedded Pi runtime to 1.0.0, adds a signed Windows launcher, and adds flow-control, agent-workflow, and installation improvements.

Changes

• Use Pi 1.0.0 with Jouzu's existing tools, work dashboard, and regular/fullscreen interfaces. Saved settings, sessions, and background work are preserved.
• Keep GPT-6 Astra requests compatible with API-key and ChatGPT sign-in authentication, including prompt-cache settings.
• Prevent rejected tool-result metadata from bypassing TextGuard checks, including calls made through another tool.
• Recover interrupted flow-journal repairs without losing completed records or blocking session reopening.
• Store flow journals as journal and scalar records with crash recovery and compatibility coverage.
• Keep running agents visible in the dashboard and Workflow.
• Run child writers in parallel by default. Child concurrency and workspace sharing are settings.
• Scope agent file searches to relevant project paths.
• Resume resolved waits after abandoned input, and keep autonomous loops moving after task waits.
• Use bundled TypeBox and resolve native canvas dependencies when an npm installation fails.
• Prioritize Shisa in the CLI login provider menu.
• Install the Windows launcher from GitHub Releases with onboarding, a workspace screen, component management, diagnostics, logs, terminal access, Git Bash support, and recovery controls. It bundles Node, pnpm, PortableGit, and Windows Terminal.
• Keep the README focused on getting started, with detailed guides in the documentation index.

Update

npm install -g jouzu@0.2.0

Global npm installations also update through Jouzu's updater. Existing sessions and flow records need no manual conversion.

Limits

The embedded Pi runtime stays at 1.0.0. Pi 1.1.0 and 1.2.0 are deferred to a later release, and upstream stopped publishing the gitHead field that Jouzu pins releases by, so those versions cannot be adopted until that is resolved.

Three transitive dependency advisories are carried forward unchanged from v0.1.18: proxy-addr (critical), @modelcontextprotocol/sdk (high), and brace-expansion (high). npm audit reports them in the installed tree. The first two come from the bundled pi-webaio extension.

Live official Astra authentication and physical-terminal behavior in both display modes remain separate from fixture coverage.

The signed Windows launcher and Jouzu update recipes are published after the npm package. The launcher carries the Jouzu version, 0.2.0.

The Windows installer was rebuilt on 2026-10-16 from commit 78a4f6e because the first upload carried launcher version 0.3.7; the launcher is now versioned with Jouzu. The launcher code and the bundled Jouzu 0.2.0 are unchanged. A launcher installed from the first upload is not offered this build as an update: run jouzu-win-x64-v0.2.0-setup.exe again.

Jouzu launcher updates

Signed launcher update feed.

Jouzu update feed

Signed Jouzu update recipes.

v0.1.18

Jouzu v0.1.18

This release moves background jobs into the work dashboard and removes the
flow-control refusals that blocked tools on a turn without an owning work item.

Background jobs in the dashboard

Background jobs publish rows into the work dashboard instead of their own inline
panel. The producer claims the dashboard first and hides the native panel only
while the claim is held, so a job appears once and no job is hidden when the
claim is released.

The background-job manager is unchanged: /bg or Alt+Shift+H opens it, and
/bg watch <task> opens it focused on one job. Visibility preferences, manager
commands, and shortcuts keep working while the inline panel is suppressed. Loops
keep their own panels.

Work attribution is not a tool permission

Attribution records which user, task, or goal a turn is working on so waits,
background jobs, and derived work name a sensible origin. It does not grant or
withhold access to a tool. The flow-control refusals recorded in v0.1.17 are
resolved:

• A turn that carries no user or task work no longer refuses bg_task,
  schedule_prompt, a command the background extension would auto-background, or
  subagent launch and resume. Each falls back to the host work registered when
  the branch attached.
• A tool call that outlives the invocation holding its work is no longer refused
  as inactive.
• agent_wait reads its work field as attribution. Omit it or pass null to
  wait as the current task or session. A task can wait on any execution
  registered in the same branch, including another task's job.

Exact producer, handle, and execution identities are still required, so a wait
cannot observe the wrong job. An unregistered work identity is still refused.

Wait and task handoff fixes

• An exact live replaceToken replaces a wait after task attribution changes. A
  different live wait on the destination task is not displaced, and a finished or
  retired token is still refused.
• A paused task keeps its wait association, so resuming does not duplicate the
  wait and stopping the task cancels it.
• A completed task continuation restores its live creation origin, so the next
  task acquires execution authority without borrowing unrelated or stale work. A
  newer task selection is kept when an older completion returns.
• Work selection is rechecked after attempt reads, before unclassified fallback,
  and after automatic authority preparation, so a selected turn cannot migrate
  between attachments.
• A running loop is re-driven after a non-loop turn while user suppression is
  preserved, and a requested compaction's continuation registers host work so the
  continuation's tools run.

Execution and recovery guidance

The model guidance now states that a failed check or an unsuccessful first
attempt is an intermediate result, not completion. The agent is asked to make
authorized in-scope repairs, rerun the affected checks, keep the original
deliverables active across prerequisites, apply a steering instruction in the
same turn, and name the exact dependency when progress needs user input or an
unavailable external resource. Review-only and diagnosis-only requests keep their
stated boundary, and a dependency wait is not reported as task completion.

These are behavioral instructions, not a runtime guarantee. Prompt-delivery tests
verify that the text reaches main and child sessions; they do not measure whether
a model follows it on a coding task.

Installation and testing limits

Update with npm install -g jouzu@0.1.18 or Jouzu's updater.

Background-job dashboard rows are covered by fixtures and the bundled background
extension's lifecycle regressions, which run without a terminal. Live
background-job rendering in a terminal, loop rows, and macOS and Windows terminal
behavior are unqualified. The v0.1.17 dashboard coverage limits still apply to
expanded mode, the Settings route on short terminals, resizing, and
streaming-session animation.

The Windows installer preview remains unsigned, and clean Windows 10/11 installer
acceptance is separate from CLI qualification.

v0.1.17

Jouzu v0.1.17

This release adds a work dashboard above the prompt, automatic session and pane
labels, and a redrawn prompt frame.

Work dashboard

The dashboard reports work that is running, waiting, or finished. Each producer
gets a section opened by a divider carrying that section's counts and route:

── Agents · 1 done · !1 ────────────────────────────────────────────────────
  ! coder · unread result · 3m · Run the shell command `sleep 180` and then…
  ✔ reviewer · 4m
── Tasks · 1 running · 1 open · 2 done ─────────────────────────────────────
  ⠋ #6 Integrate dashboard rendering
  ○ #7 Qualify and document

• A row carries the state marker shared with the Session Line, the producer kind,
  the elapsed time, and a detail field, such as the current tool and its arguments
  for a running child.
• A finished child whose result the model has not read raises an attention row
  and a count. The row leaves the panel 30 seconds after it appears; the count
  stays until the result is read. Reading the result through subagent read
  clears it, delivery alone does not.
• Compact mode shows five lines and expanded mode ten, both capped at one third
  of terminal height. Settings holds the mode. Hiding the dashboard for a session
  does not change the saved mode, and a malformed policy file is reported and
  preserved rather than replaced.
• Rows stop animating while the session streams and while the dashboard is
  hidden. Elapsed time still refreshes.
• A section that runs out of room collapses to its divider, which keeps the
  counts and the route.

Child agents, tasks, and flow alerts use the dashboard. Background jobs and loops
keep their own panels: those producers publish rows only after confirming,
through a widget claim, that their native panel is hidden, and the pinned
versions do not implement that interface. No item is shown twice.

The height measurement reads Pi's interactive root order, and
scripts/check-pi-contract.mjs asserts that order, so a Pi upgrade fails
qualification instead of silently dropping the panel.

Session and pane labels

Automatic naming is on by default and runs after the first completed task turn,
using the selected provider/model. The naming route is fixed at the first
request, so switching the conversation model does not change it.

• /labels reports status and the command list without changing anything.
• /labels on and /labels off set the session switch. A saved off stays off
  when the session is reopened.
• /labels global on|off sets the persistent switch shared with Settings →
  Auto labels. Both the global and session switches must be on for naming.
• /labels pin and /labels auto protect or release the session name. /name
  also pins it.
• /labels pane pin and /labels pane auto protect or release the pane title.

A session name is at most 60 characters. A pane label is at most 12 lowercase
ASCII letters, digits, or hyphens. Session IDs, filenames, workflow lanes, and
tmux window names do not change. Stock tmux and Byobu status formats show an
owned label without renaming the window, and an existing title that Jouzu does
not own is left alone.

Global settings live in session-labels.json under Jouzu's configuration
directory; a malformed file disables naming and is not overwritten. Session
choices and pane pins are saved in the session transcript. See
Session labels.

Prompt frame

The prompt rail and the background fill that replaced it are gone. The frame
draws a single ❯ on the first prompt row and a blank gutter of the same width on
continuation rows, so selecting a wrapped prompt in the terminal picks up at most
one marker character instead of one per row. The editor renders at two columns
less than the frame width.

The model label uses the same teal as the prompt leader; the provider stays dim.
The thinking suffix turns teal with the model name.

Fixes

• Optional fields are declared nullable. Optional subagent fields and
  agent_wait arguments are declared nullable at registration, and an explicit
  null, an empty string, and the documented none sentinel for replaceToken
  are read as omission. A provider that requires every declared property no
  longer forces a model to supply a placeholder value for a field it meant to
  omit. Authority checks, required fields, and unknown-field rejection are
  unchanged.
• Subagent argument errors name the recovery. An operation-specific input
  that does not fit the operation is refused with the field and the recovery,
  and launch context is ignored on operations other than launch and resume.
• A task package source mismatch explains how to recover. When the pinned
  task package's source hash differs, the diagnostic says to preserve local edits
  and reinstall the pinned package. The overwrite guard is unchanged.
• Task continuations keep Jouzu's flow ownership while adopting upstream
  @lhl/pi-tasks a07c749. Continuation identity uses custom-message metadata
  rather than prompt text, cancellation context survives a thrown abort, the tree
  reconnection anchor is repaired, and an upgrade from an older pin is refused
  rather than applied as a lifecycle-only change.
• Native provider requests are no longer capped at 8 MiB. A session history
  carrying images is sent whole. Explicit byte budgets and automatic-result
  limits are unchanged.
• Astra diagnoses and repairs by default when you point out a problem, and
  keeps its scope for diagnosis-only and review-only requests.
• Dashboard counts and polling. The Session Line child count counts queued
  and running children from the child source only, disabled flow control reports
  nothing pending so earlier alerts clear, idle flow state is polled every five
  seconds instead of every second, and source polls coalesce during an active
  read.

Installation and testing limits

Update with npm install -g jouzu@0.1.17 or Jouzu's updater.

Dashboard coverage uses fixtures and one live qualification in tmux at 137x67.
Expanded mode, the Settings route on short terminals, resizing, streaming-session
animation, the loop producer, voice input, a multiline editor, and Windows or
macOS terminal behavior are unqualified. Session-label coverage uses fixtures and
live tmux windows and does not establish naming quality for every repository or
query shape.

Two flow-control refusals are recorded and unresolved in this release. Background
and scheduled tools require an owning work item, so a turn that carries none, such
as a scheduled-prompt wake turn or a continuation whose work already completed,
refuses a command the background extension would auto-background, bg_task, and
schedule_prompt; the next host turn accepts them. A tool call that outlives the
invocation holding its work is refused as inactive and succeeds when reissued.

The Windows installer preview remains unsigned, and clean Windows 10/11 installer
acceptance is separate from CLI qualification.

v0.1.16

Jouzu v0.1.16

This release fixes opening a session after upgrading from v0.1.15.

Flow registry recovery

v0.1.15 shortened the identity digest used as a path component, to keep a child agent's nested flow lock inside the path length SQLite can open on Windows. That digest is the directory key for flow storage, so the change also moved each session's flow registry and branch storage. The transcript kept its own markers, which then named a registry the code no longer looked for, and opening the session failed:

Jouzu failed: Active Pi branch differs from its flow registry.

Four changes make an upgrade safe:

• Flow storage written under the previous digest is adopted when the shortened key holds nothing, so an upgrading session keeps its registry and branch history.
• A flow session whose file records the directory it was written at is accepted there. Moving the directory does not rewrite the session file, and rejecting its original path stopped the session from opening even after the registry was recovered.
• A registry that still cannot be reconciled with the transcript is rebuilt from the transcript's verified marker instead of blocking the load. The transcript is the durable record and the registry is derived from it. The dropped state is saved beside the live one and reported in the session, so nothing is discarded silently.
• Rebuilding a branch that came from a navigation no longer repeats on every open. A rebuilt record holds no navigation transition of its own, so comparing it against the transition still recorded in the transcript rebuilt the registry again each time.

A session that already failed to open needs no manual repair. The registry its failed attempt created is the case the rebuild handles, and a directory an earlier attempt already moved is accepted too.

Installation and testing limits

Update with npm install -g jouzu@0.1.16 or Jouzu's updater.

Flow recovery coverage uses fixture registries, transcripts, and session files. It does not establish behavior for every registry shape an earlier version could have written, and it does not cover a moved state root: if the directory holding Jouzu's state changes, a flow session file that records the old location is still rejected. The subagent state root uses the same digest without an adoption path, so upgrading can orphan a subagent run's stored state; that never blocks opening a session.

The Windows installer preview remains unsigned, and clean Windows 10/11 installer acceptance is separate from CLI qualification.

v0.1.15

Jouzu v0.1.15

This release gives subagents their own context, resources, and visibility, makes long sessions durable, and upgrades the embedded Pi runtime to 0.87.1.

Subagent children

A subagent launch chooses its context: fresh starts independent, fork shares the parent conversation as references, and splice shares selected entries. A child can read bounded parent context without inheriting it. Snapshots are retained across resume, and review roles default to independent context.

Children load bundled extensions, discovered skills, active profile guidance, and TextGuard. Their work joins task, background, scheduled, and compaction continuations, with cancellation and total turn limits unchanged.

The dashboard above the editor shows child activity, hides and shows on demand, and routes to Runs. Run selection survives dashboard updates.

Parent and child session traces are written as bounded, filterable JSONL with resumable byte cursors. Tracing is read-only: it does not change completion receipts or saved sessions.

Scheduling stays under parent ownership. The scheduler is excluded from every child role, and a saved child schedule is disabled before resume restores automation. Invalid child schedule state is preserved under a quarantine name with a persistent warning instead of blocking resume.

Child state paths stay inside the length SQLite can open on Windows, where a child's nested flow lock previously exceeded the limit and no subagent could start. Identity digests used as path components are 128-bit; the directory layout is otherwise unchanged.

See Agents and runs.

Long sessions

Background execution state and retained results move into a versioned canonical sidecar with bounded progress persistence, migration markers, fail-closed recovery, and session-transition handling. The whole-transcript history capacity lockout is removed, and long sessions use record-bounded streaming and writer-aware indexed verification.

Flow control and continuations

A command's own send counts as the user's instruction, so /goal resume and similar sends are admitted where typed input is instead of being held with no visible effect. A refused user submission and a reopened session's recovery hold are reported once per message and reason, so a hold is never visible only to someone who runs /flow.

An undispatched continuation stays retained across reattachment and is issued again at the next release boundary; the superseded record is retired so it is not issued at every later open. Each inherited continuation is issued on its own during replay, so a record that cannot be sent or retired no longer stops the records behind it.

A multiloop lane whose continuation was never submitted is driven again when its flow gate clears, instead of waiting for an agent_end that never fires on an idle session. A bare /multiloop resume selects the attached run, or the only active or paused run, instead of handing the choice to the agent.

Tool calls on strict providers

Some providers require every declared property, which leaves a model no way to omit an optional field. Optional agent_wait fields now read the placeholders those providers force — explicit null, an empty string, and the documented none sentinel for replaceToken — as the omission they stand for. Required fields, unknown-field rejection, and placeholder-token refusal are unchanged.

A redeclare refusal names the live token to copy, so a caller whose context no longer holds the earlier receipt can comply. An inapplicable checkAfter is dropped rather than refused, and a token belonging to another work is distinguished from one that names no live wait. A rejection survives history pruning.

A declined optional argument no longer reaches a tool as a supplied value, so an empty-string placeholder cannot act as a chosen role, owner, or dedupe key.

Runtime and skills

The embedded Pi runtime moves from 0.86.1 to 0.87.1. Session projections, queue admission, and source recovery keep their behavior across Pi's new provider-context model; the review and its evidence are in Pi update review.

Core installs four optional skills, adding jouzu-anti-slop beside jouzu-clear-writing. It is a filler-removal checklist for existing prose that keeps facts, qualifiers, and exact technical content.

The output safety reserve scales to the larger of 4096 tokens or five percent of estimated input, preserving caller caps and overflow recovery.

Installation and testing limits

Update with npm install -g jouzu@0.1.15 or Jouzu's updater. Restart running sessions to pick up the changed wait schema and argument normalization.

Subagent, dashboard, and trace coverage uses assembled sessions and fixtures. It does not establish live-model delegation quality or trace usefulness on a real workload. Long-session storage tests cover migration, injected faults, and a bounded large-session corpus, not every filesystem. Wait-tool compatibility tests cover the all-required argument shape and nullable forms; a provider that transforms the registered schema outside the session can present a shape these tests do not reproduce.

The Windows installer preview remains unsigned, and clean Windows 10/11 installer acceptance is separate from CLI qualification.

v0.1.14

Jouzu v0.1.14

This release improves background-work coordination, Shisa account setup, runtime diagnostics, and bug reporting. It also updates the embedded Pi runtime and makes prompt-cache warming opt-in.

Background work and recovery

Subagent launches and scheduled prompts return receipts that agent_wait can use without polling. Subagent waits track one exact run. Schedule waits track the first trigger of a newly created schedule, not completion of its work. Tasks can wait on background jobs started by their parent turn without taking ownership of those jobs.

Completed execution takes precedence over a health check when a job finishes during wait registration. Unreadable producer state keeps automatic work held while allowing /flow inspection and recovery. /about remains available during a hold without releasing it.

Subagent session and workspace locks last for the lifetime of the owning process. Exiting or killing that process releases the locks; suspending it keeps them held. Storage failures are reported rather than leaving work queued indefinitely. Close other Jouzu processes before upgrading: versions before v0.1.14 do not share these process-held locks.

Empty request-history records are bounded during continuous tool runs. Cancelled tool results remain intact when cancellation occurred before content scanning. Empty sessions are omitted from the resume list without preventing explicit session recovery.

Work summaries and runtime identity

Goals and loops leave a summary card when they finish, stop, or pause. Cards show the outcome, objective, elapsed time, activity counters, and resume command where applicable. Measured runs also show the metric and acceptance result. Background completion receipts include finish times and durations.

/about shows the running and installed Jouzu builds, Pi version, and startup time. /session includes a compact runtime line. If the installed build differs from the running build, restart Jouzu to load it.

Shisa account setup

First launch explains access to open coding models such as Qwen and GLM, the $10 signup credit offer, and the additional $25 offer for attaching a credit card. Connecting is optional; /login shisa remains available later.

Settings / Catalogs includes a Shisa AI account row with in-panel browser approval and confirmed sign-out. A saved sign-in shows its organization; an environment key identifies SHISA_API_KEY without borrowing a saved account's identity. The row scrolls with the catalog pane so expanded catalog offerings can use the space.

Signing in refreshes authenticated catalogs and model availability in the same session. If credentials were saved but server confirmation failed or was interrupted, Settings retains the warning and asks you to sign in again. Signup offers are not shown as an account balance.

Bug reporting

/bug prepares an editable issue draft with the reported problem, reproduction details, and minimal runtime information. It always provides the Jouzu issue form. When an authenticated GitHub CLI account is verified, it also offers to submit as that user after explicit confirmation. Keeping the draft is the default.

Reports collect no transcript or attachments automatically, and drafting makes no model request. Review the title and body before posting: GitHub issues are public. An uncertain submission result keeps the draft and asks you to check existing issues before retrying. See Report a Jouzu bug.

Runtime and cache settings

The embedded Pi runtime is updated from 0.85.1 to 0.86.1. System instructions survive cancelled user input, compacted summaries are checked by message role, and native clipboard helpers ship with the runtime.

Built-in OpenAI requests remain compatible with flow control. Astra retains its reasoning settings and explicit cache-disable behavior, and /reload refreshes added, removed, and changed OpenAI model entries without a restart.

File tools preserve Unicode spaces in paths. Writes and edits do not redirect a requested full-width-space filename to an existing ASCII-space sibling. Reads prefer an existing exact path before trying pasted-space compatibility fallbacks.

Prompt-cache warming defaults to off. Explicit streaming and idle modes remain available in /settings; ordinary provider-side prompt caching is unaffected. Refresh requests have separate admission checks, child refresh usage is included in parent totals, and new or resumed children inherit the global warming setting. See Prompt-cache warming for provider-dependent behavior and limitations.

Model-picker history is limited to 512 projects and 16 MiB while preserving explicit defaults, favorites, and reasoning preferences. Content scanning uses the embedded TextGuard scanner; the optional Python comparison-scanner flags from v0.1.13 are removed.

Installation and testing limits

Update with npm install -g jouzu@0.1.14 or Jouzu's updater. Windows setup requirements remain documented in Windows setup.

Account-flow tests use isolated loopback services to verify credential persistence, catalog activation, and model authentication in one session; they do not establish live signup or inference behavior. Cache refresh lifecycle tests do not establish provider cache retention or savings. The Windows installer preview remains unsigned, and clean Windows 10/11 installer acceptance is separate from CLI qualification.

v0.1.13

Jouzu v0.1.13

This release adds session-scoped flow control, durable conversation-branch reactivation, bounded flow retention, and clearer Windows installation failures.

Flow control off and on

/flow off takes flow control out of the circuit for the session: what you send runs as an ordinary turn, and jobs, tasks, and loops deliver their own notifications instead of flow control composing them. /flow on puts it back. Both keep the session, its records, and every running job. Producer tools and their own delivery paths keep working while it is off, and /flow runtime still reports the running and installed versions.

While flow control is off, every flow tool refuses with the same message and /flow reports the state. /flow reset turns it off and on in order.

Conversation branches

Returning to where you last left a recent conversation branch resumes its unfinished work, including a wait on a background job, and a retained late result stays readable on that branch. Restart rebinds the session to the branch that owns the newest transcript entry. A rewind inside the active branch still starts a new branch with nothing inherited, and an interrupted transition recovers by rebinding to the branch that owns the leaf instead of holding the session.

Branch records are bounded by a byte budget rather than a record count, so a session with many small branches stays inside the same limit. An automated turn that no producer owns now receives host work, so its tools run instead of being refused.

Flow retention and indexing

Completed, cancelled, and archived flow work retires into indexed history: submissions, native requests and their retry chains, cancellations, waits, results, and the identities that read them. Retained evidence stays readable after retirement, and routine reads query exact records instead of scanning bounded windows, so a long session no longer accumulates unbounded active records or exhausts a lifetime quota with repeated completed work.

An explicitly reset native request that never reached an outcome is retired, a completed retry chain retires as one group, and cancellation checks stay in force after a request is retired. Producer rounds survive nonprefix retirement, and retirement authorization is rechecked before the ledger commits.

Browser tools

The Camoufox browser stops after five minutes without a tff-fetch_url or tff-search_web call, and the next call relaunches it. Set JOUZU_CAMOUFOX_IDLE_STOP_MS to a whole number of milliseconds from 1000 to 2147483647 to change the delay, or 0 to keep the browser loaded until the session ends. An invalid value keeps the browser tools from loading until it is fixed. Stopping releases the browser process; runtime modules already loaded in the session stay in memory.

Installation

Update an npm installation with npm install -g jouzu, or use Jouzu's automatic updater. A failed Windows installation now names the stage that failed, the launcher error, and the automatic setup log path, and each activation check allows 90 seconds instead of 30. This release also provides an unsigned Windows x64 installer preview. See Windows installer preview for installation, rollback, and the /LOG flag for diagnosing activation failures.

Testing limits

Flow retention and indexing changes are covered by component tests with controlled fixtures; long-session behavior under live provider traffic is not measured. Conversation-branch recovery is verified with controlled transcripts, not live-provider recovery. Native Windows installer acceptance covers Windows Server 2025 x64; clean Windows 10/11 testing remains pending, and the installer is unsigned.

v0.1.12

Jouzu v0.1.12

This release improves subagent controls and handoffs, preserves automatic work across conversation-tree navigation, and fixes first-use catalog model selection.

Subagents and delegation

Use /workflow on, /workflow off, or /workflow toggle to control subagents for the session. The Workflow view also has an On/Off control. Turning subagents off stops running and queued children while preserving files already changed and retained results. The setting survives reload and session resume.

Child agents use the model configured for their role. Only you can change that selection in Workflow; the agent-facing tool rejects model overrides. New launches use the configured model, and resumed runs keep their saved model and definition. A role you configure as same uses the parent session's model at launch.

Core and JA include jouzu-delegation, a skill for writing assignments and follow-ups. Every parent model also receives a short checklist while subagents are enabled: one objective, verified context, constraints, acceptance checks, and an explicit stopping point. The guidance calls for complete sentences and distinguishes provider, tool, instruction, and implementation failures. It does not guarantee that models follow the instructions or improve their performance.

Workflow and subagent summaries show friendly model names. Output previews summarize activity and display readable events. Unread completion results remain deliverable after tree navigation; a complete terminal read suppresses another completion turn only when flow control verifies that the output reached the model.

See Agents and runs.

Goals, tasks, and conversation history

/goal resume directly selects a sole saved goal. When there are multiple goals or the target is unclear, the agent uses the conversation and saved goals to resolve it. Resume requests follow normal flow-controlled delivery. Tasks and multiloops reconnect when you navigate the conversation tree. Archiving a multiloop now succeeds on Windows.

With flow control enabled, Jouzu prepares tool history before model admission. A tool call whose result is missing from the selected branch gets an explicit unknown-outcome placeholder. This covers ordinary turns, automatic turns, and built-in model-generated summaries. It does not rerun the tool, copy a result from another branch, or change the saved conversation. Ambiguous or mismatched tool results still block the request. Rewinding history does not undo tool side effects.

The Session Line shows goal, loop, and child-agent activity, with an animated marker while work runs and lifecycle counts. Workspace, Git, runtime, and context information remain in the Status Bar.

Catalog startup

An enabled catalog with an available credential but no activated revision refreshes before initial model selection, with an eight-second budget and a Fetching model catalog… notice. Existing catalogs keep serving cached models while refreshing in the background. Failed refreshes and malformed catalog configuration do not prevent startup.

Installation

Update an npm installation with npm install -g jouzu, or use Jouzu's automatic updater. This release also provides an unsigned Windows x64 installer preview. See Windows installer preview for installation, rollback, and the /LOG flag for diagnosing activation failures.

Testing limits

Automated tests cover role-model restrictions, skill delivery, notification receipts, tree navigation, history preparation, and catalog startup. They do not measure delegation quality or establish live-provider recovery behavior. Windows installer acceptance covers Windows Server 2025 x64; clean Windows 10/11 testing remains pending. The installer is unsigned.