@calltelemetry/openclaw-linear 0.6.1 → 0.7.1

package/src/pipeline/pipeline.ts

@@ -34,6 +34,7 @@ import {
   getActiveDispatch,
 } from "./dispatch-state.js";
 import { type NotifyFn } from "../infra/notify.js";
+import { onProjectIssueCompleted, onProjectIssueStuck } from "./dag-dispatch.js";
 import {
   saveWorkerOutput,
   saveAuditVerdict,
@@ -45,6 +46,7 @@ import {
   resolveOrchestratorWorkspace,
 } from "./artifacts.js";
 import { resolveWatchdogConfig } from "../agent/watchdog.js";
+import { emitDiagnostic } from "../infra/observability.js";
 
 // ---------------------------------------------------------------------------
 // Prompt loading
@@ -70,13 +72,29 @@ const DEFAULT_PROMPTS: PromptTemplates = {
   },
 };
 
-let _cachedPrompts: PromptTemplates | null = null;
+let _cachedGlobalPrompts: PromptTemplates | null = null;
+const _projectPromptCache = new Map<string, PromptTemplates>();
 
-export function loadPrompts(pluginConfig?: Record<string, unknown>): PromptTemplates {
-  if (_cachedPrompts) return _cachedPrompts;
+/**
+ * Merge two prompt layers. Overlay replaces individual fields per section
+ * (shallow section-level merge, not deep).
+ */
+function mergePromptLayers(base: PromptTemplates, overlay: Partial<PromptTemplates>): PromptTemplates {
+  return {
+    worker: { ...base.worker, ...overlay.worker },
+    audit: { ...base.audit, ...overlay.audit },
+    rework: { ...base.rework, ...overlay.rework },
+  };
+}
+
+/**
+ * Load global prompts (layers 1+2: hardcoded defaults + global promptsPath override).
+ * Cached after first load.
+ */
+function loadGlobalPrompts(pluginConfig?: Record<string, unknown>): PromptTemplates {
+  if (_cachedGlobalPrompts) return _cachedGlobalPrompts;
 
   try {
-    // Try custom path first
     const customPath = pluginConfig?.promptsPath as string | undefined;
     let raw: string;
 
@@ -86,27 +104,52 @@ export function loadPrompts(pluginConfig?: Record<string, unknown>): PromptTempl
         : customPath;
       raw = readFileSync(resolved, "utf-8");
     } else {
-      // Load from plugin directory (sidecar file)
       const pluginRoot = join(dirname(fileURLToPath(import.meta.url)), "../..");
       raw = readFileSync(join(pluginRoot, "prompts.yaml"), "utf-8");
     }
 
     const parsed = parseYaml(raw) as Partial<PromptTemplates>;
-    _cachedPrompts = {
-      worker: { ...DEFAULT_PROMPTS.worker, ...parsed.worker },
-      audit: { ...DEFAULT_PROMPTS.audit, ...parsed.audit },
-      rework: { ...DEFAULT_PROMPTS.rework, ...parsed.rework },
-    };
+    _cachedGlobalPrompts = mergePromptLayers(DEFAULT_PROMPTS, parsed);
   } catch {
-    _cachedPrompts = DEFAULT_PROMPTS;
+    _cachedGlobalPrompts = DEFAULT_PROMPTS;
   }
 
-  return _cachedPrompts;
+  return _cachedGlobalPrompts;
+}
+
+/**
+ * Load prompts with three-layer merge:
+ * 1. Built-in defaults (hardcoded DEFAULT_PROMPTS)
+ * 2. Global override (promptsPath or sidecar prompts.yaml)
+ * 3. Per-project override ({worktreePath}/.claw/prompts.yaml) — optional
+ */
+export function loadPrompts(pluginConfig?: Record<string, unknown>, worktreePath?: string): PromptTemplates {
+  const global = loadGlobalPrompts(pluginConfig);
+
+  if (!worktreePath) return global;
+
+  // Check per-project cache
+  const cached = _projectPromptCache.get(worktreePath);
+  if (cached) return cached;
+
+  // Try loading per-project prompts
+  try {
+    const projectPromptsPath = join(worktreePath, ".claw", "prompts.yaml");
+    const raw = readFileSync(projectPromptsPath, "utf-8");
+    const parsed = parseYaml(raw) as Partial<PromptTemplates>;
+    const merged = mergePromptLayers(global, parsed);
+    _projectPromptCache.set(worktreePath, merged);
+    return merged;
+  } catch {
+    // No per-project override — use global
+    return global;
+  }
 }
 
 /** Clear prompt cache (for testing or after config change) */
 export function clearPromptCache(): void {
-  _cachedPrompts = null;
+  _cachedGlobalPrompts = null;
+  _projectPromptCache.clear();
 }
 
 function renderTemplate(template: string, vars: Record<string, string>): string {
@@ -137,7 +180,7 @@ export function buildWorkerTask(
   worktreePath: string,
   opts?: { attempt?: number; gaps?: string[]; pluginConfig?: Record<string, unknown> },
 ): { system: string; task: string } {
-  const prompts = loadPrompts(opts?.pluginConfig);
+  const prompts = loadPrompts(opts?.pluginConfig, worktreePath);
   const vars: Record<string, string> = {
     identifier: issue.identifier,
     title: issue.title,
@@ -167,7 +210,7 @@ export function buildAuditTask(
   worktreePath: string,
   pluginConfig?: Record<string, unknown>,
 ): { system: string; task: string } {
-  const prompts = loadPrompts(pluginConfig);
+  const prompts = loadPrompts(pluginConfig, worktreePath);
   const vars: Record<string, string> = {
     identifier: issue.identifier,
     title: issue.title,
@@ -274,6 +317,7 @@ export async function triggerAudit(
   }
 
   api.logger.info(`${TAG} worker completed, triggering audit (attempt ${dispatch.attempt})`);
+  emitDiagnostic(api, { event: "phase_transition", identifier: dispatch.issueIdentifier, from: "working", to: "auditing", attempt: dispatch.attempt });
 
   // Update .claw/ manifest
   try { updateManifest(dispatch.worktreePath, { status: "auditing", attempts: dispatch.attempt }); } catch {}
@@ -464,7 +508,14 @@ async function handleAuditPass(
     if (summary) {
       writeSummary(dispatch.worktreePath, summary);
       const wsDir = resolveOrchestratorWorkspace(api, pluginConfig);
-      writeDispatchMemory(dispatch.issueIdentifier, summary, wsDir);
+      writeDispatchMemory(dispatch.issueIdentifier, summary, wsDir, {
+        title: dispatch.issueTitle ?? dispatch.issueIdentifier,
+        tier: dispatch.tier,
+        status: "done",
+        project: dispatch.project,
+        attempts: dispatch.attempt + 1,
+        model: dispatch.model,
+      });
       api.logger.info(`${TAG} .claw/ summary and memory written`);
     }
   } catch (err) {
@@ -480,6 +531,7 @@ async function handleAuditPass(
   ).catch((err) => api.logger.error(`${TAG} failed to post audit pass comment: ${err}`));
 
   api.logger.info(`${TAG} audit PASSED — dispatch completed (attempt ${dispatch.attempt})`);
+  emitDiagnostic(api, { event: "verdict_processed", identifier: dispatch.issueIdentifier, phase: "done", attempt: dispatch.attempt });
 
   await notify("audit_pass", {
     identifier: dispatch.issueIdentifier,
@@ -489,6 +541,12 @@ async function handleAuditPass(
     verdict: { pass: true, gaps: [] },
   });
 
+  // DAG cascade: if this issue belongs to a project dispatch, check for newly unblocked issues
+  if (dispatch.project) {
+    void onProjectIssueCompleted(hookCtx, dispatch.project, dispatch.issueIdentifier)
+      .catch((err) => api.logger.error(`${TAG} DAG cascade error: ${err}`));
+  }
+
   clearActiveSession(dispatch.issueId);
 }
 
@@ -531,7 +589,14 @@ async function handleAuditFail(
       if (summary) {
         writeSummary(dispatch.worktreePath, summary);
         const wsDir = resolveOrchestratorWorkspace(api, pluginConfig);
-        writeDispatchMemory(dispatch.issueIdentifier, summary, wsDir);
+        writeDispatchMemory(dispatch.issueIdentifier, summary, wsDir, {
+          title: dispatch.issueTitle ?? dispatch.issueIdentifier,
+          tier: dispatch.tier,
+          status: "stuck",
+          project: dispatch.project,
+          attempts: nextAttempt,
+          model: dispatch.model,
+        });
       }
     } catch {}
 
@@ -542,6 +607,7 @@ async function handleAuditFail(
     ).catch((err) => api.logger.error(`${TAG} failed to post escalation comment: ${err}`));
 
     api.logger.warn(`${TAG} audit FAILED ${nextAttempt}x — escalating to human`);
+    emitDiagnostic(api, { event: "verdict_processed", identifier: dispatch.issueIdentifier, phase: "stuck", attempt: nextAttempt });
 
     await notify("escalation", {
       identifier: dispatch.issueIdentifier,
@@ -552,6 +618,12 @@ async function handleAuditFail(
       verdict: { pass: false, gaps: verdict.gaps },
     });
 
+    // DAG cascade: mark this issue as stuck in the project dispatch
+    if (dispatch.project) {
+      void onProjectIssueStuck(hookCtx, dispatch.project, dispatch.issueIdentifier)
+        .catch((err) => api.logger.error(`${TAG} DAG stuck cascade error: ${err}`));
+    }
+
     return;
   }
 
@@ -579,6 +651,7 @@ async function handleAuditFail(
   ).catch((err) => api.logger.error(`${TAG} failed to post rework comment: ${err}`));
 
   api.logger.info(`${TAG} audit FAILED — rework attempt ${nextAttempt}/${maxAttempts + 1}`);
+  emitDiagnostic(api, { event: "phase_transition", identifier: dispatch.issueIdentifier, from: "auditing", to: "working", attempt: nextAttempt });
 
   await notify("audit_fail", {
     identifier: dispatch.issueIdentifier,
@@ -698,6 +771,7 @@ export async function spawnWorker(
     const thresholdSec = Math.round(wdConfig.inactivityMs / 1000);
 
     api.logger.warn(`${TAG} worker killed by inactivity watchdog 2x — escalating to stuck`);
+    emitDiagnostic(api, { event: "watchdog_kill", identifier: dispatch.issueIdentifier, attempt: dispatch.attempt });
 
     try {
       appendLog(dispatch.worktreePath, {

package/src/pipeline/planner.test.ts

@@ -0,0 +1,334 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+
+// ---------------------------------------------------------------------------
+// Mocks (vi.hoisted + vi.mock)
+// ---------------------------------------------------------------------------
+
+const { runAgentMock } = vi.hoisted(() => ({
+  runAgentMock: vi.fn().mockResolvedValue({ success: true, output: "Mock planner response" }),
+}));
+
+vi.mock("../agent/agent.js", () => ({
+  runAgent: runAgentMock,
+}));
+
+vi.mock("../api/linear-api.js", () => ({}));
+
+vi.mock("openclaw/plugin-sdk", () => ({}));
+
+const mockLinearApi = {
+  getProject: vi.fn().mockResolvedValue({
+    id: "proj-1",
+    name: "Test Project",
+    teams: { nodes: [{ id: "team-1", name: "Team" }] },
+  }),
+  getProjectIssues: vi.fn().mockResolvedValue([]),
+  getTeamStates: vi.fn().mockResolvedValue([
+    { id: "st-1", name: "Backlog", type: "backlog" },
+  ]),
+  getTeamLabels: vi.fn().mockResolvedValue([]),
+  createComment: vi.fn().mockResolvedValue("comment-id"),
+  getIssueDetails: vi.fn().mockResolvedValue({
+    id: "issue-1",
+    identifier: "PROJ-1",
+    title: "Root",
+    comments: { nodes: [] },
+    project: { id: "proj-1" },
+    team: { id: "team-1" },
+  }),
+};
+
+vi.mock("./planning-state.js", () => ({
+  registerPlanningSession: vi.fn().mockResolvedValue(undefined),
+  updatePlanningSession: vi.fn().mockResolvedValue({
+    turnCount: 1,
+    projectId: "proj-1",
+    status: "interviewing",
+  }),
+  endPlanningSession: vi.fn().mockResolvedValue(undefined),
+  setPlanningCache: vi.fn(),
+  clearPlanningCache: vi.fn(),
+}));
+
+vi.mock("../tools/planner-tools.js", () => ({
+  setActivePlannerContext: vi.fn(),
+  clearActivePlannerContext: vi.fn(),
+  buildPlanSnapshot: vi.fn().mockReturnValue("_No issues created yet._"),
+  auditPlan: vi.fn().mockReturnValue({ pass: true, problems: [], warnings: [] }),
+}));
+
+// ---------------------------------------------------------------------------
+// Imports (AFTER mocks)
+// ---------------------------------------------------------------------------
+
+import { initiatePlanningSession, handlePlannerTurn, runPlanAudit } from "./planner.js";
+import {
+  registerPlanningSession,
+  updatePlanningSession,
+  endPlanningSession,
+  setPlanningCache,
+} from "./planning-state.js";
+import {
+  setActivePlannerContext,
+  clearActivePlannerContext,
+  auditPlan,
+} from "../tools/planner-tools.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function createApi() {
+  return {
+    logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() },
+    pluginConfig: {},
+  } as any;
+}
+
+function createCtx(overrides?: Partial<{ api: any; linearApi: any; pluginConfig: any }>) {
+  return {
+    api: createApi(),
+    linearApi: mockLinearApi,
+    pluginConfig: {},
+    ...overrides,
+  };
+}
+
+function createSession(overrides?: Record<string, unknown>) {
+  return {
+    projectId: "proj-1",
+    projectName: "Test Project",
+    rootIssueId: "issue-1",
+    rootIdentifier: "PROJ-1",
+    teamId: "team-1",
+    status: "interviewing" as const,
+    startedAt: new Date().toISOString(),
+    turnCount: 0,
+    ...overrides,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Reset
+// ---------------------------------------------------------------------------
+
+afterEach(() => {
+  vi.clearAllMocks();
+  runAgentMock.mockResolvedValue({ success: true, output: "Mock planner response" });
+  vi.mocked(auditPlan).mockReturnValue({ pass: true, problems: [], warnings: [] });
+});
+
+// ---------------------------------------------------------------------------
+// initiatePlanningSession
+// ---------------------------------------------------------------------------
+
+describe("initiatePlanningSession", () => {
+  const rootIssue = {
+    id: "issue-1",
+    identifier: "PROJ-1",
+    title: "Root",
+    team: { id: "team-1" },
+  };
+
+  it("registers session in state with projectId and status interviewing", async () => {
+    const ctx = createCtx();
+    await initiatePlanningSession(ctx, "proj-1", rootIssue);
+
+    expect(registerPlanningSession).toHaveBeenCalledWith(
+      "proj-1",
+      expect.objectContaining({
+        projectId: "proj-1",
+        status: "interviewing",
+      }),
+      undefined,
+    );
+  });
+
+  it("sets planning cache with the session", async () => {
+    const ctx = createCtx();
+    await initiatePlanningSession(ctx, "proj-1", rootIssue);
+
+    expect(setPlanningCache).toHaveBeenCalledWith(
+      expect.objectContaining({
+        projectId: "proj-1",
+        projectName: "Test Project",
+        status: "interviewing",
+      }),
+    );
+  });
+
+  it("posts welcome comment containing the project name", async () => {
+    const ctx = createCtx();
+    await initiatePlanningSession(ctx, "proj-1", rootIssue);
+
+    expect(mockLinearApi.createComment).toHaveBeenCalledWith(
+      "issue-1",
+      expect.stringContaining("Test Project"),
+    );
+  });
+
+  it("fetches project metadata and team states", async () => {
+    const ctx = createCtx();
+    await initiatePlanningSession(ctx, "proj-1", rootIssue);
+
+    expect(mockLinearApi.getProject).toHaveBeenCalledWith("proj-1");
+    expect(mockLinearApi.getTeamStates).toHaveBeenCalledWith("team-1");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// handlePlannerTurn
+// ---------------------------------------------------------------------------
+
+describe("handlePlannerTurn", () => {
+  const input = {
+    issueId: "issue-1",
+    commentBody: "Let's add a search feature",
+    commentorName: "Tester",
+  };
+
+  it("increments turn count via updatePlanningSession", async () => {
+    const ctx = createCtx();
+    const session = createSession();
+    await handlePlannerTurn(ctx, session, input);
+
+    expect(updatePlanningSession).toHaveBeenCalledWith(
+      "proj-1",
+      { turnCount: 1 },
+      undefined,
+    );
+  });
+
+  it("builds plan snapshot from project issues", async () => {
+    const ctx = createCtx();
+    const session = createSession();
+    await handlePlannerTurn(ctx, session, input);
+
+    expect(mockLinearApi.getProjectIssues).toHaveBeenCalledWith("proj-1");
+  });
+
+  it("calls runAgent with system prompt", async () => {
+    const ctx = createCtx();
+    const session = createSession();
+    await handlePlannerTurn(ctx, session, input);
+
+    expect(runAgentMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        message: expect.stringContaining("planning"),
+      }),
+    );
+  });
+
+  it("posts agent response as comment", async () => {
+    const ctx = createCtx();
+    const session = createSession();
+    await handlePlannerTurn(ctx, session, input);
+
+    expect(mockLinearApi.createComment).toHaveBeenCalledWith(
+      "issue-1",
+      "Mock planner response",
+    );
+  });
+
+  it("detects finalize plan intent and triggers audit instead of regular turn", async () => {
+    const ctx = createCtx();
+    const session = createSession();
+
+    await handlePlannerTurn(ctx, session, {
+      issueId: "issue-1",
+      commentBody: "finalize plan",
+      commentorName: "Tester",
+    });
+
+    // Audit path: auditPlan is called, runAgent is NOT called
+    expect(auditPlan).toHaveBeenCalled();
+    expect(runAgentMock).not.toHaveBeenCalled();
+  });
+
+  it("detects abandon intent and ends session as abandoned", async () => {
+    const ctx = createCtx();
+    const session = createSession();
+
+    await handlePlannerTurn(ctx, session, {
+      issueId: "issue-1",
+      commentBody: "abandon",
+      commentorName: "Tester",
+    });
+
+    expect(endPlanningSession).toHaveBeenCalledWith(
+      "proj-1",
+      "abandoned",
+      undefined,
+    );
+    // Should NOT run the agent
+    expect(runAgentMock).not.toHaveBeenCalled();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// runPlanAudit
+// ---------------------------------------------------------------------------
+
+describe("runPlanAudit", () => {
+  it("posts success comment on passing audit", async () => {
+    vi.mocked(auditPlan).mockReturnValue({ pass: true, problems: [], warnings: [] });
+    const ctx = createCtx();
+    const session = createSession();
+
+    await runPlanAudit(ctx, session);
+
+    expect(mockLinearApi.createComment).toHaveBeenCalledWith(
+      "issue-1",
+      expect.stringContaining("Approved"),
+    );
+  });
+
+  it("ends session as approved on pass", async () => {
+    vi.mocked(auditPlan).mockReturnValue({ pass: true, problems: [], warnings: [] });
+    const ctx = createCtx();
+    const session = createSession();
+
+    await runPlanAudit(ctx, session);
+
+    expect(endPlanningSession).toHaveBeenCalledWith(
+      "proj-1",
+      "approved",
+      undefined,
+    );
+  });
+
+  it("posts problems on failing audit", async () => {
+    vi.mocked(auditPlan).mockReturnValue({
+      pass: false,
+      problems: ["Missing description on PROJ-2"],
+      warnings: [],
+    });
+    const ctx = createCtx();
+    const session = createSession();
+
+    await runPlanAudit(ctx, session);
+
+    expect(mockLinearApi.createComment).toHaveBeenCalledWith(
+      "issue-1",
+      expect.stringContaining("Missing description on PROJ-2"),
+    );
+  });
+
+  it("does NOT end session as approved on fail", async () => {
+    vi.mocked(auditPlan).mockReturnValue({
+      pass: false,
+      problems: ["No estimates"],
+      warnings: [],
+    });
+    const ctx = createCtx();
+    const session = createSession();
+
+    await runPlanAudit(ctx, session);
+
+    expect(endPlanningSession).not.toHaveBeenCalledWith(
+      "proj-1",
+      "approved",
+      expect.anything(),
+    );
+  });
+});