@williambeto/ai-workflow 2.7.0 → 2.8.0

package/{chunk-BDZPUAEX.js → chunk-Y4RLP6ZM.js}

@@ -407,6 +407,7 @@ var EvidenceCollector = class {
   explicitApprovals;
   visualDist;
   port;
+  workflowEvidence;
   constructor({
     cwd,
     maxLogLength = 2e3,
@@ -419,7 +420,8 @@ var EvidenceCollector = class {
     userRequest = null,
     explicitApprovals = [],
     visualDist = null,
-    port = 8080
+    port = 8080,
+    workflowEvidence = null
   }) {
     this.cwd = cwd;
     this.maxLogLength = maxLogLength;
@@ -433,6 +435,7 @@ var EvidenceCollector = class {
     this.explicitApprovals = explicitApprovals;
     this.visualDist = visualDist;
     this.port = Number(port || 8080);
+    this.workflowEvidence = workflowEvidence;
   }
   async findUserRequest() {
     if (this.userRequest) return this.userRequest;
@@ -607,7 +610,12 @@ var EvidenceCollector = class {
       limitations,
       deliveryDecision,
       artifactFidelityCheck,
-      visualEvidence
+      visualEvidence,
+      workflowId: this.workflowEvidence?.workflowId || void 0,
+      baseSha: this.workflowEvidence?.baseSha || void 0,
+      artifactHashes: this.workflowEvidence?.artifactHashes || void 0,
+      phaseOrder: this.workflowEvidence?.phaseOrder || void 0,
+      confirmedActors: this.workflowEvidence?.confirmedActors || void 0
     };
     if (writeArtifact) {
       await fs3.writeFile(path3.join(this.cwd, "EVIDENCE.json"), JSON.stringify(evidence, null, 2));
@@ -731,4 +739,4 @@ export {
   EvidenceCollector,
   ValidationPlanner
 };
-//# sourceMappingURL=chunk-BDZPUAEX.js.map
+//# sourceMappingURL=chunk-Y4RLP6ZM.js.map

package/chunk-YOBY5C72.js

@@ -0,0 +1,76 @@
+// src/linting/skill-frontmatter-linter.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+function parseFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---\n/);
+  if (!match) return {};
+  const lines = match[1].split("\n");
+  const data = {};
+  for (const line of lines) {
+    const colonIdx = line.indexOf(":");
+    if (colonIdx !== -1) {
+      const key = line.substring(0, colonIdx).trim();
+      const value = line.substring(colonIdx + 1).trim();
+      data[key] = value.replace(/^["'](.*)["']$/, "$1");
+    }
+  }
+  return data;
+}
+function lintSkillFile(filePath) {
+  const errors = [];
+  if (!fs.existsSync(filePath)) return errors;
+  const content = fs.readFileSync(filePath, "utf8");
+  const frontmatter = parseFrontmatter(content);
+  if (!frontmatter.name) {
+    errors.push({ filePath, message: "Missing or empty 'name' field in frontmatter" });
+  }
+  if (!frontmatter.description) {
+    errors.push({ filePath, message: "Missing or empty 'description' field in frontmatter" });
+  }
+  return errors;
+}
+function findSkillDirs(baseDir) {
+  if (!fs.existsSync(baseDir)) return [];
+  const entries = fs.readdirSync(baseDir, { withFileTypes: true });
+  return entries.filter((e) => e.isDirectory()).map((e) => path.join(baseDir, e.name));
+}
+function getDiscoverableSkillPaths(cwd) {
+  const pathsToSearch = [
+    path.join(cwd, ".agents/skills"),
+    path.join(cwd, ".ai-workflow/opencode/skills"),
+    // Installed by kit
+    path.join(cwd, "dist-assets/skills"),
+    // DevKit source
+    path.join(os.homedir(), ".gemini/config/skills"),
+    path.join(os.homedir(), ".gemini/antigravity-cli/builtin/skills")
+  ];
+  const skillFiles = [];
+  for (const basePath of pathsToSearch) {
+    const dirs = findSkillDirs(basePath);
+    for (const dir of dirs) {
+      const skillFile = path.join(dir, "SKILL.md");
+      if (fs.existsSync(skillFile)) {
+        skillFiles.push(skillFile);
+      }
+    }
+  }
+  return skillFiles;
+}
+function runLinter(cwd) {
+  const files = getDiscoverableSkillPaths(cwd);
+  const allErrors = [];
+  for (const file of files) {
+    const fileErrors = lintSkillFile(file);
+    allErrors.push(...fileErrors);
+  }
+  return { errors: allErrors, filesScanned: files.length };
+}
+
+export {
+  parseFrontmatter,
+  lintSkillFile,
+  getDiscoverableSkillPaths,
+  runLinter
+};
+//# sourceMappingURL=chunk-YOBY5C72.js.map

package/core/index.d.ts

@@ -133,6 +133,8 @@ declare class EvidenceLedger {
     cwd: string;
     workflowId: string;
     events: LedgerEvent[];
+    private loadedPath;
+    private loadedContentHash;
     constructor({ cwd, workflowId }?: {
         cwd?: string;
         workflowId?: string;
@@ -154,6 +156,7 @@ declare class EvidenceLedger {
      * Saves the ledger events to a JSON file.
      */
     save(filePath: string): Promise<void>;
+    load(filePath: string): Promise<boolean>;
     verifyRoleConfinement(): Promise<RoleConfinementResult>;
 }
 
@@ -161,6 +164,7 @@ interface InspectResult {
     available: boolean;
     supports: {
         run: boolean;
+        server: boolean;
         formatJson: boolean;
         agent: boolean;
         model: boolean;
@@ -171,6 +175,7 @@ interface ExecuteOptions {
     model?: string | null;
     readOnly?: boolean;
     fastTrack?: boolean;
+    requireActorConfirmation?: boolean;
 }
 interface ExecuteResult {
     success: boolean;
@@ -182,6 +187,8 @@ interface ExecuteResult {
     runtimeAgentApplied?: string | null;
     runtimeAgentSupported?: boolean;
     runtimeAgentSelectionMode?: string;
+    runtimeActorConfirmation?: "confirmed" | "unavailable";
+    output?: string;
 }
 /**
  * OpenCodeAdapter - Real runtime integration with the OpenCode CLI.
@@ -198,7 +205,7 @@ declare class OpenCodeAdapter {
     /**
      * Runs opencode with a prompt and options.
      */
-    execute(message: string, { agent, model, readOnly, fastTrack }?: ExecuteOptions): Promise<ExecuteResult>;
+    execute(message: string, { agent, model, readOnly, fastTrack, requireActorConfirmation }?: ExecuteOptions): Promise<ExecuteResult>;
 }
 
 interface DelegationControllerOptions {
@@ -206,6 +213,22 @@ interface DelegationControllerOptions {
     ledger?: EvidenceLedger;
     adapter?: OpenCodeAdapter;
 }
+interface PhaseArtifactResult {
+    artifactPath?: string;
+    artifactHash?: string;
+    [key: string]: unknown;
+}
+interface DelegationPhaseOptions {
+    phase: "specification" | "planning" | "implementation";
+    actor: "Nexus" | "Orion" | "Astra";
+    prompt: string;
+    readOnly: boolean;
+    requireExplicitActor?: boolean;
+    onOutput?: (output: string) => Promise<PhaseArtifactResult | void>;
+}
+interface DelegationPhaseResult extends ExecuteResult {
+    artifact?: PhaseArtifactResult;
+}
 /**
  * DelegationController - Manages and logs coordination between Atlas, Astra, Sage, and Phoenix.
  */
@@ -219,6 +242,11 @@ declare class DelegationController {
      * Logs routing decision by Atlas.
      */
     route(naturalRequest: string, classification: RequestClassifierResult): Promise<void>;
+    /**
+     * Executes one high-risk phase and fails closed unless the runtime confirms
+     * the requested actor through machine-readable output.
+     */
+    executePhase({ phase, actor, prompt, readOnly, requireExplicitActor, onOutput }: DelegationPhaseOptions): Promise<DelegationPhaseResult>;
     /**
      * Logs and executes the implementation process by Astra.
      */
@@ -426,11 +454,14 @@ interface SpecValidationResult {
     reason?: string;
     tier?: string;
 }
+type RequiredSpecStatus = "DRAFT" | "APPROVED";
 /**
  * SpecValidator - Enforces "No Spec, No Code" rule.
  * Validates existence, structure, and approval status of specifications.
  */
 declare class SpecValidator {
+    validateContent(content: string, requiredStatus?: RequiredSpecStatus): SpecValidationResult;
+    validateDraftContent(content: string): SpecValidationResult;
     /**
      * Validates a specification file.
      */

package/core/index.js

@@ -1,5 +1,4 @@
 import {
-  BranchGate,
   DelegationController,
   EvidenceLedger,
   ExecutionPlanner,
@@ -10,10 +9,13 @@ import {
   RequestClassifier,
   SpecValidator,
   WorkflowStateMachine
-} from "../chunk-W4RTQWVQ.js";
+} from "../chunk-LI76KI7C.js";
 import {
   MergeGate
 } from "../chunk-XW747GIG.js";
+import {
+  BranchGate
+} from "../chunk-AINIR25D.js";
 import "../chunk-5WRI5ZAA.js";
 export {
   BranchGate,

package/dist-assets/docs/cli-reference.md

@@ -75,19 +75,21 @@ Runs formal orchestration for an approved specification with branch safety, obse
 
 **Synopsis:**
 ```bash
-ai-workflow run --spec-path=<path>
+ai-workflow run --spec-path=<path> [--approval-path=<path>]
 ```
 
 **Description:**
-Reads an approved specification file and orchestrates the full implementation workflow. Enforces branch gate safety, runs validation commands, applies bounded remediation (up to configured attempt limits), and generates a handoff summary.
+Reads an approved specification file and orchestrates the full implementation workflow. Enforces branch gate safety, runs validation commands, applies bounded remediation (up to configured attempt limits), and generates a handoff summary. DEEP specifications also require a hash-bound approval receipt created after human review.
 
 | Flag | Description |
 | --- | --- |
 | `--spec-path=<path>` | Path to the approved specification file (required) |
+| `--approval-path=<path>` | Path to the approval receipt required for DEEP specifications |
 
 **Example:**
 ```bash
 ai-workflow run --spec-path=.ai-workflow/specs/feature-auth.md
+ai-workflow run --spec-path=docs/workflows/auth/spec.md --approval-path=.ai-workflow/approvals/auth.json
 ```
 
 ---
@@ -196,6 +198,49 @@ ai-workflow clean --purge-agents  # Remove everything including .agents/
 
 ---
 
+## `ai-workflow skill create`
+
+Creates a workspace-local skill scaffold.
+
+**Synopsis:**
+```bash
+ai-workflow skill create <name> [--description=<description>] [--dry-run] [--force]
+```
+
+**Description:**
+Creates `.agents/skills/<name>/SKILL.md` with the required `name` and `description` YAML frontmatter. Skill names must use lowercase kebab-case. The command validates the destination before applying the branch gate and rejects paths or symbolic links detected outside the workspace.
+
+| Flag | Description |
+| --- | --- |
+| `--description=<description>` | Search-friendly description written to the YAML frontmatter |
+| `--dry-run` | Show the target and planned action without creating a branch or writing files |
+| `--force` | Back up and overwrite an existing `SKILL.md`; preserves auxiliary files |
+
+**Example:**
+```bash
+ai-workflow skill create database-migrations \
+  --description="Guidelines for safe database migrations"
+```
+
+The generated folder can also contain optional `scripts/`, `examples/`, and `references/` directories. Workspace-local skills are discovered automatically and take precedence over installed or global skills.
+
+The containment checks protect against unsafe paths present when the command runs. As with other local filesystem tools, they do not defend against another process concurrently replacing validated directories while the write is in progress.
+
+---
+
+## `ai-workflow lint skills`
+
+Checks the required YAML frontmatter of every discoverable `SKILL.md`.
+
+**Synopsis:**
+```bash
+ai-workflow lint skills
+```
+
+The command scans workspace-local, installed, development, and supported global skill locations. It exits with a non-zero status when a skill is missing a non-empty `name` or `description` field.
+
+---
+
 ## Public Statuses
 
 All workflow commands that produce delivery summaries use these statuses:

package/dist-assets/schemas/approval-receipt.schema.json

@@ -0,0 +1,35 @@
+{
+  "$id": "https://github.com/williambeto/ai-workflow/schemas/approval-receipt.schema.json",
+  "title": "Human Approval Receipt",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "workflowId",
+    "approvedSpecHash",
+    "approvedBy",
+    "approvedAt",
+    "authorizationSource"
+  ],
+  "properties": {
+    "workflowId": {
+      "type": "string",
+      "pattern": "^[a-zA-Z0-9][a-zA-Z0-9._-]{0,127}$"
+    },
+    "approvedSpecHash": {
+      "type": "string",
+      "pattern": "^[a-f0-9]{64}$"
+    },
+    "approvedBy": {
+      "type": "string",
+      "minLength": 1
+    },
+    "approvedAt": {
+      "type": "string",
+      "format": "date-time"
+    },
+    "authorizationSource": {
+      "type": "string",
+      "minLength": 1
+    }
+  }
+}

package/dist-assets/schemas/evidence.schema.json

@@ -104,6 +104,39 @@
     "visualEvidence": {
       "type": ["object", "null"],
       "additionalProperties": true
+    },
+    "workflowId": {
+      "type": "string"
+    },
+    "baseSha": {
+      "type": "string"
+    },
+    "artifactHashes": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["draft", "approved", "technicalPlan"],
+      "properties": {
+        "draft": { "type": ["string", "null"], "pattern": "^[a-f0-9]{64}$" },
+        "approved": { "type": "string", "pattern": "^[a-f0-9]{64}$" },
+        "technicalPlan": { "type": "string", "pattern": "^[a-f0-9]{64}$" }
+      }
+    },
+    "phaseOrder": {
+      "type": "array",
+      "items": { "enum": ["specification", "planning", "implementation"] }
+    },
+    "confirmedActors": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["phase", "requested", "applied"],
+        "properties": {
+          "phase": { "enum": ["specification", "planning", "implementation"] },
+          "requested": { "enum": ["Nexus", "Orion", "Astra"] },
+          "applied": { "enum": ["Nexus", "Orion", "Astra"] }
+        }
+      }
     }
   }
 }

package/evidence-validator-HS3NTWAB.js

@@ -0,0 +1,8 @@
+import {
+  EvidenceValidator
+} from "./chunk-FNT7DN3N.js";
+import "./chunk-5WRI5ZAA.js";
+export {
+  EvidenceValidator
+};
+//# sourceMappingURL=evidence-validator-HS3NTWAB.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@williambeto/ai-workflow",
-  "version": "2.7.0",
+  "version": "2.8.0",
   "description": "AI Workflow Kit — OpenCode-first software delivery workflow with agents, commands, skills, validation, and evidence",
   "license": "MIT",
   "author": "José Willams",
@@ -13,6 +13,18 @@
   "engines": {
     "node": ">=20.11"
   },
+  "devEngines": {
+    "runtime": {
+      "name": "node",
+      "version": ">=22.14.0 <23",
+      "onFail": "error"
+    },
+    "packageManager": {
+      "name": "npm",
+      "version": ">=10",
+      "onFail": "error"
+    }
+  },
   "keywords": [
     "ai-workflow",
     "opencode",
@@ -41,5 +53,8 @@
     "README.md",
     "LICENSE",
     "CHANGELOG.md"
-  ]
+  ],
+  "dependencies": {
+    "@opencode-ai/sdk": "1.17.18"
+  }
 }

package/skill-4MEGJ3DO.js

@@ -0,0 +1,211 @@
+import {
+  createManagedBackup
+} from "./chunk-AY33SA5W.js";
+import {
+  BranchGate
+} from "./chunk-AINIR25D.js";
+import {
+  lintSkillFile
+} from "./chunk-YOBY5C72.js";
+import "./chunk-5WRI5ZAA.js";
+
+// src/cli/commands/skill.ts
+import fs from "fs/promises";
+import path from "path";
+import { randomUUID } from "crypto";
+var SKILL_NAME_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var MAX_SKILL_NAME_LENGTH = 64;
+var BACKUP_ROOT = ".ai-workflow-backups";
+function requireDescription(value) {
+  if (value === void 0 || value.trim().length === 0) {
+    throw new Error("--description requires a non-empty value");
+  }
+  return value.trim();
+}
+function parseSkillCreateArgs(args) {
+  const positionals = [];
+  let description;
+  let descriptionSeen = false;
+  let force = false;
+  let dryRun = false;
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--force") {
+      force = true;
+    } else if (arg === "--dry-run") {
+      dryRun = true;
+    } else if (arg === "--description") {
+      if (descriptionSeen) throw new Error("--description may only be provided once");
+      const value = args[index + 1];
+      if (value?.startsWith("--")) throw new Error("--description requires a non-empty value");
+      description = requireDescription(value);
+      descriptionSeen = true;
+      index += 1;
+    } else if (arg.startsWith("--description=")) {
+      if (descriptionSeen) throw new Error("--description may only be provided once");
+      description = requireDescription(arg.slice("--description=".length));
+      descriptionSeen = true;
+    } else if (arg.startsWith("-")) {
+      throw new Error(`Unknown option for skill create: ${arg}`);
+    } else {
+      positionals.push(arg);
+    }
+  }
+  if (positionals.length > 1) {
+    throw new Error(`Unexpected positional arguments: ${positionals.slice(1).join(" ")}`);
+  }
+  return { name: positionals[0], description, force, dryRun };
+}
+function isWithin(parent, candidate) {
+  const relative = path.relative(parent, candidate);
+  return relative === "" || !relative.startsWith(`..${path.sep}`) && relative !== ".." && !path.isAbsolute(relative);
+}
+function assertWithinWorkspace(workspaceRoot, candidate, label) {
+  if (!isWithin(workspaceRoot, candidate)) {
+    throw new Error(`${label} resolves outside the workspace: ${candidate}`);
+  }
+}
+async function lstatIfExists(targetPath) {
+  try {
+    return await fs.lstat(targetPath);
+  } catch (error) {
+    if (error?.code === "ENOENT") return void 0;
+    throw error;
+  }
+}
+async function validateExistingDirectory(targetPath, workspaceRoot, label, rejectSymlink = false) {
+  const entry = await lstatIfExists(targetPath);
+  if (!entry) return false;
+  if (rejectSymlink && entry.isSymbolicLink()) {
+    throw new Error(`${label} must not be a symbolic link: ${targetPath}`);
+  }
+  let resolved;
+  try {
+    resolved = await fs.realpath(targetPath);
+  } catch (error) {
+    throw new Error(`Cannot resolve ${label}: ${error.message}`);
+  }
+  assertWithinWorkspace(workspaceRoot, resolved, label);
+  const resolvedEntry = await fs.stat(targetPath);
+  if (!resolvedEntry.isDirectory()) {
+    throw new Error(`${label} must be a directory: ${targetPath}`);
+  }
+  return true;
+}
+async function validateExistingSkillFile(skillFile) {
+  const entry = await lstatIfExists(skillFile);
+  if (!entry) return false;
+  if (entry.isSymbolicLink()) {
+    throw new Error(`SKILL.md must not be a symbolic link: ${skillFile}`);
+  }
+  if (!entry.isFile()) {
+    throw new Error(`SKILL.md must be a regular file: ${skillFile}`);
+  }
+  return true;
+}
+function validateSkillName(name) {
+  if (name.length > MAX_SKILL_NAME_LENGTH || !SKILL_NAME_PATTERN.test(name)) {
+    throw new Error(
+      `Invalid skill name '${name}'. Use lowercase kebab-case with at most ${MAX_SKILL_NAME_LENGTH} characters (for example: database-migrations).`
+    );
+  }
+}
+function buildSkillContent(name, description) {
+  const safeDescription = description || `Provides guidelines and instructions for ${name}`;
+  const readableName = name.split("-").map((part) => `${part[0].toUpperCase()}${part.slice(1)}`).join(" ");
+  return `---
+name: ${JSON.stringify(name)}
+description: ${JSON.stringify(safeDescription)}
+---
+
+# ${readableName}
+
+## Context
+
+Describe when this skill should be used.
+
+## Instructions
+
+- Add concrete, actionable instructions.
+- Document constraints and prohibited actions.
+
+## Validation
+
+- Define the commands or checks required before completion.
+`;
+}
+async function runSkillCreate(options) {
+  const { cwd, name, description, force = false, dryRun = false } = options;
+  if (!name) {
+    throw new Error('Skill name is required. Usage: ai-workflow skill create <name> [--description="..."] [--dry-run] [--force]');
+  }
+  validateSkillName(name);
+  const normalizedDescription = description === void 0 ? void 0 : requireDescription(description);
+  const workspaceRoot = await fs.realpath(cwd);
+  const agentsDir = path.join(workspaceRoot, ".agents");
+  const skillsDir = path.join(agentsDir, "skills");
+  const skillDir = path.join(skillsDir, name);
+  const skillFile = path.join(skillDir, "SKILL.md");
+  assertWithinWorkspace(workspaceRoot, skillFile, "Skill destination");
+  await validateExistingDirectory(agentsDir, workspaceRoot, ".agents directory");
+  await validateExistingDirectory(skillsDir, workspaceRoot, "Skills directory");
+  await validateExistingDirectory(skillDir, workspaceRoot, `Skill directory '${name}'`, true);
+  const skillExists = await validateExistingSkillFile(skillFile);
+  if (skillExists && !force) {
+    throw new Error(`Skill '${name}' already exists at ${skillFile}. Use --force to overwrite.`);
+  }
+  const content = buildSkillContent(name, normalizedDescription);
+  const branchGate = new BranchGate({ cwd: workspaceRoot });
+  const gateResult = branchGate.check("", { taskSlug: `skill-${name}`, readOnly: dryRun });
+  if (gateResult.blocked || gateResult.branch === "unknown") {
+    throw new Error(`[GATE BLOCKED] ${gateResult.reason || "Git is unavailable or the current branch could not be determined."}`);
+  }
+  if (dryRun) {
+    console.log(`[DRY RUN] Would ${skillExists ? "overwrite" : "create"} skill '${name}' at ${skillFile}`);
+    return { status: "dry-run", skillName: name, skillFile, branch: gateResult.branch };
+  }
+  await fs.mkdir(skillDir, { recursive: true });
+  await validateExistingDirectory(agentsDir, workspaceRoot, ".agents directory");
+  await validateExistingDirectory(skillsDir, workspaceRoot, "Skills directory");
+  await validateExistingDirectory(skillDir, workspaceRoot, `Skill directory '${name}'`, true);
+  let backupPath;
+  if (skillExists) {
+    await validateExistingSkillFile(skillFile);
+    const backupRoot = path.join(workspaceRoot, BACKUP_ROOT);
+    await validateExistingDirectory(backupRoot, workspaceRoot, "Backup directory");
+    backupPath = await createManagedBackup(skillFile, { cwd: workspaceRoot, backupRoot: BACKUP_ROOT });
+    assertWithinWorkspace(workspaceRoot, await fs.realpath(backupPath), "Backup file");
+    await validateExistingDirectory(skillDir, workspaceRoot, `Skill directory '${name}'`, true);
+    await validateExistingSkillFile(skillFile);
+    const stagedFile = path.join(skillDir, `.SKILL.md.${randomUUID()}.tmp`);
+    try {
+      await fs.writeFile(stagedFile, content, { encoding: "utf8", flag: "wx" });
+      await validateExistingDirectory(skillDir, workspaceRoot, `Skill directory '${name}'`, true);
+      await fs.rename(stagedFile, skillFile);
+    } finally {
+      await fs.rm(stagedFile, { force: true }).catch(() => {
+      });
+    }
+  } else {
+    try {
+      await fs.writeFile(skillFile, content, { encoding: "utf8", flag: "wx" });
+    } catch (error) {
+      if (error?.code === "EEXIST") {
+        throw new Error(`Skill '${name}' already exists at ${skillFile}. Use --force to overwrite.`);
+      }
+      throw error;
+    }
+  }
+  const lintErrors = lintSkillFile(skillFile);
+  if (lintErrors.length > 0) {
+    throw new Error(`Generated skill failed frontmatter lint: ${lintErrors.map((error) => error.message).join("; ")}`);
+  }
+  const status = skillExists ? "overwritten" : "created";
+  console.log(`${status === "created" ? "Created" : "Overwrote"} skill '${name}' at ${skillFile}`);
+  return { status, skillName: name, skillFile, backupPath, branch: gateResult.branch };
+}
+export {
+  parseSkillCreateArgs,
+  runSkillCreate
+};
+//# sourceMappingURL=skill-4MEGJ3DO.js.map

package/skill-frontmatter-linter-FMJADOK4.js

@@ -0,0 +1,14 @@
+import {
+  getDiscoverableSkillPaths,
+  lintSkillFile,
+  parseFrontmatter,
+  runLinter
+} from "./chunk-YOBY5C72.js";
+import "./chunk-5WRI5ZAA.js";
+export {
+  getDiscoverableSkillPaths,
+  lintSkillFile,
+  parseFrontmatter,
+  runLinter
+};
+//# sourceMappingURL=skill-frontmatter-linter-FMJADOK4.js.map

package/{validate-A46WUBVZ.js → validate-IEHLAVZ6.js}

@@ -3,7 +3,7 @@ import {
   QualityGuard,
   ValidationPlanner,
   VisualVerifier
-} from "./chunk-BDZPUAEX.js";
+} from "./chunk-Y4RLP6ZM.js";
 import "./chunk-XW747GIG.js";
 import "./chunk-5WRI5ZAA.js";
 
@@ -86,4 +86,4 @@ async function runValidate({
 export {
   runValidate
 };
-//# sourceMappingURL=validate-A46WUBVZ.js.map
+//# sourceMappingURL=validate-IEHLAVZ6.js.map