@viccydev/pi-fpa 0.8.0 → 0.8.1

package/README.md

@@ -33,7 +33,9 @@ Skill：
 阶段的请求都必须先查询 Graph catalog，再运行当前第一个满足入口条件的
 Graph；在此之前不得调用 `fpa_*` 工具或写 Artifact。四个工作流的边界为：
 
-- `fpa-strategy-planning`：规划至 `reviewed_strategy_handoff` 后停止。
+- `fpa-strategy-planning`：在一个组合 Graph 中完成规划至
+  `reviewed_strategy_handoff` 后停止。数据/驱动审计与三类策略场景分别并行；
+  并行子节点只读，正式 Artifact 由后续汇总节点顺序写入。
 - `fpa-forecast-freeze`：只接受精确 handoff，经人工批准后冻结 Forecast。
 - `fpa-strategy-execution`：只接受精确 committed Forecast ref 和单独执行授权。
 - `fpa-cycle-review`：只接受精确 Forecast/Execution refs 与新 Actuals。
@@ -47,6 +49,11 @@ Graph 的业务阻塞不能触发父 Agent 降级执行。Graph 工具不可用
 它从展开后的请求识别多阶段 FP&A 意图，要求目标 Graph 与请求阶段一致，并
 阻断父 Agent 的提前 `fpa_*` 调用和 `artifacts/` 写入。Graph worker 没有
 `graph_list`/`graph_run` 时不会激活该护栏，因此节点仍可执行被分配的单一阶段。
+首次在可信项目进入 FP&A 工作流时，护栏会把 package 自带的 Graph 模板安装到
+`.agent-graph/graphs`；较旧的同名模板和已经退役的拆分 Graph 会先移入
+`.agent-graph/graphs_backup_v*` 再更新，因此 `graph_list` 能直接发现当前组合
+Graph，同时保留可恢复的旧定义。非可信项目、符号链接目录和更高版本的项目
+Graph 均不会被覆盖。
 
 ## 数据 Extension（fpa-data）
 
@@ -75,10 +82,14 @@ Extension 内置的关键防护：
 
 `fpa-artifacts` 提供 `fpa_artifact_commit`，对 `approved_cycle_forecast` 和 `execution_receipt` 做严格字段校验、对账、稳定指纹和原子落盘。只有工具返回成功后的 JSON 才是冻结产物，Markdown 不是正式数据源。
 
-`fpa-dashboard` 提供三个工具：
+`fpa-dashboard` 提供分模块发布工具和兼容的闭环刷新工具：
 
 | 工具 | 作用 |
 | --- | --- |
+| `fpa_dashboard_module_status` | 只读检查各独立模块及当前 Dashboard revision |
+| `fpa_dashboard_publish_review` | 只发布 `period-review`，保留其他模块 |
+| `fpa_dashboard_publish_strategy` | 只发布带确认/修改动作的 `next-strategy`，并绑定当前主会话 |
+| `fpa_dashboard_publish_forecast` | 确认策略并冻结预测后，只发布 `next-forecast` |
 | `fpa_dashboard_status` | 只读检查当前 manifest、构建回执和各数据集是否可读 |
 | `fpa_dashboard_refresh` | 从冻结预测、可选执行回执和实时 Actuals 生成固定的闭环看板；先 preview，再携带相同指纹原子 publish |
 | `fpa_dashboard_refresh_queue` | 检查或处理持久刷新队列；主 Agent 用 `enqueue_artifact` 显式交接 Forecast/Execution，Actuals watermark 按 SLA 轮询并幂等发布 |
@@ -148,12 +159,12 @@ pi list
 团队分发建议使用固定 Git tag：
 
 ```bash
-pi install git:github.com/linyqh/pi-fpa@v0.8.0
+pi install git:github.com/linyqh/pi-fpa@v0.8.1
 ```
 
 ## 发布到 npm
 
-发布动作由 GitHub Release 触发。Release 标签必须严格使用 `v<package.json version>`，例如版本 `0.8.0` 对应 `v0.8.0`。工作流会检出该标签，执行 `npm ci`、`npm test` 和包内容预检，全部通过后发布公开包 `@viccydev/pi-fpa`。普通 Release 发布到 `latest`，Prerelease 发布到 `next`。
+发布动作由 GitHub Release 触发。Release 标签必须严格使用 `v<package.json version>`，例如版本 `0.8.1` 对应 `v0.8.1`。工作流会检出该标签，执行 `npm ci`、`npm test` 和包内容预检，全部通过后发布公开包 `@viccydev/pi-fpa`。普通 Release 发布到 `latest`，Prerelease 发布到 `next`。
 
 发布认证使用 npm Trusted Publishing / OIDC，不使用长期 npm Token。npm 包后台的 Trusted Publisher 配置为：
 

package/extensions/fpa-artifacts/index.ts

@@ -1,3 +1,5 @@
+import { createHash } from "node:crypto";
+
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 
@@ -7,6 +9,7 @@ import {
 	commitArtifactFromPath,
 	readArtifactByRef,
 	readProjectJsonFile,
+	stableJson,
 	type ArtifactRefV2,
 } from "./store.ts";
 
@@ -115,6 +118,25 @@ export default function fpaArtifactsExtension(pi: ExtensionAPI): void {
 		},
 	});
 
+	pi.registerTool({
+		name: "fpa_json_fingerprint",
+		label: "Fingerprint FP&A JSON Artifacts",
+		description: "Read project-local JSON artifacts and return deterministic SHA-256 fingerprints over their canonical JSON form. Use this to bind reviewed handoffs to exact proposal and review bodies.",
+		promptSnippet: "Fingerprint exact FP&A JSON artifacts for a version-bound handoff",
+		parameters: Type.Object({
+			paths: Type.Array(Type.String({ minLength: 1 }), { minItems: 1, maxItems: 8 }),
+		}, { additionalProperties: false }),
+		executionMode: "parallel",
+		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+			if (new Set(params.paths).size !== params.paths.length) throw new Error("Fingerprint paths must be unique.");
+			const entries = await Promise.all(params.paths.map(async (path) => {
+				const value = await readProjectJsonFile(ctx.cwd, path, "path");
+				return [path, createHash("sha256").update(stableJson(value)).digest("hex")] as const;
+			}));
+			return toolResult({ status: "fingerprinted", fingerprints: Object.fromEntries(entries) });
+		},
+	});
+
 	pi.registerTool({
 		name: "fpa_forecast_compose",
 		label: "Compose Approved Forecast",

package/extensions/fpa-dashboard/index.ts

@@ -114,7 +114,11 @@ export default function fpaDashboardExtension(pi: ExtensionAPI): void {
 		parameters: Type.Object({
 			mode: StringEnum(["preview", "publish"] as const),
 			proposal_path: Type.String({ minLength: 1 }),
+			review_path: Type.String({ minLength: 1 }),
 			handoff_path: Type.String({ minLength: 1 }),
+			scope_id: Type.String({ minLength: 1, maxLength: 256 }),
+			cycle_id: Type.String({ minLength: 1, maxLength: 256 }),
+			forecast_role: Type.String({ minLength: 1, maxLength: 64 }),
 			expected_preview_fingerprint: Type.Optional(Type.String({ pattern: "^[a-f0-9]{64}$" })),
 			expected_dashboard_revision: Type.Optional(Type.Union([Type.String({ pattern: "^[a-f0-9]{64}$" }), Type.Null()])),
 			dashboard_title: Type.Optional(Type.String({ minLength: 1, maxLength: 256 })),
@@ -122,8 +126,13 @@ export default function fpaDashboardExtension(pi: ExtensionAPI): void {
 		executionMode: "sequential",
 		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
 			const proposal = await readProjectJsonFile(ctx.cwd, params.proposal_path, "proposal_path");
+			const review = await readProjectJsonFile(ctx.cwd, params.review_path, "review_path");
 			const handoff = await readProjectJsonFile(ctx.cwd, params.handoff_path, "handoff_path");
-			const module = projectStrategyModule(proposal, handoff);
+			const module = projectStrategyModule(proposal, handoff, review, {
+				scope_id: params.scope_id,
+				cycle_id: params.cycle_id,
+				forecast_role: params.forecast_role,
+			});
 			const previewFingerprint = dashboardModuleBuildFingerprint(module);
 			const current = await readDashboardModuleManifest(ctx.cwd);
 			if (params.mode === "preview") return toolResult({

package/extensions/fpa-dashboard/stage-projector.ts

@@ -6,6 +6,20 @@ import type { TableCell } from "./projector.ts";
 import type { ApprovedCycleForecast } from "../fpa-artifacts/contracts.ts";
 import type { ArtifactRefV2 } from "../fpa-artifacts/store.ts";
 
+const STRATEGY_ACTION_LABELS = {
+	grow: "增长",
+	hold: "保持",
+	cut: "削减",
+	stop: "止损",
+} as const;
+type StrategyAction = keyof typeof STRATEGY_ACTION_LABELS;
+
+export interface StrategyModuleContext {
+	scope_id: string;
+	cycle_id: string;
+	forecast_role: string;
+}
+
 function record(value: unknown, label: string): Record<string, unknown> {
 	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`${label} must be an object.`);
 	return value as Record<string, unknown>;
@@ -37,6 +51,11 @@ function lines(value: unknown): string {
 	return value.map((item) => typeof item === "string" ? item : JSON.stringify(item)).join("\n");
 }
 
+function strategyAction(value: unknown, label: string): StrategyAction {
+	if (typeof value === "string" && value in STRATEGY_ACTION_LABELS) return value as StrategyAction;
+	throw new Error(`${label} must be one of grow, hold, cut, stop.`);
+}
+
 export function projectReviewModule(input: unknown): DashboardModuleBuild {
 	const analysis = record(input, "driver_analysis");
 	if (analysis.artifact_type !== "driver_analysis") throw new Error("Review publication requires artifact_type=driver_analysis.");
@@ -93,32 +112,74 @@ export function projectReviewModule(input: unknown): DashboardModuleBuild {
 	};
 }
 
-export function projectStrategyModule(proposalInput: unknown, handoffInput: unknown): DashboardModuleBuild {
+export function projectStrategyModule(
+	proposalInput: unknown,
+	handoffInput: unknown,
+	reviewInput: unknown,
+	expectedContext: StrategyModuleContext,
+): DashboardModuleBuild {
 	const proposal = record(proposalInput, "strategy_proposal");
 	const handoff = record(handoffInput, "reviewed_strategy_handoff");
+	const review = record(reviewInput, "strategy_review");
 	if (proposal.artifact_type !== "strategy_proposal") throw new Error("Strategy publication requires artifact_type=strategy_proposal.");
 	if (handoff.kind !== "fpa.reviewed-strategy-handoff") throw new Error("Strategy publication requires kind=fpa.reviewed-strategy-handoff.");
+	if (review.artifact_type !== "strategy_review") throw new Error("Strategy publication requires artifact_type=strategy_review.");
 	const strategyVersion = requiredString(proposal.strategy_version, "strategy_proposal.strategy_version");
 	if (handoff.strategy_version !== strategyVersion || handoff.reviewed_strategy_version !== strategyVersion) {
 		throw new Error("Reviewed handoff version does not match the strategy proposal version.");
 	}
 	if (handoff.status !== "ready") throw new Error("Reviewed strategy handoff is not ready for a human decision.");
+	if (review.reviewed_strategy_version !== strategyVersion) throw new Error("Strategy review version does not match the strategy proposal version.");
+	if (review.status !== "complete" && review.status !== "complete_with_limits") throw new Error("Strategy review is not complete.");
+	if (review.independence_confirmed !== true || handoff.independence_confirmed !== true) throw new Error("Strategy publication requires an independently reviewed proposal.");
+	const reviewerIdentity = requiredString(review.reviewer_identity, "strategy_review.reviewer_identity");
+	if (handoff.reviewer_identity !== reviewerIdentity) throw new Error("Reviewed handoff reviewer identity does not match the strategy review.");
+	if (review.opinion !== "support" && review.opinion !== "support_with_conditions") throw new Error("Strategy review opinion does not support human approval.");
+	if (handoff.review_opinion !== review.opinion) throw new Error("Reviewed handoff opinion does not match the strategy review.");
+	if (handoff.next_graph !== "fpa-forecast-freeze") throw new Error("Reviewed handoff next_graph must be fpa-forecast-freeze.");
+	for (const key of ["scope_id", "cycle_id", "forecast_role"] as const) {
+		const expected = requiredString(expectedContext[key], `strategy publication ${key}`);
+		if (handoff[key] !== expected) throw new Error(`Reviewed handoff ${key} does not match the publication context.`);
+	}
+	if (handoff.proposal_fingerprint !== fingerprint(proposal)) throw new Error("Reviewed handoff proposal_fingerprint does not match the strategy proposal.");
+	if (handoff.review_fingerprint !== fingerprint(review)) throw new Error("Reviewed handoff review_fingerprint does not match the strategy review.");
+	const reviewConditions = array(review.conditions_for_human_approval ?? [], "strategy_review.conditions_for_human_approval");
+	const residualRisks = array(review.residual_risks ?? [], "strategy_review.residual_risks");
+	if (stableJson(handoff.review_conditions ?? []) !== stableJson(reviewConditions)) throw new Error("Reviewed handoff conditions do not match the strategy review.");
+	if (stableJson(handoff.review_residual_risks ?? []) !== stableJson(residualRisks)) throw new Error("Reviewed handoff residual risks do not match the strategy review.");
 	const allocations = array(proposal.allocation, "strategy_proposal.allocation");
 	const outcomes = record(proposal.expected_outcomes, "strategy_proposal.expected_outcomes");
 	const base = record(outcomes.base ?? {}, "strategy_proposal.expected_outcomes.base");
-	const totalSpend = allocations.reduce((sum, item, index) => {
+	const parsedAllocations = allocations.map((item, index) => {
 		const allocation = record(item, `strategy_proposal.allocation[${index}]`);
-		if (typeof allocation.spend !== "number" || !Number.isFinite(allocation.spend)) throw new Error(`strategy_proposal.allocation[${index}].spend must be a finite number.`);
-		return sum + allocation.spend;
-	}, 0);
+		if (typeof allocation.spend !== "number" || !Number.isFinite(allocation.spend) || allocation.spend < 0) throw new Error(`strategy_proposal.allocation[${index}].spend must be a finite non-negative number.`);
+		if (typeof allocation.change_from_baseline !== "number" || !Number.isFinite(allocation.change_from_baseline)) throw new Error(`strategy_proposal.allocation[${index}].change_from_baseline must be a finite number.`);
+		const action = strategyAction(allocation.action, `strategy_proposal.allocation[${index}].action`);
+		const consistent = action === "grow"
+			? allocation.change_from_baseline > 0
+			: action === "hold"
+				? allocation.change_from_baseline === 0
+				: action === "cut"
+					? allocation.change_from_baseline < 0 && allocation.spend > 0
+					: allocation.change_from_baseline <= 0 && allocation.spend === 0;
+		if (!consistent) throw new Error(`strategy_proposal.allocation[${index}].action ${action} conflicts with spend and change_from_baseline.`);
+		return { allocation, action };
+	});
+	const totalSpend = parsedAllocations.reduce((sum, { allocation }) => sum + (allocation.spend as number), 0);
+	const actionCounts = Object.fromEntries(Object.keys(STRATEGY_ACTION_LABELS).map((action) => [action, 0])) as Record<StrategyAction, number>;
+	for (const { action } of parsedAllocations) actionCounts[action] += 1;
+	const actionHeadline = (Object.entries(STRATEGY_ACTION_LABELS) as [StrategyAction, string][])
+		.map(([action, label]) => `${label} ${actionCounts[action]} 项`)
+		.join("；");
 	return {
 		id: "next-strategy",
 		title: "下周期执行策略",
 		status: "awaiting_decision",
 		source: {
 			artifact_type: "reviewed_strategy",
-			artifact_fingerprint: fingerprint({ proposal, handoff }),
+			artifact_fingerprint: fingerprint({ proposal, review, handoff }),
 			proposal_fingerprint: fingerprint(proposal),
+			review_fingerprint: fingerprint(review),
 			handoff_fingerprint: fingerprint(handoff),
 			strategy_version: strategyVersion,
 			review_opinion: handoff.review_opinion,
@@ -137,6 +198,7 @@ export function projectStrategyModule(proposalInput: unknown, handoffInput: unkn
 						{ metric: "总预算", value: totalSpend.toFixed(2) },
 						{ metric: "Base 收入", value: cell(base.revenue) },
 						{ metric: "Base ROAS", value: cell(base.roas) },
+						{ metric: "执行结论", value: actionHeadline },
 						{ metric: "决策理由", value: lines(proposal.decision_rationale) },
 					],
 				},
@@ -150,12 +212,13 @@ export function projectStrategyModule(proposalInput: unknown, handoffInput: unkn
 					label: "预算分配",
 					columns: [
 						{ key: "app", label: "App" }, { key: "store", label: "商店" }, { key: "channel", label: "渠道" },
+						{ key: "action", label: "动作" },
 						{ key: "spend", label: "预算", align: "right" }, { key: "change", label: "较基线变化", align: "right" },
 					],
-					rows: allocations.map((item, index) => {
-						const allocation = record(item, `strategy_proposal.allocation[${index}]`);
+					rows: parsedAllocations.map(({ allocation, action }) => {
 						return {
 							app: cell(allocation.app_id), store: cell(allocation.store), channel: cell(allocation.channel_group),
+							action: STRATEGY_ACTION_LABELS[action],
 							spend: (allocation.spend as number).toFixed(2), change: cell(allocation.change_from_baseline),
 						};
 					}),

package/extensions/fpa-routing-guard/graph-installer.ts

@@ -0,0 +1,234 @@
+import { createHash, randomUUID } from "node:crypto";
+import { lstat, mkdir, open, readFile, realpath, rename, unlink, writeFile } from "node:fs/promises";
+import { basename, dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const TEMPLATE_NAMES = ["fpa-strategy-planning", "fpa-forecast-freeze"] as const;
+const RETIRED_NAMES = ["fpa-period-analysis", "fpa-strategy-recommendation"] as const;
+const PACKAGE_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "../..");
+
+interface GraphInstallResult {
+	installed: string[];
+	upgraded: string[];
+	retired: string[];
+	backups: string[];
+	warnings: string[];
+}
+
+interface GraphIdentity {
+	name?: string;
+	version?: string;
+}
+
+async function pathStat(path: string) {
+	try {
+		return await lstat(path);
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code === "ENOENT") return undefined;
+		throw error;
+	}
+}
+
+async function secureGraphsDirectory(cwd: string): Promise<{ agentGraph: string; graphs: string }> {
+	const cwdReal = await realpath(cwd);
+	const agentGraph = join(cwdReal, ".agent-graph");
+	const graphs = join(agentGraph, "graphs");
+	for (const directory of [agentGraph, graphs]) {
+		let existing = await pathStat(directory);
+		if (!existing) {
+			try {
+				await mkdir(directory);
+			} catch (error) {
+				if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error;
+			}
+			existing = await pathStat(directory);
+		}
+		if (!existing?.isDirectory() || existing.isSymbolicLink()) {
+			throw new Error(`FP&A Graph directory must be a real directory: ${directory}`);
+		}
+		if (await realpath(directory) !== directory) throw new Error(`FP&A Graph directory escapes the trusted cwd: ${directory}`);
+	}
+	return { agentGraph, graphs };
+}
+
+async function secureChildDirectory(parent: string, directory: string): Promise<void> {
+	if (dirname(directory) !== parent) throw new Error(`FP&A Graph backup directory escapes its parent: ${directory}`);
+	let existing = await pathStat(directory);
+	if (!existing) {
+		try {
+			await mkdir(directory);
+		} catch (error) {
+			if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error;
+		}
+		existing = await pathStat(directory);
+	}
+	if (!existing?.isDirectory() || existing.isSymbolicLink() || await realpath(directory) !== directory) {
+		throw new Error(`FP&A Graph backup directory must be a real directory inside the trusted cwd: ${directory}`);
+	}
+}
+
+function graphIdentity(content: string): GraphIdentity {
+	try {
+		const parsed = JSON.parse(content) as Record<string, unknown>;
+		return {
+			name: typeof parsed.name === "string" ? parsed.name : undefined,
+			version: typeof parsed.version === "string" ? parsed.version : undefined,
+		};
+	} catch {
+		return {};
+	}
+}
+
+function compareVersions(left: string | undefined, right: string | undefined): number | undefined {
+	const parse = (value: string | undefined) => value?.match(/^(\d+)\.(\d+)\.(\d+)$/)?.slice(1).map(Number);
+	const a = parse(left);
+	const b = parse(right);
+	if (!a || !b) return undefined;
+	for (let index = 0; index < 3; index += 1) {
+		if (a[index] !== b[index]) return a[index] - b[index];
+	}
+	return 0;
+}
+
+function safeVersion(value: string | undefined): string {
+	return value?.match(/^\d+\.\d+\.\d+$/)?.[0] ?? "unknown";
+}
+
+async function atomicCreate(path: string, content: string): Promise<void> {
+	await writeFile(path, content, { flag: "wx" });
+}
+
+async function backupFile(agentGraph: string, path: string, content: string, version: string | undefined, removeSource: boolean): Promise<string> {
+	const backupDirectory = join(agentGraph, `graphs_backup_v${safeVersion(version)}`);
+	await secureChildDirectory(agentGraph, backupDirectory);
+	let destination = join(backupDirectory, basename(path));
+	let existing = await pathStat(destination);
+	if (existing) {
+		if (!existing.isFile() || existing.isSymbolicLink()) throw new Error(`Unsafe FP&A Graph backup target: ${destination}`);
+		const existingContent = await readFile(destination, "utf8");
+		if (existingContent === content) {
+			if (removeSource) await unlink(path);
+			return destination;
+		}
+		const fingerprint = createHash("sha256").update(content).digest("hex").slice(0, 12);
+		destination = join(backupDirectory, `${basename(path, ".json")}.${fingerprint}.json`);
+		existing = await pathStat(destination);
+		if (existing) {
+			if (!existing.isFile() || existing.isSymbolicLink() || await readFile(destination, "utf8") !== content) {
+				throw new Error(`Conflicting FP&A Graph backup target: ${destination}`);
+			}
+			if (removeSource) await unlink(path);
+			return destination;
+		}
+	}
+	await atomicCreate(destination, content);
+	if (removeSource) await unlink(path);
+	return destination;
+}
+
+async function atomicWrite(path: string, content: string): Promise<void> {
+	const temporary = join(dirname(path), `.${basename(path)}.${process.pid}.${randomUUID()}.tmp`);
+	await writeFile(temporary, content, { flag: "wx" });
+	try {
+		await rename(temporary, path);
+	} catch (error) {
+		await unlink(temporary).catch(() => undefined);
+		throw error;
+	}
+}
+
+async function withInstallerLock<T>(agentGraph: string, timeoutMs: number, action: () => Promise<T>): Promise<T> {
+	const lockPath = join(agentGraph, ".fpa-graph-installer.lock");
+	let handle: Awaited<ReturnType<typeof open>> | undefined;
+	let ownership: { dev: number | bigint; ino: number | bigint } | undefined;
+	const deadline = Date.now() + Math.max(0, timeoutMs);
+	while (!handle) {
+		try {
+			const candidate = await open(lockPath, "wx", 0o600);
+			try {
+				await candidate.writeFile(`${process.pid} ${Date.now()}\n`);
+				const stat = await candidate.stat();
+				ownership = { dev: stat.dev, ino: stat.ino };
+				handle = candidate;
+			} catch (error) {
+				await candidate.close().catch(() => undefined);
+				await unlink(lockPath).catch(() => undefined);
+				throw error;
+			}
+		} catch (error) {
+			if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error;
+			const stat = await pathStat(lockPath);
+			if (!stat?.isFile() || stat.isSymbolicLink()) throw new Error(`Unsafe FP&A Graph installer lock: ${lockPath}`);
+			// Never steal a pathname from an unknown owner: an old holder could
+			// otherwise unlink the replacement lock from its own finally block.
+			if (Date.now() >= deadline) break;
+			await new Promise((resolve) => setTimeout(resolve, Math.min(25, Math.max(1, deadline - Date.now()))));
+		}
+	}
+	if (!handle) throw new Error(`Timed out waiting for FP&A Graph installer lock: ${lockPath}`);
+	try {
+		return await action();
+	} finally {
+		await handle.close();
+		const current = await pathStat(lockPath);
+		if (
+			ownership
+			&& current?.isFile()
+			&& !current.isSymbolicLink()
+			&& current.dev === ownership.dev
+			&& current.ino === ownership.ino
+		) await unlink(lockPath).catch(() => undefined);
+	}
+}
+
+export async function ensureFpaProjectGraphs(options: { cwd: string; trusted: boolean; lockTimeoutMs?: number }): Promise<GraphInstallResult> {
+	const result: GraphInstallResult = { installed: [], upgraded: [], retired: [], backups: [], warnings: [] };
+	if (!options.trusted) return result;
+	const { agentGraph, graphs } = await secureGraphsDirectory(options.cwd);
+	return withInstallerLock(agentGraph, options.lockTimeoutMs ?? 5_000, async () => {
+		for (const name of TEMPLATE_NAMES) {
+			const sourcePath = join(PACKAGE_ROOT, "graphs", `${name}.json`);
+			const sourceContent = await readFile(sourcePath, "utf8");
+			const sourceIdentity = graphIdentity(sourceContent);
+			if (sourceIdentity.name !== name || !sourceIdentity.version) throw new Error(`Invalid packaged FP&A Graph template: ${sourcePath}`);
+			const targetPath = join(graphs, `${name}.json`);
+			const targetStat = await pathStat(targetPath);
+			if (!targetStat) {
+				await atomicWrite(targetPath, sourceContent);
+				result.installed.push(name);
+				continue;
+			}
+			if (!targetStat.isFile() || targetStat.isSymbolicLink()) {
+				result.warnings.push(`Preserved unsafe or non-file Graph target: ${targetPath}`);
+				continue;
+			}
+			const targetContent = await readFile(targetPath, "utf8");
+			if (targetContent === sourceContent) continue;
+			const targetIdentity = graphIdentity(targetContent);
+			const comparison = compareVersions(targetIdentity.version, sourceIdentity.version);
+			if (targetIdentity.name === name && comparison !== undefined && comparison > 0) {
+				result.warnings.push(`Preserved newer project Graph ${name}@${targetIdentity.version}; package provides ${sourceIdentity.version}.`);
+				continue;
+			}
+			const backup = await backupFile(agentGraph, targetPath, targetContent, targetIdentity.version, false);
+			result.backups.push(backup);
+			await atomicWrite(targetPath, sourceContent);
+			result.upgraded.push(name);
+		}
+
+		for (const name of RETIRED_NAMES) {
+			const path = join(graphs, `${name}.json`);
+			const stat = await pathStat(path);
+			if (!stat) continue;
+			if (!stat.isFile() || stat.isSymbolicLink()) {
+				result.warnings.push(`Preserved unsafe or non-file retired Graph target: ${path}`);
+				continue;
+			}
+			const content = await readFile(path, "utf8");
+			const backup = await backupFile(agentGraph, path, content, graphIdentity(content).version, true);
+			result.backups.push(backup);
+			result.retired.push(name);
+		}
+		return result;
+	});
+}

package/extensions/fpa-routing-guard/index.ts

@@ -5,10 +5,11 @@ import type {
 	ToolResultEvent,
 } from "@earendil-works/pi-coding-agent";
 
+import { ensureFpaProjectGraphs } from "./graph-installer.ts";
+
 const GRAPH_TOOLS = ["graph_list", "graph_run"] as const;
+const ROUTING_STATE_CUSTOM_TYPE = "fpa-routing-guard-state";
 const FP_AND_A_GRAPHS = [
-	"fpa-period-analysis",
-	"fpa-strategy-recommendation",
 	"fpa-strategy-planning",
 	"fpa-forecast-freeze",
 	"fpa-strategy-execution",
@@ -22,6 +23,14 @@ interface RoutingState {
 	availableGraphs: Set<string>;
 	graphRunStarted: boolean;
 	graphRunCompleted: boolean;
+	reviewPublished: boolean;
+}
+
+interface PersistedRoutingState {
+	version: 1;
+	requiredGraph: FpaGraph;
+	graphRunCompleted: boolean;
+	reviewPublished: boolean;
 }
 
 function emptyState(): RoutingState {
@@ -30,6 +39,7 @@ function emptyState(): RoutingState {
 		availableGraphs: new Set(),
 		graphRunStarted: false,
 		graphRunCompleted: false,
+		reviewPublished: false,
 	};
 }
 
@@ -60,6 +70,10 @@ function isExplicitIsolatedPhase(prompt: string): boolean {
 	const skill = prompt.match(/^<skill name="(fpa-[^"]+)"/);
 	if (skill && skill[1] !== "fpa-apply-core-rules") return true;
 	if (!/(?:^|[。；;]\s*)(?:请)?(?:本次)?(?:只|仅)|\bonly\b/i.test(prompt)) return false;
+	if (
+		FP_AND_A_GRAPHS.some((graph) => prompt.toLowerCase().includes(graph))
+		&& /(?:运行|执行|启动|调用|使用|通过|\brun\b|\bexecute\b|\bstart\b)/i.test(prompt)
+	) return false;
 	return !/(?:然后|接着|随后|再进入|后再|直至|全流程|完整流程|end[- ]to[- ]end)/i.test(prompt);
 }
 
@@ -119,7 +133,7 @@ export function classifyFpaGraph(prompt: string): FpaGraph | undefined {
 		return "fpa-strategy-execution";
 	}
 
-	return hasFpaIntent(normalized) ? "fpa-period-analysis" : undefined;
+	return hasFpaIntent(normalized) ? "fpa-strategy-planning" : undefined;
 }
 
 function contentText(event: ToolResultEvent): string {
@@ -148,30 +162,93 @@ function artifactWrite(event: ToolCallEvent): boolean {
 	return /artifacts?[\\/]/i.test(command);
 }
 
-function routingInstruction(graph: FpaGraph): string {
-	return [
+function graphContextError(event: ToolCallEvent, graph: FpaGraph): string | undefined {
+	const context = "context" in event.input ? event.input.context : undefined;
+	if (!context || typeof context !== "object" || Array.isArray(context)) {
+		return "graph_run requires a context object whose values are strings.";
+	}
+	const values = context as Record<string, unknown>;
+	const required = graph === "fpa-strategy-planning" || graph === "fpa-forecast-freeze"
+		? ["scope_id", "cycle_id", "forecast_role"]
+		: [];
+	const missing = required.filter((key) => !(key in values) || (typeof values[key] === "string" && values[key].trim().length === 0));
+	if (missing.length > 0) return `graph_run requires non-empty string context keys: ${missing.join(", ")}.`;
+	const nonStrings = Object.entries(values)
+		.filter(([, value]) => typeof value !== "string")
+		.map(([key]) => key);
+	return nonStrings.length > 0
+		? `All graph_run context values must be strings; invalid keys: ${nonStrings.join(", ")}. Put structured data in goal.`
+		: undefined;
+}
+
+function routingInstruction(graph: FpaGraph, resumeCompletedGraph = false): string {
+	const instructions = [
 		"FP&A runtime routing guard is active for this request.",
 		`The first eligible workflow is ${graph}.`,
-		"Call graph_list first, then graph_run with that exact graph and the complete immutable context.",
+		"Call graph_list first, then graph_run with that exact graph. All graph_run context values must be strings; never pass arrays, objects, numbers, booleans, or null.",
 		"Graph nodes own business phase execution. After a successful Graph handoff, only the main Agent may call the matching fpa_dashboard_publish_* tool; Graphs must never publish dashboard data.",
-	].join(" ");
+	];
+	if (graph === "fpa-strategy-planning" || graph === "fpa-forecast-freeze") {
+		instructions.push("Provide the immutable non-empty string context keys scope_id, cycle_id, and forecast_role. Put structured planning details in goal, not context.");
+	}
+	if (graph === "fpa-strategy-planning") {
+		instructions.push(resumeCompletedGraph
+			? "A completed combined Graph handoff was restored from this session. Continue modular publication from its persisted artifacts; do not rerun the Graph unless those artifacts are unavailable or the user changed the planning requirements. Publish period-review before next-strategy."
+			: "After this combined Graph completes, the main Agent must publish period-review first from artifacts/driver_analysis.json, then publish next-strategy from artifacts/strategy_proposal.json, artifacts/strategy_review.json, and artifacts/reviewed_strategy_handoff.json with the exact scope_id, cycle_id, forecast_role, and a fresh dashboard revision. Stop for the dashboard decision; do not run forecast yet.");
+	}
+	return instructions.join(" ");
 }
 
 export default function fpaRoutingGuardExtension(pi: ExtensionAPI): void {
 	let state = emptyState();
+	let installWarning: string | undefined;
+
+	function persistState(): void {
+		if (!state.requiredGraph) return;
+		pi.appendEntry(ROUTING_STATE_CUSTOM_TYPE, {
+			version: 1,
+			requiredGraph: state.requiredGraph,
+			graphRunCompleted: state.graphRunCompleted,
+			reviewPublished: state.reviewPublished,
+		} satisfies PersistedRoutingState);
+	}
+
+	pi.on("session_start", async (_event, ctx) => {
+		state = emptyState();
+		installWarning = undefined;
+		try {
+			const installed = await ensureFpaProjectGraphs({ cwd: ctx.cwd, trusted: ctx.isProjectTrusted() });
+			if (installed.warnings.length > 0) installWarning = installed.warnings.join(" ");
+		} catch (error) {
+			installWarning = error instanceof Error ? error.message : String(error);
+		}
+		const restored = [...ctx.sessionManager.getBranch()].reverse().find((entry) => entry.type === "custom" && entry.customType === ROUTING_STATE_CUSTOM_TYPE);
+		if (!restored || restored.type !== "custom" || !restored.data || typeof restored.data !== "object" || Array.isArray(restored.data)) return;
+		const data = restored.data as Partial<PersistedRoutingState>;
+		if (data.version !== 1 || !FP_AND_A_GRAPHS.includes(data.requiredGraph as FpaGraph)) return;
+		state.requiredGraph = data.requiredGraph;
+		state.graphRunStarted = data.graphRunCompleted === true;
+		state.graphRunCompleted = data.graphRunCompleted === true;
+		state.reviewPublished = data.graphRunCompleted === true && data.reviewPublished === true;
+	});
 
 	pi.on("before_agent_start", (event: BeforeAgentStartEvent) => {
-		const previousGraph = state.requiredGraph;
+		const previousState = state;
 		state = emptyState();
 		const active = new Set(pi.getActiveTools());
 		if (!GRAPH_TOOLS.every((tool) => active.has(tool))) return;
 
 		const classified = classifyFpaGraph(event.prompt);
 		const isContinuation = /^(?:继续|接着|下一步|continue|go on)[。.!！\s]*$/i.test(event.prompt.trim());
-		const requiredGraph = classified ?? (isContinuation ? previousGraph : undefined);
+		const requiredGraph = classified ?? (isContinuation ? previousState.requiredGraph : undefined);
 		if (!requiredGraph) return;
 		state.requiredGraph = requiredGraph;
-		return { systemPrompt: `${event.systemPrompt}\n\n${routingInstruction(requiredGraph)}` };
+		if (isContinuation && previousState.requiredGraph === requiredGraph) {
+			state.graphRunStarted = previousState.graphRunCompleted;
+			state.graphRunCompleted = previousState.graphRunCompleted;
+			state.reviewPublished = previousState.reviewPublished;
+		}
+		return { systemPrompt: `${event.systemPrompt}\n\n${routingInstruction(requiredGraph, state.graphRunCompleted)}${installWarning ? `\n\nFP&A Graph provisioning warning: ${installWarning}` : ""}` };
 	});
 
 	pi.on("tool_call", (event: ToolCallEvent) => {
@@ -184,15 +261,6 @@ export default function fpaRoutingGuardExtension(pi: ExtensionAPI): void {
 				return { block: true, reason: `Call graph_list before graph_run for ${graph}.` };
 			}
 			const requested = "graph" in event.input ? event.input.graph : undefined;
-			if (graph === "fpa-period-analysis" && state.graphRunCompleted && requested === "fpa-strategy-recommendation") {
-				if (!state.availableGraphs.has("fpa-strategy-recommendation")) {
-					return { block: true, reason: "fpa-strategy-recommendation is unavailable; do not emulate strategy work in the parent Agent." };
-				}
-				state.requiredGraph = "fpa-strategy-recommendation";
-				state.graphRunStarted = true;
-				state.graphRunCompleted = false;
-				return;
-			}
 			if (requested !== graph) {
 				return { block: true, reason: `Run the first eligible ${graph} Graph; received ${String(requested)}.` };
 			}
@@ -202,21 +270,28 @@ export default function fpaRoutingGuardExtension(pi: ExtensionAPI): void {
 					reason: `${graph} is not available. Return blocked; local work requires a new, explicit isolated-phase request.`,
 				};
 			}
+			const contextError = graphContextError(event, graph);
+			if (contextError) return { block: true, reason: contextError };
 			state.graphRunStarted = true;
 			state.graphRunCompleted = false;
+			state.reviewPublished = false;
+			persistState();
 			return;
 		}
 
 		if (event.toolName === "fpa_dashboard_module_status") return;
-		if ((graph === "fpa-forecast-freeze" || graph === "fpa-strategy-recommendation") && !state.graphRunStarted && event.toolName === "fpa_strategy_decision_commit") return;
-		const allowedPublication = graph === "fpa-period-analysis"
-			? "fpa_dashboard_publish_review"
-			: graph === "fpa-strategy-recommendation"
-				? "fpa_dashboard_publish_strategy"
-				: graph === "fpa-forecast-freeze"
-					? "fpa_dashboard_publish_forecast"
-					: "fpa_dashboard_refresh_queue";
-		if (event.toolName === allowedPublication && state.graphRunCompleted) return;
+		if ((graph === "fpa-forecast-freeze" || graph === "fpa-strategy-planning") && !state.graphRunStarted && event.toolName === "fpa_strategy_decision_commit") return;
+		const allowedPublications = graph === "fpa-strategy-planning"
+			? new Set(["fpa_dashboard_publish_review", "fpa_dashboard_publish_strategy"])
+			: graph === "fpa-forecast-freeze"
+				? new Set(["fpa_dashboard_publish_forecast"])
+				: new Set(["fpa_dashboard_refresh_queue"]);
+		if (allowedPublications.has(event.toolName) && state.graphRunCompleted) {
+			if (graph === "fpa-strategy-planning" && event.toolName === "fpa_dashboard_publish_strategy" && !state.reviewPublished) {
+				return { block: true, reason: "Publish the period-review module successfully before previewing or publishing next-strategy." };
+			}
+			return;
+		}
 
 		if (!event.toolName.startsWith("fpa_") && !artifactWrite(event)) return;
 		if (!state.catalogLoaded) {
@@ -249,6 +324,17 @@ export default function fpaRoutingGuardExtension(pi: ExtensionAPI): void {
 				? (event.details as { status?: unknown }).status
 				: undefined;
 			state.graphRunCompleted = status !== "failed" && status !== "blocked" && status !== "cancelled";
+			persistState();
+			return;
+		}
+		if (event.toolName === "fpa_dashboard_publish_review" && state.graphRunCompleted) {
+			const status = event.details && typeof event.details === "object" && "status" in event.details
+				? (event.details as { status?: unknown }).status
+				: undefined;
+			if (status === "published") {
+				state.reviewPublished = true;
+				persistState();
+			}
 		}
 	});
 }

package/graphs/fpa-forecast-freeze.json

@@ -1,11 +1,95 @@
 {
+  "description": "FP&A 正式预测冻结：消费已审核策略交接与主 Agent 已提交的精确 strategy_decision，生成、合成并冻结 approved_cycle_forecast；Graph 不请求审批、不发布仪表盘。",
+  "maxSteps": 10,
+  "mutationPolicy": "mutating",
   "name": "fpa-forecast-freeze",
-  "version": "2.0.0",
-  "start": "load_confirmed_strategy",
   "nodes": [
-    { "id": "load_confirmed_strategy", "type": "subagent", "agentName": "load_confirmed_strategy", "next": "draft_forecast", "tools": ["read"], "prompt": "核验主 Agent 已提交的策略 decision 与 reviewed handoff 精确一致；不得审批或发布仪表盘。" },
-    { "id": "draft_forecast", "type": "subagent", "agentName": "draft_forecast", "next": "compose_forecast", "skills": ["fpa-forecast-approved-strategy"], "tools": ["read", "write", "fpa_calc"], "prompt": "只按已确认策略写预测计划；不得重新优化策略或发布仪表盘。" },
-    { "id": "compose_forecast", "type": "tool", "tool": "fpa_forecast_compose", "next": "commit_forecast", "args": { "plan_path": "artifacts/forecast_plan.json" } },
-    { "id": "commit_forecast", "type": "tool", "tool": "fpa_artifact_commit", "mutates": true, "args": { "artifact": "{{data.compose_forecast.details.artifact}}", "context": { "scope_id": "{{context.scope_id}}", "cycle_id": "{{context.cycle_id}}", "forecast_role": "{{context.forecast_role}}" } } }
-  ]
+    {
+      "agentName": "load_confirmed_strategy",
+      "id": "load_confirmed_strategy",
+      "label": "核验已确认策略",
+      "next": "route_confirmed_strategy",
+      "outputKey": "confirmed_strategy",
+      "parseJson": true,
+      "prompt": "操作备注：{{goal}}\n\n读取 artifacts/reviewed_strategy_handoff.json、其中绑定的 strategy_proposal 与 strategy_review，以及操作备注明确给出的 strategy_decision path。必须核验 handoff status=ready；scope_id/cycle_id/forecast_role 与 Graph context 一致；proposal、review、handoff 的 strategy_version 一致；decision.kind=fpa.strategy.decision、decision=confirm；decision 的 strategy_version、handoff_fingerprint、decision_fingerprint 与操作备注和当前 handoff 精确一致。任一不一致即 blocked。不得请求或记录第二次审批，不得调用任何 fpa_dashboard_* 工具。\n\n只输出 JSON：{\"status\":\"ready|blocked\",\"strategy_version\":\"...\",\"strategy_decision_path\":\"...\",\"strategy_decision_fingerprint\":\"...\",\"review_conditions\":[],\"blockers\":[]}",
+      "skills": ["fpa-apply-core-rules"],
+      "systemPrompt": "你是 FP&A 已确认策略核验 Agent。只读核验主 Agent 已提交的不可变决策，不批准、不预测、不发布仪表盘。权威上下文为 scope_id={{context.scope_id}}、cycle_id={{context.cycle_id}}、forecast_role={{context.forecast_role}}。",
+      "tools": ["read"],
+      "type": "subagent"
+    },
+    {
+      "cases": [
+        { "equals": "ready", "label": "确认有效", "to": "draft_forecast" },
+        { "equals": "blocked", "label": "确认无效", "to": "report_blocked" }
+      ],
+      "default": { "label": "其他结果", "to": "report_blocked" },
+      "id": "route_confirmed_strategy",
+      "label": "判断是否可预测",
+      "path": "data.confirmed_strategy.status",
+      "type": "router"
+    },
+    {
+      "id": "report_blocked",
+      "label": "报告预测阻断",
+      "outputKey": "forecast_blocked",
+      "parseJson": true,
+      "prompt": "核验结果：{{data.confirmed_strategy}}\n\n只输出 JSON：{\"kind\":\"fpa.graph-handoff\",\"status\":\"blocked\",\"graph\":\"fpa-forecast-freeze\",\"blockers\":[],\"required_action\":\"由原主会话提交与当前 handoff 精确匹配的策略确认\"}",
+      "systemPrompt": "用中文简洁报告预测阻断，只输出约定 JSON。",
+      "type": "prompt"
+    },
+    {
+      "agentName": "draft_forecast",
+      "id": "draft_forecast",
+      "label": "正式预测决策计划",
+      "next": "compose_forecast",
+      "outputKey": "draft_forecast",
+      "prompt": "操作备注：{{goal}}\n\n已核验策略与决策：{{data.confirmed_strategy}}\n\n读取 reviewed_strategy_handoff、strategy_proposal、strategy_review 和精确 strategy_decision，按 fpa-forecast-approved-strategy 写 artifacts/forecast_plan.json。不得重新优化策略；业务分配、范围、假设或审核条件需变化时必须 blocked 并回到策略规划。只写 allocation 与每个切片的 ROAS assumptions；revenue、汇总、单位和 frozen_at 由下游 fpa_forecast_compose 推导。切片键必须使用 ua_spend 的 app_code/platform/media_source 合法值。不得调用任何 fpa_dashboard_* 工具。",
+      "skills": ["fpa-apply-core-rules", "fpa-forecast-approved-strategy"],
+      "systemPrompt": "你是 FP&A 正式预测 Agent。只按已确认策略写预测计划，不请求审批、不发布仪表盘、不手算派生值。",
+      "tools": ["read", "write", "fpa_calc"],
+      "type": "subagent"
+    },
+    {
+      "args": { "plan_path": "artifacts/forecast_plan.json" },
+      "failure": { "maxAttempts": 2, "onError": "repair_forecast_plan" },
+      "id": "compose_forecast",
+      "label": "合成正式预测",
+      "next": "commit_forecast",
+      "outputKey": "compose_forecast",
+      "tool": "fpa_forecast_compose",
+      "type": "tool"
+    },
+    {
+      "agentName": "repair_forecast_plan",
+      "id": "repair_forecast_plan",
+      "label": "定点修正预测计划",
+      "next": "compose_forecast",
+      "outputKey": "repair_forecast_plan",
+      "prompt": "合成失败：{{data.__graphError}}\n\n读取 artifacts/forecast_plan.json、planning_brief 和 reviewed_strategy_handoff，只定点修正格式、合法切片键或 forecast plan 契约问题。不得改变已确认策略的业务分配、范围、假设或条件；若错误要求此类变化，报告 blocked。不得调用任何 fpa_dashboard_* 工具。",
+      "skills": ["fpa-forecast-approved-strategy"],
+      "systemPrompt": "你是预测计划修复 Agent，只按确定性合成报错做最小修正。",
+      "tools": ["read", "write", "edit"],
+      "type": "subagent"
+    },
+    {
+      "args": {
+        "artifact": "{{data.compose_forecast.details.artifact}}",
+        "context": {
+          "cycle_id": "{{context.cycle_id}}",
+          "forecast_role": "{{context.forecast_role}}",
+          "scope_id": "{{context.scope_id}}"
+        }
+      },
+      "id": "commit_forecast",
+      "label": "冻结正式预测",
+      "mutates": true,
+      "outputKey": "commit_forecast",
+      "tool": "fpa_artifact_commit",
+      "type": "tool"
+    }
+  ],
+  "schemaVersion": 1,
+  "start": "load_confirmed_strategy",
+  "transitionLabels": { "default": "其他情况", "error": "失败", "next": "继续" },
+  "version": "2.1.0"
 }

package/graphs/fpa-strategy-planning.json

@@ -0,0 +1,159 @@
+{
+  "schemaVersion": 1,
+  "name": "fpa-strategy-planning",
+  "version": "4.2.0",
+  "description": "FP&A 组合式策略规划：在一个 Graph 内完成目标规划、并行只读数据/驱动审计、并行只读场景分析、策略推荐与独立审核，最终形成 reviewed_strategy_handoff。必须提供字符串 context.scope_id、context.cycle_id、context.forecast_role；Graph 不审批、不预测、不发布仪表盘。",
+  "mutationPolicy": "mutating",
+  "start": "plan_cycle",
+  "maxSteps": 24,
+  "nodes": [
+    {
+      "id": "plan_cycle",
+      "type": "subagent",
+      "agentName": "plan_cycle",
+      "label": "目标与范围规划",
+      "outputKey": "plan_cycle",
+      "next": "parallel_analysis",
+      "systemPrompt": "你是 FP&A 目标规划 Agent。权威上下文为 scope_id={{context.scope_id}}、cycle_id={{context.cycle_id}}、forecast_role={{context.forecast_role}}。不得从目标文本猜测或替换这些标识。",
+      "prompt": "目标：{{goal}}\n\n按 fpa-plan-cycle 先调用 fpa_data_catalog 实测目标期和对比期字段可用性，再写 artifacts/planning_brief.md。明确目标、预算、周期、in_scope/out_of_scope 维度与指标、App 清单及增长/成熟/收缩角色。正式预测指标白名单仅为 spend、revenue、roas。不得生成策略、预测或调用任何 fpa_dashboard_* 工具。",
+      "skills": ["fpa-apply-core-rules", "fpa-plan-cycle"],
+      "tools": ["read", "write", "fpa_data_catalog"]
+    },
+    {
+      "id": "parallel_analysis",
+      "type": "parallel",
+      "label": "并行数据与经营审计",
+      "concurrency": 2,
+      "next": "synthesize_analysis",
+      "children": [
+        {
+          "id": "actuals_audit",
+          "type": "subagent",
+          "agentName": "actuals_audit",
+          "systemPrompt": "你是只读 FP&A 数据质量审计 Agent。不得写文件或发布仪表盘。",
+          "prompt": "目标：{{goal}}\n\n读取 artifacts/planning_brief.md，按 fpa-diagnose-actuals 检查数据窗口、字段覆盖、revenue 回刷成熟度、cohort 可用性、scope reduction 与 blocking issue。只输出结构化 JSON 证据给汇总节点，不写任何 artifact。",
+          "skills": ["fpa-apply-core-rules", "fpa-diagnose-actuals"],
+          "tools": ["read", "fpa_data_catalog", "fpa_query", "fpa_cohort"]
+        },
+        {
+          "id": "driver_audit",
+          "type": "subagent",
+          "agentName": "driver_audit",
+          "systemPrompt": "你是只读 FP&A 经营驱动审计 Agent。不得写文件或发布仪表盘。",
+          "prompt": "目标：{{goal}}\n\n读取 artifacts/planning_brief.md，按 in_scope_dimensions 独立查询 spend、revenue、roas、cpi、installs，分析组合、App、商店、渠道和平台驱动；明确每个 App/切片的增长、保持、削减或止损证据。只输出结构化 JSON，不写任何 artifact。",
+          "skills": ["fpa-apply-core-rules", "fpa-analyze-drivers"],
+          "tools": ["read", "fpa_query", "fpa_cohort", "fpa_compare", "fpa_calc"]
+        }
+      ]
+    },
+    {
+      "id": "synthesize_analysis",
+      "type": "subagent",
+      "agentName": "synthesize_analysis",
+      "label": "汇总上周期分析",
+      "outputKey": "driver_analysis",
+      "next": "parallel_scenarios",
+      "systemPrompt": "你是 FP&A 分析汇总 Agent。只整合并复核并行审计证据，不补造数据。",
+      "prompt": "目标：{{goal}}\n\n并行审计：{{data.parallel_analysis}}\n\n读取 planning_brief，交叉核对两个只读审计结果；冲突时重新用确定性工具复算。写 artifacts/actuals_snapshot.md、artifacts/data_issue_report.md、artifacts/driver_analysis.md 和机器可读 artifacts/driver_analysis.json。JSON 必须符合 driver_analysis contract，包含 artifact_type、status、headline_results、drivers、data_limits/limitations，并对每个 App 或 in-scope 切片给出增长/保持/削减/止损结论与证据。不得生成策略或发布仪表盘。",
+      "skills": ["fpa-apply-core-rules", "fpa-diagnose-actuals", "fpa-analyze-drivers"],
+      "tools": ["read", "write", "fpa_query", "fpa_compare", "fpa_calc"]
+    },
+    {
+      "id": "parallel_scenarios",
+      "type": "parallel",
+      "label": "并行策略场景分析",
+      "concurrency": 3,
+      "next": "synthesize_scenarios",
+      "children": [
+        {
+          "id": "efficiency_lane",
+          "type": "subagent",
+          "agentName": "efficiency_lane",
+          "systemPrompt": "你是只读 FP&A 稳健效率场景 Agent。不得写文件、批准策略或发布仪表盘。",
+          "prompt": "读取 planning_brief、actuals_snapshot 与 driver_analysis，构造维持硬 ROAS 下限的稳健/效率候选场景，逐 App/商店/渠道给出完整 allocation、downside/base/upside、假设和止损。只输出结构化 JSON 候选，不写 artifact。",
+          "skills": ["fpa-apply-core-rules", "fpa-simulate-strategies"],
+          "tools": ["read", "fpa_query", "fpa_calc"]
+        },
+        {
+          "id": "growth_lane",
+          "type": "subagent",
+          "agentName": "growth_lane",
+          "systemPrompt": "你是只读 FP&A 增长与探索场景 Agent。不得写文件、批准策略或发布仪表盘。",
+          "prompt": "读取 planning_brief、actuals_snapshot 与 driver_analysis，构造增长/探索候选场景；探索预算约 10%，逐 App/商店/渠道给出完整 allocation、downside/base/upside、假设和止损。只输出结构化 JSON 候选，不写 artifact。",
+          "skills": ["fpa-apply-core-rules", "fpa-simulate-strategies"],
+          "tools": ["read", "fpa_query", "fpa_calc"]
+        },
+        {
+          "id": "risk_lane",
+          "type": "subagent",
+          "agentName": "risk_lane",
+          "systemPrompt": "你是只读 FP&A 约束与风险挑战 Agent。不得写文件、批准策略或发布仪表盘。",
+          "prompt": "读取 planning_brief 与 driver_analysis，独立检查预算上下限、ROAS 硬下限、Revenue 次目标、ROAS<0.5 止损、集中度、外推和数据成熟度。输出每个候选策略必须满足的约束、压力测试区间与淘汰规则，只输出结构化 JSON。",
+          "skills": ["fpa-apply-core-rules", "fpa-simulate-strategies"],
+          "tools": ["read", "fpa_query", "fpa_calc"]
+        }
+      ]
+    },
+    {
+      "id": "synthesize_scenarios",
+      "type": "subagent",
+      "agentName": "synthesize_scenarios",
+      "label": "汇总候选策略",
+      "outputKey": "strategy_scenarios",
+      "next": "recommend_strategy",
+      "systemPrompt": "你是 FP&A 场景汇总 Agent。所有加总、ROAS 和约束判断必须确定性复算。",
+      "prompt": "目标：{{goal}}\n\n并行场景与风险审计：{{data.parallel_scenarios}}\n\n读取权威上游工件，合并、去重并复算候选场景，至少保留现状、稳健和增长场景。写 artifacts/strategy_scenarios.md 与符合 contract 的 artifacts/strategy_scenarios.json；逐切片完整覆盖，探索/利用分开，所有 ROAS<0.5 切片必须削减或清零。不得推荐、批准、预测或发布仪表盘。",
+      "skills": ["fpa-apply-core-rules", "fpa-simulate-strategies"],
+      "tools": ["read", "write", "fpa_calc"]
+    },
+    {
+      "id": "recommend_strategy",
+      "type": "subagent",
+      "agentName": "recommend_strategy",
+      "label": "形成执行策略",
+      "outputKey": "strategy_proposal",
+      "next": "review_strategy",
+      "systemPrompt": "你是 FP&A 策略推荐 Agent。不得自我批准、生成预测或发布仪表盘。",
+      "prompt": "目标：{{goal}}\n\n读取 planning_brief、driver_analysis 和 strategy_scenarios，按 fpa-recommend-strategy 选择推荐策略。写 artifacts/strategy_proposal.md 与符合 contract 的 artifacts/strategy_proposal.json。allocation 必须逐 App/商店/渠道包含显式 action（grow/hold/cut/stop）、spend 与 change_from_baseline，使 Dashboard 能明确展示增长、保持、削减和止损；保留完整 expected_outcomes、理由、风险、阈值和 required_human_decisions。",
+      "skills": ["fpa-apply-core-rules", "fpa-recommend-strategy"],
+      "tools": ["read", "write", "fpa_calc"]
+    },
+    {
+      "id": "review_strategy",
+      "type": "subagent",
+      "agentName": "review_strategy",
+      "label": "独立审核",
+      "outputKey": "strategy_review",
+      "parseJson": true,
+      "next": "route_review",
+      "systemPrompt": "你是未参与推荐生成的 FP&A 独立审核 Agent。不得批准策略、生成预测或发布仪表盘。",
+      "prompt": "读取 proposal 及全部上游机器工件，按 fpa-review-strategy 独立复算覆盖、加总、ROAS、止损、探索占比、外推与数据血缘。写 artifacts/strategy_review.md 和 artifacts/strategy_review.json。最终只输出路由 JSON：{\"status\":\"support|support_with_conditions|reject\",\"summary\":\"...\",\"conditions\":[]}。",
+      "skills": ["fpa-apply-core-rules", "fpa-review-strategy"],
+      "tools": ["read", "write", "fpa_query", "fpa_calc"]
+    },
+    {
+      "id": "route_review",
+      "type": "router",
+      "label": "审核结果路由",
+      "path": "data.strategy_review.status",
+      "cases": [
+        { "equals": "reject", "label": "审核拒绝，重新推荐", "to": "recommend_strategy" },
+        { "equals": "support", "label": "审核支持", "to": "prepare_strategy_handoff" },
+        { "equals": "support_with_conditions", "label": "有条件支持", "to": "prepare_strategy_handoff" }
+      ],
+      "default": { "label": "其他结果，重新推荐", "to": "recommend_strategy" }
+    },
+    {
+      "id": "prepare_strategy_handoff",
+      "type": "subagent",
+      "agentName": "prepare_strategy_handoff",
+      "label": "形成已审核策略交接",
+      "outputKey": "strategy_handoff",
+      "parseJson": true,
+      "systemPrompt": "你是 FP&A 策略交接 Agent。权威上下文为 scope_id={{context.scope_id}}、cycle_id={{context.cycle_id}}、forecast_role={{context.forecast_role}}。不批准、不预测、不发布仪表盘。",
+      "prompt": "读取 planning_brief、driver_analysis.json、strategy_scenarios.json、strategy_proposal.json 与 strategy_review.json，先调用 fpa_json_fingerprint 对 proposal/review 两个 JSON 生成确定性 SHA-256，再严格按 fpa-review-strategy 的 reviewed_strategy_handoff contract 核验并写 artifacts/reviewed_strategy_handoff.json。ready 文件必须包含 kind=fpa.reviewed-strategy-handoff、scope_id/cycle_id/forecast_role、相同的 strategy_version 与 reviewed_strategy_version、工具返回的 proposal/review fingerprint、独立审核身份、review_opinion、条件、剩余风险和 next_graph=fpa-forecast-freeze；失败时写 blocked 结果且不得覆盖已有 ready 文件。最终只输出 fpa.graph-handoff JSON。Graph 到此结束，由主 Agent 依次发布 period-review 与 next-strategy 模块并等待用户决策。",
+      "skills": ["fpa-apply-core-rules", "fpa-review-strategy"],
+      "tools": ["read", "write", "fpa_json_fingerprint"]
+    }
+  ]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@viccydev/pi-fpa",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "type": "module",
   "description": "Full-cycle FP&A planning, strategy, forecast, and review prompts, skills, and data tools for Pi",
   "license": "UNLICENSED",
@@ -31,7 +31,7 @@
 		"fpa-dashboard-worker": "./bin/fpa-dashboard-worker.mjs"
 	},
   "scripts": {
-		"test": "node tests/package-structure.test.mjs && node tests/workflow-routing.test.mjs && node --test tests/workflow-routing-guard.test.mjs tests/graph-contract.test.mjs && node tests/extension-unit.test.mjs && node --test tests/catalog-timeout.test.mjs tests/artifact-store.test.mjs tests/artifact-ledger.test.mjs tests/artifact-handoff.test.mjs tests/forecast-compose.test.mjs tests/dashboard-actuals.test.mjs tests/dashboard-projector.test.mjs tests/dashboard-module-publisher.test.mjs tests/dashboard-stage-projector.test.mjs tests/strategy-decision.test.mjs tests/cycle-operating-projection.test.mjs tests/forward-outlook.test.mjs tests/forecast-accuracy.test.mjs tests/dashboard-publisher.test.mjs tests/dashboard-provenance.test.mjs tests/dashboard-coordinator.test.mjs && node tests/pi-loader-smoke.mjs && node tests/worker-loader-smoke.mjs && node tests/publish-workflow.test.mjs",
+		"test": "node tests/package-structure.test.mjs && node tests/workflow-routing.test.mjs && node --test tests/workflow-routing-guard.test.mjs tests/graph-contract.test.mjs tests/graph-installer.test.mjs && node tests/extension-unit.test.mjs && node --test tests/catalog-timeout.test.mjs tests/artifact-store.test.mjs tests/artifact-ledger.test.mjs tests/artifact-handoff.test.mjs tests/forecast-compose.test.mjs tests/dashboard-actuals.test.mjs tests/dashboard-projector.test.mjs tests/dashboard-module-publisher.test.mjs tests/dashboard-stage-projector.test.mjs tests/strategy-decision.test.mjs tests/cycle-operating-projection.test.mjs tests/forward-outlook.test.mjs tests/forecast-accuracy.test.mjs tests/dashboard-publisher.test.mjs tests/dashboard-provenance.test.mjs tests/dashboard-coordinator.test.mjs && node tests/pi-loader-smoke.mjs && node tests/worker-loader-smoke.mjs && node tests/publish-workflow.test.mjs",
     "test:structure": "node tests/package-structure.test.mjs",
 		"test:unit": "node tests/extension-unit.test.mjs && node --test tests/catalog-timeout.test.mjs tests/artifact-store.test.mjs tests/artifact-ledger.test.mjs tests/artifact-handoff.test.mjs tests/forecast-compose.test.mjs tests/dashboard-actuals.test.mjs tests/dashboard-projector.test.mjs tests/dashboard-module-publisher.test.mjs tests/dashboard-stage-projector.test.mjs tests/strategy-decision.test.mjs tests/cycle-operating-projection.test.mjs tests/forward-outlook.test.mjs tests/forecast-accuracy.test.mjs tests/dashboard-publisher.test.mjs tests/dashboard-provenance.test.mjs tests/dashboard-coordinator.test.mjs",
     "test:loader": "node tests/pi-loader-smoke.mjs && node tests/worker-loader-smoke.mjs",

package/prompts/fpa-plan-cycle.md

@@ -17,19 +17,19 @@ argument-hint: "<project-root> <cycle-id> [instructions]"
 ## 强制 Graph 路由
 
 先读取 `fpa-apply-core-rules`。如果当前 Agent 提供 `graph_list` 和
-`graph_run`，必须先调用 `graph_list`，确认 `fpa-period-analysis` 与
-`fpa-strategy-recommendation` 后按以下边界执行：
-
-1. 以完整用户目标、项目根、周期边界、业务范围和数据上下文运行
-   `fpa-period-analysis`。Graph 返回 `artifacts/driver_analysis.json` 后，父
-   Agent 调用 `fpa_dashboard_publish_review` 先 preview，再用精确
-   fingerprint/revision 发布 `period-review`。
-2. 再运行 `fpa-strategy-recommendation`。Graph 返回
-   `strategy_proposal.json` 与 `reviewed_strategy_handoff.json` 后，父 Agent
-   调用 `fpa_dashboard_publish_strategy` preview/publish，发布
+`graph_run`，必须先调用 `graph_list`，确认 `fpa-strategy-planning` 后按以下边界执行：
+
+1. 以完整用户目标运行一个组合式 `fpa-strategy-planning`。`graph_run.context`
+   的所有值必须是字符串，并明确提供 `scope_id`、`cycle_id`、
+   `forecast_role`；对象、数组、数字和其他结构化要求全部留在 `goal`。
+2. Graph 返回 `driver_analysis.json`、`strategy_proposal.json`、
+   `strategy_review.json` 与 `reviewed_strategy_handoff.json` 后，父 Agent 先调用
+   `fpa_dashboard_publish_review` preview/publish，取得最新 revision；再调用
+   `fpa_dashboard_publish_strategy`，传入 proposal/review/handoff 三个路径及精确
+   `scope_id`、`cycle_id`、`forecast_role` 做 preview/publish，发布
    `next-strategy` 并等待仪表盘决策。
 
-两个 Graph 都不得拥有或调用任何 `fpa_dashboard_*` 工具。发布是父 Agent
+Graph 不得拥有或调用任何 `fpa_dashboard_*` 工具。发布是父 Agent
 在 Graph 返回后的职责；父 Agent不得自行模拟 Graph 内的业务阶段。
 
 如果匹配 Graph 不在 catalog 中或无法加载，列出缺口并保持 `blocked`；不得把
@@ -39,7 +39,7 @@ Graph 返回业务阻塞同样不构成降级理由。所需上下文缺失时
 ## 不可跳过的停点
 
 - 策略推荐者不得批准或独立复核自己的提案。若宿主不能证明复核上下文与提案作者独立，复核阶段必须报告 `blocked`。
-- 独立复核完成后，`fpa-strategy-recommendation` 必须生成精确绑定提案与复核版本的 `reviewed_strategy_handoff`，然后停止。
+- 独立复核完成后，`fpa-strategy-planning` 必须生成精确绑定提案与复核版本的 `reviewed_strategy_handoff`，然后停止。
 - 聊天中的认可、模型自我确认或 Forecast 授权都不等于策略执行授权。
 - 仪表盘响应回到原主会话后，先由主 Agent 调用
   `fpa_strategy_decision_commit`。只有 `confirm` 成功才可在后续运行

package/skills/fpa-apply-core-rules/SKILL.md

@@ -20,18 +20,18 @@ writing artifacts. It applies only when the current agent exposes both
 
    | Eligible request and evidence | Required Graph |
    | --- | --- |
-   | New or changed objective requiring planning, Actuals diagnosis, and driver analysis | `fpa-period-analysis` |
-   | Completed `driver_analysis` requiring scenarios, recommendation, and independent review | `fpa-strategy-recommendation` |
+   | New or changed objective requiring planning, Actuals diagnosis, driver analysis, scenarios, recommendation, and independent review | `fpa-strategy-planning` |
    | Ready `reviewed_strategy_handoff` plus an exact confirmed `strategy_decision` and a request for an official forecast | `fpa-forecast-freeze` |
    | Exact committed approved Forecast ref plus an authorized execution request | `fpa-strategy-execution` |
    | Exact Forecast and Execution refs plus newly arrived comparable Actuals | `fpa-cycle-review` |
 
-3. Call `graph_run` with the user's complete goal and the exact immutable
-   context required by that Graph. The parent agent must not reproduce its
-   nodes or pre-run their `fpa_*` calls. After a successful Graph handoff, the
-   main Agent must publish only that stage's module with the matching
-   `fpa_dashboard_publish_*` tool. Graph nodes must never receive dashboard
-   publication tools.
+3. Call `graph_run` with the user's complete goal. Every `context` value must
+   be a string; provide exact `scope_id`, `cycle_id`, and `forecast_role`, and
+   keep structured planning details in `goal`. The parent agent must not
+   reproduce Graph nodes or pre-run their `fpa_*` calls. After the combined
+   planning Graph succeeds, the main Agent publishes `period-review` and then
+   `next-strategy` with their matching `fpa_dashboard_publish_*` tools. Graph
+   nodes must never receive dashboard publication tools.
 4. If required context is missing or ambiguous, return `blocked` and request
    the exact identity or ref. Do not fall back to direct phase execution.
 

package/skills/fpa-apply-core-rules/references/core-rules.md

@@ -2,20 +2,18 @@
 
 ## 1. Workflow and artifacts
 
-Period-analysis workflow (`fpa-period-analysis`):
+Combined strategy-planning workflow (`fpa-strategy-planning`):
 
-`planning_brief -> actuals_snapshot + data_issue_report -> driver_analysis`
+`planning_brief -> parallel(actuals audit, driver audit) -> driver_analysis -> parallel(efficiency, growth, risk) -> strategy_scenarios -> strategy_proposal -> strategy_review -> reviewed_strategy_handoff`
 
-The calling main Agent publishes `period-review`, then starts the separate
-strategy-recommendation workflow (`fpa-strategy-recommendation`):
-
-`driver_analysis -> strategy_scenarios -> strategy_proposal -> strategy_review -> reviewed_strategy_handoff`
-
-Each Graph stops at its named handoff. Neither Graph may publish dashboard
-content. The strategy Graph does not
+The Graph stops at the reviewed strategy handoff and may not publish dashboard
+content. Parallel children are independent and read-only; sequential reducer
+nodes alone write the canonical artifacts. The strategy Graph does not
 approve the strategy, create an official forecast, or execute the allocation.
 
-The calling main Agent publishes the exact ready handoff through
+The calling main Agent first publishes the exact `driver_analysis` through
+`fpa_dashboard_publish_review`, then publishes the exact proposal, independent
+review, ready handoff, and immutable scope/cycle/role through
 `fpa_dashboard_publish_strategy`, waits for the dashboard response in the
 originating main session, and commits it with `fpa_strategy_decision_commit`.
 Dashboard publishing and decision commit tools are forbidden from every Graph
@@ -27,9 +25,9 @@ ready handoff plus the exact confirmed strategy-decision fingerprint:
 `reviewed_strategy_handoff + strategy_decision -> forecast_plan -> approved_cycle_forecast`
 
 The main Agent owns approval recording; the forecast Graph owns deterministic
-composition and artifact freezing. A rejected approval returns to a new
-`fpa-strategy-planning` version rather than modifying the reviewed proposal in
-place.
+composition and artifact freezing. A rejected approval reruns
+`fpa-strategy-planning` with the exact feedback and produces a new version
+rather than modifying the reviewed proposal in place.
 
 Execution is a separate `fpa-strategy-execution` workflow:
 

package/skills/fpa-recommend-strategy/SKILL.md

@@ -12,7 +12,7 @@ Load `$fpa-apply-core-rules` first. Recommend one plan while keeping alternative
 1. Consume `planning_brief`, `driver_analysis`, and `strategy_scenarios`.
 2. Remove scenarios that breach hard constraints.
 3. Rank remaining scenarios using the objective priorities and declared trade-off rule.
-4. Select one recommendation and specify exact allocation, changes from baseline, expected ranges, assumptions, and risks.
+4. Select one recommendation and specify exact allocation, an explicit `grow | hold | cut | stop` action for every App/store/channel row, changes from baseline, expected ranges, assumptions, and risks.
 5. State why rejected alternatives were not chosen.
 6. Define next-cycle evaluation thresholds; do not create a real-time monitoring obligation.
 7. Write `strategy_proposal` using [artifact-contract.md](references/artifact-contract.md).

package/skills/fpa-recommend-strategy/references/artifact-contract.md

@@ -12,6 +12,7 @@ allocation:
   - app_id: string
     store: string
     channel_group: string
+    action: grow | hold | cut | stop
     spend: number
     change_from_baseline: number
 expected_outcomes:
@@ -27,4 +28,4 @@ next_cycle_evaluation_thresholds: []
 required_human_decisions: []
 ```
 
-The total allocation must reconcile to the proposed total budget, and every allocation row must map to a simulated scenario row.
+The total allocation must reconcile to the proposed total budget, and every allocation row must map to a simulated scenario row. `action` is explicit and mandatory: use `grow` for a budget increase, `hold` for an unchanged allocation, `cut` for a non-zero reduction, and `stop` when the slice is removed or held at zero under a stop-loss decision.

package/skills/fpa-refresh-dashboard/SKILL.md

@@ -22,10 +22,13 @@ preserve every other module revision.
 
 1. After the analysis Graph returns `driver_analysis`, preview then publish
    `period-review` with `fpa_dashboard_publish_review`.
-2. After the strategy Graph returns the exact `strategy_proposal` and
-   `reviewed_strategy_handoff`, preview then publish `next-strategy` with
-   `fpa_dashboard_publish_strategy`. Publication binds its decision action to
-   the current main session; never copy or expose a session id in dashboard data.
+2. After the strategy Graph returns the exact `strategy_proposal`, independent
+   `strategy_review`, and `reviewed_strategy_handoff`, preview then publish
+   `next-strategy` with `fpa_dashboard_publish_strategy`. Supply all three paths
+   and the exact `scope_id`, `cycle_id`, and `forecast_role`; the tool verifies
+   fingerprints, review independence, opinion, conditions, and next-stage
+   binding. Publication binds its decision action to the current main session;
+   never copy or expose a session id in dashboard data.
 3. Stop and wait for the dashboard action. The Web host sends a canonical
    decision message back to the bound original session. In that session call
    `fpa_strategy_decision_commit` with the exact `action_id`.

package/skills/fpa-review-strategy/references/artifact-contract.md

@@ -23,3 +23,25 @@ reviewed_at: timestamp
 ```
 
 Set `independence_confirmed: false` and `status: blocked` if the reviewer also authored the proposal. Any unresolved critical finding requires `reject`.
+
+# `reviewed_strategy_handoff` contract
+
+```yaml
+kind: fpa.reviewed-strategy-handoff
+status: ready | blocked
+scope_id: string
+cycle_id: string
+forecast_role: string
+strategy_version: string
+reviewed_strategy_version: string
+proposal_fingerprint: sha256
+review_fingerprint: sha256
+reviewer_identity: string
+independence_confirmed: true
+review_opinion: support | support_with_conditions
+review_conditions: []
+review_residual_risks: []
+next_graph: fpa-forecast-freeze
+```
+
+`strategy_version` and `reviewed_strategy_version` must be identical and must bind the exact proposal reviewed. A rejected or non-independent review cannot produce a ready handoff.

package/graphs/fpa-period-analysis.json

@@ -1,10 +0,0 @@
-{
-  "name": "fpa-period-analysis",
-  "version": "1.0.0",
-  "start": "plan_cycle",
-  "nodes": [
-    { "id": "plan_cycle", "type": "subagent", "agentName": "plan_cycle", "next": "diagnose_actuals", "skills": ["fpa-plan-cycle"], "tools": ["read", "write", "fpa_data_catalog"], "prompt": "规划精确周期、范围、指标与边界；不得推荐策略或调用仪表盘工具。" },
-    { "id": "diagnose_actuals", "type": "subagent", "agentName": "diagnose_actuals", "next": "analyze_drivers", "skills": ["fpa-diagnose-actuals"], "tools": ["read", "write", "fpa_data_catalog", "fpa_query"], "prompt": "诊断 Actuals 完整性并写入工件；不得调用仪表盘工具。" },
-    { "id": "analyze_drivers", "type": "subagent", "agentName": "analyze_drivers", "skills": ["fpa-analyze-drivers"], "tools": ["read", "write", "fpa_query", "fpa_calc"], "prompt": "分析上周期驱动因素并写 artifacts/driver_analysis.json；不得推荐策略或调用仪表盘工具。" }
-  ]
-}

package/graphs/fpa-strategy-recommendation.json

@@ -1,11 +0,0 @@
-{
-  "name": "fpa-strategy-recommendation",
-  "version": "1.0.0",
-  "start": "simulate_strategies",
-  "nodes": [
-    { "id": "simulate_strategies", "type": "subagent", "agentName": "simulate_strategies", "next": "recommend_strategy", "skills": ["fpa-simulate-strategies"], "tools": ["read", "write", "fpa_query", "fpa_calc"], "prompt": "根据分析工件试算候选策略；不得批准、预测或发布仪表盘。" },
-    { "id": "recommend_strategy", "type": "subagent", "agentName": "recommend_strategy", "next": "review_strategy", "skills": ["fpa-recommend-strategy"], "tools": ["read", "write"], "prompt": "形成完整策略提案；不得自我批准或发布仪表盘。" },
-    { "id": "review_strategy", "type": "subagent", "agentName": "review_strategy", "next": "prepare_handoff", "skills": ["fpa-review-strategy"], "tools": ["read", "write", "fpa_calc"], "prompt": "独立复核策略并写审核工件；不得批准或发布仪表盘。" },
-    { "id": "prepare_handoff", "type": "subagent", "agentName": "prepare_handoff", "tools": ["read", "write"], "prompt": "仅在审核通过时形成 reviewed_strategy_handoff；停止，不批准、不预测、不发布仪表盘。" }
-  ]
-}