@calltelemetry/openclaw-linear 0.7.0 → 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.ts

@@ -149,13 +149,14 @@ export async function handlePlannerTurn(
   ctx: PlannerContext,
   session: PlanningSession,
   input: { issueId: string; commentBody: string; commentorName: string },
+  opts?: { onApproved?: (projectId: string) => void },
 ): Promise<void> {
   const { api, linearApi, pluginConfig } = ctx;
   const configPath = pluginConfig?.planningStatePath as string | undefined;
 
   // Detect finalization intent
   if (FINALIZE_PATTERN.test(input.commentBody)) {
-    await runPlanAudit(ctx, session);
+    await runPlanAudit(ctx, session, { onApproved: opts?.onApproved });
     return;
   }
 
@@ -234,6 +235,7 @@ export async function handlePlannerTurn(
 export async function runPlanAudit(
   ctx: PlannerContext,
   session: PlanningSession,
+  opts?: { onApproved?: (projectId: string) => void },
 ): Promise<void> {
   const { api, linearApi, pluginConfig } = ctx;
   const configPath = pluginConfig?.planningStatePath as string | undefined;
@@ -262,6 +264,9 @@ export async function runPlanAudit(
 
     await endPlanningSession(session.projectId, "approved", configPath);
     api.logger.info(`Planning: session approved for ${session.projectName}`);
+
+    // Trigger DAG-based dispatch if callback provided
+    opts?.onApproved?.(session.projectId);
   } else {
     // Post problems and keep planning
     const problemsList = result.problems.map((p) => `- ${p}`).join("\n");

package/src/pipeline/planning-state.ts

@@ -48,48 +48,10 @@ function resolveStatePath(configPath?: string): string {
 }
 
 // ---------------------------------------------------------------------------
-// File locking
+// File locking (shared utility)
 // ---------------------------------------------------------------------------
 
-const LOCK_STALE_MS = 30_000;
-const LOCK_RETRY_MS = 50;
-const LOCK_TIMEOUT_MS = 10_000;
-
-function lockPath(statePath: string): string {
-  return statePath + ".lock";
-}
-
-async function acquireLock(statePath: string): Promise<void> {
-  const lock = lockPath(statePath);
-  const deadline = Date.now() + LOCK_TIMEOUT_MS;
-
-  while (Date.now() < deadline) {
-    try {
-      await fs.writeFile(lock, String(Date.now()), { flag: "wx" });
-      return;
-    } catch (err: any) {
-      if (err.code !== "EEXIST") throw err;
-
-      try {
-        const content = await fs.readFile(lock, "utf-8");
-        const lockTime = Number(content);
-        if (Date.now() - lockTime > LOCK_STALE_MS) {
-          try { await fs.unlink(lock); } catch { /* race */ }
-          continue;
-        }
-      } catch { /* lock disappeared — retry */ }
-
-      await new Promise((r) => setTimeout(r, LOCK_RETRY_MS));
-    }
-  }
-
-  try { await fs.unlink(lockPath(statePath)); } catch { /* ignore */ }
-  await fs.writeFile(lock, String(Date.now()), { flag: "wx" });
-}
-
-async function releaseLock(statePath: string): Promise<void> {
-  try { await fs.unlink(lockPath(statePath)); } catch { /* already removed */ }
-}
+import { acquireLock, releaseLock } from "../infra/file-lock.js";
 
 // ---------------------------------------------------------------------------
 // Read / Write

package/src/pipeline/tier-assess.test.ts

@@ -0,0 +1,175 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { TIER_MODELS, assessTier, type IssueContext } from "./tier-assess.js";
+
+// ---------------------------------------------------------------------------
+// Mock runAgent
+// ---------------------------------------------------------------------------
+
+const mockRunAgent = vi.fn();
+
+vi.mock("../agent/agent.js", () => ({
+  runAgent: (...args: unknown[]) => mockRunAgent(...args),
+}));
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeApi(overrides?: { defaultAgentId?: string }) {
+  return {
+    logger: {
+      info: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+    },
+    pluginConfig: {
+      defaultAgentId: overrides?.defaultAgentId,
+    },
+  } as any;
+}
+
+function makeIssue(overrides?: Partial<IssueContext>): IssueContext {
+  return {
+    identifier: "CT-123",
+    title: "Fix login bug",
+    description: "Users cannot log in when using SSO",
+    labels: ["bug"],
+    commentCount: 2,
+    ...overrides,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("TIER_MODELS", () => {
+  it("maps junior to haiku, medior to sonnet, senior to opus", () => {
+    expect(TIER_MODELS.junior).toBe("anthropic/claude-haiku-4-5");
+    expect(TIER_MODELS.medior).toBe("anthropic/claude-sonnet-4-6");
+    expect(TIER_MODELS.senior).toBe("anthropic/claude-opus-4-6");
+  });
+});
+
+describe("assessTier", () => {
+  beforeEach(() => {
+    mockRunAgent.mockReset();
+  });
+
+  it("returns parsed tier from agent response", async () => {
+    mockRunAgent.mockResolvedValue({
+      success: true,
+      output: '{"tier":"senior","reasoning":"Multi-service architecture change"}',
+    });
+
+    const api = makeApi({ defaultAgentId: "mal" });
+    const result = await assessTier(api, makeIssue());
+
+    expect(result.tier).toBe("senior");
+    expect(result.model).toBe(TIER_MODELS.senior);
+    expect(result.reasoning).toBe("Multi-service architecture change");
+    expect(api.logger.info).toHaveBeenCalled();
+  });
+
+  it("falls back to medior when agent fails (success: false) with no parseable JSON", async () => {
+    mockRunAgent.mockResolvedValue({
+      success: false,
+      output: "Agent process exited with code 1",
+    });
+
+    const api = makeApi({ defaultAgentId: "mal" });
+    const result = await assessTier(api, makeIssue());
+
+    expect(result.tier).toBe("medior");
+    expect(result.model).toBe(TIER_MODELS.medior);
+    expect(result.reasoning).toBe("Assessment failed — defaulting to medior");
+    expect(api.logger.warn).toHaveBeenCalled();
+  });
+
+  it("falls back to medior when output has no JSON", async () => {
+    mockRunAgent.mockResolvedValue({
+      success: true,
+      output: "I think this is a medium complexity issue because it involves multiple files.",
+    });
+
+    const api = makeApi({ defaultAgentId: "mal" });
+    const result = await assessTier(api, makeIssue());
+
+    expect(result.tier).toBe("medior");
+    expect(result.model).toBe(TIER_MODELS.medior);
+    expect(result.reasoning).toBe("Assessment failed — defaulting to medior");
+  });
+
+  it("falls back to medior when JSON has invalid tier", async () => {
+    mockRunAgent.mockResolvedValue({
+      success: true,
+      output: '{"tier":"expert","reasoning":"Very hard problem"}',
+    });
+
+    const api = makeApi({ defaultAgentId: "mal" });
+    const result = await assessTier(api, makeIssue());
+
+    expect(result.tier).toBe("medior");
+    expect(result.model).toBe(TIER_MODELS.medior);
+  });
+
+  it("handles agent throwing an error", async () => {
+    mockRunAgent.mockRejectedValue(new Error("Connection refused"));
+
+    const api = makeApi({ defaultAgentId: "mal" });
+    const result = await assessTier(api, makeIssue());
+
+    expect(result.tier).toBe("medior");
+    expect(result.model).toBe(TIER_MODELS.medior);
+    expect(result.reasoning).toBe("Assessment failed — defaulting to medior");
+    expect(api.logger.warn).toHaveBeenCalledWith(
+      expect.stringContaining("Tier assessment error for CT-123"),
+    );
+  });
+
+  it("truncates long descriptions to 1500 chars", async () => {
+    const longDescription = "A".repeat(3000);
+    mockRunAgent.mockResolvedValue({
+      success: true,
+      output: '{"tier":"junior","reasoning":"Simple copy change"}',
+    });
+
+    const api = makeApi({ defaultAgentId: "mal" });
+    await assessTier(api, makeIssue({ description: longDescription }));
+
+    // Verify the message sent to runAgent has the description truncated
+    const callArgs = mockRunAgent.mock.calls[0][0];
+    const message: string = callArgs.message;
+    // The description in the prompt should be at most 1500 chars of the original
+    // "Description: " prefix + 1500 chars = the truncated form
+    expect(message).toContain("Description: " + "A".repeat(1500));
+    expect(message).not.toContain("A".repeat(1501));
+  });
+
+  it("uses configured agentId when provided", async () => {
+    mockRunAgent.mockResolvedValue({
+      success: true,
+      output: '{"tier":"junior","reasoning":"Typo fix"}',
+    });
+
+    const api = makeApi({ defaultAgentId: "mal" });
+    await assessTier(api, makeIssue(), "kaylee");
+
+    const callArgs = mockRunAgent.mock.calls[0][0];
+    expect(callArgs.agentId).toBe("kaylee");
+  });
+
+  it("parses JSON even when wrapped in markdown fences", async () => {
+    mockRunAgent.mockResolvedValue({
+      success: true,
+      output: '```json\n{"tier":"junior","reasoning":"Config tweak"}\n```',
+    });
+
+    const api = makeApi({ defaultAgentId: "mal" });
+    const result = await assessTier(api, makeIssue());
+
+    expect(result.tier).toBe("junior");
+    expect(result.model).toBe(TIER_MODELS.junior);
+    expect(result.reasoning).toBe("Config tweak");
+  });
+});

package/src/pipeline/webhook.ts

@@ -12,6 +12,8 @@ import { createWorktree, prepareWorkspace } from "../infra/codex-worktree.js";
 import { ensureClawDir, writeManifest } from "./artifacts.js";
 import { readPlanningState, isInPlanningMode, getPlanningSession } from "./planning-state.js";
 import { initiatePlanningSession, handlePlannerTurn } from "./planner.js";
+import { startProjectDispatch } from "./dag-dispatch.js";
+import { emitDiagnostic } from "../infra/observability.js";
 
 // ── Agent profiles (loaded from config, no hardcoded names) ───────
 interface AgentProfile {
@@ -148,6 +150,7 @@ export async function handleLinearWebhook(
   // Debug: log full payload structure for diagnosing webhook types
   const payloadKeys = Object.keys(payload).join(", ");
   api.logger.info(`Linear webhook received: type=${payload.type} action=${payload.action} keys=[${payloadKeys}]`);
+  emitDiagnostic(api, { event: "webhook_received", webhookType: payload.type, webhookAction: payload.action });
 
 
   // ── AppUserNotification — OAuth app webhook for agent mentions/assignments
@@ -666,6 +669,8 @@ export async function handleLinearWebhook(
     const issue = comment?.issue ?? payload.issue;
 
     // ── Planning mode intercept ──────────────────────────────────
+    const pluginConfig = (api as any).pluginConfig as Record<string, unknown> | undefined;
+
     if (issue?.id) {
       const linearApiForPlanning = createLinearApi(api);
       if (linearApiForPlanning) {
@@ -698,6 +703,20 @@ export async function handleLinearWebhook(
                   { api, linearApi: linearApiForPlanning, pluginConfig },
                   session,
                   { issueId: issue.id, commentBody, commentorName: commentor },
+                  {
+                    onApproved: (approvedProjectId) => {
+                      const notify = createNotifierFromConfig(pluginConfig, api.runtime);
+                      const hookCtx: HookContext = {
+                        api,
+                        linearApi: linearApiForPlanning,
+                        notify,
+                        pluginConfig,
+                        configPath: pluginConfig?.dispatchStatePath as string | undefined,
+                      };
+                      void startProjectDispatch(hookCtx, approvedProjectId)
+                        .catch((err) => api.logger.error(`Project dispatch start error: ${err}`));
+                    },
+                  },
                 ).catch((err) => api.logger.error(`Planner turn error: ${err}`));
               }
               return true;
@@ -1283,6 +1302,7 @@ async function handleDispatch(
   });
 
   api.logger.info(`@dispatch: ${identifier} assessed as ${assessment.tier} (${assessment.model}) — ${assessment.reasoning}`);
+  emitDiagnostic(api, { event: "dispatch_started", identifier, tier: assessment.tier, issueId: issue.id });
 
   // 5. Create persistent worktree
   let worktree;
@@ -1351,6 +1371,7 @@ async function handleDispatch(
     dispatchedAt: now,
     agentSessionId,
     attempt: 0,
+    project: enrichedIssue?.project?.id,
   }, statePath);
 
   // 8. Register active session for tool resolution