@harness-engineering/cli 1.4.0 → 1.6.0

package/dist/{chunk-C3J2HW4Y.js → chunk-VS4OTOKZ.js}

@@ -5,10 +5,10 @@ import {
   createCreateSkillCommand,
   handleError,
   logger
-} from "./chunk-EFZOLZFB.js";
+} from "./chunk-ACMDUQJG.js";
 
 // src/index.ts
-import { Command as Command33 } from "commander";
+import { Command as Command39 } from "commander";
 import { VERSION } from "@harness-engineering/core";
 
 // src/commands/validate.ts
@@ -788,6 +788,29 @@ function resolveSkillsDir() {
   }
   return path6.join(__dirname, "agents", "skills", "claude-code");
 }
+function resolveProjectSkillsDir(cwd) {
+  let dir = cwd ?? process.cwd();
+  for (let i = 0; i < 8; i++) {
+    const candidate = path6.join(dir, "agents", "skills", "claude-code");
+    if (fs3.existsSync(candidate) && fs3.statSync(candidate).isDirectory()) {
+      const agentsDir = path6.join(dir, "agents");
+      if (fs3.existsSync(path6.join(agentsDir, "skills"))) {
+        return candidate;
+      }
+    }
+    const parent = path6.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+function resolveGlobalSkillsDir() {
+  const agentsDir = findUpDir("agents", "skills");
+  if (agentsDir) {
+    return path6.join(agentsDir, "skills", "claude-code");
+  }
+  return path6.join(__dirname, "agents", "skills", "claude-code");
+}
 
 // src/commands/setup-mcp.ts
 import { Command as Command4 } from "commander";
@@ -1268,7 +1291,7 @@ import { Command as Command10 } from "commander";
 
 // src/commands/agent/run.ts
 import { Command as Command8 } from "commander";
-import * as path12 from "path";
+import * as path14 from "path";
 import * as childProcess from "child_process";
 import { Ok as Ok10, Err as Err8 } from "@harness-engineering/core";
 import { requestPeerReview } from "@harness-engineering/core";
@@ -1281,10 +1304,24 @@ import { Ok as Ok9, Err as Err7 } from "@harness-engineering/core";
 
 // 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() }).optional()
+    conditions: z3.object({
+      paths: z3.array(z3.string()).optional(),
+      min_files: z3.number().optional()
+    }).optional()
   }),
   z3.object({
     event: z3.literal("on_commit"),
@@ -1293,6 +1330,9 @@ var PersonaTriggerSchema = z3.discriminatedUnion("event", [
   z3.object({
     event: z3.literal("scheduled"),
     cron: z3.string()
+  }),
+  z3.object({
+    event: z3.literal("manual")
   })
 ]);
 var PersonaConfigSchema = z3.object({
@@ -1305,7 +1345,7 @@ var PersonaOutputsSchema = z3.object({
   "ci-workflow": z3.boolean().default(true),
   "runtime-config": z3.boolean().default(true)
 });
-var PersonaSchema = z3.object({
+var PersonaSchemaV1 = z3.object({
   version: z3.literal(1),
   name: z3.string(),
   description: z3.string(),
@@ -1316,8 +1356,33 @@ var PersonaSchema = z3.object({
   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)) {
@@ -1329,7 +1394,7 @@ function loadPersona(filePath) {
     if (!result.success) {
       return Err7(new Error(`Invalid persona ${filePath}: ${result.error.message}`));
     }
-    return Ok9(result.data);
+    return Ok9(normalizePersona(result.data));
   } catch (error) {
     return Err7(
       new Error(`Failed to load persona: ${error instanceof Error ? error.message : String(error)}`)
@@ -1358,75 +1423,312 @@ function listPersonas(dir) {
   }
 }
 
+// src/persona/trigger-detector.ts
+import * as fs7 from "fs";
+import * as path12 from "path";
+function detectTrigger(projectPath) {
+  const handoffPath = path12.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__";
-async function runPersona(persona, executor) {
+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",
-    commands: [],
+    steps: [],
     totalDurationMs: 0
   };
-  for (let i = 0; i < persona.commands.length; i++) {
-    const command = persona.commands[i];
-    if (command === void 0) continue;
+  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) {
-      for (let j = i; j < persona.commands.length; j++) {
-        const remaining = persona.commands[j];
-        if (remaining !== void 0) {
-          report.commands.push({ name: remaining, status: "skipped", durationMs: 0 });
-        }
-      }
+      skipRemaining(activeSteps, i, report);
       report.status = "partial";
       break;
     }
-    const cmdStart = Date.now();
+    const stepStart = Date.now();
     const remainingTime = timeout - (Date.now() - startTime);
-    const result = await Promise.race([
-      executor(command),
-      new Promise(
-        (resolve14) => setTimeout(
-          () => resolve14({ ok: false, error: new Error(TIMEOUT_ERROR_MESSAGE) }),
-          remainingTime
+    if ("command" in step) {
+      const result = await Promise.race([
+        context.commandExecutor(step.command),
+        new Promise(
+          (resolve18) => setTimeout(
+            () => resolve18({
+              ok: false,
+              error: new Error(TIMEOUT_ERROR_MESSAGE)
+            }),
+            remainingTime
+          )
         )
-      )
-    ]);
-    const durationMs = Date.now() - cmdStart;
-    if (result.ok) {
-      report.commands.push({ name: command, status: "pass", result: result.value, durationMs });
-    } else if (result.error.message === TIMEOUT_ERROR_MESSAGE) {
-      report.commands.push({ name: command, status: "skipped", error: "timed out", durationMs });
-      report.status = "partial";
-      for (let j = i + 1; j < persona.commands.length; j++) {
-        const skipped = persona.commands[j];
-        if (skipped !== void 0) {
-          report.commands.push({ name: skipped, status: "skipped", durationMs: 0 });
-        }
+      ]);
+      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;
       }
-      break;
     } else {
-      report.commands.push({
-        name: command,
+      const skillContext = {
+        trigger: resolvedTrigger,
+        projectPath: context.projectPath,
+        outputMode: step.output ?? "auto",
+        ...handoff ? { handoff } : {}
+      };
+      const SKILL_TIMEOUT_RESULT = {
         status: "fail",
-        error: result.error.message,
-        durationMs
-      });
-      report.status = "fail";
-      for (let j = i + 1; j < persona.commands.length; j++) {
-        const skipped = persona.commands[j];
-        if (skipped !== void 0) {
-          report.commands.push({ name: skipped, status: "skipped", durationMs: 0 });
-        }
+        output: "timed out",
+        durationMs: 0
+      };
+      const result = await Promise.race([
+        context.skillExecutor(step.skill, skillContext),
+        new Promise(
+          (resolve18) => setTimeout(() => resolve18(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;
       }
-      break;
     }
   }
   report.totalDurationMs = Date.now() - startTime;
   return report;
 }
 
+// src/persona/skill-executor.ts
+import * as fs8 from "fs";
+import * as path13 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 path13.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 = path13.join(skillsDir, skillName);
+  if (!fs8.existsSync(skillDir)) {
+    return {
+      status: "fail",
+      output: `Skill not found: ${skillName}`,
+      durationMs: Date.now() - startTime
+    };
+  }
+  const yamlPath = path13.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 = path13.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 = path13.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",
+  "cleanup",
+  "fix-drift",
+  "add"
+]);
+
 // src/commands/agent/run.ts
 async function runAgentTask(task, options) {
   const configResult = resolveConfig(options.configPath);
@@ -1469,28 +1771,32 @@ async function runAgentTask(task, options) {
 ${review.comments.map((c) => `  - ${c.message}`).join("\n")}`
   });
 }
+var VALID_TRIGGERS = /* @__PURE__ */ new Set([
+  "always",
+  "on_pr",
+  "on_commit",
+  "on_review",
+  "scheduled",
+  "manual",
+  "on_plan_approved",
+  "auto"
+]);
 function createRunCommand() {
-  return new Command8("run").description("Run an agent task").argument("[task]", "Task to run (review, doc-review, test-review)").option("--timeout <ms>", "Timeout in milliseconds", "300000").option("--persona <name>", "Run a persona by name").action(async (task, opts, cmd) => {
+  return new Command8("run").description("Run an agent task").argument("[task]", "Task to run (review, doc-review, test-review)").option("--timeout <ms>", "Timeout in milliseconds", "300000").option("--persona <name>", "Run a persona by name").option("--trigger <context>", "Trigger context (auto, on_pr, on_commit, manual)", "auto").action(async (task, opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     if (opts.persona) {
       const personasDir = resolvePersonasDir();
-      const filePath = path12.join(personasDir, `${opts.persona}.yaml`);
+      const filePath = path14.join(personasDir, `${opts.persona}.yaml`);
       const personaResult = loadPersona(filePath);
       if (!personaResult.ok) {
         logger.error(personaResult.error.message);
         process.exit(ExitCode.ERROR);
       }
       const persona = personaResult.value;
-      const ALLOWED_COMMANDS = /* @__PURE__ */ new Set([
-        "validate",
-        "check-deps",
-        "check-docs",
-        "cleanup",
-        "fix-drift",
-        "add"
-      ]);
-      const executor = async (command) => {
-        if (!ALLOWED_COMMANDS.has(command)) {
+      const projectPath = process.cwd();
+      const trigger = opts.trigger === "auto" ? "auto" : VALID_TRIGGERS.has(opts.trigger) ? opts.trigger : "manual";
+      const commandExecutor = async (command) => {
+        if (!ALLOWED_PERSONA_COMMANDS.has(command)) {
           return Err8(new Error(`Unknown harness command: ${command}`));
         }
         try {
@@ -1500,12 +1806,21 @@ function createRunCommand() {
           return Err8(new Error(error instanceof Error ? error.message : String(error)));
         }
       };
-      const report = await runPersona(persona, executor);
+      const report = await runPersona(persona, {
+        trigger,
+        commandExecutor,
+        skillExecutor: executeSkill,
+        projectPath
+      });
       if (!globalOpts.quiet) {
         logger.info(`Persona '${report.persona}' status: ${report.status}`);
-        for (const c of report.commands) {
-          const icon = c.status === "pass" ? "v" : c.status === "fail" ? "x" : "-";
-          console.log(`  [${icon}] ${c.name} (${c.durationMs}ms)`);
+        for (const s of report.steps) {
+          const icon = s.status === "pass" ? "v" : s.status === "fail" ? "x" : "-";
+          const typeTag = s.type === "skill" ? " [skill]" : "";
+          console.log(`  [${icon}] ${s.name}${typeTag} (${s.durationMs}ms)`);
+          if (s.artifactPath) {
+            console.log(`      artifact: ${s.artifactPath}`);
+          }
         }
       }
       process.exit(report.status === "fail" ? ExitCode.ERROR : ExitCode.SUCCESS);
@@ -1622,8 +1937,8 @@ function createAgentCommand() {
 
 // src/commands/add.ts
 import { Command as Command11 } from "commander";
-import * as fs7 from "fs";
-import * as path13 from "path";
+import * as fs9 from "fs";
+import * as path15 from "path";
 import { Ok as Ok12, Err as Err10 } from "@harness-engineering/core";
 var LAYER_INDEX_TEMPLATE = (name) => `// ${name} layer
 // Add your ${name} exports here
@@ -1668,61 +1983,61 @@ async function runAdd(componentType, name, options) {
   try {
     switch (componentType) {
       case "layer": {
-        const layerDir = path13.join(cwd, "src", name);
-        if (!fs7.existsSync(layerDir)) {
-          fs7.mkdirSync(layerDir, { recursive: true });
+        const layerDir = path15.join(cwd, "src", name);
+        if (!fs9.existsSync(layerDir)) {
+          fs9.mkdirSync(layerDir, { recursive: true });
           created.push(`src/${name}/`);
         }
-        const indexPath = path13.join(layerDir, "index.ts");
-        if (!fs7.existsSync(indexPath)) {
-          fs7.writeFileSync(indexPath, LAYER_INDEX_TEMPLATE(name));
+        const indexPath = path15.join(layerDir, "index.ts");
+        if (!fs9.existsSync(indexPath)) {
+          fs9.writeFileSync(indexPath, LAYER_INDEX_TEMPLATE(name));
           created.push(`src/${name}/index.ts`);
         }
         break;
       }
       case "module": {
-        const modulePath = path13.join(cwd, "src", `${name}.ts`);
-        if (fs7.existsSync(modulePath)) {
+        const modulePath = path15.join(cwd, "src", `${name}.ts`);
+        if (fs9.existsSync(modulePath)) {
           return Err10(new CLIError(`Module ${name} already exists`, ExitCode.ERROR));
         }
-        fs7.writeFileSync(modulePath, MODULE_TEMPLATE(name));
+        fs9.writeFileSync(modulePath, MODULE_TEMPLATE(name));
         created.push(`src/${name}.ts`);
         break;
       }
       case "doc": {
-        const docsDir = path13.join(cwd, "docs");
-        if (!fs7.existsSync(docsDir)) {
-          fs7.mkdirSync(docsDir, { recursive: true });
+        const docsDir = path15.join(cwd, "docs");
+        if (!fs9.existsSync(docsDir)) {
+          fs9.mkdirSync(docsDir, { recursive: true });
         }
-        const docPath = path13.join(docsDir, `${name}.md`);
-        if (fs7.existsSync(docPath)) {
+        const docPath = path15.join(docsDir, `${name}.md`);
+        if (fs9.existsSync(docPath)) {
           return Err10(new CLIError(`Doc ${name} already exists`, ExitCode.ERROR));
         }
-        fs7.writeFileSync(docPath, DOC_TEMPLATE(name));
+        fs9.writeFileSync(docPath, DOC_TEMPLATE(name));
         created.push(`docs/${name}.md`);
         break;
       }
       case "skill": {
-        const { generateSkillFiles: generateSkillFiles2 } = await import("./create-skill-4GKJZB5R.js");
+        const { generateSkillFiles: generateSkillFiles2 } = await import("./create-skill-NZDLMMR6.js");
         generateSkillFiles2({
           name,
           description: `${name} skill`,
-          outputDir: path13.join(cwd, "agents", "skills", "claude-code")
+          outputDir: path15.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 = path13.join(cwd, "agents", "personas");
-        if (!fs7.existsSync(personasDir)) {
-          fs7.mkdirSync(personasDir, { recursive: true });
+        const personasDir = path15.join(cwd, "agents", "personas");
+        if (!fs9.existsSync(personasDir)) {
+          fs9.mkdirSync(personasDir, { recursive: true });
         }
-        const personaPath = path13.join(personasDir, `${name}.yaml`);
-        if (fs7.existsSync(personaPath)) {
+        const personaPath = path15.join(personasDir, `${name}.yaml`);
+        if (fs9.existsSync(personaPath)) {
           return Err10(new CLIError(`Persona ${name} already exists`, ExitCode.ERROR));
         }
-        fs7.writeFileSync(
+        fs9.writeFileSync(
           personaPath,
           `name: ${name}
 description: ${name} persona
@@ -1910,8 +2225,8 @@ function createListCommand() {
 
 // src/commands/persona/generate.ts
 import { Command as Command16 } from "commander";
-import * as fs8 from "fs";
-import * as path14 from "path";
+import * as fs10 from "fs";
+import * as path16 from "path";
 
 // src/persona/generators/runtime.ts
 import { Ok as Ok13, Err as Err11 } from "@harness-engineering/core";
@@ -1927,7 +2242,7 @@ function generateRuntime(persona) {
     const config = {
       name: toKebabCase(persona.name),
       skills: persona.skills,
-      commands: persona.commands,
+      steps: persona.steps,
       timeout: persona.config.timeout,
       severity: persona.config.severity
     };
@@ -1955,13 +2270,17 @@ function formatTrigger(trigger) {
     }
     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.commands.map((c) => `\`harness ${c}\``).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}
@@ -1970,7 +2289,7 @@ function generateAgentsMd(persona) {
 
 **Skills:** ${skills}
 
-**When this agent flags an issue:** Fix violations before merging. Run ${commands} locally to validate.
+**When this agent flags an issue:** Fix violations before merging. Run ${allCommands} locally to validate.
 `;
     return Ok14(fragment);
   } catch (error) {
@@ -2017,9 +2336,10 @@ function generateCIWorkflow(persona, platform) {
       { uses: "actions/setup-node@v4", with: { "node-version": "20" } },
       { uses: "pnpm/action-setup@v4", with: { run_install: "frozen" } }
     ];
-    for (const cmd of persona.commands) {
+    const commandSteps = persona.steps.filter((s) => "command" in s);
+    for (const step of commandSteps) {
       const severityFlag = severity ? ` --severity ${severity}` : "";
-      steps.push({ run: `npx harness ${cmd}${severityFlag}` });
+      steps.push({ run: `npx harness ${step.command}${severityFlag}` });
     }
     const workflow = {
       name: persona.name,
@@ -2046,40 +2366,40 @@ function createGenerateCommand2() {
   return new Command16("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 = path14.join(personasDir, `${name}.yaml`);
+    const filePath = path16.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 = path14.resolve(opts.outputDir);
+    const outputDir = path16.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 = path14.join(outputDir, `${slug}.runtime.json`);
-        fs8.mkdirSync(path14.dirname(outPath), { recursive: true });
-        fs8.writeFileSync(outPath, result.value);
+        const outPath = path16.join(outputDir, `${slug}.runtime.json`);
+        fs10.mkdirSync(path16.dirname(outPath), { recursive: true });
+        fs10.writeFileSync(outPath, result.value);
         generated.push(outPath);
       }
     }
     if (!only || only === "agents-md") {
       const result = generateAgentsMd(persona);
       if (result.ok) {
-        const outPath = path14.join(outputDir, `${slug}.agents.md`);
-        fs8.writeFileSync(outPath, result.value);
+        const outPath = path16.join(outputDir, `${slug}.agents.md`);
+        fs10.writeFileSync(outPath, result.value);
         generated.push(outPath);
       }
     }
     if (!only || only === "ci") {
       const result = generateCIWorkflow(persona, "github");
       if (result.ok) {
-        const outPath = path14.join(outputDir, ".github", "workflows", `${slug}.yml`);
-        fs8.mkdirSync(path14.dirname(outPath), { recursive: true });
-        fs8.writeFileSync(outPath, result.value);
+        const outPath = path16.join(outputDir, ".github", "workflows", `${slug}.yml`);
+        fs10.mkdirSync(path16.dirname(outPath), { recursive: true });
+        fs10.writeFileSync(outPath, result.value);
         generated.push(outPath);
       }
     }
@@ -2104,26 +2424,26 @@ import { Command as Command22 } from "commander";
 
 // src/commands/skill/list.ts
 import { Command as Command18 } from "commander";
-import * as fs9 from "fs";
-import * as path15 from "path";
-import { parse as parse2 } from "yaml";
+import * as fs11 from "fs";
+import * as path17 from "path";
+import { parse as parse3 } from "yaml";
 function createListCommand2() {
   return new Command18("list").description("List available skills").action(async (_opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const skillsDir = resolveSkillsDir();
-    if (!fs9.existsSync(skillsDir)) {
+    if (!fs11.existsSync(skillsDir)) {
       logger.info("No skills directory found.");
       process.exit(ExitCode.SUCCESS);
       return;
     }
-    const entries = fs9.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+    const entries = fs11.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
     const skills = [];
     for (const name of entries) {
-      const yamlPath = path15.join(skillsDir, name, "skill.yaml");
-      if (!fs9.existsSync(yamlPath)) continue;
+      const yamlPath = path17.join(skillsDir, name, "skill.yaml");
+      if (!fs11.existsSync(yamlPath)) continue;
       try {
-        const raw = fs9.readFileSync(yamlPath, "utf-8");
-        const parsed = parse2(raw);
+        const raw = fs11.readFileSync(yamlPath, "utf-8");
+        const parsed = parse3(raw);
         const result = SkillMetadataSchema.safeParse(parsed);
         if (result.success) {
           skills.push(result.data);
@@ -2153,9 +2473,9 @@ function createListCommand2() {
 
 // src/commands/skill/run.ts
 import { Command as Command19 } from "commander";
-import * as fs10 from "fs";
-import * as path16 from "path";
-import { parse as parse3 } from "yaml";
+import * as fs12 from "fs";
+import * as path18 from "path";
+import { parse as parse4 } from "yaml";
 
 // src/skill/complexity.ts
 import { execSync as execSync2 } from "child_process";
@@ -2244,18 +2564,18 @@ ${options.priorState}`);
 function createRunCommand2() {
   return new Command19("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 = path16.join(skillsDir, name);
-    if (!fs10.existsSync(skillDir)) {
+    const skillDir = path18.join(skillsDir, name);
+    if (!fs12.existsSync(skillDir)) {
       logger.error(`Skill not found: ${name}`);
       process.exit(ExitCode.ERROR);
       return;
     }
-    const yamlPath = path16.join(skillDir, "skill.yaml");
+    const yamlPath = path18.join(skillDir, "skill.yaml");
     let metadata = null;
-    if (fs10.existsSync(yamlPath)) {
+    if (fs12.existsSync(yamlPath)) {
       try {
-        const raw = fs10.readFileSync(yamlPath, "utf-8");
-        const parsed = parse3(raw);
+        const raw = fs12.readFileSync(yamlPath, "utf-8");
+        const parsed = parse4(raw);
         const result = SkillMetadataSchema.safeParse(parsed);
         if (result.success) metadata = result.data;
       } catch {
@@ -2265,17 +2585,17 @@ function createRunCommand2() {
     if (metadata?.phases && metadata.phases.length > 0) {
       const requested = opts.complexity ?? "auto";
       if (requested === "auto") {
-        const projectPath2 = opts.path ? path16.resolve(opts.path) : process.cwd();
+        const projectPath2 = opts.path ? path18.resolve(opts.path) : process.cwd();
         complexity = detectComplexity(projectPath2);
       } else {
         complexity = requested;
       }
     }
     let principles;
-    const projectPath = opts.path ? path16.resolve(opts.path) : process.cwd();
-    const principlesPath = path16.join(projectPath, "docs", "principles.md");
-    if (fs10.existsSync(principlesPath)) {
-      principles = fs10.readFileSync(principlesPath, "utf-8");
+    const projectPath = opts.path ? path18.resolve(opts.path) : process.cwd();
+    const principlesPath = path18.join(projectPath, "docs", "principles.md");
+    if (fs12.existsSync(principlesPath)) {
+      principles = fs12.readFileSync(principlesPath, "utf-8");
     }
     let priorState;
     let stateWarning;
@@ -2290,16 +2610,16 @@ function createRunCommand2() {
       }
       if (metadata?.state.persistent && metadata.state.files.length > 0) {
         for (const stateFilePath of metadata.state.files) {
-          const fullPath = path16.join(projectPath, stateFilePath);
-          if (fs10.existsSync(fullPath)) {
-            const stat = fs10.statSync(fullPath);
+          const fullPath = path18.join(projectPath, stateFilePath);
+          if (fs12.existsSync(fullPath)) {
+            const stat = fs12.statSync(fullPath);
             if (stat.isDirectory()) {
-              const files = fs10.readdirSync(fullPath).map((f) => ({ name: f, mtime: fs10.statSync(path16.join(fullPath, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
+              const files = fs12.readdirSync(fullPath).map((f) => ({ name: f, mtime: fs12.statSync(path18.join(fullPath, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
               if (files.length > 0) {
-                priorState = fs10.readFileSync(path16.join(fullPath, files[0].name), "utf-8");
+                priorState = fs12.readFileSync(path18.join(fullPath, files[0].name), "utf-8");
               }
             } else {
-              priorState = fs10.readFileSync(fullPath, "utf-8");
+              priorState = fs12.readFileSync(fullPath, "utf-8");
             }
             break;
           }
@@ -2318,17 +2638,17 @@ function createRunCommand2() {
       ...stateWarning !== void 0 && { stateWarning },
       party: opts.party
     });
-    const skillMdPath = path16.join(skillDir, "SKILL.md");
-    if (!fs10.existsSync(skillMdPath)) {
+    const skillMdPath = path18.join(skillDir, "SKILL.md");
+    if (!fs12.existsSync(skillMdPath)) {
       logger.error(`SKILL.md not found for skill: ${name}`);
       process.exit(ExitCode.ERROR);
       return;
     }
-    let content = fs10.readFileSync(skillMdPath, "utf-8");
+    let content = fs12.readFileSync(skillMdPath, "utf-8");
     if (metadata?.state.persistent && opts.path) {
-      const stateFile = path16.join(projectPath, ".harness", "state.json");
-      if (fs10.existsSync(stateFile)) {
-        const stateContent = fs10.readFileSync(stateFile, "utf-8");
+      const stateFile = path18.join(projectPath, ".harness", "state.json");
+      if (fs12.existsSync(stateFile)) {
+        const stateContent = fs12.readFileSync(stateFile, "utf-8");
         content += `
 
 ---
@@ -2346,9 +2666,9 @@ ${stateContent}
 
 // src/commands/skill/validate.ts
 import { Command as Command20 } from "commander";
-import * as fs11 from "fs";
-import * as path17 from "path";
-import { parse as parse4 } from "yaml";
+import * as fs13 from "fs";
+import * as path19 from "path";
+import { parse as parse5 } from "yaml";
 var REQUIRED_SECTIONS = [
   "## When to Use",
   "## Process",
@@ -2360,32 +2680,32 @@ function createValidateCommand3() {
   return new Command20("validate").description("Validate all skill.yaml files and SKILL.md structure").action(async (_opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const skillsDir = resolveSkillsDir();
-    if (!fs11.existsSync(skillsDir)) {
+    if (!fs13.existsSync(skillsDir)) {
       logger.info("No skills directory found.");
       process.exit(ExitCode.SUCCESS);
       return;
     }
-    const entries = fs11.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+    const entries = fs13.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
     const errors = [];
     let validated = 0;
     for (const name of entries) {
-      const skillDir = path17.join(skillsDir, name);
-      const yamlPath = path17.join(skillDir, "skill.yaml");
-      const skillMdPath = path17.join(skillDir, "SKILL.md");
-      if (!fs11.existsSync(yamlPath)) {
+      const skillDir = path19.join(skillsDir, name);
+      const yamlPath = path19.join(skillDir, "skill.yaml");
+      const skillMdPath = path19.join(skillDir, "SKILL.md");
+      if (!fs13.existsSync(yamlPath)) {
         errors.push(`${name}: missing skill.yaml`);
         continue;
       }
       try {
-        const raw = fs11.readFileSync(yamlPath, "utf-8");
-        const parsed = parse4(raw);
+        const raw = fs13.readFileSync(yamlPath, "utf-8");
+        const parsed = parse5(raw);
         const result = SkillMetadataSchema.safeParse(parsed);
         if (!result.success) {
           errors.push(`${name}/skill.yaml: ${result.error.message}`);
           continue;
         }
-        if (fs11.existsSync(skillMdPath)) {
-          const mdContent = fs11.readFileSync(skillMdPath, "utf-8");
+        if (fs13.existsSync(skillMdPath)) {
+          const mdContent = fs13.readFileSync(skillMdPath, "utf-8");
           for (const section of REQUIRED_SECTIONS) {
             if (!mdContent.includes(section)) {
               errors.push(`${name}/SKILL.md: missing section "${section}"`);
@@ -2427,28 +2747,28 @@ function createValidateCommand3() {
 
 // src/commands/skill/info.ts
 import { Command as Command21 } from "commander";
-import * as fs12 from "fs";
-import * as path18 from "path";
-import { parse as parse5 } from "yaml";
+import * as fs14 from "fs";
+import * as path20 from "path";
+import { parse as parse6 } from "yaml";
 function createInfoCommand() {
   return new Command21("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 = path18.join(skillsDir, name);
-    if (!fs12.existsSync(skillDir)) {
+    const skillDir = path20.join(skillsDir, name);
+    if (!fs14.existsSync(skillDir)) {
       logger.error(`Skill not found: ${name}`);
       process.exit(ExitCode.ERROR);
       return;
     }
-    const yamlPath = path18.join(skillDir, "skill.yaml");
-    if (!fs12.existsSync(yamlPath)) {
+    const yamlPath = path20.join(skillDir, "skill.yaml");
+    if (!fs14.existsSync(yamlPath)) {
       logger.error(`skill.yaml not found for skill: ${name}`);
       process.exit(ExitCode.ERROR);
       return;
     }
     try {
-      const raw = fs12.readFileSync(yamlPath, "utf-8");
-      const parsed = parse5(raw);
+      const raw = fs14.readFileSync(yamlPath, "utf-8");
+      const parsed = parse6(raw);
       const result = SkillMetadataSchema.safeParse(parsed);
       if (!result.success) {
         logger.error(`Invalid skill.yaml: ${result.error.message}`);
@@ -2501,12 +2821,12 @@ import { Command as Command26 } from "commander";
 
 // src/commands/state/show.ts
 import { Command as Command23 } from "commander";
-import * as path19 from "path";
+import * as path21 from "path";
 import { loadState } from "@harness-engineering/core";
 function createShowCommand() {
   return new Command23("show").description("Show current project state").option("--path <path>", "Project root path", ".").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
-    const projectPath = path19.resolve(opts.path);
+    const projectPath = path21.resolve(opts.path);
     const result = await loadState(projectPath);
     if (!result.ok) {
       logger.error(result.error.message);
@@ -2546,22 +2866,22 @@ Decisions: ${state.decisions.length}`);
 
 // src/commands/state/reset.ts
 import { Command as Command24 } from "commander";
-import * as fs13 from "fs";
-import * as path20 from "path";
+import * as fs15 from "fs";
+import * as path22 from "path";
 import * as readline from "readline";
 function createResetCommand() {
   return new Command24("reset").description("Reset project state (deletes .harness/state.json)").option("--path <path>", "Project root path", ".").option("--yes", "Skip confirmation prompt").action(async (opts, _cmd) => {
-    const projectPath = path20.resolve(opts.path);
-    const statePath = path20.join(projectPath, ".harness", "state.json");
-    if (!fs13.existsSync(statePath)) {
+    const projectPath = path22.resolve(opts.path);
+    const statePath = path22.join(projectPath, ".harness", "state.json");
+    if (!fs15.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((resolve14) => {
-        rl.question("Reset project state? This cannot be undone. [y/N] ", resolve14);
+      const answer = await new Promise((resolve18) => {
+        rl.question("Reset project state? This cannot be undone. [y/N] ", resolve18);
       });
       rl.close();
       if (answer.toLowerCase() !== "y" && answer.toLowerCase() !== "yes") {
@@ -2571,7 +2891,7 @@ function createResetCommand() {
       }
     }
     try {
-      fs13.unlinkSync(statePath);
+      fs15.unlinkSync(statePath);
       logger.success("Project state reset.");
     } catch (e) {
       logger.error(`Failed to reset state: ${e instanceof Error ? e.message : String(e)}`);
@@ -2584,11 +2904,11 @@ function createResetCommand() {
 
 // src/commands/state/learn.ts
 import { Command as Command25 } from "commander";
-import * as path21 from "path";
+import * as path23 from "path";
 import { appendLearning } from "@harness-engineering/core";
 function createLearnCommand() {
   return new Command25("learn").description("Append a learning to .harness/learnings.md").argument("<message>", "The learning to record").option("--path <path>", "Project root path", ".").action(async (message, opts, _cmd) => {
-    const projectPath = path21.resolve(opts.path);
+    const projectPath = path23.resolve(opts.path);
     const result = await appendLearning(projectPath, message);
     if (!result.ok) {
       logger.error(result.error.message);
@@ -2611,18 +2931,18 @@ function createStateCommand() {
 
 // src/commands/check-phase-gate.ts
 import { Command as Command27 } from "commander";
-import * as path22 from "path";
-import * as fs14 from "fs";
+import * as path24 from "path";
+import * as fs16 from "fs";
 import { Ok as Ok16 } from "@harness-engineering/core";
 function resolveSpecPath(implFile, implPattern, specPattern, cwd) {
-  const relImpl = path22.relative(cwd, implFile);
+  const relImpl = path24.relative(cwd, implFile);
   const implBase = (implPattern.split("*")[0] ?? "").replace(/\/+$/, "");
   const afterBase = relImpl.startsWith(implBase + "/") ? relImpl.slice(implBase.length + 1) : relImpl;
   const segments = afterBase.split("/");
   const firstSegment = segments[0] ?? "";
-  const feature = segments.length > 1 ? firstSegment : path22.basename(firstSegment, path22.extname(firstSegment));
+  const feature = segments.length > 1 ? firstSegment : path24.basename(firstSegment, path24.extname(firstSegment));
   const specRelative = specPattern.replace("{feature}", feature);
-  return path22.resolve(cwd, specRelative);
+  return path24.resolve(cwd, specRelative);
 }
 async function runCheckPhaseGate(options) {
   const configResult = resolveConfig(options.configPath);
@@ -2630,7 +2950,7 @@ async function runCheckPhaseGate(options) {
     return configResult;
   }
   const config = configResult.value;
-  const cwd = options.cwd ?? (options.configPath ? path22.dirname(path22.resolve(options.configPath)) : process.cwd());
+  const cwd = options.cwd ?? (options.configPath ? path24.dirname(path24.resolve(options.configPath)) : process.cwd());
   if (!config.phaseGates?.enabled) {
     return Ok16({
       pass: true,
@@ -2647,10 +2967,10 @@ async function runCheckPhaseGate(options) {
     for (const implFile of implFiles) {
       checkedFiles++;
       const expectedSpec = resolveSpecPath(implFile, mapping.implPattern, mapping.specPattern, cwd);
-      if (!fs14.existsSync(expectedSpec)) {
+      if (!fs16.existsSync(expectedSpec)) {
         missingSpecs.push({
-          implFile: path22.relative(cwd, implFile),
-          expectedSpec: path22.relative(cwd, expectedSpec)
+          implFile: path24.relative(cwd, implFile),
+          expectedSpec: path24.relative(cwd, expectedSpec)
         });
       }
     }
@@ -2720,15 +3040,15 @@ function createCheckPhaseGateCommand() {
 
 // src/commands/generate-slash-commands.ts
 import { Command as Command28 } from "commander";
-import fs17 from "fs";
-import path25 from "path";
+import fs19 from "fs";
+import path27 from "path";
 import os2 from "os";
 import readline2 from "readline";
 
 // src/slash-commands/normalize.ts
-import fs15 from "fs";
-import path23 from "path";
-import { parse as parse6 } from "yaml";
+import fs17 from "fs";
+import path25 from "path";
+import { parse as parse7 } from "yaml";
 
 // src/slash-commands/normalize-name.ts
 function normalizeName(skillName) {
@@ -2744,106 +3064,117 @@ function normalizeName(skillName) {
 }
 
 // src/slash-commands/normalize.ts
-function normalizeSkills(skillsDir, platforms) {
-  const entries = fs15.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory());
+function normalizeSkills(skillSources, platforms) {
   const specs = [];
   const nameMap = /* @__PURE__ */ new Map();
-  for (const entry of entries) {
-    const yamlPath = path23.join(skillsDir, entry.name, "skill.yaml");
-    if (!fs15.existsSync(yamlPath)) continue;
-    let raw;
-    try {
-      raw = fs15.readFileSync(yamlPath, "utf-8");
-    } catch {
-      continue;
-    }
-    const parsed = parse6(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);
-    if (nameMap.has(normalized)) {
-      throw new Error(
-        `Name collision: skills "${nameMap.get(normalized)}" and "${meta.name}" both normalize to "${normalized}"`
+  for (const { dir: skillsDir, source } of skillSources) {
+    if (!fs17.existsSync(skillsDir)) continue;
+    const entries = fs17.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory());
+    for (const entry of entries) {
+      const yamlPath = path25.join(skillsDir, entry.name, "skill.yaml");
+      if (!fs17.existsSync(yamlPath)) continue;
+      let raw;
+      try {
+        raw = fs17.readFileSync(yamlPath, "utf-8");
+      } catch {
+        continue;
+      }
+      const parsed = parse7(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 = path25.join(skillsDir, entry.name, "SKILL.md");
+      const skillMdContent = fs17.existsSync(skillMdPath) ? fs17.readFileSync(skillMdPath, "utf-8") : "";
+      const skillMdRelative = path25.relative(
+        process.cwd(),
+        path25.join(skillsDir, entry.name, "SKILL.md")
       );
-    }
-    nameMap.set(normalized, meta.name);
-    const skillMdPath = path23.join(skillsDir, entry.name, "SKILL.md");
-    const skillMdContent = fs15.existsSync(skillMdPath) ? fs15.readFileSync(skillMdPath, "utf-8") : "";
-    const skillMdRelative = path23.relative(
-      process.cwd(),
-      path23.join(skillsDir, entry.name, "SKILL.md")
-    );
-    const skillYamlRelative = path23.relative(
-      process.cwd(),
-      path23.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 skillYamlRelative = path25.relative(
+        process.cwd(),
+        path25.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 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,
-      prompt: {
-        context: contextLines.join("\n"),
-        objective: objectiveLines.join("\n"),
-        executionContext: executionContextLines.join("\n"),
-        process: processLines.join("\n")
+      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;
 }
@@ -2945,19 +3276,24 @@ function renderGemini(spec, skillMdContent, skillYamlContent) {
 }
 
 // src/slash-commands/sync.ts
-import fs16 from "fs";
-import path24 from "path";
+import fs18 from "fs";
+import path26 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 = path24.join(outputDir, filename);
-    if (!fs16.existsSync(filePath)) {
+    const filePath = path26.join(outputDir, filename);
+    if (!fs18.existsSync(filePath)) {
       added.push(filename);
     } else {
-      const existing = fs16.readFileSync(filePath, "utf-8");
+      const existing = fs18.readFileSync(filePath, "utf-8");
       if (existing === content) {
         unchanged.push(filename);
       } else {
@@ -2965,15 +3301,15 @@ function computeSyncPlan(outputDir, rendered) {
       }
     }
   }
-  if (fs16.existsSync(outputDir)) {
-    const existing = fs16.readdirSync(outputDir).filter((f) => {
-      const stat = fs16.statSync(path24.join(outputDir, f));
+  if (fs18.existsSync(outputDir)) {
+    const existing = fs18.readdirSync(outputDir).filter((f) => {
+      const stat = fs18.statSync(path26.join(outputDir, f));
       return stat.isFile();
     });
     for (const filename of existing) {
       if (rendered.has(filename)) continue;
-      const content = fs16.readFileSync(path24.join(outputDir, filename), "utf-8");
-      if (content.includes(GENERATED_HEADER_CLAUDE) || content.includes(GENERATED_HEADER_GEMINI)) {
+      const content = fs18.readFileSync(path26.join(outputDir, filename), "utf-8");
+      if (content.includes(GENERATED_HEADER_CLAUDE) || content.includes(GENERATED_HEADER_GEMINI) || content.includes(GENERATED_HEADER_AGENT)) {
         removed.push(filename);
       }
     }
@@ -2981,18 +3317,18 @@ function computeSyncPlan(outputDir, rendered) {
   return { added, updated, removed, unchanged };
 }
 function applySyncPlan(outputDir, rendered, plan, deleteOrphans) {
-  fs16.mkdirSync(outputDir, { recursive: true });
+  fs18.mkdirSync(outputDir, { recursive: true });
   for (const filename of [...plan.added, ...plan.updated]) {
     const content = rendered.get(filename);
     if (content !== void 0) {
-      fs16.writeFileSync(path24.join(outputDir, filename), content);
+      fs18.writeFileSync(path26.join(outputDir, filename), content);
     }
   }
   if (deleteOrphans) {
     for (const filename of plan.removed) {
-      const filePath = path24.join(outputDir, filename);
-      if (fs16.existsSync(filePath)) {
-        fs16.unlinkSync(filePath);
+      const filePath = path26.join(outputDir, filename);
+      if (fs18.existsSync(filePath)) {
+        fs18.unlinkSync(filePath);
       }
     }
   }
@@ -3001,30 +3337,44 @@ function applySyncPlan(outputDir, rendered, plan, deleteOrphans) {
 // src/commands/generate-slash-commands.ts
 function resolveOutputDir(platform, opts) {
   if (opts.output) {
-    return path25.join(opts.output, "harness");
+    return path27.join(opts.output, "harness");
   }
   if (opts.global) {
     const home = os2.homedir();
-    return platform === "claude-code" ? path25.join(home, ".claude", "commands", "harness") : path25.join(home, ".gemini", "commands", "harness");
+    return platform === "claude-code" ? path27.join(home, ".claude", "commands", "harness") : path27.join(home, ".gemini", "commands", "harness");
   }
-  return platform === "claude-code" ? path25.join("agents", "commands", "claude-code", "harness") : path25.join("agents", "commands", "gemini-cli", "harness");
+  return platform === "claude-code" ? path27.join("agents", "commands", "claude-code", "harness") : path27.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((resolve14) => {
+  return new Promise((resolve18) => {
     rl.question(`
 Remove ${files.length} orphaned command(s)? (y/N) `, (answer) => {
       rl.close();
-      resolve14(answer.toLowerCase() === "y");
+      resolve18(answer.toLowerCase() === "y");
     });
   });
 }
 function generateSlashCommands(opts) {
-  const skillsDir = opts.skillsDir || resolveSkillsDir();
-  const specs = normalizeSkills(skillsDir, opts.platforms);
+  const skillSources = [];
+  if (opts.skillsDir) {
+    skillSources.push({ dir: opts.skillsDir, source: "project" });
+  } else {
+    const projectDir = resolveProjectSkillsDir();
+    if (projectDir) {
+      skillSources.push({ dir: projectDir, source: "project" });
+    }
+    if (opts.includeGlobal || skillSources.length === 0) {
+      const globalDir = resolveGlobalSkillsDir();
+      if (!projectDir || path27.resolve(globalDir) !== path27.resolve(projectDir)) {
+        skillSources.push({ dir: globalDir, source: "global" });
+      }
+    }
+  }
+  const specs = normalizeSkills(skillSources, opts.platforms);
   const results = [];
   for (const platform of opts.platforms) {
     const outputDir = resolveOutputDir(platform, opts);
@@ -3041,7 +3391,7 @@ function generateSlashCommands(opts) {
             executionContext: spec.prompt.executionContext.split("\n").map((line) => {
               if (line.startsWith("@")) {
                 const relPath = line.slice(1);
-                return `@${path25.resolve(relPath)}`;
+                return `@${path27.resolve(relPath)}`;
               }
               return line;
             }).join("\n")
@@ -3049,10 +3399,10 @@ function generateSlashCommands(opts) {
         } : spec;
         rendered.set(filename, renderClaudeCode(renderSpec));
       } else {
-        const mdPath = path25.join(skillsDir, spec.sourceDir, "SKILL.md");
-        const yamlPath = path25.join(skillsDir, spec.sourceDir, "skill.yaml");
-        const mdContent = fs17.existsSync(mdPath) ? fs17.readFileSync(mdPath, "utf-8") : "";
-        const yamlContent = fs17.existsSync(yamlPath) ? fs17.readFileSync(yamlPath, "utf-8") : "";
+        const mdPath = path27.join(spec.skillsBaseDir, spec.sourceDir, "SKILL.md");
+        const yamlPath = path27.join(spec.skillsBaseDir, spec.sourceDir, "skill.yaml");
+        const mdContent = fs19.existsSync(mdPath) ? fs19.readFileSync(mdPath, "utf-8") : "";
+        const yamlContent = fs19.existsSync(yamlPath) ? fs19.readFileSync(yamlPath, "utf-8") : "";
         rendered.set(filename, renderGemini(spec, mdContent, yamlContent));
       }
     }
@@ -3078,9 +3428,9 @@ async function handleOrphanDeletion(results, opts) {
     const shouldDelete = opts.yes || await confirmDeletion(result.removed);
     if (shouldDelete) {
       for (const filename of result.removed) {
-        const filePath = path25.join(result.outputDir, filename);
-        if (fs17.existsSync(filePath)) {
-          fs17.unlinkSync(filePath);
+        const filePath = path27.join(result.outputDir, filename);
+        if (fs19.existsSync(filePath)) {
+          fs19.unlinkSync(filePath);
         }
       }
     }
@@ -3089,7 +3439,7 @@ async function handleOrphanDeletion(results, opts) {
 function createGenerateSlashCommandsCommand() {
   return new Command28("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("--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) => {
+  ).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) {
@@ -3103,6 +3453,7 @@ function createGenerateSlashCommandsCommand() {
     const generateOpts = {
       platforms,
       global: opts.global,
+      includeGlobal: opts.includeGlobal,
       output: opts.output,
       skillsDir: opts.skillsDir ?? "",
       dryRun: opts.dryRun,
@@ -3114,6 +3465,16 @@ function createGenerateSlashCommandsCommand() {
         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}`);
@@ -3221,8 +3582,8 @@ function createCheckCommand() {
 
 // src/commands/ci/init.ts
 import { Command as Command30 } from "commander";
-import * as fs18 from "fs";
-import * as path26 from "path";
+import * as fs20 from "fs";
+import * as path28 from "path";
 import { Ok as Ok17, Err as Err14 } from "@harness-engineering/core";
 var ALL_CHECKS = ["validate", "deps", "docs", "entropy", "phase-gate"];
 function buildSkipFlag(checks) {
@@ -3315,8 +3676,8 @@ function generateCIConfig(options) {
   });
 }
 function detectPlatform() {
-  if (fs18.existsSync(".github")) return "github";
-  if (fs18.existsSync(".gitlab-ci.yml")) return "gitlab";
+  if (fs20.existsSync(".github")) return "github";
+  if (fs20.existsSync(".gitlab-ci.yml")) return "gitlab";
   return null;
 }
 function createInitCommand2() {
@@ -3332,12 +3693,12 @@ function createInitCommand2() {
       process.exit(result.error.exitCode);
     }
     const { filename, content } = result.value;
-    const targetPath = path26.resolve(filename);
-    const dir = path26.dirname(targetPath);
-    fs18.mkdirSync(dir, { recursive: true });
-    fs18.writeFileSync(targetPath, content);
+    const targetPath = path28.resolve(filename);
+    const dir = path28.dirname(targetPath);
+    fs20.mkdirSync(dir, { recursive: true });
+    fs20.writeFileSync(targetPath, content);
     if (platform === "generic") {
-      fs18.chmodSync(targetPath, "755");
+      fs20.chmodSync(targetPath, "755");
     }
     if (globalOpts.json) {
       console.log(JSON.stringify({ file: filename, platform }));
@@ -3415,10 +3776,10 @@ function prompt(question) {
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve14) => {
+  return new Promise((resolve18) => {
     rl.question(question, (answer) => {
       rl.close();
-      resolve14(answer.trim().toLowerCase());
+      resolve18(answer.trim().toLowerCase());
     });
   });
 }
@@ -3491,9 +3852,654 @@ function createUpdateCommand() {
   });
 }
 
+// src/commands/generate-agent-definitions.ts
+import { Command as Command33 } from "commander";
+import * as fs21 from "fs";
+import * as path29 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."
+};
+var DEFAULT_TOOLS = ["Bash", "Read", "Write", "Edit", "Glob", "Grep"];
+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 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}`);
+  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(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" ? path29.join(opts.output, "claude-code") : path29.join(opts.output, "gemini-cli");
+  }
+  if (opts.global) {
+    const home = os3.homedir();
+    return platform === "claude-code" ? path29.join(home, ".claude", "agents") : path29.join(home, ".gemini", "agents");
+  }
+  return platform === "claude-code" ? path29.join("agents", "agents", "claude-code") : path29.join("agents", "agents", "gemini-cli");
+}
+function loadSkillContent(skillName) {
+  const skillsDir = resolveSkillsDir();
+  const skillMdPath = path29.join(skillsDir, skillName, "SKILL.md");
+  if (!fs21.existsSync(skillMdPath)) return null;
+  return fs21.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 Command33("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 Command34 } from "commander";
+function createGenerateCommand3() {
+  return new Command34("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) {
+      if (!VALID_PLATFORMS.includes(p)) {
+        throw new CLIError(
+          `Invalid platform "${p}". Valid platforms: ${VALID_PLATFORMS.join(", ")}`,
+          ExitCode.VALIDATION_FAILED
+        );
+      }
+    }
+    try {
+      console.log("Generating slash commands...");
+      const slashResults = generateSlashCommands({
+        platforms,
+        global: opts.global,
+        includeGlobal: opts.includeGlobal,
+        output: opts.output,
+        skillsDir: "",
+        dryRun: opts.dryRun,
+        yes: opts.yes
+      });
+      for (const result of slashResults) {
+        const total = result.added.length + result.updated.length + result.unchanged.length;
+        console.log(
+          `  ${result.platform}: ${total} commands (${result.added.length} new, ${result.updated.length} updated)`
+        );
+      }
+      await handleOrphanDeletion(slashResults, { yes: opts.yes, dryRun: opts.dryRun });
+      console.log("\nGenerating agent definitions...");
+      const agentResults = generateAgentDefinitions({
+        platforms,
+        global: opts.global,
+        output: opts.output,
+        dryRun: opts.dryRun
+      });
+      for (const result of agentResults) {
+        const total = result.added.length + result.updated.length + result.unchanged.length;
+        console.log(
+          `  ${result.platform}: ${total} agents (${result.added.length} new, ${result.updated.length} updated)`
+        );
+      }
+      if (opts.dryRun) {
+        console.log("\n(dry run \u2014 no files written)");
+      } else {
+        console.log("\nDone.");
+      }
+      if (globalOpts.json) {
+        console.log(
+          JSON.stringify({ slashCommands: slashResults, agentDefinitions: agentResults }, null, 2)
+        );
+      }
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
+// src/commands/graph/scan.ts
+import { Command as Command35 } from "commander";
+import * as path30 from "path";
+async function runScan(projectPath) {
+  const { GraphStore, CodeIngestor, TopologicalLinker, KnowledgeIngestor, GitIngestor } = await import("@harness-engineering/graph");
+  const store = new GraphStore();
+  const start = Date.now();
+  await new CodeIngestor(store).ingest(projectPath);
+  new TopologicalLinker(store).link();
+  const knowledgeIngestor = new KnowledgeIngestor(store);
+  await knowledgeIngestor.ingestAll(projectPath);
+  try {
+    await new GitIngestor(store).ingest(projectPath);
+  } catch {
+  }
+  const graphDir = path30.join(projectPath, ".harness", "graph");
+  await store.save(graphDir);
+  return { nodeCount: store.nodeCount, edgeCount: store.edgeCount, durationMs: Date.now() - start };
+}
+function createScanCommand() {
+  return new Command35("scan").description("Scan project and build knowledge graph").argument("[path]", "Project root path", ".").action(async (inputPath, _opts, cmd) => {
+    const projectPath = path30.resolve(inputPath);
+    const globalOpts = cmd.optsWithGlobals();
+    try {
+      const result = await runScan(projectPath);
+      if (globalOpts.json) {
+        console.log(JSON.stringify(result));
+      } else {
+        console.log(
+          `Graph built: ${result.nodeCount} nodes, ${result.edgeCount} edges (${result.durationMs}ms)`
+        );
+      }
+    } catch (err) {
+      console.error("Scan failed:", err instanceof Error ? err.message : err);
+      process.exit(2);
+    }
+  });
+}
+
+// src/commands/graph/ingest.ts
+import { Command as Command36 } from "commander";
+import * as path31 from "path";
+async function loadConnectorConfig(projectPath, source) {
+  try {
+    const fs22 = await import("fs/promises");
+    const configPath = path31.join(projectPath, "harness.config.json");
+    const config = JSON.parse(await fs22.readFile(configPath, "utf-8"));
+    const connector = config.graph?.connectors?.find(
+      (c) => c.source === source
+    );
+    return connector?.config ?? {};
+  } catch {
+    return {};
+  }
+}
+function mergeResults(...results) {
+  return results.reduce(
+    (acc, r) => ({
+      nodesAdded: acc.nodesAdded + r.nodesAdded,
+      nodesUpdated: acc.nodesUpdated + r.nodesUpdated,
+      edgesAdded: acc.edgesAdded + r.edgesAdded,
+      edgesUpdated: acc.edgesUpdated + r.edgesUpdated,
+      errors: [...acc.errors, ...r.errors],
+      durationMs: acc.durationMs + r.durationMs
+    }),
+    {
+      nodesAdded: 0,
+      nodesUpdated: 0,
+      edgesAdded: 0,
+      edgesUpdated: 0,
+      errors: [],
+      durationMs: 0
+    }
+  );
+}
+async function runIngest(projectPath, source, opts) {
+  const {
+    GraphStore,
+    CodeIngestor,
+    TopologicalLinker,
+    KnowledgeIngestor,
+    GitIngestor,
+    SyncManager,
+    JiraConnector,
+    SlackConnector
+  } = await import("@harness-engineering/graph");
+  const graphDir = path31.join(projectPath, ".harness", "graph");
+  const store = new GraphStore();
+  await store.load(graphDir);
+  if (opts?.all) {
+    const startMs = Date.now();
+    const codeResult = await new CodeIngestor(store).ingest(projectPath);
+    new TopologicalLinker(store).link();
+    const knowledgeResult = await new KnowledgeIngestor(store).ingestAll(projectPath);
+    const gitResult = await new GitIngestor(store).ingest(projectPath);
+    const syncManager = new SyncManager(store, graphDir);
+    const connectorMap = {
+      jira: () => new JiraConnector(),
+      slack: () => new SlackConnector()
+    };
+    for (const [name, factory] of Object.entries(connectorMap)) {
+      const config = await loadConnectorConfig(projectPath, name);
+      syncManager.registerConnector(factory(), config);
+    }
+    const connectorResult = await syncManager.syncAll();
+    await store.save(graphDir);
+    const merged = mergeResults(codeResult, knowledgeResult, gitResult, connectorResult);
+    return { ...merged, durationMs: Date.now() - startMs };
+  }
+  let result;
+  switch (source) {
+    case "code":
+      result = await new CodeIngestor(store).ingest(projectPath);
+      new TopologicalLinker(store).link();
+      break;
+    case "knowledge":
+      result = await new KnowledgeIngestor(store).ingestAll(projectPath);
+      break;
+    case "git":
+      result = await new GitIngestor(store).ingest(projectPath);
+      break;
+    default: {
+      const knownConnectors = ["jira", "slack"];
+      if (!knownConnectors.includes(source)) {
+        throw new Error(`Unknown source: ${source}. Available: code, knowledge, git, jira, slack`);
+      }
+      if (!SyncManager) {
+        throw new Error(
+          `Connector support not available. Ensure @harness-engineering/graph is built with connector support.`
+        );
+      }
+      const syncManager = new SyncManager(store, graphDir);
+      const extConnectorMap = {
+        jira: () => new JiraConnector(),
+        slack: () => new SlackConnector()
+      };
+      const factory = extConnectorMap[source];
+      const config = await loadConnectorConfig(projectPath, source);
+      syncManager.registerConnector(factory(), config);
+      result = await syncManager.sync(source);
+      break;
+    }
+  }
+  await store.save(graphDir);
+  return result;
+}
+function createIngestCommand() {
+  return new Command36("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 = path31.resolve(globalOpts.config ? path31.dirname(globalOpts.config) : ".");
+    try {
+      const result = await runIngest(projectPath, opts.source ?? "", {
+        full: opts.full,
+        all: opts.all
+      });
+      if (globalOpts.json) {
+        console.log(JSON.stringify(result));
+      } else {
+        const label = opts.all ? "all" : opts.source;
+        console.log(
+          `Ingested (${label}): +${result.nodesAdded} nodes, +${result.edgesAdded} edges (${result.durationMs}ms)`
+        );
+      }
+    } catch (err) {
+      console.error("Ingest failed:", err instanceof Error ? err.message : err);
+      process.exit(2);
+    }
+  });
+}
+
+// src/commands/graph/query.ts
+import { Command as Command37 } from "commander";
+import * as path32 from "path";
+async function runQuery(projectPath, rootNodeId, opts) {
+  const { GraphStore, ContextQL } = await import("@harness-engineering/graph");
+  const store = new GraphStore();
+  const graphDir = path32.join(projectPath, ".harness", "graph");
+  const loaded = await store.load(graphDir);
+  if (!loaded) throw new Error("No graph found. Run `harness scan` first.");
+  const params = {
+    rootNodeIds: [rootNodeId],
+    maxDepth: opts.depth ?? 3,
+    bidirectional: opts.bidirectional ?? false,
+    ...opts.types ? { includeTypes: opts.types.split(",") } : {},
+    ...opts.edges ? { includeEdges: opts.edges.split(",") } : {}
+  };
+  const cql = new ContextQL(store);
+  return cql.execute(params);
+}
+function createQueryCommand() {
+  return new Command37("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 = path32.resolve(globalOpts.config ? path32.dirname(globalOpts.config) : ".");
+    try {
+      const result = await runQuery(projectPath, rootNodeId, {
+        depth: parseInt(opts.depth),
+        types: opts.types,
+        edges: opts.edges,
+        bidirectional: opts.bidirectional
+      });
+      if (globalOpts.json) {
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        console.log(
+          `Found ${result.nodes.length} nodes, ${result.edges.length} edges (depth ${result.stats.depthReached}, pruned ${result.stats.pruned})`
+        );
+        for (const node of result.nodes) {
+          console.log(`  ${node.type.padEnd(12)} ${node.id}`);
+        }
+      }
+    } catch (err) {
+      console.error("Query failed:", err instanceof Error ? err.message : err);
+      process.exit(2);
+    }
+  });
+}
+
+// src/commands/graph/index.ts
+import { Command as Command38 } from "commander";
+
+// src/commands/graph/status.ts
+import * as path33 from "path";
+async function runGraphStatus(projectPath) {
+  const { GraphStore } = await import("@harness-engineering/graph");
+  const graphDir = path33.join(projectPath, ".harness", "graph");
+  const store = new GraphStore();
+  const loaded = await store.load(graphDir);
+  if (!loaded) return { status: "no_graph", message: "No graph found. Run `harness scan` first." };
+  const fs22 = await import("fs/promises");
+  const metaPath = path33.join(graphDir, "metadata.json");
+  let lastScan = "unknown";
+  try {
+    const meta = JSON.parse(await fs22.readFile(metaPath, "utf-8"));
+    lastScan = meta.lastScanTimestamp;
+  } catch {
+  }
+  const allNodes = store.findNodes({});
+  const nodesByType = {};
+  for (const node of allNodes) {
+    nodesByType[node.type] = (nodesByType[node.type] ?? 0) + 1;
+  }
+  let connectorSyncStatus = {};
+  try {
+    const syncMetaPath = path33.join(graphDir, "sync-metadata.json");
+    const syncMeta = JSON.parse(await fs22.readFile(syncMetaPath, "utf-8"));
+    for (const [name, data] of Object.entries(syncMeta.connectors ?? {})) {
+      connectorSyncStatus[name] = data.lastSyncTimestamp;
+    }
+  } catch {
+  }
+  return {
+    status: "ok",
+    nodeCount: store.nodeCount,
+    edgeCount: store.edgeCount,
+    nodesByType,
+    lastScanTimestamp: lastScan,
+    ...Object.keys(connectorSyncStatus).length > 0 ? { connectorSyncStatus } : {}
+  };
+}
+
+// src/commands/graph/export.ts
+import * as path34 from "path";
+async function runGraphExport(projectPath, format) {
+  const { GraphStore } = await import("@harness-engineering/graph");
+  const graphDir = path34.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.");
+  if (format === "json") {
+    const nodes = store.findNodes({});
+    const edges = store.getEdges({});
+    return JSON.stringify({ nodes, edges }, null, 2);
+  }
+  if (format === "mermaid") {
+    const nodes = store.findNodes({});
+    const edges = store.getEdges({});
+    const lines = ["graph TD"];
+    for (const node of nodes.slice(0, 200)) {
+      const safeId = node.id.replace(/[^a-zA-Z0-9]/g, "_");
+      const safeName = node.name.replace(/"/g, "#quot;");
+      lines.push(`  ${safeId}["${safeName}"]`);
+    }
+    for (const edge of edges.slice(0, 500)) {
+      const safeFrom = edge.from.replace(/[^a-zA-Z0-9]/g, "_");
+      const safeTo = edge.to.replace(/[^a-zA-Z0-9]/g, "_");
+      lines.push(`  ${safeFrom} -->|${edge.type}| ${safeTo}`);
+    }
+    return lines.join("\n");
+  }
+  throw new Error(`Unknown format: ${format}. Available: json, mermaid`);
+}
+
+// src/commands/graph/index.ts
+import * as path35 from "path";
+function createGraphCommand() {
+  const graph = new Command38("graph").description("Knowledge graph management");
+  graph.command("status").description("Show graph statistics").action(async (_opts, cmd) => {
+    try {
+      const globalOpts = cmd.optsWithGlobals();
+      const projectPath = path35.resolve(globalOpts.config ? path35.dirname(globalOpts.config) : ".");
+      const result = await runGraphStatus(projectPath);
+      if (globalOpts.json) {
+        console.log(JSON.stringify(result, null, 2));
+      } else if (result.status === "no_graph") {
+        console.log(result.message);
+      } else {
+        console.log(`Graph: ${result.nodeCount} nodes, ${result.edgeCount} edges`);
+        console.log(`Last scan: ${result.lastScanTimestamp}`);
+        console.log("Nodes by type:");
+        for (const [type, count] of Object.entries(result.nodesByType)) {
+          console.log(`  ${type}: ${count}`);
+        }
+        if (result.connectorSyncStatus) {
+          console.log("Connector sync status:");
+          for (const [name, timestamp] of Object.entries(result.connectorSyncStatus)) {
+            console.log(`  ${name}: last synced ${timestamp}`);
+          }
+        }
+      }
+    } catch (err) {
+      console.error("Status failed:", err instanceof Error ? err.message : err);
+      process.exit(2);
+    }
+  });
+  graph.command("export").description("Export graph").requiredOption("--format <format>", "Output format (json, mermaid)").action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const projectPath = path35.resolve(globalOpts.config ? path35.dirname(globalOpts.config) : ".");
+    try {
+      const output = await runGraphExport(projectPath, opts.format);
+      console.log(output);
+    } catch (err) {
+      console.error("Export failed:", err instanceof Error ? err.message : err);
+      process.exit(2);
+    }
+  });
+  return graph;
+}
+
 // src/index.ts
 function createProgram() {
-  const program = new Command33();
+  const program = new Command39();
   program.name("harness").description("CLI for Harness Engineering toolkit").version(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());
@@ -3511,8 +4517,14 @@ function createProgram() {
   program.addCommand(createCreateSkillCommand());
   program.addCommand(createSetupMcpCommand());
   program.addCommand(createGenerateSlashCommandsCommand());
+  program.addCommand(createGenerateAgentDefinitionsCommand());
+  program.addCommand(createGenerateCommand3());
   program.addCommand(createCICommand());
   program.addCommand(createUpdateCommand());
+  program.addCommand(createScanCommand());
+  program.addCommand(createIngestCommand());
+  program.addCommand(createQueryCommand());
+  program.addCommand(createGraphCommand());
   return program;
 }
 
@@ -3525,12 +4537,25 @@ export {
   TemplateEngine,
   loadPersona,
   listPersonas,
+  detectTrigger,
   runPersona,
+  executeSkill,
+  ALLOWED_PERSONA_COMMANDS,
   generateRuntime,
   generateAgentsMd,
   generateCIWorkflow,
   buildPreamble,
   runCheckPhaseGate,
   generateSlashCommands,
+  AGENT_DESCRIPTIONS,
+  generateAgentDefinition,
+  renderClaudeCodeAgent,
+  renderGeminiAgent,
+  generateAgentDefinitions,
+  runScan,
+  runIngest,
+  runQuery,
+  runGraphStatus,
+  runGraphExport,
   createProgram
 };