agent-dealer 1.2.3 → 1.2.5

package/bundle/server/dist/coordinator/worktree-cwd-guard.js

@@ -0,0 +1,48 @@
+// packages/server/src/coordinator/worktree-cwd-guard.ts
+//
+// NOT-273: defensive guard on the developer/reviewer spawn path. The worktree
+// resolution (`resolveDeveloperWorktree` / `roleWorktreePathForResolution`) is
+// correct today, but nothing asserts the resolved cwd before a child process
+// is spawned — a regression there would run agent CLIs against the wrong
+// directory (in the worst case the primary repo checkout itself, where a
+// worker's `git add . && git commit` lands real commits on the checkout).
+// Every real developer/reviewer spawn calls `assertWorktreeCwd` first and
+// throws instead of spawning when the cwd is not a recognized
+// coordinator-managed worktree path.
+import path from "node:path";
+/** Basename shape the worktree manager itself uses: `<sessionId>-<role>`. */
+const ROLE_SUFFIX_RE = /-(developer|reviewer)$/;
+/**
+ * Parent directory names under which coordinator-managed role worktrees live:
+ * - legacy layout: `<repo>/.agent-dealer-worktrees/<sessionId>-<role>`
+ * - managed layout (NOT-149): `<executionRoot>/worktrees/<identity>/<sessionId>-<role>`
+ * - dev-mode equivalent: `<dataDir>/worktrees/...`
+ */
+const WORKTREE_PARENT_NAMES = new Set([".agent-dealer-worktrees", "worktrees"]);
+/**
+ * True when `cwd` looks like a coordinator-managed role worktree path: its
+ * basename carries the `-developer`/`-reviewer` role suffix AND one of its
+ * parent directories is a recognized worktrees root. In particular the
+ * primary repo root itself never matches (no role suffix, no worktrees
+ * parent), nor does the ambient `process.cwd()` of a dev checkout.
+ */
+export function isManagedWorktreeCwd(cwd) {
+    if (typeof cwd !== "string" || cwd.length === 0)
+        return false;
+    const normalized = path.normalize(cwd);
+    if (!ROLE_SUFFIX_RE.test(path.basename(normalized)))
+        return false;
+    const segments = normalized.split(path.sep).filter(Boolean);
+    return segments.slice(0, -1).some((segment) => WORKTREE_PARENT_NAMES.has(segment));
+}
+/**
+ * Throw instead of spawning when `cwd` is not a recognized managed-worktree
+ * path. Called at the top of `realDeveloperSpawn`/`realReviewerSpawn`, before
+ * any child process exists — the effects turn this pre-spawn throw into a
+ * `session_failed` "could not start" outcome, never a run against the repo.
+ */
+export function assertWorktreeCwd(cwd) {
+    if (!isManagedWorktreeCwd(cwd)) {
+        throw new Error(`Refusing to spawn a worker outside a managed worktree (NOT-273): ${cwd}`);
+    }
+}

package/bundle/server/dist/coordinator/worktree-cwd-guard.test.js

@@ -0,0 +1,83 @@
+// packages/server/src/coordinator/worktree-cwd-guard.test.ts
+//
+// NOT-273: the developer/reviewer spawn path refuses to spawn outside a
+// recognized coordinator-managed worktree — in particular the primary repo
+// root itself — before any child process exists.
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+const { assertWorktreeCwd, isManagedWorktreeCwd } = await import("./worktree-cwd-guard.js");
+const { realDeveloperSpawn, realReviewerSpawn } = await import("./spawn.js");
+const SESSION_ID = "00000000-0000-4000-8000-000000000001";
+test("real worktree-shaped paths pass the guard", () => {
+    // Legacy layout: <repo>/.agent-dealer-worktrees/<sessionId>-<role>.
+    assert.equal(isManagedWorktreeCwd(`/repo/.agent-dealer-worktrees/${SESSION_ID}-developer`), true);
+    assert.equal(isManagedWorktreeCwd(`/repo/.agent-dealer-worktrees/${SESSION_ID}-reviewer`), true);
+    // Managed layout (NOT-149): <executionRoot>/worktrees/<identity>/<sessionId>-<role>.
+    assert.equal(isManagedWorktreeCwd(`/data/execution/worktrees/github.com/acme/app/${SESSION_ID}-developer`), true);
+    assert.equal(isManagedWorktreeCwd(`/data/execution/worktrees/github.com/acme/app/${SESSION_ID}-reviewer`), true);
+    // Dev-mode equivalent under a dev data dir.
+    assert.equal(isManagedWorktreeCwd(path.join(os.homedir(), ".agent-dealer-dev", "worktrees", "github.com", "acme", "app", `${SESSION_ID}-developer`)), true);
+    assert.doesNotThrow(() => assertWorktreeCwd(`/repo/.agent-dealer-worktrees/${SESSION_ID}-developer`));
+});
+test("the primary repo root and other non-worktree paths are rejected", () => {
+    const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-guard-repo-"));
+    // A plain checkout dir (what the ambient process cwd is in a normal dev
+    // checkout). Deliberately synthetic, never `process.cwd()` itself: the
+    // runner's own cwd is environment-dependent and may itself be
+    // worktree-shaped (e.g. a `<uuid>-developer` dir under a `worktrees`
+    // parent), which the guard correctly accepts per the naming convention.
+    const checkoutDir = path.join(repoRoot, "checkout");
+    fs.mkdirSync(checkoutDir);
+    try {
+        assert.equal(isManagedWorktreeCwd(repoRoot), false, "primary repo root itself");
+        assert.equal(isManagedWorktreeCwd(checkoutDir), false, "ambient-checkout-shaped cwd");
+        assert.equal(isManagedWorktreeCwd(os.tmpdir()), false, "bare temp dir");
+        assert.equal(isManagedWorktreeCwd(path.join(os.tmpdir(), `${SESSION_ID}-developer`)), false, "role suffix without a worktrees parent");
+        assert.equal(isManagedWorktreeCwd("/repo/.agent-dealer-worktrees"), false, "worktrees root without a session dir");
+        assert.equal(isManagedWorktreeCwd(""), false, "empty cwd");
+        assert.throws(() => assertWorktreeCwd(repoRoot), /managed worktree/);
+        assert.throws(() => assertWorktreeCwd(checkoutDir), /managed worktree/);
+    }
+    finally {
+        fs.rmSync(repoRoot, { recursive: true, force: true });
+    }
+});
+test("realDeveloperSpawn refuses the primary repo root before any process is spawned", async () => {
+    const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-guard-dev-"));
+    try {
+        await assert.rejects(realDeveloperSpawn({
+            sessionId: SESSION_ID,
+            runtime: "claude_code",
+            policy: { worktreeWrite: true },
+            model: null,
+            prompt: "Implement it",
+            cwd: repoRoot,
+            timeoutMs: 1000,
+        }), /managed worktree/, "repo-root cwd throws instead of spawning");
+    }
+    finally {
+        fs.rmSync(repoRoot, { recursive: true, force: true });
+    }
+});
+test("realReviewerSpawn refuses the primary repo root before any process is spawned", async () => {
+    // Synthetic repo-root stand-in, never `process.cwd()`: the runner's own
+    // cwd is environment-dependent and may itself be worktree-shaped.
+    const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-guard-rev-"));
+    try {
+        await assert.rejects(realReviewerSpawn({
+            sessionId: SESSION_ID,
+            runtime: "claude_code",
+            policy: { worktreeWrite: false },
+            model: null,
+            prompt: "Review it",
+            cwd: repoRoot,
+            timeoutMs: 1000,
+        }), /managed worktree/, "repo-root cwd throws instead of spawning");
+    }
+    finally {
+        fs.rmSync(repoRoot, { recursive: true, force: true });
+    }
+});

package/bundle/server/dist/routes/human-actions.js

@@ -1,5 +1,6 @@
 import { getHumanAction, listOpenHumanActions } from "../repository/human-actions.js";
 import { resolveHumanActionAndAdvanceAsync } from "../coordinator/commands.js";
+import { normalizeResolutionNote } from "../coordinator/human-resolution.js";
 import { triggerIssueReflect, resolveReflectionInteractionAction } from "../coordinator/reflect-trigger.js";
 import { resolveOutboundDeliveryAction } from "../queue/approve-deliver.js";
 export async function registerHumanActionRoutes(app) {
@@ -14,6 +15,12 @@ export async function registerHumanActionRoutes(app) {
         if (!resolvedBy || !choice) {
             return reply.status(400).send({ error: "resolvedBy and choice are required" });
         }
+        // NOT-272: optional human note for a product_scope_decision resolution — validated
+        // the same way as resolvedBy/choice above (present-but-not-a-string 400s, never 500s).
+        const normalizedNote = normalizeResolutionNote(body?.note);
+        if (!normalizedNote.ok) {
+            return reply.status(400).send({ error: normalizedNote.error });
+        }
         // Read before resolving — the issue id this action belongs to, needed for the reflect
         // trigger below and stable regardless of how resolution turns out.
         const action = getHumanAction(id);
@@ -45,7 +52,9 @@ export async function registerHumanActionRoutes(app) {
         }
         // Awaits undraft+merge when final_review:complete (NOT-102) — sync resolve alone would
         // only park at AUTO_MERGE_INTENT and leave the PR draft.
-        const result = await resolveHumanActionAndAdvanceAsync(id, resolvedBy, choice);
+        const result = await resolveHumanActionAndAdvanceAsync(id, resolvedBy, choice, {
+            note: normalizedNote.note,
+        });
         if (!result.ok)
             return reply.status(result.code).send({ error: result.error });
         // Reflect is a best-effort network call to Agent Deck (health check + a sequential

package/bundle/server/dist/routes/human-actions.test.js

@@ -12,7 +12,7 @@ const { createHumanAction, getHumanAction, listHumanActionsForIssue } = await im
 const { registerHumanActionRoutes } = await import("./human-actions.js");
 const { startWorkflow, applyCompletion } = await import("../coordinator/commands.js");
 const { ReviewerResult } = await import("../coordinator/reviewer-result.js");
-const { claimWorkItem } = await import("../repository/work-items.js");
+const { claimWorkItem, getWorkItem } = await import("../repository/work-items.js");
 const { listArtifactsForIssue } = await import("../repository/artifacts-for-issue.js");
 const { createRun, getRun, transitionRun, addArtifact, updateRunFields } = await import("../repository/runs.js");
 const { pendingSendCount, getPendingOutboundDraft } = await import("../repository/outbound-drafts.js");
@@ -284,3 +284,119 @@ test("POST resolve 400s on a choice not valid for reflection_interaction_require
     assert.equal(res.statusCode, 400);
     await app.close();
 });
+// NOT-272: seeds.
+function seedPreStartScopeDecision() {
+    const issue = createIssue({ title: "Scope gated", repo: "acme/app", baseBranch: "main", developerAgentId: BUILTIN_AGENT_CLAUDE_ID, reviewerAgentId: BUILTIN_AGENT_CURSOR_ID, acceptanceCriteria: "Works", maxReviewRounds: 3, maxInfraAttempts: 3, source: "manual" });
+    const action = createHumanAction({
+        issueId: issue.id,
+        actionType: "product_scope_decision",
+        reason: "Scope unclear before start",
+        question: "Is this in scope?",
+        responseOptions: [{ choice: "resume", label: "Resume development" }],
+    });
+    return { issue, action };
+}
+/** Drives a real issue to a mid-workflow product_scope_decision via a reviewer
+ * escalate verdict carrying a productScopeQuestion (NOT-150 routing). */
+async function seedMidWorkflowScopeDecision() {
+    const issue = createIssue({ title: "Scope escalated", repo: "acme/app", baseBranch: "main", developerAgentId: BUILTIN_AGENT_CLAUDE_ID, reviewerAgentId: BUILTIN_AGENT_CURSOR_ID, acceptanceCriteria: "Works", maxReviewRounds: 3, maxInfraAttempts: 3, source: "manual" });
+    const start = startWorkflow(issue.id);
+    assert.equal(start.ok, true);
+    const devItem = claimWorkItem(`scope-note-test-${issue.id}-dev`, { leaseMs: 60_000 });
+    await applyCompletion(devItem.id, devItem.leaseToken, {
+        kind: "clean_handoff",
+        branch: `issue-${issue.id}`,
+        headSha: "a".repeat(40),
+        baseSha: "b".repeat(40),
+        prNumber: 1,
+        prUrl: "https://gh/pr/1"
+    });
+    const reviewItem = claimWorkItem(`scope-note-test-${issue.id}-rev`, { leaseMs: 60_000 });
+    await applyCompletion(reviewItem.id, reviewItem.leaseToken, {
+        kind: "verdict",
+        result: ReviewerResult.parse({
+            verdict: "escalated",
+            baseSha: "b".repeat(40),
+            headSha: "a".repeat(40),
+            acceptanceCriteriaAssessment: "unclear scope",
+            evidenceAssessment: "fine",
+            findings: [],
+            risks: [],
+            productScopeQuestion: "Is the runner migration in scope?"
+        })
+    });
+    const humanAction = listHumanActionsForIssue(issue.id).find((a) => a.actionType === "product_scope_decision");
+    assert.ok(humanAction, "expected a product_scope_decision human action");
+    return { issueId: issue.id, actionId: humanAction.id };
+}
+test("NOT-272: POST resolve 400s (not 500) on a non-string note", async () => {
+    const app = await buildApp();
+    const { action } = seedPreStartScopeDecision();
+    const res = await app.inject({ method: "POST", url: `/api/human-actions/${action.id}/resolve`, payload: { resolvedBy: "yusuke", choice: "resume", note: 123 } });
+    assert.equal(res.statusCode, 400);
+    assert.match(res.json().error, /note must be a string/);
+    assert.equal(getHumanAction(action.id).status, "open", "a rejected resolve must leave the action open");
+    await app.close();
+});
+test("NOT-272: POST resolve 400s on an over-long note", async () => {
+    const app = await buildApp();
+    const { action } = seedPreStartScopeDecision();
+    const res = await app.inject({ method: "POST", url: `/api/human-actions/${action.id}/resolve`, payload: { resolvedBy: "yusuke", choice: "resume", note: "x".repeat(4001) } });
+    assert.equal(res.statusCode, 400);
+    assert.match(res.json().error, /at most 4000/);
+    assert.equal(getHumanAction(action.id).status, "open");
+    await app.close();
+});
+test("NOT-272: pre-start product_scope_decision resolve with a note persists it and carries it on the round-1 payload", async () => {
+    const app = await buildApp();
+    const { action } = seedPreStartScopeDecision();
+    const note = "The runner migration IS in scope — proceed with it.";
+    const res = await app.inject({ method: "POST", url: `/api/human-actions/${action.id}/resolve`, payload: { resolvedBy: "yusuke", choice: "resume", note: `  ${note}  ` } });
+    assert.equal(res.statusCode, 200);
+    const body = res.json();
+    assert.equal(body.restarted, true);
+    assert.ok(body.nextWorkItemId);
+    const stored = getHumanAction(action.id);
+    assert.equal(stored.status, "resolved");
+    assert.deepEqual(JSON.parse(stored.resolutionJson), { choice: "resume", note }, "note round-trips exactly (trimmed)");
+    const payload = JSON.parse(getWorkItem(body.nextWorkItemId).payloadJson);
+    assert.equal(payload.scopeDecisionNote, note, "the very next round's payload carries the note");
+    await app.close();
+});
+test("NOT-272: mid-workflow product_scope_decision resolve with a note persists it and carries it on the next developer payload", async () => {
+    const app = await buildApp();
+    const { issueId, actionId } = await seedMidWorkflowScopeDecision();
+    const note = "Out of scope for this ticket — finish the runner work already here, nothing more.";
+    const res = await app.inject({ method: "POST", url: `/api/human-actions/${actionId}/resolve`, payload: { resolvedBy: "yusuke", choice: "resume", note } });
+    assert.equal(res.statusCode, 200);
+    const body = res.json();
+    assert.equal(body.issueStatus, "developing");
+    assert.ok(body.nextWorkItemId);
+    const stored = getHumanAction(actionId);
+    assert.deepEqual(JSON.parse(stored.resolutionJson), { choice: "resume", note });
+    const payload = JSON.parse(getWorkItem(body.nextWorkItemId).payloadJson);
+    assert.equal(payload.scopeDecisionNote, note);
+    assert.equal(getIssue(issueId).status, "developing");
+    await app.close();
+});
+test("NOT-272: resolving a product_scope_decision without a note stores exactly today's record and queues a noteless payload", async () => {
+    const app = await buildApp();
+    const { action } = seedPreStartScopeDecision();
+    const res = await app.inject({ method: "POST", url: `/api/human-actions/${action.id}/resolve`, payload: { resolvedBy: "yusuke", choice: "resume" } });
+    assert.equal(res.statusCode, 200);
+    const body = res.json();
+    const stored = getHumanAction(action.id);
+    assert.equal(stored.resolutionJson, JSON.stringify({ choice: "resume" }));
+    const payload = JSON.parse(getWorkItem(body.nextWorkItemId).payloadJson);
+    assert.ok(!("scopeDecisionNote" in payload), "no new payload key without a note");
+    await app.close();
+});
+test("NOT-272: a note sent with any other action type is dropped, never stored", async () => {
+    const app = await buildApp();
+    const { actionId } = await seedRealIssueAwaitingFinalReview();
+    const res = await app.inject({ method: "POST", url: `/api/human-actions/${actionId}/resolve`, payload: { resolvedBy: "yusuke", choice: "close", note: "should not persist" } });
+    assert.equal(res.statusCode, 200);
+    const stored = getHumanAction(actionId);
+    assert.equal(stored.resolutionJson, JSON.stringify({ choice: "close" }));
+    await app.close();
+});

package/bundle/server/dist/routes/index.js

@@ -8,7 +8,7 @@ import { getLinearUsageSnapshot } from "../adapters/linear-graphql.js";
 import { listRuntimeModels } from "../runners/models.js";
 import { configuredCapacityRuntimes, getRuntimeCapacitySnapshot } from "../capacity/service.js";
 import { refreshClaudeCapacityIfStale } from "../capacity/claude-local-cache.js";
-import { maybeRefreshMuseCapacityFromHost } from "../capacity/muse-host.js";
+import { refreshMuseCapacityIfStale } from "../capacity/muse-probe.js";
 import { refreshCodexCapacityIfStale } from "../capacity/codex-app-server.js";
 import { getCursorTeamBillingSnapshot, refreshCursorTeamBillingIfStale, } from "../capacity/cursor-team.js";
 import { getCursorIndividualBillingSnapshot, refreshCursorIndividualBillingIfStale, refreshCursorIndividualCapacityIfStale, } from "../capacity/cursor-individual.js";
@@ -63,13 +63,12 @@ export async function registerRoutes(app) {
     // NOT-245: provider-neutral capacity read model — one entry per configured
     // runtime account with its windows, freshness, and explicit unavailable
     // reasons. Normalized snapshots only; evidence stays server-side.
-    // NOT-270: the only production trigger for Muse capacity — a throttled
-    // (default 5 min), bounded, best-effort refresh through the server-owned
-    // long-lived `muse serve` host when `muse_code` is configured. The
-    // refresh runs in the background without blocking the read: GET serves
-    // the last-known snapshot immediately so a slow or hanging host (bounded
-    // by the capacity timeout) can never stall the Agents page. Failures
-    // preserve last-good rows as N/A and never fail the read.
+    // Muse capacity: first take the free throttled read from the server-owned
+    // execution host. If there is still no complete observation under an hour
+    // old, the default-on bounded fallback runs one minimal turn on a dedicated
+    // restricted host and reads 5H/1W from that same host. This stays in the
+    // background: GET serves last-good immediately and never waits on model
+    // work. `AGENT_DEALER_MUSE_CAPACITY_REFRESH=off` disables paid fallback.
     // NOT-246: on-demand Codex refresh — when the stored Codex snapshot is
     // stale the read triggers one bounded, non-billable App Server poll
     // (single-flight, never health rows, never throws); fresh snapshots and
@@ -77,11 +76,15 @@ export async function registerRoutes(app) {
     // subprocess.
     // NOT-268: Claude local-first ladder — one background refresh ingests
     // Claude Code's own free cache (plain file read, never a spawn) and then
-    // considers the paid probe without blocking the read: a bounded Haiku
-    // probe fires at most once per hour and only under the explicit
-    // `AGENT_DEALER_CLAUDE_CAPACITY_REFRESH=paid-after-1h` opt-in when every
-    // valid 5H/1W observation is older than 60 minutes. Disabled is a strict
-    // no-op (no spawn, no spend). Failures never break the read below.
+    // considers the free `/usage` refresh without blocking the read: a
+    // bounded `claude -p "/usage"` call fires at most once per hour, only
+    // when every valid 5H/1W observation is older than 60 minutes, and only
+    // when enabled (default on; `AGENT_DEALER_CLAUDE_CAPACITY_REFRESH=off`
+    // disables it). `/usage` is a local slash-command — no model call, $0
+    // cost, ~300ms, verified live 2026-09-27 (the original design spawned a
+    // real model turn and was fixed after a live proof showed it never
+    // worked; see docs/RUNTIME_CAPACITY.md). Failures never break the read
+    // below.
     app.get("/api/runtime-capacity", async () => {
         try {
             void refreshClaudeCapacityIfStale().catch(() => {
@@ -93,7 +96,7 @@ export async function registerRoutes(app) {
         }
         try {
             if (configuredCapacityRuntimes().includes("muse_code")) {
-                void maybeRefreshMuseCapacityFromHost().catch(() => {
+                void refreshMuseCapacityIfStale().catch(() => {
                     // Best-effort: failures preserve last-good rows via the ingest path.
                 });
             }

package/bundle/server/dist/routes/runtime-capacity.test.js

@@ -15,6 +15,13 @@ process.env.AGENT_DEALER_SKIP_AGENT_HEALTH = "1";
 // Never spawn a real provider from route tests: the on-demand Codex refresh is
 // covered against the fake App Server in codex-app-server.test.ts.
 process.env.AGENT_DEALER_CODEX_CAPACITY_REFRESH = "off";
+// Claude's `/usage` refresh is free and default-on in production (fixed
+// 2026-09-27 — see docs/RUNTIME_CAPACITY.md); still disabled here so route
+// tests never spawn a real `claude` subprocess.
+process.env.AGENT_DEALER_CLAUDE_CAPACITY_REFRESH = "off";
+// Muse's one-hour fallback is also default-on; route tests cover the free
+// host trigger only and must never run a real model turn.
+process.env.AGENT_DEALER_MUSE_CAPACITY_REFRESH = "off";
 // NOT-268: the route also ingests the real ~/.claude.json cache on every read. Point it at a
 // path that never exists so a developer's own Claude usage never leaks extra windows into the
 // fixture-controlled assertions below (this passed in CI, which has no such file, but failed
@@ -62,9 +69,10 @@ test("GET /api/runtime-capacity returns normalized entries without evidence", as
     assert.ok(!raw.includes("evidence"), "no evidence pointers leak to the browser");
     await app.close();
 });
-test("GET triggers the Muse refresh when muse_code is configured", async () => {
-    // NOT-270: the route is the only production trigger for Muse capacity
-    // (owned host). No credential here (env key removed, empty login dir),
+test("GET triggers the free Muse refresh when muse_code is configured", async () => {
+    // The route is the production trigger for Muse capacity. This suite sets
+    // the paid fallback off, so it exercises only the free owned-host read.
+    // No credential here (env key removed, empty login dir),
     // so the refresh short-circuits to a `missing` sentinel without spawning
     // anything live.
     clearAllCapacitySnapshots();

package/bundle/server/dist/runners/muse-serve-session.js

@@ -1,12 +1,13 @@
 // packages/server/src/runners/muse-serve-session.ts
 //
-// NOT-270: run a real Dealer Muse developer turn through the server-owned
-// `muse serve` host (the NOT-269 proven lifecycle). Only a host that
+// NOT-270: run a Muse turn through a caller-owned `muse serve` host (the
+// NOT-269 proven lifecycle). Only a host that
 // observes the account's provider traffic can answer `usage/read`, so the
-// observation opportunity IS the real session: `session/start` +
-// `turn/start` on the owned host, then the session-boundary `usage/read`
-// (the existing refresh hook) populates 5H/1W. No synthetic prompt is ever
-// sent — the turn below carries the genuine Dealer developer prompt.
+// observation opportunity is a `session/start` + `turn/start` on that host.
+// Production callers use this for genuine Dealer developer work and, when
+// capacity has been unavailable for an hour, the dedicated bounded capacity
+// probe. The capacity probe owns a separate restricted host and shuts it down
+// after its final `usage/read`.
 //
 // Wire contract (stable MSP, Muse 1.4.x):
 //   session/start {commandId UUIDv7, workspaceRoot, modelId, approvalMode}

package/bundle/server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-dealer/server",
-  "version": "1.2.3",
+  "version": "1.2.5",
   "type": "module",
   "main": "dist/index.js",
   "files": [
@@ -22,7 +22,7 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@agent-dealer/shared": "1.2.3",
+    "@agent-dealer/shared": "1.2.5",
     "@fastify/cors": "^11.0.1",
     "@fastify/static": "^8.2.0",
     "@modelcontextprotocol/sdk": "^1.29.0",