@calltelemetry/openclaw-linear 0.9.4 → 0.9.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@calltelemetry/openclaw-linear",
-  "version": "0.9.4",
+  "version": "0.9.5",
   "description": "Linear Agent plugin for OpenClaw — webhook-driven AI pipeline with OAuth, multi-agent routing, and issue triage",
   "type": "module",
   "license": "MIT",

package/src/__test__/fixtures/recorded-sub-issue-flow.ts

@@ -0,0 +1,172 @@
+/**
+ * Recorded API responses from sub-issue decomposition smoke test.
+ *
+ * Initially seeded with placeholder data. Overwritten with real API responses
+ * when the smoke test runs: npx vitest run src/__test__/smoke-linear-api.test.ts
+ *
+ * Last recorded: seed (placeholder)
+ */
+
+export const RECORDED = {
+  teamStates: [
+    { id: "state-backlog", name: "Backlog", type: "backlog" },
+    { id: "state-started", name: "In Progress", type: "started" },
+    { id: "state-done", name: "Done", type: "completed" },
+    { id: "state-canceled", name: "Canceled", type: "canceled" },
+  ],
+  createParent: { id: "parent-001", identifier: "UAT-100" },
+  createSubIssue1: { id: "sub1-001", identifier: "UAT-101" },
+  createSubIssue2: { id: "sub2-001", identifier: "UAT-102" },
+  parentDetails: {
+    id: "parent-001",
+    identifier: "UAT-100",
+    title: "[SMOKE TEST] Sub-Issue Parent: Search Feature",
+    description:
+      "Auto-generated by smoke test to verify sub-issue decomposition.\n\n" +
+      "This parent issue should have two sub-issues created under it.",
+    estimate: null,
+    state: { name: "Backlog", type: "backlog" },
+    creator: { name: "Test User", email: null as string | null },
+    assignee: null as { name: string } | null,
+    labels: { nodes: [] as Array<{ id: string; name: string }> },
+    team: { id: "team-uat", name: "UAT", issueEstimationType: "notUsed" },
+    comments: {
+      nodes: [] as Array<{
+        body: string;
+        user: { name: string } | null;
+        createdAt: string;
+      }>,
+    },
+    project: null as { id: string; name: string } | null,
+    parent: null as { id: string; identifier: string } | null,
+    relations: {
+      nodes: [] as Array<{
+        type: string;
+        relatedIssue: { id: string; identifier: string; title: string };
+      }>,
+    },
+  },
+  subIssue1Details: {
+    id: "sub1-001",
+    identifier: "UAT-101",
+    title: "[SMOKE TEST] Sub-Issue 1: Backend API",
+    description:
+      "Implement the backend search API endpoint.\n\n" +
+      "Given a search query, when the API is called, then matching results are returned.",
+    estimate: 2,
+    state: { name: "Backlog", type: "backlog" },
+    creator: { name: "Test User", email: null as string | null },
+    assignee: null as { name: string } | null,
+    labels: { nodes: [] as Array<{ id: string; name: string }> },
+    team: { id: "team-uat", name: "UAT", issueEstimationType: "notUsed" },
+    comments: {
+      nodes: [] as Array<{
+        body: string;
+        user: { name: string } | null;
+        createdAt: string;
+      }>,
+    },
+    project: null as { id: string; name: string } | null,
+    parent: { id: "parent-001", identifier: "UAT-100" },
+    relations: {
+      nodes: [] as Array<{
+        type: string;
+        relatedIssue: { id: string; identifier: string; title: string };
+      }>,
+    },
+  },
+  subIssue2Details: {
+    id: "sub2-001",
+    identifier: "UAT-102",
+    title: "[SMOKE TEST] Sub-Issue 2: Frontend UI",
+    description:
+      "Build the frontend search UI component.\n\n" +
+      "Given the search page loads, when the user types a query, then results display in real-time.",
+    estimate: 3,
+    state: { name: "Backlog", type: "backlog" },
+    creator: { name: "Test User", email: null as string | null },
+    assignee: null as { name: string } | null,
+    labels: { nodes: [] as Array<{ id: string; name: string }> },
+    team: { id: "team-uat", name: "UAT", issueEstimationType: "notUsed" },
+    comments: {
+      nodes: [] as Array<{
+        body: string;
+        user: { name: string } | null;
+        createdAt: string;
+      }>,
+    },
+    project: null as { id: string; name: string } | null,
+    parent: { id: "parent-001", identifier: "UAT-100" },
+    relations: {
+      nodes: [] as Array<{
+        type: string;
+        relatedIssue: { id: string; identifier: string; title: string };
+      }>,
+    },
+  },
+  createRelation: { id: "rel-001" },
+  subIssue1WithRelation: {
+    id: "sub1-001",
+    identifier: "UAT-101",
+    title: "[SMOKE TEST] Sub-Issue 1: Backend API",
+    description:
+      "Implement the backend search API endpoint.\n\n" +
+      "Given a search query, when the API is called, then matching results are returned.",
+    estimate: 2,
+    state: { name: "Backlog", type: "backlog" },
+    creator: { name: "Test User", email: null as string | null },
+    assignee: null as { name: string } | null,
+    labels: { nodes: [] as Array<{ id: string; name: string }> },
+    team: { id: "team-uat", name: "UAT", issueEstimationType: "notUsed" },
+    comments: {
+      nodes: [] as Array<{
+        body: string;
+        user: { name: string } | null;
+        createdAt: string;
+      }>,
+    },
+    project: null as { id: string; name: string } | null,
+    parent: { id: "parent-001", identifier: "UAT-100" },
+    relations: {
+      nodes: [
+        {
+          type: "blocks",
+          relatedIssue: {
+            id: "sub2-001",
+            identifier: "UAT-102",
+            title: "[SMOKE TEST] Sub-Issue 2: Frontend UI",
+          },
+        },
+      ],
+    },
+  },
+  subIssue2WithRelation: {
+    id: "sub2-001",
+    identifier: "UAT-102",
+    title: "[SMOKE TEST] Sub-Issue 2: Frontend UI",
+    description:
+      "Build the frontend search UI component.\n\n" +
+      "Given the search page loads, when the user types a query, then results display in real-time.",
+    estimate: 3,
+    state: { name: "Backlog", type: "backlog" },
+    creator: { name: "Test User", email: null as string | null },
+    assignee: null as { name: string } | null,
+    labels: { nodes: [] as Array<{ id: string; name: string }> },
+    team: { id: "team-uat", name: "UAT", issueEstimationType: "notUsed" },
+    comments: {
+      nodes: [] as Array<{
+        body: string;
+        user: { name: string } | null;
+        createdAt: string;
+      }>,
+    },
+    project: null as { id: string; name: string } | null,
+    parent: { id: "parent-001", identifier: "UAT-100" },
+    relations: {
+      nodes: [] as Array<{
+        type: string;
+        relatedIssue: { id: string; identifier: string; title: string };
+      }>,
+    },
+  },
+};

package/src/agent/watchdog.ts

@@ -7,6 +7,7 @@
  */
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
+import { homedir } from "node:os";
 
 // ---------------------------------------------------------------------------
 // Defaults (seconds — matches config units)

package/src/infra/doctor.test.ts

@@ -1290,7 +1290,7 @@ describe("buildSummary — additional branches", () => {
 // ---------------------------------------------------------------------------
 
 describe("runDoctor — additional branches", () => {
-    it("applies --fix to auth-profiles.json permissions when fixable check exists", async () => {
+      it("applies --fix to auth-profiles.json permissions when fixable check exists", async () => {
     // We need a scenario where checkAuth produces a fixable permissions check
     // The AUTH_PROFILES_PATH is mocked to /tmp/test-auth-profiles.json
     // Write a file there with wrong permissions so statSync succeeds
@@ -1938,3 +1938,313 @@ describe("checkFilesAndDirs — dispatch state non-Error exception", () => {
     expect(stateCheck?.detail).toContain("raw string dispatch error");
   });
 });
+
+// ---------------------------------------------------------------------------
+// checkFilesAndDirs — lock file branches
+// ---------------------------------------------------------------------------
+
+describe("checkFilesAndDirs — lock file branches", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = mkdtempSync(join(tmpdir(), "doctor-lock-"));
+  });
+
+  it("warns about stale lock file without --fix", async () => {
+    const statePath = join(tmpDir, "state.json");
+    const lockPath = statePath + ".lock";
+    writeFileSync(statePath, '{}');
+    writeFileSync(lockPath, "locked");
+    // Make the lock file appear stale by backdating its mtime
+    const staleTime = Date.now() - 60_000; // 60 seconds old (> 30s LOCK_STALE_MS)
+    const { utimesSync } = await import("node:fs");
+    utimesSync(lockPath, staleTime / 1000, staleTime / 1000);
+
+    vi.mocked(readDispatchState).mockResolvedValueOnce({
+      dispatches: { active: {}, completed: {} },
+      sessionMap: {},
+      processedEvents: [],
+    });
+
+    const checks = await checkFilesAndDirs({ dispatchStatePath: statePath }, false);
+    const lockCheck = checks.find((c) => c.label.includes("Stale lock file"));
+    expect(lockCheck?.severity).toBe("warn");
+    expect(lockCheck?.fixable).toBe(true);
+  });
+
+  it("removes stale lock file with --fix", async () => {
+    const statePath = join(tmpDir, "state.json");
+    const lockPath = statePath + ".lock";
+    writeFileSync(statePath, '{}');
+    writeFileSync(lockPath, "locked");
+    const staleTime = Date.now() - 60_000;
+    const { utimesSync } = await import("node:fs");
+    utimesSync(lockPath, staleTime / 1000, staleTime / 1000);
+
+    vi.mocked(readDispatchState).mockResolvedValueOnce({
+      dispatches: { active: {}, completed: {} },
+      sessionMap: {},
+      processedEvents: [],
+    });
+
+    const checks = await checkFilesAndDirs({ dispatchStatePath: statePath }, true);
+    const lockCheck = checks.find((c) => c.label.includes("Stale lock file removed"));
+    expect(lockCheck?.severity).toBe("pass");
+    expect(existsSync(lockPath)).toBe(false);
+  });
+
+  it("warns about active (non-stale) lock file", async () => {
+    const statePath = join(tmpDir, "state.json");
+    const lockPath = statePath + ".lock";
+    writeFileSync(statePath, '{}');
+    writeFileSync(lockPath, "locked");
+    // Lock file is fresh (just created), so lockAge < LOCK_STALE_MS
+
+    vi.mocked(readDispatchState).mockResolvedValueOnce({
+      dispatches: { active: {}, completed: {} },
+      sessionMap: {},
+      processedEvents: [],
+    });
+
+    const checks = await checkFilesAndDirs({ dispatchStatePath: statePath }, false);
+    const lockCheck = checks.find((c) => c.label.includes("Lock file active"));
+    expect(lockCheck?.severity).toBe("warn");
+    expect(lockCheck?.label).toContain("may be in use");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// checkFilesAndDirs — prompt variable edge cases
+// ---------------------------------------------------------------------------
+
+describe("checkFilesAndDirs — prompt variable edge cases", () => {
+  it("reports when variable missing from worker.task but present in audit.task", async () => {
+    vi.mocked(loadPrompts).mockReturnValueOnce({
+      worker: {
+        system: "ok",
+        task: "Do something", // missing all vars
+      },
+      audit: {
+        system: "ok",
+        task: "Audit {{identifier}} {{title}} {{description}} in {{worktreePath}}", // has all vars
+      },
+      rework: { addendum: "Fix these gaps: {{gaps}}" },
+    } as any);
+
+    const checks = await checkFilesAndDirs();
+    const promptCheck = checks.find((c) => c.label.includes("Prompt issues"));
+    expect(promptCheck?.severity).toBe("fail");
+    expect(promptCheck?.label).toContain("worker.task missing");
+    // Crucially, audit.task should NOT be missing
+    expect(promptCheck?.label).not.toContain("audit.task missing");
+  });
+
+  it("reports loadPrompts throwing non-Error value", async () => {
+    vi.mocked(loadPrompts).mockImplementationOnce(() => { throw "raw string error"; });
+
+    const checks = await checkFilesAndDirs();
+    const promptCheck = checks.find((c) => c.label.includes("Failed to load prompts"));
+    expect(promptCheck?.severity).toBe("fail");
+    expect(promptCheck?.detail).toContain("raw string error");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// checkFilesAndDirs — worktree & base repo edge cases
+// ---------------------------------------------------------------------------
+
+describe("checkFilesAndDirs — worktree & base repo edge cases", () => {
+  it("reports worktree base dir does not exist", async () => {
+    const checks = await checkFilesAndDirs({
+      worktreeBaseDir: "/tmp/nonexistent-worktree-dir-" + Date.now(),
+    });
+    const wtCheck = checks.find((c) => c.label.includes("Worktree base dir does not exist"));
+    expect(wtCheck?.severity).toBe("warn");
+    expect(wtCheck?.detail).toContain("Will be created on first dispatch");
+  });
+
+  it("reports base repo does not exist", async () => {
+    const checks = await checkFilesAndDirs({
+      codexBaseRepo: "/tmp/nonexistent-repo-" + Date.now(),
+    });
+    const repoCheck = checks.find((c) => c.label.includes("Base repo does not exist"));
+    expect(repoCheck?.severity).toBe("fail");
+    expect(repoCheck?.fix).toContain("codexBaseRepo");
+  });
+
+  it("reports base repo exists but is not a git repo", async () => {
+    const tmpDir = mkdtempSync(join(tmpdir(), "doctor-nongit-"));
+    const checks = await checkFilesAndDirs({
+      codexBaseRepo: tmpDir,
+    });
+    const repoCheck = checks.find((c) => c.label.includes("Base repo is not a git repo"));
+    expect(repoCheck?.severity).toBe("fail");
+    expect(repoCheck?.fix).toContain("git init");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// checkFilesAndDirs — tilde path resolution branches
+// ---------------------------------------------------------------------------
+
+describe("checkFilesAndDirs — tilde path resolution", () => {
+  it("resolves ~/... dispatch state path", async () => {
+    vi.mocked(readDispatchState).mockRejectedValueOnce(new Error("ENOENT"));
+
+    // Providing a path with ~/ triggers the tilde resolution branch
+    const checks = await checkFilesAndDirs({
+      dispatchStatePath: "~/nonexistent-state-file.json",
+    });
+    // The file won't exist (tilde-resolved), so we get the "no file yet" message
+    const stateCheck = checks.find((c) => c.label.includes("Dispatch state"));
+    expect(stateCheck).toBeDefined();
+  });
+
+  it("resolves ~/... worktree base dir path", async () => {
+    const checks = await checkFilesAndDirs({
+      worktreeBaseDir: "~/nonexistent-worktree-base",
+    });
+    const wtCheck = checks.find((c) => c.label.includes("Worktree base dir"));
+    expect(wtCheck).toBeDefined();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// checkDispatchHealth — orphaned worktree singular
+// ---------------------------------------------------------------------------
+
+describe("checkDispatchHealth — edge cases", () => {
+  it("reports single orphaned worktree (singular)", async () => {
+    vi.mocked(listWorktrees).mockReturnValueOnce([
+      { issueIdentifier: "ORPHAN-1", path: "/tmp/wt1" } as any,
+    ]);
+
+    const checks = await checkDispatchHealth();
+    const orphanCheck = checks.find((c) => c.label.includes("orphaned worktree"));
+    expect(orphanCheck?.severity).toBe("warn");
+    expect(orphanCheck?.label).toContain("1 orphaned worktree");
+    expect(orphanCheck?.label).not.toContain("worktrees"); // singular, not plural
+  });
+
+  it("prunes multiple old completed dispatches (plural)", async () => {
+    vi.mocked(readDispatchState).mockResolvedValueOnce({
+      dispatches: {
+        active: {},
+        completed: {
+          "A-1": { completedAt: new Date(Date.now() - 10 * 24 * 3_600_000).toISOString() } as any,
+          "A-2": { completedAt: new Date(Date.now() - 10 * 24 * 3_600_000).toISOString() } as any,
+        },
+      },
+      sessionMap: {},
+      processedEvents: [],
+    });
+    vi.mocked(pruneCompleted).mockResolvedValueOnce(2);
+
+    const checks = await checkDispatchHealth(undefined, true);
+    const pruneCheck = checks.find((c) => c.label.includes("Pruned"));
+    expect(pruneCheck?.severity).toBe("pass");
+    expect(pruneCheck?.label).toContain("2 old completed dispatches");
+  });
+
+  it("reports single stale dispatch (singular)", async () => {
+    vi.mocked(listStaleDispatches).mockReturnValueOnce([
+      { issueIdentifier: "API-1", status: "working" } as any,
+    ]);
+
+    const checks = await checkDispatchHealth();
+    const staleCheck = checks.find((c) => c.label.includes("stale dispatch"));
+    expect(staleCheck?.severity).toBe("warn");
+    // Singular: "1 stale dispatch" not "1 stale dispatches"
+    expect(staleCheck?.label).toMatch(/1 stale dispatch(?!es)/);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// checkConnectivity — webhook self-test with ok but body !== "ok"
+// ---------------------------------------------------------------------------
+
+describe("checkConnectivity — webhook non-ok body", () => {
+  it("warns when webhook returns ok status but body is not 'ok'", async () => {
+    vi.stubGlobal("fetch", vi.fn(async (url: string) => {
+      if (url.includes("localhost")) {
+        return { ok: true, text: async () => "pong" };
+      }
+      throw new Error("unexpected");
+    }));
+
+    const checks = await checkConnectivity({}, { viewer: { name: "T" } });
+    const webhookCheck = checks.find((c) => c.label.includes("Webhook self-test:"));
+    // ok is true but body is "pong" not "ok" — the condition is `res.ok && body === "ok"`
+    // Since body !== "ok", it falls into the warn branch
+    expect(webhookCheck?.severity).toBe("warn");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// formatReport — icon function TTY branches
+// ---------------------------------------------------------------------------
+
+describe("formatReport — TTY icon rendering", () => {
+  it("renders colored icons when stdout.isTTY is true", () => {
+    const origIsTTY = process.stdout.isTTY;
+    try {
+      Object.defineProperty(process.stdout, "isTTY", { value: true, writable: true, configurable: true });
+
+      const report = {
+        sections: [{
+          name: "Test",
+          checks: [
+            { label: "pass check", severity: "pass" as const },
+            { label: "warn check", severity: "warn" as const },
+            { label: "fail check", severity: "fail" as const },
+          ],
+        }],
+        summary: { passed: 1, warnings: 1, errors: 1 },
+      };
+
+      const output = formatReport(report);
+      // TTY output includes ANSI escape codes
+      expect(output).toContain("\x1b[32m"); // green for pass
+      expect(output).toContain("\x1b[33m"); // yellow for warn
+      expect(output).toContain("\x1b[31m"); // red for fail
+    } finally {
+      Object.defineProperty(process.stdout, "isTTY", { value: origIsTTY, writable: true, configurable: true });
+    }
+  });
+});
+
+// ---------------------------------------------------------------------------
+// checkCodingTools — codingTool fallback to "codex" in label
+// ---------------------------------------------------------------------------
+
+describe("checkCodingTools — codingTool null fallback", () => {
+  it("shows 'codex' as default when codingTool is undefined but backends exist", () => {
+    vi.mocked(loadCodingConfig).mockReturnValueOnce({
+      codingTool: undefined,
+      backends: { codex: { aliases: ["codex"] } },
+    } as any);
+
+    const checks = checkCodingTools();
+    const configCheck = checks.find((c) => c.label.includes("coding-tools.json loaded"));
+    expect(configCheck?.severity).toBe("pass");
+    expect(configCheck?.label).toContain("codex"); // falls back to "codex" via ??
+  });
+});
+
+// ---------------------------------------------------------------------------
+// checkFilesAndDirs — dispatch state non-Error catch branch
+// ---------------------------------------------------------------------------
+
+describe("checkFilesAndDirs — dispatch state non-Error exception", () => {
+  it("handles non-Error thrown during dispatch state read", async () => {
+    const tmpDir = mkdtempSync(join(tmpdir(), "doctor-nonError-"));
+    const statePath = join(tmpDir, "state.json");
+    writeFileSync(statePath, '{}');
+    vi.mocked(readDispatchState).mockRejectedValueOnce("raw string dispatch error");
+
+    const checks = await checkFilesAndDirs({ dispatchStatePath: statePath });
+    const stateCheck = checks.find((c) => c.label.includes("Dispatch state corrupt"));
+    expect(stateCheck?.severity).toBe("fail");
+    expect(stateCheck?.detail).toContain("raw string dispatch error");
+  });
+});

package/src/pipeline/webhook.test.ts

@@ -24,9 +24,6 @@ const {
   resetGuidanceCacheMock,
   setActiveSessionMock,
   clearActiveSessionMock,
-  getIssueAffinityMock,
-  configureAffinityTtlMock,
-  resetAffinityForTestingMock,
   readDispatchStateMock,
   getActiveDispatchMock,
   registerDispatchMock,
@@ -100,9 +97,6 @@ const {
   resetGuidanceCacheMock: vi.fn(),
   setActiveSessionMock: vi.fn(),
   clearActiveSessionMock: vi.fn(),
-  getIssueAffinityMock: vi.fn().mockReturnValue(null),
-  configureAffinityTtlMock: vi.fn(),
-  resetAffinityForTestingMock: vi.fn(),
   readDispatchStateMock: vi.fn().mockResolvedValue({ activeDispatches: {} }),
   getActiveDispatchMock: vi.fn().mockReturnValue(null),
   registerDispatchMock: vi.fn().mockResolvedValue(undefined),
@@ -113,7 +107,7 @@ const {
   createWorktreeMock: vi.fn().mockReturnValue({ path: "/tmp/worktree", branch: "codex/ENG-123", resumed: false }),
   createMultiWorktreeMock: vi.fn().mockReturnValue({ parentPath: "/tmp/multi", worktrees: [] }),
   prepareWorkspaceMock: vi.fn().mockReturnValue({ pulled: true, submodulesInitialized: false, errors: [] }),
-  resolveReposMock: vi.fn().mockReturnValue({ repos: [{ name: "main", path: "/tmp/test/workspace" }], source: "config_default" }),
+  resolveReposMock: vi.fn().mockReturnValue({ repos: [{ name: "main", path: "/home/claw/ai-workspace" }], source: "config_default" }),
   isMultiRepoMock: vi.fn().mockReturnValue(false),
   ensureClawDirMock: vi.fn(),
   writeManifestMock: vi.fn(),
@@ -173,9 +167,9 @@ vi.mock("./guidance.js", () => ({
 vi.mock("./active-session.js", () => ({
   setActiveSession: setActiveSessionMock,
   clearActiveSession: clearActiveSessionMock,
-  getIssueAffinity: getIssueAffinityMock,
-  _configureAffinityTtl: configureAffinityTtlMock,
-  _resetAffinityForTesting: resetAffinityForTestingMock,
+  getIssueAffinity: vi.fn().mockReturnValue(null),
+  _configureAffinityTtl: vi.fn(),
+  _resetAffinityForTesting: vi.fn(),
 }));
 
 vi.mock("./dispatch-state.js", () => ({
@@ -364,9 +358,6 @@ afterEach(() => {
   isGuidanceEnabledMock.mockReset().mockReturnValue(false);
   setActiveSessionMock.mockReset();
   clearActiveSessionMock.mockReset();
-  getIssueAffinityMock.mockReset().mockReturnValue(null);
-  configureAffinityTtlMock.mockReset();
-  resetAffinityMock.mockReset();
   readDispatchStateMock.mockReset().mockResolvedValue({ activeDispatches: {} });
   getActiveDispatchMock.mockReset().mockReturnValue(null);
   registerDispatchMock.mockReset().mockResolvedValue(undefined);
@@ -375,7 +366,7 @@ afterEach(() => {
   assessTierMock.mockReset().mockResolvedValue({ tier: "medium", model: "anthropic/claude-sonnet-4-6", reasoning: "moderate complexity" });
   createWorktreeMock.mockReset().mockReturnValue({ path: "/tmp/worktree", branch: "codex/ENG-123", resumed: false });
   prepareWorkspaceMock.mockReset().mockReturnValue({ pulled: true, submodulesInitialized: false, errors: [] });
-  resolveReposMock.mockReset().mockReturnValue({ repos: [{ name: "main", path: "/tmp/test/workspace" }], source: "config_default" });
+  resolveReposMock.mockReset().mockReturnValue({ repos: [{ name: "main", path: "/home/claw/ai-workspace" }], source: "config_default" });
   isMultiRepoMock.mockReset().mockReturnValue(false);
   ensureClawDirMock.mockReset();
   writeManifestMock.mockReset();
@@ -4276,8 +4267,8 @@ describe("handleDispatch multi-repo and .catch/.finally", () => {
     });
     resolveReposMock.mockReturnValue({
       repos: [
-        { name: "api", path: "/tmp/test/api" },
-        { name: "spa", path: "/tmp/test/spa" },
+        { name: "api", path: "/home/claw/api" },
+        { name: "spa", path: "/home/claw/spa" },
       ],
       source: "issue_markers",
     });
@@ -4842,3 +4833,194 @@ describe("handleDispatch error via Issue.update .catch wrapper", () => {
     expect(errorCalls.some((msg: string) => msg.includes("Dispatch pipeline error"))).toBe(true);
   });
 });
+
+// ---------------------------------------------------------------------------
+// Session affinity routing
+// ---------------------------------------------------------------------------
+
+describe("session affinity routing", () => {
+  it("request_work uses affinity agent instead of default", async () => {
+    getIssueAffinityMock.mockReturnValue("kaylee");
+    classifyIntentMock.mockResolvedValue({
+      intent: "request_work",
+      reasoning: "User wants work done",
+      fromFallback: false,
+    });
+    mockLinearApiInstance.getIssueDetails.mockResolvedValue({
+      id: "issue-affinity-rw",
+      identifier: "ENG-AFF-RW",
+      title: "Affinity Request Work",
+      description: "desc",
+      state: { name: "Backlog", type: "backlog" },
+      team: { id: "team-aff" },
+      comments: { nodes: [] },
+    });
+
+    const result = await postWebhook({
+      type: "Comment",
+      action: "create",
+      data: {
+        id: "comment-affinity-rw",
+        body: "Please implement this",
+        user: { id: "human-aff", name: "Human" },
+        issue: { id: "issue-affinity-rw", identifier: "ENG-AFF-RW" },
+      },
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 300));
+    const infoCalls = (result.api.logger.info as any).mock.calls.map((c: any[]) => c[0]);
+    expect(infoCalls.some((msg: string) => msg.includes("request_work") && msg.includes("kaylee"))).toBe(true);
+  });
+
+  it("null affinity falls through to default agent", async () => {
+    getIssueAffinityMock.mockReturnValue(null);
+    classifyIntentMock.mockResolvedValue({
+      intent: "request_work",
+      reasoning: "User wants work done",
+      fromFallback: false,
+    });
+    mockLinearApiInstance.getIssueDetails.mockResolvedValue({
+      id: "issue-no-aff",
+      identifier: "ENG-NO-AFF",
+      title: "No Affinity",
+      description: "desc",
+      state: { name: "Backlog", type: "backlog" },
+      team: { id: "team-noaff" },
+      comments: { nodes: [] },
+    });
+
+    const result = await postWebhook({
+      type: "Comment",
+      action: "create",
+      data: {
+        id: "comment-no-aff",
+        body: "Do something",
+        user: { id: "human-noaff", name: "Human" },
+        issue: { id: "issue-no-aff", identifier: "ENG-NO-AFF" },
+      },
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 300));
+    // Default agent is "mal" (from loadAgentProfilesMock isDefault: true)
+    const infoCalls = (result.api.logger.info as any).mock.calls.map((c: any[]) => c[0]);
+    expect(infoCalls.some((msg: string) => msg.includes("request_work") && msg.includes("mal"))).toBe(true);
+  });
+
+  it("AgentSessionEvent.created uses affinity when no @mention", async () => {
+    getIssueAffinityMock.mockReturnValue("kaylee");
+
+    const result = await postWebhook({
+      type: "AgentSessionEvent",
+      action: "created",
+      agentSession: {
+        id: "sess-aff-created",
+        issue: { id: "issue-aff-created", identifier: "ENG-AFF-C" },
+      },
+      previousComments: [
+        { body: "Can you investigate?", user: { name: "Dev" } },
+      ],
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 50));
+    const infoCalls = (result.api.logger.info as any).mock.calls.map((c: any[]) => c[0]);
+    expect(infoCalls.some((msg: string) => msg.includes("session affinity") && msg.includes("kaylee"))).toBe(true);
+  });
+
+  it("@mention overrides affinity in AgentSessionEvent.created", async () => {
+    getIssueAffinityMock.mockReturnValue("kaylee");
+    resolveAgentFromAliasMock.mockReturnValue({ agentId: "mal", profile: { label: "Mal" } });
+
+    const result = await postWebhook({
+      type: "AgentSessionEvent",
+      action: "created",
+      agentSession: {
+        id: "sess-mention-override",
+        issue: { id: "issue-mention-override", identifier: "ENG-MO" },
+      },
+      previousComments: [
+        { body: "@mal please fix this", user: { name: "Dev" } },
+      ],
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 50));
+    const infoCalls = (result.api.logger.info as any).mock.calls.map((c: any[]) => c[0]);
+    // @mention should win over affinity
+    expect(infoCalls.some((msg: string) => msg.includes("routed to mal via @mal mention"))).toBe(true);
+    // Affinity should NOT appear in log because @mention took priority
+    expect(infoCalls.some((msg: string) => msg.includes("session affinity"))).toBe(false);
+  });
+
+  it("close_issue uses affinity agent", async () => {
+    getIssueAffinityMock.mockReturnValue("kaylee");
+    classifyIntentMock.mockResolvedValue({
+      intent: "close_issue",
+      reasoning: "User wants to close",
+      fromFallback: false,
+    });
+    mockLinearApiInstance.getIssueDetails.mockResolvedValue({
+      id: "issue-aff-close",
+      identifier: "ENG-AFF-CL",
+      title: "Affinity Close",
+      description: "desc",
+      state: { name: "In Progress", type: "started" },
+      team: { id: "team-aff-cl" },
+      comments: { nodes: [] },
+    });
+
+    const result = await postWebhook({
+      type: "Comment",
+      action: "create",
+      data: {
+        id: "comment-aff-close",
+        body: "close this please",
+        user: { id: "human-aff-cl", name: "Human" },
+        issue: { id: "issue-aff-close", identifier: "ENG-AFF-CL" },
+      },
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 300));
+    const infoCalls = (result.api.logger.info as any).mock.calls.map((c: any[]) => c[0]);
+    expect(infoCalls.some((msg: string) => msg.includes("close_issue") && msg.includes("kaylee"))).toBe(true);
+  });
+
+  it("ask_agent with explicit agentId overrides affinity", async () => {
+    getIssueAffinityMock.mockReturnValue("kaylee");
+    classifyIntentMock.mockResolvedValue({
+      intent: "ask_agent",
+      agentId: "mal",
+      reasoning: "User asked mal explicitly",
+      fromFallback: false,
+    });
+    mockLinearApiInstance.getIssueDetails.mockResolvedValue({
+      id: "issue-ask-override",
+      identifier: "ENG-ASK-O",
+      title: "Ask Agent Override",
+      description: "desc",
+      state: { name: "Backlog", type: "backlog" },
+      team: { id: "team-ask-o" },
+      comments: { nodes: [] },
+    });
+
+    const result = await postWebhook({
+      type: "Comment",
+      action: "create",
+      data: {
+        id: "comment-ask-override",
+        body: "@mal what do you think?",
+        user: { id: "human-ask-o", name: "Human" },
+        issue: { id: "issue-ask-override", identifier: "ENG-ASK-O" },
+      },
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 300));
+    const infoCalls = (result.api.logger.info as any).mock.calls.map((c: any[]) => c[0]);
+    // ask_agent uses intentResult.agentId directly, not affinity
+    expect(infoCalls.some((msg: string) => msg.includes("ask_agent") && msg.includes("mal"))).toBe(true);
+  });
+});