@peterxiaoyang/superspec 0.1.40 → 0.1.42

package/README.md

@@ -8,10 +8,10 @@
 
 它解决的是一个很常见的问题：AI 编程工具写代码很快，但有时候还没搞清楚需求、现有代码和测试边界，就已经开始改文件了。
 
-SuperSpec 会把一次需求变更拆成 5 步：
+SuperSpec 会把一次需求变更拆成 4 个阶段：
 
 ```text
-探索需求 -> 写方案 -> 做实现 -> 代码审查与最终验证 -> 归档收尾
+探索需求 -> 写方案 -> 做实现 -> 代码审查与最终验证 -> accepted
 ```
 
 这样做的目的很简单：
@@ -20,7 +20,7 @@ SuperSpec 会把一次需求变更拆成 5 步：
 - 写实现前先有方案和任务
 - 任务完成前先有测试或验证记录
 - 宣布完成前先经过审查
-- 归档时保留关键过程记录
+- 进入 accepted 时保留关键过程记录
 
 ## 适合谁
 
@@ -53,12 +53,12 @@ SuperSpec 管“AI 应该怎样把这次改动做稳”。
 | 方案怎么写 | 提供标准的变更文档结构 | 要求方案前后有范围、风险、业务约束和测试思路 |
 | 代码怎么做 | 记录任务清单和完成状态 | 要求按任务实现，并留下测试或验证记录 |
 | 做完怎么算稳 | 可以校验规格和归档 | 增加代码审查、架构审查、反方审查和最终验证 |
-| 以后怎么追溯 | 保留 OpenSpec 的变更文档 | 额外保留探索、测试、审查和收尾记录 |
+| 以后怎么追溯 | 保留 OpenSpec 的变更文档 | 额外保留探索、测试和审查记录 |
 
 举个例子：
 
 OpenSpec 会帮你记录“要增加登录功能、需要哪些规格、设计和任务”。
-SuperSpec 会进一步要求 AI 先看看现有登录/权限代码在哪里、哪些业务规则不能破坏、哪些场景必须测试、实现后要经过哪些审查，最后再归档。
+SuperSpec 会进一步要求 AI 先看看现有登录/权限代码在哪里、哪些业务规则不能破坏、哪些场景必须测试、实现后要经过哪些审查，最终进入 accepted 完成本轮流程。
 
 所以 SuperSpec 不是 OpenSpec 的替代品。它更像是 OpenSpec 外面的一层执行纪律，专门约束 AI 编程工具不要跳过关键步骤。
 
@@ -118,13 +118,9 @@ superspec.cmd install
 使用 superspec-review，完成代码审查、问题处理和最终验证。
 ```
 
-审查通过后，归档：
+审查通过并进入 `accepted` 后，本轮工作流完成。如果之后需要补充或修改需求、方案或验收内容，直接用自然语言告诉 Agent；Agent 会按引擎返回的内部 continuation 自动回到计划阶段并重新完成后续审查。
 
-```text
-使用 superspec-archive，归档这个变更。
-```
-
-## 五个入口分别做什么
+## 四个入口分别做什么
 
 | 入口 | 什么时候用 | 它会要求做什么 |
 |---|---|---|
@@ -132,9 +128,8 @@ superspec.cmd install
 | `superspec-propose` | 需求已经清楚后 | 写正式方案、规格、设计和任务，并提前规划测试 |
 | `superspec-apply` | 方案通过后 | 按任务实现代码，记录测试或验证结果 |
 | `superspec-review` | 实现完成后 | 检查代码实现是否符合方案，处理审查问题，并完成最终验证 |
-| `superspec-archive` | 审查通过后 | 用 OpenSpec 完成归档，并检查关键记录是否保留 |
 
-你日常主要记住这五个入口就够了。
+你日常主要记住这四个入口就够了。
 
 CLI 不带 `--risk` 时默认走完整审查路径；需要轻量路径时显式传 `--risk normal` 或 `--risk minimal`。探索阶段会创建 `critic` 工作项审查需求澄清记录；计划阶段会创建 `critic`、`architect` 和 `test-engineer` 工作项后再进入实现准备。
 
@@ -226,7 +221,6 @@ superspec update
   skills/superspec-propose/
   skills/superspec-apply/
   skills/superspec-review/
-  skills/superspec-archive/
   prompts/architect.md
   prompts/code-reviewer.md
   prompts/critic.md

package/dist/cli.js

@@ -7,9 +7,10 @@ import { installProject } from "./install.js";
 import { writeSnapshot } from "./store.js";
 import { rebuildSnapshot } from "./sync.js";
 import { next as nextCmd } from "./next.js";
-import { proposeReady, commitTransition, transitionInit, transitionExplore, startApply, taskStart, taskComplete, reopen, reviewReady, accept, archive } from "./transition.js";
+import { proposeReady, commitTransition, transitionInit, transitionExplore, startApply, taskStart, taskComplete, reopen, reviewReady, accept } from "./transition.js";
 import { recordJobSubmit, recordJobSubmitContent, recordUserDecision, recordUserDecisionContent, jobsList, jobsPacket } from "./record.js";
 import { recordTestRun, recordTestRunContent } from "./task.js";
+import { RecordInputDecodingError, decodeRecordInput } from "./record_input.js";
 import { probeOpenSpec, openspecStatus, changeRoot } from "./openspec.js";
 import { SUPERSPEC_VERSION } from "./version.js";
 const PACKAGE_NAME = "@peterxiaoyang/superspec";
@@ -54,7 +55,7 @@ function readStdinRecordContent(flag) {
     if (process.stdin.isTTY === true) {
         throw new StdinRecordInputError(flag);
     }
-    return readFileSync(0, "utf8");
+    return decodeRecordInput(readFileSync(0));
 }
 function transitionExitCode(result) {
     if (result.outcome === "blocked")
@@ -516,8 +517,8 @@ transition 子命令：
   init / explore / sync / next / propose-ready / start-apply
   task-start --task <T> / task-complete --task <T> [--input -]
   reopen --to apply --reason <TEXT> [--review-fix <JOB#FINDING>]
-  reopen --to propose --reason <TEXT> --review-finding <JOB#FINDING>
-  review-ready / accept / archive
+  reopen --to propose --reason <TEXT> [--review-finding <JOB#FINDING>]
+  review-ready / accept
 
 record 子命令：
   job-submit --job <J> --report <F|->
@@ -709,7 +710,7 @@ jobs 子命令：
                                 inputContent = readStdinRecordContent("--input");
                             }
                             catch (err) {
-                                if (err instanceof StdinRecordInputError) {
+                                if (err instanceof StdinRecordInputError || err instanceof RecordInputDecodingError) {
                                     console.error(err.message);
                                     return 1;
                                 }
@@ -751,11 +752,6 @@ jobs 子命令：
                         console.log(JSON.stringify(result, null, 2));
                         return transitionExitCode(result);
                     }
-                    case "archive": {
-                        const result = archive(projectRoot, change, cr);
-                        console.log(JSON.stringify(result, null, 2));
-                        return transitionExitCode(result);
-                    }
                     default:
                         console.error(`未知的 transition 子命令：${subcommand}`);
                         return 1;
@@ -778,7 +774,7 @@ jobs 子命令：
                                 : recordJobSubmit(projectRoot, change, cr, jobId, report);
                         }
                         catch (err) {
-                            if (err instanceof StdinRecordInputError) {
+                            if (err instanceof StdinRecordInputError || err instanceof RecordInputDecodingError) {
                                 console.error(err.message);
                                 return 1;
                             }
@@ -800,7 +796,7 @@ jobs 子命令：
                                 : recordUserDecision(projectRoot, change, inputFile);
                         }
                         catch (err) {
-                            if (err instanceof StdinRecordInputError) {
+                            if (err instanceof StdinRecordInputError || err instanceof RecordInputDecodingError) {
                                 console.error(err.message);
                                 return 1;
                             }
@@ -822,7 +818,7 @@ jobs 子命令：
                                 : recordTestRun(projectRoot, change, inputFile);
                         }
                         catch (err) {
-                            if (err instanceof StdinRecordInputError) {
+                            if (err instanceof StdinRecordInputError || err instanceof RecordInputDecodingError) {
                                 console.error(err.message);
                                 return 1;
                             }

package/dist/code_review.d.ts

@@ -1,4 +1,4 @@
-import type { CodeReviewResultKind, CodeReviewScope, CodeStateCheck, CoverageExemptionRef, Event, Job, JobPacketContext, Ref } from "./types.ts";
+import type { CodeReviewResultKind, CodeReviewScope, CodeStateCheck, CoverageExemptionRef, Event, Job, JobPacketContext, Ref, ReviewPreviousRejection } from "./types.ts";
 export declare const CODE_REVIEW_REPAIR_SCOPE_PREFIX = "code_reviewer_report_repair:";
 export declare const CODE_REVIEW_DECISION_SCOPE_PREFIX = "code_review_decision:";
 export declare const TEST_COVERAGE_EXEMPTION_SCOPE_PREFIX = "test_coverage_exemption:";
@@ -63,11 +63,7 @@ export declare function codeReviewPacketDigest(input: {
     checkedDocs: string[];
     created_from_transition: string;
     packet_context?: JobPacketContext;
-    previous_rejection?: {
-        result_kind: CodeReviewResultKind;
-        reason: string;
-        job_id: string;
-    };
+    previous_rejection?: ReviewPreviousRejection;
 }): string;
 export declare function codeReviewPacketContext(changeRoot: string, projectRoot: string, scope: CodeReviewScope, events: Event[]): JobPacketContext;
 export declare function effectiveCoverageExemptionRefsFromEvents(events: Event[]): CoverageExemptionRef[];

package/dist/install.d.ts

@@ -1,4 +1,4 @@
-export declare const WORKFLOW_SKILLS: readonly ["superspec-explore", "superspec-propose", "superspec-apply", "superspec-review", "superspec-archive"];
+export declare const WORKFLOW_SKILLS: readonly ["superspec-explore", "superspec-propose", "superspec-apply", "superspec-review"];
 export declare const WORKFLOW_PROMPTS: readonly ["architect.md", "code-reviewer.md", "critic.md", "executor.md", "explore.md", "test-engineer.md", "test-runner.md", "verifier.md"];
 export declare const WORKFLOW_AGENTS: readonly ["architect.toml", "code-reviewer.toml", "critic.toml", "executor.toml", "explore.toml", "test-engineer.toml", "test-runner.toml", "verifier.toml"];
 export interface InstallResult {

package/dist/install.js

@@ -6,8 +6,8 @@ export const WORKFLOW_SKILLS = [
     "superspec-propose",
     "superspec-apply",
     "superspec-review",
-    "superspec-archive",
 ];
+const DEPRECATED_WORKFLOW_SKILLS = ["superspec-archive"];
 export const WORKFLOW_PROMPTS = [
     "architect.md",
     "code-reviewer.md",
@@ -74,6 +74,9 @@ function writeBundledFile(src, dest) {
 }
 function copySkills(templateRoot, projectRoot) {
     const skillsDest = join(projectRoot, ".codex", "skills");
+    for (const skill of DEPRECATED_WORKFLOW_SKILLS) {
+        rmSync(join(skillsDest, skill), { recursive: true, force: true });
+    }
     const installedSkills = [];
     for (const skill of WORKFLOW_SKILLS) {
         const src = join(templateRoot, "skills", skill, "SKILL.md");
@@ -280,7 +283,7 @@ export function installProject(projectRoot, options = {}) {
     if (!options.allowLegacyState && legacyStateFound(projectRoot)) {
         throw new Error("检测到老版 SuperSpec (0.x) 的状态文件。\n" +
             `SuperSpec ${SUPERSPEC_VERSION} 是全新引擎，不兼容 0.x 的状态格式。\n` +
-            `请先用老版（0.1.x）完成或归档现有 change，再安装 ${SUPERSPEC_VERSION}。\n` +
+            `请先用老版（0.1.x）完成现有 change，再安装 ${SUPERSPEC_VERSION}。\n` +
             "或在全新项目目录中安装。");
     }
     const templateRoot = options.templateRoot ?? defaultTemplateRoot();

package/dist/next.js

@@ -40,14 +40,6 @@ function toNextOutput(change, plan) {
             return requiredJobsOutput(plan.state, change, plan.jobs, plan.reason);
         case "ask_user":
             return { state: plan.state, path: "ask_user", ask_user: plan.ask, reason: plan.reason };
-        case "ask_archive_confirmation": {
-            const ask = {
-                question: `审查已通过，流程停在 accepted。确认归档时请执行 ${transitionCommand(change, "archive")}`,
-                allowed_answers: ["确认归档"],
-                scope: "archive_confirmation",
-            };
-            return { state: "accepted", path: "ask_user", ask_user: ask, reason: plan.reason };
-        }
         case "run_transition":
             return {
                 state: plan.state,
@@ -57,7 +49,12 @@ function toNextOutput(change, plan) {
                 missing_inputs: [],
             };
         case "done":
-            return { state: plan.state, path: "done", reason: plan.reason };
+            return {
+                state: plan.state,
+                path: "done",
+                reason: plan.reason,
+                ...(plan.continuation ? { continuation: plan.continuation } : {}),
+            };
     }
 }
 /** next 命令：读 snapshot，返回唯一可执行路径 */

package/dist/phase_confirmation.d.ts

@@ -0,0 +1,31 @@
+import { type ReviewRisk } from "./review.ts";
+import type { AskUser, AskUserAction, Event, Snapshot } from "./types.ts";
+export declare const PHASE_CONFIRMATION_SCOPE_PREFIX = "phase_confirmation:";
+export type PhaseBoundary = "explore_to_propose" | "propose_to_apply" | "apply_to_review";
+export type PhaseDecision = "advance" | "stay";
+export interface PhaseDecisionAction extends AskUserAction {
+    boundary: PhaseBoundary;
+    decision: PhaseDecision;
+}
+export interface PhaseConfirmation {
+    boundary: PhaseBoundary;
+    epoch_event_id: string;
+    material_digest: string;
+    scope: string;
+    actions: PhaseDecisionAction[];
+    ask: AskUser;
+}
+export interface PhaseConfirmationDecision {
+    event: Event;
+    scope: string;
+    answer: string;
+    decision: PhaseDecision;
+}
+export declare function isPhaseConfirmationScope(value: unknown): value is string;
+export declare function phaseConfirmationForBoundary(projectRoot: string, events: Event[], snapshot: Snapshot, boundary: PhaseBoundary, risk?: ReviewRisk): PhaseConfirmation | null;
+export declare function phaseConfirmationForCurrentState(projectRoot: string, events: Event[], snapshot: Snapshot, risk?: ReviewRisk): PhaseConfirmation | null;
+export declare function phaseActionForAnswer(confirmation: PhaseConfirmation, answer: unknown): PhaseDecisionAction | null;
+export declare function latestAcceptedPhaseDecision(events: Event[], confirmation: PhaseConfirmation): PhaseConfirmationDecision | null;
+export declare function isPhaseAdvanceAuthorized(events: Event[], confirmation: PhaseConfirmation): boolean;
+export declare function phaseConfirmationCommitPayload(confirmation: PhaseConfirmation, decision: PhaseConfirmationDecision): Record<string, unknown>;
+export declare function phaseConfirmationMissingMessage(confirmation: PhaseConfirmation): string;

package/dist/phase_confirmation.js

@@ -0,0 +1,218 @@
+import { currentGitHead, dirtyCodeFiles } from "./git_state.js";
+import { reviewEvidenceDigest } from "./review.js";
+import { findLatestEvent, sha256Text } from "./store.js";
+export const PHASE_CONFIRMATION_SCOPE_PREFIX = "phase_confirmation:";
+function latestTransition(events, predicate) {
+    return findLatestEvent(events, "transition_commit", event => predicate(event.payload));
+}
+const SPECS = {
+    explore_to_propose: {
+        state: "explore",
+        question: "探索与探索审查已完成，请选择进入计划阶段，或留在探索阶段继续完善。",
+        actions: [
+            { decision: "advance", label: "确认进入计划阶段", reason: "none", resume: { kind: "next" } },
+            {
+                decision: "stay",
+                label: "留在探索阶段继续完善",
+                reason: "required",
+                reasonPrompt: "请说明还需要补充或核对哪些探索信息。",
+                resume: {
+                    kind: "continue_current_phase",
+                    instruction: "根据用户说明继续完善 discovery；完成后重新执行 next。",
+                },
+            },
+        ],
+        scopePrefix: `${PHASE_CONFIRMATION_SCOPE_PREFIX}explore_to_propose`,
+        epoch: events => latestTransition(events, payload => payload.from_state === "init" && payload.to_state === "explore"),
+    },
+    propose_to_apply: {
+        state: "propose_ready",
+        question: "计划文档与计划审查已完成，请选择开始实现，或留在计划阶段继续完善。",
+        actions: [
+            { decision: "advance", label: "确认开始实现", reason: "none", resume: { kind: "next" } },
+            {
+                decision: "stay",
+                label: "留在计划阶段继续完善",
+                reason: "required",
+                reasonPrompt: "请说明还需要调整哪些计划内容。",
+                resume: {
+                    kind: "continue_current_phase",
+                    instruction: "根据用户说明继续完善绑定计划材料；完成后重新执行 next。",
+                },
+            },
+        ],
+        scopePrefix: `${PHASE_CONFIRMATION_SCOPE_PREFIX}propose_to_apply`,
+        epoch: events => latestTransition(events, payload => payload.to_state === "propose_ready"),
+    },
+    apply_to_review: {
+        state: "apply_done",
+        question: "实现、测试证据与代码审查已完成，请选择进入最终审查，或暂不进入最终审查。",
+        actions: [
+            { decision: "advance", label: "确认进入最终审查", reason: "none", resume: { kind: "next" } },
+            { decision: "stay", label: "暂不进入最终审查", reason: "optional", resume: { kind: "stop" } },
+        ],
+        scopePrefix: `${PHASE_CONFIRMATION_SCOPE_PREFIX}apply_to_review`,
+        epoch: events => latestTransition(events, payload => payload.from_state === "apply" && payload.to_state === "apply_done"),
+    },
+};
+function boundaryForState(state) {
+    switch (state) {
+        case "explore": return "explore_to_propose";
+        case "propose_ready": return "propose_to_apply";
+        case "apply_done": return "apply_to_review";
+        default: return null;
+    }
+}
+function materialDigest(projectRoot, events, snapshot) {
+    const head = currentGitHead(projectRoot);
+    const dirty = dirtyCodeFiles(projectRoot);
+    const acceptedJobs = snapshot.accepted_jobs
+        .map(job => ({
+        job_id: job.job_id,
+        role: job.role,
+        gate_id: job.gate_id ?? null,
+        packet_digest: job.packet_digest,
+        review_evidence_digest: job.review_evidence_digest ?? null,
+    }))
+        .sort((a, b) => a.job_id.localeCompare(b.job_id));
+    const documents = Object.entries(snapshot.document_digests)
+        .sort(([left], [right]) => left.localeCompare(right));
+    return sha256Text(JSON.stringify({
+        documents,
+        tasks_structure_digest: snapshot.tasks_structure_digest,
+        accepted_jobs: acceptedJobs,
+        review_evidence_digest: reviewEvidenceDigest(events),
+        code_state: {
+            head: head.head,
+            head_reason: head.reason,
+            dirty_files: dirty.files,
+            ...(dirty.ok ? {} : { dirty_files_reason: dirty.reason }),
+        },
+    }));
+}
+function phaseRecordArgv(change) {
+    return ["superspec", "record", "user-decision", "--change", change, "--input", "-"];
+}
+function nextArgv(change, risk) {
+    return [
+        "superspec",
+        "transition",
+        "next",
+        "--change",
+        change,
+        ...(risk === "strict" ? [] : ["--risk", risk]),
+    ];
+}
+function buildActions(change, boundary, scope, question, specs, risk) {
+    if (specs.length < 2)
+        throw new Error(`${boundary} 至少需要两个 phase actions`);
+    const labels = new Set();
+    for (const spec of specs) {
+        if (labels.has(spec.label))
+            throw new Error(`${boundary} 存在重复 action label：${spec.label}`);
+        labels.add(spec.label);
+    }
+    if (!specs.some(action => action.decision === "advance")) {
+        throw new Error(`${boundary} 缺少 advance action`);
+    }
+    if (!specs.some(action => action.decision === "stay")) {
+        throw new Error(`${boundary} 缺少 stay action`);
+    }
+    return specs.map(spec => ({
+        boundary,
+        decision: spec.decision,
+        label: spec.label,
+        selection: "exact_label",
+        reason: spec.reason,
+        ...(spec.reasonPrompt ? { reason_prompt: spec.reasonPrompt } : {}),
+        record_argv: phaseRecordArgv(change),
+        record_input: { scope, question, answer: spec.label },
+        resume: spec.resume.kind === "next"
+            ? { kind: "next", argv: nextArgv(change, risk) }
+            : spec.resume.kind === "continue_current_phase"
+                ? {
+                    kind: "continue_current_phase",
+                    instruction: spec.resume.instruction,
+                    next_argv_after_completion: nextArgv(change, risk),
+                }
+                : { kind: "stop" },
+    }));
+}
+export function isPhaseConfirmationScope(value) {
+    return typeof value === "string" && value.startsWith(PHASE_CONFIRMATION_SCOPE_PREFIX);
+}
+export function phaseConfirmationForBoundary(projectRoot, events, snapshot, boundary, risk = "strict") {
+    const spec = SPECS[boundary];
+    if (snapshot.state !== spec.state)
+        return null;
+    const epoch = spec.epoch(events);
+    const epochEventId = epoch?.event_id ?? `legacy-${spec.state}`;
+    const digest = materialDigest(projectRoot, events, snapshot);
+    const scope = `${spec.scopePrefix}:${epochEventId}:${digest}`;
+    const actions = buildActions(snapshot.change_id, boundary, scope, spec.question, spec.actions, risk);
+    return {
+        boundary,
+        epoch_event_id: epochEventId,
+        material_digest: digest,
+        scope,
+        actions,
+        ask: {
+            question: spec.question,
+            allowed_answers: actions.map(action => action.label),
+            scope,
+            actions,
+        },
+    };
+}
+export function phaseConfirmationForCurrentState(projectRoot, events, snapshot, risk = "strict") {
+    const boundary = boundaryForState(snapshot.state);
+    return boundary
+        ? phaseConfirmationForBoundary(projectRoot, events, snapshot, boundary, risk)
+        : null;
+}
+export function phaseActionForAnswer(confirmation, answer) {
+    return typeof answer === "string"
+        ? confirmation.actions.find(action => action.label === answer) ?? null
+        : null;
+}
+export function latestAcceptedPhaseDecision(events, confirmation) {
+    const event = findLatestEvent(events, "user_decision_recorded", candidate => {
+        const payload = candidate.payload;
+        const phase = payload.phase_confirmation;
+        return payload.accepted !== false &&
+            payload.scope === confirmation.scope &&
+            phase?.boundary === confirmation.boundary &&
+            (phase.decision === "advance" || phase.decision === "stay");
+    });
+    if (!event)
+        return null;
+    const payload = event.payload;
+    return {
+        event,
+        scope: confirmation.scope,
+        answer: payload.answer,
+        decision: payload.phase_confirmation.decision,
+    };
+}
+export function isPhaseAdvanceAuthorized(events, confirmation) {
+    return latestAcceptedPhaseDecision(events, confirmation)?.decision === "advance";
+}
+export function phaseConfirmationCommitPayload(confirmation, decision) {
+    if (decision.decision !== "advance") {
+        throw new Error(`${confirmation.boundary} 的 stay decision 不能写入阶段推进 commit`);
+    }
+    return {
+        phase_confirmation: {
+            boundary: confirmation.boundary,
+            decision: decision.decision,
+            epoch_event_id: confirmation.epoch_event_id,
+            material_digest: confirmation.material_digest,
+            scope: confirmation.scope,
+            decision_event_id: decision.event.event_id,
+        },
+    };
+}
+export function phaseConfirmationMissingMessage(confirmation) {
+    const answers = confirmation.actions.map(action => action.label).join(" / ");
+    return `缺少当前阶段的用户确认；请先执行 next，并按返回的 scope=${confirmation.scope} 精确选择：${answers}`;
+}

package/dist/phase_plan.d.ts

@@ -1,8 +1,8 @@
 import type { ReviewGateRule } from "./review_job_gates.ts";
-import type { AskUser, Event, Job, JobRole, State } from "./types.ts";
+import type { AcceptedMaterialFollowupContinuation, AskUser, Event, Job, JobRole, State } from "./types.ts";
 import type { Snapshot } from "./types.ts";
 import type { ReviewRisk } from "./review.ts";
-export type TransitionName = "explore" | "propose-ready" | "start-apply" | "task-start" | "task-complete" | "review-ready" | "reopen" | "accept" | "archive";
+export type TransitionName = "explore" | "propose-ready" | "start-apply" | "task-start" | "task-complete" | "review-ready" | "reopen" | "accept";
 export type WorkflowMode = {
     kind: "risk";
     risk: ReviewRisk;
@@ -43,10 +43,6 @@ export type NextStepPlan = {
     state: State;
     ask: AskUser;
     reason: string;
-} | {
-    kind: "ask_archive_confirmation";
-    state: "accepted";
-    reason: string;
 } | {
     kind: "run_transition";
     state: State;
@@ -59,6 +55,7 @@ export type NextStepPlan = {
     kind: "done";
     state: State;
     reason: string;
+    continuation?: AcceptedMaterialFollowupContinuation;
 };
 export type TransitionDecisionPlan = {
     kind: "skip";
@@ -86,6 +83,7 @@ export interface ApplyPendingTaskStatus {
     completedByEvent: string[];
 }
 export declare function proposalDocsBaseline(changeRoot: string): Record<string, string>;
+export declare function latestAcceptedProposalBaseline(events: Event[]): Record<string, string> | null;
 export declare function latestReopenProposeBaseline(events: Event[]): Record<string, string> | null;
 export declare function proposalDocsChangedSinceBaseline(changeRoot: string, baseline: Record<string, string>): boolean;
 export declare function historicalProposeReadyRoles(events: Event[]): JobRole[];
@@ -94,4 +92,5 @@ export declare function applyRequirementModeForCurrentRound(events: Event[]): bo
 export declare function pendingTaskStatusForApply(changeRoot: string, events: Event[]): ApplyPendingTaskStatus;
 export declare function formatPendingTaskMessage(ids: string[], action: string): string;
 export declare function planNextStep(context: PhasePlanContext): NextStepPlan | null;
+export declare function blockingJobsForApplyDone(projectRoot: string, events: Event[], snapshot: Snapshot): Job[];
 export declare function planTransition(name: "explore" | "propose-ready" | "start-apply" | "accept", context: TransitionPlanContext): TransitionDecisionPlan;