Merge branch 'main' into feat/verifier-gated-router

Author: anandgupta42

.github/workflows/dispatch-code-review.yml

@@ -0,0 +1,58 @@
+name: Dispatch Code Review
+
+# Lightweight relay — on PR ready (not every push), dispatches the centralized
+# ocr/Gemini review in AltimateAI/altimate-qa (code-review.yml).
+#
+# Gated loop: review fires only when a PR is opened non-draft or marked Ready for
+# review. `synchronize` is intentionally omitted so pushes don't re-trigger.
+# altimate-qa flips the PR back to draft on CRITICAL findings, so re-review happens
+# on the next ready_for_review after the author addresses them.
+#
+# Token: reuses the org-level AUTOPILOT_DISPATCH_TOKEN (same one dbt-integration /
+# vscode-dbt-power-user use to dispatch to altimate-qa). If that org secret is not
+# visible to this repo, the step skips cleanly — ask an admin to extend its repo
+# visibility (no new token needs to be created).
+
+on:
+  pull_request:
+    types: [opened, ready_for_review]
+    branches: [main]
+
+concurrency:
+  group: dispatch-code-review-${{ github.event.pull_request.number }}
+  cancel-in-progress: true
+
+permissions:
+  contents: read
+
+jobs:
+  dispatch:
+    name: Notify altimate-qa
+    runs-on: ubuntu-latest
+    if: github.event.pull_request.draft == false
+    timeout-minutes: 2
+    steps:
+      - name: Dispatch to centralized code review
+        env:
+          GH_TOKEN: ${{ secrets.AUTOPILOT_DISPATCH_TOKEN }}
+          PR_NUMBER: ${{ github.event.pull_request.number }}
+          PR_HEAD_REF: ${{ github.event.pull_request.head.ref }}
+          PR_HEAD_SHA: ${{ github.event.pull_request.head.sha }}
+          PR_AUTHOR: ${{ github.event.pull_request.user.login }}
+          PR_TITLE: ${{ github.event.pull_request.title }}
+        run: |
+          if [ -z "$GH_TOKEN" ]; then
+            echo "AUTOPILOT_DISPATCH_TOKEN not available to altimate-code — skipping centralized dispatch."
+            echo "Ask an org admin to extend that org secret's visibility to AltimateAI/altimate-code."
+            exit 0
+          fi
+          gh api repos/AltimateAI/altimate-qa/dispatches \
+            --method POST \
+            -f event_type=code-review \
+            -f "client_payload[repo]=AltimateAI/altimate-code" \
+            -f "client_payload[pr_number]=$PR_NUMBER" \
+            -f "client_payload[head_ref]=$PR_HEAD_REF" \
+            -f "client_payload[head_sha]=$PR_HEAD_SHA" \
+            -f "client_payload[author]=$PR_AUTHOR" \
+            -f "client_payload[title]=$PR_TITLE"
+          echo "Dispatched code review for PR #$PR_NUMBER"

CHANGELOG.md

@@ -5,6 +5,12 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.8.6] - 2026-06-08
+
+### Added
+
+- **Session traces now work in headless `serve` mode — your VS Code "Altimate Code" chat sessions show up in `/traces` just like terminal sessions.** Sessions driven over `altimate serve` (the server behind the VS Code chat panel) had no TUI worker observing the event stream, so trace files were never written and `/traces` was always empty after a chat. The per-session tracing logic is now a shared `TraceConsumer` wired into both the TUI worker and `serve`, so IDE chat sessions produce the same incremental `ses_<id>.json` files — full multi-turn waterfall, recorded prompt, tool-call log, cost, and timing. `serve` now registers `SIGINT`/`SIGTERM`/`beforeExit` handlers that drain and finalize in-flight traces on shutdown (so a serve trace ends as `completed`, not `running`, and the process exits with signal-conventional codes), finalizes a session as soon as it is deleted, and finalizes all open sessions concurrently so a busy server isn't cut off mid-write by a container shutdown grace period. (#886)
+
 ## [0.8.5] - 2026-06-06
 
 ### Fixed

docs/docs/configure/trace.md

@@ -325,7 +325,7 @@ Traces are designed to survive process crashes:
 
 2. **Incremental snapshots.** After every tool call and generation completion, the trace file is updated atomically (write to temp file, then rename). The file on disk always contains a valid, complete JSON document.
 
-3. **Crash handlers.** The `run` command registers `SIGINT`/`SIGTERM`/`beforeExit` handlers that flush the trace synchronously with a `"crashed"` status.
+3. **Crash handlers.** The `run` and `serve` commands register `SIGINT`/`SIGTERM`/`beforeExit` handlers that finalize in-flight traces on shutdown. (`run` flushes synchronously with a `"crashed"` status; `serve` drains and finalizes its active sessions.)
 
 4. **Status indicators.** Trace status tells you exactly what happened:
 

docs/docs/usage/ide.md

@@ -39,6 +39,7 @@ This opens the Altimate Code chat panel where you can interact with altimate age
 - **Tool call results inline** — SQL analysis, lineage, dbt operations, and more displayed in the chat
 - **Agent mode switching** — switch between Builder (full read/write), Analyst (read-only), and Plan (minimal access) modes from the command palette
 - **100+ data engineering tools** — SQL validation, query optimization, column lineage, dbt model generation, FinOps analysis, schema exploration, and more
+- **Session tracing** — every chat session is recorded as a trace file (the IDE panel runs `altimate-code serve` under the hood, which now writes traces just like the terminal). Inspect them with `altimate-code trace list` / `altimate-code trace view <id>`. See [Traces](../configure/trace.md).
 
 ## Configuration
 

packages/opencode/src/altimate/observability/trace-consumer.ts

@@ -309,11 +309,17 @@ export class TraceConsumer {
     this.sessionUserMsgIds.clear()
   }
 
-  /** End all in-flight traces and wait for them. Used on shutdown. */
+  /**
+   * End all in-flight traces and wait for them. Used on shutdown.
+   * Finalizes sessions concurrently rather than sequentially: each
+   * `endTrace()` can wait on an HttpExporter (5s timeout each), so a sequential
+   * loop over N sessions could take N×5s and blow past a container's shutdown
+   * grace period (e.g. k8s `terminationGracePeriodSeconds`) and be SIGKILL'd
+   * mid-write. Concurrent finalization bounds the wall-clock to the slowest
+   * single trace.
+   */
   async flush() {
-    for (const [, trace] of this.sessionTraces) {
-      await trace.endTrace().catch(() => {})
-    }
+    await Promise.allSettled([...this.sessionTraces.values()].map((trace) => trace.endTrace().catch(() => {})))
     this.sessionTraces.clear()
     this.sessionUserMsgIds.clear()
   }
@@ -410,7 +416,11 @@ export function subscribeTraceConsumer(
         }
       } catch (err) {
         if (!signal.aborted) {
-          Log.Default.warn("[tracing] trace event stream disconnected, reconnecting", {
+          // debug, not warn: this is the in-process event stream, reconnect is
+          // automatic and not user-actionable. Logging at warn on every backoff
+          // iteration (up to ~7 in the first 8s of an outage) would spike log
+          // aggregators for something the operator can't act on.
+          Log.Default.debug("[tracing] trace event stream ended, reconnecting", {
             error: err instanceof Error ? err.message : String(err),
           })
         }

packages/opencode/src/cli/cmd/serve.ts

@@ -29,6 +29,10 @@ export const ServeCommand = cmd({
     // serve mode. Subscribe the shared trace consumer to the in-process
     // event stream so serve sessions produce the same trace files as the
     // terminal entrypoints.
+    //
+    // `directory` is the SDK workspace/routing context, NOT the trace output
+    // location — trace files always go to the configured tracing dir
+    // (`tracing.dir`, default ~/.local/share/altimate-code/traces/).
     const traceSub = subscribeTraceConsumer({ directory: process.cwd() })
 
     // Finalize traces on shutdown. `serve` blocks forever on the promise below

packages/opencode/test/skill/release-v0.8.5-adversarial.test.ts

@@ -228,10 +228,15 @@ describe("v0.8.5 adversarial - composite action", () => {
   })
 
   test("docs point at the action patch, not the already-published broken tag", async () => {
+    // This is the 0.8.5 release gate: it asserts the 0.8.5 docs reference the
+    // patched action tag (@v0.8.5) and NOT the already-published broken @v0.8.4.
+    // It must stay pinned to the constant "0.8.5" — earlier this derived `version`
+    // from the changelog's TOP entry, which later releases (0.8.6+) move, breaking
+    // the gate on every subsequent release. Assert the 0.8.5 entry EXISTS in the
+    // changelog rather than that it is the latest.
+    const version = "0.8.5"
     const changelog = await fs.readFile(path.join(repoRoot, "CHANGELOG.md"), "utf8")
-    // Match whether the entry is still "Unreleased" or has been date-stamped at release.
-    const version = changelog.match(/^## \[(\d+\.\d+\.\d+)\] - (?:Unreleased|\d{4}-\d{2}-\d{2})$/m)?.[1]
-    expect(version).toBe("0.8.5")
+    expect(changelog).toContain(`## [${version}]`)
 
     for (const relative of ["docs/docs/usage/dbt-pr-review.md", "github/review/examples/altimate-ingestion.yml"]) {
       const content = await fs.readFile(path.join(repoRoot, relative), "utf8")