geo-ai-search-optimization 1.2.17 → 1.2.19

package/README.md

@@ -42,6 +42,48 @@ geo-ai-search-optimization skills --json
 - agent 执行闭环相关 skills
 - 分享 / 导出 / 最终交付相关 skills
 
+## Agent Orchestrator 命令
+
+如果你希望 agent 不要看长链路，而是直接拿到“现在唯一该跑哪条命令”，可以直接用 `agent-orchestrator`：
+
+```bash
+geo-ai-search-optimization agent-orchestrator "继续这个 GEO 任务"
+geo-ai-search-optimization agent-orchestrator https://example.com
+geo-ai-search-optimization agent-orchestrator ./your-site
+geo-ai-search-optimization agent-orchestrator ./reports/agent-playbook-pack.json --format json --out ./reports/agent-orchestrator.json
+```
+
+它会输出：
+
+- 当前阶段
+- 为什么现在该做这一步
+- 现在只该跑哪条命令
+- 预期产物
+- 什么时候先停下
+- 做完之后下一条是什么
+- 可直接复制给 agent 的 orchestrator prompt
+
+## Agent Resume 命令
+
+如果 GEO 工作已经做过一轮或多轮，你不想让下一个 agent 从头重新判断，而是想让它从最近一个可靠恢复点继续，可以直接用 `agent-resume`：
+
+```bash
+geo-ai-search-optimization agent-resume "继续这个 GEO 任务"
+geo-ai-search-optimization agent-resume https://example.com
+geo-ai-search-optimization agent-resume ./your-site
+geo-ai-search-optimization agent-resume ./reports/agent-playbook-pack.json --format json --out ./reports/agent-resume.json
+```
+
+它会输出：
+
+- 恢复模式
+- 从哪里恢复
+- 现在只恢复哪一条命令
+- 恢复前要先确认什么
+- 恢复时不要重置什么
+- 恢复后下一条是什么
+- 可直接复制给 agent 的 resume prompt
+
 ## Auto Flow 命令
 
 如果你希望 agent 不用自己判断现在该用哪个 skill、该跑哪个命令，可以直接用 `auto-flow`：
@@ -660,6 +702,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 agent-orchestrator ./your-site
+geo-ai-search-optimization agent-resume ./your-site
 geo-ai-search-optimization auto-flow "audit this site and tell me the next skill"
 geo-ai-search-optimization agent-session ./your-site
 geo-ai-search-optimization agent-runbook ./your-site
@@ -741,6 +785,22 @@ geo-ai-search-optimization help
 - 输出 do-now checklist、stop checklist、success checklist、验证命令和回报模板
 - 新增 `geo-ai-search-optimization-agent-executor` skill
 
+## New in 1.2.19
+
+- 新增 `agent-resume`
+- 把 `agent-orchestrator + agent-playbook-pack` 收敛成“从最近一个可靠恢复点继续”的恢复入口
+- 输出 `resume_mode`、`resume_from`、`resume_command`、`verify_before_resume`、`do_not_reset`、`after_resume`
+- `auto-flow`、`agent-session`、`skills` 已经把 `agent-resume` 视为正式恢复链路
+- 新增 `geo-ai-search-optimization-agent-resume` skill
+
+## New in 1.2.18
+
+- 新增 `agent-orchestrator`
+- 把 `auto-flow + agent-session` 收敛成一个“现在只该做哪条命令”的总入口
+- 输出固定 contract：`current_stage`、`why_now`、`next_command`、`expected_artifact`、`stop_if`、`after_that`
+- 更适合 PM 把任务直接交给 agent，或 agent 接着前一个工件继续做
+- 新增 `geo-ai-search-optimization-agent-orchestrator` skill
+
 ## New in 1.2.17
 
 - 新增 `agent-playbook-pack`
@@ -978,6 +1038,8 @@ The installed package now includes a bundled GEO skill pack, including:
 
 - `geo-ai-search-optimization`
 - `geo-ai-search-optimization-auto-flow`
+- `geo-ai-search-optimization-agent-orchestrator`
+- `geo-ai-search-optimization-agent-resume`
 - `geo-ai-search-optimization-agent-session`
 - `geo-ai-search-optimization-agent-runbook`
 - `geo-ai-search-optimization-agent-executor`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "geo-ai-search-optimization",
-  "version": "1.2.17",
+  "version": "1.2.19",
   "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/references/skill-bundle-map.md

@@ -32,6 +32,26 @@ Best for:
 - turning one-line task briefs into a concrete command sequence
 - deciding whether the work should move into diagnosis, execution, closeout, or delivery
 
+### `geo-ai-search-optimization-agent-orchestrator`
+
+Use this when the next agent should get one immediate next command instead of reading a full command chain.
+
+Best for:
+
+- deciding the one command to run now
+- returning a short contract with expected artifact, stop conditions, and follow-up command
+- reducing ambiguity for PM-to-agent or agent-to-agent handoffs
+
+### `geo-ai-search-optimization-agent-resume`
+
+Use this when the next agent should continue from the latest reliable GEO checkpoint instead of restarting the whole chain.
+
+Best for:
+
+- resuming from a playbook pack, decision log, status board, checkpoint, or similar GEO artifact
+- telling the next agent exactly where to continue and what not to reset
+- turning a previously interrupted GEO chain into one resume command plus one follow-up command
+
 ### `geo-ai-search-optimization-agent-session`
 
 Use this when the next agent needs a runnable session plan, not just a routing answer.

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

@@ -0,0 +1,23 @@
+---
+name: geo-ai-search-optimization-agent-orchestrator
+description: Choose the one next GEO command an agent should run right now. Use when an agent, PM, or another workflow has a GEO URL, codebase, task brief, or artifact and wants a single next command, expected artifact, stop conditions, and follow-up command instead of a full chain.
+---
+
+# GEO Agent Orchestrator
+
+Use this skill when the next agent should not browse a long command chain.
+
+`GEO = Generative Engine Optimization`
+
+## What it does
+
+- turns a GEO input into one immediate next command
+- explains why this command should run now
+- shows what artifact should come out of that command
+- tells the next agent when to stop and what to run after that
+
+## Best use
+
+- when PM wants the next agent to start without reading the whole GEO stack
+- when another agent says "just tell me the next command"
+- when GEO work should continue from a URL, codebase, playbook pack, decision log, or other GEO artifact with minimal ambiguity

package/resources/geo-ai-search-optimization-agent-orchestrator/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "GEO Agent Orchestrator"
+  short_description: "Choose the one next GEO command to run now"
+  default_prompt: "Use $geo-ai-search-optimization-agent-orchestrator to pick the one next GEO command to run now, explain why, define the expected artifact, and list stop conditions plus the follow-up command."

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

@@ -0,0 +1,24 @@
+---
+name: geo-ai-search-optimization-agent-resume
+description: Resume a GEO workflow from the latest reliable point instead of restarting the whole chain. Use when an agent, PM, or another workflow has a GEO URL, codebase, playbook pack, decision log, status board, checkpoint, or related artifact and needs the exact resume command, pre-resume checks, and a clear list of what should not be reset.
+---
+
+# GEO Agent Resume
+
+Use this skill when the next agent should continue, not restart.
+
+`GEO = Generative Engine Optimization`
+
+## What it does
+
+- finds the latest reliable GEO recovery point
+- tells the next agent which one command to resume now
+- explains what to verify before resuming
+- lists what should not be reset while continuing the chain
+- keeps the agent aligned with the current packet, next packet, and follow-up command
+
+## Best use
+
+- when GEO work was interrupted and another agent needs to continue safely
+- when PM wants to say "pick up from where the last agent left off"
+- when there are already GEO artifacts and the risk is restarting the chain from the wrong place

package/resources/geo-ai-search-optimization-agent-resume/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "GEO Agent Resume"
+  short_description: "Resume GEO work from the latest reliable point"
+  default_prompt: "Use $geo-ai-search-optimization-agent-resume to continue this GEO workflow from the latest reliable checkpoint, identify the one resume command to run now, list what to verify first, and explain what must not be reset."

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

@@ -13,38 +13,42 @@ Treat this tool as a PM-friendly GEO workflow for websites.
 
 `GEO = Generative Engine Optimization`
 
-The package is best explained as twenty-four layers:
-
-1. `auto-flow`: auto-select the next skill and command chain
-2. `agent-session`: build a runnable session for the next agent
-3. `agent-runbook`: execution manual and checklist for the next agent
-4. `agent-executor`: choose one packet to execute right now
-5. `agent-batch-executor`: queue the first few packets, but still advance one packet at a time
-6. `agent-progress-tracker`: track which packet is done, which one is active, and what comes next
-7. `agent-status-board`: turn the execution state into a board view for PM and agents
-8. `agent-checkpoint`: freeze the current round into a continue / unblock / closeout decision
-9. `agent-decision-log`: preserve why each round continued, paused, or closed out
-10. `agent-retrospective`: explain multi-round patterns, lessons, and next-round advice
-11. `agent-playbook-pack`: compress retrospective, decision history, and handoff into one resume entrypoint
-12. `skills`: inspect the bundled skill package
-13. `onboard-url` / `onboard`: first look
-14. `scan`: raw signal check
-15. `audit` / `report`: diagnosis
-16. `fix-plan` / `owner-board`: execution planning
-17. `agent-handoff`: agent takeover package
-18. `apply-plan`: execution loop
-19. `completion-report`: closeout
-20. `handoff-bundle`: all-in-one package
-21. `share-pack`: audience-ready delivery
-22. `export-pack`: folder export
-23. `html-pack` / `publish-pack`: browsable and final delivery output
-24. `pm-brief` / `roadmap`: stakeholder alignment
+The package is best explained as twenty-six layers:
+
+1. `agent-orchestrator`: choose the one next GEO command to run right now
+2. `agent-resume`: resume from the latest reliable GEO checkpoint instead of restarting the whole chain
+3. `auto-flow`: auto-select the next skill and command chain
+4. `agent-session`: build a runnable session for the next agent
+5. `agent-runbook`: execution manual and checklist for the next agent
+6. `agent-executor`: choose one packet to execute right now
+7. `agent-batch-executor`: queue the first few packets, but still advance one packet at a time
+8. `agent-progress-tracker`: track which packet is done, which one is active, and what comes next
+9. `agent-status-board`: turn the execution state into a board view for PM and agents
+10. `agent-checkpoint`: freeze the current round into a continue / unblock / closeout decision
+11. `agent-decision-log`: preserve why each round continued, paused, or closed out
+12. `agent-retrospective`: explain multi-round patterns, lessons, and next-round advice
+13. `agent-playbook-pack`: compress retrospective, decision history, and handoff into one resume entrypoint
+14. `skills`: inspect the bundled skill package
+15. `onboard-url` / `onboard`: first look
+16. `scan`: raw signal check
+17. `audit` / `report`: diagnosis
+18. `fix-plan` / `owner-board`: execution planning
+19. `agent-handoff`: agent takeover package
+20. `apply-plan`: execution loop
+21. `completion-report`: closeout
+22. `handoff-bundle`: all-in-one package
+23. `share-pack`: audience-ready delivery
+24. `export-pack`: folder export
+25. `html-pack` / `publish-pack`: browsable and final delivery output
+26. `pm-brief` / `roadmap`: stakeholder alignment
 
 ## Recommended command order
 
 If the user only has a website URL:
 
 ```bash
+npx geo-ai-search-optimization agent-orchestrator https://example.com
+npx geo-ai-search-optimization agent-resume https://example.com
 npx geo-ai-search-optimization auto-flow https://example.com
 npx geo-ai-search-optimization agent-session https://example.com
 npx geo-ai-search-optimization agent-runbook https://example.com
@@ -64,6 +68,8 @@ npx geo-ai-search-optimization roadmap https://example.com
 If the user has the website codebase:
 
 ```bash
+npx geo-ai-search-optimization agent-orchestrator ./your-site
+npx geo-ai-search-optimization agent-resume ./your-site
 npx geo-ai-search-optimization auto-flow ./your-site
 npx geo-ai-search-optimization agent-session ./your-site
 npx geo-ai-search-optimization agent-runbook ./your-site
@@ -92,6 +98,8 @@ npx geo-ai-search-optimization roadmap ./your-site
 
 ## When to recommend each command
 
+- `agent-orchestrator`: choose the one next GEO command to run now, plus expected artifact, stop conditions, and follow-up command
+- `agent-resume`: resume from the latest reliable checkpoint, confirm what not to reset, and tell the next agent the one resume command to run
 - `auto-flow`: auto-select the next skill and command order from a task brief, URL, project path, or GEO artifact
 - `agent-session`: build a step-by-step session packet for the next agent from the same kinds of inputs
 - `agent-runbook`: build a checklist-driven runbook with preflight, validation, and reporting rules
@@ -127,6 +135,8 @@ 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 next agent wants just one next command, move them to `agent-orchestrator`
+- if the user or next agent needs to continue from the latest reliable checkpoint without restarting, move them to `agent-resume`
 - if the user or the next agent is unsure where to start, move them to `auto-flow` first
 - if the user wants something the next agent can follow step by step, move them to `agent-session`
 - if the user wants the next agent to follow a checklist and execution manual, move them to `agent-runbook`

package/src/agent-orchestrator.js

@@ -0,0 +1,191 @@
+import { createAgentSession } from "./agent-session.js";
+import { writeScanOutput } from "./scan.js";
+
+const VALID_FORMATS = new Set(["markdown", "json"]);
+
+function normalizeFormat(format) {
+  const resolved = (format || "markdown").toLowerCase();
+  if (!VALID_FORMATS.has(resolved)) {
+    throw new Error(`不支持的 agent-orchestrator 格式：${format}。可选值：${Array.from(VALID_FORMATS).join(", ")}`);
+  }
+  return resolved;
+}
+
+function inferOrchestrationMode(session) {
+  if (session.status === "needs-context") {
+    return "needs-context";
+  }
+  if (session.intent === "share") {
+    return "delivery";
+  }
+  if (session.intent === "closeout") {
+    return "closeout";
+  }
+  if (session.intent === "execute") {
+    return "execution";
+  }
+  if (session.intent === "guide") {
+    return "guidance";
+  }
+  return "diagnosis";
+}
+
+function buildWhyNow(session, nextStep) {
+  if (!nextStep) {
+    return "当前还没有足够上下文来确定下一步命令，先补输入。";
+  }
+
+  if (session.artifactKind === "geo-agent-playbook-pack") {
+    return "当前已经有单入口 playbook，不应该重新规划整条链，直接沿着既有恢复点继续最稳。";
+  }
+  if (session.artifactKind === "geo-agent-decision-log") {
+    return "当前已经有跨轮决策历史，下一步应沿着最近一次决策继续，而不是重新做全量判断。";
+  }
+  if (session.artifactKind === "geo-agent-retrospective") {
+    return "当前已经有多轮复盘，下一步应该把复盘结论转成正式动作，而不是回到最前面的扫描阶段。";
+  }
+  if (session.sourceType === "url" && session.intent === "execute") {
+    return "当前只有公开网址，最重要的是先把建议型执行入口建立好，再决定是否需要仓库上下文。";
+  }
+
+  return `${session.whyThisSkill} 当前最该先跑的是 ${nextStep.commandName}，因为它会直接产出下一阶段需要的关键工件。`;
+}
+
+function buildStopIf(session, nextStep) {
+  const items = [...session.contextNeeded];
+
+  if (session.sourceType === "url" && session.intent === "execute") {
+    items.push("只有网址时，不要宣称已经完成代码级修复。");
+  }
+  if (session.artifactKind === "geo-agent-playbook-pack") {
+    items.push("不要绕开 playbook 重新拆一条新链，除非当前 playbook 已明显过时。");
+  }
+  if (nextStep?.commandName === "agent-executor") {
+    items.push("不要同时展开多个任务包；这一轮先推进当前单包。");
+  }
+  if (nextStep?.commandName === "completion-report") {
+    items.push("如果这一轮还没有完成或没有明确验证结果，不要过早进入 closeout。");
+  }
+  if (nextStep?.commandName === "publish-pack") {
+    items.push("如果前面的 completion-report 或 share 结果还不完整，不要直接产出最终交付包。");
+  }
+
+  return Array.from(new Set(items));
+}
+
+function buildAfterThat(session) {
+  return session.steps[1]?.command || null;
+}
+
+function buildOrchestratorPrompt(orchestrator) {
+  const lines = [
+    `Use $${orchestrator.selectedSkill.name} to continue this GEO task.`,
+    `当前输入：${orchestrator.source}`,
+    `当前阶段：${orchestrator.current_stage}`,
+    `当前模式：${orchestrator.orchestration_mode}`,
+    `为什么现在做这一步：${orchestrator.why_now}`
+  ];
+
+  if (orchestrator.next_command) {
+    lines.push(`现在只运行这一条命令：${orchestrator.next_command}`);
+  }
+  if (orchestrator.expected_artifact) {
+    lines.push(`预期产物：${orchestrator.expected_artifact}`);
+  }
+  if (orchestrator.after_that) {
+    lines.push(`完成后下一条：${orchestrator.after_that}`);
+  }
+  if (orchestrator.stop_if.length > 0) {
+    lines.push("出现以下情况就先停下：");
+    for (const item of orchestrator.stop_if) {
+      lines.push(`- ${item}`);
+    }
+  }
+
+  lines.push("输出时先说明为什么执行这一步，再说明得到什么，以及之后怎么继续。");
+  return lines.join("\n");
+}
+
+export async function createAgentOrchestrator(input, options = {}) {
+  const format = normalizeFormat(options.format);
+  const session = await createAgentSession(input, {
+    intent: options.intent
+  });
+  const nextStep = session.steps[0] || null;
+
+  const orchestrator = {
+    kind: "geo-agent-orchestrator",
+    input,
+    source: session.source,
+    sourceType: session.sourceType,
+    artifactKind: session.artifactKind,
+    format,
+    orchestration_mode: inferOrchestrationMode(session),
+    current_stage: session.stage,
+    why_now: buildWhyNow(session, nextStep),
+    next_command: nextStep?.command || null,
+    expected_artifact: nextStep?.expectedArtifact || null,
+    stop_if: buildStopIf(session, nextStep),
+    after_that: buildAfterThat(session),
+    selectedSkill: session.selectedSkill,
+    next_skill: nextStep?.suggestedSkill || session.selectedSkill.name,
+    session_status: session.status,
+    next_action: session.nextAction,
+    session,
+    orchestrator_prompt: ""
+  };
+
+  orchestrator.orchestrator_prompt = buildOrchestratorPrompt(orchestrator);
+  return orchestrator;
+}
+
+export function renderAgentOrchestratorMarkdown(orchestrator) {
+  const lines = [
+    "# GEO Agent Orchestrator",
+    "",
+    `- 输入：\`${orchestrator.source}\``,
+    `- 输入类型：\`${orchestrator.sourceType}\``,
+    `- 工件类型：\`${orchestrator.artifactKind}\``,
+    `- 当前阶段：${orchestrator.current_stage}`,
+    `- orchestration mode：\`${orchestrator.orchestration_mode}\``,
+    `- 当前建议 skill：\`${orchestrator.next_skill}\``,
+    "",
+    "## 为什么现在做这一步",
+    "",
+    `- ${orchestrator.why_now}`,
+    "",
+    "## 现在只做这一条",
+    "",
+    `- 命令：\`${orchestrator.next_command || "先补输入"}\``,
+    `- 预期产物：${orchestrator.expected_artifact || "先明确需要什么上下文"}`,
+    ""
+  ];
+
+  if (orchestrator.after_that) {
+    lines.push("## 做完之后", "", `- 下一条：\`${orchestrator.after_that}\``, "");
+  }
+
+  lines.push("## 什么时候先停下", "");
+  if (orchestrator.stop_if.length === 0) {
+    lines.push("- 当前没有额外 stop 条件。");
+  } else {
+    for (const item of orchestrator.stop_if) {
+      lines.push(`- ${item}`);
+    }
+  }
+
+  lines.push(
+    "",
+    "## 可直接复制给 Agent 的 Orchestrator Prompt",
+    "",
+    "```text",
+    orchestrator.orchestrator_prompt,
+    "```"
+  );
+
+  return `${lines.join("\n")}\n`;
+}
+
+export async function writeAgentOrchestratorOutput(outputPath, content) {
+  return writeScanOutput(outputPath, content);
+}

package/src/agent-resume.js

@@ -0,0 +1,329 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { createAgentOrchestrator } from "./agent-orchestrator.js";
+import { createAgentPlaybookPack } from "./agent-playbook-pack.js";
+import { writeScanOutput } from "./scan.js";
+
+const VALID_FORMATS = new Set(["markdown", "json"]);
+
+function normalizeFormat(format) {
+  const resolved = (format || "markdown").toLowerCase();
+  if (!VALID_FORMATS.has(resolved)) {
+    throw new Error(`不支持的 agent-resume 格式：${format}。可选值：${Array.from(VALID_FORMATS).join(", ")}`);
+  }
+  return resolved;
+}
+
+async function pathExists(targetPath) {
+  try {
+    await fs.access(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function tryReadExistingPlaybookPack(input) {
+  const resolvedPath = path.resolve(String(input));
+  if (!(await pathExists(resolvedPath)) || path.extname(resolvedPath).toLowerCase() !== ".json") {
+    return null;
+  }
+
+  try {
+    const parsed = JSON.parse(await fs.readFile(resolvedPath, "utf8"));
+    if (parsed.kind === "geo-agent-playbook-pack") {
+      return parsed;
+    }
+    if (parsed.kind === "geo-agent-resume" && parsed.playbookPack) {
+      return parsed.playbookPack;
+    }
+  } catch {
+    return null;
+  }
+
+  return null;
+}
+
+async function tryCreatePlaybookPack(input) {
+  const existing = await tryReadExistingPlaybookPack(input);
+  if (existing) {
+    return existing;
+  }
+  try {
+    return await createAgentPlaybookPack(input, { format: "json" });
+  } catch {
+    return null;
+  }
+}
+
+function inferResumeMode(orchestrator, playbookPack) {
+  if (orchestrator.orchestration_mode === "needs-context") {
+    return "needs-context";
+  }
+  if (playbookPack?.playbookStatus === "closeout-ready") {
+    return "resume-closeout";
+  }
+  if (playbookPack?.playbookStatus === "unblock-first") {
+    return "resume-after-unblock";
+  }
+  if (playbookPack?.playbookStatus === "advice-ready") {
+    return "resume-advice";
+  }
+  if (playbookPack?.currentPacket) {
+    return "resume-current-packet";
+  }
+  return "resume-workflow";
+}
+
+function buildResumeFrom(orchestrator, playbookPack) {
+  if (playbookPack?.playbookStatus === "closeout-ready") {
+    return "从 closeout 阶段继续";
+  }
+  if (playbookPack?.playbookStatus === "unblock-first") {
+    return `先从解除阻塞继续，再回到 ${playbookPack.currentPacket?.id || "当前包"}`;
+  }
+  if (playbookPack?.currentPacket) {
+    return `从 ${playbookPack.currentPacket.id}｜${playbookPack.currentPacket.title} 继续`;
+  }
+  if (orchestrator.next_command) {
+    return `从下一条命令继续：${orchestrator.next_command}`;
+  }
+  return "先补输入后再恢复";
+}
+
+function buildResumeSummary(orchestrator, playbookPack) {
+  if (orchestrator.orchestration_mode === "needs-context") {
+    return "当前还没有足够上下文恢复上一轮工作，先补网址、目录或 GEO 工件。";
+  }
+  if (playbookPack?.playbookStatus === "closeout-ready") {
+    return "当前已经进入或接近收尾，恢复时不要重新回到执行第一包。";
+  }
+  if (playbookPack?.playbookStatus === "unblock-first") {
+    return "当前恢复重点不是继续改动，而是先清掉重复阻塞项，再回到当前包。";
+  }
+  if (playbookPack?.currentPacket) {
+    return `当前最稳的恢复点是 ${playbookPack.currentPacket.id}，不要把前面已经排好的链重新拆掉。`;
+  }
+  return orchestrator.why_now;
+}
+
+function shouldUnwrapResumeCommand(orchestrator) {
+  return /\bagent-resume\b/.test(orchestrator.next_command || "");
+}
+
+function buildResumeCommand(orchestrator, playbookPack) {
+  if (shouldUnwrapResumeCommand(orchestrator) && playbookPack?.startCommand) {
+    return playbookPack.startCommand;
+  }
+  return orchestrator.next_command;
+}
+
+function buildAfterResume(orchestrator, playbookPack, resumeCommand) {
+  if (shouldUnwrapResumeCommand(orchestrator) && Array.isArray(playbookPack?.followupCommands)) {
+    return playbookPack.followupCommands.find((command) => command && command !== resumeCommand) || orchestrator.after_that;
+  }
+  return orchestrator.after_that;
+}
+
+function inferExpectedArtifactFromCommand(command) {
+  const normalized = String(command || "").toLowerCase();
+
+  if (normalized.includes("completion-report")) {
+    return "复盘工件";
+  }
+  if (normalized.includes("agent-executor")) {
+    return "agent 单任务执行包";
+  }
+  if (normalized.includes("agent-batch-executor")) {
+    return "agent 多任务批次执行包";
+  }
+  if (normalized.includes("agent-runbook")) {
+    return "agent 执行手册";
+  }
+  if (normalized.includes("agent-status-board")) {
+    return "agent 执行状态看板";
+  }
+  if (normalized.includes("agent-progress-tracker")) {
+    return "agent 执行进度追踪工件";
+  }
+  if (normalized.includes("agent-decision-log")) {
+    return "agent 决策历史工件";
+  }
+  if (normalized.includes("fix-plan")) {
+    return "待办清单与优先级";
+  }
+  if (normalized.includes("audit")) {
+    return "GEO 审计结果";
+  }
+  if (normalized.includes("scan")) {
+    return "基础信号扫描结果";
+  }
+  return null;
+}
+
+function buildExpectedArtifact(orchestrator, playbookPack, resumeCommand) {
+  if (shouldUnwrapResumeCommand(orchestrator)) {
+    return inferExpectedArtifactFromCommand(resumeCommand) || playbookPack?.resumeSummary || "阶段性 GEO 输出";
+  }
+  return orchestrator.expected_artifact;
+}
+
+function buildVerifyBeforeResume(orchestrator, playbookPack) {
+  const items = [];
+
+  if (playbookPack) {
+    items.push(...playbookPack.readOrder.slice(0, 2));
+    if (playbookPack.currentPacket) {
+      items.push(`确认当前包仍然是 ${playbookPack.currentPacket.id}，不要在恢复时改成别的包。`);
+    }
+  } else if (orchestrator.sourceType === "task-text") {
+    items.push("先确认是否已经有网址、目录或 JSON 工件，否则无法恢复上一轮。");
+  }
+
+  items.push(...orchestrator.stop_if);
+  return Array.from(new Set(items));
+}
+
+function buildDoNotReset(playbookPack) {
+  if (!playbookPack) {
+    return ["没有恢复工件时，不要假装已经知道上一轮做到哪里。"];
+  }
+
+  const items = ["不要从第一步重新跑整条链，除非当前工件已经明显过时。", ...playbookPack.avoidNowChecklist];
+  return Array.from(new Set(items));
+}
+
+function buildResumePrompt(resume) {
+  const lines = [
+    `Use $${resume.selectedSkill.name} to resume this GEO task without restarting the chain.`,
+    `当前输入：${resume.source}`,
+    `恢复模式：${resume.resume_mode}`,
+    `恢复点：${resume.resume_from}`,
+    `恢复摘要：${resume.resume_summary}`
+  ];
+
+  if (resume.resume_command) {
+    lines.push(`现在只恢复这一条命令：${resume.resume_command}`);
+  }
+  if (resume.expected_artifact) {
+    lines.push(`预期恢复产物：${resume.expected_artifact}`);
+  }
+  if (resume.after_resume) {
+    lines.push(`恢复后下一条：${resume.after_resume}`);
+  }
+  if (resume.verify_before_resume.length > 0) {
+    lines.push("恢复前先确认：");
+    for (const item of resume.verify_before_resume) {
+      lines.push(`- ${item}`);
+    }
+  }
+  if (resume.do_not_reset.length > 0) {
+    lines.push("恢复时不要做这些事：");
+    for (const item of resume.do_not_reset) {
+      lines.push(`- ${item}`);
+    }
+  }
+
+  lines.push("输出时先说明你是从哪里恢复的，再说明为什么不需要重新规划整条链。");
+  return lines.join("\n");
+}
+
+export async function createAgentResume(input, options = {}) {
+  const format = normalizeFormat(options.format);
+  const [orchestrator, playbookPack] = await Promise.all([
+    createAgentOrchestrator(input, { format: "json", intent: options.intent }),
+    tryCreatePlaybookPack(input)
+  ]);
+  const resumeCommand = buildResumeCommand(orchestrator, playbookPack);
+  const afterResume = buildAfterResume(orchestrator, playbookPack, resumeCommand);
+  const expectedArtifact = buildExpectedArtifact(orchestrator, playbookPack, resumeCommand);
+
+  const resume = {
+    kind: "geo-agent-resume",
+    input,
+    source: orchestrator.source,
+    sourceType: orchestrator.sourceType,
+    artifactKind: orchestrator.artifactKind,
+    format,
+    resume_mode: inferResumeMode(orchestrator, playbookPack),
+    resume_from: buildResumeFrom(orchestrator, playbookPack),
+    resume_summary: buildResumeSummary(orchestrator, playbookPack),
+    resume_command: resumeCommand,
+    expected_artifact: expectedArtifact,
+    verify_before_resume: buildVerifyBeforeResume(orchestrator, playbookPack),
+    do_not_reset: buildDoNotReset(playbookPack),
+    after_resume: afterResume,
+    selectedSkill: {
+      name: "geo-ai-search-optimization-agent-resume",
+      displayName: "GEO Agent Resume"
+    },
+    next_skill: orchestrator.next_skill || orchestrator.selectedSkill?.name || "geo-ai-search-optimization",
+    contextNeeded: orchestrator.session?.contextNeeded || [],
+    currentPacket: playbookPack?.currentPacket || null,
+    nextPacket: playbookPack?.nextPacket || null,
+    playbookStatus: playbookPack?.playbookStatus || null,
+    orchestrator,
+    playbookPack,
+    resume_prompt: ""
+  };
+
+  resume.resume_prompt = buildResumePrompt(resume);
+  return resume;
+}
+
+export function renderAgentResumeMarkdown(resume) {
+  const lines = [
+    "# GEO Agent Resume",
+    "",
+    `- 输入：\`${resume.source}\``,
+    `- 输入类型：\`${resume.sourceType}\``,
+    `- 工件类型：\`${resume.artifactKind}\``,
+    `- 恢复模式：\`${resume.resume_mode}\``,
+    `- 当前建议 skill：\`${resume.next_skill}\``,
+    "",
+    "## 从哪里恢复",
+    "",
+    `- ${resume.resume_from}`,
+    `- ${resume.resume_summary}`,
+    "",
+    "## 现在恢复这一条",
+    "",
+    `- 命令：\`${resume.resume_command || "先补输入"}\``,
+    `- 预期产物：${resume.expected_artifact || "先补输入再恢复"}`,
+    ""
+  ];
+
+  if (resume.currentPacket) {
+    lines.push("## 当前包", "", `- ${resume.currentPacket.id}｜${resume.currentPacket.title}`, "");
+  }
+  if (resume.nextPacket) {
+    lines.push("## 下一包", "", `- ${resume.nextPacket.id}｜${resume.nextPacket.title}`, "");
+  }
+  if (resume.after_resume) {
+    lines.push("## 恢复后下一条", "", `- \`${resume.after_resume}\``, "");
+  }
+
+  lines.push("## 恢复前先确认", "");
+  for (const item of resume.verify_before_resume) {
+    lines.push(`- ${item}`);
+  }
+
+  lines.push("", "## 恢复时不要重置", "");
+  for (const item of resume.do_not_reset) {
+    lines.push(`- ${item}`);
+  }
+
+  if (resume.contextNeeded.length > 0) {
+    lines.push("", "## 还缺什么", "");
+    for (const item of resume.contextNeeded) {
+      lines.push(`- ${item}`);
+    }
+  }
+
+  lines.push("", "## 可直接复制给 Agent 的 Resume Prompt", "", "```text", resume.resume_prompt, "```");
+  return `${lines.join("\n")}\n`;
+}
+
+export async function writeAgentResumeOutput(outputPath, content) {
+  return writeScanOutput(outputPath, content);
+}

package/src/agent-session.js

@@ -46,6 +46,9 @@ function inferSkillForCommand(commandName, flow) {
   if (commandName === "auto-flow") {
     return "geo-ai-search-optimization-auto-flow";
   }
+  if (commandName === "agent-resume") {
+    return "geo-ai-search-optimization-agent-resume";
+  }
   if (commandName === "agent-runbook") {
     return "geo-ai-search-optimization-agent-runbook";
   }
@@ -114,6 +117,8 @@ function inferStepPurpose(commandName, flow) {
       return "先理解当前技能包结构，避免 agent 选错链路。";
     case "quick-start":
       return "快速建立从 0 到 1 的执行顺序。";
+    case "agent-resume":
+      return "从最近一个可靠恢复点继续，而不是把整条 GEO 链重新跑一遍。";
     case "onboard":
     case "onboard-url":
       return "先从网址或引导流程拿到首轮 GEO 判断。";
@@ -191,6 +196,8 @@ function inferExpectedArtifact(commandName) {
       return "阶段路线图";
     case "agent-handoff":
       return "agent 交接工件";
+    case "agent-resume":
+      return "agent 恢复入口工件";
     case "agent-runbook":
       return "agent 执行手册";
     case "agent-executor":
@@ -238,6 +245,9 @@ function buildStepInstructions(parsedCommand, flow) {
   if (parsedCommand.commandName === "publish-pack") {
     lines.push("完成后把 `START-HERE.md` 和 `AGENT-START.md` 当作最终入口。");
   }
+  if (parsedCommand.commandName === "agent-resume") {
+    lines.push("先确认恢复点、当前包和不要重置的内容，再继续执行。");
+  }
   if (parsedCommand.commandName === "apply-plan") {
     lines.push("执行包出来后，优先从第一包开始，不要同时展开太多任务。");
   }

package/src/auto-flow.js

@@ -41,6 +41,9 @@ function detectArtifactKindFromParsedJson(parsed) {
 function inferTaskTextMode(text) {
   const normalized = String(text).toLowerCase();
 
+  if (/(agent-resume|resume|恢复继续|从中断处继续|接着上次继续|从最近恢复点继续)/i.test(normalized)) {
+    return "execute";
+  }
   if (/(share-pack|export-pack|html-pack|publish-pack|分享|导出|交付|外发|报告包)/i.test(normalized)) {
     return "share";
   }
@@ -171,6 +174,9 @@ function resolveEffectiveIntent(intent, detected) {
   if (detected.artifactKind === "geo-agent-playbook-pack") {
     return detected.parsed?.playbookStatus === "closeout-ready" ? "closeout" : "execute";
   }
+  if (detected.artifactKind === "geo-agent-resume") {
+    return detected.parsed?.resume_mode === "resume-closeout" ? "closeout" : "execute";
+  }
   if (
     [
       "geo-share-pack",
@@ -338,79 +344,79 @@ function buildCommandChain(detected, intent) {
     case "geo-agent-progress-tracker":
       return detected.parsed?.status === "completed"
         ? [
+            `geo-ai-search-optimization agent-resume ${source}`,
             `geo-ai-search-optimization completion-report ${source}`,
             `geo-ai-search-optimization handoff-bundle ${source}`,
             `geo-ai-search-optimization publish-pack ${source}`
           ]
         : detected.parsed?.currentTaskId
           ? [
-              `geo-ai-search-optimization agent-executor ${source} --task ${detected.parsed.currentTaskId}`,
-              `geo-ai-search-optimization completion-report ${source}`,
-              `geo-ai-search-optimization handoff-bundle ${source}`
+              `geo-ai-search-optimization agent-resume ${source}`,
+              `geo-ai-search-optimization agent-progress-tracker ${source}`,
+              `geo-ai-search-optimization agent-decision-log ${source}`
             ]
           : [
+              `geo-ai-search-optimization agent-resume ${source}`,
               `geo-ai-search-optimization agent-batch-executor ${source}`,
-              `geo-ai-search-optimization completion-report ${source}`,
-              `geo-ai-search-optimization handoff-bundle ${source}`
+              `geo-ai-search-optimization agent-progress-tracker ${source}`
             ];
     case "geo-agent-status-board":
       return detected.parsed?.boardStatus === "completed"
         ? [
+            `geo-ai-search-optimization agent-resume ${source}`,
             `geo-ai-search-optimization completion-report ${source}`,
             `geo-ai-search-optimization handoff-bundle ${source}`,
             `geo-ai-search-optimization publish-pack ${source}`
           ]
         : detected.parsed?.tracker?.currentTaskId
           ? [
-              `geo-ai-search-optimization agent-executor ${source} --task ${detected.parsed.tracker.currentTaskId}`,
+              `geo-ai-search-optimization agent-resume ${source}`,
               `geo-ai-search-optimization agent-progress-tracker ${source}`,
-              `geo-ai-search-optimization completion-report ${source}`
+              `geo-ai-search-optimization agent-decision-log ${source}`
             ]
           : [
+              `geo-ai-search-optimization agent-resume ${source}`,
               `geo-ai-search-optimization agent-progress-tracker ${source}`,
-              `geo-ai-search-optimization completion-report ${source}`,
-              `geo-ai-search-optimization handoff-bundle ${source}`
+              `geo-ai-search-optimization agent-decision-log ${source}`
             ];
     case "geo-agent-checkpoint":
       return detected.parsed?.decision === "move-to-closeout"
         ? [
+            `geo-ai-search-optimization agent-resume ${source}`,
             `geo-ai-search-optimization completion-report ${source}`,
             `geo-ai-search-optimization handoff-bundle ${source}`,
             `geo-ai-search-optimization publish-pack ${source}`
           ]
         : detected.parsed?.decision === "resolve-blockers"
           ? [
-              detected.parsed.suggestedNextCommand || `geo-ai-search-optimization agent-runbook ${source}`,
+              `geo-ai-search-optimization agent-resume ${source}`,
               `geo-ai-search-optimization agent-status-board ${source}`,
               `geo-ai-search-optimization agent-progress-tracker ${source}`
             ]
           : [
-              detected.parsed?.suggestedNextCommand || `geo-ai-search-optimization agent-executor ${source}`,
+              `geo-ai-search-optimization agent-resume ${source}`,
               `geo-ai-search-optimization agent-progress-tracker ${source}`,
-              `geo-ai-search-optimization completion-report ${source}`
+              `geo-ai-search-optimization agent-decision-log ${source}`
             ];
     case "geo-agent-decision-log": {
       const baseSource = detected.parsed?.latestCheckpoint?.source || detected.parsed?.source || source;
       const latestDecision = detected.parsed?.latestDecision;
-      const suggestedNext =
-        detected.parsed?.suggestedNextCommand ||
-        detected.parsed?.latestCheckpoint?.suggestedNextCommand ||
-        `geo-ai-search-optimization agent-executor ${baseSource}`;
 
       return latestDecision === "move-to-closeout"
         ? [
+            `geo-ai-search-optimization agent-resume ${source}`,
             `geo-ai-search-optimization completion-report ${baseSource}`,
             `geo-ai-search-optimization handoff-bundle ${baseSource}`,
             `geo-ai-search-optimization publish-pack ${baseSource}`
           ]
         : latestDecision === "resolve-blockers"
           ? [
-              suggestedNext,
+              `geo-ai-search-optimization agent-resume ${source}`,
               `geo-ai-search-optimization agent-status-board ${source}`,
               `geo-ai-search-optimization agent-decision-log ${baseSource} --append-from ${source}`
             ]
           : [
-              suggestedNext,
+              `geo-ai-search-optimization agent-resume ${source}`,
               `geo-ai-search-optimization agent-progress-tracker ${source}`,
               `geo-ai-search-optimization agent-decision-log ${baseSource} --append-from ${source}`
             ];
@@ -425,16 +431,21 @@ function buildCommandChain(detected, intent) {
       const baseSource = detected.parsed?.source || source;
       return detected.parsed?.playbookStatus === "closeout-ready"
         ? [
-            detected.parsed?.startCommand || `geo-ai-search-optimization completion-report ${baseSource}`,
+            `geo-ai-search-optimization agent-resume ${source}`,
             `geo-ai-search-optimization meeting-pack ${baseSource}`,
             `geo-ai-search-optimization publish-pack ${baseSource}`
           ]
         : [
-            detected.parsed?.startCommand || `geo-ai-search-optimization agent-executor ${baseSource}`,
+            `geo-ai-search-optimization agent-resume ${source}`,
             `geo-ai-search-optimization agent-status-board ${baseSource}`,
             `geo-ai-search-optimization agent-decision-log ${baseSource}`
           ];
     }
+    case "geo-agent-resume": {
+      const resumeCommand = detected.parsed?.resume_command;
+      const afterResume = detected.parsed?.after_resume;
+      return [resumeCommand, afterResume].filter(Boolean);
+    }
     case "geo-apply-plan":
       return [
         `geo-ai-search-optimization agent-executor ${source}`,
@@ -511,17 +522,14 @@ function pickSkillName(detected, intent) {
     case "geo-agent-batch-executor":
       return "geo-ai-search-optimization-agent-batch-executor";
     case "geo-agent-progress-tracker":
-      return "geo-ai-search-optimization-agent-progress-tracker";
     case "geo-agent-status-board":
-      return "geo-ai-search-optimization-agent-status-board";
     case "geo-agent-checkpoint":
-      return "geo-ai-search-optimization-agent-checkpoint";
     case "geo-agent-decision-log":
-      return "geo-ai-search-optimization-agent-decision-log";
+    case "geo-agent-playbook-pack":
+    case "geo-agent-resume":
+      return "geo-ai-search-optimization-agent-resume";
     case "geo-agent-retrospective":
       return "geo-ai-search-optimization-agent-retrospective";
-    case "geo-agent-playbook-pack":
-      return "geo-ai-search-optimization-agent-playbook-pack";
     case "geo-completion-report":
       return "geo-ai-search-optimization-completion-report";
     case "geo-handoff-bundle":
@@ -563,12 +571,14 @@ function buildSecondarySkillNames(primarySkill, intent, detected) {
       "geo-agent-status-board",
       "geo-agent-checkpoint",
       "geo-agent-decision-log",
+      "geo-agent-resume",
       "geo-agent-playbook-pack",
       "geo-apply-plan"
     ].includes(
       detected.artifactKind
     )
   ) {
+    names.add("geo-ai-search-optimization-agent-resume");
     names.add("geo-ai-search-optimization-agent-batch-executor");
     names.add("geo-ai-search-optimization-agent-progress-tracker");
     names.add("geo-ai-search-optimization-agent-status-board");
@@ -590,6 +600,9 @@ function buildSecondarySkillNames(primarySkill, intent, detected) {
 }
 
 function buildStage(intent, detected) {
+  if (detected.artifactKind === "geo-agent-resume") {
+    return "恢复继续";
+  }
   if (intent === "guide") {
     return "使用引导";
   }
@@ -610,6 +623,7 @@ function buildStage(intent, detected) {
       "geo-agent-status-board",
       "geo-agent-checkpoint",
       "geo-agent-decision-log",
+      "geo-agent-resume",
       "geo-agent-playbook-pack",
       "geo-agent-retrospective",
       "geo-apply-plan",
@@ -629,6 +643,7 @@ function buildStage(intent, detected) {
       "geo-agent-status-board",
       "geo-agent-checkpoint",
       "geo-agent-decision-log",
+      "geo-agent-resume",
       "geo-agent-playbook-pack",
       "geo-agent-retrospective",
       "geo-apply-plan",
@@ -717,14 +732,17 @@ function buildNextAction(detected, intent, commands) {
     return `先运行 \`${commands[0]}\` 生成适合外发或交接的结果。`;
   }
   if (intent === "execute") {
+    if (detected.artifactKind === "geo-agent-resume") {
+      return `先运行 \`${commands[0]}\`，从最近一个可靠恢复点继续，不要把整条 GEO 链重新跑一遍。`;
+    }
     if (detected.artifactKind === "geo-agent-progress-tracker") {
-      return `先运行 \`${commands[0]}\`，继续当前执行包或校准下一包。`;
+      return `先运行 \`${commands[0]}\`，先确认最近一个可靠恢复点，再继续当前执行包。`;
     }
     if (detected.artifactKind === "geo-agent-decision-log") {
-      return `先运行 \`${commands[0]}\`，沿着最近一次阶段决策继续推进，而不是重新判断整条链。`;
+      return `先运行 \`${commands[0]}\`，沿着最近一次阶段决策恢复，而不是重新判断整条链。`;
     }
     if (detected.artifactKind === "geo-agent-playbook-pack") {
-      return `先运行 \`${commands[0]}\`，直接沿着 playbook 的起始命令继续，不要重新拆链。`;
+      return `先运行 \`${commands[0]}\`，直接从 playbook 对应的恢复点继续，不要重新拆链。`;
     }
     return `先运行 \`${commands[0]}\`，把当前输入推进到 agent 可执行状态。`;
   }

package/src/cli.js

@@ -16,6 +16,12 @@ import {
 } from "./agent-progress-tracker.js";
 import { createAgentCheckpoint, renderAgentCheckpointMarkdown, writeAgentCheckpointOutput } from "./agent-checkpoint.js";
 import { createAgentDecisionLog, renderAgentDecisionLogMarkdown, writeAgentDecisionLogOutput } from "./agent-decision-log.js";
+import {
+  createAgentOrchestrator,
+  renderAgentOrchestratorMarkdown,
+  writeAgentOrchestratorOutput
+} from "./agent-orchestrator.js";
+import { createAgentResume, renderAgentResumeMarkdown, writeAgentResumeOutput } from "./agent-resume.js";
 import {
   createAgentPlaybookPack,
   renderAgentPlaybookPackMarkdown,
@@ -80,6 +86,8 @@ function printHelp() {
       "Usage:",
       "  geo-ai-search-optimization",
       "  geo-ai-search-optimization install [--target <dir>] [--json]",
+      "  geo-ai-search-optimization agent-orchestrator <input> [--intent <auto|diagnose|guide|execute|share|closeout>] [--format <markdown|json>] [--out <file>]",
+      "  geo-ai-search-optimization agent-resume <input> [--intent <auto|diagnose|guide|execute|share|closeout>] [--format <markdown|json>] [--out <file>]",
       "  geo-ai-search-optimization auto-flow <input> [--intent <auto|diagnose|guide|execute|share|closeout>] [--json] [--out <file>]",
       "  geo-ai-search-optimization agent-session <input> [--intent <auto|diagnose|guide|execute|share|closeout>] [--json] [--out <file>]",
       "  geo-ai-search-optimization agent-runbook <input> [--intent <auto|diagnose|guide|execute|share|closeout>] [--task <id>] [--format <markdown|json>] [--out <file>]",
@@ -183,6 +191,56 @@ async function handleAutoFlow(args) {
   process.stdout.write(renderedOutput);
 }
 
+async function handleAgentOrchestrator(args) {
+  const input = args.find((value) => !value.startsWith("-"));
+  if (!input) {
+    throw new Error("agent-orchestrator 需要一个输入值，可以是任务描述、项目路径、网站网址或已导出的工件");
+  }
+
+  const format = getFlagValue(args, "--format") || (hasFlag(args, "--json") ? "json" : undefined);
+  const orchestrator = await createAgentOrchestrator(input, {
+    intent: getFlagValue(args, "--intent"),
+    format
+  });
+  const outputJson = orchestrator.format === "json";
+  const renderedOutput = outputJson
+    ? `${JSON.stringify(orchestrator, null, 2)}\n`
+    : renderAgentOrchestratorMarkdown(orchestrator);
+
+  const outputPath = getFlagValue(args, "--out");
+  if (outputPath) {
+    const resolvedOutputPath = await writeAgentOrchestratorOutput(outputPath, renderedOutput);
+    process.stdout.write(`已保存 agent-orchestrator 结果：${resolvedOutputPath}\n`);
+    return;
+  }
+
+  process.stdout.write(renderedOutput);
+}
+
+async function handleAgentResume(args) {
+  const input = args.find((value) => !value.startsWith("-"));
+  if (!input) {
+    throw new Error("agent-resume 需要一个输入值，可以是任务描述、项目路径、网站网址或已导出的工件");
+  }
+
+  const format = getFlagValue(args, "--format") || (hasFlag(args, "--json") ? "json" : undefined);
+  const resume = await createAgentResume(input, {
+    intent: getFlagValue(args, "--intent"),
+    format
+  });
+  const outputJson = resume.format === "json";
+  const renderedOutput = outputJson ? `${JSON.stringify(resume, null, 2)}\n` : renderAgentResumeMarkdown(resume);
+
+  const outputPath = getFlagValue(args, "--out");
+  if (outputPath) {
+    const resolvedOutputPath = await writeAgentResumeOutput(outputPath, renderedOutput);
+    process.stdout.write(`已保存 agent-resume 结果：${resolvedOutputPath}\n`);
+    return;
+  }
+
+  process.stdout.write(renderedOutput);
+}
+
 async function handleAgentSession(args) {
   const input = args.find((value) => !value.startsWith("-"));
   if (!input) {
@@ -999,6 +1057,16 @@ export async function runCli(args = []) {
     return;
   }
 
+  if (command === "agent-orchestrator") {
+    await handleAgentOrchestrator(rest);
+    return;
+  }
+
+  if (command === "agent-resume") {
+    await handleAgentResume(rest);
+    return;
+  }
+
   if (command === "agent-session") {
     await handleAgentSession(rest);
     return;

package/src/index.js

@@ -7,6 +7,8 @@ export {
 } from "./interactive-onboarding.js";
 export { createAutoFlow, renderAutoFlowMarkdown, writeAutoFlowOutput } from "./auto-flow.js";
 export { createApplyPlan, renderApplyPlanMarkdown, writeApplyPlanOutput } from "./apply-plan.js";
+export { createAgentOrchestrator, renderAgentOrchestratorMarkdown, writeAgentOrchestratorOutput } from "./agent-orchestrator.js";
+export { createAgentResume, renderAgentResumeMarkdown, writeAgentResumeOutput } from "./agent-resume.js";
 export { createAgentBatchExecutor, renderAgentBatchExecutorMarkdown, writeAgentBatchExecutorOutput } from "./agent-batch-executor.js";
 export { createAgentCheckpoint, renderAgentCheckpointMarkdown, writeAgentCheckpointOutput } from "./agent-checkpoint.js";
 export { createAgentDecisionLog, renderAgentDecisionLogMarkdown, writeAgentDecisionLogOutput } from "./agent-decision-log.js";

package/src/skills.js

@@ -5,6 +5,8 @@ import { getPackageRoot } from "./paths.js";
 const SKILL_ORDER = [
   "geo-ai-search-optimization",
   "geo-ai-search-optimization-auto-flow",
+  "geo-ai-search-optimization-agent-orchestrator",
+  "geo-ai-search-optimization-agent-resume",
   "geo-ai-search-optimization-agent-session",
   "geo-ai-search-optimization-agent-runbook",
   "geo-ai-search-optimization-agent-executor",
@@ -29,6 +31,8 @@ const SKILL_ORDER = [
 const SKILL_CATEGORY = {
   "geo-ai-search-optimization": "core",
   "geo-ai-search-optimization-auto-flow": "routing",
+  "geo-ai-search-optimization-agent-orchestrator": "routing",
+  "geo-ai-search-optimization-agent-resume": "routing",
   "geo-ai-search-optimization-agent-session": "routing",
   "geo-ai-search-optimization-agent-runbook": "execution",
   "geo-ai-search-optimization-agent-executor": "execution",
@@ -171,6 +175,8 @@ export function renderBundledSkillsMarkdown(bundle) {
     "## 推荐理解顺序",
     "",
     "- 先看核心 GEO skill。",
+    "- 如果你只想让 agent 立刻知道现在唯一该跑哪条命令，先跑 agent-orchestrator。",
+    "- 如果工作中断后要从最近一个可靠恢复点继续，先跑 agent-resume。",
     "- 如果 agent 需要自动选 skill，先跑 auto-flow。",
     "- 如果要给 agent 明确步骤，继续进入 agent-session。",
     "- 如果要给 agent 一份执行手册和检查表，再进入 agent-runbook。",