agent-dealer 1.2.6 → 1.2.8

package/bundle/server/dist/adapters/agent-deck-bind.js

@@ -153,20 +153,29 @@ function readAmbientCodexAuthPolicy(ambientCodexHome) {
         return {};
     }
 }
-function deckLaunchHeaders(deckId, worktreePath) {
-    return {
+/**
+ * NOT-305: header carrying the session's opaque Deck correlation UUID. Observability
+ * metadata only — Deck uses it to attribute its normalized playbook-fetch stream back
+ * to this durable Dealer session; it grants no authority.
+ */
+export const DECK_CORRELATION_HEADER = "x-agent-deck-correlation-id";
+function deckLaunchHeaders(deckId, worktreePath, correlationId) {
+    const headers = {
         "x-agent-deck-deck-id": deckId,
         "x-agent-deck-workspace": worktreePath,
     };
+    if (correlationId)
+        headers[DECK_CORRELATION_HEADER] = correlationId;
+    return headers;
 }
 /** claude's `--mcp-config` file schema — deck headers only, no Authorization. */
-function urlHeaderMcpConfig(mcpUrl, deckId, worktreePath) {
+function urlHeaderMcpConfig(mcpUrl, deckId, worktreePath, correlationId) {
     return {
         mcpServers: {
             "agent-deck": {
                 type: "http",
                 url: mcpUrl,
-                headers: deckLaunchHeaders(deckId, worktreePath),
+                headers: deckLaunchHeaders(deckId, worktreePath, correlationId),
             },
         },
     };
@@ -202,7 +211,7 @@ function ensureCursorMcpExcluded(worktreePath) {
 async function materializeWorkerMcpConfig(opts) {
     const mcpBase = getAgentDeckMcpUrl().replace(/\/mcp\/?$/, "");
     const mcpUrl = `${mcpBase}/mcp`;
-    const headers = deckLaunchHeaders(opts.deckId, opts.worktreePath);
+    const headers = deckLaunchHeaders(opts.deckId, opts.worktreePath, opts.correlationId);
     // NOT-278: Muse Code settings come only from `prepareMuseAttempt`
     // (runners/muse-config.ts) — never emit a Claude/Codex/Cursor config for Muse. Refuse
     // before anything is written rather than fall through to the Claude config below.
@@ -257,7 +266,7 @@ async function materializeWorkerMcpConfig(opts) {
     const dir = getWorkerMcpConfigDir();
     const filePath = path.join(dir, `claude-mcp-${opts.deckId.slice(0, 8)}-${randomUUID()}.json`);
     try {
-        fs.writeFileSync(filePath, JSON.stringify(urlHeaderMcpConfig(mcpUrl, opts.deckId, opts.worktreePath)), { mode: 0o600 });
+        fs.writeFileSync(filePath, JSON.stringify(urlHeaderMcpConfig(mcpUrl, opts.deckId, opts.worktreePath, opts.correlationId)), { mode: 0o600 });
     }
     catch (err) {
         fs.rmSync(filePath, { force: true });
@@ -416,6 +425,7 @@ export async function prepareWorkerDeckConnection(opts) {
             deckId: opts.deckId,
             worktreePath: opts.worktreePath,
             policy: opts.policy,
+            correlationId: opts.correlationId,
         });
     }
     catch (err) {

package/bundle/server/dist/adapters/agent-deck-bind.test.js

@@ -528,3 +528,77 @@ test("a deck that loses the connection mid-playbook is deck_unavailable", async
     if (!result.ok)
         assert.equal(result.kind, "deck_unavailable");
 });
+// NOT-305: every new worker session persists an opaque Deck correlation UUID before
+// spawn, and every runtime launch config carries it as the exact
+// `x-agent-deck-correlation-id` observability header (never authority).
+const CORRELATION_ID = "aaaaaaaa-1111-4111-a111-aaaaaaaaaaaa";
+test("prepareWorkerDeckConnection writes the exact correlation header for claude_code", async () => {
+    const result = await prepareWorkerDeckConnection({
+        policy: DENIED,
+        ...BASE_OPTS,
+        correlationId: CORRELATION_ID,
+        verifyCallTool: async (name) => {
+            assert.equal(name, "get_bound_deck");
+            return textResult({ id: DECK, name: "personal-dev" });
+        },
+    });
+    assert.equal(result.ok, true);
+    if (result.ok) {
+        const written = JSON.parse(fs.readFileSync(result.mcpConfigPath, "utf8"));
+        const headers = written.mcpServers["agent-deck"].headers;
+        assert.equal(headers["x-agent-deck-correlation-id"], CORRELATION_ID);
+        await releaseWorkerDeckConnection({ mcpConfigPath: result.mcpConfigPath });
+    }
+});
+test("prepareWorkerDeckConnection omits the correlation header when the session has none", async () => {
+    const result = await prepareWorkerDeckConnection({
+        policy: DENIED,
+        ...BASE_OPTS,
+        verifyCallTool: async () => textResult({ id: DECK, name: "personal-dev" }),
+    });
+    assert.equal(result.ok, true);
+    if (result.ok) {
+        const written = JSON.parse(fs.readFileSync(result.mcpConfigPath, "utf8"));
+        const headers = written.mcpServers["agent-deck"].headers;
+        assert.equal("x-agent-deck-correlation-id" in headers, false);
+        await releaseWorkerDeckConnection({ mcpConfigPath: result.mcpConfigPath });
+    }
+});
+test("prepareWorkerDeckConnection writes the exact correlation header for codex_local", async () => {
+    const result = await prepareWorkerDeckConnection({
+        policy: DENIED,
+        ...BASE_OPTS,
+        runtime: "codex_local",
+        correlationId: CORRELATION_ID,
+        verifyCallTool: async () => textResult({ id: DECK }),
+    });
+    assert.equal(result.ok, true);
+    if (result.ok) {
+        const toml = fs.readFileSync(path.join(result.mcpConfigPath, "config.toml"), "utf8");
+        assert.match(toml, new RegExp(`x-agent-deck-correlation-id = "${CORRELATION_ID}"`));
+        await releaseWorkerDeckConnection({ mcpConfigPath: result.mcpConfigPath });
+    }
+});
+test("prepareWorkerDeckConnection writes the exact correlation header for cursor_local", async () => {
+    const repo = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-cursor-correlation-"));
+    initGitRepo(repo);
+    try {
+        const result = await prepareWorkerDeckConnection({
+            policy: DENIED,
+            deckId: DECK,
+            worktreePath: repo,
+            runtime: "cursor_local",
+            correlationId: CORRELATION_ID,
+            verifyCallTool: async () => textResult({ id: DECK }),
+        });
+        assert.equal(result.ok, true);
+        if (result.ok) {
+            const written = JSON.parse(fs.readFileSync(result.mcpConfigPath, "utf8"));
+            assert.equal(written.mcpServers["agent-deck"].headers["x-agent-deck-correlation-id"], CORRELATION_ID);
+            await releaseWorkerDeckConnection({ mcpConfigPath: result.mcpConfigPath });
+        }
+    }
+    finally {
+        fs.rmSync(repo, { recursive: true, force: true });
+    }
+});

package/bundle/server/dist/adapters/agent-health.js

@@ -107,6 +107,15 @@ export function setRunCommandForTests(fn) {
 function runCommand(cmd, args, timeoutMs = DEFAULT_PROBE_TIMEOUT_MS, env) {
     return runCommandImpl(cmd, args, timeoutMs, env);
 }
+/**
+ * NOT-308: drop only the cached muse runtime issues — the `muse_capability` acknowledge
+ * path calls this so the lifted block is seen on the next health read instead of after
+ * the 60s TTL. Never touches capability state itself (unlike clearAgentHealthCaches,
+ * which resets it for tests).
+ */
+export function invalidateMuseHealthCache() {
+    runtimeIssueCache.delete("muse_code");
+}
 /** Exported for tests — clears the shared github + runtime health caches and soft-fail streak. */
 export function clearAgentHealthCaches() {
     runtimeIssueCache.clear();
@@ -199,9 +208,11 @@ async function cursorRuntimeIssues() {
  * existence only, never read.
  *
  * NOT-277: with CLI and credentials present, the reported version is handed to the capability
- * check — a version not yet checked runs one real developer-shell probe (muse-capability.ts);
- * `runtime_capability` blocks while it runs, when it finds shell/write missing, or when it could
- * not complete.
+ * check — a version not yet checked runs one real developer-shell probe (muse-capability.ts).
+ * NOT-308: `runtime_capability` blocks only on a confirmed shell/write loss (`missing`,
+ * not operator-overridden); while the version is unchecked or inconclusive the check
+ * runs in the background and admission proceeds on the last confirmed baseline
+ * (fresh installs with no baseline still fail closed).
  */
 async function museRuntimeIssues() {
     const bin = resolveMuseBin();

package/bundle/server/dist/adapters/github.js

@@ -527,7 +527,10 @@ const NONE_STREAK_REQUIRED = 2;
  * between resets the streak); if the deadline is hit before that streak completes, the
  * poll fails closed as "timeout" rather than silently waving the handoff through.
  */
-export async function pollPrChecks(adapter, opts) {
+export async function pollPrChecks(
+// NOT-310: narrowed to what the poll actually calls — the merge-conflict sync
+// passes only a checks reader, and full adapters still satisfy this shape.
+adapter, opts) {
     const deadline = Date.now() + opts.timeoutMs;
     let noneStreak = 0;
     for (;;) {