geo-ai-search-optimization 1.2.5 → 1.2.7

package/README.md

@@ -24,6 +24,42 @@ npx geo-ai-search-optimization
 - installs the bundled GEO skills into your Codex skills directory
 - ships a local resource folder with `SKILL.md`, references, and a scanner script
 - provides a CLI for installing, locating, and scanning projects for GEO signals
+- now exposes the bundled skill package directly, so agents can discover which GEO sub-skill to use next
+
+## Skills 命令
+
+如果你想先看这个 npm 包里到底打包了哪些 skills，现在可以直接用：
+
+```bash
+geo-ai-search-optimization skills
+geo-ai-search-optimization skills --json
+```
+
+它会列出：
+
+- 核心 GEO skill
+- usage / onboarding skill
+- agent 执行闭环相关 skills
+- 分享 / 导出 / 最终交付相关 skills
+
+## Auto Flow 命令
+
+如果你希望 agent 不用自己判断现在该用哪个 skill、该跑哪个命令，可以直接用 `auto-flow`：
+
+```bash
+geo-ai-search-optimization auto-flow "我想把这份 GEO 结果交给下一个 agent 继续修"
+geo-ai-search-optimization auto-flow https://example.com
+geo-ai-search-optimization auto-flow ./your-site
+geo-ai-search-optimization auto-flow ./reports/apply-plan.json --json
+```
+
+它会自动输出：
+
+- 当前输入属于哪一类
+- 现在更像诊断、执行、复盘还是交付阶段
+- 最适合的下一个 skill
+- 建议命令顺序
+- 可直接复制给 agent 的 prompt
 
 ## Quick Start
 
@@ -418,6 +454,8 @@ geo-ai-search-optimization onboard --url https://example.com --json --out ./repo
 geo-ai-search-optimization
 geo-ai-search-optimization install
 geo-ai-search-optimization install --target ./tmp/custom-skills --json
+geo-ai-search-optimization auto-flow "audit this site and tell me the next skill"
+geo-ai-search-optimization skills
 geo-ai-search-optimization where
 geo-ai-search-optimization doctor
 geo-ai-search-optimization quick-start
@@ -452,6 +490,20 @@ geo-ai-search-optimization version
 geo-ai-search-optimization help
 ```
 
+## New in 1.2.6
+
+- 新增 `skills` 命令，直接列出整套 GEO 技能包
+- 安装后会额外写入 `.skill-bundle.json`，方便 agent 自动发现技能
+- 为缺失的 skill 补齐 `agents/openai.yaml`
+- 主 skill 新增 `skill-bundle-map` 参考，usage skill 也同步纳入 `publish-pack` 和 `skills`
+
+## New in 1.2.7
+
+- 新增 `auto-flow` 命令，自动选择下一步该用哪个 GEO skill
+- 支持任务描述、网站网址、本地项目目录和 JSON 工件作为输入
+- 输出推荐 skill、命令顺序与可直接复制给 agent 的 prompt
+- 新增 `geo-ai-search-optimization-auto-flow` skill，作为 agent 的自动路由入口
+
 ## New in 1.2.5
 
 - 新增 `publish-pack`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "geo-ai-search-optimization",
-  "version": "1.2.5",
+  "version": "1.2.7",
   "description": "Install and run a Generative Engine Optimization (GEO)-first, SEO-supported Codex skill for website optimization.",
   "type": "module",
   "bin": {

package/resources/geo-ai-search-optimization/SKILL.md

@@ -163,3 +163,4 @@ When the user asks for the latest vendor behavior or policy:
 - `references/quick-start.md`: from-0-to-1 startup sequence for using the CLI and the skill together
 - `references/geo-playbook.md`: content patterns and GEO-first page design heuristics
 - `references/implementation-checklist.md`: technical, content, and measurement checklist
+- `references/skill-bundle-map.md`: bundled GEO sub-skills and when to use each one

package/resources/geo-ai-search-optimization/references/skill-bundle-map.md

@@ -0,0 +1,94 @@
+# GEO Skill Bundle Map
+
+## Table of Contents
+
+- Core skill
+- Auto entry
+- Usage guide
+- Agent execution loop
+- Delivery chain
+
+## Core skill
+
+### `geo-ai-search-optimization`
+
+Use this first when the task is still about diagnosing or improving GEO readiness itself.
+
+Best for:
+
+- auditing a website or codebase
+- improving answerability, structure, and citation readiness
+- deciding what the highest-impact GEO fixes are
+
+## Auto entry
+
+### `geo-ai-search-optimization-auto-flow`
+
+Use this when the next agent needs a routing entrypoint and should not have to decide manually which skill to use.
+
+Best for:
+
+- selecting the next skill from a URL, directory, or artifact
+- turning one-line task briefs into a concrete command sequence
+- deciding whether the work should move into diagnosis, execution, closeout, or delivery
+
+## Usage guide
+
+### `geo-ai-search-optimization-usage`
+
+Use this when the next agent or user does not know which command or skill to use next.
+
+Best for:
+
+- onboarding new users
+- explaining command order
+- translating a GEO request into concrete CLI steps
+
+## Agent execution loop
+
+Use these when the work is moving from analysis into action.
+
+### `geo-ai-search-optimization-agent-handoff`
+
+Turn GEO findings into a package that another agent can continue from.
+
+### `geo-ai-search-optimization-repair-loop`
+
+Continue from `apply-plan` style execution tasks and close the loop on actual fixes.
+
+### `geo-ai-search-optimization-completion-report`
+
+Summarize what finished, what still blocks progress, and what should happen next.
+
+### `geo-ai-search-optimization-handoff-bundle`
+
+Use when one artifact needs to contain handoff, execution, and closeout together.
+
+## Delivery chain
+
+Use these when the output needs to be shared, exported, or handed off to humans and agents.
+
+### `geo-ai-search-optimization-share-pack`
+
+Prepare role-specific views for PM, engineering, management, and the next agent.
+
+### `geo-ai-search-optimization-export-pack`
+
+Generate a disk folder with ready-to-send markdown or JSON deliverables.
+
+### `geo-ai-search-optimization-html-pack`
+
+Generate browsable HTML pages for quick sharing.
+
+### `geo-ai-search-optimization-publish-pack`
+
+Generate the final delivery folder that combines:
+
+- `site/` HTML pages
+- `documents/` markdown files
+- `data/` JSON artifacts
+- `START-HERE.md`
+- `AGENT-START.md`
+- `manifest.json`
+
+This is the best choice when the output should be directly handed to a PM, a stakeholder group, or another agent without further manual packaging.

package/resources/geo-ai-search-optimization-auto-flow/SKILL.md

@@ -0,0 +1,23 @@
+---
+name: geo-ai-search-optimization-auto-flow
+description: Automatically choose the next GEO skill and command chain from a task description, website URL, local project directory, or existing GEO artifact. Use when an agent needs a routing entrypoint to decide which GEO skill to invoke next and what commands should follow.
+---
+
+# GEO Auto Flow
+
+Use this skill when the next agent should not have to guess which GEO skill to use.
+
+`GEO = Generative Engine Optimization`
+
+## What it does
+
+- identify whether the input is a task brief, URL, project directory, or GEO artifact
+- route to the most suitable next GEO skill
+- recommend the next commands
+- generate a copyable agent prompt
+
+## Best use
+
+- start a new agent session from one line of user input
+- continue from an existing GEO artifact without re-reading the whole system
+- decide whether the next move is diagnosis, execution, closeout, or delivery

package/resources/geo-ai-search-optimization-auto-flow/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "GEO Auto Flow"
+  short_description: "Auto-select the next GEO skill and command chain"
+  default_prompt: "Use $geo-ai-search-optimization-auto-flow to choose the next GEO skill, explain why, and recommend the next commands for this input."

package/resources/geo-ai-search-optimization-export-pack/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "GEO Export Pack"
+  short_description: "Export GEO deliverables into a shareable folder"
+  default_prompt: "Use $geo-ai-search-optimization-export-pack to generate a folder of GEO deliverables for PM, engineering, management, and agent handoff."

package/resources/geo-ai-search-optimization-handoff-bundle/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "GEO Handoff Bundle"
+  short_description: "Continue from one bundled GEO execution artifact"
+  default_prompt: "Use $geo-ai-search-optimization-handoff-bundle to continue from this combined GEO handoff, execution, and closeout artifact."

package/resources/geo-ai-search-optimization-html-pack/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "GEO HTML Pack"
+  short_description: "Generate browsable HTML pages from GEO outputs"
+  default_prompt: "Use $geo-ai-search-optimization-html-pack to convert these GEO deliverables into browsable HTML pages for sharing."

package/resources/geo-ai-search-optimization-share-pack/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "GEO Share Pack"
+  short_description: "Prepare audience-specific GEO views for sharing"
+  default_prompt: "Use $geo-ai-search-optimization-share-pack to turn this GEO result into role-specific views for PM, engineering, management, and the next agent."

package/resources/geo-ai-search-optimization-usage/SKILL.md

@@ -13,26 +13,29 @@ Treat this tool as a PM-friendly GEO workflow for websites.
 
 `GEO = Generative Engine Optimization`
 
-The package is best explained as twelve layers:
-
-1. `onboard-url` / `onboard`: first look
-2. `scan`: raw signal check
-3. `audit` / `report`: diagnosis
-4. `fix-plan` / `owner-board`: execution planning
-5. `agent-handoff`: agent takeover package
-6. `apply-plan`: execution loop
-7. `completion-report`: closeout
-8. `handoff-bundle`: all-in-one package
-9. `share-pack`: audience-ready delivery
-10. `export-pack`: folder export
-11. `html-pack`: browsable output
-12. `pm-brief` / `roadmap`: stakeholder alignment
+The package is best explained as fourteen layers:
+
+1. `auto-flow`: auto-select the next skill and command chain
+2. `skills`: inspect the bundled skill package
+3. `onboard-url` / `onboard`: first look
+4. `scan`: raw signal check
+5. `audit` / `report`: diagnosis
+6. `fix-plan` / `owner-board`: execution planning
+7. `agent-handoff`: agent takeover package
+8. `apply-plan`: execution loop
+9. `completion-report`: closeout
+10. `handoff-bundle`: all-in-one package
+11. `share-pack`: audience-ready delivery
+12. `export-pack`: folder export
+13. `html-pack` / `publish-pack`: browsable and final delivery output
+14. `pm-brief` / `roadmap`: stakeholder alignment
 
 ## Recommended command order
 
 If the user only has a website URL:
 
 ```bash
+npx geo-ai-search-optimization auto-flow https://example.com
 npx geo-ai-search-optimization onboard-url https://example.com
 npx geo-ai-search-optimization pm-brief https://example.com
 npx geo-ai-search-optimization roadmap https://example.com
@@ -41,6 +44,7 @@ npx geo-ai-search-optimization roadmap https://example.com
 If the user has the website codebase:
 
 ```bash
+npx geo-ai-search-optimization auto-flow ./your-site
 npx geo-ai-search-optimization scan ./your-site
 npx geo-ai-search-optimization audit ./your-site
 npx geo-ai-search-optimization fix-plan ./your-site
@@ -51,14 +55,17 @@ npx geo-ai-search-optimization handoff-bundle ./your-site
 npx geo-ai-search-optimization share-pack ./your-site
 npx geo-ai-search-optimization export-pack ./your-site
 npx geo-ai-search-optimization html-pack ./your-site
+npx geo-ai-search-optimization publish-pack ./your-site
 npx geo-ai-search-optimization owner-board ./your-site
 npx geo-ai-search-optimization roadmap ./your-site
 ```
 
 ## When to recommend each command
 
+- `auto-flow`: auto-select the next skill and command order from a task brief, URL, project path, or GEO artifact
 - `onboard-url`: first-time website check from a live URL
 - `onboard`: interactive first-time onboarding
+- `skills`: list the bundled skills and decide which skill or command chain fits the task
 - `scan`: check raw technical signals across files
 - `audit`: get GEO score, issue areas, blockers, and PM action list
 - `report`: export audit/onboarding/scan into readable files
@@ -70,6 +77,7 @@ npx geo-ai-search-optimization roadmap ./your-site
 - `share-pack`: prepare role-specific shareable outputs for PM, engineering, management, and agents
 - `export-pack`: generate a folder with multiple ready-to-send files
 - `html-pack`: generate static HTML pages for sharing and browsing
+- `publish-pack`: generate the final delivery folder for humans and agents together
 - `owner-board`: group tasks by PM / engineering / SEO / content
 - `pm-brief`: prepare a PM summary for meetings and prioritization
 - `roadmap`: turn tasks into a 2-week / 4-week execution sequence
@@ -79,6 +87,7 @@ npx geo-ai-search-optimization roadmap ./your-site
 When explaining the tool to a user:
 
 - prefer telling them which command to run next, not listing every command
+- if the user or the next agent is unsure where to start, move them to `auto-flow` first
 - explain the result in PM language, not implementation jargon
 - if the user sounds new, start with `onboard-url` or `quick-start`
 - if the user wants another agent to take over, move them to `agent-handoff`
@@ -88,6 +97,7 @@ When explaining the tool to a user:
 - if the user wants something ready to forward to multiple audiences, move them to `share-pack`
 - if the user wants actual files on disk for each audience, move them to `export-pack`
 - if the user wants browsable HTML pages, move them to `html-pack`
+- if the user wants one final package with HTML, markdown, JSON, and an agent entrypoint, move them to `publish-pack`
 - if the user already has a report, move them to `fix-plan`, `owner-board`, or `roadmap`
 
 Read [references/usage-patterns.md](references/usage-patterns.md) when you need response patterns and command selection examples.

package/src/auto-flow.js

@@ -0,0 +1,563 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { writeScanOutput } from "./scan.js";
+import { listBundledSkills } from "./skills.js";
+
+const VALID_INTENTS = new Set(["auto", "diagnose", "guide", "execute", "share", "closeout"]);
+
+function isUrlInput(input) {
+  return /^https?:\/\//i.test(input);
+}
+
+function normalizeIntent(intent) {
+  const resolved = (intent || "auto").toLowerCase();
+  if (!VALID_INTENTS.has(resolved)) {
+    throw new Error(`不支持的 auto-flow intent：${intent}。可选值：${Array.from(VALID_INTENTS).join(", ")}`);
+  }
+  return resolved;
+}
+
+async function pathExists(targetPath) {
+  try {
+    await fs.access(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function detectArtifactKindFromParsedJson(parsed) {
+  if (!parsed || typeof parsed !== "object") {
+    return "unknown-json";
+  }
+
+  if (parsed.kind === "geo-report") {
+    return `geo-report:${parsed.mode || "unknown"}`;
+  }
+
+  return parsed.kind || "unknown-json";
+}
+
+function inferTaskTextMode(text) {
+  const normalized = String(text).toLowerCase();
+
+  if (/(share-pack|export-pack|html-pack|publish-pack|分享|导出|交付|外发|报告包)/i.test(normalized)) {
+    return "share";
+  }
+  if (/(apply-plan|handoff|接手|交给.*agent|继续修|继续做|修复|执行|修改|落地|repair|implement|fix)/i.test(normalized)) {
+    return "execute";
+  }
+  if (/(completion-report|closeout|复盘|收尾|总结|剩余风险)/i.test(normalized)) {
+    return "closeout";
+  }
+  if (/(how to use|怎么用|如何用|命令|skill|技能|流程|next step|下一步)/i.test(normalized)) {
+    return "guide";
+  }
+  return "diagnose";
+}
+
+async function detectInput(input) {
+  if (!input) {
+    throw new Error("auto-flow 需要一个输入值，可以是任务描述、项目路径、网站网址或已导出的工件。");
+  }
+
+  if (isUrlInput(input)) {
+    return {
+      source: input,
+      sourceType: "url",
+      artifactKind: "website-url",
+      summary: "公开网站网址"
+    };
+  }
+
+  const resolvedPath = path.resolve(input);
+  if (!(await pathExists(resolvedPath))) {
+    return {
+      source: input,
+      sourceType: "task-text",
+      artifactKind: "task-brief",
+      summary: "自然语言任务描述",
+      inferredTextIntent: inferTaskTextMode(input)
+    };
+  }
+
+  const stat = await fs.stat(resolvedPath);
+  if (stat.isDirectory()) {
+    return {
+      source: resolvedPath,
+      sourceType: "directory",
+      artifactKind: "project-directory",
+      summary: "本地网站项目目录"
+    };
+  }
+
+  const extension = path.extname(resolvedPath).toLowerCase();
+  if (extension === ".json") {
+    const raw = await fs.readFile(resolvedPath, "utf8");
+    const parsed = JSON.parse(raw);
+    return {
+      source: resolvedPath,
+      sourceType: "json",
+      artifactKind: detectArtifactKindFromParsedJson(parsed),
+      summary: "GEO JSON 工件",
+      parsed
+    };
+  }
+
+  const fileName = path.basename(resolvedPath);
+  let artifactKind = "generic-file";
+  if (fileName === "START-HERE.md" || fileName === "AGENT-START.md" || fileName === "manifest.json") {
+    artifactKind = "geo-publish-pack-entry";
+  } else if (/share-pack/i.test(fileName)) {
+    artifactKind = "geo-share-pack-file";
+  } else if (/owner-board/i.test(fileName)) {
+    artifactKind = "geo-owner-board-file";
+  }
+
+  return {
+    source: resolvedPath,
+    sourceType: "file",
+    artifactKind,
+    summary: "本地文件工件"
+  };
+}
+
+function resolveEffectiveIntent(intent, detected) {
+  if (intent !== "auto") {
+    return intent;
+  }
+
+  if (detected.sourceType === "task-text") {
+    return detected.inferredTextIntent || "diagnose";
+  }
+
+  if (detected.artifactKind === "geo-completion-report") {
+    return "closeout";
+  }
+  if (
+    [
+      "geo-share-pack",
+      "geo-export-pack",
+      "geo-html-pack",
+      "geo-publish-pack",
+      "geo-publish-pack-entry",
+      "geo-share-pack-file"
+    ].includes(detected.artifactKind)
+  ) {
+    return "share";
+  }
+  if (
+    ["geo-agent-handoff", "geo-apply-plan", "geo-handoff-bundle", "geo-fix-plan"].includes(detected.artifactKind)
+  ) {
+    return "execute";
+  }
+  if (detected.artifactKind === "task-brief") {
+    return detected.inferredTextIntent || "diagnose";
+  }
+  return "diagnose";
+}
+
+function buildCommandChain(detected, intent) {
+  const source = detected.source;
+
+  if (detected.sourceType === "task-text") {
+    return [`geo-ai-search-optimization skills`, `geo-ai-search-optimization quick-start`];
+  }
+
+  if (intent === "guide") {
+    return [`geo-ai-search-optimization skills`, `geo-ai-search-optimization quick-start`, `geo-ai-search-optimization auto-flow ${source}`];
+  }
+
+  if (intent === "share") {
+    if (detected.artifactKind === "geo-completion-report") {
+      return [
+        `geo-ai-search-optimization share-pack ${source}`,
+        `geo-ai-search-optimization export-pack ${source}`,
+        `geo-ai-search-optimization publish-pack ${source}`
+      ];
+    }
+
+    return [
+      `geo-ai-search-optimization share-pack ${source}`,
+      `geo-ai-search-optimization html-pack ${source}`,
+      `geo-ai-search-optimization publish-pack ${source}`
+    ];
+  }
+
+  if (intent === "closeout") {
+    return [
+      `geo-ai-search-optimization completion-report ${source}`,
+      `geo-ai-search-optimization meeting-pack ${source}`,
+      `geo-ai-search-optimization publish-pack ${source}`
+    ];
+  }
+
+  if (detected.sourceType === "url") {
+    if (intent === "execute") {
+      return [
+        `geo-ai-search-optimization onboard-url ${source}`,
+        `geo-ai-search-optimization fix-plan ${source}`,
+        `geo-ai-search-optimization agent-handoff ${source}`
+      ];
+    }
+    return [
+      `geo-ai-search-optimization onboard-url ${source}`,
+      `geo-ai-search-optimization pm-brief ${source}`,
+      `geo-ai-search-optimization report ${source} --mode onboarding --format markdown`
+    ];
+  }
+
+  if (detected.sourceType === "directory") {
+    if (intent === "execute") {
+      return [
+        `geo-ai-search-optimization audit ${source}`,
+        `geo-ai-search-optimization fix-plan ${source}`,
+        `geo-ai-search-optimization agent-handoff ${source}`,
+        `geo-ai-search-optimization apply-plan ${source}`
+      ];
+    }
+    return [
+      `geo-ai-search-optimization scan ${source}`,
+      `geo-ai-search-optimization audit ${source}`,
+      `geo-ai-search-optimization fix-plan ${source}`
+    ];
+  }
+
+  switch (detected.artifactKind) {
+    case "geo-report:audit":
+    case "geo-audit":
+      return intent === "execute"
+        ? [
+            `geo-ai-search-optimization fix-plan ${source}`,
+            `geo-ai-search-optimization agent-handoff ${source}`,
+            `geo-ai-search-optimization apply-plan ${source}`
+          ]
+        : [`geo-ai-search-optimization fix-plan ${source}`, `geo-ai-search-optimization owner-board ${source}`];
+    case "geo-url-onboarding":
+    case "geo-report:onboarding":
+      return [
+        `geo-ai-search-optimization pm-brief ${source}`,
+        `geo-ai-search-optimization fix-plan ${source}`,
+        `geo-ai-search-optimization roadmap ${source}`
+      ];
+    case "geo-fix-plan":
+      return [
+        `geo-ai-search-optimization agent-handoff ${source}`,
+        `geo-ai-search-optimization apply-plan ${source}`
+      ];
+    case "geo-agent-handoff":
+      return [
+        `geo-ai-search-optimization apply-plan ${source}`,
+        `geo-ai-search-optimization completion-report ${source}`
+      ];
+    case "geo-apply-plan":
+      return [
+        `geo-ai-search-optimization apply-plan ${source}`,
+        `geo-ai-search-optimization completion-report ${source}`,
+        `geo-ai-search-optimization handoff-bundle ${source}`
+      ];
+    case "geo-completion-report":
+      return [
+        `geo-ai-search-optimization meeting-pack ${source}`,
+        `geo-ai-search-optimization share-pack ${source}`,
+        `geo-ai-search-optimization publish-pack ${source}`
+      ];
+    case "geo-handoff-bundle":
+      return [
+        `geo-ai-search-optimization apply-plan ${source}`,
+        `geo-ai-search-optimization completion-report ${source}`,
+        `geo-ai-search-optimization publish-pack ${source}`
+      ];
+    case "geo-share-pack":
+    case "geo-share-pack-file":
+      return [
+        `geo-ai-search-optimization export-pack ${source}`,
+        `geo-ai-search-optimization html-pack ${source}`,
+        `geo-ai-search-optimization publish-pack ${source}`
+      ];
+    case "geo-export-pack":
+      return [`geo-ai-search-optimization html-pack ${source}`, `geo-ai-search-optimization publish-pack ${source}`];
+    case "geo-html-pack":
+      return [`geo-ai-search-optimization publish-pack ${source}`];
+    case "geo-publish-pack":
+    case "geo-publish-pack-entry":
+      return [`geo-ai-search-optimization auto-flow ${source} --intent guide`, `geo-ai-search-optimization skills`];
+    default:
+      return [`geo-ai-search-optimization skills`, `geo-ai-search-optimization quick-start`];
+  }
+}
+
+function pickSkillName(detected, intent) {
+  if (intent === "guide") {
+    return "geo-ai-search-optimization-usage";
+  }
+  if (intent === "share") {
+    return "geo-ai-search-optimization-publish-pack";
+  }
+  if (intent === "closeout") {
+    return "geo-ai-search-optimization-completion-report";
+  }
+
+  switch (detected.artifactKind) {
+    case "task-brief":
+      return detected.inferredTextIntent === "share"
+        ? "geo-ai-search-optimization-publish-pack"
+        : detected.inferredTextIntent === "execute"
+          ? "geo-ai-search-optimization-agent-handoff"
+          : "geo-ai-search-optimization-usage";
+    case "website-url":
+    case "project-directory":
+    case "geo-audit":
+    case "geo-report:audit":
+    case "geo-url-onboarding":
+    case "geo-report:onboarding":
+      return intent === "execute" ? "geo-ai-search-optimization-agent-handoff" : "geo-ai-search-optimization";
+    case "geo-fix-plan":
+    case "geo-agent-handoff":
+      return "geo-ai-search-optimization-agent-handoff";
+    case "geo-apply-plan":
+      return "geo-ai-search-optimization-repair-loop";
+    case "geo-completion-report":
+      return "geo-ai-search-optimization-completion-report";
+    case "geo-handoff-bundle":
+      return "geo-ai-search-optimization-handoff-bundle";
+    case "geo-share-pack":
+    case "geo-share-pack-file":
+      return "geo-ai-search-optimization-share-pack";
+    case "geo-export-pack":
+      return "geo-ai-search-optimization-export-pack";
+    case "geo-html-pack":
+      return "geo-ai-search-optimization-html-pack";
+    case "geo-publish-pack":
+    case "geo-publish-pack-entry":
+      return "geo-ai-search-optimization-publish-pack";
+    default:
+      return "geo-ai-search-optimization-usage";
+  }
+}
+
+function buildSecondarySkillNames(primarySkill, intent, detected) {
+  const names = new Set(["geo-ai-search-optimization-usage"]);
+
+  if (primarySkill !== "geo-ai-search-optimization") {
+    names.add("geo-ai-search-optimization");
+  }
+  if (intent === "share") {
+    names.add("geo-ai-search-optimization-share-pack");
+    names.add("geo-ai-search-optimization-publish-pack");
+  }
+  if (intent === "execute" || ["geo-fix-plan", "geo-agent-handoff", "geo-apply-plan"].includes(detected.artifactKind)) {
+    names.add("geo-ai-search-optimization-agent-handoff");
+    names.add("geo-ai-search-optimization-repair-loop");
+  }
+  if (intent === "closeout") {
+    names.add("geo-ai-search-optimization-completion-report");
+  }
+
+  names.delete(primarySkill);
+  return Array.from(names);
+}
+
+function buildStage(intent, detected) {
+  if (intent === "guide") {
+    return "使用引导";
+  }
+  if (intent === "share") {
+    return "交付分享";
+  }
+  if (intent === "closeout") {
+    return "执行复盘";
+  }
+  if (intent === "execute") {
+    return ["geo-fix-plan", "geo-agent-handoff", "geo-apply-plan", "geo-handoff-bundle"].includes(detected.artifactKind)
+      ? "Agent 执行"
+      : "执行准备";
+  }
+  if (["geo-fix-plan", "geo-agent-handoff", "geo-apply-plan", "geo-handoff-bundle"].includes(detected.artifactKind)) {
+    return "Agent 执行";
+  }
+  return "诊断规划";
+}
+
+function buildWhy(detected, intent, primarySkillLabel) {
+  if (detected.sourceType === "task-text") {
+    return `当前输入是一段任务描述，还不是具体工件，所以先用 ${primarySkillLabel} 来判断阶段，并明确下一步还缺什么上下文。`;
+  }
+  if (detected.sourceType === "url") {
+    return `当前只有公开网址，没有仓库上下文，最适合先走网址级 GEO 流程，再决定是否进入 agent 执行。`;
+  }
+  if (detected.sourceType === "directory") {
+    return intent === "execute"
+      ? "当前已经有本地项目目录，可以直接进入 GEO 诊断到 agent 接手的执行链。"
+      : "当前已有本地项目目录，先跑诊断和优先级判断最稳妥。";
+  }
+  if (detected.sourceType === "json") {
+    return `当前输入已经是 GEO 工件（${detected.artifactKind}），所以可以跳过前置步骤，直接进入对应阶段。`;
+  }
+  return "当前输入更像中间结果或说明文本，先根据上下文自动选择最接近的 skill。";
+}
+
+function buildContextNeeded(detected, intent) {
+  if (detected.sourceType === "task-text") {
+    const items = ["至少补一个公开网址、本地项目路径，或已有 GEO JSON 工件。"];
+    if (intent === "execute") {
+      items.push("如果希望 agent 直接修复，最好提供代码仓库或本地项目目录。");
+    }
+    if (intent === "share") {
+      items.push("如果希望直接交付，最好提供已生成的 audit / handoff / completion 等工件。");
+    }
+    return items;
+  }
+
+  if (detected.sourceType === "url" && intent === "execute") {
+    return ["当前只有公开网址，能先做建议型执行。若要直接修复，后续仍需提供本地项目目录或仓库上下文。"];
+  }
+
+  return [];
+}
+
+function buildAgentPrompt(skill, detected, intent, commands) {
+  const lines = [
+    skill.defaultPrompt || `Use $${skill.name} to continue this GEO task.`,
+    `输入：${detected.source}`,
+    `意图：${intent}`,
+    "请先说明你为什么选择这个 skill，然后按建议命令顺序继续。"
+  ];
+
+  if (commands.length > 0) {
+    lines.push("建议命令顺序：");
+    for (const command of commands) {
+      lines.push(`- ${command}`);
+    }
+  }
+
+  return lines.join("\n");
+}
+
+function buildNextAction(detected, intent, commands) {
+  if (detected.sourceType === "task-text") {
+    if (intent === "execute") {
+      return "先补一个公开网址、本地项目目录或 GEO JSON 工件；有了具体输入后再重跑 auto-flow，才能真正进入 agent 执行链。";
+    }
+    if (intent === "share") {
+      return "先补一个 GEO 工件或项目输入，再生成可分享的交付包。";
+    }
+    if (intent === "closeout") {
+      return "先补 completion-report、apply-plan 或 handoff-bundle 这类执行工件，再进入复盘。";
+    }
+    return "先补一个公开网址、本地项目目录或 GEO 工件，让系统能自动定位到正确阶段。";
+  }
+
+  if (commands.length === 0) {
+    return "先运行 skills 查看整套技能包。";
+  }
+
+  if (intent === "share") {
+    return `先运行 \`${commands[0]}\` 生成适合外发或交接的结果。`;
+  }
+  if (intent === "execute") {
+    return `先运行 \`${commands[0]}\`，把当前输入推进到 agent 可执行状态。`;
+  }
+  if (intent === "closeout") {
+    return `先运行 \`${commands[0]}\`，整理本轮完成情况和剩余风险。`;
+  }
+  if (intent === "guide") {
+    return `先运行 \`${commands[0]}\`，确认技能包与命令顺序。`;
+  }
+  return `先运行 \`${commands[0]}\`，建立当前阶段的 GEO 基线。`;
+}
+
+export async function createAutoFlow(input, options = {}) {
+  const bundle = await listBundledSkills();
+  const detected = await detectInput(input);
+  const intent = resolveEffectiveIntent(normalizeIntent(options.intent), detected);
+  const primarySkillName = pickSkillName(detected, intent);
+  const primarySkill = bundle.skills.find((skill) => skill.name === primarySkillName);
+
+  if (!primarySkill) {
+    throw new Error(`找不到技能：${primarySkillName}`);
+  }
+
+  const secondarySkillNames = buildSecondarySkillNames(primarySkillName, intent, detected);
+  const secondarySkills = bundle.skills.filter((skill) => secondarySkillNames.includes(skill.name));
+  const commandChain = buildCommandChain(detected, intent);
+
+  return {
+    kind: "geo-auto-flow",
+    input,
+    source: detected.source,
+    sourceType: detected.sourceType,
+    artifactKind: detected.artifactKind,
+    summary: detected.summary,
+    intent,
+    stage: buildStage(intent, detected),
+    selectedSkill: {
+      name: primarySkill.name,
+      displayName: primarySkill.displayName,
+      shortDescription: primarySkill.shortDescription,
+      defaultPrompt: primarySkill.defaultPrompt,
+      skillPath: primarySkill.skillPath
+    },
+    secondarySkills: secondarySkills.map((skill) => ({
+      name: skill.name,
+      displayName: skill.displayName,
+      shortDescription: skill.shortDescription,
+      skillPath: skill.skillPath
+    })),
+    whyThisSkill: buildWhy(detected, intent, primarySkill.displayName),
+    contextNeeded: buildContextNeeded(detected, intent),
+    nextAction: buildNextAction(detected, intent, commandChain),
+    commandChain,
+    agentPrompt: buildAgentPrompt(primarySkill, detected, intent, commandChain)
+  };
+}
+
+export function renderAutoFlowMarkdown(flow) {
+  const lines = [
+    "# GEO Auto Flow",
+    "",
+    `- 输入：\`${flow.source}\``,
+    `- 输入类型：\`${flow.sourceType}\``,
+    `- 工件类型：\`${flow.artifactKind}\``,
+    `- 当前阶段：${flow.stage}`,
+    `- 当前意图：${flow.intent}`,
+    `- 自动选择的 skill：\`${flow.selectedSkill.name}\``,
+    `- 显示名：${flow.selectedSkill.displayName}`,
+    `- 说明：${flow.selectedSkill.shortDescription}`,
+    "",
+    "## 为什么是这个 skill",
+    "",
+    `- ${flow.whyThisSkill}`,
+    "",
+    "## 下一步",
+    "",
+    `- ${flow.nextAction}`,
+    "",
+    "## 建议命令顺序",
+    ""
+  ];
+
+  for (const command of flow.commandChain) {
+    lines.push(`- \`${command}\``);
+  }
+
+  if (flow.contextNeeded.length > 0) {
+    lines.push("", "## 还需要补什么", "");
+    for (const item of flow.contextNeeded) {
+      lines.push(`- ${item}`);
+    }
+  }
+
+  lines.push("", "## 可一起参考的 skill", "");
+  for (const skill of flow.secondarySkills) {
+    lines.push(`- ${skill.name}｜${skill.displayName}｜${skill.shortDescription}`);
+  }
+
+  lines.push("", "## 可直接复制给 Agent 的 Prompt", "", "```text", flow.agentPrompt, "```");
+
+  return `${lines.join("\n")}\n`;
+}
+
+export async function writeAutoFlowOutput(outputPath, content) {
+  return writeScanOutput(outputPath, content);
+}

package/src/cli.js

@@ -3,6 +3,7 @@ import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { createApplyPlan, renderApplyPlanMarkdown, writeApplyPlanOutput } from "./apply-plan.js";
 import { createAgentHandoff, renderAgentHandoffMarkdown, writeAgentHandoffOutput } from "./agent-handoff.js";
+import { createAutoFlow, renderAutoFlowMarkdown, writeAutoFlowOutput } from "./auto-flow.js";
 import {
   createCompletionReport,
   renderCompletionReportMarkdown,
@@ -33,6 +34,7 @@ import {
 import { createQuickStartPlan, renderQuickStartMarkdown, writeQuickStartOutput } from "./quick-start.js";
 import { createSchemaTemplate } from "./schema.js";
 import { createSharePack, renderSharePackMarkdown, writeSharePackOutput } from "./share-pack.js";
+import { listBundledSkills, renderBundledSkillsMarkdown } from "./skills.js";
 import { analyzeWebsiteUrl, renderWebsiteOnboardingMarkdown, writeWebsiteOnboardingOutput } from "./url-onboarding.js";
 
 let cachedVersion;
@@ -56,6 +58,8 @@ function printHelp() {
       "Usage:",
       "  geo-ai-search-optimization",
       "  geo-ai-search-optimization install [--target <dir>] [--json]",
+      "  geo-ai-search-optimization auto-flow <input> [--intent <auto|diagnose|guide|execute|share|closeout>] [--json] [--out <file>]",
+      "  geo-ai-search-optimization skills [--json]",
       "  geo-ai-search-optimization where",
       "  geo-ai-search-optimization doctor [--json]",
       "  geo-ai-search-optimization quick-start [--json] [--out <file>]",
@@ -125,6 +129,28 @@ async function handleInstall(args) {
   }
 }
 
+async function handleAutoFlow(args) {
+  const input = args.find((value) => !value.startsWith("-"));
+  if (!input) {
+    throw new Error("auto-flow 需要一个输入值，可以是任务描述、项目路径、网站网址或已导出的工件");
+  }
+
+  const flow = await createAutoFlow(input, {
+    intent: getFlagValue(args, "--intent")
+  });
+  const outputJson = hasFlag(args, "--json");
+  const renderedOutput = outputJson ? `${JSON.stringify(flow, null, 2)}\n` : renderAutoFlowMarkdown(flow);
+
+  const outputPath = getFlagValue(args, "--out");
+  if (outputPath) {
+    const resolvedOutputPath = await writeAutoFlowOutput(outputPath, renderedOutput);
+    process.stdout.write(`已保存 auto-flow 结果：${resolvedOutputPath}\n`);
+    return;
+  }
+
+  process.stdout.write(renderedOutput);
+}
+
 function handleWhere() {
   process.stdout.write(
     [
@@ -136,6 +162,16 @@ function handleWhere() {
   );
 }
 
+async function handleSkills(args) {
+  const bundle = await listBundledSkills();
+  if (hasFlag(args, "--json")) {
+    process.stdout.write(`${JSON.stringify(bundle, null, 2)}\n`);
+    return;
+  }
+
+  process.stdout.write(renderBundledSkillsMarkdown(bundle));
+}
+
 async function handleDoctor(args) {
   const report = await runDoctor();
   if (hasFlag(args, "--json")) {
@@ -655,6 +691,16 @@ export async function runCli(args = []) {
     return;
   }
 
+  if (command === "auto-flow") {
+    await handleAutoFlow(rest);
+    return;
+  }
+
+  if (command === "skills") {
+    await handleSkills(rest);
+    return;
+  }
+
   if (command === "where") {
     handleWhere();
     return;

package/src/index.js

@@ -5,6 +5,7 @@ export {
   runInteractiveOnboarding,
   writeInteractiveOnboardingOutput
 } from "./interactive-onboarding.js";
+export { createAutoFlow, renderAutoFlowMarkdown, writeAutoFlowOutput } from "./auto-flow.js";
 export { createApplyPlan, renderApplyPlanMarkdown, writeApplyPlanOutput } from "./apply-plan.js";
 export { createAgentHandoff, renderAgentHandoffMarkdown, writeAgentHandoffOutput } from "./agent-handoff.js";
 export { createCompletionReport, renderCompletionReportMarkdown, writeCompletionReportOutput } from "./completion-report.js";
@@ -27,4 +28,5 @@ export { createRoadmap, renderRoadmapMarkdown, writeRoadmapOutput } from "./road
 export { createSchemaTemplate } from "./schema.js";
 export { scanProject, renderScanMarkdown, writeScanOutput } from "./scan.js";
 export { createSharePack, renderSharePackMarkdown, writeSharePackOutput } from "./share-pack.js";
+export { listBundledSkills, renderBundledSkillsMarkdown } from "./skills.js";
 export { analyzeWebsiteUrl, renderWebsiteOnboardingMarkdown, writeWebsiteOnboardingOutput } from "./url-onboarding.js";

package/src/install-skill.js

@@ -1,6 +1,7 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import { getBundledSkillPath, getInstalledSkillPath, getSkillName } from "./paths.js";
+import { listBundledSkills } from "./skills.js";
 
 async function pathExists(targetPath) {
   try {
@@ -11,10 +12,18 @@ async function pathExists(targetPath) {
   }
 }
 
+function resolveInstalledSkillPath(skillName, targetDir) {
+  if (skillName === getSkillName()) {
+    return targetDir;
+  }
+  return path.join(path.dirname(targetDir), skillName);
+}
+
 export async function installSkill(options = {}) {
   const sourceDir = getBundledSkillPath();
   const targetDir = options.targetDir || getInstalledSkillPath();
   const silent = Boolean(options.silent);
+  const bundle = await listBundledSkills();
 
   if (!(await pathExists(sourceDir))) {
     throw new Error(`Bundled skill folder not found: ${sourceDir}`);
@@ -48,6 +57,14 @@ export async function installSkill(options = {}) {
   const manifest = {
     skill: getSkillName(),
     installedSkills,
+    installedSkillDetails: bundle.skills
+      .filter((skill) => installedSkills.includes(skill.name))
+      .map((skill) => ({
+        name: skill.name,
+        displayName: skill.displayName,
+        shortDescription: skill.shortDescription,
+        installPath: resolveInstalledSkillPath(skill.name, targetDir)
+      })),
     installedAt: new Date().toISOString(),
     installedFrom: sourceDir,
     packageName: "geo-ai-search-optimization",
@@ -60,6 +77,30 @@ export async function installSkill(options = {}) {
     "utf8"
   );
 
+  const bundleManifestPath = path.join(targetDir, ".skill-bundle.json");
+  await fs.writeFile(
+    bundleManifestPath,
+    `${JSON.stringify(
+      {
+        kind: bundle.kind,
+        totalSkills: bundle.totalSkills,
+        groups: bundle.groups.map((group) => ({
+          category: group.category,
+          label: group.label,
+          skills: group.skills.map((skill) => ({
+            name: skill.name,
+            displayName: skill.displayName,
+            shortDescription: skill.shortDescription,
+            installPath: resolveInstalledSkillPath(skill.name, targetDir)
+          }))
+        }))
+      },
+      null,
+      2
+    )}\n`,
+    "utf8"
+  );
+
   if (!silent) {
     process.stdout.write(`Installed skills (${installedSkills.join(", ")}) to ${path.dirname(targetDir)}\n`);
   }
@@ -69,6 +110,7 @@ export async function installSkill(options = {}) {
     sourceDir,
     skillName: getSkillName(),
     installedSkills,
-    manifest
+    manifest,
+    bundleManifestPath
   };
 }

package/src/skills.js

@@ -0,0 +1,173 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { getPackageRoot } from "./paths.js";
+
+const SKILL_ORDER = [
+  "geo-ai-search-optimization",
+  "geo-ai-search-optimization-auto-flow",
+  "geo-ai-search-optimization-usage",
+  "geo-ai-search-optimization-agent-handoff",
+  "geo-ai-search-optimization-repair-loop",
+  "geo-ai-search-optimization-completion-report",
+  "geo-ai-search-optimization-handoff-bundle",
+  "geo-ai-search-optimization-share-pack",
+  "geo-ai-search-optimization-export-pack",
+  "geo-ai-search-optimization-html-pack",
+  "geo-ai-search-optimization-publish-pack"
+];
+
+const SKILL_CATEGORY = {
+  "geo-ai-search-optimization": "core",
+  "geo-ai-search-optimization-auto-flow": "routing",
+  "geo-ai-search-optimization-usage": "guidance",
+  "geo-ai-search-optimization-agent-handoff": "execution",
+  "geo-ai-search-optimization-repair-loop": "execution",
+  "geo-ai-search-optimization-completion-report": "execution",
+  "geo-ai-search-optimization-handoff-bundle": "execution",
+  "geo-ai-search-optimization-share-pack": "delivery",
+  "geo-ai-search-optimization-export-pack": "delivery",
+  "geo-ai-search-optimization-html-pack": "delivery",
+  "geo-ai-search-optimization-publish-pack": "delivery"
+};
+
+const CATEGORY_LABELS = {
+  core: "核心 GEO 能力",
+  routing: "自动入口",
+  guidance: "使用引导",
+  execution: "Agent 执行闭环",
+  delivery: "交付与分享"
+};
+
+function stripQuotes(value) {
+  return String(value).trim().replace(/^['"]|['"]$/g, "");
+}
+
+function parseYamlBlock(raw) {
+  const record = {};
+  for (const line of raw.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) {
+      continue;
+    }
+    const separatorIndex = trimmed.indexOf(":");
+    if (separatorIndex === -1) {
+      continue;
+    }
+    const key = trimmed.slice(0, separatorIndex).trim();
+    const value = stripQuotes(trimmed.slice(separatorIndex + 1));
+    record[key] = value;
+  }
+  return record;
+}
+
+async function readSkillMetadata(skillDir) {
+  const skillPath = path.join(skillDir, "SKILL.md");
+  const raw = await fs.readFile(skillPath, "utf8");
+  const frontmatterMatch = raw.match(/^---\n([\s\S]*?)\n---/);
+  const frontmatter = frontmatterMatch ? parseYamlBlock(frontmatterMatch[1]) : {};
+  const yamlPath = path.join(skillDir, "agents", "openai.yaml");
+
+  let interfaceMetadata = {};
+  try {
+    const yamlRaw = await fs.readFile(yamlPath, "utf8");
+    const interfaceMatch = yamlRaw.match(/interface:\n([\s\S]*)/);
+    if (interfaceMatch) {
+      interfaceMetadata = parseYamlBlock(interfaceMatch[1]);
+    }
+  } catch {
+    interfaceMetadata = {};
+  }
+
+  const directoryName = path.basename(skillDir);
+  const name = frontmatter.name || directoryName;
+
+  return {
+    name,
+    directoryName,
+    description: frontmatter.description || "",
+    displayName: interfaceMetadata.display_name || name,
+    shortDescription: interfaceMetadata.short_description || frontmatter.description || "",
+    defaultPrompt: interfaceMetadata.default_prompt || "",
+    category: SKILL_CATEGORY[name] || "delivery",
+    skillPath
+  };
+}
+
+function sortSkills(skills) {
+  return [...skills].sort((left, right) => {
+    const leftIndex = SKILL_ORDER.indexOf(left.name);
+    const rightIndex = SKILL_ORDER.indexOf(right.name);
+    if (leftIndex === -1 && rightIndex === -1) {
+      return left.name.localeCompare(right.name);
+    }
+    if (leftIndex === -1) {
+      return 1;
+    }
+    if (rightIndex === -1) {
+      return -1;
+    }
+    return leftIndex - rightIndex;
+  });
+}
+
+export async function listBundledSkills() {
+  const resourcesDir = path.join(getPackageRoot(), "resources");
+  const entries = await fs.readdir(resourcesDir, { withFileTypes: true });
+  const skillDirs = entries
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => path.join(resourcesDir, entry.name));
+
+  const skills = [];
+  for (const skillDir of skillDirs) {
+    try {
+      await fs.access(path.join(skillDir, "SKILL.md"));
+    } catch {
+      continue;
+    }
+    skills.push(await readSkillMetadata(skillDir));
+  }
+
+  const ordered = sortSkills(skills);
+  const grouped = Object.entries(CATEGORY_LABELS).map(([category, label]) => ({
+    category,
+    label,
+    skills: ordered.filter((skill) => skill.category === category)
+  }));
+
+  return {
+    kind: "geo-skill-bundle",
+    totalSkills: ordered.length,
+    skills: ordered,
+    groups: grouped.filter((group) => group.skills.length > 0)
+  };
+}
+
+export function renderBundledSkillsMarkdown(bundle) {
+  const lines = [
+    "# GEO Skill Bundle",
+    "",
+    `- 技能数量：\`${bundle.totalSkills}\``,
+    "",
+    "## 推荐理解顺序",
+    "",
+    "- 先看核心 GEO skill。",
+    "- 如果 agent 需要自动选 skill，先跑 auto-flow。",
+    "- 再看 usage skill，知道什么时候该跑哪个命令。",
+    "- 如果要交给 agent 执行，再进入 handoff / apply / completion 这一条执行链。",
+    "- 如果要产出给团队分发，再进入 share / export / html / publish 这一条交付链。",
+    ""
+  ];
+
+  for (const group of bundle.groups) {
+    lines.push(`## ${group.label}`, "");
+    for (const skill of group.skills) {
+      lines.push(`- ${skill.name}`);
+      lines.push(`  - 显示名：${skill.displayName}`);
+      lines.push(`  - 说明：${skill.shortDescription}`);
+      lines.push(`  - 路径：\`${skill.skillPath}\``);
+    }
+    lines.push("");
+  }
+
+  return `${lines.join("\n")}\n`;
+}