v0.2.1

Oratorio v0.2.1

Oratorio v0.2.1 is a maintenance release focused on DotCraft SDK compatibility and managed-run reliability.

What's Changed

• Upgraded to DotCraft.Sdk 0.4.2.
• Unified Runtime Dynamic Tools and App Binding tools through the SDK registry for consistent schemas and dispatch.
• Fixed managed-run workspace handling while preserving isolated worktree execution.
• Improved realtime and auto-publish test stability.
• Migrate Oratorio tools to SDK v0.4.1 by @AkiKurisu in #9

Full Changelog: v0.2.0...v0.2.1

v0.2.0

Oratorio v0.2.0

Oratorio v0.2.0 is a feature release focused on deeper DotCraft integration and more resilient automated pull request and merge request reviews.

What's Changed

• Added DotCraft v2 App Binding support through DotCraft.Sdk 0.4.0, including principal-based authentication, automatic rotation of expiring credentials, and reliable connection and rebind handling.
• Published a protected Oratorio board surface to DotCraft. Agents can inspect board items and, with approval, create local tasks or queue review rounds through binding-scoped MCP tools.
• Upgraded the board, item, and review result cards to standard MCP Apps powered by the official AppBridge client.
• Moved run-scoped agent tools into the oratorio_run namespace, clearly separating review, implementation, follow-up, and discussion workflows from app-bound board capabilities.
• Added bounded automatic retries for recoverable PR/MR review failures with configurable exponential backoff. Compatible semantic and model failures can resume the preceding DotCraft thread, while infrastructure failures start a fresh thread.
• Prevented stale review retries from running after the source head changes, and preserved successfully submitted Review Drafts as the authoritative result to avoid duplicate submissions after late failures.
• Clarified that Runtime.MaxRunAttempts represents the maximum total number of attempts, including the initial run.

Pull Requests

• Added retry recovery for failed PR/MR reviews by @AkiKurisu in #6
• Integrated DotCraft v2 MCP features and refactored App Binding by @AkiKurisu in #8

Full Changelog: v0.1.7...v0.2.0

v0.1.7

Oratorio v0.1.7

Oratorio v0.1.7 is a patch release focused on simplifying GitHub configuration and making source sync recover cleanly from provider timeouts.

What's Changed

• Simplified GitHub integration by removing the legacy token-based authentication path and standardizing GitHub API access on GitHub App credentials and installation profiles.
• Fixed GitHub and GitLab source sync timeout handling so a canceled provider request marks the affected repository or project as failed instead of leaving the sync job stuck in running.
• Fixed source project labels so GitHub and GitLab projects display consistently across board filters, task cards, queue views, item details, and settings.

Full Changelog: v0.1.6...v0.1.7

v0.1.6

Oratorio v0.1.6

Oratorio v0.1.6 is a patch release for the server deployment CLI. It rebuilds the Linux CLI artifact as a musl-linked binary so install.sh works on more Linux hosts, including distributions whose glibc is older than the current GitHub Actions runner image.

What's Changed

• Build Linux CLI releases as musl-linked binaries for wider server compatibility
• Add CLI release smoke checks to prevent glibc-linked Linux artifacts

Full Changelog: v0.1.5...v0.1.6

v0.1.5

Oratorio v0.1.5

Oratorio v0.1.5 focuses on remote operation: Desktop can connect to a private headless backend, and the new CLI can provision and manage a Linux review stack for unattended PR review work.

Highlights

1. Remote backend mode for Desktop

   Oratorio Desktop can now connect to a configured remote backend URL instead of always starting a local server. Remote mode is health-checked, clearly shown in the desktop shell, and offers reconnect, change-address, and switch-to-local recovery paths.

2. CLI-managed server deployments

   The new oratorio CLI can bootstrap a dedicated Docker Compose review stack with oratorio server init, including the Oratorio backend, DotCraft AppServer, shared workspace, server configuration, and repository routing. It also includes operational commands such as doctor, status, logs, restart, upgrade, and add-repo.

3. More reliable AppServer timeout handling

   When an AppServer run times out after a DotCraft turn has started, Oratorio now requests a turn interrupt and keeps Oratorio's timeout decision authoritative, avoiding late completions being treated as successful runs.

What's Changed

• feat: add remote backend desktop mode by @AkiKurisu in #4
• Add remote deployment CLI and server deployment docs
• Handle AppServer timeouts by interrupting active turns

Full Changelog: v0.1.4...v0.1.5

v0.1.4

Oratorio v0.1.4

Oratorio v0.1.4 focuses on making the daily operator loop smoother: clearer board drag-and-drop, a calmer live run drawer, faster archiving for closed work, more reliable GitLab MR review publication, and simpler DotCraft SDK packaging.

Highlights

1. Smoother board movement

   The board now shows a dashed drop-slot indicator while dragging cards, and card spacing is measured in the way the drag-and-drop library expects. This makes lift, displacement, and drop behavior feel more stable instead of snapping around the insertion point.

2. Cleaner live run status in the drawer

   The task drawer now treats the active run as an Agent status section with a fixed-height live activity feed, round chip when relevant, and no duplicate progress bar. The latest thinking, writing, command, or tool activity stays readable without turning the drawer into a full DotCraft conversation surface.

3. Explicit archive action for closed work

   Approved and rejected tasks can now show Archive as a first-class drawer action, so completed work can be filed away without hunting through the overflow menu. The promoted action follows the same busy-state guard as the shell controls.

4. More resilient GitLab MR review publishing

   GitLab review drafts can now fall back to local git diff anchors when GitLab merge request diff reads fail. When fallback is possible, inline comments and suggestions can still publish; when it is not, Oratorio records a failed source write with a clear diagnostic instead of losing the failure path.

5. More accurate GitLab suggestion positions

   GitLab inline suggestions now preserve old/new line positions for context lines and normalize line endings during text matching. This improves publication of review suggestions, including auto-review publish flows, and adds coverage for warning, stale-head, disabled-write, and retry paths.

6. Simpler DotCraft SDK restore and packaging

   The server now consumes DotCraft.Sdk from NuGet, and Docker / Linux publish scripts no longer depend on a sibling DotCraft checkout. Desktop and server package versions are bumped to 0.1.4.

What's Changed

• feat: streamline drawer run status and add explicit archive by @AkiKurisu in #1
• Polish run-status and review-decision layout in drawer by @AkiKurisu in #2
• Add GitLab review diff fallback
• Fix GitLab review suggestion positions
• Enhance board drag-and-drop affordances
• Merge board refresh button into the source pull action
• Switch DotCraft SDK to NuGet package

New Contributors

• @AkiKurisu made their first contribution in #1

Full Changelog: v0.1.3...v0.1.4

v0.1.3

Oratorio v0.1.3

Oratorio v0.1.3 focuses on making review runs easier to follow, PR/MR worktrees more reliable, and follow-up work stay attached to the right source context.

Highlights

1. Live DotCraft activity in the drawer

   The task drawer now shows compact live activity while DotCraft is running, including thinking, writing, command, and tool states, with streamed text clipped into a readable one-line status.

2. More reliable PR/MR review worktrees

   Review analysis can now fetch provider-specific review head refs when the target commit is missing locally. GitHub PRs and GitLab MRs both get stable fetch behavior and clearer failure states.

3. Follow-up work keeps PR/MR context

   Follow-up tasks generated from review work can inherit the parent repository, branch, and head context when safe, so follow-up implementation continues from the original review target instead of losing routing.

4. Cleaner review surfaces

   The drawer result card is slimmer, drawer overflow issues are fixed, the header has a faster detail-page shortcut, and task detail now shows the full source body with flatter source activity.

5. App Binding UI bridge fix

   Embedded Oratorio cards now retain and reuse the DotCraft bridge token for refresh and open-link actions, making Interactive Tool UI cards more dependable.

What's Changed

• Show live DotCraft run activity in the task drawer
• Fetch review target refs for PR/MR analysis worktrees
• Inherit pull request route for follow-up tasks
• Slim the drawer Result card and add a detail-page shortcut
• Render full source body and flatten source activity in task detail
• Fix drawer status clipping and overflow behavior
• Fix Interactive Tool UI bridge token handling

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

v0.1.2

Oratorio v0.1.2

Oratorio v0.1.2 is a compact workflow polish release that makes the DotCraft pairing feel more native, keeps GitHub review resolution context attached to the original discussion, and tightens the desktop review surfaces around the operator’s next decision.

Highlights

1. Interactive Oratorio cards inside DotCraft

   Oratorio’s app-bound board tools now declare DotCraft Interactive Tool UI resources for board lists, item details, and review queueing. When DotCraft calls supported Oratorio tools, results can render as focused cards with refresh and action affordances instead of plain text-only tool output.

2. GitHub review resolutions now leave context

   When a published Oratorio review finding is resolved as fixed with a note, Oratorio can post a reply into the mapped GitHub review thread before resolving it. The reply includes the operator’s resolution reason and an Oratorio marker so retries do not duplicate the same resolution note.

3. Cleaner review drawer and task detail hierarchy

   The desktop drawer and detail page now emphasize the operator workflow: Problem, Result, Action, and Decision. Successful run process details are moved out of the default path, while Diagnostics remains available when a run is active, failed, cancelled, timed out, or explicitly opened.

4. Sharper metadata and decision layout

   Task detail labels and source metadata are more compact, the review stage stepper only shows Diagnostics when it is useful, and decision controls have a clearer hierarchy for request changes, approve, and reject.

Getting Started

1. Download the desktop installer or DMG from this release, or run from source with .\dev.bat.
2. Open Oratorio and connect the same project directory DotCraft already uses.
3. Add GitHub/GitLab sources if you want real issues, PRs, and MRs on the board.
4. Use DotCraft App Binding to let DotCraft inspect board items, open item cards, and queue review rounds through Oratorio.

Learn more in the documentation:

• Getting Started: https://dotharness.github.io/oratorio/getting-started
• Configuration: https://dotharness.github.io/oratorio/configuration
• GitHub Integration: https://dotharness.github.io/oratorio/github
• GitLab Integration: https://dotharness.github.io/oratorio/gitlab

What's Changed

• Add GitHub review-thread replies for resolution notes
• Add DotCraft Interactive Tool UI cards for board tools
• Move detail labels into metadata row

Full Changelog: v0.1.1...v0.1.2

v0.1.1

Oratorio v0.1.1

Oratorio v0.1.1 is a focused workflow release that makes the first public build easier to start, safer to operate, and more durable when Oratorio is paired with DotCraft. It adds a guided quick-start tour, active-run cancellation from the board, implementation follow-up for generated pull requests, native suggested-change publishing, a Docker server deployment path, and more resilient DotCraft App Binding.

Highlights

1. Guided quick-start tour

   New users now get an in-app walkthrough of the Oratorio loop: connect a project, optionally sync GitHub/GitLab work, create a local task, hand it to DotCraft, then review and decide. The tour can be replayed later from Settings.

2. Cancel active runs from the board

   Running or dispatching cards can now be dragged into the cancelled lane with an explicit confirmation step. This gives operators a clearer way to stop work without digging through detail views.

3. Implementation follow-up for generated pull requests

   When an Oratorio-generated pull request receives unresolved review findings or new human review comments, Oratorio can queue a bounded follow-up implementation round on the originating issue or task. Follow-up work reuses the existing PR branch and pushes additional commits to the same review target instead of opening a duplicate PR.

4. Native review suggestions

   Review drafts now use replacement-based suggestions: the agent supplies the exact current diff text and the replacement text, and Oratorio publishes valid findings as native suggested-change blocks. Invalid, ambiguous, or no-op suggestions are filtered before publishing.

5. More durable DotCraft App Binding

   Oratorio now remembers its DotCraft App Binding connection and re-announces the live loopback endpoint on startup, so DotCraft’s embedded Oratorio board can reconnect after the desktop backend moves ports. This release also adds Oratorio deep links for opening the board, tasks, and settings from trusted DotCraft surfaces.

6. Server deployment and cleaner settings

   v0.1.1 adds a Docker Compose deployment path for running Oratorio backend plus DotCraft AppServer continuously on a Linux host. Settings have also been reorganized around provider-centered GitHub and GitLab pages, with clearer source sync, routing, and credential status.

Getting Started

1. Download the desktop installer or DMG from this release, or run from source with .\dev.bat.
2. Open Oratorio and follow the quick-start tour, or replay it from Settings → General.
3. Connect the same project directory DotCraft already uses.
4. Add GitHub/GitLab sources if you want real issues, PRs, and MRs on the board.
5. For unattended backend usage, follow the Docker server deployment guide.

Learn more in the documentation:

• Getting Started: https://dotharness.github.io/oratorio/getting-started
• Configuration: https://dotharness.github.io/oratorio/configuration
• Server Deployment: https://dotharness.github.io/oratorio/server-deployment
• GitHub Integration: https://dotharness.github.io/oratorio/github
• GitLab Integration: https://dotharness.github.io/oratorio/gitlab

What's Changed

• Restructure source settings into provider-centric GitHub/GitLab pages
• Trim duplicated Agents bridge rows; spin settings refresh icon
• Implement replace-based review suggestions
• Restyle notices as stacked toasts; trim redundant ones
• Durable DotCraft App Binding: stable port + startup re-announce
• Add Oratorio board deep links and embedded surface
• Add Implementation Follow-up loop: re-implement issues from generated PR feedback
• Add server deployment: Docker stack + encrypted AppServer token
• Add drag-to-cancel run flow
• Add in-app onboarding quick-start tour
• Fix DotCraft ReadThread call for new turnLimit parameter
• Refine review draft summary formatting
• Add runtime context support for AppServer runs

Full Changelog: v0.1.0...v0.1.1

v0.1.0

Oratorio v0.1.0

Oratorio v0.1.0 is the first public release of Oratorio: an agent-addressable project board powered by DotCraft. It brings local tasks, GitHub/GitLab issues, and pull or merge requests into one durable workflow where you can assign work, track progress, review results, and deliver accepted changes back to your source platform.

Highlights

1. One board for every kind of work

   Local Tasks, GitHub/GitLab issues, PRs, and MRs can all live on the same board with the same lifecycle: New, Dispatching, Running, and Awaiting Review. You can see where each item stands and who needs to act next.

2. DotCraft-powered agent execution

   Oratorio owns the board, workflow state, drafts, and source writes. DotCraft handles the actual agent conversation, code changes, and execution details. Once a project is connected, Oratorio can dispatch work to a DotCraft agent that already understands that workspace.

3. Structured drafts before delivery

   Review results, implementation summaries, and follow-up tasks arrive as structured drafts instead of loose model output. You stay in control: inspect the summary, review inline suggestions, then approve, request changes, or reject the work.

4. GitHub and GitLab source support

   Oratorio can sync GitHub/GitLab issues, PRs, and MRs into the board. It also supports comment or note write-back, review draft publishing, implementation delivery, and generated GitHub PR or GitLab MR creation.

5. Local-first desktop workflow

   This release includes Oratorio Desktop, the local backend, Settings, diagnostics, the task drawer, and a complete local task flow. You can try the loop without connecting an external source: create a local task, dispatch it, let the agent work, and review the result.

Getting Started

1. Set up DotCraft in your target project first, and confirm the agent can respond in that workspace.
2. Download the Windows installer Oratorio-*.exe from this release, or run from source with .\dev.bat.
3. Open Oratorio Desktop and add the same project directory under Settings → Projects.
4. Create a local task, or connect GitHub/GitLab to sync real source items.
5. Dispatch the card to the agent, wait for it to reach Awaiting Review, then approve, request changes, or reject the result.

Learn more in the documentation:

• Getting Started: https://dotharness.github.io/oratorio/getting-started
• Configuration: https://dotharness.github.io/oratorio/configuration
• GitHub Integration: https://dotharness.github.io/oratorio/github
• GitLab Integration: https://dotharness.github.io/oratorio/gitlab
• Local Support Matrix: https://dotharness.github.io/oratorio/local-support

What's Changed

First public release of Oratorio.

Full Changelog: https://github.com/DotHarness/oratorio/commits/v0.1.0