@pikaa-ai/pikaa 0.3.27 → 0.3.28

package/dist/index.js

@@ -2567,29 +2567,116 @@ var shellTool = createShellTool();
 // src/tools/handlers/file-ops.ts
 import { readdirSync as readdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3, existsSync as existsSync8, statSync as statSync3, mkdirSync as mkdirSync6 } from "fs";
 import { resolve as resolve6, dirname as dirname4 } from "path";
+var DEFAULT_MAX_UNPAGINATED_LINES = 250;
 var readFileTool = {
   name: "read_file",
-  description: "Read the full text content of a file.",
+  description: "Read file content with surgical line-range support. Supports start_line and end_line to inspect specific sections of large files without exhausting token context.",
   parameters: {
     type: "object",
     properties: {
-      path: { type: "string", description: "Relative or absolute path to the file." }
+      path: {
+        type: "string",
+        description: "Relative or absolute path to the file."
+      },
+      start_line: {
+        type: "number",
+        description: "Optional 1-indexed line number to start reading from (e.g. 120)."
+      },
+      end_line: {
+        type: "number",
+        description: "Optional 1-indexed line number to end reading at, inclusive (e.g. 180)."
+      },
+      offset: {
+        type: "number",
+        description: "Alias for start_line (1-indexed)."
+      },
+      limit: {
+        type: "number",
+        description: "Maximum number of lines to read."
+      },
+      line_numbers: {
+        type: "boolean",
+        description: "Whether to include line number prefixes ('<line>: <content>'). Defaults to true for range reads."
+      }
     },
     required: ["path"]
   },
   async execute(args, ctx) {
-    const filePath = resolve6(ctx.cwd, String(args.path || ""));
+    const rawPath = String(args.path || "");
+    const filePath = resolve6(ctx.cwd, rawPath);
     if (!existsSync8(filePath)) {
-      return { output: `Error: File not found: '${args.path}'`, isError: true };
+      return { output: `Error: File not found: '${rawPath}'`, isError: true };
     }
     try {
       const content = readFileSync3(filePath, "utf8");
-      return { output: content };
+      const lines = content.split(/\r?\n/);
+      const totalLines = lines.length;
+      const hasRange = args.start_line !== undefined || args.end_line !== undefined || args.startLine !== undefined || args.endLine !== undefined || args.offset !== undefined || args.limit !== undefined;
+      if (!hasRange) {
+        if (args.line_numbers === true) {
+          const formatted = lines.map((l, idx) => `${idx + 1}: ${l}`).join(`
+`);
+          return { output: formatted };
+        }
+        if (totalLines <= DEFAULT_MAX_UNPAGINATED_LINES) {
+          return { output: content };
+        }
+        const truncated = lines.slice(0, DEFAULT_MAX_UNPAGINATED_LINES);
+        const formatted = truncated.map((l, idx) => `${idx + 1}: ${l}`).join(`
+`);
+        return {
+          output: `[Showing lines 1 to ${DEFAULT_MAX_UNPAGINATED_LINES} of ${totalLines} in '${rawPath}']
+${formatted}
+
+[Truncated: ${totalLines - DEFAULT_MAX_UNPAGINATED_LINES} more lines. Use start_line=${DEFAULT_MAX_UNPAGINATED_LINES + 1} to continue reading.]`
+        };
+      }
+      const startArg = args.start_line ?? args.startLine ?? args.offset;
+      const start = Math.max(1, typeof startArg === "number" ? Math.floor(startArg) : 1);
+      let end;
+      const endArg = args.end_line ?? args.endLine;
+      if (typeof endArg === "number") {
+        end = Math.min(totalLines, Math.floor(endArg));
+      } else if (typeof args.limit === "number") {
+        end = Math.min(totalLines, start + Math.floor(args.limit) - 1);
+      } else {
+        end = Math.min(totalLines, start + DEFAULT_MAX_UNPAGINATED_LINES - 1);
+      }
+      if (start > totalLines) {
+        return {
+          output: `Error: start_line (${start}) exceeds total lines in file (${totalLines}).`,
+          isError: true
+        };
+      }
+      if (end < start) {
+        return {
+          output: `Error: end_line (${end}) cannot be less than start_line (${start}).`,
+          isError: true
+        };
+      }
+      const sliced = lines.slice(start - 1, end);
+      const withNums = args.line_numbers !== false;
+      const rendered = withNums ? sliced.map((l, idx) => `${start + idx}: ${l}`).join(`
+`) : sliced.join(`
+`);
+      let notice = `[Showing lines ${start} to ${end} of ${totalLines} in '${rawPath}']
+${rendered}`;
+      if (end < totalLines) {
+        notice += `
+
+[File has ${totalLines} lines. To read further, use start_line=${end + 1}.]`;
+      }
+      return { output: notice };
     } catch (err) {
       return { output: `Failed to read file: ${err instanceof Error ? err.message : String(err)}`, isError: true };
     }
   }
 };
+var viewFileTool = {
+  ...readFileTool,
+  name: "view_file",
+  description: "View file content with surgical line-range support. Alias for read_file matching Antigravity & Claude Code conventions."
+};
 var listDirTool = {
   name: "list_dir",
   description: "List contents of a directory with file names and types.",
@@ -3103,7 +3190,13 @@ function createFileSearchTools(engine = new FileSearchEngine) {
 `) };
     }
   };
-  return [grepSearchTool, findFilesTool];
+  const findByNameTool = {
+    name: "find_by_name",
+    description: "Search for files and directories across the workspace matching a name or glob pattern. Alias for find_files matching Antigravity & Claude Code conventions.",
+    parameters: findFilesTool.parameters,
+    execute: findFilesTool.execute
+  };
+  return [grepSearchTool, findFilesTool, findByNameTool];
 }
 
 // src/code-mode/tools-proxy.ts
@@ -3622,6 +3715,7 @@ function createDefaultTools(options = {}) {
   router2.register(applyPatchTool);
   router2.register(shellTool);
   router2.register(readFileTool);
+  router2.register(viewFileTool);
   router2.register(writeFileTool);
   router2.register(listDirTool);
   router2.register(requestUserInputTool);
@@ -4268,7 +4362,499 @@ class TurnContext {
     this.abortController.abort(new Error(reason));
   }
 }
+// src/verification/verifier.ts
+import { spawnSync } from "child_process";
+import { existsSync as existsSync14, readFileSync as readFileSync9 } from "fs";
+import { join as join8 } from "path";
+
+// src/init/project-analyzer.ts
+import { existsSync as existsSync13, readFileSync as readFileSync8, readdirSync as readdirSync6 } from "fs";
+import { join as join7, basename } from "path";
 
+class ProjectAnalyzer {
+  cwd;
+  constructor(cwd = process.cwd()) {
+    this.cwd = cwd;
+  }
+  analyze() {
+    const readmeInfo = this.extractReadmeMetadata();
+    const projectName = readmeInfo.title || this.detectProjectName();
+    const languages = this.detectLanguages();
+    const packageManager = this.detectPackageManager();
+    const frameworks = [];
+    const infrastructure = [];
+    const commands = {};
+    const architectureNotes = [];
+    const codeConventions = [];
+    let description = readmeInfo.description;
+    const pkgPath = join7(this.cwd, "package.json");
+    if (existsSync13(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync8(pkgPath, "utf8"));
+        if (!description && pkg.description)
+          description = pkg.description;
+        const pm = packageManager || "npm";
+        const runPrefix = pm === "bun" || pm === "yarn" || pm === "pnpm" ? `${pm} run` : "npm run";
+        const testPrefix = pm === "bun" ? "bun test" : pm === "pnpm" ? "pnpm test" : pm === "yarn" ? "yarn test" : "npm test";
+        if (pkg.scripts) {
+          if (pkg.scripts.dev)
+            commands.dev = `${runPrefix} dev`;
+          else if (pkg.scripts.start)
+            commands.dev = `${runPrefix} start`;
+          if (pkg.scripts.build)
+            commands.build = `${runPrefix} build`;
+          if (pkg.scripts.test)
+            commands.test = pkg.scripts.test === "bun test" ? "bun test" : testPrefix;
+          if (pkg.scripts.typecheck)
+            commands.typecheck = `${runPrefix} typecheck`;
+          else if (pkg.scripts.check)
+            commands.typecheck = `${runPrefix} check`;
+          if (pkg.scripts.lint)
+            commands.lint = `${runPrefix} lint`;
+          if (pkg.scripts.format)
+            commands.format = `${runPrefix} format`;
+        }
+        const allDeps = {
+          ...pkg.dependencies || {},
+          ...pkg.devDependencies || {}
+        };
+        if (allDeps.next)
+          frameworks.push("Next.js");
+        if (allDeps.react)
+          frameworks.push("React");
+        if (allDeps.vue)
+          frameworks.push("Vue.js");
+        if (allDeps.svelte || allDeps["@sveltejs/kit"])
+          frameworks.push("Svelte");
+        if (allDeps.astro)
+          frameworks.push("Astro");
+        if (allDeps.vite)
+          frameworks.push("Vite");
+        if (allDeps.express)
+          frameworks.push("Express");
+        if (allDeps.hono)
+          frameworks.push("Hono");
+        if (allDeps.fastify)
+          frameworks.push("Fastify");
+        if (allDeps["@nestjs/core"])
+          frameworks.push("NestJS");
+        if (allDeps.tailwindcss)
+          frameworks.push("TailwindCSS");
+        if (allDeps["lucide-react"] || allDeps.lucide)
+          frameworks.push("Lucide Icons");
+        if (allDeps.zustand)
+          frameworks.push("Zustand");
+        if (allDeps["@tanstack/react-query"])
+          frameworks.push("TanStack Query");
+        if (allDeps.oxlint)
+          frameworks.push("Oxlint");
+        if (allDeps.eslint)
+          frameworks.push("ESLint");
+        if (allDeps.vitest)
+          frameworks.push("Vitest");
+        if (allDeps.jest)
+          frameworks.push("Jest");
+        if (allDeps.playwright || allDeps["@playwright/test"])
+          frameworks.push("Playwright");
+        if (pkg.type === "module") {
+          codeConventions.push("Use ES modules (`import/export`), not CommonJS (`require`).");
+        }
+      } catch {}
+    }
+    const tsconfigPath = join7(this.cwd, "tsconfig.json");
+    if (existsSync13(tsconfigPath)) {
+      try {
+        const tsconfig = JSON.parse(readFileSync8(tsconfigPath, "utf8"));
+        if (tsconfig.compilerOptions?.strict) {
+          codeConventions.push("TypeScript strict mode enabled.");
+        }
+        if (!commands.typecheck) {
+          commands.typecheck = "tsc --noEmit";
+        }
+      } catch {}
+    }
+    const cargoPath = join7(this.cwd, "Cargo.toml");
+    if (existsSync13(cargoPath)) {
+      try {
+        commands.dev = commands.dev || "cargo run";
+        commands.build = commands.build || "cargo build";
+        commands.test = commands.test || "cargo test";
+        commands.lint = commands.lint || "cargo clippy";
+        frameworks.push("Rust Cargo");
+      } catch {}
+    }
+    const goModPath = join7(this.cwd, "go.mod");
+    if (existsSync13(goModPath)) {
+      try {
+        commands.dev = commands.dev || "go run .";
+        commands.build = commands.build || "go build ./...";
+        commands.test = commands.test || "go test ./...";
+        commands.lint = commands.lint || "golangci-lint run";
+        frameworks.push("Go Modules");
+      } catch {}
+    }
+    const pyprojectPath = join7(this.cwd, "pyproject.toml");
+    const requirementsPath = join7(this.cwd, "requirements.txt");
+    if (existsSync13(pyprojectPath) || existsSync13(requirementsPath)) {
+      commands.test = commands.test || "pytest";
+      commands.lint = commands.lint || "ruff check .";
+      if (existsSync13(join7(this.cwd, "uv.lock"))) {
+        frameworks.push("uv");
+        commands.test = "uv run pytest";
+      } else if (existsSync13(join7(this.cwd, "poetry.lock"))) {
+        frameworks.push("Poetry");
+        commands.test = "poetry run pytest";
+      }
+    }
+    if (existsSync13(join7(this.cwd, "Dockerfile"))) {
+      infrastructure.push("Docker");
+      const sanitizedName = projectName.toLowerCase().replace(/[^a-z0-9_-]/g, "-").replace(/^-+|-+$/g, "");
+      commands.dockerBuild = `docker build -t ${sanitizedName || "app"} .`;
+    }
+    if (existsSync13(join7(this.cwd, "nginx.conf"))) {
+      infrastructure.push("Nginx");
+    }
+    if (existsSync13(join7(this.cwd, "src/api.ts")) || existsSync13(join7(this.cwd, "src/api"))) {
+      architectureNotes.push("Backend API endpoints and network client logic are centralized in `src/api`.");
+    }
+    if (existsSync13(join7(this.cwd, "src/components"))) {
+      architectureNotes.push("Reusable UI presentation components live in `src/components/`.");
+    }
+    if (existsSync13(join7(this.cwd, "src/types.ts")) || existsSync13(join7(this.cwd, "src/types"))) {
+      architectureNotes.push("Shared TypeScript data models and interfaces are defined in `src/types`.");
+    }
+    if (existsSync13(join7(this.cwd, ".env.example"))) {
+      architectureNotes.push("Environment configuration template is in `.env.example`.");
+    }
+    if (commands.typecheck || commands.lint || commands.test) {
+      const checks = [];
+      if (commands.typecheck)
+        checks.push(`typecheck (\`${commands.typecheck}\`)`);
+      if (commands.lint)
+        checks.push(`lint (\`${commands.lint}\`)`);
+      if (commands.test)
+        checks.push(`tests (\`${commands.test}\`)`);
+      codeConventions.push(`Run ${checks.join(" and ")} before concluding any major code edits.`);
+    }
+    const instructionFiles = ["AGENTS.md", "CLAUDE.md", ".agents.md", "AGENTS.override.md"];
+    let hasExistingInstructions = false;
+    let existingInstructionFile;
+    for (const f of instructionFiles) {
+      if (existsSync13(join7(this.cwd, f))) {
+        hasExistingInstructions = true;
+        existingInstructionFile = f;
+        break;
+      }
+    }
+    return {
+      projectName,
+      description,
+      languages,
+      packageManager,
+      frameworks,
+      infrastructure,
+      commands,
+      architectureNotes,
+      codeConventions,
+      hasExistingInstructions,
+      existingInstructionFile
+    };
+  }
+  generateAgentsMarkdown(analysis) {
+    const lines = [];
+    lines.push(`# ${analysis.projectName}`);
+    lines.push("");
+    if (analysis.description) {
+      lines.push(`> ${analysis.description}`);
+      lines.push("");
+    }
+    lines.push("## Commands");
+    lines.push("");
+    if (Object.keys(analysis.commands).length > 0) {
+      if (analysis.commands.dev)
+        lines.push(`- **Dev Server**: \`${analysis.commands.dev}\``);
+      if (analysis.commands.build)
+        lines.push(`- **Build**: \`${analysis.commands.build}\``);
+      if (analysis.commands.test)
+        lines.push(`- **Test**: \`${analysis.commands.test}\``);
+      if (analysis.commands.typecheck)
+        lines.push(`- **Typecheck**: \`${analysis.commands.typecheck}\``);
+      if (analysis.commands.lint)
+        lines.push(`- **Lint**: \`${analysis.commands.lint}\``);
+      if (analysis.commands.format)
+        lines.push(`- **Format**: \`${analysis.commands.format}\``);
+      if (analysis.commands.dockerBuild)
+        lines.push(`- **Docker Build**: \`${analysis.commands.dockerBuild}\``);
+    } else {
+      lines.push("- *No standard build/test commands detected.*");
+    }
+    lines.push("");
+    lines.push("## Architecture & Stack");
+    lines.push("");
+    const stackItems = [];
+    if (analysis.languages.length > 0)
+      stackItems.push(analysis.languages.join(", "));
+    if (analysis.frameworks.length > 0)
+      stackItems.push(analysis.frameworks.join(", "));
+    if (analysis.infrastructure.length > 0)
+      stackItems.push(analysis.infrastructure.join(", "));
+    if (stackItems.length > 0) {
+      lines.push(`- **Core Stack**: ${stackItems.join(" \u2022 ")}`);
+    }
+    for (const note of analysis.architectureNotes) {
+      lines.push(`- ${note}`);
+    }
+    lines.push("");
+    lines.push("## Workflow & Code Guidelines");
+    lines.push("");
+    if (analysis.codeConventions.length > 0) {
+      for (const conv of analysis.codeConventions) {
+        lines.push(`- ${conv}`);
+      }
+    }
+    lines.push("- Prefer targeted edits over whole-file rewrites.");
+    lines.push("- When fixing errors, address the root cause rather than suppressing compiler warnings.");
+    lines.push("");
+    return lines.join(`
+`);
+  }
+  extractReadmeMetadata() {
+    const readmeFiles = ["README.md", "readme.md", "README.MD"];
+    for (const file of readmeFiles) {
+      const fullPath = join7(this.cwd, file);
+      if (existsSync13(fullPath)) {
+        try {
+          const content = readFileSync8(fullPath, "utf8");
+          const lines = content.split(`
+`);
+          let title;
+          let description;
+          for (const line of lines) {
+            const trimmed = line.trim();
+            if (!title && trimmed.startsWith("# ")) {
+              title = trimmed.replace(/^#\s+/, "").trim();
+              continue;
+            }
+            if (title && !description && trimmed.length > 0 && !trimmed.startsWith("#") && !trimmed.startsWith("```") && !trimmed.startsWith("[")) {
+              description = trimmed;
+              break;
+            }
+          }
+          return { title, description };
+        } catch {}
+      }
+    }
+    return {};
+  }
+  detectProjectName() {
+    const pkgPath = join7(this.cwd, "package.json");
+    if (existsSync13(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync8(pkgPath, "utf8"));
+        if (pkg.name && pkg.name !== "frontend" && pkg.name !== "backend" && pkg.name !== "app") {
+          return pkg.name.startsWith("@") ? pkg.name.split("/")[1] || pkg.name : pkg.name;
+        }
+      } catch {}
+    }
+    const cargoPath = join7(this.cwd, "Cargo.toml");
+    if (existsSync13(cargoPath)) {
+      try {
+        const match = readFileSync8(cargoPath, "utf8").match(/name\s*=\s*"([^"]+)"/);
+        if (match?.[1])
+          return match[1];
+      } catch {}
+    }
+    const goModPath = join7(this.cwd, "go.mod");
+    if (existsSync13(goModPath)) {
+      try {
+        const match = readFileSync8(goModPath, "utf8").match(/module\s+([^\s]+)/);
+        if (match?.[1])
+          return basename(match[1]);
+      } catch {}
+    }
+    return basename(this.cwd);
+  }
+  detectLanguages() {
+    const langs = new Set;
+    if (existsSync13(join7(this.cwd, "tsconfig.json")) || this.hasFileWithExtension(".ts", ".tsx")) {
+      langs.add("TypeScript");
+    }
+    if (existsSync13(join7(this.cwd, "package.json")) || this.hasFileWithExtension(".js", ".jsx", ".mjs")) {
+      langs.add("JavaScript");
+    }
+    if (existsSync13(join7(this.cwd, "Cargo.toml")) || this.hasFileWithExtension(".rs")) {
+      langs.add("Rust");
+    }
+    if (existsSync13(join7(this.cwd, "go.mod")) || this.hasFileWithExtension(".go")) {
+      langs.add("Go");
+    }
+    if (existsSync13(join7(this.cwd, "pyproject.toml")) || existsSync13(join7(this.cwd, "requirements.txt")) || this.hasFileWithExtension(".py")) {
+      langs.add("Python");
+    }
+    if (existsSync13(join7(this.cwd, "pom.xml")) || existsSync13(join7(this.cwd, "build.gradle")) || this.hasFileWithExtension(".java")) {
+      langs.add("Java");
+    }
+    if (existsSync13(join7(this.cwd, "CMakeLists.txt")) || this.hasFileWithExtension(".cpp", ".c", ".h", ".hpp")) {
+      langs.add("C/C++");
+    }
+    return Array.from(langs);
+  }
+  detectPackageManager() {
+    if (existsSync13(join7(this.cwd, "bun.lockb")) || existsSync13(join7(this.cwd, "bun.lock")))
+      return "bun";
+    if (existsSync13(join7(this.cwd, "pnpm-lock.yaml")))
+      return "pnpm";
+    if (existsSync13(join7(this.cwd, "yarn.lock")))
+      return "yarn";
+    if (existsSync13(join7(this.cwd, "package-lock.json")))
+      return "npm";
+    if (existsSync13(join7(this.cwd, "Cargo.lock")) || existsSync13(join7(this.cwd, "Cargo.toml")))
+      return "cargo";
+    if (existsSync13(join7(this.cwd, "uv.lock")))
+      return "uv";
+    if (existsSync13(join7(this.cwd, "poetry.lock")))
+      return "poetry";
+    if (existsSync13(join7(this.cwd, "go.sum")) || existsSync13(join7(this.cwd, "go.mod")))
+      return "go";
+    if (existsSync13(join7(this.cwd, "package.json")))
+      return "npm";
+    return;
+  }
+  hasFileWithExtension(...exts) {
+    try {
+      const entries = readdirSync6(this.cwd);
+      return entries.some((e) => exts.some((ext) => e.endsWith(ext)));
+    } catch {
+      return false;
+    }
+  }
+}
+
+// src/verification/verifier.ts
+class AutoVerifier {
+  cwd;
+  customCommand;
+  timeoutMs;
+  constructor(options) {
+    this.cwd = options.cwd;
+    this.customCommand = options.customCommand;
+    this.timeoutMs = options.timeoutMs ?? 30000;
+  }
+  resolveVerificationCommand() {
+    if (this.customCommand && this.customCommand.trim()) {
+      return this.customCommand.trim();
+    }
+    try {
+      const analyzer = new ProjectAnalyzer(this.cwd);
+      const analysis = analyzer.analyze();
+      if (analysis.commands.typecheck) {
+        return analysis.commands.typecheck;
+      }
+      if (analysis.commands.lint) {
+        return analysis.commands.lint;
+      }
+      if (analysis.commands.test) {
+        return analysis.commands.test;
+      }
+    } catch {}
+    const pkgPath = join8(this.cwd, "package.json");
+    if (existsSync14(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync9(pkgPath, "utf8"));
+        if (pkg.scripts) {
+          if (pkg.scripts.typecheck)
+            return "npm run typecheck";
+          if (pkg.scripts.check)
+            return "npm run check";
+          if (pkg.scripts.test)
+            return "npm test";
+        }
+      } catch {}
+    }
+    if (existsSync14(join8(this.cwd, "tsconfig.json"))) {
+      return "npx tsc --noEmit";
+    }
+    if (existsSync14(join8(this.cwd, "Cargo.toml"))) {
+      return "cargo check";
+    }
+    if (existsSync14(join8(this.cwd, "go.mod"))) {
+      return "go vet ./...";
+    }
+    if (existsSync14(join8(this.cwd, "pyproject.toml")) || existsSync14(join8(this.cwd, "setup.py"))) {
+      if (existsSync14(join8(this.cwd, "mypy.ini")) || existsSync14(join8(this.cwd, ".mypy.ini"))) {
+        return "mypy .";
+      }
+    }
+    return null;
+  }
+  verify(modifiedFiles = []) {
+    const command = this.resolveVerificationCommand();
+    const startTime = performance.now();
+    if (!command) {
+      return {
+        command: "none",
+        success: true,
+        exitCode: 0,
+        output: "No automated verification command configured or detected for this workspace.",
+        durationMs: 0,
+        reason: "NO_VERIFIER_DETECTED"
+      };
+    }
+    try {
+      const isWindows = process.platform === "win32";
+      const proc = spawnSync(command, {
+        cwd: this.cwd,
+        shell: true,
+        encoding: "utf8",
+        timeout: this.timeoutMs,
+        maxBuffer: 10 * 1024 * 1024,
+        env: {
+          ...process.env,
+          CI: "true",
+          FORCE_COLOR: "0"
+        }
+      });
+      const durationMs = Math.round(performance.now() - startTime);
+      const stdout = proc.stdout ? String(proc.stdout) : "";
+      const stderr = proc.stderr ? String(proc.stderr) : "";
+      let combined = (stdout + `
+` + stderr).trim();
+      if (combined.length > 3000) {
+        const lines = combined.split(`
+`);
+        if (lines.length > 60) {
+          const head = lines.slice(0, 30).join(`
+`);
+          const tail = lines.slice(-25).join(`
+`);
+          combined = `${head}
+
+... [${lines.length - 55} lines truncated for context efficiency] ...
+
+${tail}`;
+        }
+      }
+      const exitCode = proc.status ?? (proc.error ? 1 : 0);
+      const success = exitCode === 0;
+      return {
+        command,
+        success,
+        exitCode,
+        output: combined || (success ? "Verification succeeded cleanly." : "Command failed with empty output."),
+        durationMs
+      };
+    } catch (err) {
+      const durationMs = Math.round(performance.now() - startTime);
+      return {
+        command,
+        success: false,
+        exitCode: 1,
+        output: `Verification execution error: ${err.message || String(err)}`,
+        durationMs
+      };
+    }
+  }
+}
 // src/session/turn.ts
 async function runTurn(session, turnContext, input) {
   const { turnId, signal } = turnContext;
@@ -4319,6 +4905,9 @@ async function runTurn(session, turnContext, input) {
   let accumulatedOutputTokens = 0;
   let accumulatedCachedTokens = 0;
   const clientSession = session.modelClient.newSession();
+  const modifiedFiles = new Set;
+  let selfHealingAttempts = 0;
+  let hasRunVerification = false;
   try {
     while (iteration < turnContext.maxIterations) {
       if (signal.aborted) {
@@ -4453,6 +5042,15 @@ async function runTurn(session, turnContext, input) {
             isError: toolResult.isError,
             createdAt: Date.now()
           };
+          if (!toolResult.isError) {
+            if (toolCall.name === "apply_patch" || toolCall.name === "write_file") {
+              const p = String(toolCall.arguments?.path || "");
+              if (p) {
+                modifiedFiles.add(p);
+                hasRunVerification = false;
+              }
+            }
+          }
           session.addHistoryItem(functionOutputItem);
           session.emitEvent({
             type: "ToolCallFinished",
@@ -4469,6 +5067,70 @@ async function runTurn(session, turnContext, input) {
         }
         continue;
       }
+      if (session.autoVerification && modifiedFiles.size > 0 && !hasRunVerification && iteration < turnContext.maxIterations) {
+        const verifier = new AutoVerifier({
+          cwd,
+          customCommand: session.autoVerificationCommand
+        });
+        const command = verifier.resolveVerificationCommand();
+        if (command) {
+          session.emitEvent({
+            type: "VerificationStarted",
+            turnId,
+            command,
+            modifiedFiles: Array.from(modifiedFiles)
+          });
+          const vResult = verifier.verify(Array.from(modifiedFiles));
+          session.emitEvent({
+            type: "VerificationCompleted",
+            turnId,
+            command: vResult.command,
+            success: vResult.success,
+            output: vResult.output,
+            durationMs: vResult.durationMs
+          });
+          if (!vResult.success) {
+            if (selfHealingAttempts < session.maxSelfHealingAttempts) {
+              selfHealingAttempts++;
+              session.emitEvent({
+                type: "SelfHealingStarted",
+                turnId,
+                attempt: selfHealingAttempts,
+                maxAttempts: session.maxSelfHealingAttempts,
+                command: vResult.command,
+                error: vResult.output
+              });
+              const feedbackMsg = `[Automated Self-Verification Failure]
+Verification command '${vResult.command}' failed with exit code ${vResult.exitCode}.
+
+Error trace / compiler output:
+${vResult.output}
+
+Modified file(s) in this turn: ${Array.from(modifiedFiles).join(", ")}
+
+Self-Healing Directive (Attempt ${selfHealingAttempts} of ${session.maxSelfHealingAttempts}):
+1. Review the error trace above carefully and locate the exact root cause.
+2. Formulate and apply the necessary surgical fix using 'apply_patch' or 'write_file'.
+3. Do NOT conclude the turn or report to the user until this error is resolved and verification passes cleanly.`;
+              session.addHistoryItem({
+                id: `msg_heal_${Date.now()}`,
+                type: "user_message",
+                content: feedbackMsg,
+                createdAt: Date.now()
+              });
+              continue;
+            } else {
+              session.emitEvent({
+                type: "Warning",
+                message: `Auto-verification failed after ${selfHealingAttempts} self-healing attempts for command: ${vResult.command}`
+              });
+              hasRunVerification = true;
+            }
+          } else {
+            hasRunVerification = true;
+          }
+        }
+      }
       if (!currentAgentText.trim() && toolCallRequests.length === 0) {
         if (iteration === 1 && iteration < turnContext.maxIterations) {
           session.addHistoryItem({
@@ -4594,6 +5256,9 @@ class Session {
   mcpManager;
   execPolicy;
   collaborationMode = "default";
+  autoVerification;
+  autoVerificationCommand;
+  maxSelfHealingAttempts;
   get permissionMode() {
     return this.execPolicy.getMode();
   }
@@ -4626,6 +5291,9 @@ class Session {
     this.mcpManager = options.mcpManager;
     this.execPolicy = options.execPolicy || new ExecPolicy;
     this.collaborationMode = options.collaborationMode || "default";
+    this.autoVerification = options.autoVerification ?? (process.env.PIKAA_AUTO_VERIFY !== "0" && process.env.PIKAA_AUTO_VERIFY !== "false");
+    this.autoVerificationCommand = options.autoVerificationCommand;
+    this.maxSelfHealingAttempts = options.maxSelfHealingAttempts ?? 3;
     this.history = options.initialHistory ? [...options.initialHistory] : [];
     if (options.onEvent) {
       this.eventListeners.push(options.onEvent);
@@ -4873,7 +5541,7 @@ class ThreadManager {
   }
 }
 // src/mcp/process-killer.ts
-import { spawnSync } from "child_process";
+import { spawnSync as spawnSync2 } from "child_process";
 
 class GlobalProcessRegistry {
   static trackedProcesses = new Map;
@@ -4883,7 +5551,7 @@ class GlobalProcessRegistry {
       return;
     if (process.platform === "win32") {
       try {
-        spawnSync("taskkill", ["/pid", String(pid), "/T", "/F"], {
+        spawnSync2("taskkill", ["/pid", String(pid), "/T", "/F"], {
           stdio: "ignore",
           windowsHide: true
         });
@@ -5450,8 +6118,8 @@ class McpClient {
   }
 }
 // src/mcp/manager.ts
-import { existsSync as existsSync13, readFileSync as readFileSync8, writeFileSync as writeFileSync4, mkdirSync as mkdirSync7 } from "fs";
-import { resolve as resolve12, dirname as dirname6, join as join7 } from "path";
+import { existsSync as existsSync15, readFileSync as readFileSync10, writeFileSync as writeFileSync4, mkdirSync as mkdirSync7 } from "fs";
+import { resolve as resolve12, dirname as dirname6, join as join9 } from "path";
 class McpManager {
   clients = new Map;
   serverConfigs = new Map;
@@ -5486,11 +6154,11 @@ class McpManager {
   }
   async loadConfigFile(filePath) {
     const fullPath = resolve12(filePath);
-    if (!existsSync13(fullPath))
+    if (!existsSync15(fullPath))
       return;
     this.loadedConfigFiles.add(fullPath);
     try {
-      const content = readFileSync8(fullPath, "utf8");
+      const content = readFileSync10(fullPath, "utf8");
       const parsed = JSON.parse(content);
       if (parsed.mcpServers) {
         await this.loadConfig(parsed);
@@ -5741,13 +6409,13 @@ class McpManager {
   saveServerToConfigFile(filePath, name, config) {
     const fullPath = resolve12(filePath);
     const dir = dirname6(fullPath);
-    if (!existsSync13(dir)) {
+    if (!existsSync15(dir)) {
       mkdirSync7(dir, { recursive: true });
     }
     let existing = { mcpServers: {} };
-    if (existsSync13(fullPath)) {
+    if (existsSync15(fullPath)) {
       try {
-        const content = readFileSync8(fullPath, "utf8");
+        const content = readFileSync10(fullPath, "utf8");
         existing = JSON.parse(content);
         if (!existing.mcpServers)
           existing.mcpServers = {};
@@ -5760,10 +6428,10 @@ class McpManager {
   }
   removeServerFromConfigFile(filePath, name) {
     const fullPath = resolve12(filePath);
-    if (!existsSync13(fullPath))
+    if (!existsSync15(fullPath))
       return false;
     try {
-      const content = readFileSync8(fullPath, "utf8");
+      const content = readFileSync10(fullPath, "utf8");
       const existing = JSON.parse(content);
       if (existing.mcpServers && existing.mcpServers[name]) {
         delete existing.mcpServers[name];
@@ -5790,11 +6458,11 @@ class McpManager {
     }
   }
   getDefaultConfigFile(cwd = process.cwd()) {
-    const workspaceConfig = join7(cwd, ".mcp.json");
-    if (existsSync13(workspaceConfig))
+    const workspaceConfig = join9(cwd, ".mcp.json");
+    if (existsSync15(workspaceConfig))
       return workspaceConfig;
-    const altConfig = join7(cwd, "mcp_config.json");
-    if (existsSync13(altConfig))
+    const altConfig = join9(cwd, "mcp_config.json");
+    if (existsSync15(altConfig))
       return altConfig;
     return workspaceConfig;
   }
@@ -5816,8 +6484,8 @@ class McpManager {
 import { resolve as resolve14 } from "path";
 
 // src/mcp/servers/chrome-devtools/launcher.ts
-import { existsSync as existsSync14, mkdirSync as mkdirSync8, rmSync as rmSync2 } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync16, mkdirSync as mkdirSync8, rmSync as rmSync2 } from "fs";
+import { join as join10 } from "path";
 import { tmpdir as tmpdir2 } from "os";
 class BrowserLauncher {
   proc = null;
@@ -5825,21 +6493,21 @@ class BrowserLauncher {
   wsDebuggerUrl = null;
   port = 0;
   static findBrowserExecutable() {
-    if (process.env.CHROME_PATH && existsSync14(process.env.CHROME_PATH)) {
+    if (process.env.CHROME_PATH && existsSync16(process.env.CHROME_PATH)) {
       return process.env.CHROME_PATH;
     }
     if (process.platform === "win32") {
       const candidates = [
         "C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe",
         "C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe",
-        join8(process.env.LOCALAPPDATA || "", "Google\\Chrome\\Application\\chrome.exe"),
+        join10(process.env.LOCALAPPDATA || "", "Google\\Chrome\\Application\\chrome.exe"),
         "C:\\Program Files (x86)\\Microsoft\\Edge\\Application\\msedge.exe",
         "C:\\Program Files\\Microsoft\\Edge\\Application\\msedge.exe",
         "C:\\Program Files\\BraveSoftware\\Brave-Browser\\Application\\brave.exe",
-        join8(process.env.LOCALAPPDATA || "", "BraveSoftware\\Brave-Browser\\Application\\brave.exe")
+        join10(process.env.LOCALAPPDATA || "", "BraveSoftware\\Brave-Browser\\Application\\brave.exe")
       ];
       for (const path of candidates) {
-        if (path && existsSync14(path))
+        if (path && existsSync16(path))
           return path;
       }
     } else if (process.platform === "darwin") {
@@ -5850,7 +6518,7 @@ class BrowserLauncher {
         "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser"
       ];
       for (const path of candidates) {
-        if (existsSync14(path))
+        if (existsSync16(path))
           return path;
       }
     } else {
@@ -5863,7 +6531,7 @@ class BrowserLauncher {
         "/usr/bin/microsoft-edge"
       ];
       for (const path of candidates) {
-        if (existsSync14(path))
+        if (existsSync16(path))
           return path;
       }
     }
@@ -5875,7 +6543,7 @@ class BrowserLauncher {
       throw new Error("No supported browser (Google Chrome, Chromium, MS Edge, Brave) found on this machine. Please install Chrome or specify CHROME_PATH.");
     }
     this.port = options.port || 9200 + Math.floor(Math.random() * 500);
-    this.tempUserDataDir = options.userDataDir || join8(tmpdir2(), `groupy_chrome_${Date.now()}_${Math.random().toString(36).slice(2)}`);
+    this.tempUserDataDir = options.userDataDir || join10(tmpdir2(), `groupy_chrome_${Date.now()}_${Math.random().toString(36).slice(2)}`);
     mkdirSync8(this.tempUserDataDir, { recursive: true });
     const isHeadless = options.headless ?? true;
     const launchArgs = [
@@ -5953,7 +6621,7 @@ class BrowserLauncher {
       }
       this.proc = null;
     }
-    if (this.tempUserDataDir && existsSync14(this.tempUserDataDir)) {
+    if (this.tempUserDataDir && existsSync16(this.tempUserDataDir)) {
       try {
         rmSync2(this.tempUserDataDir, { recursive: true, force: true });
       } catch {}
@@ -7793,7 +8461,7 @@ import { resolve as resolve17 } from "path";
 // src/mcp/servers/sqlite/db-engine.ts
 import { Database as Database2 } from "bun:sqlite";
 import { resolve as resolve16, isAbsolute } from "path";
-import { readdirSync as readdirSync6 } from "fs";
+import { readdirSync as readdirSync7 } from "fs";
 
 class SqliteEngine {
   connections = new Map;
@@ -7823,7 +8491,7 @@ class SqliteEngine {
   }
   autoDiscoverDatabase() {
     try {
-      const files = readdirSync6(process.cwd());
+      const files = readdirSync7(process.cwd());
       const dbFile = files.find((f) => f.endsWith(".sqlite") || f.endsWith(".sqlite3") || f.endsWith(".db"));
       return dbFile ? resolve16(process.cwd(), dbFile) : null;
     } catch {
@@ -8327,8 +8995,8 @@ function verifyTaskAction(assertion, payload) {
   }
 }
 // src/agents/roles.ts
-import { existsSync as existsSync16, readdirSync as readdirSync7, readFileSync as readFileSync9 } from "fs";
-import { resolve as resolve18, join as join9 } from "path";
+import { existsSync as existsSync18, readdirSync as readdirSync8, readFileSync as readFileSync11 } from "fs";
+import { resolve as resolve18, join as join11 } from "path";
 
 class AgentRoleRegistry {
   roles = new Map;
@@ -8413,13 +9081,13 @@ class AgentRoleRegistry {
   }
   loadRolesFromDir(dirPath) {
     const fullPath = resolve18(dirPath);
-    if (!existsSync16(fullPath))
+    if (!existsSync18(fullPath))
       return;
-    const entries = readdirSync7(fullPath);
+    const entries = readdirSync8(fullPath);
     for (const entry of entries) {
       if (entry.endsWith(".json")) {
         try {
-          const content = readFileSync9(join9(fullPath, entry), "utf8");
+          const content = readFileSync11(join11(fullPath, entry), "utf8");
           const parsed = JSON.parse(content);
           if (parsed.name && parsed.systemPrompt) {
             this.registerRole(parsed);
@@ -8449,7 +9117,7 @@ class AgentRoleRegistry {
 // src/agents/graph-store.ts
 import { Database as Database3 } from "bun:sqlite";
 import { resolve as resolve19 } from "path";
-import { existsSync as existsSync17, mkdirSync as mkdirSync10 } from "fs";
+import { existsSync as existsSync19, mkdirSync as mkdirSync10 } from "fs";
 class AgentGraphStore {
   db;
   constructor(dbPathOrDb) {
@@ -8459,7 +9127,7 @@ class AgentGraphStore {
       const dbPath = dbPathOrDb || getAgentGraphDbPath();
       if (dbPath !== ":memory:") {
         const dir = resolve19(dbPath, "..");
-        if (!existsSync17(dir)) {
+        if (!existsSync19(dir)) {
           mkdirSync10(dir, { recursive: true });
         }
       }
@@ -8882,7 +9550,7 @@ function registerMultiAgentTools(router, spawner) {
 }
 // src/storage/sqlite-store.ts
 import { Database as Database4 } from "bun:sqlite";
-import { existsSync as existsSync18, mkdirSync as mkdirSync11 } from "fs";
+import { existsSync as existsSync20, mkdirSync as mkdirSync11 } from "fs";
 import { dirname as dirname8 } from "path";
 class SqliteThreadStore {
   db;
@@ -8890,7 +9558,7 @@ class SqliteThreadStore {
     const effectivePath = dbPath || this.getDefaultDbPath();
     if (effectivePath !== ":memory:") {
       const dir = dirname8(effectivePath);
-      if (!existsSync18(dir)) {
+      if (!existsSync20(dir)) {
         mkdirSync11(dir, { recursive: true });
       }
     }
@@ -9144,8 +9812,8 @@ class SessionPersistenceManager {
   }
 }
 // src/skills/loader.ts
-import { existsSync as existsSync19, readdirSync as readdirSync8, readFileSync as readFileSync10 } from "fs";
-import { resolve as resolve20, join as join10 } from "path";
+import { existsSync as existsSync21, readdirSync as readdirSync9, readFileSync as readFileSync12 } from "fs";
+import { resolve as resolve20, join as join12 } from "path";
 var __dirname = "/home/runner/work/agent-cli/agent-cli/src/skills";
 
 class SkillsLoader {
@@ -9215,7 +9883,7 @@ class SkillsLoader {
         resolve20(cwd, "skills")
       ];
       for (const cand of candidates) {
-        if (existsSync19(cand) && !roots.includes(cand)) {
+        if (existsSync21(cand) && !roots.includes(cand)) {
           roots.push(cand);
         }
       }
@@ -9224,7 +9892,7 @@ class SkillsLoader {
       roots.push(getGlobalSkillsDir());
     }
     roots.push(...this.customRoots.map((r) => resolve20(r)));
-    return roots.filter((r) => existsSync19(r));
+    return roots.filter((r) => existsSync21(r));
   }
   discoverSkills(cwd, options) {
     return this.listSkills(cwd, options);
@@ -9240,12 +9908,12 @@ class SkillsLoader {
     const discovered = new Map;
     for (const root of roots) {
       try {
-        const entries = readdirSync8(root, { withFileTypes: true });
+        const entries = readdirSync9(root, { withFileTypes: true });
         for (const entry of entries) {
           if (entry.isDirectory()) {
-            const skillDir = join10(root, entry.name);
-            const skillFilePath = join10(skillDir, "SKILL.md");
-            if (existsSync19(skillFilePath)) {
+            const skillDir = join12(root, entry.name);
+            const skillFilePath = join12(skillDir, "SKILL.md");
+            if (existsSync21(skillFilePath)) {
               const meta = this.parseSkillFrontmatter(skillFilePath, entry.name, root, cwd);
               if (meta && !discovered.has(meta.name)) {
                 meta.enabled = !this.isSkillDisabled(meta.name);
@@ -9274,7 +9942,7 @@ class SkillsLoader {
     if (!meta)
       return null;
     try {
-      const raw = readFileSync10(meta.path, "utf8");
+      const raw = readFileSync12(meta.path, "utf8");
       const { body } = this.extractFrontmatterAndBody(raw);
       return {
         ...meta,
@@ -9286,7 +9954,7 @@ class SkillsLoader {
   }
   parseSkillFrontmatter(filePath, dirName, root, cwd) {
     try {
-      const raw = readFileSync10(filePath, "utf8");
+      const raw = readFileSync12(filePath, "utf8");
       const { attributes } = this.extractFrontmatterAndBody(raw);
       let scope = "global";
       const normPath = filePath.toLowerCase().replace(/\\/g, "/");
@@ -9367,8 +10035,8 @@ When tackling complex specialized tasks that match any of these skills, autonomo
   }
 }
 // src/memories/store.ts
-import { existsSync as existsSync20, readFileSync as readFileSync11, writeFileSync as writeFileSync6, mkdirSync as mkdirSync12, readdirSync as readdirSync9 } from "fs";
-import { resolve as resolve21, join as join11, basename, dirname as dirname9 } from "path";
+import { existsSync as existsSync22, readFileSync as readFileSync13, writeFileSync as writeFileSync6, mkdirSync as mkdirSync12, readdirSync as readdirSync10 } from "fs";
+import { resolve as resolve21, join as join13, basename as basename2, dirname as dirname9 } from "path";
 import { createHash } from "crypto";
 class MemoryStore {
   globalPath;
@@ -9380,7 +10048,7 @@ class MemoryStore {
   findProjectRoot(cwd) {
     let current = resolve21(cwd);
     while (true) {
-      if (existsSync20(join11(current, ".git"))) {
+      if (existsSync22(join13(current, ".git"))) {
         return current;
       }
       const parent = dirname9(current);
@@ -9392,14 +10060,14 @@ class MemoryStore {
   }
   getProjectSlug(cwd) {
     const root = this.findProjectRoot(cwd);
-    const folderName = basename(root).toLowerCase().replace(/[^a-z0-9_-]/g, "-") || "project";
+    const folderName = basename2(root).toLowerCase().replace(/[^a-z0-9_-]/g, "-") || "project";
     const hash = createHash("sha256").update(resolve21(root)).digest("hex").slice(0, 6);
     return `${folderName}-${hash}`;
   }
   getProjectMemoryDir(cwd) {
     if (this.customWorkspacePath) {
       const dir = resolve21(this.customWorkspacePath);
-      if (!existsSync20(dir)) {
+      if (!existsSync22(dir)) {
         try {
           mkdirSync12(dir, { recursive: true });
         } catch {}
@@ -9407,8 +10075,8 @@ class MemoryStore {
       return dir;
     }
     const slug = this.getProjectSlug(cwd);
-    const dir = join11(getProjectsDir(), slug, "memory");
-    if (!existsSync20(dir)) {
+    const dir = join13(getProjectsDir(), slug, "memory");
+    if (!existsSync22(dir)) {
       try {
         mkdirSync12(dir, { recursive: true });
       } catch {}
@@ -9416,7 +10084,7 @@ class MemoryStore {
     return dir;
   }
   getMemoryIndexPath(cwd) {
-    return join11(this.getProjectMemoryDir(cwd), "MEMORY.md");
+    return join13(this.getProjectMemoryDir(cwd), "MEMORY.md");
   }
   normalizeCategory(raw) {
     const cat = raw.toLowerCase().trim();
@@ -9435,7 +10103,7 @@ class MemoryStore {
     const sanitizedName = params.name.toLowerCase().trim().replace(/[^a-z0-9_-]/g, "_").replace(/^_+|_+$/g, "") || `note_${Date.now()}`;
     const memoryDir = this.getProjectMemoryDir(params.cwd);
     const fileName = `${type}_${sanitizedName}.md`;
-    const filePath = join11(memoryDir, fileName);
+    const filePath = join13(memoryDir, fileName);
     const nowIso = new Date().toISOString();
     const cleanContent = params.content.trim();
     const desc = (params.description || cleanContent.split(`
@@ -9470,23 +10138,23 @@ class MemoryStore {
   }
   readTopicMemory(topicNameOrFile, cwd) {
     const memoryDir = this.getProjectMemoryDir(cwd);
-    let targetPath = join11(memoryDir, topicNameOrFile);
-    if (!existsSync20(targetPath)) {
+    let targetPath = join13(memoryDir, topicNameOrFile);
+    if (!existsSync22(targetPath)) {
       if (!topicNameOrFile.endsWith(".md")) {
-        targetPath = join11(memoryDir, `${topicNameOrFile}.md`);
+        targetPath = join13(memoryDir, `${topicNameOrFile}.md`);
       }
     }
-    if (!existsSync20(targetPath)) {
-      const files = readdirSync9(memoryDir);
+    if (!existsSync22(targetPath)) {
+      const files = readdirSync10(memoryDir);
       const match = files.find((f) => f.includes(topicNameOrFile));
       if (match) {
-        targetPath = join11(memoryDir, match);
+        targetPath = join13(memoryDir, match);
       } else {
         return null;
       }
     }
     try {
-      const raw = readFileSync11(targetPath, "utf8");
+      const raw = readFileSync13(targetPath, "utf8");
       return this.parseTopicFile(raw, targetPath);
     } catch {
       return null;
@@ -9497,7 +10165,7 @@ class MemoryStore {
 `);
     let inFm = false;
     let type = "project";
-    let name = basename(filePath, ".md");
+    let name = basename2(filePath, ".md");
     let description;
     let modified = new Date().toISOString();
     const bodyLines = [];
@@ -9541,13 +10209,13 @@ class MemoryStore {
   }
   syncMemoryIndex(cwd) {
     const memoryDir = this.getProjectMemoryDir(cwd);
-    const indexPath = join11(memoryDir, "MEMORY.md");
-    const files = existsSync20(memoryDir) ? readdirSync9(memoryDir).filter((f) => f.endsWith(".md") && f !== "MEMORY.md") : [];
+    const indexPath = join13(memoryDir, "MEMORY.md");
+    const files = existsSync22(memoryDir) ? readdirSync10(memoryDir).filter((f) => f.endsWith(".md") && f !== "MEMORY.md") : [];
     const items = [];
     for (const f of files) {
       try {
-        const full = join11(memoryDir, f);
-        const parsed = this.parseTopicFile(readFileSync11(full, "utf8"), full);
+        const full = join13(memoryDir, f);
+        const parsed = this.parseTopicFile(readFileSync13(full, "utf8"), full);
         items.push({
           type: parsed.type,
           name: parsed.name,
@@ -9573,10 +10241,10 @@ class MemoryStore {
   }
   loadMemoryIndex(cwd) {
     const indexPath = this.getMemoryIndexPath(cwd);
-    if (!existsSync20(indexPath))
+    if (!existsSync22(indexPath))
       return "";
     try {
-      const raw = readFileSync11(indexPath, "utf8");
+      const raw = readFileSync13(indexPath, "utf8");
       const byteLimit = 25 * 1024;
       const sliced = raw.length > byteLimit ? raw.slice(0, byteLimit) : raw;
       const lines = sliced.split(`
@@ -9589,14 +10257,14 @@ class MemoryStore {
   }
   listProjectMemories(cwd) {
     const memoryDir = this.getProjectMemoryDir(cwd);
-    if (!existsSync20(memoryDir))
+    if (!existsSync22(memoryDir))
       return [];
-    const files = readdirSync9(memoryDir).filter((f) => f.endsWith(".md") && f !== "MEMORY.md");
+    const files = readdirSync10(memoryDir).filter((f) => f.endsWith(".md") && f !== "MEMORY.md");
     const list = [];
     for (const f of files) {
       try {
-        const full = join11(memoryDir, f);
-        list.push(this.parseTopicFile(readFileSync11(full, "utf8"), full));
+        const full = join13(memoryDir, f);
+        list.push(this.parseTopicFile(readFileSync13(full, "utf8"), full));
       } catch {}
     }
     return list;
@@ -9773,8 +10441,8 @@ async function removeWorktreeGit(repoRoot, worktreePath, deleteBranch = false) {
   return { success: true };
 }
 // src/worktree/manager.ts
-import { resolve as resolve23, join as join12 } from "path";
-import { existsSync as existsSync21, mkdirSync as mkdirSync13, writeFileSync as writeFileSync7, readFileSync as readFileSync12 } from "fs";
+import { resolve as resolve23, join as join14 } from "path";
+import { existsSync as existsSync23, mkdirSync as mkdirSync13, writeFileSync as writeFileSync7, readFileSync as readFileSync14 } from "fs";
 var DEFAULT_WORKTREE_KEEP_COUNT = 15;
 
 class WorktreeManager {
@@ -9798,7 +10466,7 @@ class WorktreeManager {
     const branchName = options.branch || `groupy/${taskId}`;
     const targetDir = options.worktreePath || (this.baseStorageDir ? resolve23(this.baseStorageDir, branchName.replace(/\//g, "_")) : resolve23(repoRoot, ".groupy", "worktrees", branchName.replace(/\//g, "_")));
     const worktreeParent = resolve23(targetDir, "..");
-    if (!existsSync21(worktreeParent)) {
+    if (!existsSync23(worktreeParent)) {
       mkdirSync13(worktreeParent, { recursive: true });
     }
     const baseBranch = options.baseBranch || await getCurrentBranch(repoRoot);
@@ -9806,7 +10474,7 @@ class WorktreeManager {
     if (!result.success) {
       throw new Error(`Failed to create git worktree: ${result.error}`);
     }
-    const metaPath = join12(targetDir, "groupy-thread.json");
+    const metaPath = join14(targetDir, "groupy-thread.json");
     try {
       writeFileSync7(metaPath, JSON.stringify({
         version: 1,
@@ -9832,10 +10500,10 @@ class WorktreeManager {
       return [];
     const worktrees = await listWorktreesGit(repoRoot);
     return worktrees.map((wt) => {
-      const metaPath = join12(wt.path, "groupy-thread.json");
-      if (existsSync21(metaPath)) {
+      const metaPath = join14(wt.path, "groupy-thread.json");
+      if (existsSync23(metaPath)) {
         try {
-          const raw = JSON.parse(readFileSync12(metaPath, "utf8"));
+          const raw = JSON.parse(readFileSync14(metaPath, "utf8"));
           return { ...wt, threadId: raw.ownerThreadId || raw.threadId };
         } catch {}
       }
@@ -11544,6 +12212,7 @@ export {
   AgentRoleRegistry,
   AgentSpawner,
   AuthClient,
+  AutoVerifier,
   BrowserLauncher,
   CHROME_DEVTOOLS_MCP_SERVER_PATH,
   CLAUDE_GLYPHS,
@@ -11565,6 +12234,7 @@ export {
   CredentialsStore,
   DEFAULT_AUTO_COMPACT_THRESHOLD_TOKENS,
   DEFAULT_MAX_CONTEXT_TOKENS,
+  DEFAULT_MAX_UNPAGINATED_LINES,
   DEFAULT_WORKTREE_KEEP_COUNT,
   DefaultModelClientSession,
   DomSnapshotEngine,
@@ -11660,5 +12330,6 @@ export {
   submissionLoop,
   updatePlanTool,
   verifyTaskAction,
+  viewFileTool,
   writeFileTool
 };