---
digest: >
  v0.16.0 closes CV13 Mirror Web Experience with the first coherent async and agent-shaped web operations substrate. The release moves Operations from request-bound actions into durable asynchronous runs with lifecycle events, result timelines, controlled command execution, cooperative cancellation, approval checkpoints, and a bounded read-only agent-run prototype. The browser now opens operation results in a full-width run console with polled output, completion handling, historical result navigation, and a slow demo operation for validating progress. True SSE/WebSocket streaming, unrestricted headless agent execution, arbitrary shell access, and broad mutation authority remain intentionally outside this release.
---

# v0.16.0 — Async Operations and Agentic Web Console

**Date:** 2026-05-27

## Highlights

- Converted web operations from synchronous `POST` execution into durable asynchronous operation runs.
- Added `operation_run_events` so queued, running, progress, completed, failed, cancelled, approval-required, and approved states can be inspected as evidence.
- Added a controlled command executor with fixed argv, `shell=False`, explicit cwd, sanitized environment, timeout, and bounded stdout/stderr capture.
- Added cooperative cancellation, approval checkpoints before selected persistent writes, and a read-only `agent-run-prototype` operation.
- Reworked the Operations UI into a full-width run console with polled output, result details, historical run navigation, completion messaging, and a bounded slow demo operation.

## Where We Started

v0.15.0 proved that Mirror Web could run small allowlisted maintenance operations safely. But those operations still lived inside the original request/response cycle. That was acceptable for runtime health, backups, and small repair flows, but it was the wrong shape for anything that takes time, asks for approval, emits evidence, or resembles agent work.

The next step was not to add an unconstrained agent. It was to give operations the body an agent would eventually need: durable runs, visible progress, cancellation, approval, evidence, and a console where the user can watch work unfold.

## What Changed

Operations now start as asynchronous runs. `POST /api/operations/run` validates the server-owned operation and parameters, creates a queued run, returns a run id, and lets a local worker execute outside the original web request. Runs can be fetched directly and remain visible in recent history.

Each run now records lifecycle evidence in `operation_run_events`. The event timeline preserves meaningful state transitions and progress messages. The UI uses that evidence to reopen historical results and to show current work in a run console instead of burying everything in audit cards.

The release also adds the first command-shaped execution boundary. `runtime-diagnose` runs through a controlled executor: fixed argv, no shell, explicit cwd, sanitized environment, timeout, and captured bounded output. This is not a terminal in the browser. It is a code-owned command capability behind the operation catalog.

Mutating work gained a pause point. Conversation journey repair apply requests now enter `approval_required` before persistent writes and continue only after an explicit approval action. Active runs can receive cancellation requests, with the current implementation remaining cooperative and evidence-based rather than forcibly killing Python threads.

Finally, the release adds a bounded `agent-run-prototype`. It accepts an intent and returns a read-only proposal with explicit boundaries through the same run, event, approval-capable, and evidence model. The Operations UI now opens a full-width execution console with tabs for polled console output and result details, temporary completion messaging, clickable historical run cards, and a `run-console-demo` operation for validating progress over time.

## Conscious Exclusions

This release does not introduce true SSE/WebSocket streaming. The console updates by polling durable run state. It also does not embed an unrestricted Pi or headless agent runtime, expose arbitrary shell commands, accept user-supplied argv/cwd/env, run raw SQL, perform git mutation, execute runtime updates, install extensions, or provide broad write approval.

The agent prototype is deliberately read-only and proposal-oriented. It proves the product shape and execution substrate without granting autonomous power over the local machine.

## What We Learned

The core design move was treating the agent as an extreme case of the operation model, not as a privileged bypass. Once that was clear, the sequence became coherent: async runs before events, events before command execution, command execution before cancellation and approvals, and only then an agent-shaped prototype.

The browser validation also clarified that evidence is not enough. Users need to feel the run as a visible execution surface. The final console polish changed Operations from an audit page into a place where work can be watched, inspected, and trusted.

## Next Horizon

The visible horizon is hardening the run substrate toward real streaming and richer agent execution. Future work can replace polling with SSE/WebSocket, make cancellation cooperate with longer-running subprocesses, and connect a real headless agent behind the same allowlisted capability boundary. The boundary remains the important part: agent work should request explicit Mirror capabilities, not raw access to the machine.
