geo-ai-search-optimization 1.2.18 → 1.2.19

package/README.md

@@ -63,6 +63,27 @@ geo-ai-search-optimization agent-orchestrator ./reports/agent-playbook-pack.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`：
@@ -682,6 +703,7 @@ 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
@@ -763,6 +785,14 @@ 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`
@@ -1009,6 +1039,7 @@ 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.18",
+  "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

@@ -42,6 +42,16 @@ Best for:
 - 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-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,33 +13,34 @@ Treat this tool as a PM-friendly GEO workflow for websites.
 
 `GEO = Generative Engine Optimization`
 
-The package is best explained as twenty-five layers:
+The package is best explained as twenty-six layers:
 
 1. `agent-orchestrator`: choose the one next GEO command to run right now
-2. `auto-flow`: auto-select the next skill and command chain
-3. `agent-session`: build a runnable session for the next agent
-4. `agent-runbook`: execution manual and checklist for the next agent
-5. `agent-executor`: choose one packet to execute right now
-6. `agent-batch-executor`: queue the first few packets, but still advance one packet at a time
-7. `agent-progress-tracker`: track which packet is done, which one is active, and what comes next
-8. `agent-status-board`: turn the execution state into a board view for PM and agents
-9. `agent-checkpoint`: freeze the current round into a continue / unblock / closeout decision
-10. `agent-decision-log`: preserve why each round continued, paused, or closed out
-11. `agent-retrospective`: explain multi-round patterns, lessons, and next-round advice
-12. `agent-playbook-pack`: compress retrospective, decision history, and handoff into one resume entrypoint
-13. `skills`: inspect the bundled skill package
-14. `onboard-url` / `onboard`: first look
-15. `scan`: raw signal check
-16. `audit` / `report`: diagnosis
-17. `fix-plan` / `owner-board`: execution planning
-18. `agent-handoff`: agent takeover package
-19. `apply-plan`: execution loop
-20. `completion-report`: closeout
-21. `handoff-bundle`: all-in-one package
-22. `share-pack`: audience-ready delivery
-23. `export-pack`: folder export
-24. `html-pack` / `publish-pack`: browsable and final delivery output
-25. `pm-brief` / `roadmap`: stakeholder alignment
+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
 
@@ -47,6 +48,7 @@ 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
@@ -67,6 +69,7 @@ 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
@@ -96,6 +99,7 @@ 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
@@ -132,6 +136,7 @@ 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-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

@@ -21,6 +21,7 @@ import {
   renderAgentOrchestratorMarkdown,
   writeAgentOrchestratorOutput
 } from "./agent-orchestrator.js";
+import { createAgentResume, renderAgentResumeMarkdown, writeAgentResumeOutput } from "./agent-resume.js";
 import {
   createAgentPlaybookPack,
   renderAgentPlaybookPackMarkdown,
@@ -86,6 +87,7 @@ function printHelp() {
       "  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>]",
@@ -215,6 +217,30 @@ async function handleAgentOrchestrator(args) {
   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) {
@@ -1036,6 +1062,11 @@ export async function runCli(args = []) {
     return;
   }
 
+  if (command === "agent-resume") {
+    await handleAgentResume(rest);
+    return;
+  }
+
   if (command === "agent-session") {
     await handleAgentSession(rest);
     return;

package/src/index.js

@@ -8,6 +8,7 @@ export {
 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

@@ -6,6 +6,7 @@ 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",
@@ -31,6 +32,7 @@ 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",
@@ -174,6 +176,7 @@ export function renderBundledSkillsMarkdown(bundle) {
     "",
     "- 先看核心 GEO skill。",
     "- 如果你只想让 agent 立刻知道现在唯一该跑哪条命令，先跑 agent-orchestrator。",
+    "- 如果工作中断后要从最近一个可靠恢复点继续，先跑 agent-resume。",
     "- 如果 agent 需要自动选 skill，先跑 auto-flow。",
     "- 如果要给 agent 明确步骤，继续进入 agent-session。",
     "- 如果要给 agent 一份执行手册和检查表，再进入 agent-runbook。",