@stigmer/runner 3.15.0 → 3.15.2-dev.20260913223433

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

@@ -1,252 +0,0 @@
-/**
- * Unit tests for the DEEP-AGENT approved-command provenance adapter (DD-28).
- *
- * These pin the two things that differ from the Cursor harness: identity turn
- * scoping (a call whose id is absent from the pre-stream settled snapshot is
- * this-turn's) and same-row consent (the executed shell row carries its own
- * server-authored approval_action). The two regressions the plan calls out are
- * asserted explicitly: a seeded WAITING_APPROVAL -> COMPLETED approved shell IS
- * counted, and a prior turn's settled call is NOT re-evaluated. The DD-28 rule
- * itself is covered by shared/filereview/__tests__/command-provenance.test.ts.
- */
-
-import { describe, it, expect } from "vitest";
-import { create, type MessageInitShape } from "@bufbuild/protobuf";
-import { AgentExecutionStatusSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
-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 { SubAgentExecutionSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/subagent_pb";
-import {
-  ApprovalAction,
-  MessageType,
-  ToolCallStatus,
-} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
-
-import { deriveTurnCommandProvenance } from "../command-provenance.js";
-
-function toolCall(overrides: MessageInitShape<typeof ToolCallSchema>): ToolCall {
-  return create(ToolCallSchema, {
-    id: "call-1",
-    status: ToolCallStatus.TOOL_CALL_COMPLETED,
-    ...overrides,
-  });
-}
-
-function aiMessage(toolCalls: ToolCall[]): AgentMessage {
-  return create(AgentMessageSchema, { type: MessageType.MESSAGE_AI, toolCalls });
-}
-
-/** A COMPLETED shell row (the deep-agent shell tool is `execute`). */
-function executedShell(id: string, overrides: MessageInitShape<typeof ToolCallSchema> = {}): ToolCall {
-  return toolCall({ id, name: "execute", args: { command: "seq 1 5 > out.txt" }, ...overrides });
-}
-
-function status(messages: AgentMessage[], subAgents: MessageInitShape<typeof SubAgentExecutionSchema>[] = []) {
-  return create(AgentExecutionStatusSchema, {
-    messages,
-    subAgentExecutions: subAgents.map((sa) => create(SubAgentExecutionSchema, sa)),
-  });
-}
-
-const NO_SETTLED = new Set<string>();
-const NO_SUBAGENTS = new Set<string>();
-
-describe("deep-agent deriveTurnCommandProvenance", () => {
-  it("cites the executed shell's OWN id for a per-command approval (same-row consent)", () => {
-    const shell = executedShell("execute-1", { approvalAction: ApprovalAction.APPROVE });
-    const provenance = deriveTurnCommandProvenance({
-      status: status([aiMessage([shell])]),
-      priorSettledToolCallIds: NO_SETTLED,
-      priorSubAgentToolCallIds: NO_SUBAGENTS,
-      globalBypass: false,
-    });
-    expect(provenance).toBeDefined();
-    expect(provenance!.consentToolCallIds).toEqual(["execute-1"]);
-    expect(provenance!.authorizedByAutoApproveAll).toBe(false);
-  });
-
-  it("cites the executed shell's own id for an APPROVE_ALL on the same row", () => {
-    const shell = executedShell("execute-1", { approvalAction: ApprovalAction.APPROVE_ALL });
-    const provenance = deriveTurnCommandProvenance({
-      status: status([aiMessage([shell])]),
-      priorSettledToolCallIds: NO_SETTLED,
-      priorSubAgentToolCallIds: NO_SUBAGENTS,
-      globalBypass: false,
-    });
-    expect(provenance!.consentToolCallIds).toEqual(["execute-1"]);
-  });
-
-  it("cites a prior APPROVE_ALL lease row for a command that ran ungated under the lease", () => {
-    // Prior turn: a gated command the user approved-all (settled before this turn).
-    const leaseRow = executedShell("lease-row", {
-      status: ToolCallStatus.TOOL_CALL_COMPLETED,
-      approvalAction: ApprovalAction.APPROVE_ALL,
-    });
-    // This turn: a fresh command runs ungated under the lease — no approval_action.
-    const leased = executedShell("execute-leased");
-    const provenance = deriveTurnCommandProvenance({
-      status: status([aiMessage([leaseRow]), aiMessage([leased])]),
-      priorSettledToolCallIds: new Set(["lease-row"]), // the lease row is a prior-turn settled call
-      priorSubAgentToolCallIds: NO_SUBAGENTS,
-      globalBypass: false,
-    });
-    expect(provenance).toBeDefined();
-    expect(provenance!.consentToolCallIds).toEqual(["lease-row"]);
-  });
-
-  it("flags auto_approve_all for an ungated command under the global bypass", () => {
-    const shell = executedShell("execute-1"); // no approval_action, no lease
-    const provenance = deriveTurnCommandProvenance({
-      status: status([aiMessage([shell])]),
-      priorSettledToolCallIds: NO_SETTLED,
-      priorSubAgentToolCallIds: NO_SUBAGENTS,
-      globalBypass: true,
-    });
-    expect(provenance).toBeDefined();
-    expect(provenance!.consentToolCallIds).toEqual([]);
-    expect(provenance!.authorizedByAutoApproveAll).toBe(true);
-  });
-
-  it("fails closed on a file-tool call this turn (even under auto_approve_all)", () => {
-    const shell = executedShell("execute-1", { approvalAction: ApprovalAction.APPROVE });
-    const write = toolCall({ id: "write-1", name: "write_file", args: { path: "a.txt" } });
-    const provenance = deriveTurnCommandProvenance({
-      status: status([aiMessage([shell, write])]),
-      priorSettledToolCallIds: NO_SETTLED,
-      priorSubAgentToolCallIds: NO_SUBAGENTS,
-      globalBypass: true,
-    });
-    expect(provenance).toBeUndefined();
-  });
-
-  it("fails closed on an MCP tool this turn", () => {
-    const shell = executedShell("execute-1", { approvalAction: ApprovalAction.APPROVE });
-    const mcp = toolCall({ id: "mcp-1", name: "apply_resource", mcpServerSlug: "planton" });
-    const provenance = deriveTurnCommandProvenance({
-      status: status([aiMessage([shell, mcp])]),
-      priorSettledToolCallIds: NO_SETTLED,
-      priorSubAgentToolCallIds: NO_SUBAGENTS,
-      globalBypass: false,
-    });
-    expect(provenance).toBeUndefined();
-  });
-
-  it("fails closed on an unrecognized tool name this turn", () => {
-    const shell = executedShell("execute-1", { approvalAction: ApprovalAction.APPROVE });
-    const unknown = toolCall({ id: "u-1", name: "mystery_tool" });
-    const provenance = deriveTurnCommandProvenance({
-      status: status([aiMessage([shell, unknown])]),
-      priorSettledToolCallIds: NO_SETTLED,
-      priorSubAgentToolCallIds: NO_SUBAGENTS,
-      globalBypass: false,
-    });
-    expect(provenance).toBeUndefined();
-  });
-
-  it("fails closed on a top-level sub-agent delegation (task row this turn)", () => {
-    const shell = executedShell("execute-1", { approvalAction: ApprovalAction.APPROVE });
-    const task = toolCall({ id: "task-1", name: "task", args: { prompt: "go" } });
-    const provenance = deriveTurnCommandProvenance({
-      status: status([aiMessage([shell, task])]),
-      priorSettledToolCallIds: NO_SETTLED,
-      priorSubAgentToolCallIds: NO_SUBAGENTS,
-      globalBypass: false,
-    });
-    expect(provenance).toBeUndefined();
-  });
-
-  it("fails closed when a sub-agent produced NEW tool-call rows this turn", () => {
-    const shell = executedShell("execute-1", { approvalAction: ApprovalAction.APPROVE });
-    const subAgentShell = executedShell("sub-execute-1", { approvalAction: ApprovalAction.APPROVE });
-    const provenance = deriveTurnCommandProvenance({
-      status: status([aiMessage([shell])], [
-        { name: "worker", messages: [aiMessage([subAgentShell])] },
-      ]),
-      priorSettledToolCallIds: NO_SETTLED,
-      priorSubAgentToolCallIds: NO_SUBAGENTS, // the sub-agent row is new this turn
-      globalBypass: false,
-    });
-    expect(provenance).toBeUndefined();
-  });
-
-  it("does NOT fail closed for a sub-agent whose rows all pre-existed this turn", () => {
-    const shell = executedShell("execute-1", { approvalAction: ApprovalAction.APPROVE });
-    const priorSubShell = executedShell("sub-prior-1", { approvalAction: ApprovalAction.APPROVE });
-    const provenance = deriveTurnCommandProvenance({
-      status: status([aiMessage([shell])], [
-        { name: "worker", messages: [aiMessage([priorSubShell])] },
-      ]),
-      priorSettledToolCallIds: NO_SETTLED,
-      priorSubAgentToolCallIds: new Set(["sub-prior-1"]), // seeded from a prior turn
-      globalBypass: false,
-    });
-    expect(provenance).toBeDefined();
-    expect(provenance!.consentToolCallIds).toEqual(["execute-1"]);
-  });
-
-  it("returns undefined when no command executed this turn", () => {
-    const pending = executedShell("execute-pending", {
-      status: ToolCallStatus.TOOL_CALL_WAITING_APPROVAL,
-    });
-    const provenance = deriveTurnCommandProvenance({
-      status: status([aiMessage([pending])]),
-      priorSettledToolCallIds: NO_SETTLED,
-      priorSubAgentToolCallIds: NO_SUBAGENTS,
-      globalBypass: false,
-    });
-    expect(provenance).toBeUndefined();
-  });
-
-  // ── Regression: identity scoping (the reason positional scoping can't port) ──
-
-  it("REGRESSION counts a seeded WAITING_APPROVAL -> COMPLETED approved shell (its id was not settled pre-stream)", () => {
-    // The shell was proposed + approved in a prior segment (WAITING_APPROVAL, so
-    // NOT in the pre-stream settled snapshot) and executes in place this segment.
-    const executedThisTurn = executedShell("execute-approved", {
-      approvalAction: ApprovalAction.APPROVE,
-    });
-    const provenance = deriveTurnCommandProvenance({
-      status: status([aiMessage([executedThisTurn])]),
-      priorSettledToolCallIds: NO_SETTLED, // it was WAITING, not settled, before the stream
-      priorSubAgentToolCallIds: NO_SUBAGENTS,
-      globalBypass: false,
-    });
-    expect(provenance).toBeDefined();
-    expect(provenance!.consentToolCallIds).toEqual(["execute-approved"]);
-  });
-
-  it("REGRESSION does NOT re-count a prior turn's already-settled shell", () => {
-    const priorShell = executedShell("execute-prior", { approvalAction: ApprovalAction.APPROVE });
-    const provenance = deriveTurnCommandProvenance({
-      status: status([aiMessage([priorShell])]),
-      priorSettledToolCallIds: new Set(["execute-prior"]), // settled in a prior turn
-      priorSubAgentToolCallIds: NO_SUBAGENTS,
-      globalBypass: false,
-    });
-    // Nothing executed THIS turn -> nothing to attribute the change set to.
-    expect(provenance).toBeUndefined();
-  });
-
-  it("REGRESSION a prior turn's settled non-shell call never disqualifies this turn", () => {
-    // A prior FAILED edit must be excluded by the settled snapshot — otherwise it
-    // would trip the !== SHELL fail-closed on a clean shell-only turn.
-    const priorEdit = toolCall({
-      id: "edit-prior",
-      name: "edit_file",
-      status: ToolCallStatus.TOOL_CALL_FAILED,
-      args: { path: "a.txt" },
-    });
-    const shellThisTurn = executedShell("execute-1", { approvalAction: ApprovalAction.APPROVE });
-    const provenance = deriveTurnCommandProvenance({
-      status: status([aiMessage([priorEdit]), aiMessage([shellThisTurn])]),
-      priorSettledToolCallIds: new Set(["edit-prior"]),
-      priorSubAgentToolCallIds: NO_SUBAGENTS,
-      globalBypass: false,
-    });
-    expect(provenance).toBeDefined();
-    expect(provenance!.consentToolCallIds).toEqual(["execute-1"]);
-  });
-});

package/src/activities/execute-deep-agent/__tests__/environment.test.ts

@@ -1,108 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import { resolveEnvironment } from "../environment.js";
-
-function createMockClient(execContext: any) {
-  return {
-    // No scoped token — the OSS/local shape (no runner credential to exchange).
-    acquireScopedRunnerToken: vi.fn().mockResolvedValue(undefined),
-    getExecutionContextByExecutionId: vi.fn().mockResolvedValue(execContext),
-  } as any;
-}
-
-function createNotFoundClient() {
-  return {
-    acquireScopedRunnerToken: vi.fn().mockResolvedValue(undefined),
-    getExecutionContextByExecutionId: vi.fn().mockRejectedValue(
-      Object.assign(new Error("not found"), { code: 5 }),
-    ),
-  } as any;
-}
-
-describe("resolveEnvironment", () => {
-  it("extracts plaintext environment variables", async () => {
-    const client = createMockClient({
-      spec: {
-        data: {
-          API_URL: { value: "https://api.example.com", isSecret: false },
-          REGION: { value: "us-east-1", isSecret: false },
-        },
-      },
-    });
-
-    const result = await resolveEnvironment(client, "exec-1");
-
-    expect(result.mergedEnvVars).toEqual({
-      API_URL: "https://api.example.com",
-      REGION: "us-east-1",
-    });
-    expect(result.secretKeys.size).toBe(0);
-  });
-
-  it("tracks secret keys separately", async () => {
-    const client = createMockClient({
-      spec: {
-        data: {
-          PUBLIC_KEY: { value: "pk_123", isSecret: false },
-          SECRET_KEY: { value: "sk_456", isSecret: true },
-          API_TOKEN: { value: "tok_789", isSecret: true },
-        },
-      },
-    });
-
-    const result = await resolveEnvironment(client, "exec-2");
-
-    expect(Object.keys(result.mergedEnvVars)).toHaveLength(3);
-    expect(result.secretKeys).toEqual(new Set(["SECRET_KEY", "API_TOKEN"]));
-  });
-
-  it("returns empty result when execution context not found", async () => {
-    const client = createNotFoundClient();
-
-    const result = await resolveEnvironment(client, "exec-no-ctx");
-
-    expect(result.mergedEnvVars).toEqual({});
-    expect(result.secretKeys.size).toBe(0);
-  });
-
-  it("returns empty result when spec.data is empty", async () => {
-    const client = createMockClient({ spec: { data: {} } });
-
-    const result = await resolveEnvironment(client, "exec-empty");
-
-    expect(result.mergedEnvVars).toEqual({});
-    expect(result.secretKeys.size).toBe(0);
-  });
-
-  it("returns empty result when spec.data is undefined", async () => {
-    const client = createMockClient({ spec: {} });
-
-    const result = await resolveEnvironment(client, "exec-no-data");
-
-    expect(result.mergedEnvVars).toEqual({});
-    expect(result.secretKeys.size).toBe(0);
-  });
-
-  it("propagates non-NOT_FOUND errors", async () => {
-    const client = {
-      acquireScopedRunnerToken: vi.fn().mockResolvedValue(undefined),
-      getExecutionContextByExecutionId: vi.fn().mockRejectedValue(
-        new Error("connection refused"),
-      ),
-    } as any;
-
-    await expect(resolveEnvironment(client, "exec-err"))
-      .rejects.toThrow("connection refused");
-  });
-
-  it("handles NOT_FOUND with lowercase code", async () => {
-    const client = {
-      acquireScopedRunnerToken: vi.fn().mockResolvedValue(undefined),
-      getExecutionContextByExecutionId: vi.fn().mockRejectedValue(
-        Object.assign(new Error("not found"), { code: "not_found" }),
-      ),
-    } as any;
-
-    const result = await resolveEnvironment(client, "exec-lc");
-    expect(result.mergedEnvVars).toEqual({});
-  });
-});

package/src/activities/execute-deep-agent/__tests__/event-recorder.test.ts

@@ -1,150 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { readFile, rm } from "node:fs/promises";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { mkdtemp } from "node:fs/promises";
-import { createV2EventRecorder } from "../event-recorder.js";
-import type { StreamEvent } from "../status-builder.js";
-
-function makeEvent(eventType: string, runId: string, data: Record<string, unknown> = {}): StreamEvent {
-  return { event: eventType, run_id: runId, data };
-}
-
-describe("createV2EventRecorder", () => {
-  it("returns undefined when recordDir is undefined", () => {
-    expect(createV2EventRecorder("exec-1", undefined)).toBeUndefined();
-  });
-
-  it("returns undefined when recordDir is empty string", () => {
-    expect(createV2EventRecorder("exec-1", "")).toBeUndefined();
-  });
-
-  it("returns a recorder when recordDir is provided", () => {
-    const recorder = createV2EventRecorder("exec-1", "/tmp/test");
-    expect(recorder).toBeDefined();
-    expect(recorder!.record).toBeInstanceOf(Function);
-    expect(recorder!.flush).toBeInstanceOf(Function);
-  });
-});
-
-describe("V2EventRecorder", () => {
-  let testDir: string;
-
-  beforeEach(async () => {
-    testDir = await mkdtemp(join(tmpdir(), "v2-recorder-test-"));
-  });
-
-  it("flush is a no-op when no events are recorded", async () => {
-    const recorder = createV2EventRecorder("exec-empty", testDir)!;
-    await recorder.flush();
-
-    const files = await import("node:fs/promises").then(fs => fs.readdir(testDir));
-    expect(files).toHaveLength(0);
-  });
-
-  it("writes events to a JSON file named by execution ID", async () => {
-    const recorder = createV2EventRecorder("exec-abc", testDir)!;
-
-    recorder.record(
-      makeEvent("on_chat_model_stream", "run-1", { chunk: { content: "hello" } }),
-      0,
-    );
-    recorder.record(
-      makeEvent("on_chat_model_end", "run-1", { output: { content: "done" } }),
-      1,
-    );
-
-    await recorder.flush();
-
-    const filePath = join(testDir, "exec-abc.v2-events.json");
-    const content = JSON.parse(await readFile(filePath, "utf-8"));
-
-    expect(content.executionId).toBe("exec-abc");
-    expect(content.eventCount).toBe(2);
-    expect(content.recordedAt).toBeTruthy();
-    expect(content.events).toHaveLength(2);
-
-    expect(content.events[0].seq).toBe(0);
-    expect(content.events[0].event).toBe("on_chat_model_stream");
-    expect(content.events[0].run_id).toBe("run-1");
-    expect(content.events[0].data.chunk.content).toBe("hello");
-    expect(content.events[0].timestamp).toBeTruthy();
-
-    expect(content.events[1].seq).toBe(1);
-    expect(content.events[1].event).toBe("on_chat_model_end");
-  });
-
-  it("preserves event metadata when present", async () => {
-    const recorder = createV2EventRecorder("exec-meta", testDir)!;
-
-    recorder.record(
-      {
-        event: "on_chat_model_stream",
-        run_id: "run-1",
-        data: { chunk: { content: "text" } },
-        metadata: { langgraph_checkpoint_ns: "tools:task-1|agent_node:inner" },
-      },
-      0,
-    );
-
-    await recorder.flush();
-
-    const content = JSON.parse(
-      await readFile(join(testDir, "exec-meta.v2-events.json"), "utf-8"),
-    );
-
-    expect(content.events[0].metadata.langgraph_checkpoint_ns).toBe(
-      "tools:task-1|agent_node:inner",
-    );
-  });
-
-  it("handles circular references in event data gracefully", async () => {
-    const recorder = createV2EventRecorder("exec-circular", testDir)!;
-
-    const circular: Record<string, unknown> = { a: 1 };
-    circular.self = circular;
-
-    recorder.record(
-      { event: "on_tool_end", run_id: "run-1", data: circular },
-      0,
-    );
-
-    await recorder.flush();
-
-    const content = JSON.parse(
-      await readFile(join(testDir, "exec-circular.v2-events.json"), "utf-8"),
-    );
-
-    expect(content.events[0].data._serializationError).toBe(true);
-    expect(content.events[0].data.keys).toContain("a");
-  });
-
-  it("creates output directory if it does not exist", async () => {
-    const nestedDir = join(testDir, "nested", "deep", "dir");
-    const recorder = createV2EventRecorder("exec-mkdir", nestedDir)!;
-
-    recorder.record(makeEvent("on_chat_model_stream", "run-1", { chunk: { content: "hi" } }), 0);
-    await recorder.flush();
-
-    const content = JSON.parse(
-      await readFile(join(nestedDir, "exec-mkdir.v2-events.json"), "utf-8"),
-    );
-    expect(content.eventCount).toBe(1);
-  });
-
-  it("preserves event name field", async () => {
-    const recorder = createV2EventRecorder("exec-name", testDir)!;
-
-    recorder.record(
-      { event: "on_tool_start", name: "read_file", run_id: "tool-1", data: { input: {} } },
-      0,
-    );
-
-    await recorder.flush();
-
-    const content = JSON.parse(
-      await readFile(join(testDir, "exec-name.v2-events.json"), "utf-8"),
-    );
-    expect(content.events[0].name).toBe("read_file");
-  });
-});