@ainyc/canonry 3.2.5 → 3.3.2

package/dist/cli.js

@@ -17,17 +17,19 @@ import {
   setGoogleAuthConfig,
   showFirstRunNotice,
   trackEvent
-} from "./chunk-AQ3AS25Y.js";
+} from "./chunk-HQ47AA6H.js";
 import {
   CcReleaseSyncStatuses,
   CheckScopes,
   CheckStatuses,
   CliError,
+  CodingAgents,
   EXIT_SYSTEM_ERROR,
   EXIT_USER_ERROR,
   ProviderNames,
   RunKinds,
   RunStatuses,
+  SkillsClients,
   configExists,
   createApiClient,
   determineAnswerMentioned,
@@ -44,8 +46,9 @@ import {
   resolveProviderInput,
   saveConfig,
   saveConfigPatch,
+  skillsClientSchema,
   usageError
-} from "./chunk-PS7JRDL3.js";
+} from "./chunk-ALMP3NBQ.js";
 import {
   apiKeys,
   competitors,
@@ -68,9 +71,9 @@ import { parseArgs } from "util";
 function commandId(spec) {
   return spec.path.join(".");
 }
-function matchesPath(args, path8) {
-  if (args.length < path8.length) return false;
-  return path8.every((segment, index) => args[index] === segment);
+function matchesPath(args, path9) {
+  if (args.length < path9.length) return false;
+  return path9.every((segment, index) => args[index] === segment);
 }
 function withFormatOption(options) {
   if (!options) {
@@ -448,6 +451,131 @@ async function backfillAiReferralPathsCommand(opts) {
   console.log(`  Updated:   ${updated}`);
   console.log(`  Unchanged: ${unchanged}`);
 }
+async function backfillAnswerMentionsCommand(opts) {
+  const config = loadConfig();
+  const db = createClient(config.database);
+  migrate(db);
+  const projectFilter = opts?.project?.trim();
+  const scopedProjects = projectFilter ? db.select().from(projects).where(eq(projects.name, projectFilter)).all() : db.select().from(projects).all();
+  let examined = 0;
+  let updated = 0;
+  let mentioned = 0;
+  if (scopedProjects.length > 0) {
+    const runRows = projectFilter ? db.select({ id: runs.id, projectId: runs.projectId }).from(runs).where(and(
+      eq(runs.kind, RunKinds["answer-visibility"]),
+      inArray(runs.projectId, scopedProjects.map((project) => project.id))
+    )).all() : db.select({ id: runs.id, projectId: runs.projectId }).from(runs).where(eq(runs.kind, RunKinds["answer-visibility"])).all();
+    const runIdsByProject = /* @__PURE__ */ new Map();
+    for (const run of runRows) {
+      const existing = runIdsByProject.get(run.projectId);
+      if (existing) existing.push(run.id);
+      else runIdsByProject.set(run.projectId, [run.id]);
+    }
+    for (const project of scopedProjects) {
+      const competitorDomains = db.select({ domain: competitors.domain }).from(competitors).where(eq(competitors.projectId, project.id)).all().map((row) => row.domain);
+      const runIds = runIdsByProject.get(project.id) ?? [];
+      if (runIds.length === 0) continue;
+      const projectDomains = effectiveDomains({
+        canonicalDomain: project.canonicalDomain,
+        ownedDomains: parseJsonColumn(project.ownedDomains, [])
+      });
+      for (let offset = 0; offset < runIds.length; offset += SNAPSHOT_BATCH_SIZE) {
+        const batchRunIds = runIds.slice(offset, offset + SNAPSHOT_BATCH_SIZE);
+        const snapshotRows = db.select({
+          id: querySnapshots.id,
+          provider: querySnapshots.provider,
+          answerMentioned: querySnapshots.answerMentioned,
+          answerText: querySnapshots.answerText,
+          citedDomains: querySnapshots.citedDomains,
+          competitorOverlap: querySnapshots.competitorOverlap,
+          recommendedCompetitors: querySnapshots.recommendedCompetitors,
+          rawResponse: querySnapshots.rawResponse
+        }).from(querySnapshots).where(inArray(querySnapshots.runId, batchRunIds)).all();
+        const pendingUpdates = [];
+        for (const snapshot of snapshotRows) {
+          examined++;
+          const answerText = snapshot.answerText ?? "";
+          const nextAnswerMentioned = determineAnswerMentioned(answerText, project.displayName, projectDomains);
+          if (nextAnswerMentioned) mentioned++;
+          const citedDomains = parseJsonColumn(snapshot.citedDomains, []);
+          const groundingSources = readStoredGroundingSources(snapshot.rawResponse);
+          const normalized = {
+            provider: snapshot.provider,
+            answerText,
+            citedDomains,
+            groundingSources,
+            searchQueries: []
+          };
+          const nextCompetitorOverlap = JSON.stringify(
+            computeCompetitorOverlap(normalized, competitorDomains)
+          );
+          const nextRecommendedCompetitors = JSON.stringify(
+            extractRecommendedCompetitors(
+              answerText,
+              projectDomains,
+              citedDomains,
+              competitorDomains
+            )
+          );
+          const nextPatch = {};
+          if (snapshot.answerMentioned !== nextAnswerMentioned) {
+            nextPatch.answerMentioned = nextAnswerMentioned;
+          }
+          if (snapshot.competitorOverlap !== nextCompetitorOverlap) {
+            nextPatch.competitorOverlap = nextCompetitorOverlap;
+          }
+          if (snapshot.recommendedCompetitors !== nextRecommendedCompetitors) {
+            nextPatch.recommendedCompetitors = nextRecommendedCompetitors;
+          }
+          if (Object.keys(nextPatch).length > 0) {
+            pendingUpdates.push({ id: snapshot.id, patch: nextPatch });
+          }
+        }
+        if (pendingUpdates.length > 0) {
+          db.transaction((tx) => {
+            for (const update of pendingUpdates) {
+              tx.update(querySnapshots).set(update.patch).where(eq(querySnapshots.id, update.id)).run();
+            }
+          });
+          updated += pendingUpdates.length;
+        }
+      }
+    }
+  }
+  const result = {
+    project: projectFilter ?? null,
+    projects: scopedProjects.length,
+    examined,
+    updated,
+    mentioned
+  };
+  if (opts?.format === "json") {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  console.log("Answer mentions backfill complete.\n");
+  if (projectFilter) console.log(`  Project:   ${projectFilter}`);
+  console.log(`  Projects:  ${scopedProjects.length}`);
+  console.log(`  Examined:  ${examined}`);
+  console.log(`  Updated:   ${updated}`);
+  console.log(`  Mentioned: ${mentioned}`);
+}
+function readStoredGroundingSources(rawResponse) {
+  const envelope = parseJsonColumn(rawResponse, {});
+  const sources = envelope.groundingSources;
+  if (!Array.isArray(sources)) return [];
+  const result = [];
+  for (const source of sources) {
+    if (source && typeof source === "object") {
+      const uri = source.uri;
+      const title = source.title;
+      if (typeof uri === "string") {
+        result.push({ uri, title: typeof title === "string" ? title : "" });
+      }
+    }
+  }
+  return result;
+}
 async function backfillInsightsCommand(project, opts) {
   const { IntelligenceService } = await import("./intelligence-service-FNJTFSI3.js");
   const config = loadConfig();
@@ -628,6 +756,20 @@ var BACKFILL_CLI_COMMANDS = [
       });
     }
   },
+  {
+    path: ["backfill", "answer-mentions"],
+    usage: "canonry backfill answer-mentions [--project <name>] [--format json]",
+    options: {
+      project: stringOption()
+    },
+    allowPositionals: false,
+    run: async (input) => {
+      await backfillAnswerMentionsCommand({
+        project: getString(input.values, "project"),
+        format: input.format
+      });
+    }
+  },
   {
     path: ["backfill", "insights"],
     usage: "canonry backfill insights <project> [--from-run <id>] [--to-run <id>] [--format json]",
@@ -675,12 +817,12 @@ var BACKFILL_CLI_COMMANDS = [
   },
   {
     path: ["backfill"],
-    usage: "canonry backfill <answer-visibility|insights|normalized-paths|ai-referral-paths> [options]",
+    usage: "canonry backfill <answer-visibility|answer-mentions|insights|normalized-paths|ai-referral-paths> [options]",
     run: async (input) => {
       unknownSubcommand(input.positionals[0], {
         command: "backfill",
-        usage: "canonry backfill <answer-visibility|insights|normalized-paths|ai-referral-paths> [options]",
-        available: ["answer-visibility", "insights", "normalized-paths", "ai-referral-paths"]
+        usage: "canonry backfill <answer-visibility|answer-mentions|insights|normalized-paths|ai-referral-paths> [options]",
+        available: ["answer-visibility", "answer-mentions", "insights", "normalized-paths", "ai-referral-paths"]
       });
     }
   }
@@ -1873,9 +2015,9 @@ async function gaConnect(project, opts) {
     propertyId: opts.propertyId
   };
   if (opts.keyFile) {
-    const fs9 = await import("fs");
+    const fs10 = await import("fs");
     try {
-      const content = fs9.readFileSync(opts.keyFile, "utf-8");
+      const content = fs10.readFileSync(opts.keyFile, "utf-8");
       JSON.parse(content);
       body.keyJson = content;
     } catch (e) {
@@ -5739,13 +5881,307 @@ Usage: canonry settings provider ${name} --api-key <key> [--model <model>] [--ma
   }
 ];
 
+// src/commands/skills.ts
+import fs4 from "fs";
+import path3 from "path";
+import { fileURLToPath } from "url";
+var BUNDLED_SKILL_NAMES = ["canonry-setup", "aero"];
+function resolveBundledSkillsRoot(pkgDir) {
+  const here = pkgDir ?? path3.dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    path3.join(here, "../assets/agent-workspace/skills"),
+    path3.join(here, "../../assets/agent-workspace/skills"),
+    path3.join(here, "../../../../skills")
+  ];
+  for (const candidate of candidates) {
+    if (BUNDLED_SKILL_NAMES.every((name) => fs4.existsSync(path3.join(candidate, name, "SKILL.md")))) {
+      return candidate;
+    }
+  }
+  throw new CliError({
+    code: "INTERNAL_ERROR",
+    message: `Bundled skills not found. Searched:
+  ${candidates.join("\n  ")}`,
+    exitCode: 2
+  });
+}
+function parseDescription(content) {
+  const fmMatch = /^---\n([\s\S]*?)\n---/.exec(content);
+  if (!fmMatch) return "";
+  const descMatch = /^description:\s*(.+?)$/m.exec(fmMatch[1]);
+  if (!descMatch) return "";
+  return descMatch[1].replace(/^["']|["']$/g, "").trim();
+}
+function getBundledSkills(pkgDir) {
+  const root = resolveBundledSkillsRoot(pkgDir);
+  return BUNDLED_SKILL_NAMES.map((name) => {
+    const skillDir = path3.join(root, name);
+    const skillFile = path3.join(skillDir, "SKILL.md");
+    const content = fs4.readFileSync(skillFile, "utf-8");
+    return { name, description: parseDescription(content), bundledPath: skillDir };
+  });
+}
+function walkRelative(dir, prefix = "") {
+  const out = [];
+  for (const entry of fs4.readdirSync(dir, { withFileTypes: true })) {
+    const rel = prefix ? path3.join(prefix, entry.name) : entry.name;
+    const full = path3.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      out.push(...walkRelative(full, rel));
+    } else if (entry.isFile()) {
+      out.push(rel);
+    }
+  }
+  return out.sort();
+}
+function compareDirContent(srcDir, destDir) {
+  if (!fs4.existsSync(destDir)) return "missing";
+  if (!fs4.statSync(destDir).isDirectory()) return "different";
+  const srcFiles = walkRelative(srcDir);
+  const destFiles = walkRelative(destDir);
+  if (srcFiles.length !== destFiles.length) return "different";
+  for (let i = 0; i < srcFiles.length; i++) {
+    if (srcFiles[i] !== destFiles[i]) return "different";
+    const srcBytes = fs4.readFileSync(path3.join(srcDir, srcFiles[i]));
+    const destBytes = fs4.readFileSync(path3.join(destDir, destFiles[i]));
+    if (!srcBytes.equals(destBytes)) return "different";
+  }
+  return "match";
+}
+function copyDirRecursive(src, dest) {
+  fs4.mkdirSync(dest, { recursive: true });
+  for (const entry of fs4.readdirSync(src, { withFileTypes: true })) {
+    const srcPath = path3.join(src, entry.name);
+    const destPath = path3.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDirRecursive(srcPath, destPath);
+    } else if (entry.isFile()) {
+      fs4.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+function installClaudeSkill(skill, targetDir, force) {
+  const targetPath = path3.join(targetDir, ".claude", "skills", skill.name);
+  const compare = compareDirContent(skill.bundledPath, targetPath);
+  if (compare === "match") {
+    return {
+      skill: skill.name,
+      client: CodingAgents.claude,
+      targetPath,
+      status: "already-installed",
+      message: `Already installed: .claude/skills/${skill.name}`
+    };
+  }
+  if (compare === "different" && !force) {
+    throw new CliError({
+      code: "VALIDATION_ERROR",
+      message: `.claude/skills/${skill.name}/ already exists and differs from the bundled skill. Pass --force to overwrite.`,
+      details: { skill: skill.name, targetPath },
+      exitCode: 1
+    });
+  }
+  if (compare === "different") {
+    fs4.rmSync(targetPath, { recursive: true, force: true });
+  }
+  copyDirRecursive(skill.bundledPath, targetPath);
+  return {
+    skill: skill.name,
+    client: CodingAgents.claude,
+    targetPath,
+    status: compare === "missing" ? "installed" : "updated",
+    message: compare === "missing" ? `Installed .claude/skills/${skill.name}` : `Updated .claude/skills/${skill.name}`
+  };
+}
+function installCodexSymlink(skill, targetDir, force) {
+  const codexPath = path3.join(targetDir, ".codex", "skills", skill.name);
+  const claudePath = path3.join(targetDir, ".claude", "skills", skill.name);
+  const linkTarget = path3.relative(path3.dirname(codexPath), claudePath);
+  fs4.mkdirSync(path3.dirname(codexPath), { recursive: true });
+  let stat;
+  try {
+    stat = fs4.lstatSync(codexPath);
+  } catch {
+    stat = void 0;
+  }
+  if (stat?.isSymbolicLink()) {
+    const existing = fs4.readlinkSync(codexPath);
+    if (existing === linkTarget) {
+      return {
+        skill: skill.name,
+        client: CodingAgents.codex,
+        targetPath: codexPath,
+        status: "already-linked",
+        message: `Already linked: .codex/skills/${skill.name}`
+      };
+    }
+    if (!force) {
+      throw new CliError({
+        code: "VALIDATION_ERROR",
+        message: `.codex/skills/${skill.name} is a symlink pointing elsewhere (${existing}). Pass --force to relink.`,
+        details: { skill: skill.name, targetPath: codexPath, existingTarget: existing },
+        exitCode: 1
+      });
+    }
+    fs4.unlinkSync(codexPath);
+    fs4.symlinkSync(linkTarget, codexPath);
+    return {
+      skill: skill.name,
+      client: CodingAgents.codex,
+      targetPath: codexPath,
+      status: "relinked",
+      message: `Relinked .codex/skills/${skill.name} \u2192 ${linkTarget}`
+    };
+  }
+  if (stat) {
+    if (!force) {
+      throw new CliError({
+        code: "VALIDATION_ERROR",
+        message: `.codex/skills/${skill.name} exists but is not a symlink. Pass --force to replace.`,
+        details: { skill: skill.name, targetPath: codexPath },
+        exitCode: 1
+      });
+    }
+    fs4.rmSync(codexPath, { recursive: true, force: true });
+  }
+  fs4.symlinkSync(linkTarget, codexPath);
+  return {
+    skill: skill.name,
+    client: CodingAgents.codex,
+    targetPath: codexPath,
+    status: stat ? "relinked" : "linked",
+    message: stat ? `Replaced and linked .codex/skills/${skill.name} \u2192 ${linkTarget}` : `Linked .codex/skills/${skill.name} \u2192 ${linkTarget}`
+  };
+}
+function buildSummaryMessage(results) {
+  const counts = {};
+  for (const r of results) counts[r.status] = (counts[r.status] ?? 0) + 1;
+  const parts = Object.entries(counts).map(([status, n]) => `${n} ${status}`);
+  return `Skills install summary: ${parts.join(", ")}.`;
+}
+async function installSkills(opts = {}) {
+  const targetDir = path3.resolve(opts.dir ?? process.cwd());
+  const client = opts.client ?? SkillsClients.all;
+  const force = opts.force ?? false;
+  const allSkills = getBundledSkills();
+  const requestedNames = opts.skills && opts.skills.length > 0 ? opts.skills : allSkills.map((s) => s.name);
+  const knownNames = new Set(allSkills.map((s) => s.name));
+  const unknown = requestedNames.filter((n) => !knownNames.has(n));
+  if (unknown.length > 0) {
+    throw new CliError({
+      code: "VALIDATION_ERROR",
+      message: `Unknown skill(s): ${unknown.join(", ")}. Available: ${[...knownNames].join(", ")}`,
+      details: { unknownSkills: unknown, availableSkills: [...knownNames] },
+      exitCode: 1
+    });
+  }
+  const skillsToInstall = allSkills.filter((s) => requestedNames.includes(s.name));
+  fs4.mkdirSync(targetDir, { recursive: true });
+  const results = [];
+  for (const skill of skillsToInstall) {
+    results.push(installClaudeSkill(skill, targetDir, force));
+    if (client !== SkillsClients.claude) {
+      results.push(installCodexSymlink(skill, targetDir, force));
+    }
+  }
+  return {
+    targetDir,
+    results,
+    message: buildSummaryMessage(results)
+  };
+}
+async function listSkills(opts = {}) {
+  const skills = getBundledSkills();
+  if (opts.format === "json") {
+    console.log(JSON.stringify({
+      skills: skills.map((s) => ({
+        name: s.name,
+        description: s.description,
+        claudePath: `.claude/skills/${s.name}`,
+        codexPath: `.codex/skills/${s.name}`
+      }))
+    }, null, 2));
+    return;
+  }
+  console.log("Bundled canonry skills:\n");
+  for (const skill of skills) {
+    console.log(`  ${skill.name}`);
+    if (skill.description) console.log(`    ${skill.description}`);
+    console.log(`    Claude: .claude/skills/${skill.name}/`);
+    console.log(`    Codex:  .codex/skills/${skill.name} (symlink \u2192 ../../.claude/skills/${skill.name})`);
+    console.log();
+  }
+}
+function emitInstallSummary(summary, format) {
+  if (format === "json") {
+    console.log(JSON.stringify(summary, null, 2));
+    return;
+  }
+  for (const r of summary.results) console.log(r.message);
+  console.log(`
+Target: ${summary.targetDir}`);
+  console.log(summary.message);
+}
+function parseSkillsClient(value) {
+  if (!value) return SkillsClients.all;
+  const parsed = skillsClientSchema.safeParse(value);
+  if (parsed.success) return parsed.data;
+  const allowed = skillsClientSchema.options;
+  throw new CliError({
+    code: "VALIDATION_ERROR",
+    message: `Invalid --client value "${value}". Must be one of: ${allowed.join(", ")}`,
+    details: { flag: "client", value, allowed },
+    exitCode: 1
+  });
+}
+
+// src/cli-commands/skills.ts
+var SKILLS_CLI_COMMANDS = [
+  {
+    path: ["skills", "list"],
+    usage: "canonry skills list [--format json]",
+    run: async (input) => {
+      await listSkills({ format: input.format });
+    }
+  },
+  {
+    path: ["skills", "install"],
+    usage: "canonry skills install [skill...] [--dir <path>] [--client claude|codex|all] [--force] [--format json]",
+    options: {
+      dir: stringOption(),
+      client: stringOption(),
+      force: { type: "boolean" }
+    },
+    allowPositionals: true,
+    run: async (input) => {
+      const summary = await installSkills({
+        dir: getString(input.values, "dir"),
+        skills: input.positionals.length > 0 ? input.positionals : void 0,
+        client: parseSkillsClient(getString(input.values, "client")),
+        force: getBoolean(input.values, "force")
+      });
+      emitInstallSummary(summary, input.format);
+    }
+  },
+  {
+    path: ["skills"],
+    usage: "canonry skills <list|install> [args]",
+    run: async (input) => {
+      unknownSubcommand(input.positionals[0], {
+        command: "skills",
+        usage: "canonry skills <list|install> [args]",
+        available: ["list", "install"]
+      });
+    }
+  }
+];
+
 // src/commands/snapshot.ts
-import fs5 from "fs";
-import path4 from "path";
+import fs6 from "fs";
+import path5 from "path";
 
 // src/snapshot-pdf.ts
-import fs4 from "fs";
-import path3 from "path";
+import fs5 from "fs";
+import path4 from "path";
 import { PDFDocument, StandardFonts, rgb } from "pdf-lib";
 var PAGE_WIDTH = 612;
 var PAGE_HEIGHT = 792;
@@ -5954,9 +6390,9 @@ async function writeSnapshotPdf(report, outputPath) {
   renderCompetitors(pdf, report);
   renderQueries(pdf, report);
   const bytes = await doc.save();
-  const resolvedPath = path3.resolve(outputPath);
-  fs4.mkdirSync(path3.dirname(resolvedPath), { recursive: true });
-  fs4.writeFileSync(resolvedPath, bytes);
+  const resolvedPath = path4.resolve(outputPath);
+  fs5.mkdirSync(path4.dirname(resolvedPath), { recursive: true });
+  fs5.writeFileSync(resolvedPath, bytes);
   return resolvedPath;
 }
 function renderCover(pdf, report) {
@@ -6114,9 +6550,9 @@ Markdown saved: ${savedMdPath}`);
 PDF saved: ${savedPdfPath}`);
 }
 function writeSnapshotMarkdown(report, outputPath) {
-  const resolvedPath = path4.resolve(outputPath);
-  fs5.mkdirSync(path4.dirname(resolvedPath), { recursive: true });
-  fs5.writeFileSync(resolvedPath, formatSnapshotMarkdown(report), "utf-8");
+  const resolvedPath = path5.resolve(outputPath);
+  fs6.mkdirSync(path5.dirname(resolvedPath), { recursive: true });
+  fs6.writeFileSync(resolvedPath, formatSnapshotMarkdown(report), "utf-8");
   return resolvedPath;
 }
 function formatSnapshotMarkdown(report) {
@@ -6771,7 +7207,7 @@ var CONTENT_CLI_COMMANDS = [
 
 // src/commands/bootstrap.ts
 import crypto from "crypto";
-import path5 from "path";
+import path6 from "path";
 import { eq as eq2 } from "drizzle-orm";
 
 // ../config/src/index.ts
@@ -6918,7 +7354,7 @@ async function bootstrapCommand(_opts) {
     );
   }
   const configDir = getConfigDir();
-  const databasePath = env.databasePath || path5.join(configDir, "data.db");
+  const databasePath = env.databasePath || path6.join(configDir, "data.db");
   const existing = configExists();
   const existingConfig = existing ? loadConfig() : void 0;
   let rawApiKey;
@@ -6988,10 +7424,10 @@ async function bootstrapCommand(_opts) {
 
 // src/commands/daemon.ts
 import { spawn } from "child_process";
-import fs6 from "fs";
-import path6 from "path";
+import fs7 from "fs";
+import path7 from "path";
 function getPidPath() {
-  return path6.join(getConfigDir(), "canonry.pid");
+  return path7.join(getConfigDir(), "canonry.pid");
 }
 function isProcessAlive(pid) {
   try {
@@ -7018,8 +7454,8 @@ async function waitForReady(host, port, maxMs = 1e4) {
 async function startDaemon(opts) {
   const pidPath = getPidPath();
   const format = opts.format ?? "text";
-  if (fs6.existsSync(pidPath)) {
-    const existingPid = parseInt(fs6.readFileSync(pidPath, "utf-8").trim(), 10);
+  if (fs7.existsSync(pidPath)) {
+    const existingPid = parseInt(fs7.readFileSync(pidPath, "utf-8").trim(), 10);
     if (!isNaN(existingPid) && isProcessAlive(existingPid)) {
       throw new CliError({
         code: "DAEMON_ALREADY_RUNNING",
@@ -7030,9 +7466,9 @@ async function startDaemon(opts) {
         }
       });
     }
-    fs6.unlinkSync(pidPath);
+    fs7.unlinkSync(pidPath);
   }
-  const cliPath = path6.resolve(new URL(import.meta.url).pathname);
+  const cliPath = path7.resolve(new URL(import.meta.url).pathname);
   const inSourceMode = new URL(import.meta.url).pathname.endsWith(".ts");
   const args = inSourceMode ? ["--import", "tsx", cliPath, "serve"] : [cliPath, "serve"];
   if (opts.port) args.push("--port", opts.port);
@@ -7051,10 +7487,10 @@ async function startDaemon(opts) {
     });
   }
   const configDir = getConfigDir();
-  if (!fs6.existsSync(configDir)) {
-    fs6.mkdirSync(configDir, { recursive: true });
+  if (!fs7.existsSync(configDir)) {
+    fs7.mkdirSync(configDir, { recursive: true });
   }
-  fs6.writeFileSync(pidPath, String(child.pid), "utf-8");
+  fs7.writeFileSync(pidPath, String(child.pid), "utf-8");
   const port = opts.port ?? "4100";
   const host = opts.host ?? "127.0.0.1";
   if (format !== "json") {
@@ -7063,7 +7499,7 @@ async function startDaemon(opts) {
   const ready = await waitForReady(host, port);
   if (!ready) {
     try {
-      fs6.unlinkSync(pidPath);
+      fs7.unlinkSync(pidPath);
     } catch {
     }
     throw new CliError({
@@ -7095,7 +7531,7 @@ async function startDaemon(opts) {
 }
 function stopDaemon(format = "text") {
   const pidPath = getPidPath();
-  if (!fs6.existsSync(pidPath)) {
+  if (!fs7.existsSync(pidPath)) {
     if (format === "json") {
       console.log(JSON.stringify({
         stopped: false,
@@ -7106,7 +7542,7 @@ function stopDaemon(format = "text") {
     console.log("Canonry is not running (no PID file found)");
     return;
   }
-  const pid = parseInt(fs6.readFileSync(pidPath, "utf-8").trim(), 10);
+  const pid = parseInt(fs7.readFileSync(pidPath, "utf-8").trim(), 10);
   if (isNaN(pid)) {
     if (format === "json") {
       console.log(JSON.stringify({
@@ -7117,7 +7553,7 @@ function stopDaemon(format = "text") {
     } else {
       console.error("Invalid PID file. Removing it.");
     }
-    fs6.unlinkSync(pidPath);
+    fs7.unlinkSync(pidPath);
     return;
   }
   if (!isProcessAlive(pid)) {
@@ -7131,12 +7567,12 @@ function stopDaemon(format = "text") {
     } else {
       console.log(`Canonry is not running (stale PID: ${pid}). Cleaning up.`);
     }
-    fs6.unlinkSync(pidPath);
+    fs7.unlinkSync(pidPath);
     return;
   }
   try {
     process.kill(pid, "SIGTERM");
-    fs6.unlinkSync(pidPath);
+    fs7.unlinkSync(pidPath);
     if (format === "json") {
       console.log(JSON.stringify({
         stopped: true,
@@ -7160,9 +7596,9 @@ function stopDaemon(format = "text") {
 
 // src/commands/init.ts
 import crypto2 from "crypto";
-import fs7 from "fs";
+import fs8 from "fs";
 import readline from "readline";
-import path7 from "path";
+import path8 from "path";
 function prompt(question) {
   const rl = readline.createInterface({
     input: process.stdin,
@@ -7180,6 +7616,12 @@ var DEFAULT_QUOTA = {
   maxRequestsPerMinute: 10,
   maxRequestsPerDay: 500
 };
+var PROJECT_MARKERS = [".git", "canonry.yaml", "canonry.yml", "package.json"];
+function cwdLooksLikeProject(dir) {
+  const home = process.env.HOME ?? "";
+  if (home && path8.resolve(dir) === path8.resolve(home)) return false;
+  return PROJECT_MARKERS.some((marker) => fs8.existsSync(path8.join(dir, marker)));
+}
 var DEFAULT_AGENT_MODELS = {
   anthropic: "anthropic/claude-sonnet-4-6",
   openai: "openai/gpt-4o",
@@ -7208,8 +7650,8 @@ async function initCommand(opts) {
     return void 0;
   }
   const configDir = getConfigDir();
-  if (!fs7.existsSync(configDir)) {
-    fs7.mkdirSync(configDir, { recursive: true });
+  if (!fs8.existsSync(configDir)) {
+    fs8.mkdirSync(configDir, { recursive: true });
   }
   const bootstrapEnv = getBootstrapEnv(process.env, {
     GEMINI_API_KEY: opts?.geminiKey,
@@ -7324,7 +7766,7 @@ async function initCommand(opts) {
   const rawApiKey = `cnry_${crypto2.randomBytes(16).toString("hex")}`;
   const keyHash = crypto2.createHash("sha256").update(rawApiKey).digest("hex");
   const keyPrefix = rawApiKey.slice(0, 9);
-  const databasePath = path7.join(configDir, "data.db");
+  const databasePath = path8.join(configDir, "data.db");
   const db = createClient(databasePath);
   migrate(db);
   db.insert(apiKeys).values({
@@ -7343,6 +7785,20 @@ async function initCommand(opts) {
     google
   });
   const providerNames = Object.keys(providers);
+  let skillsSummary;
+  let skillsTip;
+  if (!opts?.skipSkills) {
+    const skillsTarget = opts?.skillsDir ?? process.cwd();
+    if (cwdLooksLikeProject(skillsTarget)) {
+      try {
+        skillsSummary = await installSkills({ dir: skillsTarget });
+      } catch (err) {
+        skillsTip = `Skills auto-install failed: ${err instanceof Error ? err.message : String(err)}. Run "canonry skills install" manually.`;
+      }
+    } else {
+      skillsTip = 'Run "canonry skills install" in a project directory to add the canonry + Aero playbook to .claude/skills/ and .codex/skills/.';
+    }
+  }
   if (format === "json") {
     console.log(JSON.stringify({
       initialized: true,
@@ -7351,7 +7807,9 @@ async function initCommand(opts) {
       apiUrl: `http://localhost:${process.env.CANONRY_PORT || "4100"}`,
       apiKey: rawApiKey,
       providers: providerNames,
-      googleConfigured: !!google
+      googleConfigured: !!google,
+      skills: skillsSummary,
+      skillsTip
     }, null, 2));
   } else {
     console.log(`
@@ -7359,6 +7817,13 @@ Config saved to ${getConfigPath()}`);
     console.log(`Database created at ${databasePath}`);
     console.log(`API key: ${rawApiKey}`);
     console.log(`Providers: ${providerNames.join(", ")}`);
+    if (skillsSummary) {
+      console.log(`
+${skillsSummary.message}`);
+      console.log(`Skills target: ${skillsSummary.targetDir}`);
+    }
+    if (skillsTip) console.log(`
+${skillsTip}`);
   }
   let agentLLM;
   const agentProvider = opts?.agentProvider;
@@ -7623,7 +8088,7 @@ function applyServerEnv(values) {
 var SYSTEM_CLI_COMMANDS = [
   {
     path: ["init"],
-    usage: "canonry init [--force] [--gemini-key <key>] [--openai-key <key>] [--claude-key <key>] [--perplexity-key <key>] [--local-url <url>] [--local-model <name>] [--local-key <key>] [--google-client-id <id>] [--google-client-secret <key>] [--format json]",
+    usage: "canonry init [--force] [--gemini-key <key>] [--openai-key <key>] [--claude-key <key>] [--perplexity-key <key>] [--local-url <url>] [--local-model <name>] [--local-key <key>] [--google-client-id <id>] [--google-client-secret <key>] [--skip-skills] [--skills-dir <path>] [--format json]",
     options: {
       force: { type: "boolean", short: "f", default: false },
       "gemini-key": stringOption(),
@@ -7634,7 +8099,9 @@ var SYSTEM_CLI_COMMANDS = [
       "local-model": stringOption(),
       "local-key": stringOption(),
       "google-client-id": stringOption(),
-      "google-client-secret": stringOption()
+      "google-client-secret": stringOption(),
+      "skip-skills": { type: "boolean" },
+      "skills-dir": stringOption()
     },
     allowPositionals: false,
     run: async (input) => {
@@ -7649,6 +8116,8 @@ var SYSTEM_CLI_COMMANDS = [
         localKey: getString(input.values, "local-key"),
         googleClientId: getString(input.values, "google-client-id"),
         googleClientSecret: getString(input.values, "google-client-secret"),
+        skipSkills: getBoolean(input.values, "skip-skills"),
+        skillsDir: getString(input.values, "skills-dir"),
         format: input.format
       });
     }
@@ -7745,7 +8214,7 @@ var SYSTEM_CLI_COMMANDS = [
 ];
 
 // src/cli-commands/wordpress.ts
-import fs8 from "fs";
+import fs9 from "fs";
 
 // src/commands/wordpress.ts
 function getClient18() {
@@ -7981,12 +8450,12 @@ async function wordpressSetMeta(project, body) {
   printPageDetail(result);
 }
 async function wordpressBulkSetMeta(project, opts) {
-  const fs9 = await import("fs/promises");
-  const path8 = await import("path");
-  const filePath = path8.resolve(opts.from);
+  const fs10 = await import("fs/promises");
+  const path9 = await import("path");
+  const filePath = path9.resolve(opts.from);
   let raw;
   try {
-    raw = await fs9.readFile(filePath, "utf8");
+    raw = await fs10.readFile(filePath, "utf8");
   } catch {
     throw new CliError({
       code: "FILE_READ_ERROR",
@@ -8083,13 +8552,13 @@ async function wordpressSetSchema(project, body) {
   printManualAssist(`Schema update for "${body.slug}"`, result);
 }
 async function wordpressSchemaDeploy(project, opts) {
-  const fs9 = await import("fs/promises");
-  const path8 = await import("path");
+  const fs10 = await import("fs/promises");
+  const path9 = await import("path");
   const yaml = await import("yaml").catch(() => null);
-  const filePath = path8.resolve(opts.profile);
+  const filePath = path9.resolve(opts.profile);
   let raw;
   try {
-    raw = await fs9.readFile(filePath, "utf8");
+    raw = await fs10.readFile(filePath, "utf8");
   } catch {
     throw new CliError({
       code: "FILE_READ_ERROR",
@@ -8194,13 +8663,13 @@ async function wordpressOnboard(project, opts) {
   }
   let profileData;
   if (opts.profile) {
-    const fs9 = await import("fs/promises");
-    const path8 = await import("path");
+    const fs10 = await import("fs/promises");
+    const path9 = await import("path");
     const yaml = await import("yaml").catch(() => null);
-    const filePath = path8.resolve(opts.profile);
+    const filePath = path9.resolve(opts.profile);
     let raw;
     try {
-      raw = await fs9.readFile(filePath, "utf8");
+      raw = await fs10.readFile(filePath, "utf8");
     } catch {
       throw new CliError({
         code: "FILE_READ_ERROR",
@@ -8349,7 +8818,7 @@ function resolveContent(input, command, usage, options) {
   }
   if (contentFile) {
     try {
-      return fs8.readFileSync(contentFile, "utf-8");
+      return fs9.readFileSync(contentFile, "utf-8");
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       throw usageError(`Error: could not read --content-file "${contentFile}": ${message}`, {
@@ -9283,6 +9752,7 @@ var REGISTERED_CLI_COMMANDS = [
   ...KEYWORD_CLI_COMMANDS,
   ...COMPETITOR_CLI_COMMANDS,
   ...SETTINGS_CLI_COMMANDS,
+  ...SKILLS_CLI_COMMANDS,
   ...SNAPSHOT_CLI_COMMANDS,
   ...RUN_CLI_COMMANDS,
   ...OPERATOR_CLI_COMMANDS,
@@ -9312,6 +9782,7 @@ Setup:
   bootstrap             Bootstrap config/database from env vars
   serve                 Start the local server (foreground)
   start / stop          Start/stop as a background daemon
+  skills                List or install bundled agent skills (claude/codex)
 
 Projects:
   project               Create, update, list, show, delete projects