@harness-engineering/cli 1.6.1 → 1.7.0

package/dist/{chunk-O6NEKDYP.js → chunk-FFIX3QVG.js}

@@ -1,3 +1,38 @@
+import {
+  BaselineManager,
+  CriticalPathResolver,
+  EntropyAnalyzer,
+  Err,
+  Ok,
+  SecurityScanner,
+  TypeScriptParser,
+  VERSION,
+  appendLearning,
+  applyFixes,
+  archiveStream,
+  buildSnapshot,
+  checkDocCoverage,
+  createFixes,
+  createSelfReview,
+  createStream,
+  defineLayer,
+  detectCircularDepsInFiles,
+  detectDeadCode,
+  detectDocDrift,
+  generateSuggestions,
+  listStreams,
+  loadState,
+  loadStreamIndex,
+  parseDiff,
+  parseSecurityConfig,
+  requestPeerReview,
+  resolveStreamPath,
+  runCIChecks,
+  setActiveStream,
+  validateAgentsMap,
+  validateDependencies,
+  validateKnowledgeMap
+} from "./chunk-GA6GN5J2.js";
 import {
   CLIError,
   ExitCode,
@@ -9,18 +44,14 @@ import {
 
 // src/index.ts
 import { Command as Command43 } from "commander";
-import { VERSION } from "@harness-engineering/core";
 
 // src/commands/validate.ts
 import { Command } from "commander";
 import * as path2 from "path";
-import { Ok as Ok2 } from "@harness-engineering/core";
-import { validateAgentsMap, validateKnowledgeMap } from "@harness-engineering/core";
 
 // src/config/loader.ts
 import * as fs from "fs";
 import * as path from "path";
-import { Ok, Err } from "@harness-engineering/core";
 
 // src/config/schema.ts
 import { z } from "zod";
@@ -55,6 +86,23 @@ var PhaseGatesConfigSchema = z.object({
   severity: z.enum(["error", "warning"]).default("error"),
   mappings: z.array(PhaseGateMappingSchema).default([{ implPattern: "src/**/*.ts", specPattern: "docs/specs/{feature}.md" }])
 });
+var SecurityConfigSchema = z.object({
+  enabled: z.boolean().default(true),
+  strict: z.boolean().default(false),
+  rules: z.record(z.string(), z.enum(["off", "error", "warning", "info"])).optional(),
+  exclude: z.array(z.string()).optional()
+}).passthrough();
+var PerformanceConfigSchema = z.object({
+  complexity: z.record(z.unknown()).optional(),
+  coupling: z.record(z.unknown()).optional(),
+  sizeBudget: z.record(z.unknown()).optional()
+}).passthrough();
+var DesignConfigSchema = z.object({
+  strictness: z.enum(["strict", "standard", "permissive"]).default("standard"),
+  platforms: z.array(z.enum(["web", "mobile"])).default([]),
+  tokenPath: z.string().optional(),
+  aestheticIntent: z.string().optional()
+});
 var HarnessConfigSchema = z.object({
   version: z.literal(1),
   name: z.string().optional(),
@@ -66,12 +114,15 @@ var HarnessConfigSchema = z.object({
   docsDir: z.string().default("./docs"),
   agent: AgentConfigSchema.optional(),
   entropy: EntropyConfigSchema.optional(),
+  security: SecurityConfigSchema.optional(),
+  performance: PerformanceConfigSchema.optional(),
   template: z.object({
     level: z.enum(["basic", "intermediate", "advanced"]),
     framework: z.string().optional(),
     version: z.number()
   }).optional(),
-  phaseGates: PhaseGatesConfigSchema.optional()
+  phaseGates: PhaseGatesConfigSchema.optional(),
+  design: DesignConfigSchema.optional()
 });
 
 // src/config/loader.ts
@@ -241,7 +292,7 @@ async function runValidate(options) {
     });
   }
   result.checks.fileStructure = true;
-  return Ok2(result);
+  return Ok(result);
 }
 function createValidateCommand() {
   const command = new Command("validate").description("Run all validation checks").option("--cross-check", "Run cross-artifact consistency validation").action(async (opts, cmd) => {
@@ -263,7 +314,7 @@ function createValidateCommand() {
       process.exit(result.error.exitCode);
     }
     if (opts.crossCheck) {
-      const { runCrossCheck: runCrossCheck2 } = await import("./validate-cross-check-LNIZ7KGZ.js");
+      const { runCrossCheck: runCrossCheck2 } = await import("./validate-cross-check-WGXQ7K62.js");
       const cwd = process.cwd();
       const specsDir = path2.join(cwd, "docs", "specs");
       const plansDir = path2.join(cwd, "docs", "plans");
@@ -291,13 +342,6 @@ function createValidateCommand() {
 // src/commands/check-deps.ts
 import { Command as Command2 } from "commander";
 import * as path3 from "path";
-import { Ok as Ok3 } from "@harness-engineering/core";
-import {
-  validateDependencies,
-  detectCircularDepsInFiles,
-  defineLayer,
-  TypeScriptParser
-} from "@harness-engineering/core";
 
 // src/utils/files.ts
 import { glob } from "glob";
@@ -319,7 +363,7 @@ async function runCheckDeps(options) {
     circularDeps: []
   };
   if (!config.layers || config.layers.length === 0) {
-    return Ok3(result);
+    return Ok(result);
   }
   const rootDir = path3.resolve(cwd, config.rootDir);
   const parser = new TypeScriptParser();
@@ -358,7 +402,7 @@ async function runCheckDeps(options) {
       }
     }
   }
-  return Ok3(result);
+  return Ok(result);
 }
 function createCheckDepsCommand() {
   const command = new Command2("check-deps").description("Validate dependency layers and detect circular dependencies").action(async (_opts, cmd) => {
@@ -403,7 +447,6 @@ function createCheckDepsCommand() {
 // src/commands/check-perf.ts
 import { Command as Command3 } from "commander";
 import * as path4 from "path";
-import { Ok as Ok4, EntropyAnalyzer } from "@harness-engineering/core";
 async function runCheckPerf(cwd, options) {
   const runAll = !options.structural && !options.size && !options.coupling;
   const analyzer = new EntropyAnalyzer({
@@ -416,7 +459,7 @@ async function runCheckPerf(cwd, options) {
   });
   const analysisResult = await analyzer.analyze();
   if (!analysisResult.ok) {
-    return Ok4({
+    return Ok({
       valid: false,
       violations: [
         {
@@ -477,7 +520,7 @@ async function runCheckPerf(cwd, options) {
   const errorCount = violations.filter((v) => v.severity === "error").length;
   const warningCount = violations.filter((v) => v.severity === "warning").length;
   const infoCount = violations.filter((v) => v.severity === "info").length;
-  return Ok4({
+  return Ok({
     valid: !hasErrors,
     violations,
     stats: {
@@ -527,7 +570,6 @@ function createCheckPerfCommand() {
 import { Command as Command4 } from "commander";
 import * as path5 from "path";
 import { execSync } from "child_process";
-import { Ok as Ok5, SecurityScanner, parseSecurityConfig } from "@harness-engineering/core";
 var SEVERITY_RANK = {
   error: 3,
   warning: 2,
@@ -548,10 +590,10 @@ async function runCheckSecurity(cwd, options) {
   const projectRoot = path5.resolve(cwd);
   let configData = {};
   try {
-    const fs22 = await import("fs");
+    const fs25 = await import("fs");
     const configPath = path5.join(projectRoot, "harness.config.json");
-    if (fs22.existsSync(configPath)) {
-      const raw = fs22.readFileSync(configPath, "utf-8");
+    if (fs25.existsSync(configPath)) {
+      const raw = fs25.readFileSync(configPath, "utf-8");
       const parsed = JSON.parse(raw);
       configData = parsed.security ?? {};
     }
@@ -579,7 +621,7 @@ async function runCheckSecurity(cwd, options) {
   const thresholdRank = SEVERITY_RANK[threshold];
   const filtered = result.findings.filter((f) => SEVERITY_RANK[f.severity] >= thresholdRank);
   const hasErrors = filtered.some((f) => f.severity === "error");
-  return Ok5({
+  return Ok({
     valid: !hasErrors,
     findings: filtered,
     stats: {
@@ -633,13 +675,12 @@ function createCheckSecurityCommand() {
 // src/commands/perf.ts
 import { Command as Command5 } from "commander";
 import * as path6 from "path";
-import { BaselineManager, CriticalPathResolver } from "@harness-engineering/core";
 function createPerfCommand() {
   const perf = new Command5("perf").description("Performance benchmark and baseline management");
   perf.command("bench [glob]").description("Run benchmarks via vitest bench").action(async (glob2, _opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const cwd = process.cwd();
-    const { BenchmarkRunner } = await import("@harness-engineering/core");
+    const { BenchmarkRunner } = await import("./dist-C4J67MPP.js");
     const runner = new BenchmarkRunner();
     const benchFiles = runner.discover(cwd, glob2);
     if (benchFiles.length === 0) {
@@ -708,7 +749,7 @@ Results (${result.results.length} benchmarks):`);
   baselines.command("update").description("Update baselines from latest benchmark run").action(async (_opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const cwd = process.cwd();
-    const { BenchmarkRunner } = await import("@harness-engineering/core");
+    const { BenchmarkRunner } = await import("./dist-C4J67MPP.js");
     const runner = new BenchmarkRunner();
     const manager = new BaselineManager(cwd);
     logger.info("Running benchmarks to update baselines...");
@@ -721,8 +762,8 @@ Results (${result.results.length} benchmarks):`);
     }
     let commitHash = "unknown";
     try {
-      const { execSync: execSync5 } = await import("child_process");
-      commitHash = execSync5("git rev-parse --short HEAD", { cwd, encoding: "utf-8" }).trim();
+      const { execSync: execSync3 } = await import("child_process");
+      commitHash = execSync3("git rev-parse --short HEAD", { cwd, encoding: "utf-8" }).trim();
     } catch {
     }
     manager.save(benchResult.results, commitHash);
@@ -736,8 +777,8 @@ Results (${result.results.length} benchmarks):`);
   perf.command("report").description("Full performance report with metrics, trends, and hotspots").action(async (_opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const cwd = process.cwd();
-    const { EntropyAnalyzer: EntropyAnalyzer3 } = await import("@harness-engineering/core");
-    const analyzer = new EntropyAnalyzer3({
+    const { EntropyAnalyzer: EntropyAnalyzer2 } = await import("./dist-C4J67MPP.js");
+    const analyzer = new EntropyAnalyzer2({
       rootDir: path6.resolve(cwd),
       analyze: { complexity: true, coupling: true }
     });
@@ -797,8 +838,6 @@ Results (${result.results.length} benchmarks):`);
 // src/commands/check-docs.ts
 import { Command as Command6 } from "commander";
 import * as path7 from "path";
-import { Ok as Ok6, Err as Err2 } from "@harness-engineering/core";
-import { checkDocCoverage, validateKnowledgeMap as validateKnowledgeMap2 } from "@harness-engineering/core";
 async function runCheckDocs(options) {
   const cwd = options.cwd ?? process.cwd();
   const minCoverage = options.minCoverage ?? 80;
@@ -815,14 +854,14 @@ async function runCheckDocs(options) {
     excludePatterns: ["**/*.test.ts", "**/*.spec.ts", "**/node_modules/**"]
   });
   if (!coverageResult.ok) {
-    return Err2(
+    return Err(
       new CLIError(
         `Documentation coverage check failed: ${coverageResult.error.message}`,
         ExitCode.ERROR
       )
     );
   }
-  const knowledgeResult = await validateKnowledgeMap2(cwd);
+  const knowledgeResult = await validateKnowledgeMap(cwd);
   let brokenLinks = [];
   if (knowledgeResult.ok) {
     brokenLinks = knowledgeResult.value.brokenLinks.map((b) => b.path);
@@ -837,7 +876,7 @@ async function runCheckDocs(options) {
     undocumented: coverageResult.value.undocumented,
     brokenLinks
   };
-  return Ok6(result);
+  return Ok(result);
 }
 function createCheckDocsCommand() {
   const command = new Command6("check-docs").description("Check documentation coverage").option("--min-coverage <percent>", "Minimum coverage percentage", "80").action(async (opts, cmd) => {
@@ -896,13 +935,11 @@ import { Command as Command8 } from "commander";
 import chalk3 from "chalk";
 import * as fs5 from "fs";
 import * as path11 from "path";
-import { Ok as Ok8, Err as Err4 } from "@harness-engineering/core";
 
 // src/templates/engine.ts
 import * as fs2 from "fs";
 import * as path8 from "path";
 import Handlebars from "handlebars";
-import { Ok as Ok7, Err as Err3 } from "@harness-engineering/core";
 
 // src/templates/schema.ts
 import { z as z2 } from "zod";
@@ -976,9 +1013,9 @@ var TemplateEngine = class {
         const parsed = TemplateMetadataSchema.safeParse(raw);
         if (parsed.success) templates.push(parsed.data);
       }
-      return Ok7(templates);
+      return Ok(templates);
     } catch (error) {
-      return Err3(
+      return Err(
         new Error(
           `Failed to list templates: ${error instanceof Error ? error.message : String(error)}`
         )
@@ -987,12 +1024,12 @@ var TemplateEngine = class {
   }
   resolveTemplate(level, framework) {
     const levelDir = this.findTemplateDir(level, "level");
-    if (!levelDir) return Err3(new Error(`Template not found for level: ${level}`));
+    if (!levelDir) return Err(new Error(`Template not found for level: ${level}`));
     const metaPath = path8.join(levelDir, "template.json");
     const metaRaw = JSON.parse(fs2.readFileSync(metaPath, "utf-8"));
     const metaResult = TemplateMetadataSchema.safeParse(metaRaw);
     if (!metaResult.success)
-      return Err3(new Error(`Invalid template.json in ${level}: ${metaResult.error.message}`));
+      return Err(new Error(`Invalid template.json in ${level}: ${metaResult.error.message}`));
     const metadata = metaResult.data;
     let files = [];
     if (metadata.extends) {
@@ -1004,7 +1041,7 @@ var TemplateEngine = class {
     let overlayMetadata;
     if (framework) {
       const frameworkDir = this.findTemplateDir(framework, "framework");
-      if (!frameworkDir) return Err3(new Error(`Framework template not found: ${framework}`));
+      if (!frameworkDir) return Err(new Error(`Framework template not found: ${framework}`));
       const fMetaPath = path8.join(frameworkDir, "template.json");
       const fMetaRaw = JSON.parse(fs2.readFileSync(fMetaPath, "utf-8"));
       const fMetaResult = TemplateMetadataSchema.safeParse(fMetaRaw);
@@ -1015,7 +1052,7 @@ var TemplateEngine = class {
     files = files.filter((f) => f.relativePath !== "template.json");
     const resolved = { metadata, files };
     if (overlayMetadata !== void 0) resolved.overlayMetadata = overlayMetadata;
-    return Ok7(resolved);
+    return Ok(resolved);
   }
   render(template, context) {
     const rendered = [];
@@ -1035,7 +1072,7 @@ var TemplateEngine = class {
           }
         } catch (error) {
           const msg = error instanceof Error ? error.message : String(error);
-          return Err3(
+          return Err(
             new Error(
               `Template render failed in ${file.sourceTemplate}/${file.relativePath}: ${msg}`
             )
@@ -1047,7 +1084,7 @@ var TemplateEngine = class {
           rendered.push({ relativePath: file.relativePath, content });
         } catch (error) {
           const msg = error instanceof Error ? error.message : String(error);
-          return Err3(
+          return Err(
             new Error(
               `Template render failed in ${file.sourceTemplate}/${file.relativePath}: ${msg}`
             )
@@ -1065,9 +1102,9 @@ var TemplateEngine = class {
       }
     } catch (error) {
       const msg = error instanceof Error ? error.message : String(error);
-      return Err3(new Error(`JSON merge failed: ${msg}`));
+      return Err(new Error(`JSON merge failed: ${msg}`));
     }
-    return Ok7({ files: rendered });
+    return Ok({ files: rendered });
   }
   write(files, targetDir, options) {
     try {
@@ -1080,9 +1117,9 @@ var TemplateEngine = class {
         fs2.writeFileSync(targetPath, file.content);
         written.push(file.relativePath);
       }
-      return Ok7(written);
+      return Ok(written);
     } catch (error) {
-      return Err3(
+      return Err(
         new Error(
           `Failed to write files: ${error instanceof Error ? error.message : String(error)}`
         )
@@ -1213,8 +1250,7 @@ import * as path10 from "path";
 import * as os from "os";
 import chalk2 from "chalk";
 var HARNESS_MCP_ENTRY = {
-  command: "npx",
-  args: ["@harness-engineering/mcp-server"]
+  command: "harness-mcp"
 };
 function readJsonFile(filePath) {
   if (!fs4.existsSync(filePath)) return null;
@@ -1326,7 +1362,7 @@ async function runInit(options) {
   const force = options.force ?? false;
   const configPath = path11.join(cwd, "harness.config.json");
   if (!force && fs5.existsSync(configPath)) {
-    return Err4(
+    return Err(
       new CLIError("Project already initialized. Use --force to overwrite.", ExitCode.ERROR)
     );
   }
@@ -1334,7 +1370,7 @@ async function runInit(options) {
   const engine = new TemplateEngine(templatesDir);
   const resolveResult = engine.resolveTemplate(level, options.framework);
   if (!resolveResult.ok) {
-    return Err4(new CLIError(resolveResult.error.message, ExitCode.ERROR));
+    return Err(new CLIError(resolveResult.error.message, ExitCode.ERROR));
   }
   const renderResult = engine.render(resolveResult.value, {
     projectName: name,
@@ -1342,13 +1378,13 @@ async function runInit(options) {
     ...options.framework !== void 0 && { framework: options.framework }
   });
   if (!renderResult.ok) {
-    return Err4(new CLIError(renderResult.error.message, ExitCode.ERROR));
+    return Err(new CLIError(renderResult.error.message, ExitCode.ERROR));
   }
   const writeResult = engine.write(renderResult.value, cwd, { overwrite: force });
   if (!writeResult.ok) {
-    return Err4(new CLIError(writeResult.error.message, ExitCode.ERROR));
+    return Err(new CLIError(writeResult.error.message, ExitCode.ERROR));
   }
-  return Ok8({ filesCreated: writeResult.value });
+  return Ok({ filesCreated: writeResult.value });
 }
 function createInitCommand() {
   const command = new Command8("init").description("Initialize a new harness-engineering project").option("-n, --name <name>", "Project name").option("-l, --level <level>", "Adoption level (basic, intermediate, advanced)", "basic").option("--framework <framework>", "Framework overlay (nextjs)").option("-f, --force", "Overwrite existing files").option("-y, --yes", "Use defaults without prompting").action(async (opts, cmd) => {
@@ -1395,13 +1431,12 @@ function createInitCommand() {
 // src/commands/cleanup.ts
 import { Command as Command9 } from "commander";
 import * as path12 from "path";
-import { Ok as Ok9, Err as Err5, EntropyAnalyzer as EntropyAnalyzer2 } from "@harness-engineering/core";
 async function runCleanup(options) {
   const cwd = options.cwd ?? process.cwd();
   const type = options.type ?? "all";
   const configResult = resolveConfig(options.configPath);
   if (!configResult.ok) {
-    return Err5(configResult.error);
+    return Err(configResult.error);
   }
   const config = configResult.value;
   const result = {
@@ -1423,10 +1458,10 @@ async function runCleanup(options) {
     },
     exclude: config.entropy?.excludePatterns ?? ["**/node_modules/**", "**/*.test.ts"]
   };
-  const analyzer = new EntropyAnalyzer2(entropyConfig);
+  const analyzer = new EntropyAnalyzer(entropyConfig);
   const analysisResult = await analyzer.analyze();
   if (!analysisResult.ok) {
-    return Err5(
+    return Err(
       new CLIError(`Entropy analysis failed: ${analysisResult.error.message}`, ExitCode.ERROR)
     );
   }
@@ -1451,7 +1486,7 @@ async function runCleanup(options) {
     }));
   }
   result.totalIssues = result.driftIssues.length + result.deadCode.length + result.patternViolations.length;
-  return Ok9(result);
+  return Ok(result);
 }
 function createCleanupCommand() {
   const command = new Command9("cleanup").description("Detect entropy issues (doc drift, dead code, patterns)").option("-t, --type <type>", "Issue type: drift, dead-code, patterns, all", "all").action(async (opts, cmd) => {
@@ -1516,22 +1551,12 @@ function createCleanupCommand() {
 // src/commands/fix-drift.ts
 import { Command as Command10 } from "commander";
 import * as path13 from "path";
-import {
-  Ok as Ok10,
-  Err as Err6,
-  buildSnapshot,
-  detectDocDrift,
-  detectDeadCode,
-  createFixes,
-  applyFixes,
-  generateSuggestions
-} from "@harness-engineering/core";
 async function runFixDrift(options) {
   const cwd = options.cwd ?? process.cwd();
   const dryRun = options.dryRun !== false;
   const configResult = resolveConfig(options.configPath);
   if (!configResult.ok) {
-    return Err6(configResult.error);
+    return Err(configResult.error);
   }
   const config = configResult.value;
   const rootDir = path13.resolve(cwd, config.rootDir);
@@ -1549,21 +1574,21 @@ async function runFixDrift(options) {
   };
   const snapshotResult = await buildSnapshot(entropyConfig);
   if (!snapshotResult.ok) {
-    return Err6(
+    return Err(
       new CLIError(`Failed to build snapshot: ${snapshotResult.error.message}`, ExitCode.ERROR)
     );
   }
   const snapshot = snapshotResult.value;
   const driftResult = await detectDocDrift(snapshot);
   if (!driftResult.ok) {
-    return Err6(
+    return Err(
       new CLIError(`Failed to detect drift: ${driftResult.error.message}`, ExitCode.ERROR)
     );
   }
   const driftReport = driftResult.value;
   const deadCodeResult = await detectDeadCode(snapshot);
   if (!deadCodeResult.ok) {
-    return Err6(
+    return Err(
       new CLIError(`Failed to detect dead code: ${deadCodeResult.error.message}`, ExitCode.ERROR)
     );
   }
@@ -1573,7 +1598,7 @@ async function runFixDrift(options) {
   if (!dryRun && fixes.length > 0) {
     const applyResult = await applyFixes(fixes, { dryRun: false });
     if (!applyResult.ok) {
-      return Err6(
+      return Err(
         new CLIError(`Failed to apply fixes: ${applyResult.error.message}`, ExitCode.ERROR)
       );
     }
@@ -1622,7 +1647,7 @@ async function runFixDrift(options) {
     fixes: appliedFixes,
     suggestions
   };
-  return Ok10(result);
+  return Ok(result);
 }
 function createFixDriftCommand() {
   const command = new Command10("fix-drift").description("Auto-fix entropy issues (doc drift, dead code)").option("--no-dry-run", "Actually apply fixes (default is dry-run mode)").action(async (opts, cmd) => {
@@ -1691,14 +1716,11 @@ import { Command as Command13 } from "commander";
 import { Command as Command11 } from "commander";
 import * as path17 from "path";
 import * as childProcess from "child_process";
-import { Ok as Ok12, Err as Err8 } from "@harness-engineering/core";
-import { requestPeerReview } from "@harness-engineering/core";
 
 // src/persona/loader.ts
 import * as fs6 from "fs";
 import * as path14 from "path";
 import YAML from "yaml";
-import { Ok as Ok11, Err as Err7 } from "@harness-engineering/core";
 
 // src/persona/schema.ts
 import { z as z3 } from "zod";
@@ -1784,24 +1806,24 @@ function normalizePersona(raw) {
 function loadPersona(filePath) {
   try {
     if (!fs6.existsSync(filePath)) {
-      return Err7(new Error(`Persona file not found: ${filePath}`));
+      return Err(new Error(`Persona file not found: ${filePath}`));
     }
     const raw = fs6.readFileSync(filePath, "utf-8");
     const parsed = YAML.parse(raw);
     const result = PersonaSchema.safeParse(parsed);
     if (!result.success) {
-      return Err7(new Error(`Invalid persona ${filePath}: ${result.error.message}`));
+      return Err(new Error(`Invalid persona ${filePath}: ${result.error.message}`));
     }
-    return Ok11(normalizePersona(result.data));
+    return Ok(normalizePersona(result.data));
   } catch (error) {
-    return Err7(
+    return Err(
       new Error(`Failed to load persona: ${error instanceof Error ? error.message : String(error)}`)
     );
   }
 }
 function listPersonas(dir) {
   try {
-    if (!fs6.existsSync(dir)) return Ok11([]);
+    if (!fs6.existsSync(dir)) return Ok([]);
     const entries = fs6.readdirSync(dir).filter((f) => f.endsWith(".yaml") || f.endsWith(".yml"));
     const personas = [];
     for (const entry of entries) {
@@ -1811,9 +1833,9 @@ function listPersonas(dir) {
         personas.push({ name: result.value.name, description: result.value.description, filePath });
       }
     }
-    return Ok11(personas);
+    return Ok(personas);
   } catch (error) {
-    return Err7(
+    return Err(
       new Error(
         `Failed to list personas: ${error instanceof Error ? error.message : String(error)}`
       )
@@ -1904,8 +1926,8 @@ async function runPersona(persona, context) {
       const result = await Promise.race([
         context.commandExecutor(step.command),
         new Promise(
-          (resolve22) => setTimeout(
-            () => resolve22({
+          (resolve24) => setTimeout(
+            () => resolve24({
               ok: false,
               error: new Error(TIMEOUT_ERROR_MESSAGE)
             }),
@@ -1960,7 +1982,7 @@ async function runPersona(persona, context) {
       const result = await Promise.race([
         context.skillExecutor(step.skill, skillContext),
         new Promise(
-          (resolve22) => setTimeout(() => resolve22(SKILL_TIMEOUT_RESULT), remainingTime)
+          (resolve24) => setTimeout(() => resolve24(SKILL_TIMEOUT_RESULT), remainingTime)
         )
       ]);
       const durationMs = Date.now() - stepStart;
@@ -2142,7 +2164,7 @@ async function runAgentTask(task, options) {
   };
   const agentType = agentTypeMap[task];
   if (!agentType) {
-    return Err8(
+    return Err(
       new CLIError(
         `Unknown task: ${task}. Available: ${Object.keys(agentTypeMap).join(", ")}`,
         ExitCode.ERROR
@@ -2162,10 +2184,10 @@ async function runAgentTask(task, options) {
     { timeout }
   );
   if (!reviewResult.ok) {
-    return Err8(new CLIError(`Agent task failed: ${reviewResult.error.message}`, ExitCode.ERROR));
+    return Err(new CLIError(`Agent task failed: ${reviewResult.error.message}`, ExitCode.ERROR));
   }
   const review = reviewResult.value;
-  return Ok12({
+  return Ok({
     success: review.approved,
     output: review.approved ? `Agent task '${task}' completed successfully` : `Agent task '${task}' found issues:
 ${review.comments.map((c) => `  - ${c.message}`).join("\n")}`
@@ -2197,13 +2219,13 @@ function createRunCommand() {
       const trigger = opts.trigger === "auto" ? "auto" : VALID_TRIGGERS.has(opts.trigger) ? opts.trigger : "manual";
       const commandExecutor = async (command) => {
         if (!ALLOWED_PERSONA_COMMANDS.has(command)) {
-          return Err8(new Error(`Unknown harness command: ${command}`));
+          return Err(new Error(`Unknown harness command: ${command}`));
         }
         try {
           childProcess.execFileSync("npx", ["harness", command], { stdio: "inherit" });
-          return Ok12(null);
+          return Ok(null);
         } catch (error) {
-          return Err8(new Error(error instanceof Error ? error.message : String(error)));
+          return Err(new Error(error instanceof Error ? error.message : String(error)));
         }
       };
       const report = await runPersona(persona, {
@@ -2245,8 +2267,6 @@ function createRunCommand() {
 // src/commands/agent/review.ts
 import { Command as Command12 } from "commander";
 import { execSync as execSync2 } from "child_process";
-import { Ok as Ok13, Err as Err9 } from "@harness-engineering/core";
-import { createSelfReview, parseDiff } from "@harness-engineering/core";
 async function runAgentReview(options) {
   const configResult = resolveConfig(options.configPath);
   if (!configResult.ok) {
@@ -2260,17 +2280,17 @@ async function runAgentReview(options) {
       diff = execSync2("git diff", { encoding: "utf-8" });
     }
   } catch {
-    return Err9(new CLIError("Failed to get git diff", ExitCode.ERROR));
+    return Err(new CLIError("Failed to get git diff", ExitCode.ERROR));
   }
   if (!diff) {
-    return Ok13({
+    return Ok({
       passed: true,
       checklist: [{ check: "No changes to review", passed: true }]
     });
   }
   const parsedDiffResult = parseDiff(diff);
   if (!parsedDiffResult.ok) {
-    return Err9(new CLIError(parsedDiffResult.error.message, ExitCode.ERROR));
+    return Err(new CLIError(parsedDiffResult.error.message, ExitCode.ERROR));
   }
   const codeChanges = parsedDiffResult.value;
   const review = await createSelfReview(codeChanges, {
@@ -2281,9 +2301,9 @@ async function runAgentReview(options) {
     }
   });
   if (!review.ok) {
-    return Err9(new CLIError(review.error.message, ExitCode.ERROR));
+    return Err(new CLIError(review.error.message, ExitCode.ERROR));
   }
-  return Ok13({
+  return Ok({
     passed: review.value.passed,
     checklist: review.value.items.map((item) => ({
       check: item.check,
@@ -2339,7 +2359,6 @@ function createAgentCommand() {
 import { Command as Command14 } from "commander";
 import * as fs9 from "fs";
 import * as path18 from "path";
-import { Ok as Ok14, Err as Err10 } from "@harness-engineering/core";
 var LAYER_INDEX_TEMPLATE = (name) => `// ${name} layer
 // Add your ${name} exports here
 
@@ -2369,7 +2388,7 @@ async function runAdd(componentType, name, options) {
   const cwd = options.cwd ?? process.cwd();
   const NAME_PATTERN = /^[a-zA-Z][a-zA-Z0-9_-]*$/;
   if (!name || !NAME_PATTERN.test(name)) {
-    return Err10(
+    return Err(
       new CLIError(
         "Invalid name. Must start with a letter and contain only alphanumeric characters, hyphens, and underscores.",
         ExitCode.ERROR
@@ -2398,7 +2417,7 @@ async function runAdd(componentType, name, options) {
       case "module": {
         const modulePath = path18.join(cwd, "src", `${name}.ts`);
         if (fs9.existsSync(modulePath)) {
-          return Err10(new CLIError(`Module ${name} already exists`, ExitCode.ERROR));
+          return Err(new CLIError(`Module ${name} already exists`, ExitCode.ERROR));
         }
         fs9.writeFileSync(modulePath, MODULE_TEMPLATE(name));
         created.push(`src/${name}.ts`);
@@ -2411,7 +2430,7 @@ async function runAdd(componentType, name, options) {
         }
         const docPath = path18.join(docsDir, `${name}.md`);
         if (fs9.existsSync(docPath)) {
-          return Err10(new CLIError(`Doc ${name} already exists`, ExitCode.ERROR));
+          return Err(new CLIError(`Doc ${name} already exists`, ExitCode.ERROR));
         }
         fs9.writeFileSync(docPath, DOC_TEMPLATE(name));
         created.push(`docs/${name}.md`);
@@ -2435,7 +2454,7 @@ async function runAdd(componentType, name, options) {
         }
         const personaPath = path18.join(personasDir, `${name}.yaml`);
         if (fs9.existsSync(personaPath)) {
-          return Err10(new CLIError(`Persona ${name} already exists`, ExitCode.ERROR));
+          return Err(new CLIError(`Persona ${name} already exists`, ExitCode.ERROR));
         }
         fs9.writeFileSync(
           personaPath,
@@ -2451,7 +2470,7 @@ focus_areas: []
       }
       default: {
         const _exhaustive = componentType;
-        return Err10(
+        return Err(
           new CLIError(
             `Unknown component type: ${String(_exhaustive)}. Use: layer, module, doc, skill, persona`,
             ExitCode.ERROR
@@ -2459,9 +2478,9 @@ focus_areas: []
         );
       }
     }
-    return Ok14({ created });
+    return Ok({ created });
   } catch (error) {
-    return Err10(
+    return Err(
       new CLIError(
         `Failed to add ${componentType}: ${error instanceof Error ? error.message : "Unknown error"}`,
         ExitCode.ERROR
@@ -2495,7 +2514,346 @@ import { Command as Command17 } from "commander";
 
 // src/commands/linter/generate.ts
 import { Command as Command15 } from "commander";
-import { generate } from "@harness-engineering/linter-gen";
+
+// ../linter-gen/dist/generator/orchestrator.js
+import * as fs12 from "fs/promises";
+import * as path21 from "path";
+
+// ../linter-gen/dist/parser/config-parser.js
+import * as fs10 from "fs/promises";
+import * as yaml from "yaml";
+
+// ../linter-gen/dist/schema/linter-config.js
+import { z as z4 } from "zod";
+var RuleConfigSchema = z4.object({
+  /** Rule name in kebab-case (e.g., 'no-ui-in-services') */
+  name: z4.string().regex(/^[a-z][a-z0-9]*(-[a-z0-9]+)*$/, "Rule name must be kebab-case"),
+  /** Rule type - determines which template to use */
+  type: z4.string().min(1),
+  /** ESLint severity level */
+  severity: z4.enum(["error", "warn", "off"]).default("error"),
+  /** Template-specific configuration */
+  config: z4.record(z4.unknown())
+});
+var LinterConfigSchema = z4.object({
+  /** Config version - currently only 1 is supported */
+  version: z4.literal(1),
+  /** Output directory for generated rules */
+  output: z4.string().min(1),
+  /** Optional explicit template path mappings (type → path) */
+  templates: z4.record(z4.string()).optional(),
+  /** Rules to generate */
+  rules: z4.array(RuleConfigSchema).min(1, "At least one rule is required")
+});
+
+// ../linter-gen/dist/parser/config-parser.js
+var ParseError = class extends Error {
+  code;
+  cause;
+  constructor(message, code, cause) {
+    super(message);
+    this.code = code;
+    this.cause = cause;
+    this.name = "ParseError";
+  }
+};
+async function parseConfig(configPath) {
+  let content;
+  try {
+    content = await fs10.readFile(configPath, "utf-8");
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      return {
+        success: false,
+        error: new ParseError(`Config file not found: ${configPath}`, "FILE_NOT_FOUND", err)
+      };
+    }
+    return {
+      success: false,
+      error: new ParseError(`Failed to read config file: ${configPath}`, "FILE_READ_ERROR", err)
+    };
+  }
+  let parsed;
+  try {
+    parsed = yaml.parse(content);
+  } catch (err) {
+    return {
+      success: false,
+      error: new ParseError(`Invalid YAML syntax in ${configPath}: ${err.message}`, "YAML_PARSE_ERROR", err)
+    };
+  }
+  const result = LinterConfigSchema.safeParse(parsed);
+  if (!result.success) {
+    const issues = result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ");
+    return {
+      success: false,
+      error: new ParseError(`Invalid config: ${issues}`, "VALIDATION_ERROR", result.error)
+    };
+  }
+  return {
+    success: true,
+    data: result.data,
+    configPath
+  };
+}
+
+// ../linter-gen/dist/engine/template-loader.js
+import * as fs11 from "fs/promises";
+import * as path19 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname2 = path19.dirname(__filename2);
+var TemplateLoadError = class extends Error {
+  code;
+  cause;
+  constructor(message, code, cause) {
+    super(message);
+    this.code = code;
+    this.cause = cause;
+    this.name = "TemplateLoadError";
+  }
+};
+var BUILTIN_TEMPLATES = ["import-restriction", "boundary-validation", "dependency-graph"];
+async function fileExists(filePath) {
+  try {
+    await fs11.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function loadTemplateFile(filePath, type) {
+  try {
+    const content = await fs11.readFile(filePath, "utf-8");
+    return {
+      success: true,
+      source: { type, path: filePath, content }
+    };
+  } catch (err) {
+    return {
+      success: false,
+      error: new TemplateLoadError(`Failed to read template: ${filePath}`, "TEMPLATE_READ_ERROR", err)
+    };
+  }
+}
+async function loadTemplate(ruleType, templatesConfig, configDir) {
+  if (templatesConfig?.[ruleType]) {
+    const explicitPath = path19.resolve(configDir, templatesConfig[ruleType]);
+    if (await fileExists(explicitPath)) {
+      return loadTemplateFile(explicitPath, "explicit");
+    }
+    return {
+      success: false,
+      error: new TemplateLoadError(`Explicit template not found: ${explicitPath}`, "TEMPLATE_NOT_FOUND")
+    };
+  }
+  const conventionPath = path19.join(configDir, "templates", `${ruleType}.ts.hbs`);
+  if (await fileExists(conventionPath)) {
+    return loadTemplateFile(conventionPath, "convention");
+  }
+  if (BUILTIN_TEMPLATES.includes(ruleType)) {
+    const builtinPath = path19.join(__dirname2, "..", "templates", `${ruleType}.ts.hbs`);
+    if (await fileExists(builtinPath)) {
+      return loadTemplateFile(builtinPath, "builtin");
+    }
+  }
+  return {
+    success: false,
+    error: new TemplateLoadError(`Template not found for type '${ruleType}'. Checked: explicit config, ./templates/${ruleType}.ts.hbs, built-in templates.`, "TEMPLATE_NOT_FOUND")
+  };
+}
+
+// ../linter-gen/dist/generator/rule-generator.js
+import * as path20 from "path";
+
+// ../linter-gen/dist/engine/context-builder.js
+var GENERATOR_VERSION = "0.1.0";
+function toCamelCase(str) {
+  return str.replace(/-([a-z0-9])/g, (_, char) => char.toUpperCase());
+}
+function toPascalCase(str) {
+  const camel = toCamelCase(str);
+  return camel.charAt(0).toUpperCase() + camel.slice(1);
+}
+function buildRuleContext(rule, configPath) {
+  return {
+    name: rule.name,
+    nameCamel: toCamelCase(rule.name),
+    namePascal: toPascalCase(rule.name),
+    severity: rule.severity,
+    config: rule.config,
+    meta: {
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      generatorVersion: GENERATOR_VERSION,
+      configPath
+    }
+  };
+}
+
+// ../linter-gen/dist/engine/template-renderer.js
+import Handlebars2 from "handlebars";
+var TemplateError = class extends Error {
+  cause;
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "TemplateError";
+  }
+};
+function toCamelCase2(str) {
+  return str.replace(/-([a-z0-9])/g, (_, char) => char.toUpperCase());
+}
+function toPascalCase2(str) {
+  const camel = toCamelCase2(str);
+  return camel.charAt(0).toUpperCase() + camel.slice(1);
+}
+Handlebars2.registerHelper("json", (obj) => JSON.stringify(obj));
+Handlebars2.registerHelper("jsonPretty", (obj) => JSON.stringify(obj, null, 2));
+Handlebars2.registerHelper("camelCase", (str) => toCamelCase2(str));
+Handlebars2.registerHelper("pascalCase", (str) => toPascalCase2(str));
+function renderTemplate(templateSource, context) {
+  try {
+    const compiled = Handlebars2.compile(templateSource, { strict: true });
+    const output = compiled(context);
+    return { success: true, output };
+  } catch (err) {
+    return {
+      success: false,
+      error: new TemplateError(`Template rendering failed: ${err.message}`, err)
+    };
+  }
+}
+
+// ../linter-gen/dist/generator/rule-generator.js
+function generateRule(rule, template, outputDir, configPath) {
+  const context = buildRuleContext(rule, configPath);
+  const renderResult = renderTemplate(template.content, context);
+  if (!renderResult.success) {
+    return {
+      success: false,
+      error: renderResult.error,
+      ruleName: rule.name
+    };
+  }
+  const outputPath = path20.join(outputDir, `${rule.name}.ts`);
+  return {
+    success: true,
+    rule: {
+      name: rule.name,
+      outputPath,
+      content: renderResult.output
+    }
+  };
+}
+
+// ../linter-gen/dist/generator/index-generator.js
+function toCamelCase3(str) {
+  return str.replace(/-([a-z0-9])/g, (_, char) => char.toUpperCase());
+}
+function generateIndex(ruleNames) {
+  const imports = ruleNames.map((name) => {
+    const camel = toCamelCase3(name);
+    return `import ${camel} from './${name}';`;
+  }).join("\n");
+  const rulesObject = ruleNames.map((name) => {
+    const camel = toCamelCase3(name);
+    return `  '${name}': ${camel},`;
+  }).join("\n");
+  const namedExports = ruleNames.map(toCamelCase3).join(", ");
+  return `// Generated by @harness-engineering/linter-gen
+// Do not edit manually - regenerate from harness-linter.yml
+
+${imports}
+
+export const rules = {
+${rulesObject}
+};
+
+export { ${namedExports} };
+`;
+}
+
+// ../linter-gen/dist/generator/orchestrator.js
+async function validate(options) {
+  const parseResult = await parseConfig(options.configPath);
+  if (!parseResult.success) {
+    return { success: false, error: parseResult.error };
+  }
+  return { success: true, ruleCount: parseResult.data.rules.length };
+}
+async function generate(options) {
+  const errors = [];
+  const parseResult = await parseConfig(options.configPath);
+  if (!parseResult.success) {
+    return { success: false, errors: [{ type: "parse", error: parseResult.error }] };
+  }
+  const config = parseResult.data;
+  const configDir = path21.dirname(path21.resolve(options.configPath));
+  const outputDir = options.outputDir ? path21.resolve(options.outputDir) : path21.resolve(configDir, config.output);
+  if (options.clean && !options.dryRun) {
+    try {
+      await fs12.rm(outputDir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+  if (!options.dryRun) {
+    await fs12.mkdir(outputDir, { recursive: true });
+  }
+  const generatedRules = [];
+  for (const rule of config.rules) {
+    const templateResult = await loadTemplate(rule.type, config.templates, configDir);
+    if (!templateResult.success) {
+      errors.push({
+        type: "template",
+        error: templateResult.error,
+        ruleName: rule.name
+      });
+      continue;
+    }
+    const ruleResult = generateRule(rule, templateResult.source, outputDir, options.configPath);
+    if (!ruleResult.success) {
+      errors.push({
+        type: "render",
+        error: ruleResult.error,
+        ruleName: ruleResult.ruleName
+      });
+      continue;
+    }
+    if (!options.dryRun) {
+      try {
+        await fs12.writeFile(ruleResult.rule.outputPath, ruleResult.rule.content, "utf-8");
+      } catch (err) {
+        errors.push({
+          type: "write",
+          error: err,
+          path: ruleResult.rule.outputPath
+        });
+        continue;
+      }
+    }
+    generatedRules.push(rule.name);
+  }
+  if (generatedRules.length > 0 && !options.dryRun) {
+    const indexContent = generateIndex(generatedRules);
+    const indexPath = path21.join(outputDir, "index.ts");
+    try {
+      await fs12.writeFile(indexPath, indexContent, "utf-8");
+    } catch (err) {
+      errors.push({ type: "write", error: err, path: indexPath });
+    }
+  }
+  if (errors.length > 0) {
+    return { success: false, errors };
+  }
+  return {
+    success: true,
+    rulesGenerated: generatedRules,
+    outputDir,
+    dryRun: options.dryRun ?? false
+  };
+}
+
+// src/commands/linter/generate.ts
 function createGenerateCommand() {
   return new Command15("generate").description("Generate ESLint rules from harness-linter.yml").option("-c, --config <path>", "Path to harness-linter.yml", "./harness-linter.yml").option("-o, --output <dir>", "Override output directory").option("--clean", "Remove existing files before generating").option("--dry-run", "Preview without writing files").option("--json", "Output as JSON").option("--verbose", "Show detailed output").action(async (options) => {
     try {
@@ -2560,7 +2918,6 @@ Generated ${result.rulesGenerated.length} rules to ${result.outputDir}`);
 
 // src/commands/linter/validate.ts
 import { Command as Command16 } from "commander";
-import { validate } from "@harness-engineering/linter-gen";
 function createValidateCommand2() {
   return new Command16("validate").description("Validate harness-linter.yml config").option("-c, --config <path>", "Path to harness-linter.yml", "./harness-linter.yml").option("--json", "Output as JSON").action(async (options) => {
     try {
@@ -2625,11 +2982,8 @@ function createListCommand() {
 
 // src/commands/persona/generate.ts
 import { Command as Command19 } from "commander";
-import * as fs10 from "fs";
-import * as path19 from "path";
-
-// src/persona/generators/runtime.ts
-import { Ok as Ok15, Err as Err11 } from "@harness-engineering/core";
+import * as fs13 from "fs";
+import * as path22 from "path";
 
 // src/utils/string.ts
 function toKebabCase(name) {
@@ -2646,9 +3000,9 @@ function generateRuntime(persona) {
       timeout: persona.config.timeout,
       severity: persona.config.severity
     };
-    return Ok15(JSON.stringify(config, null, 2));
+    return Ok(JSON.stringify(config, null, 2));
   } catch (error) {
-    return Err11(
+    return Err(
       new Error(
         `Failed to generate runtime config: ${error instanceof Error ? error.message : String(error)}`
       )
@@ -2657,7 +3011,6 @@ function generateRuntime(persona) {
 }
 
 // src/persona/generators/agents-md.ts
-import { Ok as Ok16, Err as Err12 } from "@harness-engineering/core";
 function formatTrigger(trigger) {
   switch (trigger.event) {
     case "on_pr": {
@@ -2691,9 +3044,9 @@ function generateAgentsMd(persona) {
 
 **When this agent flags an issue:** Fix violations before merging. Run ${allCommands} locally to validate.
 `;
-    return Ok16(fragment);
+    return Ok(fragment);
   } catch (error) {
-    return Err12(
+    return Err(
       new Error(
         `Failed to generate AGENTS.md fragment: ${error instanceof Error ? error.message : String(error)}`
       )
@@ -2703,7 +3056,6 @@ function generateAgentsMd(persona) {
 
 // src/persona/generators/ci-workflow.ts
 import YAML2 from "yaml";
-import { Ok as Ok17, Err as Err13 } from "@harness-engineering/core";
 function buildGitHubTriggers(triggers) {
   const on = {};
   for (const trigger of triggers) {
@@ -2729,7 +3081,7 @@ function buildGitHubTriggers(triggers) {
 }
 function generateCIWorkflow(persona, platform) {
   try {
-    if (platform === "gitlab") return Err13(new Error("GitLab CI generation is not yet supported"));
+    if (platform === "gitlab") return Err(new Error("GitLab CI generation is not yet supported"));
     const severity = persona.config.severity;
     const steps = [
       { uses: "actions/checkout@v4" },
@@ -2751,9 +3103,9 @@ function generateCIWorkflow(persona, platform) {
         }
       }
     };
-    return Ok17(YAML2.stringify(workflow, { lineWidth: 0 }));
+    return Ok(YAML2.stringify(workflow, { lineWidth: 0 }));
   } catch (error) {
-    return Err13(
+    return Err(
       new Error(
         `Failed to generate CI workflow: ${error instanceof Error ? error.message : String(error)}`
       )
@@ -2766,40 +3118,40 @@ function createGenerateCommand2() {
   return new Command19("generate").description("Generate artifacts from a persona config").argument("<name>", "Persona name (e.g., architecture-enforcer)").option("--output-dir <dir>", "Output directory", ".").option("--only <type>", "Generate only: ci, agents-md, runtime").action(async (name, opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const personasDir = resolvePersonasDir();
-    const filePath = path19.join(personasDir, `${name}.yaml`);
+    const filePath = path22.join(personasDir, `${name}.yaml`);
     const personaResult = loadPersona(filePath);
     if (!personaResult.ok) {
       logger.error(personaResult.error.message);
       process.exit(ExitCode.ERROR);
     }
     const persona = personaResult.value;
-    const outputDir = path19.resolve(opts.outputDir);
+    const outputDir = path22.resolve(opts.outputDir);
     const slug = toKebabCase(persona.name);
     const only = opts.only;
     const generated = [];
     if (!only || only === "runtime") {
       const result = generateRuntime(persona);
       if (result.ok) {
-        const outPath = path19.join(outputDir, `${slug}.runtime.json`);
-        fs10.mkdirSync(path19.dirname(outPath), { recursive: true });
-        fs10.writeFileSync(outPath, result.value);
+        const outPath = path22.join(outputDir, `${slug}.runtime.json`);
+        fs13.mkdirSync(path22.dirname(outPath), { recursive: true });
+        fs13.writeFileSync(outPath, result.value);
         generated.push(outPath);
       }
     }
     if (!only || only === "agents-md") {
       const result = generateAgentsMd(persona);
       if (result.ok) {
-        const outPath = path19.join(outputDir, `${slug}.agents.md`);
-        fs10.writeFileSync(outPath, result.value);
+        const outPath = path22.join(outputDir, `${slug}.agents.md`);
+        fs13.writeFileSync(outPath, result.value);
         generated.push(outPath);
       }
     }
     if (!only || only === "ci") {
       const result = generateCIWorkflow(persona, "github");
       if (result.ok) {
-        const outPath = path19.join(outputDir, ".github", "workflows", `${slug}.yml`);
-        fs10.mkdirSync(path19.dirname(outPath), { recursive: true });
-        fs10.writeFileSync(outPath, result.value);
+        const outPath = path22.join(outputDir, ".github", "workflows", `${slug}.yml`);
+        fs13.mkdirSync(path22.dirname(outPath), { recursive: true });
+        fs13.writeFileSync(outPath, result.value);
         generated.push(outPath);
       }
     }
@@ -2824,26 +3176,26 @@ import { Command as Command25 } from "commander";
 
 // src/commands/skill/list.ts
 import { Command as Command21 } from "commander";
-import * as fs11 from "fs";
-import * as path20 from "path";
-import { parse as parse3 } from "yaml";
+import * as fs14 from "fs";
+import * as path23 from "path";
+import { parse as parse4 } from "yaml";
 function createListCommand2() {
   return new Command21("list").description("List available skills").action(async (_opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const skillsDir = resolveSkillsDir();
-    if (!fs11.existsSync(skillsDir)) {
+    if (!fs14.existsSync(skillsDir)) {
       logger.info("No skills directory found.");
       process.exit(ExitCode.SUCCESS);
       return;
     }
-    const entries = fs11.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+    const entries = fs14.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
     const skills = [];
     for (const name of entries) {
-      const yamlPath = path20.join(skillsDir, name, "skill.yaml");
-      if (!fs11.existsSync(yamlPath)) continue;
+      const yamlPath = path23.join(skillsDir, name, "skill.yaml");
+      if (!fs14.existsSync(yamlPath)) continue;
       try {
-        const raw = fs11.readFileSync(yamlPath, "utf-8");
-        const parsed = parse3(raw);
+        const raw = fs14.readFileSync(yamlPath, "utf-8");
+        const parsed = parse4(raw);
         const result = SkillMetadataSchema.safeParse(parsed);
         if (result.success) {
           skills.push(result.data);
@@ -2873,12 +3225,12 @@ function createListCommand2() {
 
 // src/commands/skill/run.ts
 import { Command as Command22 } from "commander";
-import * as fs12 from "fs";
-import * as path21 from "path";
-import { parse as parse4 } from "yaml";
+import * as fs15 from "fs";
+import * as path24 from "path";
+import { parse as parse5 } from "yaml";
 
 // src/skill/complexity.ts
-import { execSync as execSync3 } from "child_process";
+import { execFileSync as execFileSync2 } from "child_process";
 function evaluateSignals(signals) {
   if (signals.fileCount >= 3) return "full";
   if (signals.newDir) return "full";
@@ -2890,17 +3242,17 @@ function evaluateSignals(signals) {
 }
 function detectComplexity(projectPath) {
   try {
-    const base = execSync3("git merge-base HEAD main", {
+    const base = execFileSync2("git", ["merge-base", "HEAD", "main"], {
       cwd: projectPath,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
-    const diffFiles = execSync3(`git diff --name-only ${base}`, {
+    const diffFiles = execFileSync2("git", ["diff", "--name-only", base], {
       cwd: projectPath,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim().split("\n").filter(Boolean);
-    const diffStat = execSync3(`git diff --stat ${base}`, {
+    const diffStat = execFileSync2("git", ["diff", "--stat", base], {
       cwd: projectPath,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -2964,18 +3316,18 @@ ${options.priorState}`);
 function createRunCommand2() {
   return new Command22("run").description("Run a skill (outputs SKILL.md content with context preamble)").argument("<name>", "Skill name (e.g., harness-tdd)").option("--path <path>", "Project root path for context injection").option("--complexity <level>", "Complexity: auto, light, full", "auto").option("--phase <name>", "Start at a specific phase (for re-entry)").option("--party", "Enable multi-perspective evaluation").action(async (name, opts, _cmd) => {
     const skillsDir = resolveSkillsDir();
-    const skillDir = path21.join(skillsDir, name);
-    if (!fs12.existsSync(skillDir)) {
+    const skillDir = path24.join(skillsDir, name);
+    if (!fs15.existsSync(skillDir)) {
       logger.error(`Skill not found: ${name}`);
       process.exit(ExitCode.ERROR);
       return;
     }
-    const yamlPath = path21.join(skillDir, "skill.yaml");
+    const yamlPath = path24.join(skillDir, "skill.yaml");
     let metadata = null;
-    if (fs12.existsSync(yamlPath)) {
+    if (fs15.existsSync(yamlPath)) {
       try {
-        const raw = fs12.readFileSync(yamlPath, "utf-8");
-        const parsed = parse4(raw);
+        const raw = fs15.readFileSync(yamlPath, "utf-8");
+        const parsed = parse5(raw);
         const result = SkillMetadataSchema.safeParse(parsed);
         if (result.success) metadata = result.data;
       } catch {
@@ -2985,17 +3337,17 @@ function createRunCommand2() {
     if (metadata?.phases && metadata.phases.length > 0) {
       const requested = opts.complexity ?? "auto";
       if (requested === "auto") {
-        const projectPath2 = opts.path ? path21.resolve(opts.path) : process.cwd();
+        const projectPath2 = opts.path ? path24.resolve(opts.path) : process.cwd();
         complexity = detectComplexity(projectPath2);
       } else {
         complexity = requested;
       }
     }
     let principles;
-    const projectPath = opts.path ? path21.resolve(opts.path) : process.cwd();
-    const principlesPath = path21.join(projectPath, "docs", "principles.md");
-    if (fs12.existsSync(principlesPath)) {
-      principles = fs12.readFileSync(principlesPath, "utf-8");
+    const projectPath = opts.path ? path24.resolve(opts.path) : process.cwd();
+    const principlesPath = path24.join(projectPath, "docs", "principles.md");
+    if (fs15.existsSync(principlesPath)) {
+      principles = fs15.readFileSync(principlesPath, "utf-8");
     }
     let priorState;
     let stateWarning;
@@ -3010,16 +3362,16 @@ function createRunCommand2() {
       }
       if (metadata?.state.persistent && metadata.state.files.length > 0) {
         for (const stateFilePath of metadata.state.files) {
-          const fullPath = path21.join(projectPath, stateFilePath);
-          if (fs12.existsSync(fullPath)) {
-            const stat = fs12.statSync(fullPath);
+          const fullPath = path24.join(projectPath, stateFilePath);
+          if (fs15.existsSync(fullPath)) {
+            const stat = fs15.statSync(fullPath);
             if (stat.isDirectory()) {
-              const files = fs12.readdirSync(fullPath).map((f) => ({ name: f, mtime: fs12.statSync(path21.join(fullPath, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
+              const files = fs15.readdirSync(fullPath).map((f) => ({ name: f, mtime: fs15.statSync(path24.join(fullPath, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
               if (files.length > 0) {
-                priorState = fs12.readFileSync(path21.join(fullPath, files[0].name), "utf-8");
+                priorState = fs15.readFileSync(path24.join(fullPath, files[0].name), "utf-8");
               }
             } else {
-              priorState = fs12.readFileSync(fullPath, "utf-8");
+              priorState = fs15.readFileSync(fullPath, "utf-8");
             }
             break;
           }
@@ -3038,17 +3390,17 @@ function createRunCommand2() {
       ...stateWarning !== void 0 && { stateWarning },
       party: opts.party
     });
-    const skillMdPath = path21.join(skillDir, "SKILL.md");
-    if (!fs12.existsSync(skillMdPath)) {
+    const skillMdPath = path24.join(skillDir, "SKILL.md");
+    if (!fs15.existsSync(skillMdPath)) {
       logger.error(`SKILL.md not found for skill: ${name}`);
       process.exit(ExitCode.ERROR);
       return;
     }
-    let content = fs12.readFileSync(skillMdPath, "utf-8");
+    let content = fs15.readFileSync(skillMdPath, "utf-8");
     if (metadata?.state.persistent && opts.path) {
-      const stateFile = path21.join(projectPath, ".harness", "state.json");
-      if (fs12.existsSync(stateFile)) {
-        const stateContent = fs12.readFileSync(stateFile, "utf-8");
+      const stateFile = path24.join(projectPath, ".harness", "state.json");
+      if (fs15.existsSync(stateFile)) {
+        const stateContent = fs15.readFileSync(stateFile, "utf-8");
         content += `
 
 ---
@@ -3066,9 +3418,9 @@ ${stateContent}
 
 // src/commands/skill/validate.ts
 import { Command as Command23 } from "commander";
-import * as fs13 from "fs";
-import * as path22 from "path";
-import { parse as parse5 } from "yaml";
+import * as fs16 from "fs";
+import * as path25 from "path";
+import { parse as parse6 } from "yaml";
 var REQUIRED_SECTIONS = [
   "## When to Use",
   "## Process",
@@ -3080,32 +3432,32 @@ function createValidateCommand3() {
   return new Command23("validate").description("Validate all skill.yaml files and SKILL.md structure").action(async (_opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const skillsDir = resolveSkillsDir();
-    if (!fs13.existsSync(skillsDir)) {
+    if (!fs16.existsSync(skillsDir)) {
       logger.info("No skills directory found.");
       process.exit(ExitCode.SUCCESS);
       return;
     }
-    const entries = fs13.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+    const entries = fs16.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
     const errors = [];
     let validated = 0;
     for (const name of entries) {
-      const skillDir = path22.join(skillsDir, name);
-      const yamlPath = path22.join(skillDir, "skill.yaml");
-      const skillMdPath = path22.join(skillDir, "SKILL.md");
-      if (!fs13.existsSync(yamlPath)) {
+      const skillDir = path25.join(skillsDir, name);
+      const yamlPath = path25.join(skillDir, "skill.yaml");
+      const skillMdPath = path25.join(skillDir, "SKILL.md");
+      if (!fs16.existsSync(yamlPath)) {
         errors.push(`${name}: missing skill.yaml`);
         continue;
       }
       try {
-        const raw = fs13.readFileSync(yamlPath, "utf-8");
-        const parsed = parse5(raw);
+        const raw = fs16.readFileSync(yamlPath, "utf-8");
+        const parsed = parse6(raw);
         const result = SkillMetadataSchema.safeParse(parsed);
         if (!result.success) {
           errors.push(`${name}/skill.yaml: ${result.error.message}`);
           continue;
         }
-        if (fs13.existsSync(skillMdPath)) {
-          const mdContent = fs13.readFileSync(skillMdPath, "utf-8");
+        if (fs16.existsSync(skillMdPath)) {
+          const mdContent = fs16.readFileSync(skillMdPath, "utf-8");
           for (const section of REQUIRED_SECTIONS) {
             if (!mdContent.includes(section)) {
               errors.push(`${name}/SKILL.md: missing section "${section}"`);
@@ -3147,28 +3499,28 @@ function createValidateCommand3() {
 
 // src/commands/skill/info.ts
 import { Command as Command24 } from "commander";
-import * as fs14 from "fs";
-import * as path23 from "path";
-import { parse as parse6 } from "yaml";
+import * as fs17 from "fs";
+import * as path26 from "path";
+import { parse as parse7 } from "yaml";
 function createInfoCommand() {
   return new Command24("info").description("Show metadata for a skill").argument("<name>", "Skill name (e.g., harness-tdd)").action(async (name, _opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const skillsDir = resolveSkillsDir();
-    const skillDir = path23.join(skillsDir, name);
-    if (!fs14.existsSync(skillDir)) {
+    const skillDir = path26.join(skillsDir, name);
+    if (!fs17.existsSync(skillDir)) {
       logger.error(`Skill not found: ${name}`);
       process.exit(ExitCode.ERROR);
       return;
     }
-    const yamlPath = path23.join(skillDir, "skill.yaml");
-    if (!fs14.existsSync(yamlPath)) {
+    const yamlPath = path26.join(skillDir, "skill.yaml");
+    if (!fs17.existsSync(yamlPath)) {
       logger.error(`skill.yaml not found for skill: ${name}`);
       process.exit(ExitCode.ERROR);
       return;
     }
     try {
-      const raw = fs14.readFileSync(yamlPath, "utf-8");
-      const parsed = parse6(raw);
+      const raw = fs17.readFileSync(yamlPath, "utf-8");
+      const parsed = parse7(raw);
       const result = SkillMetadataSchema.safeParse(parsed);
       if (!result.success) {
         logger.error(`Invalid skill.yaml: ${result.error.message}`);
@@ -3221,12 +3573,11 @@ import { Command as Command30 } from "commander";
 
 // src/commands/state/show.ts
 import { Command as Command26 } from "commander";
-import * as path24 from "path";
-import { loadState } from "@harness-engineering/core";
+import * as path27 from "path";
 function createShowCommand() {
   return new Command26("show").description("Show current project state").option("--path <path>", "Project root path", ".").option("--stream <name>", "Target a specific stream").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
-    const projectPath = path24.resolve(opts.path);
+    const projectPath = path27.resolve(opts.path);
     const result = await loadState(projectPath, opts.stream);
     if (!result.ok) {
       logger.error(result.error.message);
@@ -3267,13 +3618,12 @@ Decisions: ${state.decisions.length}`);
 
 // src/commands/state/reset.ts
 import { Command as Command27 } from "commander";
-import * as fs15 from "fs";
-import * as path25 from "path";
+import * as fs18 from "fs";
+import * as path28 from "path";
 import * as readline from "readline";
-import { resolveStreamPath } from "@harness-engineering/core";
 function createResetCommand() {
   return new Command27("reset").description("Reset project state (deletes .harness/state.json)").option("--path <path>", "Project root path", ".").option("--stream <name>", "Target a specific stream").option("--yes", "Skip confirmation prompt").action(async (opts, _cmd) => {
-    const projectPath = path25.resolve(opts.path);
+    const projectPath = path28.resolve(opts.path);
     let statePath;
     if (opts.stream) {
       const streamResult = await resolveStreamPath(projectPath, { stream: opts.stream });
@@ -3282,19 +3632,19 @@ function createResetCommand() {
         process.exit(ExitCode.ERROR);
         return;
       }
-      statePath = path25.join(streamResult.value, "state.json");
+      statePath = path28.join(streamResult.value, "state.json");
     } else {
-      statePath = path25.join(projectPath, ".harness", "state.json");
+      statePath = path28.join(projectPath, ".harness", "state.json");
     }
-    if (!fs15.existsSync(statePath)) {
+    if (!fs18.existsSync(statePath)) {
       logger.info("No state file found. Nothing to reset.");
       process.exit(ExitCode.SUCCESS);
       return;
     }
     if (!opts.yes) {
       const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-      const answer = await new Promise((resolve22) => {
-        rl.question("Reset project state? This cannot be undone. [y/N] ", resolve22);
+      const answer = await new Promise((resolve24) => {
+        rl.question("Reset project state? This cannot be undone. [y/N] ", resolve24);
       });
       rl.close();
       if (answer.toLowerCase() !== "y" && answer.toLowerCase() !== "yes") {
@@ -3304,7 +3654,7 @@ function createResetCommand() {
       }
     }
     try {
-      fs15.unlinkSync(statePath);
+      fs18.unlinkSync(statePath);
       logger.success("Project state reset.");
     } catch (e) {
       logger.error(`Failed to reset state: ${e instanceof Error ? e.message : String(e)}`);
@@ -3317,11 +3667,10 @@ function createResetCommand() {
 
 // src/commands/state/learn.ts
 import { Command as Command28 } from "commander";
-import * as path26 from "path";
-import { appendLearning } from "@harness-engineering/core";
+import * as path29 from "path";
 function createLearnCommand() {
   return new Command28("learn").description("Append a learning to .harness/learnings.md").argument("<message>", "The learning to record").option("--path <path>", "Project root path", ".").option("--stream <name>", "Target a specific stream").action(async (message, opts, _cmd) => {
-    const projectPath = path26.resolve(opts.path);
+    const projectPath = path29.resolve(opts.path);
     const result = await appendLearning(projectPath, message, void 0, void 0, opts.stream);
     if (!result.ok) {
       logger.error(result.error.message);
@@ -3335,19 +3684,12 @@ function createLearnCommand() {
 
 // src/commands/state/streams.ts
 import { Command as Command29 } from "commander";
-import * as path27 from "path";
-import {
-  createStream,
-  listStreams,
-  archiveStream,
-  setActiveStream,
-  loadStreamIndex
-} from "@harness-engineering/core";
+import * as path30 from "path";
 function createStreamsCommand() {
   const command = new Command29("streams").description("Manage state streams");
   command.command("list").description("List all known streams").option("--path <path>", "Project root path", ".").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
-    const projectPath = path27.resolve(opts.path);
+    const projectPath = path30.resolve(opts.path);
     const indexResult = await loadStreamIndex(projectPath);
     const result = await listStreams(projectPath);
     if (!result.ok) {
@@ -3371,7 +3713,7 @@ function createStreamsCommand() {
     process.exit(ExitCode.SUCCESS);
   });
   command.command("create <name>").description("Create a new stream").option("--path <path>", "Project root path", ".").option("--branch <branch>", "Associate with a git branch").action(async (name, opts) => {
-    const projectPath = path27.resolve(opts.path);
+    const projectPath = path30.resolve(opts.path);
     const result = await createStream(projectPath, name, opts.branch);
     if (!result.ok) {
       logger.error(result.error.message);
@@ -3382,7 +3724,7 @@ function createStreamsCommand() {
     process.exit(ExitCode.SUCCESS);
   });
   command.command("archive <name>").description("Archive a stream").option("--path <path>", "Project root path", ".").action(async (name, opts) => {
-    const projectPath = path27.resolve(opts.path);
+    const projectPath = path30.resolve(opts.path);
     const result = await archiveStream(projectPath, name);
     if (!result.ok) {
       logger.error(result.error.message);
@@ -3393,7 +3735,7 @@ function createStreamsCommand() {
     process.exit(ExitCode.SUCCESS);
   });
   command.command("activate <name>").description("Set the active stream").option("--path <path>", "Project root path", ".").action(async (name, opts) => {
-    const projectPath = path27.resolve(opts.path);
+    const projectPath = path30.resolve(opts.path);
     const result = await setActiveStream(projectPath, name);
     if (!result.ok) {
       logger.error(result.error.message);
@@ -3418,18 +3760,17 @@ function createStateCommand() {
 
 // src/commands/check-phase-gate.ts
 import { Command as Command31 } from "commander";
-import * as path28 from "path";
-import * as fs16 from "fs";
-import { Ok as Ok18 } from "@harness-engineering/core";
+import * as path31 from "path";
+import * as fs19 from "fs";
 function resolveSpecPath(implFile, implPattern, specPattern, cwd) {
-  const relImpl = path28.relative(cwd, implFile);
+  const relImpl = path31.relative(cwd, implFile);
   const implBase = (implPattern.split("*")[0] ?? "").replace(/\/+$/, "");
   const afterBase = relImpl.startsWith(implBase + "/") ? relImpl.slice(implBase.length + 1) : relImpl;
   const segments = afterBase.split("/");
   const firstSegment = segments[0] ?? "";
-  const feature = segments.length > 1 ? firstSegment : path28.basename(firstSegment, path28.extname(firstSegment));
+  const feature = segments.length > 1 ? firstSegment : path31.basename(firstSegment, path31.extname(firstSegment));
   const specRelative = specPattern.replace("{feature}", feature);
-  return path28.resolve(cwd, specRelative);
+  return path31.resolve(cwd, specRelative);
 }
 async function runCheckPhaseGate(options) {
   const configResult = resolveConfig(options.configPath);
@@ -3437,9 +3778,9 @@ async function runCheckPhaseGate(options) {
     return configResult;
   }
   const config = configResult.value;
-  const cwd = options.cwd ?? (options.configPath ? path28.dirname(path28.resolve(options.configPath)) : process.cwd());
+  const cwd = options.cwd ?? (options.configPath ? path31.dirname(path31.resolve(options.configPath)) : process.cwd());
   if (!config.phaseGates?.enabled) {
-    return Ok18({
+    return Ok({
       pass: true,
       skipped: true,
       missingSpecs: [],
@@ -3454,16 +3795,16 @@ async function runCheckPhaseGate(options) {
     for (const implFile of implFiles) {
       checkedFiles++;
       const expectedSpec = resolveSpecPath(implFile, mapping.implPattern, mapping.specPattern, cwd);
-      if (!fs16.existsSync(expectedSpec)) {
+      if (!fs19.existsSync(expectedSpec)) {
         missingSpecs.push({
-          implFile: path28.relative(cwd, implFile),
-          expectedSpec: path28.relative(cwd, expectedSpec)
+          implFile: path31.relative(cwd, implFile),
+          expectedSpec: path31.relative(cwd, expectedSpec)
         });
       }
     }
   }
   const pass = missingSpecs.length === 0;
-  return Ok18({
+  return Ok({
     pass,
     skipped: false,
     severity: phaseGates.severity,
@@ -3527,15 +3868,15 @@ function createCheckPhaseGateCommand() {
 
 // src/commands/generate-slash-commands.ts
 import { Command as Command32 } from "commander";
-import fs19 from "fs";
-import path31 from "path";
+import fs22 from "fs";
+import path34 from "path";
 import os2 from "os";
 import readline2 from "readline";
 
 // src/slash-commands/normalize.ts
-import fs17 from "fs";
-import path29 from "path";
-import { parse as parse7 } from "yaml";
+import fs20 from "fs";
+import path32 from "path";
+import { parse as parse8 } from "yaml";
 
 // src/slash-commands/normalize-name.ts
 function normalizeName(skillName) {
@@ -3555,18 +3896,18 @@ function normalizeSkills(skillSources, platforms) {
   const specs = [];
   const nameMap = /* @__PURE__ */ new Map();
   for (const { dir: skillsDir, source } of skillSources) {
-    if (!fs17.existsSync(skillsDir)) continue;
-    const entries = fs17.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory());
+    if (!fs20.existsSync(skillsDir)) continue;
+    const entries = fs20.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory());
     for (const entry of entries) {
-      const yamlPath = path29.join(skillsDir, entry.name, "skill.yaml");
-      if (!fs17.existsSync(yamlPath)) continue;
+      const yamlPath = path32.join(skillsDir, entry.name, "skill.yaml");
+      if (!fs20.existsSync(yamlPath)) continue;
       let raw;
       try {
-        raw = fs17.readFileSync(yamlPath, "utf-8");
+        raw = fs20.readFileSync(yamlPath, "utf-8");
       } catch {
         continue;
       }
-      const parsed = parse7(raw);
+      const parsed = parse8(raw);
       const result = SkillMetadataSchema.safeParse(parsed);
       if (!result.success) {
         console.warn(`Skipping ${entry.name}: invalid skill.yaml`);
@@ -3586,15 +3927,15 @@ function normalizeSkills(skillSources, platforms) {
         continue;
       }
       nameMap.set(normalized, { skillName: meta.name, source });
-      const skillMdPath = path29.join(skillsDir, entry.name, "SKILL.md");
-      const skillMdContent = fs17.existsSync(skillMdPath) ? fs17.readFileSync(skillMdPath, "utf-8") : "";
-      const skillMdRelative = path29.relative(
+      const skillMdPath = path32.join(skillsDir, entry.name, "SKILL.md");
+      const skillMdContent = fs20.existsSync(skillMdPath) ? fs20.readFileSync(skillMdPath, "utf-8") : "";
+      const skillMdRelative = path32.relative(
         process.cwd(),
-        path29.join(skillsDir, entry.name, "SKILL.md")
+        path32.join(skillsDir, entry.name, "SKILL.md")
       );
-      const skillYamlRelative = path29.relative(
+      const skillYamlRelative = path32.relative(
         process.cwd(),
-        path29.join(skillsDir, entry.name, "skill.yaml")
+        path32.join(skillsDir, entry.name, "skill.yaml")
       );
       const args = (meta.cli?.args ?? []).map((a) => ({
         name: a.name,
@@ -3763,8 +4104,8 @@ function renderGemini(spec, skillMdContent, skillYamlContent) {
 }
 
 // src/slash-commands/sync.ts
-import fs18 from "fs";
-import path30 from "path";
+import fs21 from "fs";
+import path33 from "path";
 
 // src/agent-definitions/constants.ts
 var GENERATED_HEADER_AGENT = "<!-- Generated by harness generate-agent-definitions. Do not edit. -->";
@@ -3776,11 +4117,11 @@ function computeSyncPlan(outputDir, rendered) {
   const removed = [];
   const unchanged = [];
   for (const [filename, content] of rendered) {
-    const filePath = path30.join(outputDir, filename);
-    if (!fs18.existsSync(filePath)) {
+    const filePath = path33.join(outputDir, filename);
+    if (!fs21.existsSync(filePath)) {
       added.push(filename);
     } else {
-      const existing = fs18.readFileSync(filePath, "utf-8");
+      const existing = fs21.readFileSync(filePath, "utf-8");
       if (existing === content) {
         unchanged.push(filename);
       } else {
@@ -3788,14 +4129,14 @@ function computeSyncPlan(outputDir, rendered) {
       }
     }
   }
-  if (fs18.existsSync(outputDir)) {
-    const existing = fs18.readdirSync(outputDir).filter((f) => {
-      const stat = fs18.statSync(path30.join(outputDir, f));
+  if (fs21.existsSync(outputDir)) {
+    const existing = fs21.readdirSync(outputDir).filter((f) => {
+      const stat = fs21.statSync(path33.join(outputDir, f));
       return stat.isFile();
     });
     for (const filename of existing) {
       if (rendered.has(filename)) continue;
-      const content = fs18.readFileSync(path30.join(outputDir, filename), "utf-8");
+      const content = fs21.readFileSync(path33.join(outputDir, filename), "utf-8");
       if (content.includes(GENERATED_HEADER_CLAUDE) || content.includes(GENERATED_HEADER_GEMINI) || content.includes(GENERATED_HEADER_AGENT)) {
         removed.push(filename);
       }
@@ -3804,18 +4145,18 @@ function computeSyncPlan(outputDir, rendered) {
   return { added, updated, removed, unchanged };
 }
 function applySyncPlan(outputDir, rendered, plan, deleteOrphans) {
-  fs18.mkdirSync(outputDir, { recursive: true });
+  fs21.mkdirSync(outputDir, { recursive: true });
   for (const filename of [...plan.added, ...plan.updated]) {
     const content = rendered.get(filename);
     if (content !== void 0) {
-      fs18.writeFileSync(path30.join(outputDir, filename), content);
+      fs21.writeFileSync(path33.join(outputDir, filename), content);
     }
   }
   if (deleteOrphans) {
     for (const filename of plan.removed) {
-      const filePath = path30.join(outputDir, filename);
-      if (fs18.existsSync(filePath)) {
-        fs18.unlinkSync(filePath);
+      const filePath = path33.join(outputDir, filename);
+      if (fs21.existsSync(filePath)) {
+        fs21.unlinkSync(filePath);
       }
     }
   }
@@ -3824,24 +4165,24 @@ function applySyncPlan(outputDir, rendered, plan, deleteOrphans) {
 // src/commands/generate-slash-commands.ts
 function resolveOutputDir(platform, opts) {
   if (opts.output) {
-    return path31.join(opts.output, "harness");
+    return path34.join(opts.output, "harness");
   }
   if (opts.global) {
     const home = os2.homedir();
-    return platform === "claude-code" ? path31.join(home, ".claude", "commands", "harness") : path31.join(home, ".gemini", "commands", "harness");
+    return platform === "claude-code" ? path34.join(home, ".claude", "commands", "harness") : path34.join(home, ".gemini", "commands", "harness");
   }
-  return platform === "claude-code" ? path31.join("agents", "commands", "claude-code", "harness") : path31.join("agents", "commands", "gemini-cli", "harness");
+  return platform === "claude-code" ? path34.join("agents", "commands", "claude-code", "harness") : path34.join("agents", "commands", "gemini-cli", "harness");
 }
 function fileExtension(platform) {
   return platform === "claude-code" ? ".md" : ".toml";
 }
 async function confirmDeletion(files) {
   const rl = readline2.createInterface({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve22) => {
+  return new Promise((resolve24) => {
     rl.question(`
 Remove ${files.length} orphaned command(s)? (y/N) `, (answer) => {
       rl.close();
-      resolve22(answer.toLowerCase() === "y");
+      resolve24(answer.toLowerCase() === "y");
     });
   });
 }
@@ -3856,7 +4197,7 @@ function generateSlashCommands(opts) {
     }
     if (opts.includeGlobal || skillSources.length === 0) {
       const globalDir = resolveGlobalSkillsDir();
-      if (!projectDir || path31.resolve(globalDir) !== path31.resolve(projectDir)) {
+      if (!projectDir || path34.resolve(globalDir) !== path34.resolve(projectDir)) {
         skillSources.push({ dir: globalDir, source: "global" });
       }
     }
@@ -3878,7 +4219,7 @@ function generateSlashCommands(opts) {
             executionContext: spec.prompt.executionContext.split("\n").map((line) => {
               if (line.startsWith("@")) {
                 const relPath = line.slice(1);
-                return `@${path31.resolve(relPath)}`;
+                return `@${path34.resolve(relPath)}`;
               }
               return line;
             }).join("\n")
@@ -3886,10 +4227,10 @@ function generateSlashCommands(opts) {
         } : spec;
         rendered.set(filename, renderClaudeCode(renderSpec));
       } else {
-        const mdPath = path31.join(spec.skillsBaseDir, spec.sourceDir, "SKILL.md");
-        const yamlPath = path31.join(spec.skillsBaseDir, spec.sourceDir, "skill.yaml");
-        const mdContent = fs19.existsSync(mdPath) ? fs19.readFileSync(mdPath, "utf-8") : "";
-        const yamlContent = fs19.existsSync(yamlPath) ? fs19.readFileSync(yamlPath, "utf-8") : "";
+        const mdPath = path34.join(spec.skillsBaseDir, spec.sourceDir, "SKILL.md");
+        const yamlPath = path34.join(spec.skillsBaseDir, spec.sourceDir, "skill.yaml");
+        const mdContent = fs22.existsSync(mdPath) ? fs22.readFileSync(mdPath, "utf-8") : "";
+        const yamlContent = fs22.existsSync(yamlPath) ? fs22.readFileSync(yamlPath, "utf-8") : "";
         rendered.set(filename, renderGemini(spec, mdContent, yamlContent));
       }
     }
@@ -3915,9 +4256,9 @@ async function handleOrphanDeletion(results, opts) {
     const shouldDelete = opts.yes || await confirmDeletion(result.removed);
     if (shouldDelete) {
       for (const filename of result.removed) {
-        const filePath = path31.join(result.outputDir, filename);
-        if (fs19.existsSync(filePath)) {
-          fs19.unlinkSync(filePath);
+        const filePath = path34.join(result.outputDir, filename);
+        if (fs22.existsSync(filePath)) {
+          fs22.unlinkSync(filePath);
         }
       }
     }
@@ -3993,7 +4334,6 @@ import { Command as Command35 } from "commander";
 
 // src/commands/ci/check.ts
 import { Command as Command33 } from "commander";
-import { runCIChecks } from "@harness-engineering/core";
 var VALID_CHECKS = ["validate", "deps", "docs", "entropy", "phase-gate"];
 async function runCICheck(options) {
   const configResult = resolveConfig(options.configPath);
@@ -4069,9 +4409,8 @@ function createCheckCommand() {
 
 // src/commands/ci/init.ts
 import { Command as Command34 } from "commander";
-import * as fs20 from "fs";
-import * as path32 from "path";
-import { Ok as Ok19, Err as Err14 } from "@harness-engineering/core";
+import * as fs23 from "fs";
+import * as path35 from "path";
 var ALL_CHECKS = ["validate", "deps", "docs", "entropy", "phase-gate"];
 function buildSkipFlag(checks) {
   if (!checks) return "";
@@ -4155,16 +4494,16 @@ function generateCIConfig(options) {
   };
   const entry = generators[platform];
   if (!entry) {
-    return Err14(new CLIError(`Unknown platform: ${platform}`, ExitCode.ERROR));
+    return Err(new CLIError(`Unknown platform: ${platform}`, ExitCode.ERROR));
   }
-  return Ok19({
+  return Ok({
     filename: entry.filename,
     content: entry.generate(skipFlag)
   });
 }
 function detectPlatform() {
-  if (fs20.existsSync(".github")) return "github";
-  if (fs20.existsSync(".gitlab-ci.yml")) return "gitlab";
+  if (fs23.existsSync(".github")) return "github";
+  if (fs23.existsSync(".gitlab-ci.yml")) return "gitlab";
   return null;
 }
 function createInitCommand2() {
@@ -4180,12 +4519,12 @@ function createInitCommand2() {
       process.exit(result.error.exitCode);
     }
     const { filename, content } = result.value;
-    const targetPath = path32.resolve(filename);
-    const dir = path32.dirname(targetPath);
-    fs20.mkdirSync(dir, { recursive: true });
-    fs20.writeFileSync(targetPath, content);
+    const targetPath = path35.resolve(filename);
+    const dir = path35.dirname(targetPath);
+    fs23.mkdirSync(dir, { recursive: true });
+    fs23.writeFileSync(targetPath, content);
     if (platform === "generic") {
-      fs20.chmodSync(targetPath, "755");
+      fs23.chmodSync(targetPath, "755");
     }
     if (globalOpts.json) {
       console.log(JSON.stringify({ file: filename, platform }));
@@ -4206,7 +4545,7 @@ function createCICommand() {
 
 // src/commands/update.ts
 import { Command as Command36 } from "commander";
-import { execSync as execSync4 } from "child_process";
+import { execFileSync as execFileSync3 } from "child_process";
 import { realpathSync } from "fs";
 import readline3 from "readline";
 import chalk4 from "chalk";
@@ -4226,7 +4565,7 @@ function detectPackageManager() {
   return "npm";
 }
 function getLatestVersion(pkg = "@harness-engineering/cli") {
-  const output = execSync4(`npm view ${pkg} dist-tags.latest`, {
+  const output = execFileSync3("npm", ["view", pkg, "dist-tags.latest"], {
     encoding: "utf-8",
     timeout: 15e3
   });
@@ -4234,7 +4573,7 @@ function getLatestVersion(pkg = "@harness-engineering/cli") {
 }
 function getInstalledVersion(pm) {
   try {
-    const output = execSync4(`${pm} list -g @harness-engineering/cli --json`, {
+    const output = execFileSync3(pm, ["list", "-g", "@harness-engineering/cli", "--json"], {
       encoding: "utf-8",
       timeout: 15e3
     });
@@ -4247,7 +4586,7 @@ function getInstalledVersion(pm) {
 }
 function getInstalledPackages(pm) {
   try {
-    const output = execSync4(`${pm} list -g --json`, {
+    const output = execFileSync3(pm, ["list", "-g", "--json"], {
       encoding: "utf-8",
       timeout: 15e3
     });
@@ -4263,10 +4602,10 @@ function prompt(question) {
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve22) => {
+  return new Promise((resolve24) => {
     rl.question(question, (answer) => {
       rl.close();
-      resolve22(answer.trim().toLowerCase());
+      resolve24(answer.trim().toLowerCase());
     });
   });
 }
@@ -4302,19 +4641,19 @@ function createUpdateCommand() {
     if (globalOpts.verbose) {
       logger.info(`Installed packages: ${packages.join(", ")}`);
     }
-    const installArgs = packages.map((pkg) => {
+    const installPkgs = packages.map((pkg) => {
       if (opts.version && pkg === "@harness-engineering/cli") {
         return `${pkg}@${opts.version}`;
       }
       return `${pkg}@latest`;
-    }).join(" ");
-    const installCmd = `${pm} install -g ${installArgs}`;
+    });
+    const installCmd = `${pm} install -g ${installPkgs.join(" ")}`;
     if (globalOpts.verbose) {
       logger.info(`Running: ${installCmd}`);
     }
     try {
       logger.info("Updating packages...");
-      execSync4(installCmd, { stdio: "inherit", timeout: 12e4 });
+      execFileSync3(pm, ["install", "-g", ...installPkgs], { stdio: "inherit", timeout: 12e4 });
       console.log("");
       logger.success("Update complete");
     } catch {
@@ -4327,12 +4666,14 @@ function createUpdateCommand() {
     const regenAnswer = await prompt("Regenerate slash commands and agent definitions? (y/N) ");
     if (regenAnswer === "y" || regenAnswer === "yes") {
       const scopeAnswer = await prompt("Generate for (g)lobal or (l)ocal project? (g/l) ");
-      const globalFlag = scopeAnswer === "g" || scopeAnswer === "global" ? " --global" : "";
+      const isGlobal = scopeAnswer === "g" || scopeAnswer === "global";
       try {
-        execSync4(`harness generate${globalFlag}`, { stdio: "inherit" });
+        execFileSync3("harness", ["generate", ...isGlobal ? ["--global"] : []], {
+          stdio: "inherit"
+        });
       } catch {
         logger.warn("Generation failed. Run manually:");
-        console.log(`  ${chalk4.cyan(`harness generate${globalFlag}`)}`);
+        console.log(`  ${chalk4.cyan(`harness generate${isGlobal ? " --global" : ""}`)}`);
       }
     }
     process.exit(ExitCode.SUCCESS);
@@ -4341,8 +4682,8 @@ function createUpdateCommand() {
 
 // src/commands/generate-agent-definitions.ts
 import { Command as Command37 } from "commander";
-import * as fs21 from "fs";
-import * as path33 from "path";
+import * as fs24 from "fs";
+import * as path36 from "path";
 import * as os3 from "os";
 
 // src/agent-definitions/generator.ts
@@ -4352,7 +4693,9 @@ var AGENT_DESCRIPTIONS = {
   "parallel-coordinator": "Dispatch independent tasks across isolated agents for parallel execution. Use when multiple independent tasks need to run concurrently, splitting work across agents, or coordinating parallel implementation.",
   "architecture-enforcer": "Validate architectural constraints and dependency rules. Use when checking layer boundaries, detecting circular dependencies, or verifying import direction compliance.",
   "documentation-maintainer": "Keep documentation in sync with source code. Use when detecting documentation drift, validating doc coverage, or aligning docs with code changes.",
-  "entropy-cleaner": "Detect and fix codebase entropy including drift, dead code, and pattern violations. Use when running cleanup, detecting dead code, or fixing pattern violations."
+  "entropy-cleaner": "Detect and fix codebase entropy including drift, dead code, and pattern violations. Use when running cleanup, detecting dead code, or fixing pattern violations.",
+  planner: "Create detailed implementation plans from specs with task breakdown, dependency ordering, and checkpoint placement. Use when planning a phase, breaking a spec into tasks, or creating an execution plan.",
+  verifier: "Verify implementation completeness against spec and plan at three tiers (EXISTS, SUBSTANTIVE, WIRED). Use when checking if built code matches what was planned, validating phase completion, or auditing implementation quality."
 };
 var DEFAULT_TOOLS = ["Bash", "Read", "Write", "Edit", "Glob", "Grep"];
 function generateAgentDefinition(persona, skillContents) {
@@ -4445,7 +4788,12 @@ function renderGeminiAgent(def) {
   lines.push(`name: ${def.name}`);
   lines.push(`description: >`);
   lines.push(`  ${def.description}`);
-  lines.push(`tools: ${def.tools.join(", ")}`);
+  if (def.tools.length > 0) {
+    lines.push("tools:");
+    for (const tool of def.tools) {
+      lines.push(`  - ${tool}`);
+    }
+  }
   lines.push("---");
   lines.push("");
   lines.push(GENERATED_HEADER_AGENT);
@@ -4478,19 +4826,19 @@ function renderGeminiAgent(def) {
 // src/commands/generate-agent-definitions.ts
 function resolveOutputDir2(platform, opts) {
   if (opts.output) {
-    return platform === "claude-code" ? path33.join(opts.output, "claude-code") : path33.join(opts.output, "gemini-cli");
+    return platform === "claude-code" ? path36.join(opts.output, "claude-code") : path36.join(opts.output, "gemini-cli");
   }
   if (opts.global) {
     const home = os3.homedir();
-    return platform === "claude-code" ? path33.join(home, ".claude", "agents") : path33.join(home, ".gemini", "agents");
+    return platform === "claude-code" ? path36.join(home, ".claude", "agents") : path36.join(home, ".gemini", "agents");
   }
-  return platform === "claude-code" ? path33.join("agents", "agents", "claude-code") : path33.join("agents", "agents", "gemini-cli");
+  return platform === "claude-code" ? path36.join("agents", "agents", "claude-code") : path36.join("agents", "agents", "gemini-cli");
 }
 function loadSkillContent(skillName) {
   const skillsDir = resolveSkillsDir();
-  const skillMdPath = path33.join(skillsDir, skillName, "SKILL.md");
-  if (!fs21.existsSync(skillMdPath)) return null;
-  return fs21.readFileSync(skillMdPath, "utf-8");
+  const skillMdPath = path36.join(skillsDir, skillName, "SKILL.md");
+  if (!fs24.existsSync(skillMdPath)) return null;
+  return fs24.readFileSync(skillMdPath, "utf-8");
 }
 function getRenderer(platform) {
   return platform === "claude-code" ? renderClaudeCodeAgent : renderGeminiAgent;
@@ -4644,9 +4992,9 @@ function createGenerateCommand3() {
 
 // src/commands/graph/scan.ts
 import { Command as Command39 } from "commander";
-import * as path34 from "path";
+import * as path37 from "path";
 async function runScan(projectPath) {
-  const { GraphStore, CodeIngestor, TopologicalLinker, KnowledgeIngestor, GitIngestor } = await import("@harness-engineering/graph");
+  const { GraphStore, CodeIngestor, TopologicalLinker, KnowledgeIngestor, GitIngestor } = await import("./dist-N4D4QWFV.js");
   const store = new GraphStore();
   const start = Date.now();
   await new CodeIngestor(store).ingest(projectPath);
@@ -4657,13 +5005,13 @@ async function runScan(projectPath) {
     await new GitIngestor(store).ingest(projectPath);
   } catch {
   }
-  const graphDir = path34.join(projectPath, ".harness", "graph");
+  const graphDir = path37.join(projectPath, ".harness", "graph");
   await store.save(graphDir);
   return { nodeCount: store.nodeCount, edgeCount: store.edgeCount, durationMs: Date.now() - start };
 }
 function createScanCommand() {
   return new Command39("scan").description("Scan project and build knowledge graph").argument("[path]", "Project root path", ".").action(async (inputPath, _opts, cmd) => {
-    const projectPath = path34.resolve(inputPath);
+    const projectPath = path37.resolve(inputPath);
     const globalOpts = cmd.optsWithGlobals();
     try {
       const result = await runScan(projectPath);
@@ -4683,12 +5031,12 @@ function createScanCommand() {
 
 // src/commands/graph/ingest.ts
 import { Command as Command40 } from "commander";
-import * as path35 from "path";
+import * as path38 from "path";
 async function loadConnectorConfig(projectPath, source) {
   try {
-    const fs22 = await import("fs/promises");
-    const configPath = path35.join(projectPath, "harness.config.json");
-    const config = JSON.parse(await fs22.readFile(configPath, "utf-8"));
+    const fs25 = await import("fs/promises");
+    const configPath = path38.join(projectPath, "harness.config.json");
+    const config = JSON.parse(await fs25.readFile(configPath, "utf-8"));
     const connector = config.graph?.connectors?.find(
       (c) => c.source === source
     );
@@ -4727,8 +5075,8 @@ async function runIngest(projectPath, source, opts) {
     SyncManager,
     JiraConnector,
     SlackConnector
-  } = await import("@harness-engineering/graph");
-  const graphDir = path35.join(projectPath, ".harness", "graph");
+  } = await import("./dist-N4D4QWFV.js");
+  const graphDir = path38.join(projectPath, ".harness", "graph");
   const store = new GraphStore();
   await store.load(graphDir);
   if (opts?.all) {
@@ -4795,7 +5143,7 @@ function createIngestCommand() {
       process.exit(1);
     }
     const globalOpts = cmd.optsWithGlobals();
-    const projectPath = path35.resolve(globalOpts.config ? path35.dirname(globalOpts.config) : ".");
+    const projectPath = path38.resolve(globalOpts.config ? path38.dirname(globalOpts.config) : ".");
     try {
       const result = await runIngest(projectPath, opts.source ?? "", {
         full: opts.full,
@@ -4818,11 +5166,11 @@ function createIngestCommand() {
 
 // src/commands/graph/query.ts
 import { Command as Command41 } from "commander";
-import * as path36 from "path";
+import * as path39 from "path";
 async function runQuery(projectPath, rootNodeId, opts) {
-  const { GraphStore, ContextQL } = await import("@harness-engineering/graph");
+  const { GraphStore, ContextQL } = await import("./dist-N4D4QWFV.js");
   const store = new GraphStore();
-  const graphDir = path36.join(projectPath, ".harness", "graph");
+  const graphDir = path39.join(projectPath, ".harness", "graph");
   const loaded = await store.load(graphDir);
   if (!loaded) throw new Error("No graph found. Run `harness scan` first.");
   const params = {
@@ -4838,7 +5186,7 @@ async function runQuery(projectPath, rootNodeId, opts) {
 function createQueryCommand() {
   return new Command41("query").description("Query the knowledge graph").argument("<rootNodeId>", "Starting node ID").option("--depth <n>", "Max traversal depth", "3").option("--types <types>", "Comma-separated node types to include").option("--edges <edges>", "Comma-separated edge types to include").option("--bidirectional", "Traverse both directions").action(async (rootNodeId, opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
-    const projectPath = path36.resolve(globalOpts.config ? path36.dirname(globalOpts.config) : ".");
+    const projectPath = path39.resolve(globalOpts.config ? path39.dirname(globalOpts.config) : ".");
     try {
       const result = await runQuery(projectPath, rootNodeId, {
         depth: parseInt(opts.depth),
@@ -4867,18 +5215,18 @@ function createQueryCommand() {
 import { Command as Command42 } from "commander";
 
 // src/commands/graph/status.ts
-import * as path37 from "path";
+import * as path40 from "path";
 async function runGraphStatus(projectPath) {
-  const { GraphStore } = await import("@harness-engineering/graph");
-  const graphDir = path37.join(projectPath, ".harness", "graph");
+  const { GraphStore } = await import("./dist-N4D4QWFV.js");
+  const graphDir = path40.join(projectPath, ".harness", "graph");
   const store = new GraphStore();
   const loaded = await store.load(graphDir);
   if (!loaded) return { status: "no_graph", message: "No graph found. Run `harness scan` first." };
-  const fs22 = await import("fs/promises");
-  const metaPath = path37.join(graphDir, "metadata.json");
+  const fs25 = await import("fs/promises");
+  const metaPath = path40.join(graphDir, "metadata.json");
   let lastScan = "unknown";
   try {
-    const meta = JSON.parse(await fs22.readFile(metaPath, "utf-8"));
+    const meta = JSON.parse(await fs25.readFile(metaPath, "utf-8"));
     lastScan = meta.lastScanTimestamp;
   } catch {
   }
@@ -4889,8 +5237,8 @@ async function runGraphStatus(projectPath) {
   }
   let connectorSyncStatus = {};
   try {
-    const syncMetaPath = path37.join(graphDir, "sync-metadata.json");
-    const syncMeta = JSON.parse(await fs22.readFile(syncMetaPath, "utf-8"));
+    const syncMetaPath = path40.join(graphDir, "sync-metadata.json");
+    const syncMeta = JSON.parse(await fs25.readFile(syncMetaPath, "utf-8"));
     for (const [name, data] of Object.entries(syncMeta.connectors ?? {})) {
       connectorSyncStatus[name] = data.lastSyncTimestamp;
     }
@@ -4907,10 +5255,10 @@ async function runGraphStatus(projectPath) {
 }
 
 // src/commands/graph/export.ts
-import * as path38 from "path";
+import * as path41 from "path";
 async function runGraphExport(projectPath, format) {
-  const { GraphStore } = await import("@harness-engineering/graph");
-  const graphDir = path38.join(projectPath, ".harness", "graph");
+  const { GraphStore } = await import("./dist-N4D4QWFV.js");
+  const graphDir = path41.join(projectPath, ".harness", "graph");
   const store = new GraphStore();
   const loaded = await store.load(graphDir);
   if (!loaded) throw new Error("No graph found. Run `harness scan` first.");
@@ -4939,13 +5287,13 @@ async function runGraphExport(projectPath, format) {
 }
 
 // src/commands/graph/index.ts
-import * as path39 from "path";
+import * as path42 from "path";
 function createGraphCommand() {
   const graph = new Command42("graph").description("Knowledge graph management");
   graph.command("status").description("Show graph statistics").action(async (_opts, cmd) => {
     try {
       const globalOpts = cmd.optsWithGlobals();
-      const projectPath = path39.resolve(globalOpts.config ? path39.dirname(globalOpts.config) : ".");
+      const projectPath = path42.resolve(globalOpts.config ? path42.dirname(globalOpts.config) : ".");
       const result = await runGraphStatus(projectPath);
       if (globalOpts.json) {
         console.log(JSON.stringify(result, null, 2));
@@ -4972,7 +5320,7 @@ function createGraphCommand() {
   });
   graph.command("export").description("Export graph").requiredOption("--format <format>", "Output format (json, mermaid)").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
-    const projectPath = path39.resolve(globalOpts.config ? path39.dirname(globalOpts.config) : ".");
+    const projectPath = path42.resolve(globalOpts.config ? path42.dirname(globalOpts.config) : ".");
     try {
       const output = await runGraphExport(projectPath, opts.format);
       console.log(output);