@codexa/cli 9.0.8 → 9.0.10

package/commands/discover.ts

@@ -12,6 +12,7 @@ import {
   type UnifiedDetectionResult,
 } from "../detectors/loader";
 import { CodexaError } from "../errors";
+import { getGrepaiWorkspace } from "./patterns";
 
 interface StackDetection {
   frontend?: string;
@@ -1123,19 +1124,36 @@ export function ensureDeepExploreAgent(): void {
     console.warn("  Instale com: go install github.com/your-org/grepai@latest");
     console.warn("  Sem grepai, o deep-explore usara apenas Grep (menos eficaz).\n");
   } else {
-    // Check if grepai index exists for this project
+    // Check if grepai index exists for this project (local GOB or workspace)
     const grepaiDir = join(process.cwd(), ".grepai");
-    if (!existsSync(grepaiDir)) {
+    const workspace = getGrepaiWorkspace();
+    if (!existsSync(grepaiDir) && !workspace) {
       console.warn("\n⚠ grepai index nao encontrado neste projeto.");
-      console.warn("  Execute: grepai index");
+      console.warn("  Execute: grepai init && grepai watch");
+      console.warn("  Ou configure um workspace: codexa discover set-stack --grepai-workspace <nome>");
       console.warn("  Sem o index, grepai search nao retornara resultados.\n");
+    } else if (workspace) {
+      console.log(`✓ grepai workspace configurado: ${workspace}`);
     }
   }
 
   // Ensure grepai permissions in target project settings
   ensureGrepaiPermissions();
 
-  if (existsSync(agentPath)) return;
+  // Check if workspace config changed — regenerate if needed
+  const currentWorkspace = getGrepaiWorkspace();
+  const wsFlag = currentWorkspace ? ` --workspace ${currentWorkspace}` : "";
+
+  if (existsSync(agentPath)) {
+    const existing = readFileSync(agentPath, "utf-8");
+    const hasWorkspace = existing.includes("--workspace ");
+    if ((currentWorkspace && !hasWorkspace) || (!currentWorkspace && hasWorkspace)) {
+      console.log("⟳ Atualizando deep-explore.md com config de workspace...");
+      // Fall through to regenerate
+    } else {
+      return; // Already up to date
+    }
+  }
 
   const agentsDir = join(process.cwd(), ".claude", "agents");
   if (!existsSync(agentsDir)) {
@@ -1165,7 +1183,7 @@ You are a semantic code exploration agent. Your primary tool is \\\`grepai\\\`
 **IMPORTANT: Execute ONE grepai search per Bash call. Do NOT run multiple grepai commands in parallel — this causes "Sibling tool call errored". Run them SEQUENTIALLY, one at a time.**
 
 \\\`\\\`\\\`bash
-grepai search "your query here" --json --compact
+grepai search "your query here" --json --compact${wsFlag}
 \\\`\\\`\\\`
 
 - Queries MUST be in English
@@ -1176,28 +1194,28 @@ grepai search "your query here" --json --compact
 Examples (run each one SEPARATELY):
 
 \\\`\\\`\\\`bash
-grepai search "authentication flow" --json --compact
+grepai search "authentication flow" --json --compact${wsFlag}
 \\\`\\\`\\\`
 
 \\\`\\\`\\\`bash
-grepai search "error handling middleware" --json --compact
+grepai search "error handling middleware" --json --compact${wsFlag}
 \\\`\\\`\\\`
 
 \\\`\\\`\\\`bash
-grepai search "database connection management" --json --compact
+grepai search "database connection management" --json --compact${wsFlag}
 \\\`\\\`\\\`
 
 ### Step 2: Use grepai trace for relationships
 
 \\\`\\\`\\\`bash
 # Find all functions that call a symbol
-grepai trace callers "HandleRequest" --json
+grepai trace callers "HandleRequest" --json${wsFlag}
 
 # Find all functions called by a symbol
-grepai trace callees "ProcessOrder" --json
+grepai trace callees "ProcessOrder" --json${wsFlag}
 
 # Build complete call graph
-grepai trace graph "ValidateToken" --depth 3 --json
+grepai trace graph "ValidateToken" --depth 3 --json${wsFlag}
 \\\`\\\`\\\`
 
 ### Step 3: Read files identified by grepai
@@ -1210,6 +1228,15 @@ Use Grep ONLY if you need exact string match (variable name, import path). Never
 
 ---
 
+### Workspace (cross-project search)
+
+If \\\`--workspace\\\` flag is included in the commands above, this project uses a grepai workspace
+for cross-project semantic search. The flag was injected automatically by the Codexa CLI.
+
+- With workspace: searches across ALL projects in the workspace
+- Without workspace: searches only the local project index
+- To filter by project: add \\\`--project <name>\\\`
+
 ### FORBIDDEN
 
 - **DO NOT** use \\\`find\\\` or \\\`ls\\\` to explore code — use \\\`grepai search\\\`

package/commands/patterns.ts

@@ -33,15 +33,42 @@ export function isGrepaiAvailable(): boolean {
   }
 }
 
+// ═══════════════════════════════════════════════════════════════
+// WORKSPACE CONFIG
+// ═══════════════════════════════════════════════════════════════
+
+const WORKSPACE_NAME_REGEX = /^[a-zA-Z0-9_-]+$/;
+
+export function isValidWorkspaceName(name: string): boolean {
+  return WORKSPACE_NAME_REGEX.test(name);
+}
+
+export function getGrepaiWorkspace(): string | null {
+  try {
+    initSchema();
+    const db = getDb();
+    const project = db.query(
+      "SELECT grepai_workspace FROM project WHERE id = 'default'"
+    ).get() as any;
+    return project?.grepai_workspace || null;
+  } catch {
+    return null;
+  }
+}
+
 // ═══════════════════════════════════════════════════════════════
 // BUSCA SEMÂNTICA
 // ═══════════════════════════════════════════════════════════════
 
-export function searchWithGrepai(query: string, topK: number = 10): GrepaiResult[] {
+export function searchWithGrepai(query: string, topK: number = 10, workspace?: string): GrepaiResult[] {
   try {
+    const args = ["search", query, "--top", topK.toString(), "--format", "json"];
+    if (workspace) {
+      args.push("--workspace", workspace);
+    }
     const result = spawnSync(
       "grepai",
-      ["search", query, "--top", topK.toString(), "--format", "json"],
+      args,
       { encoding: "utf-8", maxBuffer: 10 * 1024 * 1024 }
     );
 

package/commands/sync.ts

@@ -1,7 +1,8 @@
 import { execSync } from "child_process";
-import { existsSync, mkdirSync, copyFileSync, readdirSync, readFileSync } from "fs";
+import { existsSync, mkdirSync, copyFileSync, readdirSync, readFileSync, writeFileSync } from "fs";
 import { join } from "path";
 import { CodexaError } from "../errors";
+import { getGrepaiWorkspace } from "./patterns";
 
 // Agents que sao referencias (nao spawnables como subagent_type)
 const REFERENCE_FILES = new Set([
@@ -71,6 +72,16 @@ export function syncAgents(options: { force?: boolean } = {}): void {
     }
 
     copyFileSync(src, dst);
+
+    // Inject workspace flag in deep-explore if configured
+    if (file === "deep-explore.md") {
+      const workspace = getGrepaiWorkspace();
+      const wsFlag = workspace ? ` --workspace ${workspace}` : "";
+      let agentContent = readFileSync(dst, "utf-8");
+      agentContent = agentContent.replace(/\{\{GREPAI_WS_FLAG\}\}/g, wsFlag);
+      writeFileSync(dst, agentContent);
+    }
+
     copied++;
   }
 

package/context/domains.test.ts

@@ -11,6 +11,7 @@ import type { ContextSection } from "./assembly";
 function makeSections(): ContextSection[] {
   return [
     { name: "STANDARDS", content: "...", priority: 1 },
+    { name: "REFERENCIAS", content: "...", priority: 2 },
     { name: "ALERTAS", content: "...", priority: 2 },
     { name: "ARQUITETURA", content: "...", priority: 3 },
     { name: "DECISOES", content: "...", priority: 4 },
@@ -119,7 +120,7 @@ describe("adjustSectionPriorities", () => {
   it("null domain passes all sections through unchanged", () => {
     const sections = makeSections();
     const result = adjustSectionPriorities(sections, null);
-    expect(result).toHaveLength(12);
+    expect(result).toHaveLength(13);
     expect(result).toEqual(sections);
   });
 
@@ -127,8 +128,9 @@ describe("adjustSectionPriorities", () => {
     const result = adjustSectionPriorities(makeSections(), "explore");
     const names = result.map(s => s.name);
 
-    // explore profile: 7 sections have relevance 0
+    // explore profile: 8 sections have relevance 0
     expect(names).not.toContain("STANDARDS");
+    expect(names).not.toContain("REFERENCIAS");
     expect(names).not.toContain("CONTEXTO DE TASKS ANTERIORES");
     expect(names).not.toContain("GRAPH");
     expect(names).not.toContain("PRODUTO");
@@ -189,7 +191,7 @@ describe("adjustSectionPriorities", () => {
     const result = adjustSectionPriorities(makeSections(), "testing");
     const names = result.map(s => s.name);
     expect(names).not.toContain("PRODUTO");
-    expect(result).toHaveLength(11);
+    expect(result).toHaveLength(12);
   });
 
   it("testing domain boosts CONTEXTO DE TASKS ANTERIORES (relevance=3)", () => {
@@ -212,10 +214,30 @@ describe("adjustSectionPriorities", () => {
     expect(produto?.priority).toBe(5);
   });
 
-  it("security domain excludes PRODUTO (relevance=0)", () => {
+  it("backend domain boosts REFERENCIAS (relevance=3)", () => {
+    const result = adjustSectionPriorities(makeSections(), "backend");
+    const refs = result.find(s => s.name === "REFERENCIAS");
+    // backend: REFERENCIAS=3 (base 2 + offset -2 = 0 → floor 1)
+    expect(refs?.priority).toBe(1);
+  });
+
+  it("explore domain excludes REFERENCIAS (relevance=0)", () => {
+    const result = adjustSectionPriorities(makeSections(), "explore");
+    const names = result.map(s => s.name);
+    expect(names).not.toContain("REFERENCIAS");
+  });
+
+  it("architecture domain excludes REFERENCIAS (relevance=0)", () => {
+    const result = adjustSectionPriorities(makeSections(), "architecture");
+    const names = result.map(s => s.name);
+    expect(names).not.toContain("REFERENCIAS");
+  });
+
+  it("security domain excludes PRODUTO and REFERENCIAS (relevance=0)", () => {
     const result = adjustSectionPriorities(makeSections(), "security");
     const names = result.map(s => s.name);
     expect(names).not.toContain("PRODUTO");
+    expect(names).not.toContain("REFERENCIAS");
     expect(result).toHaveLength(11);
   });
 
@@ -235,12 +257,12 @@ describe("adjustSectionPriorities", () => {
 
 describe("DOMAIN_PROFILES completeness", () => {
   const allSectionNames = [
-    "STANDARDS", "ALERTAS", "ARQUITETURA", "DECISOES",
+    "STANDARDS", "REFERENCIAS", "ALERTAS", "ARQUITETURA", "DECISOES",
     "CONTEXTO DE TASKS ANTERIORES", "GRAPH", "PRODUTO",
     "DISCOVERIES", "UTILITIES", "PATTERNS", "HINTS", "STACK",
   ];
 
-  it("every domain profile covers all 12 sections", () => {
+  it("every domain profile covers all 13 sections", () => {
     for (const [domain, profile] of Object.entries(DOMAIN_PROFILES)) {
       for (const section of allSectionNames) {
         expect(profile[section as keyof typeof profile]).toBeDefined();

package/context/domains.ts

@@ -19,6 +19,7 @@ export type Relevance = 0 | 1 | 2 | 3;
 
 export type SectionName =
   | "STANDARDS"
+  | "REFERENCIAS"
   | "ALERTAS"
   | "ARQUITETURA"
   | "DECISOES"
@@ -58,42 +59,42 @@ export const AGENT_DOMAIN: Record<string, AgentDomain> = {
 
 export const DOMAIN_PROFILES: Record<AgentDomain, DomainProfile> = {
   backend: {
-    "STANDARDS": 3, "ALERTAS": 3, "ARQUITETURA": 2, "DECISOES": 3,
+    "STANDARDS": 3, "REFERENCIAS": 3, "ALERTAS": 3, "ARQUITETURA": 2, "DECISOES": 3,
     "CONTEXTO DE TASKS ANTERIORES": 2, "GRAPH": 2, "PRODUTO": 1,
     "DISCOVERIES": 2, "UTILITIES": 3, "PATTERNS": 2, "HINTS": 2, "STACK": 2,
   },
   frontend: {
-    "STANDARDS": 3, "ALERTAS": 3, "ARQUITETURA": 2, "DECISOES": 3,
+    "STANDARDS": 3, "REFERENCIAS": 3, "ALERTAS": 3, "ARQUITETURA": 2, "DECISOES": 3,
     "CONTEXTO DE TASKS ANTERIORES": 2, "GRAPH": 2, "PRODUTO": 3,
     "DISCOVERIES": 2, "UTILITIES": 3, "PATTERNS": 3, "HINTS": 2, "STACK": 2,
   },
   database: {
-    "STANDARDS": 3, "ALERTAS": 3, "ARQUITETURA": 3, "DECISOES": 3,
+    "STANDARDS": 3, "REFERENCIAS": 3, "ALERTAS": 3, "ARQUITETURA": 3, "DECISOES": 3,
     "CONTEXTO DE TASKS ANTERIORES": 2, "GRAPH": 2, "PRODUTO": 0,
     "DISCOVERIES": 2, "UTILITIES": 1, "PATTERNS": 2, "HINTS": 2, "STACK": 3,
   },
   testing: {
-    "STANDARDS": 3, "ALERTAS": 3, "ARQUITETURA": 1, "DECISOES": 2,
+    "STANDARDS": 3, "REFERENCIAS": 3, "ALERTAS": 3, "ARQUITETURA": 1, "DECISOES": 2,
     "CONTEXTO DE TASKS ANTERIORES": 3, "GRAPH": 1, "PRODUTO": 0,
     "DISCOVERIES": 2, "UTILITIES": 3, "PATTERNS": 3, "HINTS": 2, "STACK": 1,
   },
   review: {
-    "STANDARDS": 3, "ALERTAS": 3, "ARQUITETURA": 3, "DECISOES": 3,
+    "STANDARDS": 3, "REFERENCIAS": 1, "ALERTAS": 3, "ARQUITETURA": 3, "DECISOES": 3,
     "CONTEXTO DE TASKS ANTERIORES": 2, "GRAPH": 2, "PRODUTO": 1,
     "DISCOVERIES": 2, "UTILITIES": 3, "PATTERNS": 2, "HINTS": 3, "STACK": 2,
   },
   security: {
-    "STANDARDS": 3, "ALERTAS": 3, "ARQUITETURA": 2, "DECISOES": 2,
+    "STANDARDS": 3, "REFERENCIAS": 0, "ALERTAS": 3, "ARQUITETURA": 2, "DECISOES": 2,
     "CONTEXTO DE TASKS ANTERIORES": 1, "GRAPH": 1, "PRODUTO": 0,
     "DISCOVERIES": 2, "UTILITIES": 1, "PATTERNS": 1, "HINTS": 2, "STACK": 3,
   },
   explore: {
-    "STANDARDS": 0, "ALERTAS": 1, "ARQUITETURA": 3, "DECISOES": 1,
+    "STANDARDS": 0, "REFERENCIAS": 0, "ALERTAS": 1, "ARQUITETURA": 3, "DECISOES": 1,
     "CONTEXTO DE TASKS ANTERIORES": 0, "GRAPH": 0, "PRODUTO": 0,
     "DISCOVERIES": 1, "UTILITIES": 0, "PATTERNS": 0, "HINTS": 0, "STACK": 3,
   },
   architecture: {
-    "STANDARDS": 2, "ALERTAS": 2, "ARQUITETURA": 3, "DECISOES": 3,
+    "STANDARDS": 2, "REFERENCIAS": 0, "ALERTAS": 2, "ARQUITETURA": 3, "DECISOES": 3,
     "CONTEXTO DE TASKS ANTERIORES": 2, "GRAPH": 2, "PRODUTO": 3,
     "DISCOVERIES": 2, "UTILITIES": 1, "PATTERNS": 2, "HINTS": 1, "STACK": 3,
   },

package/context/generator.ts

@@ -18,6 +18,7 @@ import {
     buildGraphSection,
     buildStackSection,
     buildHintsSection,
+    buildReferencesSection,
 } from "./sections";
 
 // v9.0: Contexto minimo para subagent (max ~2KB)
@@ -253,6 +254,7 @@ export function getContextForSubagent(taskId: number): string {
         buildProductSection(data),
         buildArchitectureSection(data),
         buildStandardsSection(data),
+        buildReferencesSection(data),
         buildDecisionsSection(data),
         buildReasoningSection(data),
         buildAlertsSection(data),

package/context/index.ts

@@ -18,4 +18,7 @@ export {
     buildGraphSection,
     buildStackSection,
     buildHintsSection,
+    buildReferencesSection,
 } from "./sections";
+export { findReferenceFiles } from "./references";
+export type { ReferenceFile } from "./references";

package/context/references.test.ts

@@ -0,0 +1,159 @@
+import { describe, it, expect, beforeAll, afterAll } from "bun:test";
+import { join } from "path";
+import { mkdirSync, rmSync, writeFileSync } from "fs";
+import { findReferenceFiles } from "./references";
+
+// ── Test fixtures ────────────────────────────────────────────
+
+const TMP_DIR = join(import.meta.dir, "__test_refs__");
+
+function ensureDir(dir: string) {
+  mkdirSync(dir, { recursive: true });
+}
+
+function writeTmpFile(relativePath: string, content: string): string {
+  const full = join(TMP_DIR, relativePath);
+  ensureDir(join(full, ".."));
+  writeFileSync(full, content);
+  return relativePath;
+}
+
+beforeAll(() => {
+  ensureDir(TMP_DIR);
+
+  // src/routes/ — 3 route files of different sizes
+  writeTmpFile("src/routes/users.ts", "export function getUsers() { return []; }\nexport function createUser() { return {}; }\n// more code here to make it larger\n".repeat(5));
+  writeTmpFile("src/routes/products.ts", "export function getProducts() { return []; }\n");
+  writeTmpFile("src/routes/orders.ts", "export function getOrders() { return []; }\nexport function createOrder() { return {}; }\n");
+
+  // src/services/ — 2 service files
+  writeTmpFile("src/services/auth.service.ts", "export class AuthService { login() {} logout() {} verify() {} }\n".repeat(3));
+  writeTmpFile("src/services/user.service.ts", "export class UserService { getById() {} }\n");
+
+  // src/components/ — React components
+  writeTmpFile("src/components/Button.tsx", "export function Button() { return <button/>; }\n");
+  writeTmpFile("src/components/Card.tsx", "export function Card() { return <div/>; }\nexport function CardHeader() { return <div/>; }\n".repeat(3));
+
+  // src/modules/users/ and src/modules/payments/ — parallel structure
+  writeTmpFile("src/modules/users/route.ts", "export function usersRoute() { return {}; }\n".repeat(4));
+  writeTmpFile("src/modules/users/service.ts", "export function usersService() {}\n");
+  writeTmpFile("src/modules/payments/service.ts", "export function paymentsService() {}\n");
+
+  // tests/ — test files
+  writeTmpFile("tests/routes/users.test.ts", "describe('users', () => { it('works', () => {}); });\n".repeat(2));
+
+  // node_modules/ — should be ignored
+  writeTmpFile("node_modules/pkg/index.ts", "export const x = 1;\n");
+
+  // Non-code file
+  writeTmpFile("docs/readme.md", "# Readme\n");
+});
+
+afterAll(() => {
+  rmSync(TMP_DIR, { recursive: true, force: true });
+});
+
+// ── Tests ────────────────────────────────────────────────────
+
+describe("findReferenceFiles", () => {
+  it("finds siblings in the same directory", () => {
+    // Target: new file in src/routes/ — should find existing routes
+    const refs = findReferenceFiles(["src/routes/payments.ts"], TMP_DIR);
+
+    expect(refs.length).toBeGreaterThanOrEqual(1);
+    expect(refs[0].reason).toBe("mesmo diretorio");
+    // Should pick the largest sibling (users.ts has the most content)
+    expect(refs[0].path).toBe("src/routes/users.ts");
+  });
+
+  it("prioritizes largest file as reference", () => {
+    const refs = findReferenceFiles(["src/components/Modal.tsx"], TMP_DIR);
+
+    expect(refs.length).toBe(1);
+    // Card.tsx is larger than Button.tsx
+    expect(refs[0].path).toBe("src/components/Card.tsx");
+  });
+
+  it("finds namesakes when no siblings exist", () => {
+    // Target: src/modules/payments/route.ts — no siblings, but src/modules/users/route.ts exists
+    const refs = findReferenceFiles(["src/modules/payments/route.ts"], TMP_DIR);
+
+    expect(refs.length).toBeGreaterThanOrEqual(1);
+    const paths = refs.map(r => r.path);
+    // Should find the namesake route.ts or a sibling service.ts
+    expect(
+      paths.some(p => p.includes("route.ts") || p.includes("service.ts"))
+    ).toBe(true);
+  });
+
+  it("returns empty for non-code files", () => {
+    const refs = findReferenceFiles(["docs/notes.md"], TMP_DIR);
+    expect(refs).toEqual([]);
+  });
+
+  it("returns empty for empty task files", () => {
+    expect(findReferenceFiles([], TMP_DIR)).toEqual([]);
+  });
+
+  it("returns empty for null/undefined", () => {
+    expect(findReferenceFiles(null as any, TMP_DIR)).toEqual([]);
+    expect(findReferenceFiles(undefined as any, TMP_DIR)).toEqual([]);
+  });
+
+  it("ignores node_modules", () => {
+    const refs = findReferenceFiles(["node_modules/pkg/new.ts"], TMP_DIR);
+    // Even if node_modules has .ts files, targets in ignored dirs get no refs
+    // (the target itself is filtered by extension check, not by ignored dir)
+    // But results should never point INTO node_modules
+    for (const ref of refs) {
+      expect(ref.path).not.toContain("node_modules");
+    }
+  });
+
+  it("limits to 3 references max", () => {
+    const refs = findReferenceFiles([
+      "src/routes/payments.ts",
+      "src/services/payment.service.ts",
+      "src/components/Modal.tsx",
+      "tests/routes/products.test.ts",
+    ], TMP_DIR);
+
+    expect(refs.length).toBeLessThanOrEqual(3);
+  });
+
+  it("deduplicates references", () => {
+    const refs = findReferenceFiles([
+      "src/routes/payments.ts",
+      "src/routes/invoices.ts",
+    ], TMP_DIR);
+
+    const paths = refs.map(r => r.path);
+    const unique = new Set(paths);
+    expect(paths.length).toBe(unique.size);
+  });
+
+  it("handles Windows-style backslash paths", () => {
+    const refs = findReferenceFiles(["src\\routes\\payments.ts"], TMP_DIR);
+    expect(refs.length).toBeGreaterThanOrEqual(1);
+    // All returned paths should use forward slashes
+    for (const ref of refs) {
+      expect(ref.path).not.toContain("\\");
+    }
+  });
+
+  it("finds reference for test files", () => {
+    const refs = findReferenceFiles(["tests/routes/products.test.ts"], TMP_DIR);
+    expect(refs.length).toBeGreaterThanOrEqual(1);
+    expect(refs[0].path).toContain("users.test.ts");
+  });
+
+  it("uses parent directory as fallback", () => {
+    // Target in a new subdirectory with no siblings or namesakes
+    writeTmpFile("src/features/billing/handler.ts", "export function handle() {}\n");
+    const refs = findReferenceFiles(["src/features/billing/processor.ts"], TMP_DIR);
+    // Should find handler.ts as sibling
+    if (refs.length > 0) {
+      expect(refs[0].path).toContain("billing");
+    }
+  });
+});

package/context/references.ts

@@ -0,0 +1,159 @@
+import { join, dirname, basename, extname, resolve, relative } from "path";
+import { globSync } from "fs";
+
+// ═══════════════════════════════════════════════════════════════
+// REFERENCE FILES — Pattern by Example (v9.5)
+//
+// Finds existing files similar to task targets so subagents can
+// read them and replicate the coding style exactly.
+// ═══════════════════════════════════════════════════════════════
+
+export interface ReferenceFile {
+  path: string;
+  reason: string;
+}
+
+const IGNORED_DIRS = new Set([
+  "node_modules", ".git", "dist", "build", ".next", ".codexa",
+  ".nuxt", ".output", "coverage", "__pycache__", ".venv", "vendor",
+  "target", "bin", "obj",
+]);
+
+const CODE_EXTENSIONS = new Set([
+  ".ts", ".tsx", ".js", ".jsx", ".vue", ".svelte",
+  ".go", ".rs", ".py", ".cs", ".kt", ".java",
+  ".dart", ".php", ".rb", ".swift",
+]);
+
+function normalizePath(p: string): string {
+  return p.replace(/\\/g, "/");
+}
+
+function isIgnored(filePath: string): boolean {
+  const parts = normalizePath(filePath).split("/");
+  return parts.some(part => IGNORED_DIRS.has(part));
+}
+
+function getFileSize(filePath: string): number {
+  try {
+    return Bun.file(filePath).size;
+  } catch {
+    return 0;
+  }
+}
+
+function fileExists(filePath: string): boolean {
+  try {
+    return Bun.file(filePath).size > 0;
+  } catch {
+    return false;
+  }
+}
+
+function globFiles(pattern: string, cwd: string): string[] {
+  try {
+    const glob = new Bun.Glob(pattern);
+    const results: string[] = [];
+    for (const match of glob.scanSync({ cwd, dot: false })) {
+      const full = join(cwd, match);
+      if (!isIgnored(full)) {
+        results.push(normalizePath(full));
+      }
+    }
+    return results;
+  } catch {
+    return [];
+  }
+}
+
+function pickLargest(files: string[]): string | null {
+  if (files.length === 0) return null;
+
+  let best = files[0];
+  let bestSize = getFileSize(files[0]);
+
+  for (let i = 1; i < files.length; i++) {
+    const size = getFileSize(files[i]);
+    if (size > bestSize) {
+      best = files[i];
+      bestSize = size;
+    }
+  }
+
+  return bestSize > 0 ? best : null;
+}
+
+/**
+ * Find reference files for a set of task target files.
+ *
+ * Strategy per target file:
+ * 1. Siblings — other files in the same directory with same extension
+ * 2. Namesakes — files with same basename in other directories
+ * 3. Parent — files with same extension in parent directory tree
+ *
+ * Returns max 3 deduplicated reference file paths.
+ */
+export function findReferenceFiles(
+  taskFiles: string[],
+  projectRoot: string,
+): ReferenceFile[] {
+  if (!taskFiles || taskFiles.length === 0) return [];
+
+  const seen = new Set<string>();
+  const results: ReferenceFile[] = [];
+  const normalizedRoot = normalizePath(resolve(projectRoot));
+
+  for (const rawTarget of taskFiles) {
+    if (results.length >= 3) break;
+
+    const target = normalizePath(resolve(projectRoot, rawTarget));
+    const ext = extname(target);
+    const base = basename(target);
+    const dir = dirname(target);
+
+    if (!ext || !CODE_EXTENSIONS.has(ext)) continue;
+
+    // Strategy 1: Siblings (same directory, same extension)
+    const siblings = globFiles(`*${ext}`, dir)
+      .filter(f => f !== target && !seen.has(f) && fileExists(f));
+
+    const bestSibling = pickLargest(siblings);
+    if (bestSibling) {
+      const rel = normalizePath(relative(normalizedRoot, bestSibling));
+      seen.add(bestSibling);
+      results.push({ path: rel, reason: "mesmo diretorio" });
+      continue;
+    }
+
+    // Strategy 2: Namesakes (same filename in other directories)
+    const namesakes = globFiles(`**/${base}`, normalizedRoot)
+      .filter(f => f !== target && !seen.has(f) && fileExists(f));
+
+    if (namesakes.length > 0) {
+      // Pick the one closest by path depth similarity
+      const bestNamesake = pickLargest(namesakes);
+      if (bestNamesake) {
+        const rel = normalizePath(relative(normalizedRoot, bestNamesake));
+        seen.add(bestNamesake);
+        results.push({ path: rel, reason: "mesmo tipo de arquivo" });
+        continue;
+      }
+    }
+
+    // Strategy 3: Parent directory search (same extension, one level up)
+    const parentDir = dirname(dir);
+    if (parentDir !== dir) {
+      const parentFiles = globFiles(`**/*${ext}`, parentDir)
+        .filter(f => f !== target && !seen.has(f) && fileExists(f));
+
+      const bestParent = pickLargest(parentFiles);
+      if (bestParent) {
+        const rel = normalizePath(relative(normalizedRoot, bestParent));
+        seen.add(bestParent);
+        results.push({ path: rel, reason: "arquivo similar proximo" });
+      }
+    }
+  }
+
+  return results;
+}

package/context/sections.ts

@@ -1,6 +1,7 @@
 import { getUtilitiesForContext, getAgentHints } from "../db/schema";
 import type { ContextSection, ContextData } from "./assembly";
 import { getAgentDomain, domainToScope } from "./domains";
+import { findReferenceFiles } from "./references";
 
 // ── Section Builders ──────────────────────────────────────────
 
@@ -245,3 +246,18 @@ ${hints.map(h => `- ${h}`).join("\n")}
 `;
     return { name: "HINTS", content, priority: 10 };
 }
+
+export function buildReferencesSection(data: ContextData): ContextSection | null {
+    if (data.taskFiles.length === 0) return null;
+
+    const projectRoot = process.cwd();
+    const refs = findReferenceFiles(data.taskFiles, projectRoot);
+    if (refs.length === 0) return null;
+
+    const content = `
+### REFERENCIA DE ESTILO (${refs.length})
+**ANTES de criar/modificar arquivos, leia estas referencias e replique o mesmo estilo** (nomenclatura, estrutura, imports, error handling):
+${refs.map(r => `- \`${r.path}\` (${r.reason})`).join("\n")}
+`;
+    return { name: "REFERENCIAS", content, priority: 2 };
+}

package/db/schema.ts

@@ -480,6 +480,13 @@ const MIGRATIONS: Migration[] = [
       db.exec(`ALTER TABLE project ADD COLUMN typecheck_command TEXT`);
     },
   },
+  {
+    version: "9.8.0",
+    description: "Adicionar grepai_workspace na tabela project para suporte a workspace cross-project",
+    up: (db) => {
+      db.exec(`ALTER TABLE project ADD COLUMN grepai_workspace TEXT`);
+    },
+  },
 ];
 
 export function runMigrations(): void {

package/detectors/go.ts

@@ -55,6 +55,37 @@ function parseGoMod(content: string): GoMod {
   return result;
 }
 
+interface GoWork {
+  goVersion?: string;
+  uses: string[];
+}
+
+function parseGoWork(content: string): GoWork {
+  const result: GoWork = { uses: [] };
+
+  const goMatch = content.match(/^go\s+(\d+\.\d+(?:\.\d+)?)$/m);
+  if (goMatch) result.goVersion = goMatch[1];
+
+  // Parse use block: use ( ./path1 \n ./path2 )
+  const useBlockMatch = content.match(/use\s*\(([\s\S]*?)\)/);
+  if (useBlockMatch) {
+    for (const line of useBlockMatch[1].split("\n")) {
+      const trimmed = line.trim();
+      if (trimmed && !trimmed.startsWith("//")) {
+        result.uses.push(trimmed);
+      }
+    }
+  }
+
+  // Parse single-line: use ./path
+  const singleUses = content.matchAll(/^use\s+(\S+)\s*$/gm);
+  for (const match of singleUses) {
+    result.uses.push(match[1].trim());
+  }
+
+  return result;
+}
+
 const goDetector: Detector = {
   name: "go",
   ecosystem: "go",
@@ -117,12 +148,35 @@ const goDetector: Detector = {
       category: "runtime",
     });
 
-    // Create dependency lookup
+    // Create dependency lookup from root go.mod
     const deps = new Map<string, string>();
     for (const req of goMod.require) {
       deps.set(req.path, req.version);
     }
 
+    // Merge workspace module dependencies from go.work
+    const goWorkPath = join(cwd, "go.work");
+    if (fileExists(goWorkPath)) {
+      const goWorkContent = readText(goWorkPath);
+      if (goWorkContent) {
+        const goWork = parseGoWork(goWorkContent);
+        for (const usePath of goWork.uses) {
+          const wsModPath = join(cwd, usePath, "go.mod");
+          if (fileExists(wsModPath)) {
+            const wsContent = readText(wsModPath);
+            if (wsContent) {
+              const wsMod = parseGoMod(wsContent);
+              for (const req of wsMod.require) {
+                if (!deps.has(req.path)) {
+                  deps.set(req.path, req.version);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+
     // Web Framework Detection
     const webFrameworks = [
       { paths: ["github.com/gin-gonic/gin"], name: "Gin", confidence: 1.0 },

package/detectors/node.ts

@@ -22,6 +22,32 @@ import {
   readText,
 } from "./index";
 
+/**
+ * Resolve workspace glob patterns from package.json workspaces or pnpm-workspace.yaml.
+ * Returns array of glob patterns (e.g. ["apps/*", "packages/*"]).
+ */
+function resolveWorkspacePatterns(cwd: string, pkg: PackageJson): string[] {
+  // npm/yarn: workspaces as array or { packages: [] }
+  if (pkg.workspaces) {
+    if (Array.isArray(pkg.workspaces)) return pkg.workspaces;
+    if (pkg.workspaces.packages) return pkg.workspaces.packages;
+  }
+
+  // pnpm: pnpm-workspace.yaml
+  const pnpmPath = join(cwd, "pnpm-workspace.yaml");
+  const content = readText(pnpmPath);
+  if (content) {
+    const patterns: string[] = [];
+    for (const line of content.split("\n")) {
+      const match = line.match(/^\s*-\s*['"]?([^'"#]+)['"]?\s*$/);
+      if (match) patterns.push(match[1].trim());
+    }
+    return patterns;
+  }
+
+  return [];
+}
+
 interface PackageJson {
   name?: string;
   version?: string;
@@ -93,12 +119,24 @@ const nodeDetector: Detector = {
     const pkg: PackageJson | null = readJson(pkgPath);
     if (!pkg) return null;
 
-    const allDeps = {
+    const allDeps: Record<string, string> = {
       ...pkg.dependencies,
       ...pkg.devDependencies,
       ...pkg.peerDependencies,
     };
 
+    // Merge workspace package dependencies
+    const workspacePatterns = resolveWorkspacePatterns(cwd, pkg);
+    for (const pattern of workspacePatterns) {
+      const pkgFiles = findFiles(cwd, `${pattern}/package.json`);
+      for (const relPath of pkgFiles) {
+        const wsPkg: PackageJson | null = readJson(join(cwd, relPath));
+        if (wsPkg) {
+          Object.assign(allDeps, wsPkg.dependencies, wsPkg.devDependencies);
+        }
+      }
+    }
+
     // Detect package manager from lock files
     if (fileExists(join(cwd, "bun.lockb"))) {
       technologies.push({

package/gates/standards-validator.ts

@@ -1,7 +1,7 @@
 import { getDb } from "../db/connection";
 import { existsSync, readFileSync } from "fs";
 import { basename, resolve } from "path";
-import { isGrepaiAvailable, searchWithGrepai, type GrepaiResult } from "../commands/patterns";
+import { isGrepaiAvailable, searchWithGrepai, getGrepaiWorkspace, type GrepaiResult } from "../commands/patterns";
 
 // ═══════════════════════════════════════════════════════════════
 // INTERFACES
@@ -119,10 +119,11 @@ function validateSemantic(
   violations: Violation[],
   warnings: Violation[]
 ): void {
+  const workspace = getGrepaiWorkspace() ?? undefined;
   for (const std of standards) {
     if (!std.semantic_query) continue;
 
-    const results = searchWithGrepai(std.semantic_query, 20);
+    const results = searchWithGrepai(std.semantic_query, 20, workspace);
 
     // Filtrar: apenas arquivos sendo validados + score acima do threshold
     const matchingFiles = results.filter(r => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codexa/cli",
-  "version": "9.0.8",
+  "version": "9.0.10",
   "description": "Orchestrated workflow system for Claude Code - manages feature development through parallel subagents with structured phases, gates, and quality enforcement.",
   "type": "module",
   "bin": {

package/workflow.ts

@@ -23,7 +23,9 @@ import {
   discoverRefreshPatterns,
   discoverExportPatterns,
   discoverIncremental,
+  ensureDeepExploreAgent,
 } from "./commands/discover";
+import { isValidWorkspaceName } from "./commands/patterns";
 import { clearTasks, clearShow } from "./commands/clear";
 import { standardsList, standardsAdd, standardsEdit, standardsRemove, standardsExport } from "./commands/standards";
 import { productImport, productSet, productConfirm, productShow, productReset } from "./commands/product";
@@ -553,6 +555,7 @@ discoverCmd
   .option("--auth <value>", "Auth (supabase, next-auth, clerk)")
   .option("--testing <value>", "Testing (vitest, jest, playwright)")
   .option("--typecheck-command <cmd>", "Comando custom de typecheck (ex: 'mypy --strict', 'go vet ./...'). Vazio para usar preset automatico.")
+  .option("--grepai-workspace <name>", "Nome do workspace grepai para busca semantica cross-project. Vazio para remover.")
   .action((options) => {
     // Tratar typecheck-command separadamente
     if (options.typecheckCommand !== undefined) {
@@ -569,9 +572,32 @@ discoverCmd
       }
       console.log("  Sera usado no gate 4.5 (typecheck-pass) em cada task done.\n");
     }
+    // Tratar grepai-workspace separadamente
+    if (options.grepaiWorkspace !== undefined) {
+      const { initSchema } = require("./db/schema");
+      const { getDb } = require("./db/connection");
+      initSchema();
+      const db = getDb();
+      const value = options.grepaiWorkspace === "" ? null : options.grepaiWorkspace;
+      if (value && !isValidWorkspaceName(value)) {
+        console.error(`\n[erro] Nome de workspace invalido: "${value}"`);
+        console.error("  Use apenas letras, numeros, hifens e underscores (ex: meu-workspace, dotnet_ws)\n");
+        return;
+      }
+      db.run("UPDATE project SET grepai_workspace = ? WHERE id = 'default'", [value]);
+      if (value) {
+        console.log(`\n✓ Grepai workspace configurado: ${value}`);
+        console.log("  Sera usado em: semantic search (standards), deep-explore agent, grepai trace");
+      } else {
+        console.log(`\n✓ Grepai workspace removido (usando index local .grepai/)`);
+      }
+      // Auto-regenerate deep-explore agent with new workspace config
+      ensureDeepExploreAgent();
+    }
     // Tratar stack options normalmente
     const stackOptions = { ...options };
     delete stackOptions.typecheckCommand;
+    delete stackOptions.grepaiWorkspace;
     if (Object.keys(stackOptions).length > 0) {
       discoverSetStack(stackOptions);
     }