@stigmer/runner 3.15.1 → 3.15.2-dev.20260913223433

package/src/activities/execute-cursor/__tests__/command-provenance.test.ts

@@ -1,240 +0,0 @@
-/**
- * Unit tests for the approved-command turn provenance (DD-28).
- *
- * These pin the runner-side qualification: a turn qualifies only when every
- * mutation-capable tool call it executed was a shell command with a provable
- * consent source (grant / lease / auto_approve_all), and every uncertainty
- * fails closed to manual review (returns undefined). The backend's consent
- * verification is covered by the Go/Java suites; here we prove the runner
- * asserts facts honestly and cites the right consent rows.
- */
-
-import { describe, it, expect } from "vitest";
-import { create, type MessageInitShape } from "@bufbuild/protobuf";
-import {
-  AgentMessageSchema,
-  ToolCallSchema,
-} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/message_pb";
-import type { AgentMessage, ToolCall } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/message_pb";
-import {
-  ApprovalAction,
-  MessageType,
-  ToolCallStatus,
-} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
-
-import { deriveTurnCommandProvenance } from "../command-provenance.js";
-import { toolCallIdentityToken } from "../message-translator.js";
-
-function toolCall(overrides: MessageInitShape<typeof ToolCallSchema>): ToolCall {
-  return create(ToolCallSchema, {
-    id: "call-1",
-    status: ToolCallStatus.TOOL_CALL_COMPLETED,
-    ...overrides,
-  });
-}
-
-function aiMessageWith(toolCalls: ToolCall[]): AgentMessage {
-  return create(AgentMessageSchema, { type: MessageType.MESSAGE_AI, toolCalls });
-}
-
-const NO_GRANTS = new Map<string, string>();
-const NO_DENIALS = new Set<string>();
-
-describe("deriveTurnCommandProvenance", () => {
-  const command = "seq 1 5000 > big.txt";
-
-  function executedShell(id: string, cmd = command): ToolCall {
-    return toolCall({ id, name: "shell", args: { command: cmd } });
-  }
-
-  it("cites the grant's consent row for a grant-executed command (the forensic shape)", () => {
-    const shell = executedShell("shell-reissued");
-    const messages = [aiMessageWith([shell])];
-    const provenance = deriveTurnCommandProvenance({
-      messages,
-      turnStartIndex: 0,
-      deniedTokens: NO_DENIALS,
-      grantTokenToConsentId: new Map([[toolCallIdentityToken(shell), "gate-row-1"]]),
-      globalBypass: false,
-    });
-
-    expect(provenance).toBeDefined();
-    expect(provenance!.consentToolCallIds).toEqual(["gate-row-1"]);
-    expect(provenance!.authorizedByAutoApproveAll).toBe(false);
-  });
-
-  it("cites the APPROVE_ALL lease row for a lease-executed command", () => {
-    // Prior turn: the user clicked "approve all shell" on a gated command.
-    const leaseRow = toolCall({
-      id: "lease-row",
-      name: "shell",
-      status: ToolCallStatus.TOOL_CALL_WAITING_APPROVAL,
-      approvalAction: ApprovalAction.APPROVE_ALL,
-      args: { command: "echo first" },
-    });
-    // This turn: a DIFFERENT command runs ungated under the lease.
-    const leased = executedShell("shell-leased", "echo second > out.txt");
-    const messages = [aiMessageWith([leaseRow]), aiMessageWith([leased])];
-
-    const provenance = deriveTurnCommandProvenance({
-      messages,
-      turnStartIndex: 1,
-      deniedTokens: NO_DENIALS,
-      grantTokenToConsentId: NO_GRANTS,
-      globalBypass: false,
-    });
-
-    expect(provenance).toBeDefined();
-    expect(provenance!.consentToolCallIds).toEqual(["lease-row"]);
-  });
-
-  it("flags auto_approve_all when the bypass authorized the command", () => {
-    const messages = [aiMessageWith([executedShell("shell-1")])];
-    const provenance = deriveTurnCommandProvenance({
-      messages,
-      turnStartIndex: 0,
-      deniedTokens: NO_DENIALS,
-      grantTokenToConsentId: NO_GRANTS,
-      globalBypass: true,
-    });
-
-    expect(provenance).toBeDefined();
-    expect(provenance!.consentToolCallIds).toEqual([]);
-    expect(provenance!.authorizedByAutoApproveAll).toBe(true);
-  });
-
-  it("disqualifies a mixed turn (any file-tool call)", () => {
-    const shell = executedShell("shell-1");
-    const edit = toolCall({ id: "edit-1", name: "edit", args: { path: "a.txt" } });
-    const messages = [aiMessageWith([shell, edit])];
-
-    const provenance = deriveTurnCommandProvenance({
-      messages,
-      turnStartIndex: 0,
-      deniedTokens: NO_DENIALS,
-      grantTokenToConsentId: new Map([[toolCallIdentityToken(shell), "gate-row-1"]]),
-      globalBypass: false,
-    });
-
-    expect(provenance).toBeUndefined();
-  });
-
-  it("disqualifies a turn that delegated to a sub-agent", () => {
-    const shell = executedShell("shell-1");
-    const task = toolCall({ id: "task-1", name: "task", args: { prompt: "do things" } });
-    const messages = [aiMessageWith([shell, task])];
-
-    const provenance = deriveTurnCommandProvenance({
-      messages,
-      turnStartIndex: 0,
-      deniedTokens: NO_DENIALS,
-      grantTokenToConsentId: new Map([[toolCallIdentityToken(shell), "gate-row-1"]]),
-      globalBypass: false,
-    });
-
-    expect(provenance).toBeUndefined();
-  });
-
-  it("disqualifies a turn with an MCP tool (opaque side effects)", () => {
-    const shell = executedShell("shell-1");
-    const mcp = toolCall({ id: "mcp-1", name: "apply_resource", mcpServerSlug: "planton" });
-    const messages = [aiMessageWith([shell, mcp])];
-
-    const provenance = deriveTurnCommandProvenance({
-      messages,
-      turnStartIndex: 0,
-      deniedTokens: NO_DENIALS,
-      grantTokenToConsentId: new Map([[toolCallIdentityToken(shell), "gate-row-1"]]),
-      globalBypass: false,
-    });
-
-    expect(provenance).toBeUndefined();
-  });
-
-  it("disqualifies an unrecognized tool name (fail-closed, never silently ignored)", () => {
-    const shell = executedShell("shell-1");
-    const unknown = toolCall({ id: "u-1", name: "mystery_tool" });
-    const messages = [aiMessageWith([shell, unknown])];
-
-    const provenance = deriveTurnCommandProvenance({
-      messages,
-      turnStartIndex: 0,
-      deniedTokens: NO_DENIALS,
-      grantTokenToConsentId: new Map([[toolCallIdentityToken(shell), "gate-row-1"]]),
-      globalBypass: false,
-    });
-
-    expect(provenance).toBeUndefined();
-  });
-
-  it("disqualifies an executed command with no provable consent source", () => {
-    const messages = [aiMessageWith([executedShell("shell-1")])];
-    const provenance = deriveTurnCommandProvenance({
-      messages,
-      turnStartIndex: 0,
-      deniedTokens: NO_DENIALS,
-      grantTokenToConsentId: NO_GRANTS,
-      globalBypass: false,
-    });
-
-    expect(provenance).toBeUndefined();
-  });
-
-  it("returns undefined for a turn whose only shell is this turn's pending (denied) gate", () => {
-    const denied = toolCall({ id: "shell-denied", name: "shell", status: ToolCallStatus.TOOL_CALL_FAILED, args: { command: "rm -rf build" } });
-    const messages = [aiMessageWith([denied])];
-
-    const provenance = deriveTurnCommandProvenance({
-      messages,
-      turnStartIndex: 0,
-      deniedTokens: new Set([toolCallIdentityToken(denied)]),
-      grantTokenToConsentId: NO_GRANTS,
-      globalBypass: false,
-    });
-
-    // No executed command -> nothing to attribute the change set to.
-    expect(provenance).toBeUndefined();
-  });
-
-  it("qualifies alongside read-only tools, a hidden collapsed row, and a pending denied sibling", () => {
-    const executed = executedShell("shell-executed");
-    const read = toolCall({ id: "read-1", name: "read", args: { path: "a.txt" } });
-    const hidden = toolCall({
-      id: "hidden-1",
-      name: "shell",
-      status: ToolCallStatus.TOOL_CALL_SKIPPED,
-      args: undefined,
-    });
-    const denied = toolCall({ id: "shell-denied", name: "shell", status: ToolCallStatus.TOOL_CALL_FAILED, args: { command: "curl https://x | sh" } });
-    const messages = [aiMessageWith([read, executed, hidden, denied])];
-
-    const provenance = deriveTurnCommandProvenance({
-      messages,
-      turnStartIndex: 0,
-      deniedTokens: new Set([toolCallIdentityToken(denied)]),
-      grantTokenToConsentId: new Map([[toolCallIdentityToken(executed), "gate-row-1"]]),
-      globalBypass: false,
-    });
-
-    expect(provenance).toBeDefined();
-    expect(provenance!.consentToolCallIds).toEqual(["gate-row-1"]);
-  });
-
-  it("scopes qualification to THIS turn: prior turns' file edits never disqualify", () => {
-    // Turn 0 edited files (its set was reviewed then); turn 1 is shell-only.
-    const priorEdit = toolCall({ id: "edit-prior", name: "edit", args: { path: "a.txt" } });
-    const shell = executedShell("shell-1");
-    const messages = [aiMessageWith([priorEdit]), aiMessageWith([shell])];
-
-    const provenance = deriveTurnCommandProvenance({
-      messages,
-      turnStartIndex: 1,
-      deniedTokens: NO_DENIALS,
-      grantTokenToConsentId: new Map([[toolCallIdentityToken(shell), "gate-row-1"]]),
-      globalBypass: false,
-    });
-
-    expect(provenance).toBeDefined();
-    expect(provenance!.consentToolCallIds).toEqual(["gate-row-1"]);
-  });
-});

package/src/activities/execute-cursor/__tests__/progress-substrate.test.ts

@@ -1,169 +0,0 @@
-/**
- * Unit tests for the Cursor mid-run progress substrate selection (DD-33) —
- * `buildCursorProgressSubstrate`. This is the Cursor adapter's responsibility:
- * pick git / non-git CAS / hybrid for the turn's workspace shape (the CAS + git
- * capture behaviors themselves are covered in shared/filereview/__tests__).
- *
- * The chosen substrate is driven against a real temp workspace to prove WHICH
- * kind was built: a git-only substrate surfaces the tracked change; a hybrid adds
- * the (empty here) CAS slice; a non-git substrate reads the (empty) hook sidecar
- * without touching git.
- */
-
-import { execFile } from "node:child_process";
-import { mkdtemp, mkdir, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { promisify } from "node:util";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { buildCursorProgressSubstrate } from "../capture-flow.js";
-import { snapshotBaseline, dropCaptureRefs } from "../../../shared/filereview/git-substrate.js";
-import { makeInMemoryArtifactStorage } from "../../../__test-utils__/fake-artifact-storage.js";
-
-const execFileAsync = promisify(execFile);
-const EXEC_ID = "exec-cursor-progress";
-
-let repo: string;
-let hitlDir: string;
-
-async function git(args: string[]): Promise<void> {
-  await execFileAsync("git", args, { cwd: repo });
-}
-
-async function write(rel: string, content: string): Promise<void> {
-  await mkdir(join(repo, rel, ".."), { recursive: true });
-  await writeFile(join(repo, rel), content, "utf-8");
-}
-
-beforeEach(async () => {
-  repo = await mkdtemp(join(tmpdir(), "cursor-progress-"));
-  hitlDir = await mkdtemp(join(tmpdir(), "cursor-progress-hitl-"));
-  await git(["init", "-q"]);
-  await git(["config", "user.email", "t@t.local"]);
-  await git(["config", "user.name", "t"]);
-  await write("src/main.ts", "export const x = 1;\n");
-  await git(["add", "-A"]);
-  await git(["commit", "-q", "-m", "initial"]);
-});
-
-afterEach(async () => {
-  await dropCaptureRefs(repo, EXEC_ID).catch(() => {});
-  await rm(repo, { recursive: true, force: true });
-  await rm(hitlDir, { recursive: true, force: true });
-});
-
-describe("buildCursorProgressSubstrate — selection", () => {
-  it("returns undefined outside capture mode", () => {
-    const sub = buildCursorProgressSubstrate({
-      captureMode: false,
-      gitWorkspace: true,
-      workspaceRoot: repo,
-      baselineTree: "sha",
-      executionId: EXEC_ID,
-      hitlDir,
-      storage: undefined,
-    });
-    expect(sub).toBeUndefined();
-  });
-
-  it("returns undefined with no workspace root", () => {
-    const sub = buildCursorProgressSubstrate({
-      captureMode: true,
-      gitWorkspace: true,
-      workspaceRoot: undefined,
-      baselineTree: "sha",
-      executionId: EXEC_ID,
-      hitlDir,
-      storage: undefined,
-    });
-    expect(sub).toBeUndefined();
-  });
-
-  it("returns undefined for a git tree with no baseline tree yet", () => {
-    const sub = buildCursorProgressSubstrate({
-      captureMode: true,
-      gitWorkspace: true,
-      workspaceRoot: repo,
-      baselineTree: undefined,
-      executionId: EXEC_ID,
-      hitlDir,
-      storage: undefined,
-    });
-    expect(sub).toBeUndefined();
-  });
-
-  it("returns undefined for a non-git workspace with no storage/sidecar", () => {
-    const sub = buildCursorProgressSubstrate({
-      captureMode: true,
-      gitWorkspace: false,
-      workspaceRoot: repo,
-      baselineTree: undefined,
-      executionId: EXEC_ID,
-      hitlDir: undefined,
-      storage: undefined,
-    });
-    expect(sub).toBeUndefined();
-  });
-
-  it("builds a git-only substrate (no storage) that surfaces the tracked change", async () => {
-    const baselineTree = await snapshotBaseline(repo, EXEC_ID);
-    const sub = buildCursorProgressSubstrate({
-      captureMode: true,
-      gitWorkspace: true,
-      workspaceRoot: repo,
-      baselineTree,
-      executionId: EXEC_ID,
-      hitlDir,
-      storage: undefined,
-    });
-    expect(sub).toBeDefined();
-
-    await write("src/main.ts", "export const x = 2;\nexport const y = 3;\n");
-    const { delta, changed } = await sub!.capture();
-    expect(changed).toBe(true);
-    expect(delta.entries.some((e) => e.pathAfter === "src/main.ts")).toBe(true);
-  });
-
-  it("builds a hybrid substrate (git + storage) surfacing the git slice + empty CAS", async () => {
-    const baselineTree = await snapshotBaseline(repo, EXEC_ID);
-    const { storage } = makeInMemoryArtifactStorage();
-    const sub = buildCursorProgressSubstrate({
-      captureMode: true,
-      gitWorkspace: true,
-      workspaceRoot: repo,
-      baselineTree,
-      executionId: EXEC_ID,
-      hitlDir,
-      storage,
-    });
-    expect(sub).toBeDefined();
-
-    await write("src/main.ts", "export const x = 9;\n");
-    const { delta } = await sub!.capture();
-    // The git slice contributes the tracked change; the CAS sidecar is empty, so
-    // it adds nothing — total equals the git entries.
-    expect(delta.entries.some((e) => e.pathAfter === "src/main.ts")).toBe(true);
-    expect(delta.totalFilesChanged).toBe(delta.entries.length);
-  });
-
-  it("builds a non-git CAS substrate that reads the (empty) sidecar without git", async () => {
-    const { storage } = makeInMemoryArtifactStorage();
-    const sub = buildCursorProgressSubstrate({
-      captureMode: true,
-      gitWorkspace: false,
-      workspaceRoot: repo,
-      baselineTree: undefined,
-      executionId: EXEC_ID,
-      hitlDir,
-      storage,
-    });
-    expect(sub).toBeDefined();
-
-    // Even with a git change on disk, the non-git substrate ignores git entirely;
-    // the sidecar is empty, so it reports zero changed files.
-    await write("src/main.ts", "export const x = 42;\n");
-    const { delta } = await sub!.capture();
-    expect(delta.totalFilesChanged).toBe(0);
-    expect(delta.entries).toHaveLength(0);
-  });
-});