pelikhan · Oct 3, 2026 · Oct 3, 2026 · Oct 3, 2026 · Oct 3, 2026 · github-actions
diff --git a/.github/workflows/smoke-work-queue.lock.yml b/.github/workflows/smoke-work-queue.lock.yml
diff --git a/.github/workflows/smoke-work-queue.md b/.github/workflows/smoke-work-queue.md
@@ -35,6 +35,28 @@ safe-outputs:
     close-older-issues: true
     close-older-key: "smoke-work-queue"
   noop:
+jobs:
+  verify_smoke_result:
+    needs: [agent, safe_outputs]
+    runs-on: ubuntu-slim
+    timeout-minutes: 3
+    permissions:
+      actions: read
+    steps:
+      - name: Download smoke evidence
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+        with:
+          name: agent
+          path: /tmp/gh-aw/
+      - name: Verify smoke result
+        run: |
+          if grep -Eq '"type"[[:space:]]*:[[:space:]]*"create_issue"' /tmp/gh-aw/safeoutputs.jsonl; then
+            echo "::error::Work queue smoke test reported a tool failure"
+            exit 1
+          fi
+          test -s /tmp/gh-aw/work-queue.finish.jsonl
+          grep -Fx '{"outcome":"completed"}' /tmp/gh-aw/work-queue.finish.jsonl
+          grep -Eq '"type"[[:space:]]*:[[:space:]]*"noop"' /tmp/gh-aw/safeoutputs.jsonl
 timeout-minutes: 10
 strict: true
 features:
@@ -47,9 +69,15 @@ Exercise the queue MCP server mounted from the activation snapshot and the
 trusted safe-output finish-intent path. This workflow has no inbound worker claim,
 so it must not mutate the durable queue log.
 
+Use the tool interface advertised in the runtime prompt. If `work-queue` is
+listed in `<mcp-clis>`, invoke `work-queue work_queue_read` and
+`work-queue work_queue_claim_finish` from bash with JSON arguments. The tool names
+are subcommands, not standalone executables.
+
 1. Call `work_queue_read` with
    `work: "__gh_aw_smoke__-${{ github.run_id }}"`. Verify the returned work is
-   `absent` and that the response includes a snapshot version.
+   `absent` and that the response includes `snapshot_sha` (which is `null` when
+   the queue branch does not exist).
 2. Call `work_queue_claim_finish` with `outcome: "completed"`. Verify it reports
    that the finish intent was recorded. Do not supply work or claim identifiers.
    The safe-output check must find this finish intent in the downloaded agent
@@ -60,3 +88,6 @@ so it must not mutate the durable queue log.
    `${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}`.
    Do not include snapshot contents, identifiers other than the run ID, or
    unredacted errors in the issue.
+
+The final verification job fails the run after processing any failure issue.
+Only a completed finish-intent artifact and a `noop` output count as success.
diff --git a/actions/setup/js/work_queue_mcp_server.cjs b/actions/setup/js/work_queue_mcp_server.cjs
@@ -77,7 +77,7 @@ function createWorkQueueStateTool(snapshot) {
     },
     handler: args => {
       console.error("[work-queue] Reading queue snapshot");
-      return readWorkQueueState(snapshot, args);
+      return { content: [{ type: "text", text: JSON.stringify(readWorkQueueState(snapshot, args)) }] };
     },
   };
 }
@@ -103,10 +103,16 @@ function createWorkQueueFinishTool(options = {}) {
       if (!["completed", "cancelled"].includes(outcome)) {
         throw new TypeError("outcome must be completed or cancelled");
       }
-      fs.mkdirSync(path.dirname(outputPath), { recursive: true });
-      fs.appendFileSync(outputPath, `${JSON.stringify({ outcome })}\n`, { encoding: "utf8", mode: 0o600 });
+      try {
+        fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+        fs.appendFileSync(outputPath, `${JSON.stringify({ outcome })}\n`, { encoding: "utf8", mode: 0o644 });
+        // The MCP container and runner artifact collector can run as different users.
+        fs.chmodSync(outputPath, 0o644);
+      } catch (error) {
+        throw new Error("Failed to record work queue finish intent", { cause: error });
+      }
       console.error(`[work-queue] Recorded ${outcome} finish intent`);
-      return { recorded: true, outcome };
+      return { content: [{ type: "text", text: JSON.stringify({ recorded: true, outcome }) }] };
     },
   };
 }

diff --git a/actions/setup/js/work_queue_mcp_server.test.cjs b/actions/setup/js/work_queue_mcp_server.test.cjs
@@ -1,10 +1,11 @@
 // @ts-check
-import { afterEach, describe, expect, it } from "vitest";
+import { afterEach, describe, expect, it, vi } from "vitest";
 import fs from "fs";
 import os from "os";
 import path from "path";
 import { createWorkQueueFinishTool, createWorkQueueStateTool, loadWorkQueueSnapshot, readWorkQueueState } from "./work_queue_mcp_server.cjs";
 import { createWorkTransaction, serializeTransactionLog } from "./work_queue_replay.cjs";
+import { createServer, handleMessage, registerTool } from "./mcp_server_core.cjs";
 
 const work = id => ({ version: 2, kind: "Work", work: id, claim: null, attempt: null });
 const claim = (workId, id) => ({ version: 2, kind: "Claim", work: workId, claim: id, attempt: null });
@@ -40,7 +41,7 @@ describe("work queue MCP snapshot", () => {
     });
     const tool = createWorkQueueStateTool(snapshot);
     expect(tool.name).toBe("work_queue_read");
-    expect(tool.handler({ work: "missing" })).toEqual({
+    expect(JSON.parse(tool.handler({ work: "missing" }).content[0].text)).toEqual({
       snapshot_sha: "activation-head",
       next_work: null,
       works: [{ id: "missing", state: "absent", winner: null, claims: [] }],
@@ -109,7 +110,57 @@ describe("work queue MCP snapshot", () => {
     expect(tool.name).toBe("work_queue_claim_finish");
     expect(Object.keys(tool.inputSchema.properties)).toEqual(["outcome"]);
     expect(tool.inputSchema.additionalProperties).toBe(false);
-    expect(tool.handler({ outcome: "completed", work_id: "untrusted" })).toEqual({ recorded: true, outcome: "completed" });
+    expect(JSON.parse(tool.handler({ outcome: "completed", work_id: "untrusted" }).content[0].text)).toEqual({ recorded: true, outcome: "completed" });
     expect(fs.readFileSync(finishPath, "utf8")).toBe('{"outcome":"completed"}\n');
+    expect(fs.statSync(finishPath).mode & 0o777).toBe(0o644);
+  });
+
+  it("returns queue state and finish confirmation through the stdio MCP transport", async () => {
+    const snapshotPath = writeSnapshot({ version: 2, sha: null, transactionLog: "", worker: null });
+    const finishPath = path.join(path.dirname(snapshotPath), "finish.jsonl");
+    const server = createServer({ name: "work-queue", version: "1.0.0" });
+    server.debug = vi.fn();
+    server.writeMessage = vi.fn();
+    registerTool(server, createWorkQueueStateTool(loadWorkQueueSnapshot(snapshotPath)));
+    registerTool(server, createWorkQueueFinishTool({ finishIntentPath: finishPath }));
+
+    for (const [id, name, args, expected] of [
+      [1, "work_queue_read", { work: "missing" }, { snapshot_sha: null, next_work: null, works: [{ id: "missing", state: "absent", winner: null, claims: [] }] }],
+      [2, "work_queue_claim_finish", { outcome: "completed" }, { recorded: true, outcome: "completed" }],
+    ]) {
+      await handleMessage(server, { jsonrpc: "2.0", id, method: "tools/call", params: { name, arguments: args } });
+      expect(server.writeMessage).toHaveBeenCalledWith({
+        jsonrpc: "2.0",
+        id,
+        result: { content: [{ type: "text", text: JSON.stringify(expected) }], isError: false },
+      });
+    }
+    expect(fs.readFileSync(finishPath, "utf8")).toBe('{"outcome":"completed"}\n');
+  });
+
+  it("makes an existing owner-only intent readable for runner artifact collection", () => {
+    const snapshotPath = writeSnapshot({ version: 2, sha: null, transactionLog: "", worker: null });
+    const finishPath = path.join(path.dirname(snapshotPath), "finish.jsonl");
+    fs.writeFileSync(finishPath, "", { mode: 0o600 });
+    const tool = createWorkQueueFinishTool({ finishIntentPath: finishPath });
+
+    tool.handler({});
+
+    expect(fs.statSync(finishPath).mode & 0o777).toBe(0o644);
+    expect(fs.readFileSync(finishPath, "utf8")).toBe('{"outcome":"completed"}\n');
+  });
+
+  it("reports filesystem failures instead of confirming a recorded finish intent", () => {
+    const snapshotPath = writeSnapshot({ version: 2, sha: null, transactionLog: "", worker: null });
+    const tool = createWorkQueueFinishTool({ finishIntentPath: path.join(path.dirname(snapshotPath), "finish.jsonl") });
+    const error = new Error("permission denied");
+    const append = vi.spyOn(fs, "appendFileSync").mockImplementation(() => {
+      throw error;
+    });
+    try {
+      expect(() => tool.handler({ outcome: "completed" })).toThrow(expect.objectContaining({ message: "Failed to record work queue finish intent", cause: error }));
+    } finally {
+      append.mockRestore();
+    }
   });
 });
diff --git a/pkg/workflow/mcp_cli_mount.go b/pkg/workflow/mcp_cli_mount.go
@@ -96,7 +96,7 @@ func getMCPCLIServerNames(data *WorkflowData) []string { //nolint:largefunc // E
 				if !isPlaywrightCLIMode(data.Tools) {
 					servers = append(servers, toolName)
 				}
-			case "qmd":
+			case "qmd", "work-queue":
 				servers = append(servers, toolName)
 			case "agentic-workflows":
 				// The gateway and manifest use "agenticworkflows" (no hyphen) as the server ID.
@@ -148,6 +148,9 @@ func getMCPCLIServerNames(data *WorkflowData) []string { //nolint:largefunc // E
 		if hasGitHubTool(data.ParsedTools) && !isGitHubCLIModeEnabled(data) && !slices.Contains(servers, constants.GitHubMCPServerID.String()) {
 			servers = append(servers, constants.GitHubMCPServerID.String())
 		}
+		if isWorkQueueEnabled(data) && !slices.Contains(servers, "work-queue") {
+			servers = append(servers, "work-queue")
+		}
 
 		for toolName, toolValue := range data.Tools {
 			servers = appendCustomMCPServerIfEligible(servers, toolName, toolValue)

diff --git a/pkg/workflow/mcp_cli_mount_test.go b/pkg/workflow/mcp_cli_mount_test.go
@@ -368,3 +368,46 @@ func TestBuildMCPCLIPromptSection_OmittedWhenBashDisabled(t *testing.T) {
 	require.NotEmpty(t, getMCPCLIServerNames(data), "safeoutputs is still CLI-mounted")
 	assert.Nil(t, buildMCPCLIPromptSection(data), "CLI-only instructions must be omitted when the agent has no shell")
 }
+
+func TestWorkQueueCLIMountSelection(t *testing.T) {
+	for _, tc := range []struct {
+		name     string
+		engine   string
+		enabled  any
+		cliProxy bool
+		expected []string
+	}{
+		{"copilot enabled", "copilot", true, false, []string{"safeoutputs", "work-queue"}},
+		{"copilot implicit", "copilot", nil, false, []string{"safeoutputs", "work-queue"}},
+		{"copilot disabled", "copilot", false, false, []string{"safeoutputs"}},
+		{"claude MCP", "claude", true, false, []string{"safeoutputs"}},
+		{"claude CLI", "claude", true, true, []string{"safeoutputs", "work-queue"}},
+		{"copilot CLI deduplicated", "copilot", true, true, []string{"safeoutputs", "work-queue"}},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			tools := map[string]any{
+				"work-queue": tc.enabled,
+				"cli-proxy":  tc.cliProxy,
+				"bash":       []any{"echo"},
+			}
+			data := &WorkflowData{
+				Tools:        tools,
+				ParsedTools:  NewTools(tools),
+				EngineConfig: &EngineConfig{ID: tc.engine},
+				SafeOutputs:  &SafeOutputsConfig{NoOp: &NoOpConfig{}},
+			}
+			require.Equal(t, tc.expected, getMCPCLIServerNames(data))
+
+			section := buildMCPCLIPromptSection(data)
+			require.NotNil(t, section)
+			commands := withMountedCLIShellCommandsInRestrictedBash(data)["bash"]
+			if len(tc.expected) == 2 {
+				require.Contains(t, section.EnvVars["GH_AW_MCP_CLI_SERVERS_LIST"], "`work-queue --help`")
+				require.Contains(t, commands, "work-queue:*")
+			} else {
+				require.NotContains(t, section.EnvVars["GH_AW_MCP_CLI_SERVERS_LIST"], "work-queue")
+				require.NotContains(t, commands, "work-queue:*")
+			}
+		})
+	}
+}
diff --git a/pkg/workflow/work_queue_compilation_integration_test.go b/pkg/workflow/work_queue_compilation_integration_test.go
@@ -4,12 +4,14 @@ package workflow
 
 import (
 	"os"
+	"os/exec"
 	"path/filepath"
 	"strings"
 	"testing"
 
 	"github.com/github/gh-aw/pkg/constants"
 	"github.com/github/gh-aw/pkg/testutil"
+	"github.com/goccy/go-yaml"
 	"github.com/stretchr/testify/require"
 )
 
@@ -93,3 +95,63 @@ Compile each work-queue workflow phase.
 	require.Contains(t, conclusion, "work_queue_summary.cjs")
 	require.Contains(t, conclusion, "await main({ core, githubClient: github, context });")
 }
+
+func TestWorkQueueSmokeVerification(t *testing.T) {
+	source, err := os.ReadFile("../../.github/workflows/smoke-work-queue.md")
+	require.NoError(t, err)
+	dir := testutil.TempDir(t, "work-queue-smoke-")
+	workflowPath := filepath.Join(dir, "smoke-work-queue.md")
+	require.NoError(t, os.WriteFile(workflowPath, source, 0o600))
+	require.NoError(t, NewCompiler(WithVersion("integration")).CompileWorkflow(workflowPath))
+
+	lock, err := os.ReadFile(filepath.Join(dir, "smoke-work-queue.lock.yml"))
+	require.NoError(t, err)
+	var compiled struct {
+		Jobs map[string]struct {
+			Needs any
+			Steps []struct {
+				Name string
+				Run  string
+			}
+		}
+	}
+	require.NoError(t, yaml.Unmarshal(lock, &compiled))
+	job, ok := compiled.Jobs["verify_smoke_result"]
+	require.True(t, ok)
+	require.Contains(t, job.Needs, "safe_outputs", "failure issues must be processed before failing the smoke run")
+	var script string
+	for _, step := range job.Steps {
+		if step.Name == "Verify smoke result" {
+			script = step.Run
+		}
+	}
+	require.NotEmpty(t, script)
+
+	for _, tc := range []struct {
+		name    string
+		outputs string
+		intent  string
+		success bool
+	}{
+		{"completed", "{\"type\":\"noop\"}\n", "{\"outcome\":\"completed\"}\n", true},
+		{"reported failure", "{\"type\":\"create_issue\"}\n", "", false},
+		{"failure with success artifacts", "{\"type\":\"noop\"}\n{\"type\":\"create_issue\"}\n", "{\"outcome\":\"completed\"}\n", false},
+		{"missing finish intent", "{\"type\":\"noop\"}\n", "", false},
+		{"cancelled", "{\"type\":\"noop\"}\n", "{\"outcome\":\"cancelled\"}\n", false},
+		{"missing noop", "", "{\"outcome\":\"completed\"}\n", false},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			evidence := t.TempDir()
+			require.NoError(t, os.WriteFile(filepath.Join(evidence, "safeoutputs.jsonl"), []byte(tc.outputs), 0o600))
+			if tc.intent != "" {
+				require.NoError(t, os.WriteFile(filepath.Join(evidence, "work-queue.finish.jsonl"), []byte(tc.intent), 0o600))
+			}
+			output, err := exec.Command("bash", "-e", "-c", strings.ReplaceAll(script, "/tmp/gh-aw/", evidence+"/")).CombinedOutput()
+			if tc.success {
+				require.NoError(t, err, "%s", output)
+			} else {
+				require.Error(t, err, "%s", output)
+			}
+		})
+	}
+}