@calltelemetry/openclaw-linear 0.9.1 → 0.9.3

package/src/pipeline/dag-dispatch.test.ts

@@ -10,6 +10,8 @@ import {
   isProjectStuck,
   readProjectDispatch,
   writeProjectDispatch,
+  startProjectDispatch,
+  dispatchReadyIssues,
   onProjectIssueCompleted,
   onProjectIssueStuck,
   type ProjectIssueStatus,
@@ -550,4 +552,446 @@ describe("onProjectIssueStuck", () => {
     const result = await readProjectDispatch("proj-1", p);
     expect(result!.status).toBe("completed");
   });
+
+  it("does nothing if issue not found in dispatch", async () => {
+    const p = tmpStatePath();
+    const pd = makeProjectDispatch({
+      issues: { "PROJ-1": makeIssueStatus("PROJ-1", { dispatchStatus: "dispatched" }) },
+    });
+    await writeProjectDispatch(pd, p);
+
+    const hookCtx = makeHookCtx(p);
+    await onProjectIssueStuck(hookCtx, "proj-1", "PROJ-999");
+
+    // Should not crash, PROJ-1 remains dispatched
+    const result = await readProjectDispatch("proj-1", p);
+    expect(result!.issues["PROJ-1"].dispatchStatus).toBe("dispatched");
+  });
+
+  it("does nothing if projectDispatch is null (non-existent project)", async () => {
+    const p = tmpStatePath();
+
+    const hookCtx = makeHookCtx(p);
+    // Should not crash on non-existent project
+    await onProjectIssueStuck(hookCtx, "no-such-proj", "PROJ-1");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// buildDispatchQueue — additional branch coverage
+// ---------------------------------------------------------------------------
+
+describe("buildDispatchQueue — additional branches", () => {
+  it("ignores relations with null relatedIssue", () => {
+    const issues = [
+      makeIssue("PROJ-1", {
+        relations: [{ type: "blocks", relatedIssue: null as any }],
+      }),
+    ];
+    const queue = buildDispatchQueue(issues);
+    expect(queue["PROJ-1"].unblocks).toHaveLength(0);
+  });
+
+  it("ignores relations with undefined identifier", () => {
+    const issues = [
+      makeIssue("PROJ-1", {
+        relations: [{ type: "blocks", relatedIssue: { identifier: undefined as any } }],
+      }),
+    ];
+    const queue = buildDispatchQueue(issues);
+    expect(queue["PROJ-1"].unblocks).toHaveLength(0);
+  });
+
+  it("ignores non-blocks/non-blocked_by relation types", () => {
+    const issues = [
+      makeIssue("PROJ-1", {
+        relations: [{ type: "related", relatedIssue: { identifier: "PROJ-2" } }],
+      }),
+      makeIssue("PROJ-2"),
+    ];
+    const queue = buildDispatchQueue(issues);
+    expect(queue["PROJ-1"].unblocks).toHaveLength(0);
+    expect(queue["PROJ-1"].dependsOn).toHaveLength(0);
+    expect(queue["PROJ-2"].dependsOn).toHaveLength(0);
+    expect(queue["PROJ-2"].unblocks).toHaveLength(0);
+  });
+
+  it("filters skipped (epic) dependencies from unblocks lists", () => {
+    const issues = [
+      makeIssue("PROJ-1", {
+        relations: [{ type: "blocks", relatedIssue: { identifier: "PROJ-2" } }],
+      }),
+      makeIssue("PROJ-2", { labels: ["Epic"] }),
+    ];
+    const queue = buildDispatchQueue(issues);
+    // PROJ-1 unblocks PROJ-2 but PROJ-2 is skipped — should be filtered
+    expect(queue["PROJ-1"].unblocks).toHaveLength(0);
+  });
+
+  it("handles issues with null labels gracefully", () => {
+    const issue = {
+      id: "id-PROJ-1",
+      identifier: "PROJ-1",
+      labels: null as any,
+      relations: { nodes: [] },
+    };
+    const queue = buildDispatchQueue([issue as any]);
+    // Should not crash; labels?.nodes?.some returns falsy
+    expect(queue["PROJ-1"].dispatchStatus).toBe("pending");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// getReadyIssues — additional branch coverage
+// ---------------------------------------------------------------------------
+
+describe("getReadyIssues — additional branches", () => {
+  it("excludes stuck issues", () => {
+    const issues: Record<string, ProjectIssueStatus> = {
+      A: makeIssueStatus("A", { dispatchStatus: "stuck" }),
+    };
+    expect(getReadyIssues(issues)).toHaveLength(0);
+  });
+
+  it("excludes skipped issues", () => {
+    const issues: Record<string, ProjectIssueStatus> = {
+      A: makeIssueStatus("A", { dispatchStatus: "skipped" }),
+    };
+    expect(getReadyIssues(issues)).toHaveLength(0);
+  });
+
+  it("excludes pending issues where a dep is stuck", () => {
+    const issues: Record<string, ProjectIssueStatus> = {
+      A: makeIssueStatus("A", { dispatchStatus: "stuck" }),
+      B: makeIssueStatus("B", { dependsOn: ["A"] }),
+    };
+    expect(getReadyIssues(issues)).toHaveLength(0);
+  });
+
+  it("returns empty for empty issues", () => {
+    expect(getReadyIssues({})).toHaveLength(0);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// isProjectStuck — additional branch coverage
+// ---------------------------------------------------------------------------
+
+describe("isProjectStuck — additional branches", () => {
+  it("false when no issues at all", () => {
+    expect(isProjectStuck({})).toBe(false);
+  });
+
+  it("false when all issues are done (no stuck)", () => {
+    const issues: Record<string, ProjectIssueStatus> = {
+      A: makeIssueStatus("A", { dispatchStatus: "done" }),
+      B: makeIssueStatus("B", { dispatchStatus: "done" }),
+    };
+    expect(isProjectStuck(issues)).toBe(false);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// dispatchReadyIssues
+// ---------------------------------------------------------------------------
+
+describe("dispatchReadyIssues", () => {
+  it("returns early when no ready issues", async () => {
+    const p = tmpStatePath();
+    const hookCtx = makeHookCtx(p);
+    const pd = makeProjectDispatch({
+      issues: {
+        "PROJ-1": makeIssueStatus("PROJ-1", { dispatchStatus: "dispatched" }),
+        "PROJ-2": makeIssueStatus("PROJ-2", { dependsOn: ["PROJ-1"] }),
+      },
+    });
+
+    await dispatchReadyIssues(hookCtx, pd);
+
+    // No issues dispatched — logger.info not called for dispatching
+    expect(hookCtx.api.logger.info).not.toHaveBeenCalledWith(
+      expect.stringContaining("dispatching PROJ"),
+    );
+  });
+
+  it("returns early when all slots are filled", async () => {
+    const p = tmpStatePath();
+    const hookCtx = makeHookCtx(p);
+    const pd = makeProjectDispatch({
+      maxConcurrent: 1,
+      issues: {
+        "PROJ-1": makeIssueStatus("PROJ-1", { dispatchStatus: "dispatched" }),
+        "PROJ-2": makeIssueStatus("PROJ-2"),
+      },
+    });
+
+    await dispatchReadyIssues(hookCtx, pd);
+
+    // PROJ-2 is ready but no slots — should not be dispatched
+    expect(pd.issues["PROJ-2"].dispatchStatus).toBe("pending");
+  });
+
+  it("dispatches ready issues up to max concurrent", async () => {
+    const p = tmpStatePath();
+    const hookCtx = makeHookCtx(p);
+    const pd = makeProjectDispatch({
+      maxConcurrent: 2,
+      issues: {
+        "PROJ-1": makeIssueStatus("PROJ-1"),
+        "PROJ-2": makeIssueStatus("PROJ-2"),
+        "PROJ-3": makeIssueStatus("PROJ-3"),
+      },
+    });
+
+    await dispatchReadyIssues(hookCtx, pd);
+
+    const dispatched = Object.values(pd.issues).filter((i) => i.dispatchStatus === "dispatched");
+    expect(dispatched).toHaveLength(2);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// startProjectDispatch
+// ---------------------------------------------------------------------------
+
+describe("startProjectDispatch", () => {
+  it("creates dispatch state and dispatches leaf issues", async () => {
+    const p = tmpStatePath();
+    const mockIssues = [
+      makeIssue("PROJ-1", {
+        relations: [{ type: "blocks", relatedIssue: { identifier: "PROJ-2" } }],
+      }),
+      makeIssue("PROJ-2"),
+    ];
+
+    const hookCtx = {
+      api: {
+        logger: {
+          info: vi.fn(),
+          warn: vi.fn(),
+          error: vi.fn(),
+        },
+      } as any,
+      linearApi: {
+        getProject: vi.fn().mockResolvedValue({ id: "proj-1", name: "Test Project" }),
+        getProjectIssues: vi.fn().mockResolvedValue(mockIssues),
+      } as any,
+      notify: vi.fn().mockResolvedValue(undefined),
+      pluginConfig: { planningStatePath: p },
+      configPath: p,
+    };
+
+    await startProjectDispatch(hookCtx, "proj-1");
+
+    const result = await readProjectDispatch("proj-1", p);
+    expect(result).not.toBeNull();
+    expect(result!.status).toBe("dispatching");
+    expect(result!.projectName).toBe("Test Project");
+    expect(Object.keys(result!.issues)).toHaveLength(2);
+    expect(hookCtx.notify).toHaveBeenCalledWith("project_progress", expect.any(Object));
+  });
+
+  it("returns early when project has no issues", async () => {
+    const p = tmpStatePath();
+    const hookCtx = {
+      api: {
+        logger: {
+          info: vi.fn(),
+          warn: vi.fn(),
+          error: vi.fn(),
+        },
+      } as any,
+      linearApi: {
+        getProject: vi.fn().mockResolvedValue({ id: "proj-1", name: "Empty Project" }),
+        getProjectIssues: vi.fn().mockResolvedValue([]),
+      } as any,
+      notify: vi.fn().mockResolvedValue(undefined),
+      pluginConfig: { planningStatePath: p },
+      configPath: p,
+    };
+
+    await startProjectDispatch(hookCtx, "proj-1");
+
+    expect(hookCtx.api.logger.warn).toHaveBeenCalledWith(
+      expect.stringContaining("no issues found"),
+    );
+    const result = await readProjectDispatch("proj-1", p);
+    expect(result).toBeNull();
+  });
+
+  it("uses maxConcurrent from opts when provided", async () => {
+    const p = tmpStatePath();
+    const hookCtx = {
+      api: {
+        logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+      } as any,
+      linearApi: {
+        getProject: vi.fn().mockResolvedValue({ id: "proj-1", name: "Test" }),
+        getProjectIssues: vi.fn().mockResolvedValue([makeIssue("PROJ-1")]),
+      } as any,
+      notify: vi.fn().mockResolvedValue(undefined),
+      pluginConfig: { planningStatePath: p },
+      configPath: p,
+    };
+
+    await startProjectDispatch(hookCtx, "proj-1", { maxConcurrent: 5 });
+
+    const result = await readProjectDispatch("proj-1", p);
+    expect(result!.maxConcurrent).toBe(5);
+  });
+
+  it("uses maxConcurrent from pluginConfig when opts not provided", async () => {
+    const p = tmpStatePath();
+    const hookCtx = {
+      api: {
+        logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+      } as any,
+      linearApi: {
+        getProject: vi.fn().mockResolvedValue({ id: "proj-1", name: "Test" }),
+        getProjectIssues: vi.fn().mockResolvedValue([makeIssue("PROJ-1")]),
+      } as any,
+      notify: vi.fn().mockResolvedValue(undefined),
+      pluginConfig: { planningStatePath: p, maxConcurrentDispatches: 7 },
+      configPath: p,
+    };
+
+    await startProjectDispatch(hookCtx, "proj-1");
+
+    const result = await readProjectDispatch("proj-1", p);
+    expect(result!.maxConcurrent).toBe(7);
+  });
+
+  it("defaults maxConcurrent to 3 when no config", async () => {
+    const p = tmpStatePath();
+    const hookCtx = {
+      api: {
+        logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+      } as any,
+      linearApi: {
+        getProject: vi.fn().mockResolvedValue({ id: "proj-1", name: "Test" }),
+        getProjectIssues: vi.fn().mockResolvedValue([makeIssue("PROJ-1")]),
+      } as any,
+      notify: vi.fn().mockResolvedValue(undefined),
+      pluginConfig: { planningStatePath: p },
+      configPath: p,
+    };
+
+    await startProjectDispatch(hookCtx, "proj-1");
+
+    const result = await readProjectDispatch("proj-1", p);
+    expect(result!.maxConcurrent).toBe(3);
+  });
+
+  it("uses rootIdentifier from planning session when available", async () => {
+    const p = tmpStatePath();
+
+    // Pre-register a planning session
+    const { registerPlanningSession } = await import("./planning-state.js");
+    await registerPlanningSession("proj-1", {
+      projectId: "proj-1",
+      projectName: "Test",
+      rootIssueId: "issue-1",
+      rootIdentifier: "PLAN-100",
+      teamId: "team-1",
+      status: "approved",
+      startedAt: new Date().toISOString(),
+      turnCount: 5,
+    }, p);
+
+    const hookCtx = {
+      api: {
+        logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+      } as any,
+      linearApi: {
+        getProject: vi.fn().mockResolvedValue({ id: "proj-1", name: "Test Project" }),
+        getProjectIssues: vi.fn().mockResolvedValue([makeIssue("PROJ-1")]),
+      } as any,
+      notify: vi.fn().mockResolvedValue(undefined),
+      pluginConfig: { planningStatePath: p },
+      configPath: p,
+    };
+
+    await startProjectDispatch(hookCtx, "proj-1");
+
+    const result = await readProjectDispatch("proj-1", p);
+    expect(result!.rootIdentifier).toBe("PLAN-100");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// onProjectIssueCompleted — additional branches
+// ---------------------------------------------------------------------------
+
+describe("onProjectIssueCompleted — additional branches", () => {
+  it("does nothing when projectDispatch is null (non-existent project)", async () => {
+    const p = tmpStatePath();
+    const hookCtx = makeHookCtx(p);
+
+    // Should not crash
+    await onProjectIssueCompleted(hookCtx, "nonexistent", "PROJ-1");
+    expect(hookCtx.notify).not.toHaveBeenCalled();
+  });
+
+  it("dispatches newly ready issues after completion", async () => {
+    const p = tmpStatePath();
+    const pd = makeProjectDispatch({
+      issues: {
+        "PROJ-1": makeIssueStatus("PROJ-1", { dispatchStatus: "dispatched", unblocks: ["PROJ-2"] }),
+        "PROJ-2": makeIssueStatus("PROJ-2", { dependsOn: ["PROJ-1"] }),
+      },
+    });
+    await writeProjectDispatch(pd, p);
+
+    const hookCtx = makeHookCtx(p);
+    await onProjectIssueCompleted(hookCtx, "proj-1", "PROJ-1");
+
+    // PROJ-2 should now be dispatchable (its dep PROJ-1 is done)
+    const result = await readProjectDispatch("proj-1", p);
+    expect(result!.issues["PROJ-1"].dispatchStatus).toBe("done");
+    // Progress notification should be sent
+    expect(hookCtx.notify).toHaveBeenCalledWith("project_progress", expect.objectContaining({
+      status: expect.stringContaining("1/2"),
+    }));
+  });
+
+  it("counts only non-skipped issues in progress totals", async () => {
+    const p = tmpStatePath();
+    const pd = makeProjectDispatch({
+      issues: {
+        "PROJ-1": makeIssueStatus("PROJ-1", { dispatchStatus: "dispatched" }),
+        "PROJ-2": makeIssueStatus("PROJ-2", { dispatchStatus: "skipped" }),
+      },
+    });
+    await writeProjectDispatch(pd, p);
+
+    const hookCtx = makeHookCtx(p);
+    await onProjectIssueCompleted(hookCtx, "proj-1", "PROJ-1");
+
+    // Should count 1/1 (PROJ-2 is skipped)
+    const result = await readProjectDispatch("proj-1", p);
+    expect(result!.status).toBe("completed");
+    expect(hookCtx.notify).toHaveBeenCalledWith("project_complete", expect.objectContaining({
+      status: expect.stringContaining("1/1"),
+    }));
+  });
+});
+
+// ---------------------------------------------------------------------------
+// writeProjectDispatch — additional branches
+// ---------------------------------------------------------------------------
+
+describe("writeProjectDispatch — additional branches", () => {
+  it("initializes projectDispatches when not present in state", async () => {
+    const p = tmpStatePath();
+    // Write some base planning state first (no projectDispatches key)
+    const { writePlanningState } = await import("./planning-state.js");
+    await writePlanningState({ sessions: {}, processedEvents: [] }, p);
+
+    const pd = makeProjectDispatch();
+    await writeProjectDispatch(pd, p);
+
+    const result = await readProjectDispatch("proj-1", p);
+    expect(result).not.toBeNull();
+    expect(result!.projectId).toBe("proj-1");
+  });
 });

package/src/pipeline/e2e-dispatch.test.ts

@@ -581,4 +581,139 @@ describe("E2E dispatch pipeline", () => {
       expect(call[0]).toBe("telegram-chat-1");
     }
   });
+
+  // =========================================================================
+  // Test 9: Watchdog kill → stuck with artifact verification
+  // =========================================================================
+  it("watchdog kill writes correct artifacts (log.jsonl, manifest)", async () => {
+    const hookCtx = makeHookCtx();
+    const dispatch = makeDispatch(worktree);
+
+    await registerDispatch(dispatch.issueIdentifier, dispatch, hookCtx.configPath);
+
+    // Pre-create manifest (as webhook.ts handleDispatch would)
+    const { ensureClawDir, writeManifest } = await import("./artifacts.js");
+    ensureClawDir(worktree);
+    writeManifest(worktree, {
+      issueIdentifier: "ENG-100",
+      issueId: "issue-1",
+      tier: "small",
+      status: "dispatched",
+      attempts: 0,
+      dispatchedAt: new Date().toISOString(),
+    });
+
+    hookCtx.mockLinearApi.getIssueDetails.mockResolvedValue(
+      makeIssueDetails({ id: "issue-1", identifier: "ENG-100", title: "Fix auth" }),
+    );
+
+    runAgentMock.mockResolvedValue({
+      success: false,
+      output: "partial work before timeout",
+      watchdogKilled: true,
+    });
+
+    await spawnWorker(hookCtx, dispatch);
+
+    // State should be stuck
+    const state = await readDispatchState(hookCtx.configPath);
+    expect(state.dispatches.active["ENG-100"].status).toBe("stuck");
+    expect(state.dispatches.active["ENG-100"].stuckReason).toBe("watchdog_kill_2x");
+
+    // Artifacts should exist
+    const clawDir = join(worktree, ".claw");
+    expect(existsSync(join(clawDir, "manifest.json"))).toBe(true);
+    expect(existsSync(join(clawDir, "log.jsonl"))).toBe(true);
+
+    // Manifest should reflect stuck status
+    const manifest = JSON.parse(readFileSync(join(clawDir, "manifest.json"), "utf8"));
+    expect(manifest.status).toBe("stuck");
+    expect(manifest.attempts).toBe(1);
+
+    // Log should contain watchdog phase entry
+    const logContent = readFileSync(join(clawDir, "log.jsonl"), "utf8");
+    const logLines = logContent.trim().split("\n").map((l) => JSON.parse(l));
+    const wdEntry = logLines.find((e) => e.phase === "watchdog");
+    expect(wdEntry).toBeDefined();
+    expect(wdEntry.success).toBe(false);
+    expect(wdEntry.watchdog).toBeDefined();
+    expect(wdEntry.watchdog.reason).toBe("inactivity");
+    expect(wdEntry.watchdog.retried).toBe(true);
+    expect(wdEntry.watchdog.thresholdSec).toBeGreaterThan(0);
+    expect(wdEntry.outputPreview).toBe("partial work before timeout");
+
+    // Should NOT have audit artifacts (no audit on watchdog kill)
+    expect(existsSync(join(clawDir, "audit-0.json"))).toBe(false);
+  });
+
+  // =========================================================================
+  // Test 10: Watchdog kill comment includes remediation steps
+  // =========================================================================
+  it("watchdog kill comment includes remediation guidance", async () => {
+    const hookCtx = makeHookCtx();
+    const dispatch = makeDispatch(worktree);
+
+    await registerDispatch(dispatch.issueIdentifier, dispatch, hookCtx.configPath);
+
+    hookCtx.mockLinearApi.getIssueDetails.mockResolvedValue(
+      makeIssueDetails({ id: "issue-1", identifier: "ENG-100", title: "Fix auth" }),
+    );
+
+    runAgentMock.mockResolvedValue({
+      success: false,
+      output: "",
+      watchdogKilled: true,
+    });
+
+    await spawnWorker(hookCtx, dispatch);
+
+    // Comment should include all remediation steps
+    const commentCall = hookCtx.mockLinearApi.createComment.mock.calls[0];
+    expect(commentCall).toBeDefined();
+    const [issueId, comment] = commentCall;
+    expect(issueId).toBe("issue-1");
+    expect(comment).toContain("Agent Timed Out");
+    expect(comment).toContain("Try again");
+    expect(comment).toContain("/dispatch retry ENG-100");
+    expect(comment).toContain("Break it down");
+    expect(comment).toContain("Increase timeout");
+    expect(comment).toContain("inactivitySec");
+    expect(comment).toContain("log.jsonl");
+    expect(comment).toContain("Stuck — waiting for you");
+  });
+
+  // =========================================================================
+  // Test 11: Watchdog notification payload shape
+  // =========================================================================
+  it("watchdog kill sends notification with correct payload", async () => {
+    const hookCtx = makeHookCtx();
+    const dispatch = makeDispatch(worktree);
+
+    await registerDispatch(dispatch.issueIdentifier, dispatch, hookCtx.configPath);
+
+    hookCtx.mockLinearApi.getIssueDetails.mockResolvedValue(
+      makeIssueDetails({ id: "issue-1", identifier: "ENG-100", title: "Fix auth" }),
+    );
+
+    runAgentMock.mockResolvedValue({
+      success: false,
+      output: "",
+      watchdogKilled: true,
+    });
+
+    await spawnWorker(hookCtx, dispatch);
+
+    // Find the watchdog_kill notification
+    const wdNotify = hookCtx.notifyCalls.find(([k]) => k === "watchdog_kill");
+    expect(wdNotify).toBeDefined();
+    const [kind, payload] = wdNotify!;
+    expect(kind).toBe("watchdog_kill");
+    expect(payload).toMatchObject({
+      identifier: "ENG-100",
+      title: "Fix auth",
+      status: "stuck",
+      attempt: 0,
+    });
+    expect((payload as any).reason).toMatch(/no I\/O for \d+s/);
+  });
 });