geo-ai-search-optimization 1.2.19 → 1.3.0

package/README.md

@@ -84,6 +84,26 @@ geo-ai-search-optimization agent-resume ./reports/agent-playbook-pack.json --for
 - 恢复后下一条是什么
 - 可直接复制给 agent 的 resume prompt
 
+## Agent Continue 命令
+
+如果你希望 agent 不只知道从哪里恢复，还要知道这一轮做完之后该更新哪些状态工件，可以直接用 `agent-continue`：
+
+```bash
+geo-ai-search-optimization agent-continue ./your-site
+geo-ai-search-optimization agent-continue ./reports/agent-playbook-pack.json
+geo-ai-search-optimization agent-continue ./reports/agent-resume.json --format json --out ./reports/agent-continue.json
+```
+
+它会输出：
+
+- 这一轮怎么继续
+- 现在先执行哪条命令
+- 这轮的 do-now checklist
+- 执行后先验证什么
+- 完成后更新哪些工件
+- 可以进入收尾时跑什么
+- 可直接复制给 agent 的 continue prompt
+
 ## Auto Flow 命令
 
 如果你希望 agent 不用自己判断现在该用哪个 skill、该跑哪个命令，可以直接用 `auto-flow`：
@@ -704,6 +724,7 @@ 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 agent-continue ./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
@@ -785,6 +806,23 @@ geo-ai-search-optimization help
 - 输出 do-now checklist、stop checklist、success checklist、验证命令和回报模板
 - 新增 `geo-ai-search-optimization-agent-executor` skill
 
+## New in 1.3.0
+
+- 正式进入 `1.3` 主线，把 agent-first 的执行闭环收敛成更明确的继续入口
+- 新增 `agent-continue`
+- 把 `agent-resume` 再推进成“继续这一轮并回写状态工件”的微闭环入口
+- 输出 `continue_now`、`validate_after`、`update_artifacts`、`closeout_when_ready`、`report_back`
+- `auto-flow`、`agent-session` 已能把 `playbook-pack / agent-resume / agent-continue` 统一接成继续链
+- 新增 `geo-ai-search-optimization-agent-continue` skill
+
+## New in 1.2.20
+
+- 新增 `agent-continue`
+- 把 `agent-resume` 再推进成“继续这一轮并回写状态工件”的微闭环入口
+- 输出 `continue_now`、`validate_after`、`update_artifacts`、`closeout_when_ready`、`report_back`
+- `auto-flow`、`agent-session` 已能把 `playbook-pack / agent-resume / agent-continue` 统一接成继续链
+- 新增 `geo-ai-search-optimization-agent-continue` skill
+
 ## New in 1.2.19
 
 - 新增 `agent-resume`
@@ -1040,6 +1078,7 @@ The installed package now includes a bundled GEO skill pack, including:
 - `geo-ai-search-optimization-auto-flow`
 - `geo-ai-search-optimization-agent-orchestrator`
 - `geo-ai-search-optimization-agent-resume`
+- `geo-ai-search-optimization-agent-continue`
 - `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.19",
+  "version": "1.3.0",
   "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

@@ -52,6 +52,16 @@ Best for:
 - 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-continue`
+
+Use this when the next agent should not only resume, but also finish one execution round and immediately write the new state back into GEO artifacts.
+
+Best for:
+
+- continuing the current packet and then updating status-board, checkpoint, or decision-log style artifacts
+- turning a resume point into a one-round execution loop
+- giving the next agent one execution command, one validation set, and one writeback list
+
 ### `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-continue/SKILL.md

@@ -0,0 +1,24 @@
+---
+name: geo-ai-search-optimization-agent-continue
+description: Continue one GEO execution round from a reliable recovery point and write the new state back into GEO artifacts. Use when an agent, PM, or workflow already has a GEO resume point, playbook pack, decision log, status board, or similar artifact and needs the next execution command, validation steps, state writeback commands, and closeout path for this round.
+---
+
+# GEO Agent Continue
+
+Use this skill when the next agent should continue one round, not restart or over-plan.
+
+`GEO = Generative Engine Optimization`
+
+## What it does
+
+- turns a GEO resume point into one concrete execution round
+- tells the next agent what to run now
+- lists what to validate after the round
+- shows which GEO status artifacts should be updated next
+- keeps the round connected to closeout commands when the work is ready
+
+## Best use
+
+- when GEO work already has a current packet and should keep moving
+- when the next agent must update status-board, checkpoint, or decision-log after execution
+- when PM wants one clean “do this round, then write back state” artifact

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

@@ -0,0 +1,4 @@
+interface:
+  display_name: "GEO Agent Continue"
+  short_description: "Continue one GEO round and write status back"
+  default_prompt: "Use $geo-ai-search-optimization-agent-continue to continue this GEO round from the latest reliable point, run the next execution command, validate the result, and list which GEO status artifacts must be updated afterward."

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

@@ -13,34 +13,35 @@ Treat this tool as a PM-friendly GEO workflow for websites.
 
 `GEO = Generative Engine Optimization`
 
-The package is best explained as twenty-six layers:
+The package is best explained as twenty-seven 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
+3. `agent-continue`: continue this round and write status artifacts back after execution
+4. `auto-flow`: auto-select the next skill and command chain
+5. `agent-session`: build a runnable session for the next agent
+6. `agent-runbook`: execution manual and checklist for the next agent
+7. `agent-executor`: choose one packet to execute right now
+8. `agent-batch-executor`: queue the first few packets, but still advance one packet at a time
+9. `agent-progress-tracker`: track which packet is done, which one is active, and what comes next
+10. `agent-status-board`: turn the execution state into a board view for PM and agents
+11. `agent-checkpoint`: freeze the current round into a continue / unblock / closeout decision
+12. `agent-decision-log`: preserve why each round continued, paused, or closed out
+13. `agent-retrospective`: explain multi-round patterns, lessons, and next-round advice
+14. `agent-playbook-pack`: compress retrospective, decision history, and handoff into one resume entrypoint
+15. `skills`: inspect the bundled skill package
+16. `onboard-url` / `onboard`: first look
+17. `scan`: raw signal check
+18. `audit` / `report`: diagnosis
+19. `fix-plan` / `owner-board`: execution planning
+20. `agent-handoff`: agent takeover package
+21. `apply-plan`: execution loop
+22. `completion-report`: closeout
+23. `handoff-bundle`: all-in-one package
+24. `share-pack`: audience-ready delivery
+25. `export-pack`: folder export
+26. `html-pack` / `publish-pack`: browsable and final delivery output
+27. `pm-brief` / `roadmap`: stakeholder alignment
 
 ## Recommended command order
 
@@ -49,6 +50,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 agent-continue 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
@@ -70,6 +72,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 agent-continue ./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
@@ -100,6 +103,7 @@ npx geo-ai-search-optimization roadmap ./your-site
 
 - `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
+- `agent-continue`: continue the current round, validate it, and tell the next agent which state artifacts to update right after execution
 - `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
@@ -137,6 +141,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 next agent needs one round of execution plus status writeback, move them to `agent-continue`
 - 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-continue.js

@@ -0,0 +1,316 @@
+import { createAgentExecutor } from "./agent-executor.js";
+import { createAgentResume } from "./agent-resume.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-continue 格式：${format}。可选值：${Array.from(VALID_FORMATS).join(", ")}`);
+  }
+  return resolved;
+}
+
+function inferContinueMode(resume, executor) {
+  if (resume.resume_mode === "needs-context") {
+    return "needs-context";
+  }
+  if (
+    resume.resume_mode === "resume-closeout" ||
+    /\b(completion-report|meeting-pack|publish-pack)\b/.test(resume.resume_command || "")
+  ) {
+    return "closeout-loop";
+  }
+  if (executor?.selectedPacket) {
+    return "single-packet-loop";
+  }
+  if (/\bagent-batch-executor\b/.test(resume.resume_command || "")) {
+    return "batch-loop";
+  }
+  if (/\b(agent-status-board|agent-progress-tracker|agent-checkpoint|agent-decision-log)\b/.test(resume.resume_command || "")) {
+    return "tracking-loop";
+  }
+  return "workflow-loop";
+}
+
+async function tryCreateExecutor(resume) {
+  if (!resume?.source || !resume?.currentPacket?.id) {
+    return null;
+  }
+
+  try {
+    return await createAgentExecutor(resume.source, {
+      format: "json",
+      taskId: resume.currentPacket.id
+    });
+  } catch {
+    return null;
+  }
+}
+
+function buildContinueNow(resume, executor) {
+  if (executor?.selectedPacket) {
+    return `geo-ai-search-optimization agent-executor ${resume.source} --task ${executor.selectedPacket.id}`;
+  }
+  return resume.resume_command;
+}
+
+function buildContinueSummary(mode, resume, executor) {
+  if (mode === "needs-context") {
+    return "当前还缺恢复所需上下文，先补网址、目录或 GEO 工件，再继续这一轮。";
+  }
+  if (mode === "closeout-loop") {
+    return "当前最稳的继续方式是进入收尾与交付，不要重新打开新的执行包。";
+  }
+  if (mode === "single-packet-loop" && executor?.selectedPacket) {
+    return `这一轮先把 ${executor.selectedPacket.id} 做完，完成后马上回写状态与决策工件。`;
+  }
+  if (mode === "batch-loop") {
+    return "当前适合沿着批次继续，但每次仍然只推进一包，再更新状态。";
+  }
+  if (mode === "tracking-loop") {
+    return "当前更适合先校准状态，再决定是否进入下一包或收尾。";
+  }
+  return "当前应先按既有恢复命令继续，再根据结果更新状态，不要重新规划整条链。";
+}
+
+function buildDoNowChecklist(mode, resume, executor, continueNow) {
+  if (mode === "needs-context") {
+    return [...resume.contextNeeded];
+  }
+
+  if (executor?.selectedPacket) {
+    return Array.from(
+      new Set([
+        ...executor.doNowChecklist,
+        "完成这一包后，立刻更新状态看板和决策历史，不要只做代码动作不回写工件。"
+      ])
+    );
+  }
+
+  const items = [`先运行：${continueNow}`];
+  if (resume.currentPacket) {
+    items.push(`继续围绕当前包 ${resume.currentPacket.id} 推进，不要中途切到别的包。`);
+  }
+  if (resume.after_resume) {
+    items.push(`这一步完成后，继续运行：${resume.after_resume}`);
+  }
+
+  return items;
+}
+
+function buildValidateAfter(mode, resume, executor) {
+  if (mode === "needs-context") {
+    return ["确认已经拿到网址、目录或 GEO JSON 工件，再重新进入继续链。"];
+  }
+
+  if (executor?.validationCommands?.length) {
+    return Array.from(new Set(executor.validationCommands));
+  }
+
+  const items = [];
+  if (resume.expected_artifact) {
+    items.push(`确认这一步真的产出了：${resume.expected_artifact}`);
+  }
+  if (mode === "closeout-loop") {
+    items.push("确认收尾输出里已经明确写出：已完成、未完成、待验证、下一轮任务。");
+  } else {
+    items.push("确认这一步没有把恢复链跑偏，也没有跳过当前包。");
+  }
+
+  return items;
+}
+
+function buildUpdateArtifacts(mode, resume) {
+  if (mode === "needs-context" || !resume.source) {
+    return [];
+  }
+
+  if (mode === "closeout-loop") {
+    return [
+      `geo-ai-search-optimization completion-report ${resume.source}`,
+      `geo-ai-search-optimization meeting-pack ${resume.source}`,
+      `geo-ai-search-optimization publish-pack ${resume.source}`
+    ];
+  }
+
+  return [
+    `geo-ai-search-optimization agent-status-board ${resume.source}`,
+    `geo-ai-search-optimization agent-checkpoint ${resume.source}`,
+    `geo-ai-search-optimization agent-decision-log ${resume.source}`
+  ];
+}
+
+function buildCloseoutWhenReady(resume) {
+  if (!resume.source) {
+    return [];
+  }
+
+  return [
+    `geo-ai-search-optimization completion-report ${resume.source}`,
+    `geo-ai-search-optimization handoff-bundle ${resume.source}`,
+    `geo-ai-search-optimization publish-pack ${resume.source}`
+  ];
+}
+
+function buildReportBack(mode, executor) {
+  if (executor?.userReplyTemplate) {
+    return executor.userReplyTemplate;
+  }
+
+  if (mode === "closeout-loop") {
+    return [
+      "这轮我已经进入收尾阶段。",
+      "我整理了什么：",
+      "- ",
+      "我确认了哪些剩余风险：",
+      "- ",
+      "下一轮建议：",
+      "- "
+    ].join("\n");
+  }
+
+  return [
+    "这轮我已经从最近一个可靠恢复点继续。",
+    "我先做了什么：",
+    "- ",
+    "我验证了什么：",
+    "- ",
+    "我接着更新了哪些状态工件：",
+    "- ",
+    "下一步：",
+    "- "
+  ].join("\n");
+}
+
+function buildContinuePrompt(artifact) {
+  const lines = [
+    "你现在进入 GEO Agent Continue 模式。",
+    `当前输入：${artifact.source}`,
+    `继续模式：${artifact.continue_mode}`,
+    `继续摘要：${artifact.continue_summary}`,
+    `现在先执行：${artifact.continue_now || "先补上下文"}`
+  ];
+
+  if (artifact.currentPacket) {
+    lines.push(`当前包：${artifact.currentPacket.id}｜${artifact.currentPacket.title}`);
+  }
+  if (artifact.nextPacket) {
+    lines.push(`下一包：${artifact.nextPacket.id}｜${artifact.nextPacket.title}`);
+  }
+  if (artifact.validate_after.length > 0) {
+    lines.push("执行后先验证：");
+    for (const item of artifact.validate_after) {
+      lines.push(`- ${item}`);
+    }
+  }
+  if (artifact.update_artifacts.length > 0) {
+    lines.push("完成这轮后更新这些工件：");
+    for (const item of artifact.update_artifacts) {
+      lines.push(`- ${item}`);
+    }
+  }
+
+  lines.push("不要重新规划整条链。先继续这一轮，再回写状态与决策。");
+  return lines.join("\n");
+}
+
+export async function createAgentContinue(input, options = {}) {
+  const format = normalizeFormat(options.format);
+  const resume = await createAgentResume(input, {
+    format: "json",
+    intent: options.intent
+  });
+  const executor = await tryCreateExecutor(resume);
+  const continueMode = inferContinueMode(resume, executor);
+  const continueNow = buildContinueNow(resume, executor);
+
+  const artifact = {
+    kind: "geo-agent-continue",
+    input,
+    source: resume.source,
+    sourceType: resume.sourceType,
+    artifactKind: resume.kind,
+    format,
+    continue_mode: continueMode,
+    continue_summary: buildContinueSummary(continueMode, resume, executor),
+    continue_now: continueNow,
+    currentPacket: executor?.selectedPacket || resume.currentPacket || null,
+    nextPacket: resume.nextPacket || null,
+    do_now_checklist: buildDoNowChecklist(continueMode, resume, executor, continueNow),
+    validate_after: buildValidateAfter(continueMode, resume, executor),
+    update_artifacts: buildUpdateArtifacts(continueMode, resume),
+    closeout_when_ready: buildCloseoutWhenReady(resume),
+    do_not_restart: resume.do_not_reset,
+    report_back: buildReportBack(continueMode, executor),
+    selectedSkill: {
+      name: "geo-ai-search-optimization-agent-continue",
+      displayName: "GEO Agent Continue",
+      shortDescription: "Continue one GEO round and write status back"
+    },
+    resume,
+    executor,
+    continue_prompt: ""
+  };
+
+  artifact.continue_prompt = buildContinuePrompt(artifact);
+  return artifact;
+}
+
+export function renderAgentContinueMarkdown(artifact) {
+  const lines = [
+    "# GEO Agent Continue",
+    "",
+    `- 输入：\`${artifact.source}\``,
+    `- 输入类型：\`${artifact.sourceType}\``,
+    `- 继续模式：\`${artifact.continue_mode}\``,
+    `- 当前建议 skill：\`${artifact.selectedSkill.name}\``,
+    "",
+    "## 这一轮怎么继续",
+    "",
+    `- ${artifact.continue_summary}`,
+    `- 现在先执行：\`${artifact.continue_now || "先补上下文"}\``
+  ];
+
+  if (artifact.currentPacket) {
+    lines.push("", "## 当前包", "", `- ${artifact.currentPacket.id}｜${artifact.currentPacket.title}`);
+  }
+  if (artifact.nextPacket) {
+    lines.push("", "## 下一包", "", `- ${artifact.nextPacket.id}｜${artifact.nextPacket.title}`);
+  }
+
+  lines.push("", "## 现在先做什么", "");
+  for (const item of artifact.do_now_checklist) {
+    lines.push(`- ${item}`);
+  }
+
+  lines.push("", "## 执行后先验证", "");
+  for (const item of artifact.validate_after) {
+    lines.push(`- ${item}`);
+  }
+
+  lines.push("", "## 这轮完成后更新哪些工件", "");
+  for (const item of artifact.update_artifacts) {
+    lines.push(`- \`${item}\``);
+  }
+
+  lines.push("", "## 可以进入收尾时跑什么", "");
+  for (const item of artifact.closeout_when_ready) {
+    lines.push(`- \`${item}\``);
+  }
+
+  lines.push("", "## 不要重启整条链", "");
+  for (const item of artifact.do_not_restart) {
+    lines.push(`- ${item}`);
+  }
+
+  lines.push("", "## 回报模板", "", "```text", artifact.report_back, "```");
+  lines.push("", "## 可直接复制给 Agent 的 Continue Prompt", "", "```text", artifact.continue_prompt, "```");
+
+  return `${lines.join("\n")}\n`;
+}
+
+export async function writeAgentContinueOutput(outputPath, content) {
+  return writeScanOutput(outputPath, content);
+}

package/src/agent-resume.js

@@ -237,12 +237,14 @@ export async function createAgentResume(input, options = {}) {
   const resumeCommand = buildResumeCommand(orchestrator, playbookPack);
   const afterResume = buildAfterResume(orchestrator, playbookPack, resumeCommand);
   const expectedArtifact = buildExpectedArtifact(orchestrator, playbookPack, resumeCommand);
+  const source = playbookPack?.source || orchestrator.source;
+  const sourceType = playbookPack?.sourceType || orchestrator.sourceType;
 
   const resume = {
     kind: "geo-agent-resume",
     input,
-    source: orchestrator.source,
-    sourceType: orchestrator.sourceType,
+    source,
+    sourceType,
     artifactKind: orchestrator.artifactKind,
     format,
     resume_mode: inferResumeMode(orchestrator, playbookPack),

package/src/agent-session.js

@@ -49,6 +49,9 @@ function inferSkillForCommand(commandName, flow) {
   if (commandName === "agent-resume") {
     return "geo-ai-search-optimization-agent-resume";
   }
+  if (commandName === "agent-continue") {
+    return "geo-ai-search-optimization-agent-continue";
+  }
   if (commandName === "agent-runbook") {
     return "geo-ai-search-optimization-agent-runbook";
   }
@@ -119,6 +122,8 @@ function inferStepPurpose(commandName, flow) {
       return "快速建立从 0 到 1 的执行顺序。";
     case "agent-resume":
       return "从最近一个可靠恢复点继续，而不是把整条 GEO 链重新跑一遍。";
+    case "agent-continue":
+      return "继续当前这一轮，并把状态、检查点和决策工件一并回写。";
     case "onboard":
     case "onboard-url":
       return "先从网址或引导流程拿到首轮 GEO 判断。";
@@ -198,6 +203,8 @@ function inferExpectedArtifact(commandName) {
       return "agent 交接工件";
     case "agent-resume":
       return "agent 恢复入口工件";
+    case "agent-continue":
+      return "agent 单轮继续工件";
     case "agent-runbook":
       return "agent 执行手册";
     case "agent-executor":
@@ -248,6 +255,9 @@ function buildStepInstructions(parsedCommand, flow) {
   if (parsedCommand.commandName === "agent-resume") {
     lines.push("先确认恢复点、当前包和不要重置的内容，再继续执行。");
   }
+  if (parsedCommand.commandName === "agent-continue") {
+    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-continue|continue this round|继续这轮|继续当前轮次|回写状态后继续)/i.test(normalized)) {
+    return "execute";
+  }
   if (/(agent-resume|resume|恢复继续|从中断处继续|接着上次继续|从最近恢复点继续)/i.test(normalized)) {
     return "execute";
   }
@@ -177,6 +180,9 @@ function resolveEffectiveIntent(intent, detected) {
   if (detected.artifactKind === "geo-agent-resume") {
     return detected.parsed?.resume_mode === "resume-closeout" ? "closeout" : "execute";
   }
+  if (detected.artifactKind === "geo-agent-continue") {
+    return detected.parsed?.continue_mode === "closeout-loop" ? "closeout" : "execute";
+  }
   if (
     [
       "geo-share-pack",
@@ -431,20 +437,23 @@ function buildCommandChain(detected, intent) {
       const baseSource = detected.parsed?.source || source;
       return detected.parsed?.playbookStatus === "closeout-ready"
         ? [
-            `geo-ai-search-optimization agent-resume ${source}`,
+            `geo-ai-search-optimization agent-continue ${source}`,
             `geo-ai-search-optimization meeting-pack ${baseSource}`,
             `geo-ai-search-optimization publish-pack ${baseSource}`
           ]
         : [
-            `geo-ai-search-optimization agent-resume ${source}`,
+            `geo-ai-search-optimization agent-continue ${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);
+      return [`geo-ai-search-optimization agent-continue ${source}`];
+    }
+    case "geo-agent-continue": {
+      const continueNow = detected.parsed?.continue_now;
+      const updates = Array.isArray(detected.parsed?.update_artifacts) ? detected.parsed.update_artifacts : [];
+      return [continueNow, ...updates.slice(0, 2)].filter(Boolean);
     }
     case "geo-apply-plan":
       return [
@@ -527,7 +536,8 @@ function pickSkillName(detected, intent) {
     case "geo-agent-decision-log":
     case "geo-agent-playbook-pack":
     case "geo-agent-resume":
-      return "geo-ai-search-optimization-agent-resume";
+    case "geo-agent-continue":
+      return "geo-ai-search-optimization-agent-continue";
     case "geo-agent-retrospective":
       return "geo-ai-search-optimization-agent-retrospective";
     case "geo-completion-report":
@@ -572,6 +582,7 @@ function buildSecondarySkillNames(primarySkill, intent, detected) {
       "geo-agent-checkpoint",
       "geo-agent-decision-log",
       "geo-agent-resume",
+      "geo-agent-continue",
       "geo-agent-playbook-pack",
       "geo-apply-plan"
     ].includes(
@@ -579,6 +590,7 @@ function buildSecondarySkillNames(primarySkill, intent, detected) {
     )
   ) {
     names.add("geo-ai-search-optimization-agent-resume");
+    names.add("geo-ai-search-optimization-agent-continue");
     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");
@@ -600,6 +612,9 @@ function buildSecondarySkillNames(primarySkill, intent, detected) {
 }
 
 function buildStage(intent, detected) {
+  if (detected.artifactKind === "geo-agent-continue") {
+    return "继续执行";
+  }
   if (detected.artifactKind === "geo-agent-resume") {
     return "恢复继续";
   }
@@ -624,6 +639,7 @@ function buildStage(intent, detected) {
       "geo-agent-checkpoint",
       "geo-agent-decision-log",
       "geo-agent-resume",
+      "geo-agent-continue",
       "geo-agent-playbook-pack",
       "geo-agent-retrospective",
       "geo-apply-plan",
@@ -644,6 +660,7 @@ function buildStage(intent, detected) {
       "geo-agent-checkpoint",
       "geo-agent-decision-log",
       "geo-agent-resume",
+      "geo-agent-continue",
       "geo-agent-playbook-pack",
       "geo-agent-retrospective",
       "geo-apply-plan",
@@ -732,8 +749,11 @@ function buildNextAction(detected, intent, commands) {
     return `先运行 \`${commands[0]}\` 生成适合外发或交接的结果。`;
   }
   if (intent === "execute") {
+    if (detected.artifactKind === "geo-agent-continue") {
+      return `先运行 \`${commands[0]}\`，继续当前这一轮，并把状态与决策工件一起回写。`;
+    }
     if (detected.artifactKind === "geo-agent-resume") {
-      return `先运行 \`${commands[0]}\`，从最近一个可靠恢复点继续，不要把整条 GEO 链重新跑一遍。`;
+      return `先运行 \`${commands[0]}\`，把恢复点推进成一轮真正的继续闭环。`;
     }
     if (detected.artifactKind === "geo-agent-progress-tracker") {
       return `先运行 \`${commands[0]}\`，先确认最近一个可靠恢复点，再继续当前执行包。`;

package/src/cli.js

@@ -7,6 +7,11 @@ import {
   renderAgentBatchExecutorMarkdown,
   writeAgentBatchExecutorOutput
 } from "./agent-batch-executor.js";
+import {
+  createAgentContinue,
+  renderAgentContinueMarkdown,
+  writeAgentContinueOutput
+} from "./agent-continue.js";
 import { createAgentExecutor, renderAgentExecutorMarkdown, writeAgentExecutorOutput } from "./agent-executor.js";
 import { createAgentHandoff, renderAgentHandoffMarkdown, writeAgentHandoffOutput } from "./agent-handoff.js";
 import {
@@ -88,6 +93,7 @@ function printHelp() {
       "  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 agent-continue <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>]",
@@ -241,6 +247,32 @@ async function handleAgentResume(args) {
   process.stdout.write(renderedOutput);
 }
 
+async function handleAgentContinue(args) {
+  const input = args.find((value) => !value.startsWith("-"));
+  if (!input) {
+    throw new Error("agent-continue 需要一个输入值，可以是任务描述、项目路径、网站网址或已导出的工件");
+  }
+
+  const format = getFlagValue(args, "--format") || (hasFlag(args, "--json") ? "json" : undefined);
+  const artifact = await createAgentContinue(input, {
+    intent: getFlagValue(args, "--intent"),
+    format
+  });
+  const outputJson = artifact.format === "json";
+  const renderedOutput = outputJson
+    ? `${JSON.stringify(artifact, null, 2)}\n`
+    : renderAgentContinueMarkdown(artifact);
+
+  const outputPath = getFlagValue(args, "--out");
+  if (outputPath) {
+    const resolvedOutputPath = await writeAgentContinueOutput(outputPath, renderedOutput);
+    process.stdout.write(`已保存 agent-continue 结果：${resolvedOutputPath}\n`);
+    return;
+  }
+
+  process.stdout.write(renderedOutput);
+}
+
 async function handleAgentSession(args) {
   const input = args.find((value) => !value.startsWith("-"));
   if (!input) {
@@ -1067,6 +1099,11 @@ export async function runCli(args = []) {
     return;
   }
 
+  if (command === "agent-continue") {
+    await handleAgentContinue(rest);
+    return;
+  }
+
   if (command === "agent-session") {
     await handleAgentSession(rest);
     return;

package/src/index.js

@@ -7,6 +7,7 @@ export {
 } from "./interactive-onboarding.js";
 export { createAutoFlow, renderAutoFlowMarkdown, writeAutoFlowOutput } from "./auto-flow.js";
 export { createApplyPlan, renderApplyPlanMarkdown, writeApplyPlanOutput } from "./apply-plan.js";
+export { createAgentContinue, renderAgentContinueMarkdown, writeAgentContinueOutput } from "./agent-continue.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";

package/src/skills.js

@@ -7,6 +7,7 @@ const SKILL_ORDER = [
   "geo-ai-search-optimization-auto-flow",
   "geo-ai-search-optimization-agent-orchestrator",
   "geo-ai-search-optimization-agent-resume",
+  "geo-ai-search-optimization-agent-continue",
   "geo-ai-search-optimization-agent-session",
   "geo-ai-search-optimization-agent-runbook",
   "geo-ai-search-optimization-agent-executor",
@@ -33,6 +34,7 @@ const SKILL_CATEGORY = {
   "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-continue": "routing",
   "geo-ai-search-optimization-agent-session": "routing",
   "geo-ai-search-optimization-agent-runbook": "execution",
   "geo-ai-search-optimization-agent-executor": "execution",
@@ -177,6 +179,7 @@ export function renderBundledSkillsMarkdown(bundle) {
     "- 先看核心 GEO skill。",
     "- 如果你只想让 agent 立刻知道现在唯一该跑哪条命令，先跑 agent-orchestrator。",
     "- 如果工作中断后要从最近一个可靠恢复点继续，先跑 agent-resume。",
+    "- 如果你希望 agent 不只恢复，还要拿到这一轮继续后的状态回写动作，继续跑 agent-continue。",
     "- 如果 agent 需要自动选 skill，先跑 auto-flow。",
     "- 如果要给 agent 明确步骤，继续进入 agent-session。",
     "- 如果要给 agent 一份执行手册和检查表，再进入 agent-runbook。",