Merge pull request #85 from arul28/merge

runnign automate and finalzie

Author: arul28

.github/workflows/ci.yml

@@ -95,7 +95,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        shard: [1, 2, 3]
+        shard: [1, 2, 3, 4, 5]
     steps:
       - uses: actions/checkout@v4
       - uses: actions/setup-node@v4
@@ -108,7 +108,7 @@ jobs:
             apps/mcp-server/node_modules
             apps/web/node_modules
           key: nm-${{ hashFiles('apps/desktop/package-lock.json','apps/mcp-server/package-lock.json','apps/web/package-lock.json') }}
-      - run: cd apps/desktop && npx vitest run --shard=${{ matrix.shard }}/3
+      - run: cd apps/desktop && npx vitest run --shard=${{ matrix.shard }}/5
 
   test-mcp:
     needs: install

apps/desktop/src/main/main.ts

@@ -69,6 +69,7 @@ import { createMissionMemoryLifecycleService } from "./services/memory/missionMe
 import { createEpisodicSummaryService } from "./services/memory/episodicSummaryService";
 import { createHumanWorkDigestService } from "./services/memory/humanWorkDigestService";
 import { createProceduralLearningService } from "./services/memory/proceduralLearningService";
+import { createMemoryRepairService } from "./services/memory/memoryRepairService";
 import { createSkillRegistryService } from "./services/memory/skillRegistryService";
 import { createKnowledgeCaptureService } from "./services/memory/knowledgeCaptureService";
 import { createCtoStateService } from "./services/cto/ctoStateService";
@@ -954,6 +955,8 @@ app.whenReady().then(async () => {
       logger,
       cacheDir: path.join(app.getPath("userData"), "transformers-cache"),
     });
+    // Auto-detect previously downloaded embedding model at startup
+    void embeddingService.probeCache().catch(() => { /* best-effort */ });
     const hybridSearchService = createHybridSearchService({
       db,
       embeddingService,
@@ -995,6 +998,11 @@ app.whenReady().then(async () => {
       projectId,
       onStatus: (event) => emitProjectEvent(projectRoot, IPC.memorySweepStatus, event)
     });
+    const memoryRepairService = createMemoryRepairService({
+      db,
+      projectId,
+      logger,
+    });
     const embeddingWorkerService = createEmbeddingWorkerService({
       db,
       logger,
@@ -1107,6 +1115,15 @@ app.whenReady().then(async () => {
           error: error instanceof Error ? error.message : String(error),
         });
       }
+
+      try {
+        memoryRepairService.runRepair();
+      } catch (error) {
+        logger.warn("memory.repair.failed", {
+          projectRoot,
+          error: error instanceof Error ? error.message : String(error),
+        });
+      }
     });
 
     const workerRevisionService = createWorkerRevisionService({

apps/desktop/src/main/services/ai/claudeCodeExecutable.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, it } from "vitest";
+import { resolveClaudeCodeExecutable } from "./claudeCodeExecutable";
+
+describe("resolveClaudeCodeExecutable", () => {
+  it("prefers the explicit env override", () => {
+    expect(
+      resolveClaudeCodeExecutable({
+        env: {
+          CLAUDE_CODE_EXECUTABLE_PATH: "/custom/bin/claude",
+          PATH: "/usr/bin:/bin",
+        },
+      }),
+    ).toEqual({
+      path: "/custom/bin/claude",
+      source: "env",
+    });
+  });
+
+  it("uses the detected Claude auth path before falling back to PATH lookup", () => {
+    expect(
+      resolveClaudeCodeExecutable({
+        auth: [
+          {
+            type: "cli-subscription",
+            cli: "claude",
+            path: "/opt/homebrew/bin/claude",
+            authenticated: true,
+            verified: true,
+          },
+        ],
+        env: {
+          PATH: "/usr/bin:/bin",
+        },
+      }),
+    ).toEqual({
+      path: "/opt/homebrew/bin/claude",
+      source: "auth",
+    });
+  });
+});

apps/desktop/src/main/services/ai/claudeCodeExecutable.ts

@@ -0,0 +1,84 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import type { DetectedAuth } from "./authDetector";
+
+export type ClaudeCodeExecutableResolution = {
+  path: string;
+  source: "env" | "auth" | "path" | "common-dir" | "fallback-command";
+};
+
+const HOME_DIR = os.homedir();
+const COMMON_BIN_DIRS = [
+  "/opt/homebrew/bin",
+  "/opt/homebrew/sbin",
+  "/usr/local/bin",
+  "/usr/local/sbin",
+  "/usr/bin",
+  "/bin",
+  `${HOME_DIR}/.local/bin`,
+  `${HOME_DIR}/.nvm/current/bin`,
+].filter(Boolean);
+
+function isExecutableFile(candidatePath: string): boolean {
+  try {
+    const stat = fs.statSync(candidatePath);
+    return stat.isFile() && (process.platform === "win32" || (stat.mode & 0o111) !== 0);
+  } catch {
+    return false;
+  }
+}
+
+function resolveFromPathEntries(command: string, pathValue: string | undefined): string | null {
+  if (!pathValue) return null;
+  for (const entry of pathValue.split(path.delimiter)) {
+    const trimmed = entry.trim();
+    if (!trimmed) continue;
+    const candidatePath = path.join(trimmed, command);
+    if (isExecutableFile(candidatePath)) {
+      return candidatePath;
+    }
+  }
+  return null;
+}
+
+function findClaudeAuthPath(auth?: DetectedAuth[]): string | null {
+  for (const entry of auth ?? []) {
+    if (entry.type !== "cli-subscription" || entry.cli !== "claude") continue;
+    const candidate = entry.path.trim();
+    if (candidate) {
+      return candidate;
+    }
+  }
+  return null;
+}
+
+export function resolveClaudeCodeExecutable(args?: {
+  auth?: DetectedAuth[];
+  env?: NodeJS.ProcessEnv;
+}): ClaudeCodeExecutableResolution {
+  const env = args?.env ?? process.env;
+  const envPath = env.CLAUDE_CODE_EXECUTABLE_PATH?.trim();
+  if (envPath) {
+    return { path: envPath, source: "env" };
+  }
+
+  const authPath = findClaudeAuthPath(args?.auth);
+  if (authPath) {
+    return { path: authPath, source: "auth" };
+  }
+
+  const pathResolved = resolveFromPathEntries("claude", env.PATH);
+  if (pathResolved) {
+    return { path: pathResolved, source: "path" };
+  }
+
+  for (const binDir of COMMON_BIN_DIRS) {
+    const candidatePath = path.join(binDir, "claude");
+    if (isExecutableFile(candidatePath)) {
+      return { path: candidatePath, source: "common-dir" };
+    }
+  }
+
+  return { path: "claude", source: "fallback-command" };
+}

apps/desktop/src/main/services/ai/claudeRuntimeProbe.test.ts

@@ -5,6 +5,20 @@ const mockState = vi.hoisted(() => ({
   reportProviderRuntimeReady: vi.fn(),
   reportProviderRuntimeAuthFailure: vi.fn(),
   reportProviderRuntimeFailure: vi.fn(),
+  resolveClaudeCodeExecutable: vi.fn(() => ({ path: "/usr/local/bin/claude", source: "path" })),
+  normalizeCliMcpServers: vi.fn(() => ({
+    ade: {
+      type: "stdio",
+      command: "node",
+      args: ["probe.js"],
+      env: { ADE_PROJECT_ROOT: "/tmp/project" },
+    },
+  })),
+  resolveAdeMcpServerLaunch: vi.fn(() => ({
+    command: "node",
+    cmdArgs: ["probe.js"],
+    env: { ADE_PROJECT_ROOT: "/tmp/project" },
+  })),
 }));
 
 vi.mock("@anthropic-ai/claude-agent-sdk", () => ({
@@ -17,6 +31,18 @@ vi.mock("./providerRuntimeHealth", () => ({
   reportProviderRuntimeFailure: (...args: unknown[]) => mockState.reportProviderRuntimeFailure(...args),
 }));
 
+vi.mock("./claudeCodeExecutable", () => ({
+  resolveClaudeCodeExecutable: mockState.resolveClaudeCodeExecutable,
+}));
+
+vi.mock("./providerResolver", () => ({
+  normalizeCliMcpServers: mockState.normalizeCliMcpServers,
+}));
+
+vi.mock("../orchestrator/unifiedOrchestratorAdapter", () => ({
+  resolveAdeMcpServerLaunch: mockState.resolveAdeMcpServerLaunch,
+}));
+
 let probeClaudeRuntimeHealth: typeof import("./claudeRuntimeProbe").probeClaudeRuntimeHealth;
 let resetClaudeRuntimeProbeCache: typeof import("./claudeRuntimeProbe").resetClaudeRuntimeProbeCache;
 let isClaudeRuntimeAuthError: typeof import("./claudeRuntimeProbe").isClaudeRuntimeAuthError;
@@ -40,6 +66,9 @@ beforeEach(async () => {
   mockState.reportProviderRuntimeReady.mockReset();
   mockState.reportProviderRuntimeAuthFailure.mockReset();
   mockState.reportProviderRuntimeFailure.mockReset();
+  mockState.resolveClaudeCodeExecutable.mockClear();
+  mockState.normalizeCliMcpServers.mockClear();
+  mockState.resolveAdeMcpServerLaunch.mockClear();
   const mod = await import("./claudeRuntimeProbe");
   probeClaudeRuntimeHealth = mod.probeClaudeRuntimeHealth;
   resetClaudeRuntimeProbeCache = mod.resetClaudeRuntimeProbeCache;
@@ -66,6 +95,15 @@ describe("claudeRuntimeProbe", () => {
     expect(query.close).toHaveBeenCalledTimes(1);
     expect(mockState.reportProviderRuntimeAuthFailure).toHaveBeenCalledTimes(1);
     expect(mockState.reportProviderRuntimeFailure).not.toHaveBeenCalled();
+    expect(mockState.query).toHaveBeenCalledWith(expect.objectContaining({
+      options: expect.objectContaining({
+        cwd: "/tmp/project",
+        pathToClaudeCodeExecutable: "/usr/local/bin/claude",
+        mcpServers: expect.objectContaining({
+          ade: expect.any(Object),
+        }),
+      }),
+    }));
   });
 
   it("treats Anthropic 401 invalid credentials responses as auth failures", async () => {

apps/desktop/src/main/services/ai/claudeRuntimeProbe.ts

@@ -1,11 +1,16 @@
+import fs from "node:fs";
+import path from "node:path";
 import { query as claudeQuery, type SDKMessage } from "@anthropic-ai/claude-agent-sdk";
 import type { Logger } from "../logging/logger";
 import { getErrorMessage } from "../shared/utils";
+import { resolveAdeMcpServerLaunch } from "../orchestrator/unifiedOrchestratorAdapter";
 import {
   reportProviderRuntimeAuthFailure,
   reportProviderRuntimeFailure,
   reportProviderRuntimeReady,
 } from "./providerRuntimeHealth";
+import { resolveClaudeCodeExecutable } from "./claudeCodeExecutable";
+import { normalizeCliMcpServers } from "./providerResolver";
 
 const PROBE_TIMEOUT_MS = 20_000;
 const PROBE_CACHE_TTL_MS = 30_000;
@@ -22,6 +27,7 @@ type ClaudeRuntimeProbeResult =
 /** Cache and in-flight probe keyed by projectRoot to avoid cross-project contamination. */
 const probeCache = new Map<string, { checkedAtMs: number; result: ClaudeRuntimeProbeResult }>();
 const inFlightProbes = new Map<string, Promise<ClaudeRuntimeProbeResult>>();
+let runtimeRootCache: string | null = null;
 
 function normalizeErrorMessage(error: unknown): string {
   const text = getErrorMessage(error).trim();
@@ -84,16 +90,52 @@ function cacheResult(projectRoot: string, result: ClaudeRuntimeProbeResult): Cla
   return result;
 }
 
-function publishResult(result: ClaudeRuntimeProbeResult): void {
-  if (result.state === "ready") {
-    reportProviderRuntimeReady("claude");
-    return;
+function resolveProbeRuntimeRoot(): string {
+  if (runtimeRootCache !== null) return runtimeRootCache;
+  const startPoints = [process.cwd(), __dirname];
+  for (const start of startPoints) {
+    let dir = path.resolve(start);
+    for (let i = 0; i < 12; i += 1) {
+      if (fs.existsSync(path.join(dir, "apps", "mcp-server", "package.json"))) {
+        runtimeRootCache = dir;
+        return dir;
+      }
+      const parent = path.dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
   }
-  if (result.state === "auth-failed") {
-    reportProviderRuntimeAuthFailure("claude", result.message);
-    return;
+  runtimeRootCache = process.cwd();
+  return runtimeRootCache;
+}
+
+function resolveProbeMcpServers(projectRoot: string): Record<string, Record<string, unknown>> | undefined {
+  const launch = resolveAdeMcpServerLaunch({
+    workspaceRoot: projectRoot,
+    runtimeRoot: resolveProbeRuntimeRoot(),
+    defaultRole: "agent",
+  });
+  return normalizeCliMcpServers("claude", {
+    ade: {
+      command: launch.command,
+      args: launch.cmdArgs,
+      env: launch.env,
+    },
+  });
+}
+
+function publishResult(result: ClaudeRuntimeProbeResult): void {
+  switch (result.state) {
+    case "ready":
+      reportProviderRuntimeReady("claude");
+      break;
+    case "auth-failed":
+      reportProviderRuntimeAuthFailure("claude", result.message);
+      break;
+    case "runtime-failed":
+      reportProviderRuntimeFailure("claude", result.message);
+      break;
   }
-  reportProviderRuntimeFailure("claude", result.message);
 }
 
 export function resetClaudeRuntimeProbeCache(): void {
@@ -119,20 +161,28 @@ export async function probeClaudeRuntimeHealth(args: {
     return;
   }
 
+  let claudeExecutablePath: string | null = null;
+
   const probe = (async (): Promise<ClaudeRuntimeProbeResult> => {
     const abortController = new AbortController();
     const timeout = setTimeout(() => abortController.abort(), PROBE_TIMEOUT_MS);
-    const stream = claudeQuery({
-      prompt: "System initialization check. Respond with only the word READY.",
-      options: {
-        cwd: projectRoot,
-        permissionMode: "plan",
-        tools: [],
-        abortController,
-      },
-    });
+    let stream: ReturnType<typeof claudeQuery> | null = null;
 
     try {
+      const claudeExecutable = resolveClaudeCodeExecutable();
+      claudeExecutablePath = claudeExecutable.path;
+      stream = claudeQuery({
+        prompt: "System initialization check. Respond with only the word READY.",
+        options: {
+          cwd: projectRoot,
+          permissionMode: "plan",
+          tools: [],
+          pathToClaudeCodeExecutable: claudeExecutable.path,
+          mcpServers: resolveProbeMcpServers(projectRoot) as any,
+          abortController,
+        },
+      });
+
       for await (const message of stream) {
         const result = resultFromSdkMessage(message);
         if (result) {
@@ -154,7 +204,7 @@ export async function probeClaudeRuntimeHealth(args: {
     } finally {
       clearTimeout(timeout);
       try {
-        stream.close();
+        stream?.close();
       } catch {
         // Best effort cleanup — avoid leaving the probe subprocess running.
       }
@@ -172,6 +222,7 @@ export async function probeClaudeRuntimeHealth(args: {
         projectRoot,
         state: result.state,
         message: result.message,
+        claudeExecutablePath,
       });
     }
   } finally {