runa/CHANGELOG.md

# Changelog

All notable changes to this project will be documented in this file.

## [Unreleased]

### Added

- Portable structured actor values: null, booleans, signed 64-bit integers,
  strings, lists, records, and distinct NanoID actor references.
- JSON state/message literals in the REPL, including named `$actor` references,
  `$record` escaping, and actor-reference completion inside nested values.
- Value conversion limits and tests for nested-state isolation, copied sends,
  cyclic/unsupported Rune output, and all-or-nothing structured transitions.
- Reusable loopback TCP protocol client with bounded messages, correlation
  checks, explicit connection failures, and no automatic request retries.
- Multi-client and reconnect tests proving that actors remain in the
  server-owned image after development clients disconnect.
- Typed, instruction-sliced Rune invocations with preserved async execution,
  wake-driven resumption, and cancellation tests.
- Minimal single-worker actor runtime with bounded FIFO mailboxes, private
  integer state, structured messages, immutable implementation IDs, explicit
  message effects, inspection, lifecycle events, stop, and restart.
- Runnable two-actor counter demonstration and tests for runaway fairness,
  pending-message isolation, failures, backpressure, and all-or-nothing effects.
- Interactive local CLI for spawning actors, sending messages, advancing ticks,
  inspecting actors/events, and stopping/restarting actors.
- Versioned BLAKE3 source and implementation identities, original-source
  retention, a Rune compile-input fingerprint, and an in-memory compiled
  artifact cache.
- In-memory named behavior revisions with optimistic publish checks, immutable
  history, rollback revisions, and runtime installation at idle handler
  boundaries.
- CLI commands for named behavior publishing, history, rollback, and
  installation, plus `mise run run` to launch the local executable.
- Cooperative actor pause/resume between scheduler ticks, preserving active
  invocations and emitting lifecycle events.
- Explicit safe-point state migration during implementation installation, with
  atomic failure behavior and migration events.
- Explicit invocation cancellation that requeues the reserved message for
  retry, exposed in the CLI and documented with native side-effect caveats.
- Active actor execution telemetry in snapshots: completed VM steps,
  instruction pointer, and call-frame depth.
- Trusted in-process `runa-image-api` service boundary for code and actor
  operations, now used by the local CLI.
- Versioned, transport-neutral `runa-protocol` request, response, and event
  DTOs with serde support and request validation.
- Transport-neutral `runa-server` dispatcher routing protocol commands through
  the image API with typed replies and error codes.
- Local JSON-lines stdio transport for the protocol dispatcher, with a 1 MiB
  request limit and explicit malformed-input failures.
- Reusable local child-process client for issuing correlated protocol requests
  and shutting down the server process cleanly.
- Loopback-only TCP JSON-lines endpoint for local development clients, sharing
  the same live image as stdio and limiting concurrent clients.
- Execution-model decision and Phase 1 runtime documentation.
- Lifecycle tests proving failed-message retry from committed state and
  stop/restart preservation of reserved-first FIFO order.
- NanoID-based public actor references, explicit behavior-and-state spawning,
  named REPL actor bindings, tab completion, and command history navigation.
- NanoID-based public actor references, explicit behavior-and-state spawning,
  named REPL actor bindings, tab completion, and command history navigation.

- Runnable Phase 0 experiment pinned to Rune 0.14.2, covering script execution,
  native calls, async suspension, instruction budgets, frame inspection,
  stepping, and compiled-code sharing across isolated VMs and threads.
- Tests for feasibility results, invalid source, runtime errors, independent
  stacks, and cancellation by dropping suspended execution.
- Rune feasibility report with measured timings, shallow object sizes,
  limitations, and a proposed Phase 1 execution model.

- Initial Rust workspace with the `runa` binary and a `runa-rune` library
  scaffold for Phase 0. Rune integration is not implemented yet.
- Project README and agent guidelines.
- Base directories for architectural decisions, default image scripts,
  development automation, examples, system tests, and the VS Code extension.
- Mise tasks for formatting, Clippy linting, workspace tests, and sequential
  pre-commit validation.
- Tombi, rustfmt, and Clippy configurations.

### Changed

- Protocol v3 and Rune's two-argument `handle(state, message)` replace the
  temporary integer-only state and kind/value/target_ref message envelope.
  Returned sends now contain `(actor_reference, message)` pairs; migrations,
  snapshots, and events preserve structured values.
- The REPL now connects to the localhost server rather than embedding its own
  image. Start the server first; `--connect` selects a loopback endpoint.
- TCP server startup publishes the bundled counter behavior once; connecting
  or disconnecting clients does not reset behavior revisions or actor state.
- Interactive CLI commands now use the versioned protocol dispatcher instead
  of calling the image API directly.
- Protocol version 2 replaces numeric actor IDs with NanoID actor references
  and adds optional target references for message effects.
- Protocol version 2 replaces numeric actor IDs with NanoID actor references
  and adds optional target references for message effects.
- Actor implementation IDs now identify compiled source/configuration content
  rather than using sequential process-local numbers.
- Expanded the architecture specification with crate ownership and dependency
  boundaries, and moved it to `docs/architecture.md`.
- Required agents to pass `mise run pre-commit` before every commit and document
  user-visible changes in this changelog.