@harness-engineering/cli 1.1.1 → 1.2.0

package/dist/agents/skills/node_modules/.bin/yaml

@@ -6,9 +6,9 @@ case `uname` in
 esac
 
 if [ -z "$NODE_PATH" ]; then
-  export NODE_PATH="/Users/cwarner/Projects/harness-engineering/node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/node_modules:/Users/cwarner/Projects/harness-engineering/node_modules/.pnpm/yaml@2.8.2/node_modules:/Users/cwarner/Projects/harness-engineering/node_modules/.pnpm/node_modules"
+  export NODE_PATH="/home/runner/work/harness-engineering/harness-engineering/node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/node_modules:/home/runner/work/harness-engineering/harness-engineering/node_modules/.pnpm/yaml@2.8.2/node_modules:/home/runner/work/harness-engineering/harness-engineering/node_modules/.pnpm/node_modules"
 else
-  export NODE_PATH="/Users/cwarner/Projects/harness-engineering/node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/node_modules:/Users/cwarner/Projects/harness-engineering/node_modules/.pnpm/yaml@2.8.2/node_modules:/Users/cwarner/Projects/harness-engineering/node_modules/.pnpm/node_modules:$NODE_PATH"
+  export NODE_PATH="/home/runner/work/harness-engineering/harness-engineering/node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/node_modules:/home/runner/work/harness-engineering/harness-engineering/node_modules/.pnpm/yaml@2.8.2/node_modules:/home/runner/work/harness-engineering/harness-engineering/node_modules/.pnpm/node_modules:$NODE_PATH"
 fi
 if [ -x "$basedir/node" ]; then
   exec "$basedir/node"  "$basedir/../yaml/bin.mjs" "$@"

package/dist/bin/harness.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   createProgram
-} from "../chunk-NHLJNFKV.js";
+} from "../chunk-IXT3KLVN.js";
 import "../chunk-3U5VZYR7.js";
 import {
   handleError

package/dist/{chunk-NHLJNFKV.js → chunk-IXT3KLVN.js}

@@ -3,11 +3,12 @@ import {
   ExitCode,
   SkillMetadataSchema,
   createCreateSkillCommand,
+  handleError,
   logger
 } from "./chunk-EFZOLZFB.js";
 
 // src/index.ts
-import { Command as Command28 } from "commander";
+import { Command as Command29 } from "commander";
 import { VERSION } from "@harness-engineering/core";
 
 // src/commands/validate.ts
@@ -2717,9 +2718,430 @@ function createCheckPhaseGateCommand() {
   return command;
 }
 
+// src/commands/generate-slash-commands.ts
+import { Command as Command28 } from "commander";
+import fs17 from "fs";
+import path25 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";
+
+// src/slash-commands/normalize-name.ts
+function normalizeName(skillName) {
+  let name = skillName;
+  if (name.startsWith("harness-")) {
+    name = name.slice("harness-".length);
+  }
+  name = name.replace(/-harness-/g, "-");
+  if (name.endsWith("-harness")) {
+    name = name.slice(0, -"-harness".length);
+  }
+  return name;
+}
+
+// src/slash-commands/normalize.ts
+function normalizeSkills(skillsDir, platforms) {
+  const entries = fs15.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory());
+  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}"`
+      );
+    }
+    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 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")
+      }
+    });
+  }
+  return specs;
+}
+
+// src/slash-commands/types.ts
+var VALID_PLATFORMS = ["claude-code", "gemini-cli"];
+var GENERATED_HEADER_CLAUDE = "<!-- Generated by harness generate-slash-commands. Do not edit. -->";
+var GENERATED_HEADER_GEMINI = "# Generated by harness generate-slash-commands. Do not edit.";
+
+// src/slash-commands/argument-hint.ts
+function buildArgumentHint(args) {
+  return args.map((arg) => arg.required ? `--${arg.name} <${arg.name}>` : `[--${arg.name} <${arg.name}>]`).join(" ");
+}
+
+// src/slash-commands/render-claude-code.ts
+function renderClaudeCode(spec) {
+  const lines = [GENERATED_HEADER_CLAUDE];
+  lines.push("---");
+  lines.push(`name: ${spec.fullName}`);
+  lines.push(`description: ${spec.description}`);
+  const hint = buildArgumentHint(spec.args);
+  if (hint) {
+    lines.push(`argument-hint: "${hint}"`);
+  }
+  if (spec.tools.length > 0) {
+    lines.push("allowed-tools:");
+    for (const tool of spec.tools) {
+      lines.push(`  - ${tool}`);
+    }
+  }
+  lines.push("---");
+  lines.push("");
+  lines.push("<context>");
+  lines.push(spec.prompt.context);
+  lines.push("</context>");
+  lines.push("");
+  lines.push("<objective>");
+  lines.push(spec.prompt.objective);
+  lines.push("</objective>");
+  lines.push("");
+  if (spec.prompt.executionContext) {
+    lines.push("<execution_context>");
+    lines.push(spec.prompt.executionContext);
+    lines.push("</execution_context>");
+    lines.push("");
+  }
+  lines.push("<process>");
+  lines.push(spec.prompt.process);
+  lines.push("</process>");
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/slash-commands/render-gemini.ts
+function escapeToml(content) {
+  return content.replace(/"""/g, '""\\"');
+}
+function renderGemini(spec, skillMdContent, skillYamlContent) {
+  const lines = [GENERATED_HEADER_GEMINI];
+  const safeDesc = spec.description.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  lines.push(`description = "${safeDesc}"`);
+  lines.push('prompt = """');
+  lines.push("<context>");
+  lines.push(spec.prompt.context);
+  lines.push("</context>");
+  lines.push("");
+  lines.push("<objective>");
+  lines.push(spec.prompt.objective);
+  lines.push("</objective>");
+  lines.push("");
+  if (skillMdContent || skillYamlContent) {
+    lines.push("<execution_context>");
+    if (skillMdContent) {
+      const mdPath = spec.prompt.executionContext.split("\n")[0]?.replace(/^@/, "") ?? "";
+      lines.push(`--- SKILL.md (${mdPath}) ---`);
+      lines.push(escapeToml(skillMdContent));
+      lines.push("");
+    }
+    if (skillYamlContent) {
+      const refs = spec.prompt.executionContext.split("\n");
+      const yamlPath = (refs[1] ?? refs[0] ?? "").replace(/^@/, "");
+      lines.push(`--- skill.yaml (${yamlPath}) ---`);
+      lines.push(escapeToml(skillYamlContent));
+    }
+    lines.push("</execution_context>");
+    lines.push("");
+  }
+  const geminiProcess = spec.prompt.process.replace(
+    "read SKILL.md and follow its workflow directly",
+    "follow the SKILL.md workflow provided above directly"
+  );
+  lines.push("<process>");
+  lines.push(geminiProcess);
+  lines.push("</process>");
+  lines.push('"""');
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/slash-commands/sync.ts
+import fs16 from "fs";
+import path24 from "path";
+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)) {
+      added.push(filename);
+    } else {
+      const existing = fs16.readFileSync(filePath, "utf-8");
+      if (existing === content) {
+        unchanged.push(filename);
+      } else {
+        updated.push(filename);
+      }
+    }
+  }
+  if (fs16.existsSync(outputDir)) {
+    const existing = fs16.readdirSync(outputDir).filter((f) => {
+      const stat = fs16.statSync(path24.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.startsWith(GENERATED_HEADER_CLAUDE) || content.startsWith(GENERATED_HEADER_GEMINI)) {
+        removed.push(filename);
+      }
+    }
+  }
+  return { added, updated, removed, unchanged };
+}
+function applySyncPlan(outputDir, rendered, plan, deleteOrphans) {
+  fs16.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);
+    }
+  }
+  if (deleteOrphans) {
+    for (const filename of plan.removed) {
+      const filePath = path24.join(outputDir, filename);
+      if (fs16.existsSync(filePath)) {
+        fs16.unlinkSync(filePath);
+      }
+    }
+  }
+}
+
+// src/commands/generate-slash-commands.ts
+function resolveOutputDir(platform, opts) {
+  if (opts.output) {
+    return path25.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" ? path25.join("agents", "commands", "claude-code", "harness") : path25.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((resolve13) => {
+    rl.question(`
+Remove ${files.length} orphaned command(s)? (y/N) `, (answer) => {
+      rl.close();
+      resolve13(answer.toLowerCase() === "y");
+    });
+  });
+}
+function generateSlashCommands(opts) {
+  const skillsDir = opts.skillsDir || resolveSkillsDir();
+  const specs = normalizeSkills(skillsDir, opts.platforms);
+  const results = [];
+  for (const platform of opts.platforms) {
+    const outputDir = resolveOutputDir(platform, opts);
+    const ext = fileExtension(platform);
+    const useAbsolutePaths = opts.global;
+    const rendered = /* @__PURE__ */ new Map();
+    for (const spec of specs) {
+      const filename = `${spec.name}${ext}`;
+      if (platform === "claude-code") {
+        const renderSpec = useAbsolutePaths ? {
+          ...spec,
+          prompt: {
+            ...spec.prompt,
+            executionContext: spec.prompt.executionContext.split("\n").map((line) => {
+              if (line.startsWith("@")) {
+                const relPath = line.slice(1);
+                return `@${path25.resolve(relPath)}`;
+              }
+              return line;
+            }).join("\n")
+          }
+        } : 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") : "";
+        rendered.set(filename, renderGemini(spec, mdContent, yamlContent));
+      }
+    }
+    const plan = computeSyncPlan(outputDir, rendered);
+    if (!opts.dryRun) {
+      applySyncPlan(outputDir, rendered, plan, false);
+    }
+    results.push({
+      platform,
+      added: plan.added,
+      updated: plan.updated,
+      removed: plan.removed,
+      unchanged: plan.unchanged,
+      outputDir
+    });
+  }
+  return results;
+}
+async function handleOrphanDeletion(results, opts) {
+  if (opts.dryRun) return;
+  for (const result of results) {
+    if (result.removed.length === 0) continue;
+    const shouldDelete = opts.yes || await confirmDeletion(result.removed);
+    if (shouldDelete) {
+      for (const filename of result.removed) {
+        const filePath = path25.join(result.outputDir, filename);
+        if (fs17.existsSync(filePath)) {
+          fs17.unlinkSync(filePath);
+        }
+      }
+    }
+  }
+}
+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) => {
+    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
+        );
+      }
+    }
+    const generateOpts = {
+      platforms,
+      global: opts.global,
+      output: opts.output,
+      skillsDir: opts.skillsDir ?? "",
+      dryRun: opts.dryRun,
+      yes: opts.yes
+    };
+    try {
+      const results = generateSlashCommands(generateOpts);
+      if (globalOpts.json) {
+        console.log(JSON.stringify(results, null, 2));
+        return;
+      }
+      for (const result of results) {
+        console.log(`
+${result.platform} \u2192 ${result.outputDir}`);
+        if (result.added.length > 0) {
+          console.log(`  + ${result.added.length} new: ${result.added.join(", ")}`);
+        }
+        if (result.updated.length > 0) {
+          console.log(`  ~ ${result.updated.length} updated: ${result.updated.join(", ")}`);
+        }
+        if (result.removed.length > 0) {
+          console.log(`  - ${result.removed.length} removed: ${result.removed.join(", ")}`);
+        }
+        if (result.unchanged.length > 0) {
+          console.log(`  = ${result.unchanged.length} unchanged`);
+        }
+        if (opts.dryRun) {
+          console.log("  (dry run \u2014 no files written)");
+        }
+      }
+      await handleOrphanDeletion(results, { yes: opts.yes, dryRun: opts.dryRun });
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
 // src/index.ts
 function createProgram() {
-  const program = new Command28();
+  const program = new Command29();
   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());
@@ -2736,6 +3158,7 @@ function createProgram() {
   program.addCommand(createCheckPhaseGateCommand());
   program.addCommand(createCreateSkillCommand());
   program.addCommand(createSetupMcpCommand());
+  program.addCommand(createGenerateSlashCommandsCommand());
   return program;
 }
 
@@ -2754,5 +3177,6 @@ export {
   generateCIWorkflow,
   buildPreamble,
   runCheckPhaseGate,
+  generateSlashCommands,
   createProgram
 };

package/dist/index.d.ts

@@ -87,6 +87,26 @@ interface GeneratedFiles {
 }
 declare function generateSkillFiles(opts: CreateSkillOptions): GeneratedFiles;
 
+type Platform = 'claude-code' | 'gemini-cli';
+interface GenerateOptions {
+    platforms: Platform[];
+    global: boolean;
+    output?: string;
+    skillsDir: string;
+    dryRun: boolean;
+    yes: boolean;
+}
+
+interface GenerateResult {
+    platform: string;
+    added: string[];
+    updated: string[];
+    removed: string[];
+    unchanged: string[];
+    outputDir: string;
+}
+declare function generateSlashCommands(opts: GenerateOptions): GenerateResult[];
+
 declare const OutputMode: {
     readonly JSON: "json";
     readonly TEXT: "text";
@@ -588,4 +608,4 @@ declare function runPersona(persona: Persona, executor: CommandExecutor): Promis
 
 declare function createProgram(): Command;
 
-export { CLIError, type CommandExecutor, type CreateSkillOptions, ExitCode, type HarnessConfig, OutputFormatter, OutputMode, type Persona, type PersonaMetadata, type PersonaRunReport, type RenderedFiles, type TemplateContext, TemplateEngine, buildPreamble, createProgram, findConfigFile, generateAgentsMd, generateCIWorkflow, generateRuntime, generateSkillFiles, handleError, listPersonas, loadConfig, loadPersona, logger, resolveConfig, runCheckPhaseGate, runCrossCheck, runPersona };
+export { CLIError, type CommandExecutor, type CreateSkillOptions, ExitCode, type GenerateResult, type HarnessConfig, OutputFormatter, OutputMode, type Persona, type PersonaMetadata, type PersonaRunReport, type RenderedFiles, type TemplateContext, TemplateEngine, buildPreamble, createProgram, findConfigFile, generateAgentsMd, generateCIWorkflow, generateRuntime, generateSkillFiles, generateSlashCommands, handleError, listPersonas, loadConfig, loadPersona, logger, resolveConfig, runCheckPhaseGate, runCrossCheck, runPersona };

package/dist/index.js

@@ -8,13 +8,14 @@ import {
   generateAgentsMd,
   generateCIWorkflow,
   generateRuntime,
+  generateSlashCommands,
   listPersonas,
   loadConfig,
   loadPersona,
   resolveConfig,
   runCheckPhaseGate,
   runPersona
-} from "./chunk-NHLJNFKV.js";
+} from "./chunk-IXT3KLVN.js";
 import {
   runCrossCheck
 } from "./chunk-3U5VZYR7.js";
@@ -38,6 +39,7 @@ export {
   generateCIWorkflow,
   generateRuntime,
   generateSkillFiles,
+  generateSlashCommands,
   handleError,
   listPersonas,
   loadConfig,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@harness-engineering/cli",
-  "version": "1.1.1",
+  "version": "1.2.0",
   "description": "CLI for Harness Engineering toolkit",
   "type": "module",
   "bin": {

package/dist/agents/agents/personas/architecture-enforcer.yaml

@@ -1,27 +0,0 @@
-version: 1
-name: Architecture Enforcer
-description: Validates architectural constraints and dependency rules
-role: Enforce layer boundaries, detect circular dependencies, block forbidden imports
-skills:
-  - enforce-architecture
-  - check-mechanical-constraints
-commands:
-  - check-deps
-  - validate
-triggers:
-  - event: on_pr
-    conditions:
-      paths: ["src/**"]
-  - event: on_commit
-    conditions:
-      branches: ["main", "develop"]
-  - event: scheduled
-    cron: "0 6 * * 1"
-config:
-  severity: error
-  autoFix: false
-  timeout: 300000
-outputs:
-  agents-md: true
-  ci-workflow: true
-  runtime-config: true

package/dist/agents/agents/personas/documentation-maintainer.yaml

@@ -1,25 +0,0 @@
-version: 1
-name: Documentation Maintainer
-description: Keeps documentation in sync with source code
-role: Detect documentation drift, validate doc coverage, align docs with code changes
-skills:
-  - detect-doc-drift
-  - align-documentation
-commands:
-  - check-docs
-  - validate
-triggers:
-  - event: on_pr
-    conditions:
-      paths: ["src/**", "docs/**"]
-  - event: on_commit
-    conditions:
-      branches: ["main"]
-config:
-  severity: warning
-  autoFix: false
-  timeout: 300000
-outputs:
-  agents-md: true
-  ci-workflow: true
-  runtime-config: true

package/dist/agents/agents/personas/entropy-cleaner.yaml

@@ -1,21 +0,0 @@
-version: 1
-name: Entropy Cleaner
-description: Detects and fixes codebase entropy (drift, dead code, pattern violations)
-role: Run scheduled cleanup, detect documentation drift, fix pattern violations
-skills:
-  - cleanup-dead-code
-  - detect-doc-drift
-commands:
-  - cleanup
-  - fix-drift
-triggers:
-  - event: scheduled
-    cron: "0 6 * * 1"
-config:
-  severity: warning
-  autoFix: false
-  timeout: 600000
-outputs:
-  agents-md: true
-  ci-workflow: true
-  runtime-config: true

package/dist/agents/agents/skills/.turbo/turbo-test.log

@@ -1,16 +0,0 @@
-
-> @harness-engineering/skills@1.0.0 test /Users/cwarner/Projects/harness-engineering/agents/skills
-> vitest
-
-
- RUN  v4.0.18 /Users/cwarner/Projects/harness-engineering/agents/skills
-
- ✓ tests/schema.test.ts (10 tests) 5ms
- ✓ tests/structure.test.ts (91 tests) 10ms
- ✓ tests/references.test.ts (48 tests) 41ms
-
- Test Files  3 passed (3)
-      Tests  149 passed (149)
-   Start at  12:08:55
-   Duration  572ms (transform 58ms, setup 0ms, import 443ms, tests 56ms, environment 0ms)
-