@calltelemetry/openclaw-linear 0.5.1 → 0.6.0

package/src/pipeline/artifacts.test.ts

@@ -0,0 +1,383 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { mkdtempSync, readFileSync, writeFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+// Mock pipeline.js to break the import chain: artifacts → pipeline → agent → extensionAPI
+vi.mock("./pipeline.js", () => ({}));
+
+import {
+  ensureClawDir,
+  ensureGitignore,
+  writeManifest,
+  readManifest,
+  updateManifest,
+  saveWorkerOutput,
+  savePlan,
+  saveAuditVerdict,
+  appendLog,
+  writeSummary,
+  buildSummaryFromArtifacts,
+  writeDispatchMemory,
+  resolveOrchestratorWorkspace,
+  type ClawManifest,
+  type LogEntry,
+} from "./artifacts.js";
+
+function makeTmpDir(): string {
+  return mkdtempSync(join(tmpdir(), "claw-test-"));
+}
+
+function makeManifest(overrides?: Partial<ClawManifest>): ClawManifest {
+  return {
+    issueIdentifier: "API-100",
+    issueTitle: "Fix login bug",
+    issueId: "id-123",
+    tier: "junior",
+    model: "test-model",
+    dispatchedAt: "2026-01-01T00:00:00Z",
+    worktreePath: "/tmp/test",
+    branch: "codex/API-100",
+    attempts: 0,
+    status: "dispatched",
+    plugin: "linear",
+    ...overrides,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// ensureClawDir
+// ---------------------------------------------------------------------------
+
+describe("ensureClawDir", () => {
+  it("creates .claw/ directory and returns path", () => {
+    const tmp = makeTmpDir();
+    const result = ensureClawDir(tmp);
+    expect(result).toBe(join(tmp, ".claw"));
+    expect(existsSync(result)).toBe(true);
+  });
+
+  it("is idempotent", () => {
+    const tmp = makeTmpDir();
+    const first = ensureClawDir(tmp);
+    const second = ensureClawDir(tmp);
+    expect(first).toBe(second);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// ensureGitignore
+// ---------------------------------------------------------------------------
+
+describe("ensureGitignore", () => {
+  it("creates .gitignore with .claw/ entry", () => {
+    const tmp = makeTmpDir();
+    ensureGitignore(tmp);
+    const content = readFileSync(join(tmp, ".gitignore"), "utf-8");
+    expect(content).toContain(".claw/");
+  });
+
+  it("appends to existing .gitignore", () => {
+    const tmp = makeTmpDir();
+    writeFileSync(join(tmp, ".gitignore"), "node_modules/\n", "utf-8");
+    ensureGitignore(tmp);
+    const content = readFileSync(join(tmp, ".gitignore"), "utf-8");
+    expect(content).toContain("node_modules/");
+    expect(content).toContain(".claw/");
+  });
+
+  it("does not duplicate entry", () => {
+    const tmp = makeTmpDir();
+    ensureGitignore(tmp);
+    ensureGitignore(tmp);
+    const content = readFileSync(join(tmp, ".gitignore"), "utf-8");
+    const matches = content.match(/\.claw\//g);
+    expect(matches).toHaveLength(1);
+  });
+
+  it("handles file without trailing newline", () => {
+    const tmp = makeTmpDir();
+    writeFileSync(join(tmp, ".gitignore"), "node_modules/", "utf-8"); // no trailing \n
+    ensureGitignore(tmp);
+    const content = readFileSync(join(tmp, ".gitignore"), "utf-8");
+    expect(content).toBe("node_modules/\n.claw/\n");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Manifest CRUD
+// ---------------------------------------------------------------------------
+
+describe("manifest", () => {
+  it("write + read round-trip", () => {
+    const tmp = makeTmpDir();
+    const manifest = makeManifest({ worktreePath: tmp });
+    writeManifest(tmp, manifest);
+    const read = readManifest(tmp);
+    expect(read).toEqual(manifest);
+  });
+
+  it("readManifest returns null when missing", () => {
+    const tmp = makeTmpDir();
+    expect(readManifest(tmp)).toBeNull();
+  });
+
+  it("updateManifest merges partial updates", () => {
+    const tmp = makeTmpDir();
+    writeManifest(tmp, makeManifest({ worktreePath: tmp }));
+    updateManifest(tmp, { status: "working", attempts: 1 });
+    const read = readManifest(tmp);
+    expect(read!.status).toBe("working");
+    expect(read!.attempts).toBe(1);
+    expect(read!.issueIdentifier).toBe("API-100"); // preserved
+  });
+
+  it("updateManifest no-op when no manifest", () => {
+    const tmp = makeTmpDir();
+    // Should not throw
+    updateManifest(tmp, { status: "done" });
+    expect(readManifest(tmp)).toBeNull();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Phase artifacts
+// ---------------------------------------------------------------------------
+
+describe("saveWorkerOutput", () => {
+  it("writes worker-{N}.md", () => {
+    const tmp = makeTmpDir();
+    saveWorkerOutput(tmp, 0, "hello world");
+    const content = readFileSync(join(tmp, ".claw", "worker-0.md"), "utf-8");
+    expect(content).toBe("hello world");
+  });
+
+  it("truncates at 8192 bytes", () => {
+    const tmp = makeTmpDir();
+    const longOutput = "x".repeat(10000);
+    saveWorkerOutput(tmp, 1, longOutput);
+    const content = readFileSync(join(tmp, ".claw", "worker-1.md"), "utf-8");
+    expect(content.length).toBeLessThan(10000);
+    expect(content).toContain("--- truncated ---");
+  });
+
+  it("does not truncate under limit", () => {
+    const tmp = makeTmpDir();
+    const shortOutput = "y".repeat(100);
+    saveWorkerOutput(tmp, 2, shortOutput);
+    const content = readFileSync(join(tmp, ".claw", "worker-2.md"), "utf-8");
+    expect(content).toBe(shortOutput);
+  });
+});
+
+describe("savePlan", () => {
+  it("writes plan.md", () => {
+    const tmp = makeTmpDir();
+    savePlan(tmp, "# My Plan\n\nStep 1...");
+    const content = readFileSync(join(tmp, ".claw", "plan.md"), "utf-8");
+    expect(content).toBe("# My Plan\n\nStep 1...");
+  });
+});
+
+describe("saveAuditVerdict", () => {
+  it("writes audit-{N}.json with correct JSON", () => {
+    const tmp = makeTmpDir();
+    const verdict = { pass: true, criteria: ["tests pass"], gaps: [], testResults: "all green" };
+    saveAuditVerdict(tmp, 0, verdict);
+    const raw = readFileSync(join(tmp, ".claw", "audit-0.json"), "utf-8");
+    expect(JSON.parse(raw)).toEqual(verdict);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Interaction log
+// ---------------------------------------------------------------------------
+
+describe("appendLog", () => {
+  function makeEntry(overrides?: Partial<LogEntry>): LogEntry {
+    return {
+      ts: "2026-01-01T00:00:00Z",
+      phase: "worker",
+      attempt: 0,
+      agent: "zoe",
+      prompt: "do the thing",
+      outputPreview: "done",
+      success: true,
+      ...overrides,
+    };
+  }
+
+  it("creates log.jsonl and writes entry", () => {
+    const tmp = makeTmpDir();
+    appendLog(tmp, makeEntry());
+    const content = readFileSync(join(tmp, ".claw", "log.jsonl"), "utf-8");
+    const parsed = JSON.parse(content.trim());
+    expect(parsed.phase).toBe("worker");
+    expect(parsed.success).toBe(true);
+  });
+
+  it("appends multiple entries as JSONL", () => {
+    const tmp = makeTmpDir();
+    appendLog(tmp, makeEntry({ attempt: 0 }));
+    appendLog(tmp, makeEntry({ attempt: 1, phase: "audit" }));
+    const lines = readFileSync(join(tmp, ".claw", "log.jsonl"), "utf-8")
+      .trim()
+      .split("\n");
+    expect(lines).toHaveLength(2);
+    expect(JSON.parse(lines[1]).phase).toBe("audit");
+  });
+
+  it("truncates prompt to 200 chars", () => {
+    const tmp = makeTmpDir();
+    appendLog(tmp, makeEntry({ prompt: "x".repeat(500) }));
+    const content = readFileSync(join(tmp, ".claw", "log.jsonl"), "utf-8");
+    const parsed = JSON.parse(content.trim());
+    expect(parsed.prompt.length).toBe(200);
+  });
+
+  it("truncates outputPreview to 500 chars", () => {
+    const tmp = makeTmpDir();
+    appendLog(tmp, makeEntry({ outputPreview: "y".repeat(1000) }));
+    const content = readFileSync(join(tmp, ".claw", "log.jsonl"), "utf-8");
+    const parsed = JSON.parse(content.trim());
+    expect(parsed.outputPreview.length).toBe(500);
+  });
+
+  it("preserves watchdog detail when phase=watchdog", () => {
+    const tmp = makeTmpDir();
+    appendLog(tmp, makeEntry({
+      phase: "watchdog",
+      watchdog: { reason: "inactivity", silenceSec: 120, thresholdSec: 120, retried: true },
+    }));
+    const content = readFileSync(join(tmp, ".claw", "log.jsonl"), "utf-8");
+    const parsed = JSON.parse(content.trim());
+    expect(parsed.phase).toBe("watchdog");
+    expect(parsed.watchdog).toEqual({
+      reason: "inactivity",
+      silenceSec: 120,
+      thresholdSec: 120,
+      retried: true,
+    });
+  });
+
+  it("omits watchdog field when undefined", () => {
+    const tmp = makeTmpDir();
+    appendLog(tmp, makeEntry());
+    const content = readFileSync(join(tmp, ".claw", "log.jsonl"), "utf-8");
+    const parsed = JSON.parse(content.trim());
+    expect(parsed.watchdog).toBeUndefined();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Summary
+// ---------------------------------------------------------------------------
+
+describe("writeSummary", () => {
+  it("writes summary.md", () => {
+    const tmp = makeTmpDir();
+    writeSummary(tmp, "# Summary\nAll done.");
+    const content = readFileSync(join(tmp, ".claw", "summary.md"), "utf-8");
+    expect(content).toBe("# Summary\nAll done.");
+  });
+});
+
+describe("buildSummaryFromArtifacts", () => {
+  it("returns null with no manifest", () => {
+    const tmp = makeTmpDir();
+    expect(buildSummaryFromArtifacts(tmp)).toBeNull();
+  });
+
+  it("builds markdown with header", () => {
+    const tmp = makeTmpDir();
+    writeManifest(tmp, makeManifest({ worktreePath: tmp }));
+    const summary = buildSummaryFromArtifacts(tmp)!;
+    expect(summary).toContain("# Dispatch: API-100");
+    expect(summary).toContain("Fix login bug");
+  });
+
+  it("includes plan section when plan exists", () => {
+    const tmp = makeTmpDir();
+    writeManifest(tmp, makeManifest({ worktreePath: tmp }));
+    savePlan(tmp, "Step 1: do stuff");
+    const summary = buildSummaryFromArtifacts(tmp)!;
+    expect(summary).toContain("## Plan");
+    expect(summary).toContain("Step 1: do stuff");
+  });
+
+  it("includes worker+audit per attempt", () => {
+    const tmp = makeTmpDir();
+    writeManifest(tmp, makeManifest({ worktreePath: tmp, attempts: 2 }));
+    saveWorkerOutput(tmp, 0, "attempt 0 output");
+    saveAuditVerdict(tmp, 0, { pass: false, criteria: ["c1"], gaps: ["g1"], testResults: "fail" });
+    saveWorkerOutput(tmp, 1, "attempt 1 output");
+    saveAuditVerdict(tmp, 1, { pass: true, criteria: ["c2"], gaps: [], testResults: "pass" });
+
+    const summary = buildSummaryFromArtifacts(tmp)!;
+    expect(summary).toContain("## Attempt 0");
+    expect(summary).toContain("attempt 0 output");
+    expect(summary).toContain("FAIL");
+    expect(summary).toContain("g1");
+    expect(summary).toContain("## Attempt 1");
+    expect(summary).toContain("attempt 1 output");
+    expect(summary).toContain("PASS");
+  });
+
+  it("handles missing artifact files gracefully", () => {
+    const tmp = makeTmpDir();
+    writeManifest(tmp, makeManifest({ worktreePath: tmp, attempts: 1 }));
+    // No worker or audit files — should not throw
+    const summary = buildSummaryFromArtifacts(tmp)!;
+    expect(summary).toContain("## Attempt 0");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Memory
+// ---------------------------------------------------------------------------
+
+describe("writeDispatchMemory", () => {
+  it("creates memory/ dir and writes file", () => {
+    const tmp = makeTmpDir();
+    writeDispatchMemory("API-100", "summary content", tmp);
+    const content = readFileSync(join(tmp, "memory", "dispatch-API-100.md"), "utf-8");
+    expect(content).toBe("summary content");
+  });
+
+  it("overwrites on second call", () => {
+    const tmp = makeTmpDir();
+    writeDispatchMemory("API-100", "first", tmp);
+    writeDispatchMemory("API-100", "second", tmp);
+    const content = readFileSync(join(tmp, "memory", "dispatch-API-100.md"), "utf-8");
+    expect(content).toBe("second");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Orchestrator workspace
+// ---------------------------------------------------------------------------
+
+describe("resolveOrchestratorWorkspace", () => {
+  it("falls back to default on error", () => {
+    const api = { runtime: { config: { loadConfig: () => { throw new Error("no config"); } } } };
+    const result = resolveOrchestratorWorkspace(api);
+    expect(result).toContain(".openclaw");
+    expect(result).toContain("workspace");
+  });
+
+  it("returns workspace from config", () => {
+    const api = {
+      runtime: {
+        config: {
+          loadConfig: () => ({
+            agents: {
+              list: [{ id: "default", workspace: "/custom/ws" }],
+            },
+          }),
+        },
+      },
+    };
+    const result = resolveOrchestratorWorkspace(api);
+    expect(result).toBe("/custom/ws");
+  });
+});

package/src/pipeline/artifacts.ts

@@ -0,0 +1,273 @@
+/**
+ * artifacts.ts — .claw/ per-worktree artifact convention.
+ *
+ * Provides a standard directory structure for storing artifacts during
+ * the lifecycle of a dispatched issue. Any OpenClaw plugin that works
+ * with a worktree can write to {worktreePath}/.claw/.
+ *
+ * Structure:
+ *   .claw/
+ *     manifest.json     — issue metadata + lifecycle timestamps
+ *     plan.md           — implementation plan
+ *     worker-{N}.md     — worker output per attempt (truncated)
+ *     audit-{N}.json    — audit verdict per attempt
+ *     log.jsonl         — append-only interaction log
+ *     summary.md        — agent-curated final summary
+ */
+import { existsSync, mkdirSync, readFileSync, appendFileSync, writeFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { homedir } from "node:os";
+import type { AuditVerdict } from "./pipeline.js";
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+const MAX_ARTIFACT_SIZE = 8192; // 8KB per output file
+const MAX_PREVIEW_SIZE = 500;   // For log entry previews
+const MAX_PROMPT_PREVIEW = 200; // For log entry prompt previews
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export interface ClawManifest {
+  issueIdentifier: string;
+  issueTitle: string;
+  issueId: string;
+  tier: string;
+  model: string;
+  dispatchedAt: string;
+  worktreePath: string;
+  branch: string;
+  attempts: number;
+  status: string;
+  plugin: string;
+}
+
+export interface WatchdogLogDetail {
+  reason: "inactivity";
+  silenceSec: number;
+  thresholdSec: number;
+  retried: boolean;
+}
+
+export interface LogEntry {
+  ts: string;
+  phase: "worker" | "audit" | "verdict" | "dispatch" | "watchdog";
+  attempt: number;
+  agent: string;
+  prompt: string;
+  outputPreview: string;
+  success: boolean;
+  durationMs?: number;
+  watchdog?: WatchdogLogDetail;
+}
+
+// ---------------------------------------------------------------------------
+// Directory setup
+// ---------------------------------------------------------------------------
+
+function clawDir(worktreePath: string): string {
+  return join(worktreePath, ".claw");
+}
+
+/** Creates .claw/ directory. Returns the path. */
+export function ensureClawDir(worktreePath: string): string {
+  const dir = clawDir(worktreePath);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  return dir;
+}
+
+/**
+ * Ensure .claw/ is in .gitignore at the worktree root.
+ * Appends if not already present. Idempotent.
+ */
+export function ensureGitignore(worktreePath: string): void {
+  const gitignorePath = join(worktreePath, ".gitignore");
+  try {
+    const content = existsSync(gitignorePath)
+      ? readFileSync(gitignorePath, "utf-8")
+      : "";
+    if (!content.split("\n").some((line) => line.trim() === ".claw" || line.trim() === ".claw/")) {
+      const nl = content.length > 0 && !content.endsWith("\n") ? "\n" : "";
+      appendFileSync(gitignorePath, `${nl}.claw/\n`, "utf-8");
+    }
+  } catch {
+    // Best effort — don't block pipeline
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Manifest
+// ---------------------------------------------------------------------------
+
+export function writeManifest(worktreePath: string, manifest: ClawManifest): void {
+  const dir = ensureClawDir(worktreePath);
+  writeFileSync(join(dir, "manifest.json"), JSON.stringify(manifest, null, 2) + "\n", "utf-8");
+}
+
+export function readManifest(worktreePath: string): ClawManifest | null {
+  try {
+    const raw = readFileSync(join(clawDir(worktreePath), "manifest.json"), "utf-8");
+    return JSON.parse(raw) as ClawManifest;
+  } catch {
+    return null;
+  }
+}
+
+export function updateManifest(worktreePath: string, updates: Partial<ClawManifest>): void {
+  const current = readManifest(worktreePath);
+  if (!current) return;
+  writeManifest(worktreePath, { ...current, ...updates });
+}
+
+// ---------------------------------------------------------------------------
+// Phase artifacts
+// ---------------------------------------------------------------------------
+
+/** Save worker output for a given attempt. Truncated to MAX_ARTIFACT_SIZE. */
+export function saveWorkerOutput(worktreePath: string, attempt: number, output: string): void {
+  const dir = ensureClawDir(worktreePath);
+  const truncated = output.length > MAX_ARTIFACT_SIZE
+    ? output.slice(0, MAX_ARTIFACT_SIZE) + "\n\n--- truncated ---"
+    : output;
+  writeFileSync(join(dir, `worker-${attempt}.md`), truncated, "utf-8");
+}
+
+/** Save a plan (extracted from worker output or provided directly). */
+export function savePlan(worktreePath: string, plan: string): void {
+  const dir = ensureClawDir(worktreePath);
+  writeFileSync(join(dir, "plan.md"), plan, "utf-8");
+}
+
+/** Save audit verdict for a given attempt. */
+export function saveAuditVerdict(worktreePath: string, attempt: number, verdict: AuditVerdict): void {
+  const dir = ensureClawDir(worktreePath);
+  writeFileSync(join(dir, `audit-${attempt}.json`), JSON.stringify(verdict, null, 2) + "\n", "utf-8");
+}
+
+// ---------------------------------------------------------------------------
+// Interaction log
+// ---------------------------------------------------------------------------
+
+/** Append a structured log entry to .claw/log.jsonl. */
+export function appendLog(worktreePath: string, entry: LogEntry): void {
+  const dir = ensureClawDir(worktreePath);
+  const truncated: LogEntry = {
+    ...entry,
+    prompt: entry.prompt.slice(0, MAX_PROMPT_PREVIEW),
+    outputPreview: entry.outputPreview.slice(0, MAX_PREVIEW_SIZE),
+  };
+  appendFileSync(join(dir, "log.jsonl"), JSON.stringify(truncated) + "\n", "utf-8");
+}
+
+// ---------------------------------------------------------------------------
+// Summary
+// ---------------------------------------------------------------------------
+
+/** Write the final curated summary. */
+export function writeSummary(worktreePath: string, summary: string): void {
+  const dir = ensureClawDir(worktreePath);
+  writeFileSync(join(dir, "summary.md"), summary, "utf-8");
+}
+
+/**
+ * Build a markdown summary from all .claw/ artifacts.
+ * Used at issue completion to generate a memory-friendly summary.
+ */
+export function buildSummaryFromArtifacts(worktreePath: string): string | null {
+  const manifest = readManifest(worktreePath);
+  if (!manifest) return null;
+
+  const parts: string[] = [];
+  parts.push(`# Dispatch: ${manifest.issueIdentifier} — ${manifest.issueTitle}`);
+  parts.push(`**Tier:** ${manifest.tier} | **Status:** ${manifest.status} | **Attempts:** ${manifest.attempts}`);
+  parts.push("");
+
+  // Include plan if exists
+  try {
+    const plan = readFileSync(join(clawDir(worktreePath), "plan.md"), "utf-8");
+    parts.push("## Plan");
+    parts.push(plan.slice(0, 2000));
+    parts.push("");
+  } catch { /* no plan */ }
+
+  // Include each attempt's worker + audit
+  for (let i = 0; i < manifest.attempts; i++) {
+    parts.push(`## Attempt ${i}`);
+
+    // Worker output preview
+    try {
+      const worker = readFileSync(join(clawDir(worktreePath), `worker-${i}.md`), "utf-8");
+      parts.push("### Worker Output");
+      parts.push(worker.slice(0, 1500));
+      parts.push("");
+    } catch { /* no worker output */ }
+
+    // Audit verdict
+    try {
+      const raw = readFileSync(join(clawDir(worktreePath), `audit-${i}.json`), "utf-8");
+      const verdict = JSON.parse(raw) as AuditVerdict;
+      parts.push(`### Audit: ${verdict.pass ? "PASS" : "FAIL"}`);
+      if (verdict.criteria.length) parts.push(`**Criteria:** ${verdict.criteria.join(", ")}`);
+      if (verdict.gaps.length) parts.push(`**Gaps:** ${verdict.gaps.join(", ")}`);
+      if (verdict.testResults) parts.push(`**Tests:** ${verdict.testResults}`);
+      parts.push("");
+    } catch { /* no audit */ }
+  }
+
+  parts.push("---");
+  parts.push(`*Artifacts: ${worktreePath}/.claw/*`);
+
+  return parts.join("\n");
+}
+
+// ---------------------------------------------------------------------------
+// Memory integration
+// ---------------------------------------------------------------------------
+
+/**
+ * Write dispatch summary to the orchestrator's memory directory.
+ * Auto-indexed by OpenClaw's sqlite+embeddings memory system.
+ */
+export function writeDispatchMemory(
+  issueIdentifier: string,
+  summary: string,
+  workspaceDir: string,
+): void {
+  const memDir = join(workspaceDir, "memory");
+  if (!existsSync(memDir)) {
+    mkdirSync(memDir, { recursive: true });
+  }
+  writeFileSync(
+    join(memDir, `dispatch-${issueIdentifier}.md`),
+    summary,
+    "utf-8",
+  );
+}
+
+/**
+ * Resolve the orchestrator agent's workspace directory from config.
+ * Same config-based approach as resolveAgentDirs in agent.ts.
+ */
+export function resolveOrchestratorWorkspace(
+  api: any,
+  pluginConfig?: Record<string, unknown>,
+): string {
+  const home = process.env.HOME ?? "/home/claw";
+  const agentId = (pluginConfig?.defaultAgentId as string) ?? "default";
+
+  try {
+    const config = api.runtime.config.loadConfig() as Record<string, any>;
+    const agentList = config?.agents?.list as Array<Record<string, any>> | undefined;
+    const agentEntry = agentList?.find((a: any) => a.id === agentId);
+    return agentEntry?.workspace
+      ?? config?.agents?.defaults?.workspace
+      ?? join(home, ".openclaw", "workspace");
+  } catch {
+    return join(home, ".openclaw", "workspace");
+  }
+}

package/src/{dispatch-service.ts → pipeline/dispatch-service.ts}

@@ -22,7 +22,7 @@ import {
   removeActiveDispatch,
   pruneCompleted,
 } from "./dispatch-state.js";
-import { getWorktreeStatus } from "./codex-worktree.js";
+import { getWorktreeStatus } from "../infra/codex-worktree.js";
 
 const INTERVAL_MS = 5 * 60_000; // 5 minutes
 const STALE_THRESHOLD_MS = 2 * 60 * 60_000; // 2 hours