geo-ai-search-optimization 1.2.18 → 1.2.20

package/README.md

@@ -63,6 +63,47 @@ 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
+
+## 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`：
@@ -682,6 +723,8 @@ 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 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
@@ -763,6 +806,22 @@ geo-ai-search-optimization help
 - 输出 do-now checklist、stop checklist、success checklist、验证命令和回报模板
 - 新增 `geo-ai-search-optimization-agent-executor` 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`
+- 把 `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 +1068,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-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.18",
+  "version": "1.2.20",
   "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,26 @@ 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-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-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,35 @@ 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-seven 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. `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
 
@@ -47,6 +49,8 @@ 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
@@ -67,6 +71,8 @@ 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
@@ -96,6 +102,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
+- `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
@@ -132,6 +140,8 @@ 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);
+}