@app-vitals/agent-runtime 0.0.1 → 0.1.1

package/cron-handler.unit.test.ts

@@ -0,0 +1,1177 @@
+/**
+ * Unit tests for cron-handler.ts's preCheck runner.
+ *
+ * Strategy: inject a FAKE spawner (matching `typeof Bun.spawn`'s shape) via
+ * `CronHandlerDeps.spawner` instead of letting the real Bun.spawn(["bun",
+ * scriptPath]) execute a child process. This removes the CI-timing
+ * dependency that came from spawning ~15 real bun processes per test run
+ * (see PR #3006 / CPS-1.1) — no real subprocess behavior is exercised here.
+ * Mirrors claude.unit.test.ts's fakeProc/mockSpawn pattern.
+ *
+ * Path-resolution tests (script-not-found via plugin format, manifest
+ * resolution, relative/absolute path resolution) still touch the real
+ * filesystem (existsSync) since that logic runs before the spawn call, but
+ * the actual spawn once a scriptPath is found still goes through the fake
+ * spawner.
+ *
+ * No test in this suite spawns a real subprocess, including the
+ * `spawner ?? Bun.spawn` default-fallback itself — that default is a single
+ * destructuring assignment (cron-handler.ts:176), the same shape as
+ * claude.ts's `spawner: typeof Bun.spawn = Bun.spawn`, whose own test suite
+ * (claude.unit.test.ts) likewise never exercises the real-Bun.spawn path
+ * with an actual child process. An earlier revision of this suite kept one
+ * real-subprocess integration test to "verify the wiring end-to-end"; it was
+ * removed after real subprocess spawns were identified as the likely source
+ * of intermittent CI failures (random `Cannot call describe()/afterEach()
+ * after the test run has completed` errors in unrelated files under GH
+ * Actions load) — see CPS-1.1.
+ */
+
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { WebClient } from "@slack/web-api";
+import {
+  ClaudeRunError,
+  type ClaudeRunResult,
+  ClaudeTimeoutError,
+  type EarlySessionIdCallback,
+  type ModelUsage,
+  type ProgressCallback,
+  type TokenUsage,
+} from "./claude.ts";
+import type { RunContextStamp } from "./context-stamp.ts";
+import { buildTokenPayload, handleCronRequest } from "./cron-handler.ts";
+import type { CronRunReporter, RunReportOpts } from "./cron-run-reporter.ts";
+import type { RunTelemetry } from "./run-telemetry.ts";
+
+// ─── Fake spawn helpers (mirrors claude.unit.test.ts) ──────────────────────
+
+interface FakeProc {
+  stdout: ReadableStream<Uint8Array>;
+  stderr: ReadableStream<Uint8Array>;
+  exited: Promise<number>;
+  kill: () => void;
+}
+
+function bodyStream(content: string): ReadableStream<Uint8Array> {
+  const enc = new TextEncoder();
+  return new ReadableStream({
+    start(controller) {
+      controller.enqueue(enc.encode(content));
+      controller.close();
+    },
+  });
+}
+
+function fakeProc(stdout: string, stderr = "", exitCode = 0): FakeProc {
+  return {
+    stdout: bodyStream(stdout),
+    stderr: bodyStream(stderr),
+    exited: Promise.resolve(exitCode),
+    kill: () => {},
+  };
+}
+
+// ─── Shared mocks ─────────────────────────────────────────────────────────────
+
+const mockPostMessage = mock(() =>
+  Promise.resolve({ ok: true, ts: "1234567890.000001" }),
+);
+const mockConversationsOpen = mock(() =>
+  Promise.resolve({ channel: { id: "D_DM_CHANNEL" } }),
+);
+const mockSlack = {
+  chat: { postMessage: mockPostMessage },
+  conversations: { open: mockConversationsOpen },
+} as unknown as WebClient;
+
+const mockRunner = mock(
+  (): Promise<{
+    result: string;
+    sessionId?: string;
+    usage?: TokenUsage;
+    totalCostUsd?: number;
+    modelUsage?: ModelUsage;
+    streamIncomplete?: boolean;
+  }> => Promise.resolve({ result: "claude reply", sessionId: "sess-1" }),
+);
+
+let mockSpawn: ReturnType<
+  typeof mock<(...args: unknown[]) => ReturnType<typeof Bun.spawn>>
+>;
+
+const deps = {
+  slack: mockSlack,
+  runner: mockRunner,
+  formatter: (text: string) => text, // identity — no markdown conversion in tests
+};
+
+afterEach(() => {
+  mockPostMessage.mockClear();
+  mockConversationsOpen.mockClear();
+  mockRunner.mockClear();
+});
+
+// ─── preCheck ─────────────────────────────────────────────────────────────────
+
+describe("handleCronRequest — preCheck", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = mkdtempSync(join(tmpdir(), "cron-test-"));
+    mkdirSync(join(tmpDir, "shipwright", "scripts"), { recursive: true });
+    mockSpawn = mock(() => fakeProc("") as ReturnType<typeof Bun.spawn>);
+  });
+
+  test("skips job when preCheck script exits 1 (no work)", async () => {
+    const script = join(tmpDir, "check.ts");
+    writeFileSync(script, "process.exit(1);");
+    mockSpawn = mock(() => fakeProc("", "", 1) as ReturnType<typeof Bun.spawn>);
+
+    await handleCronRequest(
+      { jobId: "j1", prompt: "hello", channel: "C-TEST", preCheck: script },
+      { ...deps, spawner: mockSpawn as unknown as typeof Bun.spawn },
+    );
+
+    expect(mockRunner).not.toHaveBeenCalled();
+    expect(mockPostMessage).not.toHaveBeenCalled();
+  });
+
+  test("uses preCheck output as prompt when it exits 0 with output", async () => {
+    const script = join(tmpDir, "check.ts");
+    writeFileSync(script, `console.log("precheck prompt"); process.exit(0);`);
+    mockSpawn = mock(
+      () =>
+        fakeProc("precheck prompt\n", "", 0) as ReturnType<typeof Bun.spawn>,
+    );
+
+    await handleCronRequest(
+      { jobId: "j1", prompt: "original", channel: "C-TEST", preCheck: script },
+      { ...deps, spawner: mockSpawn as unknown as typeof Bun.spawn },
+    );
+
+    expect(mockRunner).toHaveBeenCalledTimes(1);
+    const runArg = (mockRunner.mock.calls as unknown as string[][])[0][0];
+    expect(runArg).toContain("precheck prompt");
+  });
+
+  test("preCheck inherits runtime process.env mutations (env: process.env passthrough)", async () => {
+    // config-sync mutates process.env at runtime (Object.assign every 60s). The
+    // preCheck child must see those mutations, not a Bun-startup snapshot —
+    // regression for a rotated SHIPWRIGHT_TASK_STORE_TOKEN causing 401s until
+    // the pod restarted. Since the fake spawner replaces the real subprocess,
+    // this is now verified by asserting the spawner was CALLED with
+    // `env: process.env` (the same live object reference), rather than by
+    // observing a real child process read a mutated env var.
+    const script = join(tmpDir, "check.ts");
+    writeFileSync(script, `console.log("ok"); process.exit(0);`);
+    mockSpawn = mock(
+      () => fakeProc("ok\n", "", 0) as ReturnType<typeof Bun.spawn>,
+    );
+
+    await handleCronRequest(
+      {
+        jobId: "j1",
+        prompt: "original",
+        channel: "C-TEST",
+        preCheck: script,
+      },
+      { ...deps, spawner: mockSpawn as unknown as typeof Bun.spawn },
+    );
+
+    expect(mockSpawn).toHaveBeenCalledTimes(1);
+    const [, opts] = mockSpawn.mock.calls[0] as [
+      string[],
+      { env: NodeJS.ProcessEnv },
+    ];
+    // Must be the SAME live process.env object (not a boot-time snapshot) so
+    // runtime mutations (e.g. config-sync's Object.assign) are visible.
+    expect(opts.env).toBe(process.env);
+  });
+
+  test("runs preCheck with cwd = workspace (resolves state relative to workspace)", async () => {
+    // Plugin preChecks resolve state relative to process.cwd() — e.g.
+    // check-review.ts / check-deploy.ts (via check-helpers.ts) read
+    // workspace-relative files like `state/agent-policy.md`. The preCheck
+    // must run with cwd rooted at the workspace, not the agent's cwd (/app in
+    // prod). Verified here via the fake spawner's recorded call opts, since
+    // the fake replaces the real subprocess entirely.
+    const ws = join(tmpDir, "ws");
+    mkdirSync(join(ws, "state"), { recursive: true });
+    writeFileSync(join(ws, "state", "agent-policy.md"), "# Agent Policy\n");
+    const script = join(tmpDir, "check.ts");
+    writeFileSync(
+      script,
+      `import { existsSync } from "node:fs";\nconsole.log(existsSync("state/agent-policy.md") ? "HAS_STATE" : "NO_STATE");\nprocess.exit(0);`,
+    );
+    mockSpawn = mock(
+      () => fakeProc("HAS_STATE\n", "", 0) as ReturnType<typeof Bun.spawn>,
+    );
+
+    await handleCronRequest(
+      { jobId: "j1", prompt: "original", channel: "C-TEST", preCheck: script },
+      {
+        ...deps,
+        workspace: ws,
+        spawner: mockSpawn as unknown as typeof Bun.spawn,
+      },
+    );
+
+    expect(mockSpawn).toHaveBeenCalledTimes(1);
+    const [, opts] = mockSpawn.mock.calls[0] as [string[], { cwd: string }];
+    expect(opts.cwd).toBe(ws);
+
+    expect(mockRunner).toHaveBeenCalledTimes(1);
+    const runArg = (mockRunner.mock.calls as unknown as string[][])[0][0];
+    expect(runArg).toContain("HAS_STATE");
+  });
+
+  test("skips job when preCheck script not found (plugin: format)", async () => {
+    await handleCronRequest(
+      {
+        jobId: "j1",
+        prompt: "hello",
+        channel: "C-TEST",
+        preCheck: "nonexistent-plugin:check.ts",
+      },
+      {
+        ...deps,
+        pluginCacheDir: tmpDir,
+        spawner: mockSpawn as unknown as typeof Bun.spawn,
+      },
+    );
+
+    expect(mockRunner).not.toHaveBeenCalled();
+    expect(mockSpawn).not.toHaveBeenCalled();
+  });
+
+  test("preCheck exits 2 → session skipped, runner NOT called, alert posted to alertsChannel", async () => {
+    const scriptPath = join(
+      tmpDir,
+      "shipwright",
+      "scripts",
+      "check-dev-task.ts",
+    );
+    writeFileSync(
+      scriptPath,
+      `#!/usr/bin/env bun\nprocess.stderr.write("something blew up\\n");\nprocess.exit(2);\n`,
+      { mode: 0o755 },
+    );
+    mockSpawn = mock(
+      () =>
+        fakeProc("", "something blew up\n", 2) as ReturnType<typeof Bun.spawn>,
+    );
+
+    await handleCronRequest(
+      {
+        jobId: "precheck-crash",
+        prompt: "original prompt",
+        silent: true,
+        preCheck: "shipwright:check-dev-task.ts",
+      },
+      {
+        ...deps,
+        pluginCacheDir: tmpDir,
+        alertsChannel: "C_ALERTS",
+        spawner: mockSpawn as unknown as typeof Bun.spawn,
+      },
+    );
+
+    expect(mockRunner).not.toHaveBeenCalled();
+    expect(mockPostMessage).toHaveBeenCalledTimes(1);
+    const call = (
+      mockPostMessage.mock.calls as unknown as unknown[][]
+    )[0][0] as {
+      channel: string;
+      text: string;
+    };
+    expect(call.channel).toBe("C_ALERTS");
+    expect(call.text).toContain("precheck-crash");
+    expect(call.text).toContain("exit 2");
+  });
+
+  test("preCheck exits 2 with no alertsChannel → session skipped, no alert, no throw", async () => {
+    const scriptPath = join(
+      tmpDir,
+      "shipwright",
+      "scripts",
+      "check-dev-task.ts",
+    );
+    writeFileSync(scriptPath, "#!/usr/bin/env bun\nprocess.exit(2);\n", {
+      mode: 0o755,
+    });
+    mockSpawn = mock(() => fakeProc("", "", 2) as ReturnType<typeof Bun.spawn>);
+
+    await expect(
+      handleCronRequest(
+        {
+          jobId: "precheck-crash-no-alert",
+          prompt: "original prompt",
+          silent: true,
+          preCheck: "shipwright:check-dev-task.ts",
+        },
+        {
+          ...deps,
+          pluginCacheDir: tmpDir,
+          spawner: mockSpawn as unknown as typeof Bun.spawn,
+        },
+      ),
+    ).resolves.toBeUndefined();
+
+    expect(mockRunner).not.toHaveBeenCalled();
+    expect(mockPostMessage).not.toHaveBeenCalled();
+  });
+
+  test("preCheck exits 0 with no output → session skipped, runner NOT called", async () => {
+    const scriptPath = join(
+      tmpDir,
+      "shipwright",
+      "scripts",
+      "check-dev-task.ts",
+    );
+    writeFileSync(scriptPath, "#!/usr/bin/env bun\nprocess.exit(0);\n", {
+      mode: 0o755,
+    });
+    mockSpawn = mock(() => fakeProc("", "", 0) as ReturnType<typeof Bun.spawn>);
+
+    await handleCronRequest(
+      {
+        jobId: "precheck-no-output",
+        prompt: "original prompt",
+        silent: true,
+        preCheck: "shipwright:check-dev-task.ts",
+      },
+      {
+        ...deps,
+        pluginCacheDir: tmpDir,
+        spawner: mockSpawn as unknown as typeof Bun.spawn,
+      },
+    );
+
+    expect(mockRunner).not.toHaveBeenCalled();
+  });
+
+  test("preCheck script not found → warning logged, runner NOT called, no throw", async () => {
+    const warnMessages: string[] = [];
+    const originalWarn = console.warn;
+    console.warn = (...args: unknown[]) => {
+      warnMessages.push(args.map(String).join(" "));
+    };
+
+    try {
+      await expect(
+        handleCronRequest(
+          {
+            jobId: "precheck-missing",
+            prompt: "original prompt",
+            silent: true,
+            preCheck: "shipwright:check-dev-task.ts",
+          },
+          {
+            ...deps,
+            pluginCacheDir: tmpDir,
+            spawner: mockSpawn as unknown as typeof Bun.spawn,
+          },
+        ),
+      ).resolves.toBeUndefined();
+
+      expect(mockRunner).not.toHaveBeenCalled();
+      expect(mockSpawn).not.toHaveBeenCalled();
+      expect(
+        warnMessages.some((m) => m.includes("preCheck script not found")),
+      ).toBe(true);
+    } finally {
+      console.warn = originalWarn;
+    }
+  });
+
+  test("preCheck resolves via installed_plugins.json manifest (production path)", async () => {
+    const installDir = mkdtempSync(join(tmpdir(), "cron-precheck-install-"));
+    const installPath = join(installDir, "shipwright");
+    mkdirSync(join(installPath, "scripts"), { recursive: true });
+
+    const scriptPath = join(installPath, "scripts", "check-dev-task.ts");
+    writeFileSync(
+      scriptPath,
+      `#!/usr/bin/env bun\nconsole.log("manifest path works");\nprocess.exit(0);\n`,
+      { mode: 0o755 },
+    );
+
+    const manifestDir = mkdtempSync(join(tmpdir(), "cron-precheck-manifest-"));
+    const manifestPath = join(manifestDir, "installed_plugins.json");
+    writeFileSync(
+      manifestPath,
+      JSON.stringify({
+        version: 2,
+        plugins: {
+          "shipwright@app-vitals/shipwright": [{ installPath }],
+        },
+      }),
+    );
+
+    mockSpawn = mock(
+      () =>
+        fakeProc("manifest path works\n", "", 0) as ReturnType<
+          typeof Bun.spawn
+        >,
+    );
+
+    // biome-ignore lint/suspicious/noExplicitAny: test mock — sessionId optional
+    mockRunner.mockResolvedValueOnce({ result: "done [silent]" } as any);
+
+    await handleCronRequest(
+      {
+        jobId: "precheck-manifest",
+        prompt: "original prompt",
+        silent: true,
+        preCheck: "shipwright:check-dev-task.ts",
+      },
+      {
+        ...deps,
+        pluginManifestPath: manifestPath,
+        spawner: mockSpawn as unknown as typeof Bun.spawn,
+      },
+    );
+
+    expect(mockRunner).toHaveBeenCalledTimes(1);
+    const runArg = (mockRunner.mock.calls as unknown as string[][])[0][0];
+    expect(runArg).toContain("manifest path works");
+  });
+
+  test("preCheck manifest path: missing plugins.json → warning logged, runner NOT called", async () => {
+    const warnMessages: string[] = [];
+    const originalWarn = console.warn;
+    console.warn = (...args: unknown[]) => {
+      warnMessages.push(args.map(String).join(" "));
+    };
+
+    try {
+      await expect(
+        handleCronRequest(
+          {
+            jobId: "precheck-nomanifest",
+            prompt: "original prompt",
+            silent: true,
+            preCheck: "shipwright:check-dev-task.ts",
+          },
+          {
+            ...deps,
+            pluginManifestPath: join(
+              tmpDir,
+              "nonexistent_installed_plugins.json",
+            ),
+            spawner: mockSpawn as unknown as typeof Bun.spawn,
+          },
+        ),
+      ).resolves.toBeUndefined();
+
+      expect(mockRunner).not.toHaveBeenCalled();
+      expect(mockSpawn).not.toHaveBeenCalled();
+      expect(
+        warnMessages.some(
+          (m) =>
+            m.includes("failed to read installed_plugins.json") ||
+            m.includes("preCheck script not found"),
+        ),
+      ).toBe(true);
+    } finally {
+      console.warn = originalWarn;
+    }
+  });
+
+  test("relative path (./scripts/check.ts) resolves against workspace, output becomes prompt", async () => {
+    const tmpWorkspace = mkdtempSync(join(tmpdir(), "cron-precheck-relpath-"));
+    mkdirSync(join(tmpWorkspace, "scripts"), { recursive: true });
+    const scriptPath = join(tmpWorkspace, "scripts", "check.ts");
+    writeFileSync(
+      scriptPath,
+      `#!/usr/bin/env bun\nconsole.log("workspace task found");\nprocess.exit(0);\n`,
+      { mode: 0o755 },
+    );
+
+    mockSpawn = mock(
+      () =>
+        fakeProc("workspace task found\n", "", 0) as ReturnType<
+          typeof Bun.spawn
+        >,
+    );
+
+    // biome-ignore lint/suspicious/noExplicitAny: test mock — sessionId optional
+    mockRunner.mockResolvedValueOnce({ result: "done [silent]" } as any);
+
+    await handleCronRequest(
+      {
+        jobId: "precheck-relpath",
+        prompt: "original prompt",
+        silent: true,
+        preCheck: "./scripts/check.ts",
+      },
+      {
+        ...deps,
+        workspace: tmpWorkspace,
+        spawner: mockSpawn as unknown as typeof Bun.spawn,
+      },
+    );
+
+    expect(mockRunner).toHaveBeenCalledTimes(1);
+    const runArg = (mockRunner.mock.calls as unknown as string[][])[0][0];
+    expect(runArg).toContain("workspace task found");
+  });
+
+  test("absolute path resolves directly regardless of workspace", async () => {
+    const absDir = mkdtempSync(join(tmpdir(), "cron-precheck-abs-"));
+    const scriptPath = join(absDir, "absolute-check.ts");
+    writeFileSync(
+      scriptPath,
+      `#!/usr/bin/env bun\nconsole.log("absolute path works");\nprocess.exit(0);\n`,
+      { mode: 0o755 },
+    );
+
+    mockSpawn = mock(
+      () =>
+        fakeProc("absolute path works\n", "", 0) as ReturnType<
+          typeof Bun.spawn
+        >,
+    );
+
+    // biome-ignore lint/suspicious/noExplicitAny: test mock — sessionId optional
+    mockRunner.mockResolvedValueOnce({ result: "done [silent]" } as any);
+
+    await handleCronRequest(
+      {
+        jobId: "precheck-absolute",
+        prompt: "original prompt",
+        silent: true,
+        preCheck: scriptPath,
+      },
+      { ...deps, spawner: mockSpawn as unknown as typeof Bun.spawn },
+    );
+
+    expect(mockRunner).toHaveBeenCalledTimes(1);
+    const runArg = (mockRunner.mock.calls as unknown as string[][])[0][0];
+    expect(runArg).toContain("absolute path works");
+  });
+
+  test("relative path without workspace → warning, runner NOT called", async () => {
+    const warnMessages: string[] = [];
+    const originalWarn = console.warn;
+    console.warn = (...args: unknown[]) => {
+      warnMessages.push(args.map(String).join(" "));
+    };
+
+    try {
+      await expect(
+        handleCronRequest(
+          {
+            jobId: "precheck-relpath-noworkspace",
+            prompt: "original prompt",
+            silent: true,
+            preCheck: "./scripts/check.ts",
+          },
+          { ...deps, spawner: mockSpawn as unknown as typeof Bun.spawn },
+        ),
+      ).resolves.toBeUndefined();
+
+      expect(mockRunner).not.toHaveBeenCalled();
+      expect(mockSpawn).not.toHaveBeenCalled();
+      expect(
+        warnMessages.some(
+          (m) => m.includes("relative") || m.includes("workspace"),
+        ),
+      ).toBe(true);
+    } finally {
+      console.warn = originalWarn;
+    }
+  });
+
+  test("relative path script not found → warning, runner NOT called", async () => {
+    const tmpWorkspace = mkdtempSync(join(tmpdir(), "cron-precheck-notfound-"));
+    const warnMessages: string[] = [];
+    const originalWarn = console.warn;
+    console.warn = (...args: unknown[]) => {
+      warnMessages.push(args.map(String).join(" "));
+    };
+
+    try {
+      await expect(
+        handleCronRequest(
+          {
+            jobId: "precheck-relpath-notfound",
+            prompt: "original prompt",
+            silent: true,
+            preCheck: "./nonexistent.ts",
+          },
+          {
+            ...deps,
+            workspace: tmpWorkspace,
+            spawner: mockSpawn as unknown as typeof Bun.spawn,
+          },
+        ),
+      ).resolves.toBeUndefined();
+
+      expect(mockRunner).not.toHaveBeenCalled();
+      expect(mockSpawn).not.toHaveBeenCalled();
+      expect(
+        warnMessages.some((m) => m.includes("preCheck script not found")),
+      ).toBe(true);
+    } finally {
+      console.warn = originalWarn;
+    }
+  });
+});
+
+// ─── SLACK_CHANNEL_ID extraEnv (STC-1.3) ───────────────────────────────────────
+
+describe("handleCronRequest — empty text after marker stripping", () => {
+  test("channel job with marker-only output → no postMessage (avoids Slack no_text)", async () => {
+    mockRunner.mockResolvedValueOnce({ result: "[react:eyes]" } as any);
+    await handleCronRequest(
+      { jobId: "empty-ch", prompt: "hello", channel: "C-TEST" },
+      deps,
+    );
+    expect(mockPostMessage).not.toHaveBeenCalled();
+  });
+
+  test("DM job with blank output → no postMessage (avoids Slack no_text)", async () => {
+    mockRunner.mockResolvedValueOnce({ result: "   \n" } as any);
+    await handleCronRequest(
+      { jobId: "empty-dm", prompt: "hello", user: "U-DAN" },
+      deps,
+    );
+    expect(mockPostMessage).not.toHaveBeenCalled();
+  });
+});
+
+describe("handleCronRequest — SLACK_CHANNEL_ID extraEnv (STC-1.3)", () => {
+  test("channel job → runner receives { SLACK_CHANNEL_ID: <channel> } extraEnv, no SLACK_THREAD_TS", async () => {
+    await handleCronRequest(
+      { jobId: "j1", prompt: "hello", channel: "C-TEST" },
+      deps,
+    );
+
+    expect(mockRunner).toHaveBeenCalledTimes(1);
+    const call = mockRunner.mock.calls[0] as unknown as [
+      string,
+      unknown,
+      Record<string, string> | undefined,
+    ];
+    expect(call[2]).toEqual({ SLACK_CHANNEL_ID: "C-TEST" });
+  });
+
+  test("user (DM) job, conversations.open succeeds → runner receives the DM channel id as SLACK_CHANNEL_ID, and post-run delivery reuses it (no second conversations.open call)", async () => {
+    await handleCronRequest(
+      { jobId: "dm-j1", prompt: "hello", user: "U-DAN" },
+      deps,
+    );
+
+    expect(mockRunner).toHaveBeenCalledTimes(1);
+    const call = mockRunner.mock.calls[0] as unknown as [
+      string,
+      unknown,
+      Record<string, string> | undefined,
+    ];
+    expect(call[2]).toEqual({ SLACK_CHANNEL_ID: "D_DM_CHANNEL" });
+
+    // Opened once (pre-run) and reused for post-run delivery — never opened twice.
+    expect(mockConversationsOpen).toHaveBeenCalledTimes(1);
+    expect(mockPostMessage).toHaveBeenCalledTimes(1);
+    expect(
+      (mockPostMessage.mock.calls as unknown as unknown[][])[0][0],
+    ).toMatchObject({ channel: "D_DM_CHANNEL" });
+  });
+
+  test("user (DM) job, conversations.open rejects → runner still called with no SLACK_CHANNEL_ID, [agent:cron] warning logged, post-run falls back to a second conversations.open call", async () => {
+    mockConversationsOpen.mockRejectedValueOnce(
+      new Error("slack network error"),
+    );
+
+    const warnMessages: string[] = [];
+    const originalWarn = console.warn;
+    console.warn = (...args: unknown[]) => {
+      warnMessages.push(args.map(String).join(" "));
+    };
+
+    try {
+      await handleCronRequest(
+        { jobId: "dm-j2", prompt: "hello", user: "U-DAN" },
+        deps,
+      );
+    } finally {
+      console.warn = originalWarn;
+    }
+
+    expect(mockRunner).toHaveBeenCalledTimes(1);
+    const call = mockRunner.mock.calls[0] as unknown as [
+      string,
+      unknown,
+      Record<string, string> | undefined,
+    ];
+    expect(call[2]).toBeUndefined();
+
+    expect(warnMessages.some((m) => m.includes("[agent:cron]"))).toBe(true);
+
+    // Pre-resolution failed — post-run falls back to opening the DM again.
+    expect(mockConversationsOpen).toHaveBeenCalledTimes(2);
+    expect(mockPostMessage).toHaveBeenCalledTimes(1);
+    expect(
+      (mockPostMessage.mock.calls as unknown as unknown[][])[0][0],
+    ).toMatchObject({ channel: "D_DM_CHANNEL" });
+  });
+
+  test("silent job with neither channel nor user → runner called with no extraEnv", async () => {
+    await handleCronRequest(
+      { jobId: "silent-j1", prompt: "hello", silent: true },
+      deps,
+    );
+
+    expect(mockRunner).toHaveBeenCalledTimes(1);
+    const call = mockRunner.mock.calls[0] as unknown as [
+      string,
+      unknown,
+      Record<string, string> | undefined,
+    ];
+    expect(call[2]).toBeUndefined();
+  });
+});
+
+// ─── SHIPWRIGHT_GH_OWNER hint (GOR-1.3) ────────────────────────────────────
+
+describe("handleCronRequest — SHIPWRIGHT_GH_OWNER hint (GOR-1.3)", () => {
+  test("repo-less cron carries the default org, merged with SLACK_CHANNEL_ID", async () => {
+    await handleCronRequest(
+      { jobId: "gor-1", prompt: "hello", channel: "C-TEST" },
+      { ...deps, getDefaultOwner: () => "default-org" },
+    );
+    const call = mockRunner.mock.calls[0] as unknown as [
+      string,
+      unknown,
+      Record<string, string> | undefined,
+    ];
+    expect(call[2]).toEqual({
+      SLACK_CHANNEL_ID: "C-TEST",
+      SHIPWRIGHT_GH_OWNER: "default-org",
+    });
+  });
+
+  test("no resolvable default org → one warn naming cron + job id, no hint", async () => {
+    const warnMessages: string[] = [];
+    const originalWarn = console.warn;
+    console.warn = (...args: unknown[]) => {
+      warnMessages.push(args.map(String).join(" "));
+    };
+    try {
+      await handleCronRequest(
+        { jobId: "gor-2", prompt: "hello", channel: "C-TEST" },
+        { ...deps, getDefaultOwner: () => null },
+      );
+    } finally {
+      console.warn = originalWarn;
+    }
+    const call = mockRunner.mock.calls[0] as unknown as [
+      string,
+      unknown,
+      Record<string, string> | undefined,
+    ];
+    expect(call[2]).toEqual({ SLACK_CHANNEL_ID: "C-TEST" });
+    const owned = warnMessages.filter((m) => m.includes("gor-2"));
+    expect(owned).toHaveLength(1);
+    expect(owned[0]).toContain("cron");
+  });
+});
+
+// ─── onEarlySessionId wiring (CES-1.1) ──────────────────────────────────────
+//
+// The generic cron path (this file) has no session-id visibility on its
+// cron-run log until completeRun fires at the very end of a dispatch —
+// unlike loop-orchestrator.ts's dev-task dispatches, which already push an
+// early session id via the same recordSessionId() reporter method. These
+// tests assert handleCronRequest constructs a matching fire-and-forget
+// onEarlySessionId callback and forwards it into runner() as the 4th
+// positional arg, mirroring the onProgress/recordProgress wiring above.
+
+function makeSessionIdRecordingReporter(
+  recordSessionIdImpl?: (
+    cronId: string,
+    runId: string | null,
+    sessionId: string,
+  ) => Promise<void>,
+): {
+  reporter: CronRunReporter;
+  sessionIdCalls: Array<{
+    cronId: string;
+    runId: string | null;
+    sessionId: string;
+  }>;
+} {
+  const sessionIdCalls: Array<{
+    cronId: string;
+    runId: string | null;
+    sessionId: string;
+  }> = [];
+  const reporter: CronRunReporter = {
+    async createRun() {
+      return "run-early-1";
+    },
+    async completeRun() {},
+    async skipRun() {},
+    async recordProgress() {},
+    async recordSessionId(cronId, runId, sessionId) {
+      sessionIdCalls.push({ cronId, runId, sessionId });
+      if (recordSessionIdImpl)
+        await recordSessionIdImpl(cronId, runId, sessionId);
+    },
+  };
+  return { reporter, sessionIdCalls };
+}
+
+describe("handleCronRequest — onEarlySessionId wiring (CES-1.1)", () => {
+  test("runner is called with a 4th-arg onEarlySessionId callback that forwards into cronRunReporter.recordSessionId(jobId, runId, sid)", async () => {
+    const { reporter, sessionIdCalls } = makeSessionIdRecordingReporter();
+
+    let capturedOnEarlySessionId: EarlySessionIdCallback | undefined;
+    const runner = mock(
+      async (
+        _message: string,
+        _onProgress?: ProgressCallback,
+        _extraEnv?: Record<string, string>,
+        onEarlySessionId?: EarlySessionIdCallback,
+      ): Promise<ClaudeRunResult> => {
+        capturedOnEarlySessionId = onEarlySessionId;
+        return { result: "claude reply", sessionId: "sess-1" };
+      },
+    );
+
+    await handleCronRequest(
+      { jobId: "j-early", prompt: "hello", silent: true },
+      { ...deps, runner, cronRunReporter: reporter },
+    );
+
+    expect(runner).toHaveBeenCalledTimes(1);
+    expect(typeof capturedOnEarlySessionId).toBe("function");
+
+    capturedOnEarlySessionId?.("early-sess-id");
+    // recordSessionId is fire-and-forget — give its promise chain a tick.
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(sessionIdCalls).toEqual([
+      { cronId: "j-early", runId: "run-early-1", sessionId: "early-sess-id" },
+    ]);
+  });
+
+  test("a cronRunReporter.recordSessionId rejection is caught and warn-logged, never thrown — dispatch still completes normally", async () => {
+    const { reporter } = makeSessionIdRecordingReporter(async () => {
+      throw new Error("network error");
+    });
+
+    let capturedOnEarlySessionId: EarlySessionIdCallback | undefined;
+    const runner = mock(
+      async (
+        _message: string,
+        _onProgress?: ProgressCallback,
+        _extraEnv?: Record<string, string>,
+        onEarlySessionId?: EarlySessionIdCallback,
+      ): Promise<ClaudeRunResult> => {
+        capturedOnEarlySessionId = onEarlySessionId;
+        return { result: "claude reply", sessionId: "sess-2" };
+      },
+    );
+
+    const warnMessages: string[] = [];
+    const originalWarn = console.warn;
+    console.warn = (...args: unknown[]) => {
+      warnMessages.push(args.map(String).join(" "));
+    };
+
+    try {
+      await expect(
+        handleCronRequest(
+          { jobId: "j-early-fail", prompt: "hello", silent: true },
+          { ...deps, runner, cronRunReporter: reporter },
+        ),
+      ).resolves.toBeUndefined();
+
+      expect(typeof capturedOnEarlySessionId).toBe("function");
+      capturedOnEarlySessionId?.("early-sess-id-2");
+      // Let the rejected recordSessionId promise's .catch handler run.
+      await Promise.resolve();
+      await Promise.resolve();
+      await Promise.resolve();
+    } finally {
+      console.warn = originalWarn;
+    }
+
+    expect(warnMessages.some((m) => m.includes("recordSessionId failed"))).toBe(
+      true,
+    );
+  });
+});
+
+// ─── buildTokenPayload — telemetry + context-stamp extras ────────────────────
+
+describe("buildTokenPayload — extras", () => {
+  const usage = {
+    input_tokens: 10,
+    output_tokens: 20,
+    cache_read_input_tokens: 30,
+    cache_creation_input_tokens: 40,
+  };
+
+  test("without extras the payload shape is unchanged", () => {
+    const payload = buildTokenPayload(usage, undefined);
+    expect(payload).toEqual({
+      inputTokens: 10,
+      outputTokens: 20,
+      cacheReadTokens: 30,
+      cacheCreationTokens: 40,
+    });
+  });
+
+  test("telemetry maps firstTurn → contextBaseline and forwards counts and skillUsage", () => {
+    const payload = buildTokenPayload(usage, undefined, {
+      telemetry: {
+        firstTurn: {
+          model: "claude-sonnet-4-6",
+          messageId: "msg_1",
+          inputTokens: 2,
+          cacheCreationTokens: 41_415,
+          cacheReadTokens: 37_771,
+          contextTokens: 79_188,
+        },
+        turns: 5,
+        toolCalls: 3,
+        skillUsage: [
+          {
+            kind: "root",
+            name: "root",
+            invocations: 0,
+            turns: 1,
+            inputTokens: 2,
+            outputTokens: 10,
+            cacheReadTokens: 0,
+            cacheCreationTokens: 0,
+            invokeContextDelta: null,
+          },
+        ],
+      },
+      contextStamp: {
+        contextFingerprint: "abc123def456",
+        pluginVersion: "1.363.0",
+        claudeCodeVersion: "2.1.285",
+      },
+    });
+
+    expect(payload.contextBaseline).toEqual({
+      model: "claude-sonnet-4-6",
+      contextTokens: 79_188,
+      inputTokens: 2,
+      cacheCreationTokens: 41_415,
+      cacheReadTokens: 37_771,
+    });
+    expect(payload.turns).toBe(5);
+    expect(payload.toolCalls).toBe(3);
+    expect(payload.skillUsage).toHaveLength(1);
+    expect(payload.contextFingerprint).toBe("abc123def456");
+    expect(payload.pluginVersion).toBe("1.363.0");
+    expect(payload.claudeCodeVersion).toBe("2.1.285");
+  });
+
+  test("telemetry without a firstTurn (resumed session) omits contextBaseline but keeps counts", () => {
+    const payload = buildTokenPayload(undefined, undefined, {
+      telemetry: { turns: 2, toolCalls: 0, skillUsage: [] },
+    });
+    expect("contextBaseline" in payload).toBe(false);
+    expect("skillUsage" in payload).toBe(false);
+    expect(payload.turns).toBe(2);
+    expect(payload.toolCalls).toBe(0);
+  });
+
+  test("a stamp with null versions sends only the fingerprint", () => {
+    const payload = buildTokenPayload(undefined, undefined, {
+      contextStamp: {
+        contextFingerprint: "feedfacecafe",
+        pluginVersion: null,
+        claudeCodeVersion: null,
+      },
+    });
+    expect(payload.contextFingerprint).toBe("feedfacecafe");
+    expect("pluginVersion" in payload).toBe(false);
+    expect("claudeCodeVersion" in payload).toBe(false);
+  });
+});
+
+// ─── handleCronRequest — telemetry + context-stamp forwarding (PAU-1.4) ──────
+
+describe("handleCronRequest — telemetry forwarding", () => {
+  const telemetry: RunTelemetry = {
+    firstTurn: {
+      model: "claude-sonnet-4-6",
+      messageId: "msg_1",
+      inputTokens: 2,
+      cacheCreationTokens: 100,
+      cacheReadTokens: 50,
+      contextTokens: 152,
+    },
+    turns: 4,
+    toolCalls: 2,
+    skillUsage: [],
+  };
+  const stamp: RunContextStamp = {
+    contextFingerprint: "abc123def456",
+    pluginVersion: "1.2.3",
+    claudeCodeVersion: "2.1.0",
+  };
+
+  function recordingReporter(): {
+    reporter: CronRunReporter;
+    completes: Array<{ outcome: string; opts?: RunReportOpts }>;
+  } {
+    const completes: Array<{ outcome: string; opts?: RunReportOpts }> = [];
+    const reporter: CronRunReporter = {
+      async createRun() {
+        return "run-t1";
+      },
+      async completeRun(_c, _r, _t, outcome, opts) {
+        completes.push({ outcome, opts });
+      },
+      async skipRun() {},
+      async recordProgress() {},
+      async recordSessionId() {},
+    };
+    return { reporter, completes };
+  }
+
+  test("completion forwards telemetry and the stamp to completeRun", async () => {
+    const { reporter, completes } = recordingReporter();
+    const runner = mock(
+      async (): Promise<ClaudeRunResult> => ({
+        result: "ok",
+        sessionId: "s1",
+        telemetry,
+      }),
+    );
+    await handleCronRequest(
+      { jobId: "j-tel", prompt: "p", silent: true },
+      { ...deps, runner, cronRunReporter: reporter, contextStamp: () => stamp },
+    );
+    expect(completes).toHaveLength(1);
+    expect(completes[0]?.opts).toMatchObject({
+      turns: 4,
+      toolCalls: 2,
+      contextFingerprint: "abc123def456",
+      pluginVersion: "1.2.3",
+      claudeCodeVersion: "2.1.0",
+      contextBaseline: { model: "claude-sonnet-4-6", contextTokens: 152 },
+    });
+  });
+
+  test("a ClaudeTimeoutError's partialTelemetry is forwarded on the failed completeRun", async () => {
+    const { reporter, completes } = recordingReporter();
+    const runner = mock(async (): Promise<ClaudeRunResult> => {
+      throw new ClaudeTimeoutError(
+        1000,
+        "ceiling",
+        undefined,
+        undefined,
+        telemetry,
+      );
+    });
+    await handleCronRequest(
+      { jobId: "j-tel-to", prompt: "p", silent: true },
+      { ...deps, runner, cronRunReporter: reporter, contextStamp: () => stamp },
+    ).catch(() => {});
+    expect(completes[0]?.outcome).toBe("failed");
+    expect(completes[0]?.opts).toMatchObject({
+      turns: 4,
+      contextFingerprint: "abc123def456",
+    });
+  });
+
+  test("a ClaudeRunError's partialTelemetry is forwarded; tokens are not", async () => {
+    const { reporter, completes } = recordingReporter();
+    const runner = mock(async (): Promise<ClaudeRunResult> => {
+      throw new ClaudeRunError(
+        "boom",
+        undefined,
+        "boom",
+        undefined,
+        undefined,
+        telemetry,
+      );
+    });
+    await handleCronRequest(
+      { jobId: "j-tel-re", prompt: "p", silent: true },
+      { ...deps, runner, cronRunReporter: reporter },
+    ).catch(() => {});
+    expect(completes[0]?.outcome).toBe("failed");
+    expect(completes[0]?.opts?.toolCalls).toBe(2);
+    expect(completes[0]?.opts?.contextFingerprint).toBeUndefined();
+    expect(completes[0]?.opts?.inputTokens).toBeUndefined();
+  });
+
+  test("a streamIncomplete run's telemetry is forwarded on the failed completeRun", async () => {
+    const { reporter, completes } = recordingReporter();
+    const runner = mock(
+      async (): Promise<ClaudeRunResult> => ({
+        result: "",
+        streamIncomplete: true,
+        telemetry,
+      }),
+    );
+    await handleCronRequest(
+      { jobId: "j-tel-si", prompt: "p", silent: true },
+      { ...deps, runner, cronRunReporter: reporter },
+    ).catch(() => {});
+    expect(completes[0]?.outcome).toBe("failed");
+    expect(completes[0]?.opts?.turns).toBe(4);
+    expect(completes[0]?.opts?.toolCalls).toBe(2);
+  });
+
+  test("without a contextStamp dep nothing extra is reported and the run does not error", async () => {
+    const { reporter, completes } = recordingReporter();
+    const runner = mock(
+      async (): Promise<ClaudeRunResult> => ({ result: "ok" }),
+    );
+    await handleCronRequest(
+      { jobId: "j-tel-none", prompt: "p", silent: true },
+      { ...deps, runner, cronRunReporter: reporter },
+    );
+    expect(completes[0]?.outcome).toBe("completed");
+    expect(completes[0]?.opts).not.toHaveProperty("contextFingerprint");
+    expect(completes[0]?.opts).not.toHaveProperty("turns");
+    expect(completes[0]?.opts).not.toHaveProperty("contextBaseline");
+  });
+
+  test("a throwing contextStamp reader is warn-logged and the run proceeds unstamped", async () => {
+    const { reporter, completes } = recordingReporter();
+    const runner = mock(
+      async (): Promise<ClaudeRunResult> => ({ result: "ok", telemetry }),
+    );
+    const warnings: string[] = [];
+    const originalWarn = console.warn;
+    console.warn = (...a: unknown[]) => {
+      warnings.push(a.map(String).join(" "));
+    };
+    try {
+      await handleCronRequest(
+        { jobId: "j-tel-throw", prompt: "p", silent: true },
+        {
+          ...deps,
+          runner,
+          cronRunReporter: reporter,
+          contextStamp: () => {
+            throw new Error("fs boom");
+          },
+        },
+      );
+    } finally {
+      console.warn = originalWarn;
+    }
+    expect(warnings.some((w) => w.includes("context stamp failed"))).toBe(true);
+    expect(completes[0]?.outcome).toBe("completed");
+    expect(completes[0]?.opts?.turns).toBe(4);
+    expect(completes[0]?.opts?.contextFingerprint).toBeUndefined();
+  });
+});