@harness-engineering/cli 1.8.2 → 1.10.0

package/dist/{chunk-Y7U5AYAL.js → chunk-PAHHT2IK.js}

@@ -1,9 +1,80 @@
+import {
+  generateCIWorkflow
+} from "./chunk-VUCPTQ6G.js";
+import {
+  OutputFormatter,
+  OutputMode,
+  createCheckPhaseGateCommand,
+  findFiles,
+  resolveConfig
+} from "./chunk-7X7ZAYMY.js";
+import {
+  createGenerateAgentDefinitionsCommand,
+  generateAgentDefinitions
+} from "./chunk-46YA6FI3.js";
+import {
+  listPersonas,
+  loadPersona
+} from "./chunk-Q6AB7W5Z.js";
+import {
+  runPersona
+} from "./chunk-TRAPF4IX.js";
+import {
+  executeSkill
+} from "./chunk-F3YDAJFQ.js";
+import {
+  ALLOWED_PERSONA_COMMANDS
+} from "./chunk-TEFCFC4H.js";
+import {
+  createCreateSkillCommand
+} from "./chunk-ECUJQS3B.js";
+import {
+  logger
+} from "./chunk-HIOXKZYF.js";
+import {
+  generate,
+  validate
+} from "./chunk-QPEH2QPG.js";
+import {
+  generateRuntime
+} from "./chunk-JSTQ3AWB.js";
+import {
+  toKebabCase
+} from "./chunk-KET4QQZB.js";
+import {
+  generateAgentsMd
+} from "./chunk-NKDM3FMH.js";
+import {
+  createGenerateSlashCommandsCommand,
+  generateSlashCommands,
+  handleOrphanDeletion
+} from "./chunk-LXU5M77O.js";
+import {
+  VALID_PLATFORMS
+} from "./chunk-ZOAWBDWU.js";
+import {
+  resolvePersonasDir,
+  resolveSkillsDir,
+  resolveTemplatesDir
+} from "./chunk-EOLRW32Q.js";
+import {
+  CLIError,
+  ExitCode,
+  handleError
+} from "./chunk-B7HFEHWP.js";
+import {
+  SkillMetadataSchema
+} from "./chunk-MDUK2J2O.js";
+import {
+  CLI_VERSION
+} from "./chunk-BM3PWGXQ.js";
+import {
+  TemplateEngine
+} from "./chunk-C2ERUR3L.js";
 import {
   BaselineManager,
   CriticalPathResolver,
   EntropyAnalyzer,
-  Err,
-  Ok,
   SecurityScanner,
   TypeScriptParser,
   appendLearning,
@@ -31,277 +102,25 @@ import {
   validateAgentsMap,
   validateDependencies,
   validateKnowledgeMap
-} from "./chunk-SAB3VXOW.js";
+} from "./chunk-NX6DSZSM.js";
 import {
-  CLIError,
-  ExitCode,
-  SkillMetadataSchema,
-  createCreateSkillCommand,
-  handleError,
-  logger
-} from "./chunk-ULSRSP53.js";
+  Err,
+  Ok
+} from "./chunk-MHBMTPW7.js";
 
 // src/index.ts
-import { Command as Command43 } from "commander";
-
-// src/version.ts
-import { createRequire } from "module";
-var require_ = createRequire(import.meta.url);
-var resolved;
-try {
-  resolved = require_("../package.json").version ?? "0.0.0";
-} catch {
-  resolved = "0.0.0";
-}
-var CLI_VERSION = resolved;
+import { Command as Command41 } from "commander";
 
 // src/commands/validate.ts
 import { Command } from "commander";
-import * as path2 from "path";
-
-// src/config/loader.ts
-import * as fs from "fs";
 import * as path from "path";
-
-// src/config/schema.ts
-import { z } from "zod";
-var LayerSchema = z.object({
-  name: z.string(),
-  pattern: z.string(),
-  allowedDependencies: z.array(z.string())
-});
-var ForbiddenImportSchema = z.object({
-  from: z.string(),
-  disallow: z.array(z.string()),
-  message: z.string().optional()
-});
-var BoundaryConfigSchema = z.object({
-  requireSchema: z.array(z.string())
-});
-var AgentConfigSchema = z.object({
-  executor: z.enum(["subprocess", "cloud", "noop"]).default("subprocess"),
-  timeout: z.number().default(3e5),
-  skills: z.array(z.string()).optional()
-});
-var EntropyConfigSchema = z.object({
-  excludePatterns: z.array(z.string()).default(["**/node_modules/**", "**/*.test.ts"]),
-  autoFix: z.boolean().default(false)
-});
-var PhaseGateMappingSchema = z.object({
-  implPattern: z.string(),
-  specPattern: z.string()
-});
-var PhaseGatesConfigSchema = z.object({
-  enabled: z.boolean().default(false),
-  severity: z.enum(["error", "warning"]).default("error"),
-  mappings: z.array(PhaseGateMappingSchema).default([{ implPattern: "src/**/*.ts", specPattern: "docs/changes/{feature}/proposal.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 I18nCoverageConfigSchema = z.object({
-  minimumPercent: z.number().min(0).max(100).default(100),
-  requirePlurals: z.boolean().default(true),
-  detectUntranslated: z.boolean().default(true)
-});
-var I18nMcpConfigSchema = z.object({
-  server: z.string(),
-  projectId: z.string().optional()
-});
-var I18nConfigSchema = z.object({
-  enabled: z.boolean().default(false),
-  strictness: z.enum(["strict", "standard", "permissive"]).default("standard"),
-  sourceLocale: z.string().default("en"),
-  targetLocales: z.array(z.string()).default([]),
-  framework: z.enum([
-    "auto",
-    "i18next",
-    "react-intl",
-    "vue-i18n",
-    "flutter-intl",
-    "apple",
-    "android",
-    "custom"
-  ]).default("auto"),
-  format: z.string().default("json"),
-  messageFormat: z.enum(["icu", "i18next", "custom"]).default("icu"),
-  keyConvention: z.enum(["dot-notation", "snake_case", "camelCase", "custom"]).default("dot-notation"),
-  translationPaths: z.record(z.string(), z.string()).optional(),
-  platforms: z.array(z.enum(["web", "mobile", "backend"])).default([]),
-  industry: z.string().optional(),
-  coverage: I18nCoverageConfigSchema.optional(),
-  pseudoLocale: z.string().optional(),
-  mcp: I18nMcpConfigSchema.optional()
-});
-var ModelTierConfigSchema = z.object({
-  fast: z.string().optional(),
-  standard: z.string().optional(),
-  strong: z.string().optional()
-});
-var ReviewConfigSchema = z.object({
-  model_tiers: ModelTierConfigSchema.optional()
-});
-var HarnessConfigSchema = z.object({
-  version: z.literal(1),
-  name: z.string().optional(),
-  rootDir: z.string().default("."),
-  layers: z.array(LayerSchema).optional(),
-  forbiddenImports: z.array(ForbiddenImportSchema).optional(),
-  boundaries: BoundaryConfigSchema.optional(),
-  agentsMapPath: z.string().default("./AGENTS.md"),
-  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(),
-  design: DesignConfigSchema.optional(),
-  i18n: I18nConfigSchema.optional(),
-  review: ReviewConfigSchema.optional(),
-  updateCheckInterval: z.number().int().min(0).optional()
-});
-
-// src/config/loader.ts
-var CONFIG_FILENAMES = ["harness.config.json"];
-function findConfigFile(startDir = process.cwd()) {
-  let currentDir = path.resolve(startDir);
-  const root = path.parse(currentDir).root;
-  while (currentDir !== root) {
-    for (const filename of CONFIG_FILENAMES) {
-      const configPath = path.join(currentDir, filename);
-      if (fs.existsSync(configPath)) {
-        return Ok(configPath);
-      }
-    }
-    currentDir = path.dirname(currentDir);
-  }
-  return Err(
-    new CLIError('No harness.config.json found. Run "harness init" to create one.', ExitCode.ERROR)
-  );
-}
-function loadConfig(configPath) {
-  if (!fs.existsSync(configPath)) {
-    return Err(new CLIError(`Config file not found: ${configPath}`, ExitCode.ERROR));
-  }
-  let rawConfig;
-  try {
-    const content = fs.readFileSync(configPath, "utf-8");
-    rawConfig = JSON.parse(content);
-  } catch (error) {
-    return Err(
-      new CLIError(
-        `Failed to parse config: ${error instanceof Error ? error.message : "Unknown error"}`,
-        ExitCode.ERROR
-      )
-    );
-  }
-  const parsed = HarnessConfigSchema.safeParse(rawConfig);
-  if (!parsed.success) {
-    const issues = parsed.error.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n");
-    return Err(new CLIError(`Invalid config:
-${issues}`, ExitCode.ERROR));
-  }
-  return Ok(parsed.data);
-}
-function resolveConfig(configPath) {
-  if (configPath) {
-    return loadConfig(configPath);
-  }
-  const findResult = findConfigFile();
-  if (!findResult.ok) {
-    return findResult;
-  }
-  return loadConfig(findResult.value);
-}
-
-// src/output/formatter.ts
-import chalk from "chalk";
-var OutputMode = {
-  JSON: "json",
-  TEXT: "text",
-  QUIET: "quiet",
-  VERBOSE: "verbose"
-};
-var OutputFormatter = class {
-  constructor(mode = OutputMode.TEXT) {
-    this.mode = mode;
-  }
-  /**
-   * Format raw data (for JSON mode)
-   */
-  format(data) {
-    if (this.mode === OutputMode.JSON) {
-      return JSON.stringify(data, null, 2);
-    }
-    return String(data);
-  }
-  /**
-   * Format validation result
-   */
-  formatValidation(result) {
-    if (this.mode === OutputMode.JSON) {
-      return JSON.stringify(result, null, 2);
-    }
-    if (this.mode === OutputMode.QUIET) {
-      if (result.valid) return "";
-      return result.issues.map((i) => `${i.file ?? ""}: ${i.message}`).join("\n");
-    }
-    const lines = [];
-    if (result.valid) {
-      lines.push(chalk.green("v validation passed"));
-    } else {
-      lines.push(chalk.red(`x Validation failed (${result.issues.length} issues)`));
-      lines.push("");
-      for (const issue of result.issues) {
-        const location = issue.file ? issue.line ? `${issue.file}:${issue.line}` : issue.file : "unknown";
-        lines.push(`  ${chalk.yellow("*")} ${chalk.dim(location)}`);
-        lines.push(`    ${issue.message}`);
-        if (issue.suggestion && this.mode === OutputMode.VERBOSE) {
-          lines.push(`    ${chalk.dim("->")} ${issue.suggestion}`);
-        }
-      }
-    }
-    return lines.join("\n");
-  }
-  /**
-   * Format a summary line
-   */
-  formatSummary(label, value, success) {
-    if (this.mode === OutputMode.JSON || this.mode === OutputMode.QUIET) {
-      return "";
-    }
-    const icon = success ? chalk.green("v") : chalk.red("x");
-    return `${icon} ${label}: ${value}`;
-  }
-};
-
-// src/commands/validate.ts
 async function runValidate(options) {
   const configResult = resolveConfig(options.configPath);
   if (!configResult.ok) {
     return configResult;
   }
   const config = configResult.value;
-  const cwd = options.cwd ?? (options.configPath ? path2.dirname(path2.resolve(options.configPath)) : process.cwd());
+  const cwd = options.cwd ?? (options.configPath ? path.dirname(path.resolve(options.configPath)) : process.cwd());
   const result = {
     valid: true,
     checks: {
@@ -311,7 +130,7 @@ async function runValidate(options) {
     },
     issues: []
   };
-  const agentsMapPath = path2.resolve(cwd, config.agentsMapPath);
+  const agentsMapPath = path.resolve(cwd, config.agentsMapPath);
   const agentsResult = await validateAgentsMap(agentsMapPath);
   if (agentsResult.ok) {
     result.checks.agentsMap = true;
@@ -369,10 +188,10 @@ function createValidateCommand() {
       process.exit(result.error.exitCode);
     }
     if (opts.crossCheck) {
-      const { runCrossCheck: runCrossCheck2 } = await import("./validate-cross-check-DLNK423G.js");
+      const { runCrossCheck: runCrossCheck2 } = await import("./validate-cross-check-WZAX357V.js");
       const cwd = process.cwd();
-      const specsDir = path2.join(cwd, "docs", "specs");
-      const plansDir = path2.join(cwd, "docs", "plans");
+      const specsDir = path.join(cwd, "docs", "specs");
+      const plansDir = path.join(cwd, "docs", "plans");
       const crossResult = await runCrossCheck2({ specsDir, plansDir, projectPath: cwd });
       if (crossResult.ok && crossResult.value.warnings > 0) {
         console.log("\nCross-artifact validation:");
@@ -396,15 +215,7 @@ function createValidateCommand() {
 
 // src/commands/check-deps.ts
 import { Command as Command2 } from "commander";
-import * as path3 from "path";
-
-// src/utils/files.ts
-import { glob } from "glob";
-async function findFiles(pattern, cwd = process.cwd()) {
-  return glob(pattern, { cwd, absolute: true });
-}
-
-// src/commands/check-deps.ts
+import * as path2 from "path";
 async function runCheckDeps(options) {
   const cwd = options.cwd ?? process.cwd();
   const configResult = resolveConfig(options.configPath);
@@ -420,7 +231,7 @@ async function runCheckDeps(options) {
   if (!config.layers || config.layers.length === 0) {
     return Ok(result);
   }
-  const rootDir = path3.resolve(cwd, config.rootDir);
+  const rootDir = path2.resolve(cwd, config.rootDir);
   const parser = new TypeScriptParser();
   const layers = config.layers.map((l) => defineLayer(l.name, [l.pattern], l.allowedDependencies));
   const layerConfig = {
@@ -501,11 +312,11 @@ function createCheckDepsCommand() {
 
 // src/commands/check-perf.ts
 import { Command as Command3 } from "commander";
-import * as path4 from "path";
+import * as path3 from "path";
 async function runCheckPerf(cwd, options) {
   const runAll = !options.structural && !options.size && !options.coupling;
   const analyzer = new EntropyAnalyzer({
-    rootDir: path4.resolve(cwd),
+    rootDir: path3.resolve(cwd),
     analyze: {
       complexity: runAll || !!options.structural,
       coupling: runAll || !!options.coupling,
@@ -623,7 +434,7 @@ function createCheckPerfCommand() {
 
 // src/commands/check-security.ts
 import { Command as Command4 } from "commander";
-import * as path5 from "path";
+import * as path4 from "path";
 import { execSync } from "child_process";
 var SEVERITY_RANK = {
   error: 3,
@@ -636,19 +447,19 @@ function getChangedFiles(cwd) {
       cwd,
       encoding: "utf-8"
     });
-    return output.trim().split("\n").filter((f) => f.length > 0).map((f) => path5.resolve(cwd, f));
+    return output.trim().split("\n").filter((f) => f.length > 0).map((f) => path4.resolve(cwd, f));
   } catch {
     return [];
   }
 }
 async function runCheckSecurity(cwd, options) {
-  const projectRoot = path5.resolve(cwd);
+  const projectRoot = path4.resolve(cwd);
   let configData = {};
   try {
-    const fs25 = await import("fs");
-    const configPath = path5.join(projectRoot, "harness.config.json");
-    if (fs25.existsSync(configPath)) {
-      const raw = fs25.readFileSync(configPath, "utf-8");
+    const fs11 = await import("fs");
+    const configPath = path4.join(projectRoot, "harness.config.json");
+    if (fs11.existsSync(configPath)) {
+      const raw = fs11.readFileSync(configPath, "utf-8");
       const parsed = JSON.parse(raw);
       configData = parsed.security ?? {};
     }
@@ -661,7 +472,7 @@ async function runCheckSecurity(cwd, options) {
   if (options.changedOnly) {
     filesToScan = getChangedFiles(projectRoot);
   } else {
-    const { glob: glob2 } = await import("glob");
+    const { glob } = await import("glob");
     const pattern = "**/*.{ts,tsx,js,jsx,go,py,java,rb}";
     const ignore = securityConfig.exclude ?? [
       "**/node_modules/**",
@@ -669,7 +480,7 @@ async function runCheckSecurity(cwd, options) {
       "**/*.test.ts",
       "**/fixtures/**"
     ];
-    filesToScan = await glob2(pattern, { cwd: projectRoot, absolute: true, ignore });
+    filesToScan = await glob(pattern, { cwd: projectRoot, absolute: true, ignore });
   }
   const result = await scanner.scanFiles(filesToScan);
   const threshold = options.severity ?? "warning";
@@ -729,15 +540,15 @@ function createCheckSecurityCommand() {
 
 // src/commands/perf.ts
 import { Command as Command5 } from "commander";
-import * as path6 from "path";
+import * as path5 from "path";
 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) => {
+  perf.command("bench [glob]").description("Run benchmarks via vitest bench").action(async (glob, _opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const cwd = process.cwd();
-    const { BenchmarkRunner } = await import("./dist-ZODQVGC4.js");
+    const { BenchmarkRunner } = await import("./dist-PBTNVK6K.js");
     const runner = new BenchmarkRunner();
-    const benchFiles = runner.discover(cwd, glob2);
+    const benchFiles = runner.discover(cwd, glob);
     if (benchFiles.length === 0) {
       if (globalOpts.json) {
         console.log(JSON.stringify({ benchFiles: [], message: "No .bench.ts files found" }));
@@ -755,7 +566,7 @@ function createPerfCommand() {
       }
       logger.info("Running benchmarks...");
     }
-    const result = await runner.run(glob2 ? { cwd, glob: glob2 } : { cwd });
+    const result = await runner.run(glob ? { cwd, glob } : { cwd });
     if (globalOpts.json) {
       console.log(JSON.stringify({ results: result.results, success: result.success }));
     } else {
@@ -804,7 +615,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("./dist-ZODQVGC4.js");
+    const { BenchmarkRunner } = await import("./dist-PBTNVK6K.js");
     const runner = new BenchmarkRunner();
     const manager = new BaselineManager(cwd);
     logger.info("Running benchmarks to update baselines...");
@@ -832,9 +643,9 @@ 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: EntropyAnalyzer2 } = await import("./dist-ZODQVGC4.js");
+    const { EntropyAnalyzer: EntropyAnalyzer2 } = await import("./dist-PBTNVK6K.js");
     const analyzer = new EntropyAnalyzer2({
-      rootDir: path6.resolve(cwd),
+      rootDir: path5.resolve(cwd),
       analyze: { complexity: true, coupling: true }
     });
     const result = await analyzer.analyze();
@@ -892,7 +703,7 @@ Results (${result.results.length} benchmarks):`);
 
 // src/commands/check-docs.ts
 import { Command as Command6 } from "commander";
-import * as path7 from "path";
+import * as path6 from "path";
 async function runCheckDocs(options) {
   const cwd = options.cwd ?? process.cwd();
   const minCoverage = options.minCoverage ?? 80;
@@ -901,8 +712,8 @@ async function runCheckDocs(options) {
     return configResult;
   }
   const config = configResult.value;
-  const docsDir = path7.resolve(cwd, config.docsDir);
-  const sourceDir = path7.resolve(cwd, config.rootDir);
+  const docsDir = path6.resolve(cwd, config.docsDir);
+  const sourceDir = path6.resolve(cwd, config.rootDir);
   const coverageResult = await checkDocCoverage("project", {
     docsDir,
     sourceDir,
@@ -987,341 +798,34 @@ function createCheckDocsCommand() {
 
 // src/commands/init.ts
 import { Command as Command8 } from "commander";
-import chalk3 from "chalk";
-import * as fs5 from "fs";
-import * as path11 from "path";
-
-// src/templates/engine.ts
+import chalk2 from "chalk";
 import * as fs2 from "fs";
 import * as path8 from "path";
-import Handlebars from "handlebars";
-
-// src/templates/schema.ts
-import { z as z2 } from "zod";
-var MergeStrategySchema = z2.object({
-  json: z2.enum(["deep-merge", "overlay-wins"]).default("deep-merge"),
-  files: z2.literal("overlay-wins").default("overlay-wins")
-});
-var TemplateMetadataSchema = z2.object({
-  name: z2.string(),
-  description: z2.string(),
-  level: z2.enum(["basic", "intermediate", "advanced"]).optional(),
-  framework: z2.string().optional(),
-  extends: z2.string().optional(),
-  mergeStrategy: MergeStrategySchema.default({}),
-  version: z2.literal(1)
-});
-
-// src/templates/merger.ts
-function isPlainObject(val) {
-  return typeof val === "object" && val !== null && !Array.isArray(val);
-}
-function deepMergeJson(base, overlay) {
-  const result = { ...base };
-  for (const key of Object.keys(overlay)) {
-    if (isPlainObject(result[key]) && isPlainObject(overlay[key])) {
-      result[key] = deepMergeJson(
-        result[key],
-        overlay[key]
-      );
-    } else {
-      result[key] = overlay[key];
-    }
-  }
-  return result;
-}
-var CONCAT_KEYS = /* @__PURE__ */ new Set(["dependencies", "devDependencies", "peerDependencies"]);
-function mergePackageJson(base, overlay) {
-  const result = { ...base };
-  for (const key of Object.keys(overlay)) {
-    if (CONCAT_KEYS.has(key) && isPlainObject(result[key]) && isPlainObject(overlay[key])) {
-      result[key] = {
-        ...result[key],
-        ...overlay[key]
-      };
-    } else if (isPlainObject(result[key]) && isPlainObject(overlay[key])) {
-      result[key] = deepMergeJson(
-        result[key],
-        overlay[key]
-      );
-    } else {
-      result[key] = overlay[key];
-    }
-  }
-  return result;
-}
-
-// src/templates/engine.ts
-var TemplateEngine = class {
-  constructor(templatesDir) {
-    this.templatesDir = templatesDir;
-  }
-  listTemplates() {
-    try {
-      const entries = fs2.readdirSync(this.templatesDir, { withFileTypes: true });
-      const templates = [];
-      for (const entry of entries) {
-        if (!entry.isDirectory()) continue;
-        const metaPath = path8.join(this.templatesDir, entry.name, "template.json");
-        if (!fs2.existsSync(metaPath)) continue;
-        const raw = JSON.parse(fs2.readFileSync(metaPath, "utf-8"));
-        const parsed = TemplateMetadataSchema.safeParse(raw);
-        if (parsed.success) templates.push(parsed.data);
-      }
-      return Ok(templates);
-    } catch (error) {
-      return Err(
-        new Error(
-          `Failed to list templates: ${error instanceof Error ? error.message : String(error)}`
-        )
-      );
-    }
-  }
-  resolveTemplate(level, framework) {
-    const levelDir = this.findTemplateDir(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 Err(new Error(`Invalid template.json in ${level}: ${metaResult.error.message}`));
-    const metadata = metaResult.data;
-    let files = [];
-    if (metadata.extends) {
-      const baseDir = path8.join(this.templatesDir, metadata.extends);
-      if (fs2.existsSync(baseDir)) files = this.collectFiles(baseDir, metadata.extends);
-    }
-    const levelFiles = this.collectFiles(levelDir, level);
-    files = this.mergeFileLists(files, levelFiles);
-    let overlayMetadata;
-    if (framework) {
-      const frameworkDir = this.findTemplateDir(framework, "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);
-      if (fMetaResult.success) overlayMetadata = fMetaResult.data;
-      const frameworkFiles = this.collectFiles(frameworkDir, framework);
-      files = this.mergeFileLists(files, frameworkFiles);
-    }
-    files = files.filter((f) => f.relativePath !== "template.json");
-    const resolved2 = { metadata, files };
-    if (overlayMetadata !== void 0) resolved2.overlayMetadata = overlayMetadata;
-    return Ok(resolved2);
-  }
-  render(template, context) {
-    const rendered = [];
-    const jsonBuffers = /* @__PURE__ */ new Map();
-    for (const file of template.files) {
-      const outputPath = file.relativePath.replace(/\.hbs$/, "");
-      if (file.isHandlebars) {
-        try {
-          const raw = fs2.readFileSync(file.absolutePath, "utf-8");
-          const compiled = Handlebars.compile(raw, { strict: true });
-          const content = compiled(context);
-          if (outputPath.endsWith(".json") && file.relativePath.endsWith(".json.hbs")) {
-            if (!jsonBuffers.has(outputPath)) jsonBuffers.set(outputPath, []);
-            jsonBuffers.get(outputPath).push(JSON.parse(content));
-          } else {
-            rendered.push({ relativePath: outputPath, content });
-          }
-        } catch (error) {
-          const msg = error instanceof Error ? error.message : String(error);
-          return Err(
-            new Error(
-              `Template render failed in ${file.sourceTemplate}/${file.relativePath}: ${msg}`
-            )
-          );
-        }
-      } else {
-        try {
-          const content = fs2.readFileSync(file.absolutePath, "utf-8");
-          rendered.push({ relativePath: file.relativePath, content });
-        } catch (error) {
-          const msg = error instanceof Error ? error.message : String(error);
-          return Err(
-            new Error(
-              `Template render failed in ${file.sourceTemplate}/${file.relativePath}: ${msg}`
-            )
-          );
-        }
-      }
-    }
-    try {
-      for (const [outputPath, jsons] of jsonBuffers) {
-        let merged = {};
-        for (const json of jsons) {
-          merged = outputPath === "package.json" ? mergePackageJson(merged, json) : deepMergeJson(merged, json);
-        }
-        rendered.push({ relativePath: outputPath, content: JSON.stringify(merged, null, 2) });
-      }
-    } catch (error) {
-      const msg = error instanceof Error ? error.message : String(error);
-      return Err(new Error(`JSON merge failed: ${msg}`));
-    }
-    return Ok({ files: rendered });
-  }
-  write(files, targetDir, options) {
-    try {
-      const written = [];
-      for (const file of files.files) {
-        const targetPath = path8.join(targetDir, file.relativePath);
-        const dir = path8.dirname(targetPath);
-        if (!options.overwrite && fs2.existsSync(targetPath)) continue;
-        fs2.mkdirSync(dir, { recursive: true });
-        fs2.writeFileSync(targetPath, file.content);
-        written.push(file.relativePath);
-      }
-      return Ok(written);
-    } catch (error) {
-      return Err(
-        new Error(
-          `Failed to write files: ${error instanceof Error ? error.message : String(error)}`
-        )
-      );
-    }
-  }
-  findTemplateDir(name, type) {
-    const entries = fs2.readdirSync(this.templatesDir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (!entry.isDirectory()) continue;
-      const metaPath = path8.join(this.templatesDir, entry.name, "template.json");
-      if (!fs2.existsSync(metaPath)) continue;
-      const raw = JSON.parse(fs2.readFileSync(metaPath, "utf-8"));
-      const parsed = TemplateMetadataSchema.safeParse(raw);
-      if (!parsed.success) continue;
-      if (type === "level" && parsed.data.level === name)
-        return path8.join(this.templatesDir, entry.name);
-      if (type === "framework" && parsed.data.framework === name)
-        return path8.join(this.templatesDir, entry.name);
-      if (parsed.data.name === name) return path8.join(this.templatesDir, entry.name);
-    }
-    return null;
-  }
-  collectFiles(dir, sourceName) {
-    const files = [];
-    const walk = (currentDir) => {
-      const entries = fs2.readdirSync(currentDir, { withFileTypes: true });
-      for (const entry of entries) {
-        const fullPath = path8.join(currentDir, entry.name);
-        if (entry.isDirectory()) {
-          walk(fullPath);
-        } else {
-          files.push({
-            relativePath: path8.relative(dir, fullPath).replace(/\\/g, "/"),
-            absolutePath: fullPath,
-            isHandlebars: entry.name.endsWith(".hbs"),
-            sourceTemplate: sourceName
-          });
-        }
-      }
-    };
-    walk(dir);
-    return files;
-  }
-  mergeFileLists(base, overlay) {
-    const map = /* @__PURE__ */ new Map();
-    for (const file of base) map.set(file.relativePath, file);
-    for (const file of overlay) {
-      if (file.relativePath.endsWith(".json.hbs")) {
-        const baseKey = base.find((f) => f.relativePath === file.relativePath);
-        if (baseKey) {
-          map.set(`__overlay__${file.relativePath}`, file);
-        } else {
-          map.set(file.relativePath, file);
-        }
-      } else {
-        map.set(file.relativePath, file);
-      }
-    }
-    return Array.from(map.values());
-  }
-};
-
-// src/utils/paths.ts
-import * as fs3 from "fs";
-import * as path9 from "path";
-import { fileURLToPath } from "url";
-var __filename = fileURLToPath(import.meta.url);
-var __dirname = path9.dirname(__filename);
-function findUpDir(targetName, marker, maxLevels = 8) {
-  let dir = __dirname;
-  for (let i = 0; i < maxLevels; i++) {
-    const candidate = path9.join(dir, targetName);
-    if (fs3.existsSync(candidate) && fs3.statSync(candidate).isDirectory()) {
-      if (fs3.existsSync(path9.join(candidate, marker))) {
-        return candidate;
-      }
-    }
-    dir = path9.dirname(dir);
-  }
-  return null;
-}
-function resolveTemplatesDir() {
-  return findUpDir("templates", "base") ?? path9.join(__dirname, "templates");
-}
-function resolvePersonasDir() {
-  const agentsDir = findUpDir("agents", "personas");
-  if (agentsDir) {
-    return path9.join(agentsDir, "personas");
-  }
-  return path9.join(__dirname, "agents", "personas");
-}
-function resolveSkillsDir() {
-  const agentsDir = findUpDir("agents", "skills");
-  if (agentsDir) {
-    return path9.join(agentsDir, "skills", "claude-code");
-  }
-  return path9.join(__dirname, "agents", "skills", "claude-code");
-}
-function resolveProjectSkillsDir(cwd) {
-  let dir = cwd ?? process.cwd();
-  for (let i = 0; i < 8; i++) {
-    const candidate = path9.join(dir, "agents", "skills", "claude-code");
-    if (fs3.existsSync(candidate) && fs3.statSync(candidate).isDirectory()) {
-      const agentsDir = path9.join(dir, "agents");
-      if (fs3.existsSync(path9.join(agentsDir, "skills"))) {
-        return candidate;
-      }
-    }
-    const parent = path9.dirname(dir);
-    if (parent === dir) break;
-    dir = parent;
-  }
-  return null;
-}
-function resolveGlobalSkillsDir() {
-  const agentsDir = findUpDir("agents", "skills");
-  if (agentsDir) {
-    return path9.join(agentsDir, "skills", "claude-code");
-  }
-  return path9.join(__dirname, "agents", "skills", "claude-code");
-}
 
 // src/commands/setup-mcp.ts
 import { Command as Command7 } from "commander";
-import * as fs4 from "fs";
-import * as path10 from "path";
+import * as fs from "fs";
+import * as path7 from "path";
 import * as os from "os";
-import chalk2 from "chalk";
+import chalk from "chalk";
 var HARNESS_MCP_ENTRY = {
   command: "harness-mcp"
 };
 function readJsonFile(filePath) {
-  if (!fs4.existsSync(filePath)) return null;
+  if (!fs.existsSync(filePath)) return null;
   try {
-    return JSON.parse(fs4.readFileSync(filePath, "utf-8"));
+    return JSON.parse(fs.readFileSync(filePath, "utf-8"));
   } catch {
-    fs4.copyFileSync(filePath, filePath + ".bak");
+    fs.copyFileSync(filePath, filePath + ".bak");
     return null;
   }
 }
 function writeJsonFile(filePath, data) {
-  const dir = path10.dirname(filePath);
-  if (!fs4.existsSync(dir)) {
-    fs4.mkdirSync(dir, { recursive: true });
+  const dir = path7.dirname(filePath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
   }
-  fs4.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");
 }
 function configureMcpServer(configPath) {
   const config = readJsonFile(configPath) ?? {};
@@ -1336,7 +840,7 @@ function configureMcpServer(configPath) {
   return true;
 }
 function addGeminiTrustedFolder(cwd) {
-  const trustedPath = path10.join(os.homedir(), ".gemini", "trustedFolders.json");
+  const trustedPath = path7.join(os.homedir(), ".gemini", "trustedFolders.json");
   const folders = readJsonFile(trustedPath) ?? {};
   if (folders[cwd] === "TRUST_FOLDER") {
     return false;
@@ -1350,7 +854,7 @@ function setupMcp(cwd, client) {
   const skipped = [];
   let trustedFolder = false;
   if (client === "all" || client === "claude") {
-    const configPath = path10.join(cwd, ".mcp.json");
+    const configPath = path7.join(cwd, ".mcp.json");
     if (configureMcpServer(configPath)) {
       configured.push("Claude Code");
     } else {
@@ -1358,7 +862,7 @@ function setupMcp(cwd, client) {
     }
   }
   if (client === "all" || client === "gemini") {
-    const configPath = path10.join(cwd, ".gemini", "settings.json");
+    const configPath = path7.join(cwd, ".gemini", "settings.json");
     if (configureMcpServer(configPath)) {
       configured.push("Gemini CLI");
     } else {
@@ -1379,7 +883,7 @@ function createSetupMcpCommand() {
         logger.success("MCP server configured!");
         console.log("");
         for (const name of configured) {
-          console.log(`  ${chalk2.green("+")} ${name}`);
+          console.log(`  ${chalk.green("+")} ${name}`);
         }
       }
       if (trustedFolder) {
@@ -1390,11 +894,11 @@ function createSetupMcpCommand() {
         console.log("");
         logger.info("Already configured:");
         for (const name of skipped) {
-          console.log(`  ${chalk2.dim("-")} ${name}`);
+          console.log(`  ${chalk.dim("-")} ${name}`);
         }
       }
       console.log("");
-      console.log(chalk2.bold("The harness MCP server provides:"));
+      console.log(chalk.bold("The harness MCP server provides:"));
       console.log(
         "  - 31 tools for validation, entropy detection, skill execution, graph querying, and more"
       );
@@ -1402,7 +906,7 @@ function createSetupMcpCommand() {
         "  - 8 resources for project context, skills, rules, learnings, state, and graph data"
       );
       console.log("");
-      console.log(`Run ${chalk2.cyan("harness skill list")} to see available skills.`);
+      console.log(`Run ${chalk.cyan("harness skill list")} to see available skills.`);
       console.log("");
     }
     process.exit(ExitCode.SUCCESS);
@@ -1412,11 +916,11 @@ function createSetupMcpCommand() {
 // src/commands/init.ts
 async function runInit(options) {
   const cwd = options.cwd ?? process.cwd();
-  const name = options.name ?? path11.basename(cwd);
+  const name = options.name ?? path8.basename(cwd);
   const level = options.level ?? "basic";
   const force = options.force ?? false;
-  const configPath = path11.join(cwd, "harness.config.json");
-  if (!force && fs5.existsSync(configPath)) {
+  const configPath = path8.join(cwd, "harness.config.json");
+  if (!force && fs2.existsSync(configPath)) {
     return Err(
       new CLIError("Project already initialized. Use --force to overwrite.", ExitCode.ERROR)
     );
@@ -1462,20 +966,20 @@ function createInitCommand() {
       console.log("");
       logger.info("Created files:");
       for (const file of result.value.filesCreated) {
-        console.log(`  ${chalk3.green("+")} ${file}`);
+        console.log(`  ${chalk2.green("+")} ${file}`);
       }
       if (mcpResult.configured.length > 0) {
         console.log("");
         logger.info("MCP server configured for:");
         for (const name of mcpResult.configured) {
-          console.log(`  ${chalk3.green("+")} ${name}`);
+          console.log(`  ${chalk2.green("+")} ${name}`);
         }
       }
       console.log("");
-      console.log(chalk3.bold("Next steps:"));
-      console.log(`  1. Review ${chalk3.cyan("harness.config.json")}`);
-      console.log(`  2. Update ${chalk3.cyan("AGENTS.md")} with your project context`);
-      console.log(`  3. Run ${chalk3.cyan("harness validate")} to check your setup`);
+      console.log(chalk2.bold("Next steps:"));
+      console.log(`  1. Review ${chalk2.cyan("harness.config.json")}`);
+      console.log(`  2. Update ${chalk2.cyan("AGENTS.md")} with your project context`);
+      console.log(`  3. Run ${chalk2.cyan("harness validate")} to check your setup`);
       console.log("");
     }
     process.exit(ExitCode.SUCCESS);
@@ -1485,7 +989,7 @@ function createInitCommand() {
 
 // src/commands/cleanup.ts
 import { Command as Command9 } from "commander";
-import * as path12 from "path";
+import * as path9 from "path";
 async function runCleanup(options) {
   const cwd = options.cwd ?? process.cwd();
   const type = options.type ?? "all";
@@ -1500,11 +1004,11 @@ async function runCleanup(options) {
     patternViolations: [],
     totalIssues: 0
   };
-  const rootDir = path12.resolve(cwd, config.rootDir);
-  const docsDir = path12.resolve(cwd, config.docsDir);
+  const rootDir = path9.resolve(cwd, config.rootDir);
+  const docsDir = path9.resolve(cwd, config.docsDir);
   const entropyConfig = {
     rootDir,
-    entryPoints: [path12.join(rootDir, "src/index.ts")],
+    entryPoints: [path9.join(rootDir, "src/index.ts")],
     docPaths: [docsDir],
     analyze: {
       drift: type === "all" || type === "drift",
@@ -1605,7 +1109,7 @@ function createCleanupCommand() {
 
 // src/commands/fix-drift.ts
 import { Command as Command10 } from "commander";
-import * as path13 from "path";
+import * as path10 from "path";
 async function runFixDrift(options) {
   const cwd = options.cwd ?? process.cwd();
   const dryRun = options.dryRun !== false;
@@ -1614,11 +1118,11 @@ async function runFixDrift(options) {
     return Err(configResult.error);
   }
   const config = configResult.value;
-  const rootDir = path13.resolve(cwd, config.rootDir);
-  const docsDir = path13.resolve(cwd, config.docsDir);
+  const rootDir = path10.resolve(cwd, config.rootDir);
+  const docsDir = path10.resolve(cwd, config.docsDir);
   const entropyConfig = {
     rootDir,
-    entryPoints: [path13.join(rootDir, "src/index.ts")],
+    entryPoints: [path10.join(rootDir, "src/index.ts")],
     docPaths: [docsDir],
     analyze: {
       drift: true,
@@ -1769,477 +1273,41 @@ import { Command as Command13 } from "commander";
 
 // src/commands/agent/run.ts
 import { Command as Command11 } from "commander";
-import * as path17 from "path";
+import * as path11 from "path";
 import * as childProcess from "child_process";
-
-// src/persona/loader.ts
-import * as fs6 from "fs";
-import * as path14 from "path";
-import YAML from "yaml";
-
-// src/persona/schema.ts
-import { z as z3 } from "zod";
-var TriggerContextSchema = z3.enum(["always", "on_pr", "on_commit", "on_review", "scheduled", "manual", "on_plan_approved"]).default("always");
-var CommandStepSchema = z3.object({
-  command: z3.string(),
-  when: TriggerContextSchema
-});
-var SkillStepSchema = z3.object({
-  skill: z3.string(),
-  when: TriggerContextSchema,
-  output: z3.enum(["inline", "artifact", "auto"]).default("auto")
-});
-var StepSchema = z3.union([CommandStepSchema, SkillStepSchema]);
-var PersonaTriggerSchema = z3.discriminatedUnion("event", [
-  z3.object({
-    event: z3.literal("on_pr"),
-    conditions: z3.object({
-      paths: z3.array(z3.string()).optional(),
-      min_files: z3.number().optional()
-    }).optional()
-  }),
-  z3.object({
-    event: z3.literal("on_commit"),
-    conditions: z3.object({ branches: z3.array(z3.string()).optional() }).optional()
-  }),
-  z3.object({
-    event: z3.literal("scheduled"),
-    cron: z3.string()
-  }),
-  z3.object({
-    event: z3.literal("manual")
-  })
-]);
-var PersonaConfigSchema = z3.object({
-  severity: z3.enum(["error", "warning"]).default("error"),
-  autoFix: z3.boolean().default(false),
-  timeout: z3.number().default(3e5)
-});
-var PersonaOutputsSchema = z3.object({
-  "agents-md": z3.boolean().default(true),
-  "ci-workflow": z3.boolean().default(true),
-  "runtime-config": z3.boolean().default(true)
-});
-var PersonaSchemaV1 = z3.object({
-  version: z3.literal(1),
-  name: z3.string(),
-  description: z3.string(),
-  role: z3.string(),
-  skills: z3.array(z3.string()),
-  commands: z3.array(z3.string()),
-  triggers: z3.array(PersonaTriggerSchema),
-  config: PersonaConfigSchema.default({}),
-  outputs: PersonaOutputsSchema.default({})
-});
-var PersonaSchemaV2 = z3.object({
-  version: z3.literal(2),
-  name: z3.string(),
-  description: z3.string(),
-  role: z3.string(),
-  skills: z3.array(z3.string()),
-  steps: z3.array(StepSchema),
-  triggers: z3.array(PersonaTriggerSchema),
-  config: PersonaConfigSchema.default({}),
-  outputs: PersonaOutputsSchema.default({})
-});
-var PersonaSchema = z3.union([PersonaSchemaV1, PersonaSchemaV2]);
-
-// src/persona/loader.ts
-function normalizePersona(raw) {
-  if (raw.version === 1 && Array.isArray(raw.commands)) {
-    const { commands, ...rest } = raw;
-    return {
-      ...rest,
-      steps: commands.map((cmd) => ({
-        command: cmd,
-        when: "always"
-      }))
-    };
-  }
-  return raw;
-}
-function loadPersona(filePath) {
-  try {
-    if (!fs6.existsSync(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 Err(new Error(`Invalid persona ${filePath}: ${result.error.message}`));
-    }
-    return Ok(normalizePersona(result.data));
-  } catch (error) {
-    return Err(
-      new Error(`Failed to load persona: ${error instanceof Error ? error.message : String(error)}`)
-    );
+async function runAgentTask(task, options) {
+  const configResult = resolveConfig(options.configPath);
+  if (!configResult.ok) {
+    return configResult;
   }
-}
-function listPersonas(dir) {
-  try {
-    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) {
-      const filePath = path14.join(dir, entry);
-      const result = loadPersona(filePath);
-      if (result.ok) {
-        personas.push({ name: result.value.name, description: result.value.description, filePath });
-      }
-    }
-    return Ok(personas);
-  } catch (error) {
+  const agentTypeMap = {
+    review: "architecture-enforcer",
+    "doc-review": "documentation-maintainer",
+    "test-review": "test-reviewer"
+  };
+  const agentType = agentTypeMap[task];
+  if (!agentType) {
     return Err(
-      new Error(
-        `Failed to list personas: ${error instanceof Error ? error.message : String(error)}`
+      new CLIError(
+        `Unknown task: ${task}. Available: ${Object.keys(agentTypeMap).join(", ")}`,
+        ExitCode.ERROR
       )
     );
   }
-}
-
-// src/persona/trigger-detector.ts
-import * as fs7 from "fs";
-import * as path15 from "path";
-function detectTrigger(projectPath) {
-  const handoffPath = path15.join(projectPath, ".harness", "handoff.json");
-  if (!fs7.existsSync(handoffPath)) {
-    return { trigger: "manual" };
-  }
-  try {
-    const raw = fs7.readFileSync(handoffPath, "utf-8");
-    const handoff = JSON.parse(raw);
-    if (handoff.fromSkill === "harness-planning" && Array.isArray(handoff.pending) && handoff.pending.length > 0) {
-      return {
-        trigger: "on_plan_approved",
-        handoff: {
-          fromSkill: handoff.fromSkill,
-          summary: handoff.summary ?? "",
-          pending: handoff.pending,
-          planPath: handoff.planPath
-        }
-      };
-    }
-    return { trigger: "manual" };
-  } catch {
-    return { trigger: "manual" };
-  }
-}
-
-// src/persona/runner.ts
-var TIMEOUT_ERROR_MESSAGE = "__PERSONA_RUNNER_TIMEOUT__";
-function stepName(step) {
-  return "command" in step ? step.command : step.skill;
-}
-function stepType(step) {
-  return "command" in step ? "command" : "skill";
-}
-function matchesTrigger(step, trigger) {
-  const when = step.when ?? "always";
-  return when === "always" || when === trigger;
-}
-function skipRemaining(activeSteps, fromIndex, report) {
-  for (let j = fromIndex; j < activeSteps.length; j++) {
-    const remaining = activeSteps[j];
-    report.steps.push({
-      name: stepName(remaining),
-      type: stepType(remaining),
-      status: "skipped",
-      durationMs: 0
-    });
-  }
-}
-async function runPersona(persona, context) {
-  const startTime = Date.now();
-  const timeout = persona.config.timeout;
-  const report = {
-    persona: persona.name.toLowerCase().replace(/\s+/g, "-"),
-    status: "pass",
-    steps: [],
-    totalDurationMs: 0
-  };
-  let resolvedTrigger;
-  let handoff = context.handoff;
-  if (context.trigger === "auto") {
-    const detection = detectTrigger(context.projectPath);
-    resolvedTrigger = detection.trigger;
-    handoff = detection.handoff ?? handoff;
-  } else {
-    resolvedTrigger = context.trigger;
-  }
-  const activeSteps = persona.steps.filter((s) => matchesTrigger(s, resolvedTrigger));
-  for (let i = 0; i < activeSteps.length; i++) {
-    const step = activeSteps[i];
-    if (Date.now() - startTime >= timeout) {
-      skipRemaining(activeSteps, i, report);
-      report.status = "partial";
-      break;
-    }
-    const stepStart = Date.now();
-    const remainingTime = timeout - (Date.now() - startTime);
-    if ("command" in step) {
-      const result = await Promise.race([
-        context.commandExecutor(step.command),
-        new Promise(
-          (resolve24) => setTimeout(
-            () => resolve24({
-              ok: false,
-              error: new Error(TIMEOUT_ERROR_MESSAGE)
-            }),
-            remainingTime
-          )
-        )
-      ]);
-      const durationMs = Date.now() - stepStart;
-      if (result.ok) {
-        report.steps.push({
-          name: step.command,
-          type: "command",
-          status: "pass",
-          result: result.value,
-          durationMs
-        });
-      } else if (result.error.message === TIMEOUT_ERROR_MESSAGE) {
-        report.steps.push({
-          name: step.command,
-          type: "command",
-          status: "skipped",
-          error: "timed out",
-          durationMs
-        });
-        report.status = "partial";
-        skipRemaining(activeSteps, i + 1, report);
-        break;
-      } else {
-        report.steps.push({
-          name: step.command,
-          type: "command",
-          status: "fail",
-          error: result.error.message,
-          durationMs
-        });
-        report.status = "fail";
-        skipRemaining(activeSteps, i + 1, report);
-        break;
-      }
-    } else {
-      const skillContext = {
-        trigger: resolvedTrigger,
-        projectPath: context.projectPath,
-        outputMode: step.output ?? "auto",
-        ...handoff ? { handoff } : {}
-      };
-      const SKILL_TIMEOUT_RESULT = {
-        status: "fail",
-        output: "timed out",
-        durationMs: 0
-      };
-      const result = await Promise.race([
-        context.skillExecutor(step.skill, skillContext),
-        new Promise(
-          (resolve24) => setTimeout(() => resolve24(SKILL_TIMEOUT_RESULT), remainingTime)
-        )
-      ]);
-      const durationMs = Date.now() - stepStart;
-      if (result === SKILL_TIMEOUT_RESULT) {
-        report.steps.push({
-          name: step.skill,
-          type: "skill",
-          status: "skipped",
-          error: "timed out",
-          durationMs
-        });
-        report.status = "partial";
-        skipRemaining(activeSteps, i + 1, report);
-        break;
-      } else if (result.status === "pass") {
-        report.steps.push({
-          name: step.skill,
-          type: "skill",
-          status: "pass",
-          result: result.output,
-          ...result.artifactPath ? { artifactPath: result.artifactPath } : {},
-          durationMs
-        });
-      } else {
-        report.steps.push({
-          name: step.skill,
-          type: "skill",
-          status: "fail",
-          error: result.output,
-          durationMs
-        });
-        report.status = "fail";
-        skipRemaining(activeSteps, i + 1, report);
-        break;
-      }
-    }
-  }
-  report.totalDurationMs = Date.now() - startTime;
-  return report;
-}
-
-// src/persona/skill-executor.ts
-import * as fs8 from "fs";
-import * as path16 from "path";
-import { parse as parse2 } from "yaml";
-function resolveOutputMode(mode, trigger) {
-  if (mode !== "auto") return mode;
-  return trigger === "manual" ? "inline" : "artifact";
-}
-function buildArtifactPath(projectPath, headSha) {
-  const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-  const sha = headSha?.slice(0, 7) ?? "unknown";
-  return path16.join(projectPath, ".harness", "reviews", `${date}-${sha}.md`);
-}
-function buildArtifactContent(skillName, trigger, headSha) {
-  const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-  return [
-    "---",
-    `skill: ${skillName}`,
-    `trigger: ${trigger}`,
-    `sha: ${headSha?.slice(0, 7) ?? "unknown"}`,
-    `date: ${date}`,
-    `assessment: pending`,
-    "---",
-    "",
-    `# Review by ${skillName}`,
-    "",
-    "## Strengths",
-    "",
-    "- (review pending)",
-    "",
-    "## Issues",
-    "",
-    "### Critical",
-    "",
-    "- None identified",
-    "",
-    "### Important",
-    "",
-    "- None identified",
-    "",
-    "### Suggestions",
-    "",
-    "- None identified",
-    "",
-    "## Assessment",
-    "",
-    "Pending \u2014 skill execution scaffolded.",
-    "",
-    "## Harness Checks",
-    "",
-    "- (run harness validate, check-deps, check-docs to populate)",
-    ""
-  ].join("\n");
-}
-async function executeSkill(skillName, context) {
-  const startTime = Date.now();
-  const skillsDir = resolveSkillsDir();
-  const skillDir = path16.join(skillsDir, skillName);
-  if (!fs8.existsSync(skillDir)) {
-    return {
-      status: "fail",
-      output: `Skill not found: ${skillName}`,
-      durationMs: Date.now() - startTime
-    };
-  }
-  const yamlPath = path16.join(skillDir, "skill.yaml");
-  if (!fs8.existsSync(yamlPath)) {
-    return {
-      status: "fail",
-      output: `skill.yaml not found for ${skillName}`,
-      durationMs: Date.now() - startTime
-    };
-  }
-  const raw = fs8.readFileSync(yamlPath, "utf-8");
-  const parsed = parse2(raw);
-  const metadataResult = SkillMetadataSchema.safeParse(parsed);
-  if (!metadataResult.success) {
-    return {
-      status: "fail",
-      output: `Invalid skill metadata: ${metadataResult.error.message}`,
-      durationMs: Date.now() - startTime
-    };
-  }
-  const skillMdPath = path16.join(skillDir, "SKILL.md");
-  if (!fs8.existsSync(skillMdPath)) {
-    return {
-      status: "fail",
-      output: `SKILL.md not found for ${skillName}`,
-      durationMs: Date.now() - startTime
-    };
-  }
-  const skillContent = fs8.readFileSync(skillMdPath, "utf-8");
-  const metadata = metadataResult.data;
-  const resolvedMode = resolveOutputMode(context.outputMode, context.trigger);
-  const output = `Skill ${metadata.name} (${metadata.type}) loaded.
-Cognitive mode: ${metadata.cognitive_mode ?? "default"}
-Content length: ${skillContent.length} chars
-Trigger: ${context.trigger}
-`;
-  let artifactPath;
-  if (resolvedMode === "artifact") {
-    artifactPath = buildArtifactPath(context.projectPath, context.headSha);
-    const artifactContent = buildArtifactContent(skillName, context.trigger, context.headSha);
-    const dir = path16.dirname(artifactPath);
-    fs8.mkdirSync(dir, { recursive: true });
-    fs8.writeFileSync(artifactPath, artifactContent, "utf-8");
-  }
-  return {
-    status: "pass",
-    output,
-    ...artifactPath ? { artifactPath } : {},
-    durationMs: Date.now() - startTime
-  };
-}
-
-// src/persona/constants.ts
-var ALLOWED_PERSONA_COMMANDS = /* @__PURE__ */ new Set([
-  "validate",
-  "check-deps",
-  "check-docs",
-  "check-perf",
-  "check-security",
-  "cleanup",
-  "fix-drift",
-  "add"
-]);
-
-// src/commands/agent/run.ts
-async function runAgentTask(task, options) {
-  const configResult = resolveConfig(options.configPath);
-  if (!configResult.ok) {
-    return configResult;
-  }
-  const agentTypeMap = {
-    review: "architecture-enforcer",
-    "doc-review": "documentation-maintainer",
-    "test-review": "test-reviewer"
-  };
-  const agentType = agentTypeMap[task];
-  if (!agentType) {
-    return Err(
-      new CLIError(
-        `Unknown task: ${task}. Available: ${Object.keys(agentTypeMap).join(", ")}`,
-        ExitCode.ERROR
-      )
-    );
-  }
-  const config = configResult.value;
-  const timeout = options.timeout ?? config.agent?.timeout ?? 3e5;
-  const reviewResult = await requestPeerReview(
-    agentType,
-    {
-      files: [],
-      diff: "",
-      commitMessage: task,
-      metadata: { task, timeout }
-    },
-    { timeout }
-  );
-  if (!reviewResult.ok) {
-    return Err(new CLIError(`Agent task failed: ${reviewResult.error.message}`, ExitCode.ERROR));
+  const config = configResult.value;
+  const timeout = options.timeout ?? config.agent?.timeout ?? 3e5;
+  const reviewResult = await requestPeerReview(
+    agentType,
+    {
+      files: [],
+      diff: "",
+      commitMessage: task,
+      metadata: { task, timeout }
+    },
+    { timeout }
+  );
+  if (!reviewResult.ok) {
+    return Err(new CLIError(`Agent task failed: ${reviewResult.error.message}`, ExitCode.ERROR));
   }
   const review = reviewResult.value;
   return Ok({
@@ -2263,7 +1331,7 @@ function createRunCommand() {
     const globalOpts = cmd.optsWithGlobals();
     if (opts.persona) {
       const personasDir = resolvePersonasDir();
-      const filePath = path17.join(personasDir, `${opts.persona}.yaml`);
+      const filePath = path11.join(personasDir, `${opts.persona}.yaml`);
       const personaResult = loadPersona(filePath);
       if (!personaResult.ok) {
         logger.error(personaResult.error.message);
@@ -2444,8 +1512,8 @@ function createAgentCommand() {
 
 // src/commands/add.ts
 import { Command as Command14 } from "commander";
-import * as fs9 from "fs";
-import * as path18 from "path";
+import * as fs3 from "fs";
+import * as path12 from "path";
 var LAYER_INDEX_TEMPLATE = (name) => `// ${name} layer
 // Add your ${name} exports here
 
@@ -2489,61 +1557,61 @@ async function runAdd(componentType, name, options) {
   try {
     switch (componentType) {
       case "layer": {
-        const layerDir = path18.join(cwd, "src", name);
-        if (!fs9.existsSync(layerDir)) {
-          fs9.mkdirSync(layerDir, { recursive: true });
+        const layerDir = path12.join(cwd, "src", name);
+        if (!fs3.existsSync(layerDir)) {
+          fs3.mkdirSync(layerDir, { recursive: true });
           created.push(`src/${name}/`);
         }
-        const indexPath = path18.join(layerDir, "index.ts");
-        if (!fs9.existsSync(indexPath)) {
-          fs9.writeFileSync(indexPath, LAYER_INDEX_TEMPLATE(name));
+        const indexPath = path12.join(layerDir, "index.ts");
+        if (!fs3.existsSync(indexPath)) {
+          fs3.writeFileSync(indexPath, LAYER_INDEX_TEMPLATE(name));
           created.push(`src/${name}/index.ts`);
         }
         break;
       }
       case "module": {
-        const modulePath = path18.join(cwd, "src", `${name}.ts`);
-        if (fs9.existsSync(modulePath)) {
+        const modulePath = path12.join(cwd, "src", `${name}.ts`);
+        if (fs3.existsSync(modulePath)) {
           return Err(new CLIError(`Module ${name} already exists`, ExitCode.ERROR));
         }
-        fs9.writeFileSync(modulePath, MODULE_TEMPLATE(name));
+        fs3.writeFileSync(modulePath, MODULE_TEMPLATE(name));
         created.push(`src/${name}.ts`);
         break;
       }
       case "doc": {
-        const docsDir = path18.join(cwd, "docs");
-        if (!fs9.existsSync(docsDir)) {
-          fs9.mkdirSync(docsDir, { recursive: true });
+        const docsDir = path12.join(cwd, "docs");
+        if (!fs3.existsSync(docsDir)) {
+          fs3.mkdirSync(docsDir, { recursive: true });
         }
-        const docPath = path18.join(docsDir, `${name}.md`);
-        if (fs9.existsSync(docPath)) {
+        const docPath = path12.join(docsDir, `${name}.md`);
+        if (fs3.existsSync(docPath)) {
           return Err(new CLIError(`Doc ${name} already exists`, ExitCode.ERROR));
         }
-        fs9.writeFileSync(docPath, DOC_TEMPLATE(name));
+        fs3.writeFileSync(docPath, DOC_TEMPLATE(name));
         created.push(`docs/${name}.md`);
         break;
       }
       case "skill": {
-        const { generateSkillFiles: generateSkillFiles2 } = await import("./create-skill-UZOHMXRU.js");
+        const { generateSkillFiles: generateSkillFiles2 } = await import("./create-skill-LUWO46WF.js");
         generateSkillFiles2({
           name,
           description: `${name} skill`,
-          outputDir: path18.join(cwd, "agents", "skills", "claude-code")
+          outputDir: path12.join(cwd, "agents", "skills", "claude-code")
         });
         created.push(`agents/skills/claude-code/${name}/skill.yaml`);
         created.push(`agents/skills/claude-code/${name}/SKILL.md`);
         break;
       }
       case "persona": {
-        const personasDir = path18.join(cwd, "agents", "personas");
-        if (!fs9.existsSync(personasDir)) {
-          fs9.mkdirSync(personasDir, { recursive: true });
+        const personasDir = path12.join(cwd, "agents", "personas");
+        if (!fs3.existsSync(personasDir)) {
+          fs3.mkdirSync(personasDir, { recursive: true });
         }
-        const personaPath = path18.join(personasDir, `${name}.yaml`);
-        if (fs9.existsSync(personaPath)) {
+        const personaPath = path12.join(personasDir, `${name}.yaml`);
+        if (fs3.existsSync(personaPath)) {
           return Err(new CLIError(`Persona ${name} already exists`, ExitCode.ERROR));
         }
-        fs9.writeFileSync(
+        fs3.writeFileSync(
           personaPath,
           `name: ${name}
 description: ${name} persona
@@ -2601,346 +1669,6 @@ import { Command as Command17 } from "commander";
 
 // src/commands/linter/generate.ts
 import { Command as Command15 } from "commander";
-
-// ../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 {
@@ -3069,176 +1797,46 @@ function createListCommand() {
 
 // src/commands/persona/generate.ts
 import { Command as Command19 } from "commander";
-import * as fs13 from "fs";
-import * as path22 from "path";
-
-// src/utils/string.ts
-function toKebabCase(name) {
-  return name.toLowerCase().replace(/\s+/g, "-");
-}
-
-// src/persona/generators/runtime.ts
-function generateRuntime(persona) {
-  try {
-    const config = {
-      name: toKebabCase(persona.name),
-      skills: persona.skills,
-      steps: persona.steps,
-      timeout: persona.config.timeout,
-      severity: persona.config.severity
-    };
-    return Ok(JSON.stringify(config, null, 2));
-  } catch (error) {
-    return Err(
-      new Error(
-        `Failed to generate runtime config: ${error instanceof Error ? error.message : String(error)}`
-      )
-    );
-  }
-}
-
-// src/persona/generators/agents-md.ts
-function formatTrigger(trigger) {
-  switch (trigger.event) {
-    case "on_pr": {
-      const paths = trigger.conditions?.paths?.join(", ") ?? "all files";
-      return `On PR (${paths})`;
+import * as fs4 from "fs";
+import * as path13 from "path";
+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 = path13.join(personasDir, `${name}.yaml`);
+    const personaResult = loadPersona(filePath);
+    if (!personaResult.ok) {
+      logger.error(personaResult.error.message);
+      process.exit(ExitCode.ERROR);
     }
-    case "on_commit": {
-      const branches = trigger.conditions?.branches?.join(", ") ?? "all branches";
-      return `On commit (${branches})`;
-    }
-    case "scheduled":
-      return `Scheduled (cron: ${trigger.cron})`;
-    case "manual":
-      return "Manual";
-  }
-}
-function generateAgentsMd(persona) {
-  try {
-    const triggers = persona.triggers.map(formatTrigger).join(", ");
-    const skills = persona.skills.join(", ");
-    const commands = persona.steps.filter((s) => "command" in s).map((s) => `\`harness ${s.command}\``).join(", ");
-    const stepSkills = persona.steps.filter((s) => "skill" in s).map((s) => `\`harness skill run ${s.skill}\``).join(", ");
-    const allCommands = [commands, stepSkills].filter(Boolean).join(", ");
-    const fragment = `## ${persona.name} Agent
-
-**Role:** ${persona.role}
-
-**Triggers:** ${triggers}
-
-**Skills:** ${skills}
-
-**When this agent flags an issue:** Fix violations before merging. Run ${allCommands} locally to validate.
-`;
-    return Ok(fragment);
-  } catch (error) {
-    return Err(
-      new Error(
-        `Failed to generate AGENTS.md fragment: ${error instanceof Error ? error.message : String(error)}`
-      )
-    );
-  }
-}
-
-// src/persona/generators/ci-workflow.ts
-import YAML2 from "yaml";
-function buildGitHubTriggers(triggers) {
-  const on = {};
-  for (const trigger of triggers) {
-    switch (trigger.event) {
-      case "on_pr": {
-        const prConfig = {};
-        if (trigger.conditions?.paths) prConfig.paths = trigger.conditions.paths;
-        on.pull_request = prConfig;
-        break;
-      }
-      case "on_commit": {
-        const pushConfig = {};
-        if (trigger.conditions?.branches) pushConfig.branches = trigger.conditions.branches;
-        on.push = pushConfig;
-        break;
-      }
-      case "scheduled":
-        on.schedule = [{ cron: trigger.cron }];
-        break;
-    }
-  }
-  return on;
-}
-function generateCIWorkflow(persona, platform) {
-  try {
-    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" },
-      { uses: "actions/setup-node@v4", with: { "node-version": "20" } },
-      { uses: "pnpm/action-setup@v4", with: { run_install: "frozen" } }
-    ];
-    const commandSteps = persona.steps.filter((s) => "command" in s);
-    for (const step of commandSteps) {
-      const severityFlag = severity ? ` --severity ${severity}` : "";
-      steps.push({ run: `npx harness ${step.command}${severityFlag}` });
-    }
-    const workflow = {
-      name: persona.name,
-      on: buildGitHubTriggers(persona.triggers),
-      jobs: {
-        enforce: {
-          "runs-on": "ubuntu-latest",
-          steps
-        }
-      }
-    };
-    return Ok(YAML2.stringify(workflow, { lineWidth: 0 }));
-  } catch (error) {
-    return Err(
-      new Error(
-        `Failed to generate CI workflow: ${error instanceof Error ? error.message : String(error)}`
-      )
-    );
-  }
-}
-
-// src/commands/persona/generate.ts
-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 = 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 = 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 = path22.join(outputDir, `${slug}.runtime.json`);
-        fs13.mkdirSync(path22.dirname(outPath), { recursive: true });
-        fs13.writeFileSync(outPath, result.value);
-        generated.push(outPath);
-      }
+    const persona = personaResult.value;
+    const outputDir = path13.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 = path13.join(outputDir, `${slug}.runtime.json`);
+        fs4.mkdirSync(path13.dirname(outPath), { recursive: true });
+        fs4.writeFileSync(outPath, result.value);
+        generated.push(outPath);
+      }
     }
     if (!only || only === "agents-md") {
       const result = generateAgentsMd(persona);
       if (result.ok) {
-        const outPath = path22.join(outputDir, `${slug}.agents.md`);
-        fs13.writeFileSync(outPath, result.value);
+        const outPath = path13.join(outputDir, `${slug}.agents.md`);
+        fs4.writeFileSync(outPath, result.value);
         generated.push(outPath);
       }
     }
     if (!only || only === "ci") {
       const result = generateCIWorkflow(persona, "github");
       if (result.ok) {
-        const outPath = path22.join(outputDir, ".github", "workflows", `${slug}.yml`);
-        fs13.mkdirSync(path22.dirname(outPath), { recursive: true });
-        fs13.writeFileSync(outPath, result.value);
+        const outPath = path13.join(outputDir, ".github", "workflows", `${slug}.yml`);
+        fs4.mkdirSync(path13.dirname(outPath), { recursive: true });
+        fs4.writeFileSync(outPath, result.value);
         generated.push(outPath);
       }
     }
@@ -3263,26 +1861,26 @@ import { Command as Command25 } from "commander";
 
 // src/commands/skill/list.ts
 import { Command as Command21 } from "commander";
-import * as fs14 from "fs";
-import * as path23 from "path";
-import { parse as parse4 } from "yaml";
+import * as fs5 from "fs";
+import * as path14 from "path";
+import { parse } from "yaml";
 function createListCommand2() {
   return new Command21("list").description("List available skills").action(async (_opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const skillsDir = resolveSkillsDir();
-    if (!fs14.existsSync(skillsDir)) {
+    if (!fs5.existsSync(skillsDir)) {
       logger.info("No skills directory found.");
       process.exit(ExitCode.SUCCESS);
       return;
     }
-    const entries = fs14.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+    const entries = fs5.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
     const skills = [];
     for (const name of entries) {
-      const yamlPath = path23.join(skillsDir, name, "skill.yaml");
-      if (!fs14.existsSync(yamlPath)) continue;
+      const yamlPath = path14.join(skillsDir, name, "skill.yaml");
+      if (!fs5.existsSync(yamlPath)) continue;
       try {
-        const raw = fs14.readFileSync(yamlPath, "utf-8");
-        const parsed = parse4(raw);
+        const raw = fs5.readFileSync(yamlPath, "utf-8");
+        const parsed = parse(raw);
         const result = SkillMetadataSchema.safeParse(parsed);
         if (result.success) {
           skills.push(result.data);
@@ -3312,9 +1910,9 @@ function createListCommand2() {
 
 // src/commands/skill/run.ts
 import { Command as Command22 } from "commander";
-import * as fs15 from "fs";
-import * as path24 from "path";
-import { parse as parse5 } from "yaml";
+import * as fs6 from "fs";
+import * as path15 from "path";
+import { parse as parse2 } from "yaml";
 
 // src/skill/complexity.ts
 import { execFileSync as execFileSync2 } from "child_process";
@@ -3403,18 +2001,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 = path24.join(skillsDir, name);
-    if (!fs15.existsSync(skillDir)) {
+    const skillDir = path15.join(skillsDir, name);
+    if (!fs6.existsSync(skillDir)) {
       logger.error(`Skill not found: ${name}`);
       process.exit(ExitCode.ERROR);
       return;
     }
-    const yamlPath = path24.join(skillDir, "skill.yaml");
+    const yamlPath = path15.join(skillDir, "skill.yaml");
     let metadata = null;
-    if (fs15.existsSync(yamlPath)) {
+    if (fs6.existsSync(yamlPath)) {
       try {
-        const raw = fs15.readFileSync(yamlPath, "utf-8");
-        const parsed = parse5(raw);
+        const raw = fs6.readFileSync(yamlPath, "utf-8");
+        const parsed = parse2(raw);
         const result = SkillMetadataSchema.safeParse(parsed);
         if (result.success) metadata = result.data;
       } catch {
@@ -3424,17 +2022,17 @@ function createRunCommand2() {
     if (metadata?.phases && metadata.phases.length > 0) {
       const requested = opts.complexity ?? "auto";
       if (requested === "auto") {
-        const projectPath2 = opts.path ? path24.resolve(opts.path) : process.cwd();
+        const projectPath2 = opts.path ? path15.resolve(opts.path) : process.cwd();
         complexity = detectComplexity(projectPath2);
       } else {
         complexity = requested;
       }
     }
     let principles;
-    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");
+    const projectPath = opts.path ? path15.resolve(opts.path) : process.cwd();
+    const principlesPath = path15.join(projectPath, "docs", "principles.md");
+    if (fs6.existsSync(principlesPath)) {
+      principles = fs6.readFileSync(principlesPath, "utf-8");
     }
     let priorState;
     let stateWarning;
@@ -3449,16 +2047,16 @@ function createRunCommand2() {
       }
       if (metadata?.state.persistent && metadata.state.files.length > 0) {
         for (const stateFilePath of metadata.state.files) {
-          const fullPath = path24.join(projectPath, stateFilePath);
-          if (fs15.existsSync(fullPath)) {
-            const stat = fs15.statSync(fullPath);
+          const fullPath = path15.join(projectPath, stateFilePath);
+          if (fs6.existsSync(fullPath)) {
+            const stat = fs6.statSync(fullPath);
             if (stat.isDirectory()) {
-              const files = fs15.readdirSync(fullPath).map((f) => ({ name: f, mtime: fs15.statSync(path24.join(fullPath, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
+              const files = fs6.readdirSync(fullPath).map((f) => ({ name: f, mtime: fs6.statSync(path15.join(fullPath, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
               if (files.length > 0) {
-                priorState = fs15.readFileSync(path24.join(fullPath, files[0].name), "utf-8");
+                priorState = fs6.readFileSync(path15.join(fullPath, files[0].name), "utf-8");
               }
             } else {
-              priorState = fs15.readFileSync(fullPath, "utf-8");
+              priorState = fs6.readFileSync(fullPath, "utf-8");
             }
             break;
           }
@@ -3477,17 +2075,17 @@ function createRunCommand2() {
       ...stateWarning !== void 0 && { stateWarning },
       party: opts.party
     });
-    const skillMdPath = path24.join(skillDir, "SKILL.md");
-    if (!fs15.existsSync(skillMdPath)) {
+    const skillMdPath = path15.join(skillDir, "SKILL.md");
+    if (!fs6.existsSync(skillMdPath)) {
       logger.error(`SKILL.md not found for skill: ${name}`);
       process.exit(ExitCode.ERROR);
       return;
     }
-    let content = fs15.readFileSync(skillMdPath, "utf-8");
+    let content = fs6.readFileSync(skillMdPath, "utf-8");
     if (metadata?.state.persistent && opts.path) {
-      const stateFile = path24.join(projectPath, ".harness", "state.json");
-      if (fs15.existsSync(stateFile)) {
-        const stateContent = fs15.readFileSync(stateFile, "utf-8");
+      const stateFile = path15.join(projectPath, ".harness", "state.json");
+      if (fs6.existsSync(stateFile)) {
+        const stateContent = fs6.readFileSync(stateFile, "utf-8");
         content += `
 
 ---
@@ -3505,9 +2103,9 @@ ${stateContent}
 
 // src/commands/skill/validate.ts
 import { Command as Command23 } from "commander";
-import * as fs16 from "fs";
-import * as path25 from "path";
-import { parse as parse6 } from "yaml";
+import * as fs7 from "fs";
+import * as path16 from "path";
+import { parse as parse3 } from "yaml";
 var REQUIRED_SECTIONS = [
   "## When to Use",
   "## Process",
@@ -3519,32 +2117,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 (!fs16.existsSync(skillsDir)) {
+    if (!fs7.existsSync(skillsDir)) {
       logger.info("No skills directory found.");
       process.exit(ExitCode.SUCCESS);
       return;
     }
-    const entries = fs16.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+    const entries = fs7.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
     const errors = [];
     let validated = 0;
     for (const name of entries) {
-      const skillDir = path25.join(skillsDir, name);
-      const yamlPath = path25.join(skillDir, "skill.yaml");
-      const skillMdPath = path25.join(skillDir, "SKILL.md");
-      if (!fs16.existsSync(yamlPath)) {
+      const skillDir = path16.join(skillsDir, name);
+      const yamlPath = path16.join(skillDir, "skill.yaml");
+      const skillMdPath = path16.join(skillDir, "SKILL.md");
+      if (!fs7.existsSync(yamlPath)) {
         errors.push(`${name}: missing skill.yaml`);
         continue;
       }
       try {
-        const raw = fs16.readFileSync(yamlPath, "utf-8");
-        const parsed = parse6(raw);
+        const raw = fs7.readFileSync(yamlPath, "utf-8");
+        const parsed = parse3(raw);
         const result = SkillMetadataSchema.safeParse(parsed);
         if (!result.success) {
           errors.push(`${name}/skill.yaml: ${result.error.message}`);
           continue;
         }
-        if (fs16.existsSync(skillMdPath)) {
-          const mdContent = fs16.readFileSync(skillMdPath, "utf-8");
+        if (fs7.existsSync(skillMdPath)) {
+          const mdContent = fs7.readFileSync(skillMdPath, "utf-8");
           for (const section of REQUIRED_SECTIONS) {
             if (!mdContent.includes(section)) {
               errors.push(`${name}/SKILL.md: missing section "${section}"`);
@@ -3586,28 +2184,28 @@ function createValidateCommand3() {
 
 // src/commands/skill/info.ts
 import { Command as Command24 } from "commander";
-import * as fs17 from "fs";
-import * as path26 from "path";
-import { parse as parse7 } from "yaml";
+import * as fs8 from "fs";
+import * as path17 from "path";
+import { parse as parse4 } 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 = path26.join(skillsDir, name);
-    if (!fs17.existsSync(skillDir)) {
+    const skillDir = path17.join(skillsDir, name);
+    if (!fs8.existsSync(skillDir)) {
       logger.error(`Skill not found: ${name}`);
       process.exit(ExitCode.ERROR);
       return;
     }
-    const yamlPath = path26.join(skillDir, "skill.yaml");
-    if (!fs17.existsSync(yamlPath)) {
+    const yamlPath = path17.join(skillDir, "skill.yaml");
+    if (!fs8.existsSync(yamlPath)) {
       logger.error(`skill.yaml not found for skill: ${name}`);
       process.exit(ExitCode.ERROR);
       return;
     }
     try {
-      const raw = fs17.readFileSync(yamlPath, "utf-8");
-      const parsed = parse7(raw);
+      const raw = fs8.readFileSync(yamlPath, "utf-8");
+      const parsed = parse4(raw);
       const result = SkillMetadataSchema.safeParse(parsed);
       if (!result.success) {
         logger.error(`Invalid skill.yaml: ${result.error.message}`);
@@ -3660,11 +2258,11 @@ import { Command as Command30 } from "commander";
 
 // src/commands/state/show.ts
 import { Command as Command26 } from "commander";
-import * as path27 from "path";
+import * as path18 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 = path27.resolve(opts.path);
+    const projectPath = path18.resolve(opts.path);
     const result = await loadState(projectPath, opts.stream);
     if (!result.ok) {
       logger.error(result.error.message);
@@ -3705,12 +2303,12 @@ Decisions: ${state.decisions.length}`);
 
 // src/commands/state/reset.ts
 import { Command as Command27 } from "commander";
-import * as fs18 from "fs";
-import * as path28 from "path";
+import * as fs9 from "fs";
+import * as path19 from "path";
 import * as readline from "readline";
 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 = path28.resolve(opts.path);
+    const projectPath = path19.resolve(opts.path);
     let statePath;
     if (opts.stream) {
       const streamResult = await resolveStreamPath(projectPath, { stream: opts.stream });
@@ -3719,708 +2317,137 @@ function createResetCommand() {
         process.exit(ExitCode.ERROR);
         return;
       }
-      statePath = path28.join(streamResult.value, "state.json");
+      statePath = path19.join(streamResult.value, "state.json");
     } else {
-      statePath = path28.join(projectPath, ".harness", "state.json");
-    }
-    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((resolve24) => {
-        rl.question("Reset project state? This cannot be undone. [y/N] ", resolve24);
-      });
-      rl.close();
-      if (answer.toLowerCase() !== "y" && answer.toLowerCase() !== "yes") {
-        logger.info("Reset cancelled.");
-        process.exit(ExitCode.SUCCESS);
-        return;
-      }
-    }
-    try {
-      fs18.unlinkSync(statePath);
-      logger.success("Project state reset.");
-    } catch (e) {
-      logger.error(`Failed to reset state: ${e instanceof Error ? e.message : String(e)}`);
-      process.exit(ExitCode.ERROR);
-      return;
-    }
-    process.exit(ExitCode.SUCCESS);
-  });
-}
-
-// src/commands/state/learn.ts
-import { Command as Command28 } from "commander";
-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 = path29.resolve(opts.path);
-    const result = await appendLearning(projectPath, message, void 0, void 0, opts.stream);
-    if (!result.ok) {
-      logger.error(result.error.message);
-      process.exit(ExitCode.ERROR);
-      return;
-    }
-    logger.success(`Learning recorded.`);
-    process.exit(ExitCode.SUCCESS);
-  });
-}
-
-// src/commands/state/streams.ts
-import { Command as Command29 } from "commander";
-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 = path30.resolve(opts.path);
-    const indexResult = await loadStreamIndex(projectPath);
-    const result = await listStreams(projectPath);
-    if (!result.ok) {
-      logger.error(result.error.message);
-      process.exit(ExitCode.ERROR);
-      return;
-    }
-    const active = indexResult.ok ? indexResult.value.activeStream : null;
-    if (globalOpts.json) {
-      logger.raw({ activeStream: active, streams: result.value });
-    } else {
-      if (result.value.length === 0) {
-        console.log("No streams found.");
-      }
-      for (const s of result.value) {
-        const marker = s.name === active ? " (active)" : "";
-        const branch = s.branch ? ` [${s.branch}]` : "";
-        console.log(`  ${s.name}${marker}${branch} \u2014 last active: ${s.lastActiveAt}`);
-      }
-    }
-    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 = path30.resolve(opts.path);
-    const result = await createStream(projectPath, name, opts.branch);
-    if (!result.ok) {
-      logger.error(result.error.message);
-      process.exit(ExitCode.ERROR);
-      return;
-    }
-    logger.success(`Stream '${name}' created.`);
-    process.exit(ExitCode.SUCCESS);
-  });
-  command.command("archive <name>").description("Archive a stream").option("--path <path>", "Project root path", ".").action(async (name, opts) => {
-    const projectPath = path30.resolve(opts.path);
-    const result = await archiveStream(projectPath, name);
-    if (!result.ok) {
-      logger.error(result.error.message);
-      process.exit(ExitCode.ERROR);
-      return;
-    }
-    logger.success(`Stream '${name}' archived.`);
-    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 = path30.resolve(opts.path);
-    const result = await setActiveStream(projectPath, name);
-    if (!result.ok) {
-      logger.error(result.error.message);
-      process.exit(ExitCode.ERROR);
-      return;
-    }
-    logger.success(`Active stream set to '${name}'.`);
-    process.exit(ExitCode.SUCCESS);
-  });
-  return command;
-}
-
-// src/commands/state/index.ts
-function createStateCommand() {
-  const command = new Command30("state").description("Project state management commands");
-  command.addCommand(createShowCommand());
-  command.addCommand(createResetCommand());
-  command.addCommand(createLearnCommand());
-  command.addCommand(createStreamsCommand());
-  return command;
-}
-
-// src/commands/check-phase-gate.ts
-import { Command as Command31 } from "commander";
-import * as path31 from "path";
-import * as fs19 from "fs";
-function resolveSpecPath(implFile, implPattern, specPattern, cwd) {
-  const relImpl = path31.relative(cwd, implFile).replace(/\\/g, "/");
-  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 : path31.basename(firstSegment, path31.extname(firstSegment));
-  const specRelative = specPattern.replace("{feature}", feature);
-  return path31.resolve(cwd, specRelative);
-}
-async function runCheckPhaseGate(options) {
-  const configResult = resolveConfig(options.configPath);
-  if (!configResult.ok) {
-    return configResult;
-  }
-  const config = configResult.value;
-  const cwd = options.cwd ?? (options.configPath ? path31.dirname(path31.resolve(options.configPath)) : process.cwd());
-  if (!config.phaseGates?.enabled) {
-    return Ok({
-      pass: true,
-      skipped: true,
-      missingSpecs: [],
-      checkedFiles: 0
-    });
-  }
-  const phaseGates = config.phaseGates;
-  const missingSpecs = [];
-  let checkedFiles = 0;
-  for (const mapping of phaseGates.mappings) {
-    const implFiles = await findFiles(mapping.implPattern, cwd);
-    for (const implFile of implFiles) {
-      checkedFiles++;
-      const expectedSpec = resolveSpecPath(implFile, mapping.implPattern, mapping.specPattern, cwd);
-      if (!fs19.existsSync(expectedSpec)) {
-        missingSpecs.push({
-          implFile: path31.relative(cwd, implFile).replace(/\\/g, "/"),
-          expectedSpec: path31.relative(cwd, expectedSpec).replace(/\\/g, "/")
-        });
-      }
-    }
-  }
-  const pass = missingSpecs.length === 0;
-  return Ok({
-    pass,
-    skipped: false,
-    severity: phaseGates.severity,
-    missingSpecs,
-    checkedFiles
-  });
-}
-function createCheckPhaseGateCommand() {
-  const command = new Command31("check-phase-gate").description("Verify that implementation files have matching spec documents").action(async (_opts, cmd) => {
-    const globalOpts = cmd.optsWithGlobals();
-    const mode = globalOpts.json ? OutputMode.JSON : globalOpts.quiet ? OutputMode.QUIET : globalOpts.verbose ? OutputMode.VERBOSE : OutputMode.TEXT;
-    const formatter = new OutputFormatter(mode);
-    const result = await runCheckPhaseGate({
-      configPath: globalOpts.config,
-      json: globalOpts.json,
-      verbose: globalOpts.verbose,
-      quiet: globalOpts.quiet
-    });
-    if (!result.ok) {
-      if (mode === OutputMode.JSON) {
-        console.log(JSON.stringify({ error: result.error.message }));
-      } else {
-        logger.error(result.error.message);
-      }
-      process.exit(result.error.exitCode);
-    }
-    const value = result.value;
-    if (value.skipped) {
-      if (mode === OutputMode.JSON) {
-        console.log(formatter.format(value));
-      } else if (mode !== OutputMode.QUIET) {
-        logger.dim("Phase gates not enabled, skipping.");
-      }
-      process.exit(ExitCode.SUCCESS);
-    }
-    const output = formatter.formatValidation({
-      valid: value.pass,
-      issues: value.missingSpecs.map((m) => ({
-        file: m.implFile,
-        message: `Missing spec: ${m.expectedSpec}`
-      }))
-    });
-    if (output) {
-      console.log(output);
-    }
-    const summary = formatter.formatSummary(
-      "Phase gate check",
-      `${value.checkedFiles} files checked, ${value.missingSpecs.length} missing specs`,
-      value.pass
-    );
-    if (summary) {
-      console.log(summary);
-    }
-    if (!value.pass && value.severity === "error") {
-      process.exit(ExitCode.VALIDATION_FAILED);
-    }
-    process.exit(ExitCode.SUCCESS);
-  });
-  return command;
-}
-
-// src/commands/generate-slash-commands.ts
-import { Command as Command32 } from "commander";
-import fs22 from "fs";
-import path34 from "path";
-import os2 from "os";
-import readline2 from "readline";
-
-// src/slash-commands/normalize.ts
-import fs20 from "fs";
-import path32 from "path";
-import { parse as parse8 } from "yaml";
-
-// src/slash-commands/normalize-name.ts
-function normalizeName(skillName) {
-  let name = skillName;
-  if (name.startsWith("harness-")) {
-    name = name.slice("harness-".length);
-  }
-  name = name.replace(/-harness-/g, "-");
-  if (name.endsWith("-harness")) {
-    name = name.slice(0, -"-harness".length);
-  }
-  return name;
-}
-
-// src/slash-commands/normalize.ts
-function normalizeSkills(skillSources, platforms) {
-  const specs = [];
-  const nameMap = /* @__PURE__ */ new Map();
-  for (const { dir: skillsDir, source } of skillSources) {
-    if (!fs20.existsSync(skillsDir)) continue;
-    const entries = fs20.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory());
-    for (const entry of entries) {
-      const yamlPath = path32.join(skillsDir, entry.name, "skill.yaml");
-      if (!fs20.existsSync(yamlPath)) continue;
-      let raw;
-      try {
-        raw = fs20.readFileSync(yamlPath, "utf-8");
-      } catch {
-        continue;
-      }
-      const parsed = parse8(raw);
-      const result = SkillMetadataSchema.safeParse(parsed);
-      if (!result.success) {
-        console.warn(`Skipping ${entry.name}: invalid skill.yaml`);
-        continue;
-      }
-      const meta = result.data;
-      const matchesPlatform = platforms.some((p) => meta.platforms.includes(p));
-      if (!matchesPlatform) continue;
-      const normalized = normalizeName(meta.name);
-      const existing = nameMap.get(normalized);
-      if (existing) {
-        if (existing.source === source) {
-          throw new Error(
-            `Name collision: skills "${existing.skillName}" and "${meta.name}" both normalize to "${normalized}"`
-          );
-        }
-        continue;
-      }
-      nameMap.set(normalized, { skillName: meta.name, source });
-      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(),
-        path32.join(skillsDir, entry.name, "SKILL.md")
-      );
-      const skillYamlRelative = path32.relative(
-        process.cwd(),
-        path32.join(skillsDir, entry.name, "skill.yaml")
-      );
-      const args = (meta.cli?.args ?? []).map((a) => ({
-        name: a.name,
-        description: a.description ?? "",
-        required: a.required ?? false
-      }));
-      const tools = [...meta.tools ?? []];
-      if (!tools.includes("Read")) {
-        tools.push("Read");
-      }
-      const contextLines = [];
-      if (meta.cognitive_mode) {
-        contextLines.push(`Cognitive mode: ${meta.cognitive_mode}`);
-      }
-      if (meta.type) {
-        contextLines.push(`Type: ${meta.type}`);
-      }
-      if (meta.state?.persistent) {
-        const files = meta.state.files?.join(", ") ?? "";
-        contextLines.push(`State: persistent${files ? ` (files: ${files})` : ""}`);
-      }
-      const objectiveLines = [meta.description];
-      if (meta.phases && meta.phases.length > 0) {
-        objectiveLines.push("");
-        objectiveLines.push("Phases:");
-        for (const phase of meta.phases) {
-          const req = phase.required !== false ? "" : " (optional)";
-          objectiveLines.push(`- ${phase.name}: ${phase.description}${req}`);
-        }
-      }
-      const executionContextLines = [];
-      if (skillMdContent) {
-        executionContextLines.push(`@${skillMdRelative}`);
-        executionContextLines.push(`@${skillYamlRelative}`);
-      }
-      const processLines = [];
-      if (meta.mcp?.tool) {
-        processLines.push(
-          `1. Try: invoke mcp__harness__${meta.mcp.tool} with skill: "${meta.name}"`
-        );
-        processLines.push(`2. If MCP unavailable: read SKILL.md and follow its workflow directly`);
-        processLines.push(`3. Pass through any arguments provided by the user`);
-      } else {
-        processLines.push(`1. Read SKILL.md and follow its workflow directly`);
-        processLines.push(`2. Pass through any arguments provided by the user`);
-      }
-      specs.push({
-        name: normalized,
-        namespace: "harness",
-        fullName: `harness:${normalized}`,
-        description: meta.description,
-        version: meta.version,
-        ...meta.cognitive_mode ? { cognitiveMode: meta.cognitive_mode } : {},
-        tools,
-        args,
-        skillYamlName: meta.name,
-        sourceDir: entry.name,
-        skillsBaseDir: skillsDir,
-        source,
-        prompt: {
-          context: contextLines.join("\n"),
-          objective: objectiveLines.join("\n"),
-          executionContext: executionContextLines.join("\n"),
-          process: processLines.join("\n")
-        }
-      });
-    }
-  }
-  return specs;
-}
-
-// src/slash-commands/types.ts
-var VALID_PLATFORMS = ["claude-code", "gemini-cli"];
-var GENERATED_HEADER_CLAUDE = "<!-- Generated by harness generate-slash-commands. Do not edit. -->";
-var GENERATED_HEADER_GEMINI = "# Generated by harness generate-slash-commands. Do not edit.";
-
-// src/slash-commands/argument-hint.ts
-function buildArgumentHint(args) {
-  return args.map((arg) => arg.required ? `--${arg.name} <${arg.name}>` : `[--${arg.name} <${arg.name}>]`).join(" ");
-}
-
-// src/slash-commands/render-claude-code.ts
-function renderClaudeCode(spec) {
-  const lines = ["---"];
-  lines.push(`name: ${spec.fullName}`);
-  lines.push(`description: ${spec.description}`);
-  const hint = buildArgumentHint(spec.args);
-  if (hint) {
-    lines.push(`argument-hint: "${hint}"`);
-  }
-  if (spec.tools.length > 0) {
-    lines.push("allowed-tools:");
-    for (const tool of spec.tools) {
-      lines.push(`  - ${tool}`);
-    }
-  }
-  lines.push("---");
-  lines.push("");
-  lines.push(GENERATED_HEADER_CLAUDE);
-  lines.push("");
-  lines.push("<context>");
-  lines.push(spec.prompt.context);
-  lines.push("</context>");
-  lines.push("");
-  lines.push("<objective>");
-  lines.push(spec.prompt.objective);
-  lines.push("</objective>");
-  lines.push("");
-  if (spec.prompt.executionContext) {
-    lines.push("<execution_context>");
-    lines.push(spec.prompt.executionContext);
-    lines.push("</execution_context>");
-    lines.push("");
-  }
-  lines.push("<process>");
-  lines.push(spec.prompt.process);
-  lines.push("</process>");
-  lines.push("");
-  return lines.join("\n");
-}
-
-// src/slash-commands/render-gemini.ts
-function escapeTomlLiteral(content) {
-  return content.replace(/'''/g, "''\\'''");
-}
-function renderGemini(spec, skillMdContent, skillYamlContent) {
-  const lines = [GENERATED_HEADER_GEMINI];
-  const safeDesc = spec.description.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
-  lines.push(`description = "${safeDesc}"`);
-  lines.push("prompt = '''");
-  lines.push("<context>");
-  lines.push(spec.prompt.context);
-  lines.push("</context>");
-  lines.push("");
-  lines.push("<objective>");
-  lines.push(spec.prompt.objective);
-  lines.push("</objective>");
-  lines.push("");
-  if (skillMdContent || skillYamlContent) {
-    lines.push("<execution_context>");
-    if (skillMdContent) {
-      const mdPath = spec.prompt.executionContext.split("\n")[0]?.replace(/^@/, "") ?? "";
-      lines.push(`--- SKILL.md (${mdPath}) ---`);
-      lines.push(escapeTomlLiteral(skillMdContent));
-      lines.push("");
-    }
-    if (skillYamlContent) {
-      const refs = spec.prompt.executionContext.split("\n");
-      const yamlPath = (refs[1] ?? refs[0] ?? "").replace(/^@/, "");
-      lines.push(`--- skill.yaml (${yamlPath}) ---`);
-      lines.push(escapeTomlLiteral(skillYamlContent));
-    }
-    lines.push("</execution_context>");
-    lines.push("");
-  }
-  const geminiProcess = spec.prompt.process.replace(
-    "read SKILL.md and follow its workflow directly",
-    "follow the SKILL.md workflow provided above directly"
-  );
-  lines.push("<process>");
-  lines.push(geminiProcess);
-  lines.push("</process>");
-  lines.push("'''");
-  lines.push("");
-  return lines.join("\n");
-}
-
-// src/slash-commands/sync.ts
-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. -->";
-
-// src/slash-commands/sync.ts
-function computeSyncPlan(outputDir, rendered) {
-  const added = [];
-  const updated = [];
-  const removed = [];
-  const unchanged = [];
-  for (const [filename, content] of rendered) {
-    const filePath = path33.join(outputDir, filename);
-    if (!fs21.existsSync(filePath)) {
-      added.push(filename);
-    } else {
-      const existing = fs21.readFileSync(filePath, "utf-8");
-      if (existing === content) {
-        unchanged.push(filename);
-      } else {
-        updated.push(filename);
-      }
-    }
-  }
-  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 = 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);
-      }
+      statePath = path19.join(projectPath, ".harness", "state.json");
     }
-  }
-  return { added, updated, removed, unchanged };
-}
-function applySyncPlan(outputDir, rendered, plan, deleteOrphans) {
-  fs21.mkdirSync(outputDir, { recursive: true });
-  for (const filename of [...plan.added, ...plan.updated]) {
-    const content = rendered.get(filename);
-    if (content !== void 0) {
-      fs21.writeFileSync(path33.join(outputDir, filename), content);
+    if (!fs9.existsSync(statePath)) {
+      logger.info("No state file found. Nothing to reset.");
+      process.exit(ExitCode.SUCCESS);
+      return;
     }
-  }
-  if (deleteOrphans) {
-    for (const filename of plan.removed) {
-      const filePath = path33.join(outputDir, filename);
-      if (fs21.existsSync(filePath)) {
-        fs21.unlinkSync(filePath);
+    if (!opts.yes) {
+      const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+      const answer = await new Promise((resolve20) => {
+        rl.question("Reset project state? This cannot be undone. [y/N] ", resolve20);
+      });
+      rl.close();
+      if (answer.toLowerCase() !== "y" && answer.toLowerCase() !== "yes") {
+        logger.info("Reset cancelled.");
+        process.exit(ExitCode.SUCCESS);
+        return;
       }
     }
-  }
+    try {
+      fs9.unlinkSync(statePath);
+      logger.success("Project state reset.");
+    } catch (e) {
+      logger.error(`Failed to reset state: ${e instanceof Error ? e.message : String(e)}`);
+      process.exit(ExitCode.ERROR);
+      return;
+    }
+    process.exit(ExitCode.SUCCESS);
+  });
 }
 
-// src/commands/generate-slash-commands.ts
-function resolveOutputDir(platform, opts) {
-  if (opts.output) {
-    return path34.join(opts.output, "harness");
-  }
-  if (opts.global) {
-    const home = os2.homedir();
-    return platform === "claude-code" ? path34.join(home, ".claude", "commands", "harness") : path34.join(home, ".gemini", "commands", "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((resolve24) => {
-    rl.question(`
-Remove ${files.length} orphaned command(s)? (y/N) `, (answer) => {
-      rl.close();
-      resolve24(answer.toLowerCase() === "y");
-    });
+// src/commands/state/learn.ts
+import { Command as Command28 } from "commander";
+import * as path20 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 = path20.resolve(opts.path);
+    const result = await appendLearning(projectPath, message, void 0, void 0, opts.stream);
+    if (!result.ok) {
+      logger.error(result.error.message);
+      process.exit(ExitCode.ERROR);
+      return;
+    }
+    logger.success(`Learning recorded.`);
+    process.exit(ExitCode.SUCCESS);
   });
 }
-function generateSlashCommands(opts) {
-  const skillSources = [];
-  if (opts.skillsDir) {
-    skillSources.push({ dir: opts.skillsDir, source: "project" });
-  } else {
-    const projectDir = resolveProjectSkillsDir();
-    if (projectDir) {
-      skillSources.push({ dir: projectDir, source: "project" });
+
+// src/commands/state/streams.ts
+import { Command as Command29 } from "commander";
+import * as path21 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 = path21.resolve(opts.path);
+    const indexResult = await loadStreamIndex(projectPath);
+    const result = await listStreams(projectPath);
+    if (!result.ok) {
+      logger.error(result.error.message);
+      process.exit(ExitCode.ERROR);
+      return;
     }
-    if (opts.includeGlobal || skillSources.length === 0) {
-      const globalDir = resolveGlobalSkillsDir();
-      if (!projectDir || path34.resolve(globalDir) !== path34.resolve(projectDir)) {
-        skillSources.push({ dir: globalDir, source: "global" });
+    const active = indexResult.ok ? indexResult.value.activeStream : null;
+    if (globalOpts.json) {
+      logger.raw({ activeStream: active, streams: result.value });
+    } else {
+      if (result.value.length === 0) {
+        console.log("No streams found.");
       }
-    }
-  }
-  const specs = normalizeSkills(skillSources, opts.platforms);
-  const results = [];
-  for (const platform of opts.platforms) {
-    const outputDir = resolveOutputDir(platform, opts);
-    const ext = fileExtension(platform);
-    const useAbsolutePaths = opts.global;
-    const rendered = /* @__PURE__ */ new Map();
-    for (const spec of specs) {
-      const filename = `${spec.name}${ext}`;
-      if (platform === "claude-code") {
-        const renderSpec = useAbsolutePaths ? {
-          ...spec,
-          prompt: {
-            ...spec.prompt,
-            executionContext: spec.prompt.executionContext.split("\n").map((line) => {
-              if (line.startsWith("@")) {
-                const relPath = line.slice(1);
-                return `@${path34.resolve(relPath)}`;
-              }
-              return line;
-            }).join("\n")
-          }
-        } : spec;
-        rendered.set(filename, renderClaudeCode(renderSpec));
-      } else {
-        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));
+      for (const s of result.value) {
+        const marker = s.name === active ? " (active)" : "";
+        const branch = s.branch ? ` [${s.branch}]` : "";
+        console.log(`  ${s.name}${marker}${branch} \u2014 last active: ${s.lastActiveAt}`);
       }
     }
-    const plan = computeSyncPlan(outputDir, rendered);
-    if (!opts.dryRun) {
-      applySyncPlan(outputDir, rendered, plan, false);
-    }
-    results.push({
-      platform,
-      added: plan.added,
-      updated: plan.updated,
-      removed: plan.removed,
-      unchanged: plan.unchanged,
-      outputDir
-    });
-  }
-  return results;
-}
-async function handleOrphanDeletion(results, opts) {
-  if (opts.dryRun) return;
-  for (const result of results) {
-    if (result.removed.length === 0) continue;
-    const shouldDelete = opts.yes || await confirmDeletion(result.removed);
-    if (shouldDelete) {
-      for (const filename of result.removed) {
-        const filePath = path34.join(result.outputDir, filename);
-        if (fs22.existsSync(filePath)) {
-          fs22.unlinkSync(filePath);
-        }
-      }
+    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 = path21.resolve(opts.path);
+    const result = await createStream(projectPath, name, opts.branch);
+    if (!result.ok) {
+      logger.error(result.error.message);
+      process.exit(ExitCode.ERROR);
+      return;
     }
-  }
-}
-function createGenerateSlashCommandsCommand() {
-  return new Command32("generate-slash-commands").description(
-    "Generate native slash commands for Claude Code and Gemini CLI from skill metadata"
-  ).option("--platforms <list>", "Target platforms (comma-separated)", "claude-code,gemini-cli").option("--global", "Write to global config directories", false).option("--include-global", "Include built-in global skills alongside project skills", false).option("--output <dir>", "Custom output directory").option("--skills-dir <path>", "Skills directory to scan").option("--dry-run", "Show what would change without writing", false).option("--yes", "Skip deletion confirmation prompts", false).action(async (opts, cmd) => {
-    const globalOpts = cmd.optsWithGlobals();
-    const platforms = opts.platforms.split(",").map((p) => p.trim());
-    for (const p of platforms) {
-      if (!VALID_PLATFORMS.includes(p)) {
-        throw new CLIError(
-          `Invalid platform "${p}". Valid platforms: ${VALID_PLATFORMS.join(", ")}`,
-          ExitCode.VALIDATION_FAILED
-        );
-      }
+    logger.success(`Stream '${name}' created.`);
+    process.exit(ExitCode.SUCCESS);
+  });
+  command.command("archive <name>").description("Archive a stream").option("--path <path>", "Project root path", ".").action(async (name, opts) => {
+    const projectPath = path21.resolve(opts.path);
+    const result = await archiveStream(projectPath, name);
+    if (!result.ok) {
+      logger.error(result.error.message);
+      process.exit(ExitCode.ERROR);
+      return;
     }
-    const generateOpts = {
-      platforms,
-      global: opts.global,
-      includeGlobal: opts.includeGlobal,
-      output: opts.output,
-      skillsDir: opts.skillsDir ?? "",
-      dryRun: opts.dryRun,
-      yes: opts.yes
-    };
-    try {
-      const results = generateSlashCommands(generateOpts);
-      if (globalOpts.json) {
-        console.log(JSON.stringify(results, null, 2));
-        return;
-      }
-      const totalCommands = results.reduce(
-        (sum, r) => sum + r.added.length + r.updated.length + r.unchanged.length,
-        0
-      );
-      if (totalCommands === 0) {
-        console.log(
-          "\nNo skills found. Use --include-global to include built-in skills, or create a skill with: harness create-skill"
-        );
-        return;
-      }
-      for (const result of results) {
-        console.log(`
-${result.platform} \u2192 ${result.outputDir}`);
-        if (result.added.length > 0) {
-          console.log(`  + ${result.added.length} new: ${result.added.join(", ")}`);
-        }
-        if (result.updated.length > 0) {
-          console.log(`  ~ ${result.updated.length} updated: ${result.updated.join(", ")}`);
-        }
-        if (result.removed.length > 0) {
-          console.log(`  - ${result.removed.length} removed: ${result.removed.join(", ")}`);
-        }
-        if (result.unchanged.length > 0) {
-          console.log(`  = ${result.unchanged.length} unchanged`);
-        }
-        if (opts.dryRun) {
-          console.log("  (dry run \u2014 no files written)");
-        }
-      }
-      await handleOrphanDeletion(results, { yes: opts.yes, dryRun: opts.dryRun });
-    } catch (error) {
-      handleError(error);
+    logger.success(`Stream '${name}' archived.`);
+    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 = path21.resolve(opts.path);
+    const result = await setActiveStream(projectPath, name);
+    if (!result.ok) {
+      logger.error(result.error.message);
+      process.exit(ExitCode.ERROR);
+      return;
     }
+    logger.success(`Active stream set to '${name}'.`);
+    process.exit(ExitCode.SUCCESS);
   });
+  return command;
+}
+
+// src/commands/state/index.ts
+function createStateCommand() {
+  const command = new Command30("state").description("Project state management commands");
+  command.addCommand(createShowCommand());
+  command.addCommand(createResetCommand());
+  command.addCommand(createLearnCommand());
+  command.addCommand(createStreamsCommand());
+  return command;
 }
 
 // src/commands/ci/index.ts
-import { Command as Command35 } from "commander";
+import { Command as Command33 } from "commander";
 
 // src/commands/ci/check.ts
-import { Command as Command33 } from "commander";
+import { Command as Command31 } from "commander";
 var VALID_CHECKS = ["validate", "deps", "docs", "entropy", "phase-gate"];
 async function runCICheck(options) {
   const configResult = resolveConfig(options.configPath);
@@ -4451,7 +2478,7 @@ function parseFailOn(failOn) {
   return "error";
 }
 function createCheckCommand() {
-  return new Command33("check").description("Run all harness checks for CI (validate, deps, docs, entropy, phase-gate)").option("--skip <checks>", "Comma-separated checks to skip (e.g., entropy,docs)").option("--fail-on <severity>", "Fail on severity level: error (default) or warning", "error").action(async (opts, cmd) => {
+  return new Command31("check").description("Run all harness checks for CI (validate, deps, docs, entropy, phase-gate)").option("--skip <checks>", "Comma-separated checks to skip (e.g., entropy,docs)").option("--fail-on <severity>", "Fail on severity level: error (default) or warning", "error").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const mode = globalOpts.json ? OutputMode.JSON : globalOpts.quiet ? OutputMode.QUIET : globalOpts.verbose ? OutputMode.VERBOSE : OutputMode.TEXT;
     const skip = parseSkip(opts.skip);
@@ -4495,9 +2522,9 @@ function createCheckCommand() {
 }
 
 // src/commands/ci/init.ts
-import { Command as Command34 } from "commander";
-import * as fs23 from "fs";
-import * as path35 from "path";
+import { Command as Command32 } from "commander";
+import * as fs10 from "fs";
+import * as path22 from "path";
 var ALL_CHECKS = ["validate", "deps", "docs", "entropy", "phase-gate"];
 function buildSkipFlag(checks) {
   if (!checks) return "";
@@ -4589,12 +2616,12 @@ function generateCIConfig(options) {
   });
 }
 function detectPlatform() {
-  if (fs23.existsSync(".github")) return "github";
-  if (fs23.existsSync(".gitlab-ci.yml")) return "gitlab";
+  if (fs10.existsSync(".github")) return "github";
+  if (fs10.existsSync(".gitlab-ci.yml")) return "gitlab";
   return null;
 }
 function createInitCommand2() {
-  return new Command34("init").description("Generate CI configuration for harness checks").option("--platform <platform>", "CI platform: github, gitlab, or generic").option("--checks <list>", "Comma-separated list of checks to include").action(async (opts, cmd) => {
+  return new Command32("init").description("Generate CI configuration for harness checks").option("--platform <platform>", "CI platform: github, gitlab, or generic").option("--checks <list>", "Comma-separated list of checks to include").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const platform = opts.platform ?? detectPlatform() ?? "generic";
     const checks = opts.checks ? opts.checks.split(",").map((s) => s.trim()) : void 0;
@@ -4606,12 +2633,12 @@ function createInitCommand2() {
       process.exit(result.error.exitCode);
     }
     const { filename, content } = result.value;
-    const targetPath = path35.resolve(filename);
-    const dir = path35.dirname(targetPath);
-    fs23.mkdirSync(dir, { recursive: true });
-    fs23.writeFileSync(targetPath, content);
+    const targetPath = path22.resolve(filename);
+    const dir = path22.dirname(targetPath);
+    fs10.mkdirSync(dir, { recursive: true });
+    fs10.writeFileSync(targetPath, content);
     if (platform === "generic" && process.platform !== "win32") {
-      fs23.chmodSync(targetPath, "755");
+      fs10.chmodSync(targetPath, "755");
     }
     if (globalOpts.json) {
       console.log(JSON.stringify({ file: filename, platform }));
@@ -4624,18 +2651,18 @@ function createInitCommand2() {
 
 // src/commands/ci/index.ts
 function createCICommand() {
-  const command = new Command35("ci").description("CI/CD integration commands");
+  const command = new Command33("ci").description("CI/CD integration commands");
   command.addCommand(createCheckCommand());
   command.addCommand(createInitCommand2());
   return command;
 }
 
 // src/commands/update.ts
-import { Command as Command36 } from "commander";
+import { Command as Command34 } from "commander";
 import { execFileSync as execFileSync3 } from "child_process";
 import { realpathSync } from "fs";
-import readline3 from "readline";
-import chalk4 from "chalk";
+import readline2 from "readline";
+import chalk3 from "chalk";
 function detectPackageManager() {
   try {
     const argv1 = process.argv[1];
@@ -4687,19 +2714,19 @@ function getInstalledPackages(pm) {
   }
 }
 function prompt(question) {
-  const rl = readline3.createInterface({
+  const rl = readline2.createInterface({
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve24) => {
+  return new Promise((resolve20) => {
     rl.question(question, (answer) => {
       rl.close();
-      resolve24(answer.trim().toLowerCase());
+      resolve20(answer.trim().toLowerCase());
     });
   });
 }
 function createUpdateCommand() {
-  return new Command36("update").description("Update all @harness-engineering packages to the latest version").option("--version <semver>", "Pin @harness-engineering/cli to a specific version").action(async (opts, cmd) => {
+  return new Command34("update").description("Update all @harness-engineering packages to the latest version").option("--version <semver>", "Pin @harness-engineering/cli to a specific version").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const pm = detectPackageManager();
     if (globalOpts.verbose) {
@@ -4721,8 +2748,8 @@ function createUpdateCommand() {
       }
       if (currentVersion) {
         console.log("");
-        logger.info(`Current CLI version: ${chalk4.dim(`v${currentVersion}`)}`);
-        logger.info(`Latest CLI version:  ${chalk4.green(`v${latestCliVersion}`)}`);
+        logger.info(`Current CLI version: ${chalk3.dim(`v${currentVersion}`)}`);
+        logger.info(`Latest CLI version:  ${chalk3.green(`v${latestCliVersion}`)}`);
         console.log("");
       }
     }
@@ -4748,7 +2775,7 @@ function createUpdateCommand() {
     } catch {
       console.log("");
       logger.error("Update failed. You can try manually:");
-      console.log(`  ${chalk4.cyan(installCmd)}`);
+      console.log(`  ${chalk3.cyan(installCmd)}`);
       process.exit(ExitCode.ERROR);
     }
     console.log("");
@@ -4762,277 +2789,17 @@ function createUpdateCommand() {
         });
       } catch {
         logger.warn("Generation failed. Run manually:");
-        console.log(`  ${chalk4.cyan(`harness generate${isGlobal ? " --global" : ""}`)}`);
+        console.log(`  ${chalk3.cyan(`harness generate${isGlobal ? " --global" : ""}`)}`);
       }
     }
     process.exit(ExitCode.SUCCESS);
   });
 }
 
-// src/commands/generate-agent-definitions.ts
-import { Command as Command37 } from "commander";
-import * as fs24 from "fs";
-import * as path36 from "path";
-import * as os3 from "os";
-
-// src/agent-definitions/generator.ts
-var AGENT_DESCRIPTIONS = {
-  "code-reviewer": "Perform code review and address review findings using harness methodology. Use when reviewing code, fixing review findings, responding to review feedback, or when a code review has produced issues that need to be addressed.",
-  "task-executor": "Execute implementation plans task-by-task with state tracking, TDD, and verification. Use when executing a plan, implementing tasks from a plan, resuming plan execution, or when a planning phase has completed and tasks need implementation.",
-  "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.",
-  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"];
-var GEMINI_TOOL_MAP = {
-  Bash: "run_shell_command",
-  Read: "read_file",
-  Write: "write_file",
-  Edit: "replace",
-  Glob: "glob",
-  Grep: "search_file_content"
-};
-function generateAgentDefinition(persona, skillContents) {
-  const kebabName = toKebabCase(persona.name);
-  const name = `harness-${kebabName}`;
-  const description = AGENT_DESCRIPTIONS[kebabName] ?? persona.description;
-  const methodologyParts = [];
-  for (const skillName of persona.skills) {
-    const content = skillContents.get(skillName);
-    if (content) {
-      methodologyParts.push(content);
-    }
-  }
-  return {
-    name,
-    description,
-    tools: [...DEFAULT_TOOLS],
-    role: persona.role,
-    skills: persona.skills,
-    steps: persona.steps,
-    methodology: methodologyParts.join("\n\n---\n\n")
-  };
-}
-
-// src/agent-definitions/render-claude-code.ts
-function formatStep(step, index) {
-  if ("command" in step && step.command) {
-    const cmd = step.command;
-    const when = step.when ?? "always";
-    return `${index + 1}. Run \`harness ${cmd}\` (${when})`;
-  }
-  if ("skill" in step && step.skill) {
-    const skill = step.skill;
-    const when = step.when ?? "always";
-    return `${index + 1}. Execute ${skill} skill (${when})`;
-  }
-  return `${index + 1}. Unknown step`;
-}
-function renderClaudeCodeAgent(def) {
-  const lines = ["---"];
-  lines.push(`name: ${def.name}`);
-  lines.push(`description: >`);
-  lines.push(`  ${def.description}`);
-  lines.push(`tools: ${def.tools.join(", ")}`);
-  lines.push("---");
-  lines.push("");
-  lines.push(GENERATED_HEADER_AGENT);
-  lines.push("");
-  lines.push("## Role");
-  lines.push("");
-  lines.push(def.role);
-  lines.push("");
-  lines.push("## Skills");
-  lines.push("");
-  for (const skill of def.skills) {
-    lines.push(`- ${skill}`);
-  }
-  lines.push("");
-  lines.push("## Steps");
-  lines.push("");
-  def.steps.forEach((step, i) => {
-    lines.push(formatStep(step, i));
-  });
-  lines.push("");
-  if (def.methodology) {
-    lines.push("## Methodology");
-    lines.push("");
-    lines.push(def.methodology);
-    lines.push("");
-  }
-  return lines.join("\n");
-}
-
-// src/agent-definitions/render-gemini-cli.ts
-function toGeminiToolName(tool) {
-  return GEMINI_TOOL_MAP[tool] ?? tool;
-}
-function formatStep2(step, index) {
-  if ("command" in step && step.command) {
-    const cmd = step.command;
-    const when = step.when ?? "always";
-    return `${index + 1}. Run \`harness ${cmd}\` (${when})`;
-  }
-  if ("skill" in step && step.skill) {
-    const skill = step.skill;
-    const when = step.when ?? "always";
-    return `${index + 1}. Execute ${skill} skill (${when})`;
-  }
-  return `${index + 1}. Unknown step`;
-}
-function renderGeminiAgent(def) {
-  const lines = ["---"];
-  lines.push(`name: ${def.name}`);
-  lines.push(`description: >`);
-  lines.push(`  ${def.description}`);
-  if (def.tools.length > 0) {
-    lines.push("tools:");
-    for (const tool of def.tools) {
-      lines.push(`  - ${toGeminiToolName(tool)}`);
-    }
-  }
-  lines.push("---");
-  lines.push("");
-  lines.push(GENERATED_HEADER_AGENT);
-  lines.push("");
-  lines.push("## Role");
-  lines.push("");
-  lines.push(def.role);
-  lines.push("");
-  lines.push("## Skills");
-  lines.push("");
-  for (const skill of def.skills) {
-    lines.push(`- ${skill}`);
-  }
-  lines.push("");
-  lines.push("## Steps");
-  lines.push("");
-  def.steps.forEach((step, i) => {
-    lines.push(formatStep2(step, i));
-  });
-  lines.push("");
-  if (def.methodology) {
-    lines.push("## Methodology");
-    lines.push("");
-    lines.push(def.methodology);
-    lines.push("");
-  }
-  return lines.join("\n");
-}
-
-// src/commands/generate-agent-definitions.ts
-function resolveOutputDir2(platform, opts) {
-  if (opts.output) {
-    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" ? path36.join(home, ".claude", "agents") : path36.join(home, ".gemini", "agents");
-  }
-  return platform === "claude-code" ? path36.join("agents", "agents", "claude-code") : path36.join("agents", "agents", "gemini-cli");
-}
-function loadSkillContent(skillName) {
-  const skillsDir = resolveSkillsDir();
-  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;
-}
-function generateAgentDefinitions(opts) {
-  const personasDir = resolvePersonasDir();
-  const personaList = listPersonas(personasDir);
-  if (!personaList.ok) return [];
-  const personas = personaList.value.map((meta) => loadPersona(meta.filePath)).filter((r) => r.ok).map((r) => r.value);
-  const allSkillNames = new Set(personas.flatMap((p) => p.skills));
-  const skillContents = /* @__PURE__ */ new Map();
-  for (const skillName of allSkillNames) {
-    const content = loadSkillContent(skillName);
-    if (content) {
-      skillContents.set(skillName, content);
-    }
-  }
-  const definitions = personas.map((p) => generateAgentDefinition(p, skillContents));
-  const results = [];
-  for (const platform of opts.platforms) {
-    const outputDir = resolveOutputDir2(platform, opts);
-    const renderer = getRenderer(platform);
-    const rendered = /* @__PURE__ */ new Map();
-    for (const def of definitions) {
-      const filename = `${def.name}.md`;
-      rendered.set(filename, renderer(def));
-    }
-    const plan = computeSyncPlan(outputDir, rendered);
-    if (!opts.dryRun) {
-      applySyncPlan(outputDir, rendered, plan, false);
-    }
-    results.push({
-      platform,
-      added: plan.added,
-      updated: plan.updated,
-      removed: plan.removed,
-      unchanged: plan.unchanged,
-      outputDir
-    });
-  }
-  return results;
-}
-function createGenerateAgentDefinitionsCommand() {
-  return new Command37("generate-agent-definitions").description("Generate agent definition files from personas for Claude Code and Gemini CLI").option("--platforms <list>", "Target platforms (comma-separated)", "claude-code,gemini-cli").option("--global", "Write to global agent directories", false).option("--output <dir>", "Custom output directory").option("--dry-run", "Show what would change without writing", false).action(async (opts, cmd) => {
-    const globalOpts = cmd.optsWithGlobals();
-    const platforms = opts.platforms.split(",").map((p) => p.trim());
-    for (const p of platforms) {
-      if (!VALID_PLATFORMS.includes(p)) {
-        throw new CLIError(
-          `Invalid platform "${p}". Valid platforms: ${VALID_PLATFORMS.join(", ")}`,
-          ExitCode.VALIDATION_FAILED
-        );
-      }
-    }
-    try {
-      const results = generateAgentDefinitions({
-        platforms,
-        global: opts.global,
-        output: opts.output,
-        dryRun: opts.dryRun
-      });
-      if (globalOpts.json) {
-        console.log(JSON.stringify(results, null, 2));
-        return;
-      }
-      for (const result of results) {
-        console.log(`
-${result.platform} \u2192 ${result.outputDir}`);
-        if (result.added.length > 0) {
-          console.log(`  + ${result.added.length} new: ${result.added.join(", ")}`);
-        }
-        if (result.updated.length > 0) {
-          console.log(`  ~ ${result.updated.length} updated: ${result.updated.join(", ")}`);
-        }
-        if (result.removed.length > 0) {
-          console.log(`  - ${result.removed.length} removed: ${result.removed.join(", ")}`);
-        }
-        if (result.unchanged.length > 0) {
-          console.log(`  = ${result.unchanged.length} unchanged`);
-        }
-        if (opts.dryRun) {
-          console.log("  (dry run \u2014 no files written)");
-        }
-      }
-    } catch (error) {
-      handleError(error);
-    }
-  });
-}
-
 // src/commands/generate.ts
-import { Command as Command38 } from "commander";
+import { Command as Command35 } from "commander";
 function createGenerateCommand3() {
-  return new Command38("generate").description("Generate all platform integrations (slash commands + agent definitions)").option("--platforms <list>", "Target platforms (comma-separated)", "claude-code,gemini-cli").option("--global", "Write to global directories", false).option("--include-global", "Include built-in global skills", false).option("--output <dir>", "Custom output directory").option("--dry-run", "Show what would change without writing", false).option("--yes", "Skip deletion confirmation prompts", false).action(async (opts, cmd) => {
+  return new Command35("generate").description("Generate all platform integrations (slash commands + agent definitions)").option("--platforms <list>", "Target platforms (comma-separated)", "claude-code,gemini-cli").option("--global", "Write to global directories", false).option("--include-global", "Include built-in global skills", false).option("--output <dir>", "Custom output directory").option("--dry-run", "Show what would change without writing", false).option("--yes", "Skip deletion confirmation prompts", false).action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const platforms = opts.platforms.split(",").map((p) => p.trim());
     for (const p of platforms) {
@@ -5091,10 +2858,10 @@ function createGenerateCommand3() {
 }
 
 // src/commands/graph/scan.ts
-import { Command as Command39 } from "commander";
-import * as path37 from "path";
+import { Command as Command36 } from "commander";
+import * as path23 from "path";
 async function runScan(projectPath) {
-  const { GraphStore, CodeIngestor, TopologicalLinker, KnowledgeIngestor, GitIngestor } = await import("./dist-K6KTTN3I.js");
+  const { GraphStore, CodeIngestor, TopologicalLinker, KnowledgeIngestor, GitIngestor } = await import("./dist-I7DB5VKB.js");
   const store = new GraphStore();
   const start = Date.now();
   await new CodeIngestor(store).ingest(projectPath);
@@ -5105,13 +2872,13 @@ async function runScan(projectPath) {
     await new GitIngestor(store).ingest(projectPath);
   } catch {
   }
-  const graphDir = path37.join(projectPath, ".harness", "graph");
+  const graphDir = path23.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 = path37.resolve(inputPath);
+  return new Command36("scan").description("Scan project and build knowledge graph").argument("[path]", "Project root path", ".").action(async (inputPath, _opts, cmd) => {
+    const projectPath = path23.resolve(inputPath);
     const globalOpts = cmd.optsWithGlobals();
     try {
       const result = await runScan(projectPath);
@@ -5130,13 +2897,13 @@ function createScanCommand() {
 }
 
 // src/commands/graph/ingest.ts
-import { Command as Command40 } from "commander";
-import * as path38 from "path";
+import { Command as Command37 } from "commander";
+import * as path24 from "path";
 async function loadConnectorConfig(projectPath, source) {
   try {
-    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 fs11 = await import("fs/promises");
+    const configPath = path24.join(projectPath, "harness.config.json");
+    const config = JSON.parse(await fs11.readFile(configPath, "utf-8"));
     const connector = config.graph?.connectors?.find(
       (c) => c.source === source
     );
@@ -5175,8 +2942,8 @@ async function runIngest(projectPath, source, opts) {
     SyncManager,
     JiraConnector,
     SlackConnector
-  } = await import("./dist-K6KTTN3I.js");
-  const graphDir = path38.join(projectPath, ".harness", "graph");
+  } = await import("./dist-I7DB5VKB.js");
+  const graphDir = path24.join(projectPath, ".harness", "graph");
   const store = new GraphStore();
   await store.load(graphDir);
   if (opts?.all) {
@@ -5237,13 +3004,13 @@ async function runIngest(projectPath, source, opts) {
   return result;
 }
 function createIngestCommand() {
-  return new Command40("ingest").description("Ingest data into the knowledge graph").option("--source <name>", "Source to ingest (code, knowledge, git, jira, slack)").option("--all", "Run all sources (code, knowledge, git, and configured connectors)").option("--full", "Force full re-ingestion").action(async (opts, cmd) => {
+  return new Command37("ingest").description("Ingest data into the knowledge graph").option("--source <name>", "Source to ingest (code, knowledge, git, jira, slack)").option("--all", "Run all sources (code, knowledge, git, and configured connectors)").option("--full", "Force full re-ingestion").action(async (opts, cmd) => {
     if (!opts.source && !opts.all) {
       console.error("Error: --source or --all is required");
       process.exit(1);
     }
     const globalOpts = cmd.optsWithGlobals();
-    const projectPath = path38.resolve(globalOpts.config ? path38.dirname(globalOpts.config) : ".");
+    const projectPath = path24.resolve(globalOpts.config ? path24.dirname(globalOpts.config) : ".");
     try {
       const result = await runIngest(projectPath, opts.source ?? "", {
         full: opts.full,
@@ -5265,12 +3032,12 @@ function createIngestCommand() {
 }
 
 // src/commands/graph/query.ts
-import { Command as Command41 } from "commander";
-import * as path39 from "path";
+import { Command as Command38 } from "commander";
+import * as path25 from "path";
 async function runQuery(projectPath, rootNodeId, opts) {
-  const { GraphStore, ContextQL } = await import("./dist-K6KTTN3I.js");
+  const { GraphStore, ContextQL } = await import("./dist-I7DB5VKB.js");
   const store = new GraphStore();
-  const graphDir = path39.join(projectPath, ".harness", "graph");
+  const graphDir = path25.join(projectPath, ".harness", "graph");
   const loaded = await store.load(graphDir);
   if (!loaded) throw new Error("No graph found. Run `harness scan` first.");
   const params = {
@@ -5284,9 +3051,9 @@ async function runQuery(projectPath, rootNodeId, opts) {
   return cql.execute(params);
 }
 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) => {
+  return new Command38("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 = path39.resolve(globalOpts.config ? path39.dirname(globalOpts.config) : ".");
+    const projectPath = path25.resolve(globalOpts.config ? path25.dirname(globalOpts.config) : ".");
     try {
       const result = await runQuery(projectPath, rootNodeId, {
         depth: parseInt(opts.depth),
@@ -5312,21 +3079,21 @@ function createQueryCommand() {
 }
 
 // src/commands/graph/index.ts
-import { Command as Command42 } from "commander";
+import { Command as Command39 } from "commander";
 
 // src/commands/graph/status.ts
-import * as path40 from "path";
+import * as path26 from "path";
 async function runGraphStatus(projectPath) {
-  const { GraphStore } = await import("./dist-K6KTTN3I.js");
-  const graphDir = path40.join(projectPath, ".harness", "graph");
+  const { GraphStore } = await import("./dist-I7DB5VKB.js");
+  const graphDir = path26.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 fs25 = await import("fs/promises");
-  const metaPath = path40.join(graphDir, "metadata.json");
+  const fs11 = await import("fs/promises");
+  const metaPath = path26.join(graphDir, "metadata.json");
   let lastScan = "unknown";
   try {
-    const meta = JSON.parse(await fs25.readFile(metaPath, "utf-8"));
+    const meta = JSON.parse(await fs11.readFile(metaPath, "utf-8"));
     lastScan = meta.lastScanTimestamp;
   } catch {
   }
@@ -5337,8 +3104,8 @@ async function runGraphStatus(projectPath) {
   }
   let connectorSyncStatus = {};
   try {
-    const syncMetaPath = path40.join(graphDir, "sync-metadata.json");
-    const syncMeta = JSON.parse(await fs25.readFile(syncMetaPath, "utf-8"));
+    const syncMetaPath = path26.join(graphDir, "sync-metadata.json");
+    const syncMeta = JSON.parse(await fs11.readFile(syncMetaPath, "utf-8"));
     for (const [name, data] of Object.entries(syncMeta.connectors ?? {})) {
       connectorSyncStatus[name] = data.lastSyncTimestamp;
     }
@@ -5355,10 +3122,10 @@ async function runGraphStatus(projectPath) {
 }
 
 // src/commands/graph/export.ts
-import * as path41 from "path";
+import * as path27 from "path";
 async function runGraphExport(projectPath, format) {
-  const { GraphStore } = await import("./dist-K6KTTN3I.js");
-  const graphDir = path41.join(projectPath, ".harness", "graph");
+  const { GraphStore } = await import("./dist-I7DB5VKB.js");
+  const graphDir = path27.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.");
@@ -5387,13 +3154,13 @@ async function runGraphExport(projectPath, format) {
 }
 
 // src/commands/graph/index.ts
-import * as path42 from "path";
+import * as path28 from "path";
 function createGraphCommand() {
-  const graph = new Command42("graph").description("Knowledge graph management");
+  const graph = new Command39("graph").description("Knowledge graph management");
   graph.command("status").description("Show graph statistics").action(async (_opts, cmd) => {
     try {
       const globalOpts = cmd.optsWithGlobals();
-      const projectPath = path42.resolve(globalOpts.config ? path42.dirname(globalOpts.config) : ".");
+      const projectPath = path28.resolve(globalOpts.config ? path28.dirname(globalOpts.config) : ".");
       const result = await runGraphStatus(projectPath);
       if (globalOpts.json) {
         console.log(JSON.stringify(result, null, 2));
@@ -5420,7 +3187,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 = path42.resolve(globalOpts.config ? path42.dirname(globalOpts.config) : ".");
+    const projectPath = path28.resolve(globalOpts.config ? path28.dirname(globalOpts.config) : ".");
     try {
       const output = await runGraphExport(projectPath, opts.format);
       console.log(output);
@@ -5432,9 +3199,18 @@ function createGraphCommand() {
   return graph;
 }
 
+// src/commands/mcp.ts
+import { Command as Command40 } from "commander";
+function createMcpCommand() {
+  return new Command40("mcp").description("Start the MCP (Model Context Protocol) server on stdio").action(async () => {
+    const { startServer: startServer2 } = await import("./mcp-BNLBTCXZ.js");
+    await startServer2();
+  });
+}
+
 // src/index.ts
 function createProgram() {
-  const program = new Command43();
+  const program = new Command41();
   program.name("harness").description("CLI for Harness Engineering toolkit").version(CLI_VERSION).option("-c, --config <path>", "Path to config file").option("--json", "Output as JSON").option("--verbose", "Verbose output").option("--quiet", "Minimal output");
   program.addCommand(createValidateCommand());
   program.addCommand(createCheckDepsCommand());
@@ -5463,36 +3239,12 @@ function createProgram() {
   program.addCommand(createIngestCommand());
   program.addCommand(createQueryCommand());
   program.addCommand(createGraphCommand());
+  program.addCommand(createMcpCommand());
   return program;
 }
 
 export {
-  CLI_VERSION,
-  findConfigFile,
-  loadConfig,
-  resolveConfig,
-  OutputMode,
-  OutputFormatter,
-  TemplateEngine,
-  loadPersona,
-  listPersonas,
-  detectTrigger,
-  runPersona,
-  executeSkill,
-  ALLOWED_PERSONA_COMMANDS,
-  generateRuntime,
-  generateAgentsMd,
-  generateCIWorkflow,
   buildPreamble,
-  runCheckPhaseGate,
-  generateSlashCommands,
-  AGENT_DESCRIPTIONS,
-  DEFAULT_TOOLS,
-  GEMINI_TOOL_MAP,
-  generateAgentDefinition,
-  renderClaudeCodeAgent,
-  renderGeminiAgent,
-  generateAgentDefinitions,
   runScan,
   runIngest,
   runQuery,