geo-ai-search-optimization 1.2.13 → 1.2.15

package/src/agent-decision-log.js

@@ -0,0 +1,368 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { createAgentCheckpoint } from "./agent-checkpoint.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-decision-log 格式：${format}。可选值：${Array.from(VALID_FORMATS).join(", ")}`);
+  }
+  return resolved;
+}
+
+async function pathExists(targetPath) {
+  try {
+    await fs.access(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function cloneForFormat(record, format) {
+  if (!record || typeof record !== "object") {
+    return record;
+  }
+
+  return {
+    ...record,
+    format
+  };
+}
+
+function buildEntryId(index) {
+  return `decision-${String(index).padStart(2, "0")}`;
+}
+
+function buildDecisionNote(options) {
+  return options.note || options.decisionNote || null;
+}
+
+function buildRecommendedFocus(checkpoint) {
+  switch (checkpoint.decision) {
+    case "resolve-blockers":
+      return `先解除 ${checkpoint.blockedItems.length || 1} 个阻塞项，再继续当前包。`;
+    case "move-to-closeout":
+      return "进入复盘、交接和交付，不要再扩展新任务。";
+    case "continue-current-packet":
+      return `继续推进当前包 ${checkpoint.currentPacket?.id || ""}，不要切换任务。`.trim();
+    case "start-first-packet":
+      return `启动第一包 ${checkpoint.currentPacket?.id || ""}，建立第一轮执行节奏。`.trim();
+    default:
+      return "先补执行上下文，再进入下一轮。";
+  }
+}
+
+function buildLogSummary(entries, checkpoint) {
+  if (entries.length === 1) {
+    return `目前已有 1 次阶段决策，最新结论是 ${checkpoint.decision}。`;
+  }
+
+  return `目前已累计 ${entries.length} 次阶段决策，最新结论是 ${checkpoint.decision}，当前重点是：${buildRecommendedFocus(checkpoint)}`;
+}
+
+function buildEntry(checkpoint, note, index) {
+  return {
+    id: buildEntryId(index),
+    createdAt: new Date().toISOString(),
+    checkpointType: checkpoint.checkpointType,
+    decision: checkpoint.decision,
+    boardStatus: checkpoint.boardStatus,
+    progressPercent: checkpoint.progressPercent,
+    decisionReason: checkpoint.decisionReason,
+    currentPacket: checkpoint.currentPacket
+      ? {
+          id: checkpoint.currentPacket.id,
+          title: checkpoint.currentPacket.title,
+          owner: checkpoint.currentPacket.owner,
+          priority: checkpoint.currentPacket.priority
+        }
+      : null,
+    nextPacket: checkpoint.nextPacket
+      ? {
+          id: checkpoint.nextPacket.id,
+          title: checkpoint.nextPacket.title,
+          owner: checkpoint.nextPacket.owner,
+          priority: checkpoint.nextPacket.priority
+        }
+      : null,
+    blockedItems: checkpoint.blockedItems.map((item) => ({
+      id: item.id,
+      title: item.title,
+      owner: item.owner,
+      priority: item.priority
+    })),
+    suggestedNextCommand: checkpoint.suggestedNextCommand,
+    alternateCommands: checkpoint.alternateCommands,
+    handoffNote: checkpoint.handoffNote,
+    note: note || null
+  };
+}
+
+function buildLogPrompt(log) {
+  const latest = log.latestCheckpoint;
+  const lines = [
+    "你现在进入 GEO 决策历史模式。",
+    `当前输入：${log.source}`,
+    `已累计决策次数：${log.totalEntries}`,
+    `最新检查点类型：${latest.checkpointType}`,
+    `最新决策：${latest.decision}`,
+    `最新决策原因：${latest.decisionReason}`,
+    `当前重点：${log.recommendedFocus}`
+  ];
+
+  if (latest.currentPacket) {
+    lines.push(`当前包：${latest.currentPacket.id}｜${latest.currentPacket.title}`);
+  }
+  if (latest.nextPacket) {
+    lines.push(`下一包：${latest.nextPacket.id}｜${latest.nextPacket.title}`);
+  }
+  if (latest.blockedItems.length > 0) {
+    lines.push(`当前阻塞：${latest.blockedItems.map((item) => item.title).join("；")}`);
+  }
+
+  lines.push("请先说明最近几轮是如何决策的，再给出这一轮应该继续、解阻还是收尾。");
+  lines.push("最后输出下一步命令、交接说明，以及是否需要追加一条新的决策记录。");
+  return lines.join("\n");
+}
+
+async function readJsonIfExists(targetPath) {
+  if (!(await pathExists(targetPath))) {
+    return null;
+  }
+
+  const raw = await fs.readFile(targetPath, "utf8");
+  return JSON.parse(raw);
+}
+
+async function resolveExistingLog(options = {}) {
+  const appendFrom = options.appendFrom || options.appendPath;
+  if (!appendFrom) {
+    return null;
+  }
+
+  const resolvedPath = path.resolve(appendFrom);
+  const parsed = await readJsonIfExists(resolvedPath);
+  if (!parsed || parsed.kind !== "geo-agent-decision-log") {
+    throw new Error(`append-from 需要指向一个 geo-agent-decision-log JSON 工件：${resolvedPath}`);
+  }
+
+  return {
+    path: resolvedPath,
+    log: parsed
+  };
+}
+
+function shouldReuseDecisionLog(parsed, options = {}) {
+  return (
+    parsed?.kind === "geo-agent-decision-log" &&
+    !options.appendFrom &&
+    !options.appendPath &&
+    !options.currentTaskId &&
+    !options.completedPacketIds &&
+    !options.blockedReasons &&
+    !buildDecisionNote(options)
+  );
+}
+
+function getCheckpointSourceFromLog(parsed, fallbackInput) {
+  return (
+    parsed?.latestCheckpoint?.source ||
+    parsed?.latestCheckpoint?.statusBoard?.source ||
+    parsed?.source ||
+    fallbackInput
+  );
+}
+
+async function resolveCheckpoint(input, options = {}) {
+  const resolvedInput = path.resolve(input);
+  if (await pathExists(resolvedInput)) {
+    try {
+      const raw = await fs.readFile(resolvedInput, "utf8");
+      const parsed = JSON.parse(raw);
+
+      if (shouldReuseDecisionLog(parsed, options)) {
+        return {
+          reuseLog: cloneForFormat(parsed, normalizeFormat(options.format)),
+          checkpoint: parsed.latestCheckpoint || null
+        };
+      }
+
+      if (parsed?.kind === "geo-agent-decision-log" && parsed.latestCheckpoint?.kind === "geo-agent-checkpoint") {
+        const checkpointSource = getCheckpointSourceFromLog(parsed, resolvedInput);
+        const checkpoint = await createAgentCheckpoint(checkpointSource, {
+          format: "json",
+          currentTaskId: options.currentTaskId || parsed.latestCheckpoint.currentPacket?.id,
+          completedPacketIds:
+            options.completedPacketIds != null
+              ? options.completedPacketIds
+              : (parsed.latestCheckpoint.completedPackets || []).map((packet) => packet.id).join(","),
+          blockedReasons:
+            options.blockedReasons != null
+              ? options.blockedReasons
+              : (parsed.latestCheckpoint.blockedItems || []).map((item) => item.title).join(",")
+        });
+
+        return {
+          reuseLog: null,
+          checkpoint
+        };
+      }
+    } catch {
+      // Fall through to checkpoint generation.
+    }
+  }
+
+  return {
+    reuseLog: null,
+    checkpoint: await createAgentCheckpoint(input, {
+      format: "json",
+      currentTaskId: options.currentTaskId,
+      completedPacketIds: options.completedPacketIds,
+      blockedReasons: options.blockedReasons
+    })
+  };
+}
+
+export async function createAgentDecisionLog(input, options = {}) {
+  const format = normalizeFormat(options.format);
+  const existing = await resolveExistingLog(options);
+  const { reuseLog, checkpoint } = await resolveCheckpoint(input, {
+    ...options,
+    format: "json"
+  });
+
+  if (reuseLog) {
+    return reuseLog;
+  }
+
+  if (!checkpoint) {
+    throw new Error("无法从当前输入生成 agent checkpoint，因此不能创建 decision log。");
+  }
+
+  const note = buildDecisionNote(options);
+  const previousEntries = existing?.log?.entries || [];
+  const entries = [
+    ...previousEntries,
+    buildEntry(checkpoint, note, previousEntries.length + 1)
+  ];
+
+  const log = {
+    kind: "geo-agent-decision-log",
+    input,
+    source: checkpoint.source,
+    sourceType: checkpoint.sourceType,
+    artifactKind: checkpoint.kind,
+    format,
+    updatedAt: new Date().toISOString(),
+    totalEntries: entries.length,
+    latestDecision: checkpoint.decision,
+    latestDecisionReason: checkpoint.decisionReason,
+    latestCheckpointType: checkpoint.checkpointType,
+    latestBoardStatus: checkpoint.boardStatus,
+    currentPacket: checkpoint.currentPacket,
+    nextPacket: checkpoint.nextPacket,
+    openBlockers: checkpoint.blockedItems,
+    recommendedFocus: buildRecommendedFocus(checkpoint),
+    logSummary: buildLogSummary(entries, checkpoint),
+    suggestedNextCommand: checkpoint.suggestedNextCommand,
+    alternateCommands: checkpoint.alternateCommands,
+    entries,
+    latestCheckpoint: checkpoint,
+    logPrompt: ""
+  };
+
+  log.logPrompt = buildLogPrompt(log);
+  return log;
+}
+
+export function renderAgentDecisionLogMarkdown(log) {
+  const lines = [
+    "# GEO Agent Decision Log",
+    "",
+    `- 输入：\`${log.source}\``,
+    `- 来源类型：\`${log.sourceType}\``,
+    `- 最新工件类型：\`${log.artifactKind}\``,
+    `- 决策次数：\`${log.totalEntries}\``,
+    `- 最新检查点类型：\`${log.latestCheckpointType}\``,
+    `- 最新状态：\`${log.latestBoardStatus}\``,
+    `- 最新决策：\`${log.latestDecision}\``,
+    `- 当前重点：${log.recommendedFocus}`,
+    `- 总结：${log.logSummary}`,
+    ""
+  ];
+
+  if (log.currentPacket) {
+    lines.push("## 当前包", "", `- ${log.currentPacket.id}｜${log.currentPacket.title}`);
+    lines.push(`- Owner：${log.currentPacket.owner}`);
+    lines.push(`- 优先级：${log.currentPacket.priority}`);
+    lines.push("");
+  }
+
+  if (log.nextPacket) {
+    lines.push("## 下一包", "", `- ${log.nextPacket.id}｜${log.nextPacket.title}`);
+    lines.push(`- Owner：${log.nextPacket.owner}`);
+    lines.push(`- 优先级：${log.nextPacket.priority}`);
+    lines.push("");
+  }
+
+  lines.push("## 当前阻塞", "");
+  if (log.openBlockers.length === 0) {
+    lines.push("- 当前没有阻塞。", "");
+  } else {
+    for (const blocker of log.openBlockers) {
+      lines.push(`- ${blocker.id}｜${blocker.title}`);
+      lines.push(`  - Owner：${blocker.owner}`);
+      lines.push(`  - 优先级：${blocker.priority}`);
+    }
+    lines.push("");
+  }
+
+  lines.push("## 决策时间线", "");
+  for (const entry of [...log.entries].reverse()) {
+    lines.push(`### ${entry.id}`);
+    lines.push("");
+    lines.push(`- 时间：\`${entry.createdAt}\``);
+    lines.push(`- 检查点类型：\`${entry.checkpointType}\``);
+    lines.push(`- 决策：\`${entry.decision}\``);
+    lines.push(`- 状态：\`${entry.boardStatus}\``);
+    lines.push(`- 进度：\`${entry.progressPercent}%\``);
+    lines.push(`- 原因：${entry.decisionReason}`);
+    if (entry.currentPacket) {
+      lines.push(`- 当前包：${entry.currentPacket.id}｜${entry.currentPacket.title}`);
+    }
+    if (entry.nextPacket) {
+      lines.push(`- 下一包：${entry.nextPacket.id}｜${entry.nextPacket.title}`);
+    }
+    if (entry.blockedItems.length > 0) {
+      lines.push(`- 阻塞：${entry.blockedItems.map((item) => item.title).join("；")}`);
+    }
+    if (entry.note) {
+      lines.push(`- 备注：${entry.note}`);
+    }
+    lines.push(`- 建议命令：\`${entry.suggestedNextCommand}\``);
+    lines.push(`- 交接说明：${entry.handoffNote}`);
+    lines.push("");
+  }
+
+  lines.push("## 建议下一步命令", "", `- \`${log.suggestedNextCommand}\``);
+
+  if (log.alternateCommands.length > 0) {
+    lines.push("", "## 备选命令", "");
+    for (const command of log.alternateCommands) {
+      lines.push(`- \`${command}\``);
+    }
+  }
+
+  lines.push("", "## 最新检查点", "", "```text", log.latestCheckpoint.checkpointPrompt, "```");
+  lines.push("", "## 可直接复制给 Agent 的 Decision Log Prompt", "", "```text", log.logPrompt, "```");
+
+  return `${lines.join("\n")}\n`;
+}
+
+export async function writeAgentDecisionLogOutput(outputPath, content) {
+  return writeScanOutput(outputPath, content);
+}

package/src/agent-progress-tracker.js

@@ -134,6 +134,76 @@ function buildExecutionContextFromParsedArtifact(parsed, input) {
     };
   }
 
+  if (parsed?.kind === "geo-agent-checkpoint" && parsed.statusBoard?.tracker?.applyPlan?.kind === "geo-apply-plan") {
+    return {
+      source:
+        parsed.source ||
+        parsed.statusBoard.source ||
+        parsed.statusBoard.tracker.source ||
+        parsed.statusBoard.tracker.applyPlan.source ||
+        input,
+      sourceType:
+        parsed.sourceType ||
+        parsed.statusBoard.sourceType ||
+        parsed.statusBoard.tracker.sourceType ||
+        parsed.statusBoard.tracker.applyPlan.sourceType ||
+        "json",
+      artifactKind: parsed.kind,
+      applyPlan: parsed.statusBoard.tracker.applyPlan,
+      trackerState: {
+        currentTaskId:
+          parsed.currentPacket?.id ||
+          parsed.statusBoard.tracker.currentTaskId ||
+          parsed.statusBoard.tracker.activePacket?.id ||
+          null,
+        completedPacketIds:
+          parsed.statusBoard.tracker.completedPacketIds ||
+          parsed.completedPackets?.map((packet) => packet.id) ||
+          [],
+        blockedReasons:
+          parsed.statusBoard.tracker.blockedReasons ||
+          parsed.blockedItems?.map((item) => item.title) ||
+          []
+      }
+    };
+  }
+
+  if (parsed?.kind === "geo-agent-decision-log" && parsed.latestCheckpoint?.statusBoard?.tracker?.applyPlan?.kind === "geo-apply-plan") {
+    return {
+      source:
+        parsed.source ||
+        parsed.latestCheckpoint.source ||
+        parsed.latestCheckpoint.statusBoard.source ||
+        parsed.latestCheckpoint.statusBoard.tracker.source ||
+        parsed.latestCheckpoint.statusBoard.tracker.applyPlan.source ||
+        input,
+      sourceType:
+        parsed.sourceType ||
+        parsed.latestCheckpoint.sourceType ||
+        parsed.latestCheckpoint.statusBoard.sourceType ||
+        parsed.latestCheckpoint.statusBoard.tracker.sourceType ||
+        parsed.latestCheckpoint.statusBoard.tracker.applyPlan.sourceType ||
+        "json",
+      artifactKind: parsed.kind,
+      applyPlan: parsed.latestCheckpoint.statusBoard.tracker.applyPlan,
+      trackerState: {
+        currentTaskId:
+          parsed.latestCheckpoint.currentPacket?.id ||
+          parsed.latestCheckpoint.statusBoard.tracker.currentTaskId ||
+          parsed.latestCheckpoint.statusBoard.tracker.activePacket?.id ||
+          null,
+        completedPacketIds:
+          parsed.latestCheckpoint.statusBoard.tracker.completedPacketIds ||
+          parsed.latestCheckpoint.completedPackets?.map((packet) => packet.id) ||
+          [],
+        blockedReasons:
+          parsed.latestCheckpoint.statusBoard.tracker.blockedReasons ||
+          parsed.latestCheckpoint.blockedItems?.map((item) => item.title) ||
+          []
+      }
+    };
+  }
+
   if (parsed?.kind === "geo-completion-report") {
     return {
       source: parsed.source || input,

package/src/agent-session.js

@@ -61,6 +61,12 @@ function inferSkillForCommand(commandName, flow) {
   if (commandName === "agent-status-board") {
     return "geo-ai-search-optimization-agent-status-board";
   }
+  if (commandName === "agent-checkpoint") {
+    return "geo-ai-search-optimization-agent-checkpoint";
+  }
+  if (commandName === "agent-decision-log") {
+    return "geo-ai-search-optimization-agent-decision-log";
+  }
   if (commandName === "skills" || commandName === "quick-start") {
     return "geo-ai-search-optimization-usage";
   }
@@ -131,6 +137,10 @@ function inferStepPurpose(commandName, flow) {
       return "追踪当前做到第几包、卡点在哪里，以及下一包该推进什么。";
     case "agent-status-board":
       return "把当前执行状态整理成 PM 和 agent 都能直接消费的分栏看板。";
+    case "agent-checkpoint":
+      return "把当前阶段压成继续 / 阻塞 / 收尾的决策检查点。";
+    case "agent-decision-log":
+      return "把每一轮 checkpoint 沉淀成可继承的决策历史。";
     case "apply-plan":
       return "把交接结果推进到具体执行包。";
     case "completion-report":
@@ -181,6 +191,10 @@ function inferExpectedArtifact(commandName) {
       return "agent 执行进度追踪工件";
     case "agent-status-board":
       return "agent 执行状态看板";
+    case "agent-checkpoint":
+      return "agent 阶段检查点工件";
+    case "agent-decision-log":
+      return "agent 决策历史工件";
     case "apply-plan":
       return "执行包";
     case "completion-report":
@@ -228,6 +242,12 @@ function buildStepInstructions(parsedCommand, flow) {
   if (parsedCommand.commandName === "agent-status-board") {
     lines.push("这一步用于把当前执行状态转成看板视图，方便 PM 和 agent 对齐当前阶段。");
   }
+  if (parsedCommand.commandName === "agent-checkpoint") {
+    lines.push("这一步用于明确此刻应该继续、先解除阻塞，还是进入收尾。");
+  }
+  if (parsedCommand.commandName === "agent-decision-log") {
+    lines.push("这一步用于保留跨轮决策历史，方便下一位 agent 直接承接上一次判断。");
+  }
   if (parsedCommand.commandName === "agent-handoff" && flow.intent === "execute") {
     lines.push("如果还是 advice-only，说明还缺仓库或本地项目上下文。");
   }

package/src/agent-status-board.js

@@ -139,6 +139,41 @@ async function resolveTracker(input, options = {}) {
             options.blockedReasons != null ? options.blockedReasons : (parsed.tracker.blockedReasons || []).join(",")
         });
       }
+      if (parsed?.kind === "geo-agent-checkpoint" && parsed.statusBoard?.tracker?.kind === "geo-agent-progress-tracker") {
+        return createAgentProgressTracker(parsed.statusBoard.tracker.source || input, {
+          format: "json",
+          currentTaskId:
+            options.currentTaskId || parsed.currentPacket?.id || parsed.statusBoard.tracker.currentTaskId,
+          completedPacketIds:
+            options.completedPacketIds != null
+              ? options.completedPacketIds
+              : (parsed.statusBoard.tracker.completedPacketIds || []).join(","),
+          blockedReasons:
+            options.blockedReasons != null
+              ? options.blockedReasons
+              : (parsed.statusBoard.tracker.blockedReasons || []).join(",")
+        });
+      }
+      if (parsed?.kind === "geo-agent-decision-log" && parsed.latestCheckpoint?.statusBoard?.tracker?.kind === "geo-agent-progress-tracker") {
+        return createAgentProgressTracker(
+          parsed.latestCheckpoint.statusBoard.tracker.source || parsed.latestCheckpoint.source || input,
+          {
+            format: "json",
+            currentTaskId:
+              options.currentTaskId ||
+              parsed.latestCheckpoint.currentPacket?.id ||
+              parsed.latestCheckpoint.statusBoard.tracker.currentTaskId,
+            completedPacketIds:
+              options.completedPacketIds != null
+                ? options.completedPacketIds
+                : (parsed.latestCheckpoint.statusBoard.tracker.completedPacketIds || []).join(","),
+            blockedReasons:
+              options.blockedReasons != null
+                ? options.blockedReasons
+                : (parsed.latestCheckpoint.statusBoard.tracker.blockedReasons || []).join(",")
+          }
+        );
+      }
     } catch {
       // Fall through to tracker generation
     }

package/src/auto-flow.js

@@ -53,6 +53,12 @@ function inferTaskTextMode(text) {
   if (/(status-board|status board|状态看板|执行看板|看板视图|board 视图)/i.test(normalized)) {
     return "execute";
   }
+  if (/(checkpoint|检查点|阶段检查点|继续还是收尾|解除阻塞还是继续)/i.test(normalized)) {
+    return "execute";
+  }
+  if (/(decision-log|decision log|决策历史|决策日志|为什么这样决定|历史决策)/i.test(normalized)) {
+    return "execute";
+  }
   if (/(executor|先做哪一个|先做哪一包|single task|执行第一包|先执行一个任务)/i.test(normalized)) {
     return "execute";
   }
@@ -173,6 +179,8 @@ function resolveEffectiveIntent(intent, detected) {
       "geo-agent-batch-executor",
       "geo-agent-progress-tracker",
       "geo-agent-status-board",
+      "geo-agent-checkpoint",
+      "geo-agent-decision-log",
       "geo-apply-plan",
       "geo-handoff-bundle",
       "geo-fix-plan"
@@ -351,6 +359,50 @@ function buildCommandChain(detected, intent) {
               `geo-ai-search-optimization completion-report ${source}`,
               `geo-ai-search-optimization handoff-bundle ${source}`
             ];
+    case "geo-agent-checkpoint":
+      return detected.parsed?.decision === "move-to-closeout"
+        ? [
+            `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-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-progress-tracker ${source}`,
+              `geo-ai-search-optimization completion-report ${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 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-status-board ${source}`,
+              `geo-ai-search-optimization agent-decision-log ${baseSource} --append-from ${source}`
+            ]
+          : [
+              suggestedNext,
+              `geo-ai-search-optimization agent-progress-tracker ${source}`,
+              `geo-ai-search-optimization agent-decision-log ${baseSource} --append-from ${source}`
+            ];
+    }
     case "geo-apply-plan":
       return [
         `geo-ai-search-optimization agent-executor ${source}`,
@@ -430,6 +482,10 @@ function pickSkillName(detected, intent) {
       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-completion-report":
       return "geo-ai-search-optimization-completion-report";
     case "geo-handoff-bundle":
@@ -469,6 +525,8 @@ function buildSecondarySkillNames(primarySkill, intent, detected) {
       "geo-agent-batch-executor",
       "geo-agent-progress-tracker",
       "geo-agent-status-board",
+      "geo-agent-checkpoint",
+      "geo-agent-decision-log",
       "geo-apply-plan"
     ].includes(
       detected.artifactKind
@@ -477,6 +535,8 @@ function buildSecondarySkillNames(primarySkill, intent, detected) {
     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");
+    names.add("geo-ai-search-optimization-agent-checkpoint");
+    names.add("geo-ai-search-optimization-agent-decision-log");
     names.add("geo-ai-search-optimization-agent-executor");
     names.add("geo-ai-search-optimization-agent-runbook");
     names.add("geo-ai-search-optimization-agent-handoff");
@@ -509,6 +569,8 @@ function buildStage(intent, detected) {
       "geo-agent-batch-executor",
       "geo-agent-progress-tracker",
       "geo-agent-status-board",
+      "geo-agent-checkpoint",
+      "geo-agent-decision-log",
       "geo-apply-plan",
       "geo-handoff-bundle"
     ].includes(detected.artifactKind)
@@ -524,6 +586,8 @@ function buildStage(intent, detected) {
       "geo-agent-batch-executor",
       "geo-agent-progress-tracker",
       "geo-agent-status-board",
+      "geo-agent-checkpoint",
+      "geo-agent-decision-log",
       "geo-apply-plan",
       "geo-handoff-bundle"
     ].includes(detected.artifactKind)
@@ -613,6 +677,9 @@ function buildNextAction(detected, intent, commands) {
     if (detected.artifactKind === "geo-agent-progress-tracker") {
       return `先运行 \`${commands[0]}\`，继续当前执行包或校准下一包。`;
     }
+    if (detected.artifactKind === "geo-agent-decision-log") {
+      return `先运行 \`${commands[0]}\`，沿着最近一次阶段决策继续推进，而不是重新判断整条链。`;
+    }
     return `先运行 \`${commands[0]}\`，把当前输入推进到 agent 可执行状态。`;
   }
   if (intent === "closeout") {