@viccydev/pi-fpa 0.7.2 → 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.7.2
+pi install git:github.com/linyqh/pi-fpa@v0.8.1
 ```
 
 ## 发布到 npm
 
-发布动作由 GitHub Release 触发。Release 标签必须严格使用 `v<package.json version>`，例如版本 `0.7.2` 对应 `v0.7.2`。工作流会检出该标签，执行 `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/compat-publisher.ts

@@ -0,0 +1,45 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+
+import type { DashboardBuild } from "./projector.ts";
+import type { DashboardProjectorProvenance, DashboardProjectorRuntime } from "./provenance.ts";
+import { publishDashboard, resolveDashboardDir } from "./publisher.ts";
+import { publishDashboardModule, readDashboardModuleManifest } from "./module-publisher.ts";
+import type { DashboardActualsSnapshot } from "./source.ts";
+
+interface Options {
+	cwd: string;
+	build: DashboardBuild;
+	projector: DashboardProjectorProvenance;
+	runtime: DashboardProjectorRuntime;
+	actualsSnapshot?: DashboardActualsSnapshot;
+	allowBacktestDisplay?: boolean;
+}
+
+export async function publishDashboardProjection(options: Options): Promise<{ dashboardDir: string; fingerprint: string; publishedDatasets: number }> {
+	const dashboardDir = await resolveDashboardDir(options.cwd);
+	let schemaVersion: number | undefined;
+	try {
+		schemaVersion = (JSON.parse(await readFile(join(dashboardDir, "manifest.json"), "utf8")) as { schemaVersion?: number }).schemaVersion;
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+	}
+	if (schemaVersion !== 2) return publishDashboard(options);
+	if (options.build.source.forecast_role === "backtest" && options.allowBacktestDisplay !== true) {
+		throw new Error("A backtest cannot replace dashboard execution evidence without explicit user authorization.");
+	}
+	const current = await readDashboardModuleManifest(options.cwd);
+	const published = await publishDashboardModule({
+		cwd: options.cwd,
+		dashboardTitle: options.build.title,
+		expectedDashboardRevision: current?.dashboardRevision ?? null,
+		module: {
+			id: "execution-evidence",
+			title: "经营执行与校准证据",
+			status: "published",
+			source: { ...options.build.source, warnings: options.build.warnings, projector: options.projector, runtime: options.runtime },
+			widgets: options.build.widgets,
+		},
+	});
+	return { dashboardDir: published.dashboardDir, fingerprint: published.moduleRevision, publishedDatasets: published.publishedDatasets };
+}

package/extensions/fpa-dashboard/coordinator.ts

@@ -9,7 +9,8 @@ import {
 	type ArtifactRefV2,
 	type ForecastRole,
 } from "../fpa-artifacts/store.ts";
-import { dashboardBuildFingerprint, publishDashboard, resolveDashboardDir } from "./publisher.ts";
+import { dashboardBuildFingerprint, resolveDashboardDir } from "./publisher.ts";
+import { publishDashboardProjection } from "./compat-publisher.ts";
 import { buildDashboardProjection } from "./service.ts";
 
 const EVENT_MAX_BYTES = 64 * 1024;
@@ -723,7 +724,7 @@ async function defaultWorker(event: DashboardRefreshEvent, projectRoot: string,
 	if (event.desired_generation_id && generationId !== event.desired_generation_id) {
 		throw new ObsoleteDashboardRefreshError("Dashboard inputs changed after polling; the stale desired generation must be replanned.");
 	}
-	await publishDashboard({ cwd: projectRoot, build: result.build, projector: result.projector, runtime: result.runtime, actualsSnapshot: result.actuals });
+	await publishDashboardProjection({ cwd: projectRoot, build: result.build, projector: result.projector, runtime: result.runtime, actualsSnapshot: result.actuals });
 	return {
 		generation_id: generationId,
 		data_as_of: result.build.source.data_as_of,

package/extensions/fpa-dashboard/index.ts

@@ -2,8 +2,19 @@ import { StringEnum } from "@earendil-works/pi-ai";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 
-import { readArtifactByRef, type ArtifactRefV2 } from "../fpa-artifacts/store.ts";
-import { dashboardBuildFingerprint, publishDashboard } from "./publisher.ts";
+import { readArtifactByRef, readProjectJsonFile, type ArtifactRefV2 } from "../fpa-artifacts/store.ts";
+import { dashboardBuildFingerprint } from "./publisher.ts";
+import { publishDashboardProjection } from "./compat-publisher.ts";
+import {
+	dashboardModuleBuildFingerprint,
+	publishDashboardModule,
+	readDashboardModuleManifest,
+	readDashboardModuleSource,
+	transitionStrategyModule,
+} from "./module-publisher.ts";
+import { projectForecastModule, projectReviewModule, projectStrategyModule } from "./stage-projector.ts";
+import type { ApprovedCycleForecast } from "../fpa-artifacts/contracts.ts";
+import { commitStrategyDecision, createStrategyDecisionRequest, readCommittedStrategyDecision } from "./strategy-decision.ts";
 import {
 	enqueueDashboardRefresh,
 	enqueueDashboardRefreshForArtifact,
@@ -28,6 +39,229 @@ export default function fpaDashboardExtension(pi: ExtensionAPI): void {
 		entry_id: Type.String({ pattern: "^[a-f0-9]{64}$" }),
 		body_fingerprint: Type.String({ pattern: "^[a-f0-9]{64}$" }),
 	}, { additionalProperties: false });
+	pi.registerTool({
+		name: "fpa_dashboard_module_status",
+		label: "FP&A Dashboard Module Status",
+		description: "Inspect independently published FP&A dashboard modules and their current dashboard revision without changing files.",
+		promptSnippet: "Inspect the independently published FP&A dashboard modules",
+		parameters: Type.Object({}, { additionalProperties: false }),
+		executionMode: "parallel",
+		async execute(_toolCallId, _params, _signal, _onUpdate, ctx) {
+			const manifest = await readDashboardModuleManifest(ctx.cwd);
+			return toolResult(manifest ? {
+				status: "available",
+				dashboard_revision: manifest.dashboardRevision,
+				module_order: manifest.moduleOrder,
+				modules: Object.fromEntries(Object.entries(manifest.modules).map(([id, module]) => [id, module ? {
+					status: module.status,
+					revision: module.revision,
+					updated_at: module.updatedAt,
+					interactive: module.interaction?.kind === "strategy-decision",
+				} : null])),
+			} : { status: "missing" });
+		},
+	});
+
+	pi.registerTool({
+		name: "fpa_dashboard_publish_review",
+		label: "Publish FP&A Period Review Module",
+		description: "Preview or publish only the period-review dashboard module from a project driver_analysis JSON artifact. Other dashboard modules are preserved.",
+		promptSnippet: "Publish the completed period analysis as its own dashboard module",
+		promptGuidelines: [
+			"This tool is called by the main Agent after the analysis Graph returns; never add it to a Graph tool allowlist.",
+			"Preview first, then publish with the exact preview fingerprint and dashboard revision.",
+		],
+		parameters: Type.Object({
+			mode: StringEnum(["preview", "publish"] as const),
+			analysis_path: Type.String({ minLength: 1 }),
+			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 })),
+		}, { additionalProperties: false }),
+		executionMode: "sequential",
+		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+			const module = projectReviewModule(await readProjectJsonFile(ctx.cwd, params.analysis_path, "analysis_path"));
+			const previewFingerprint = dashboardModuleBuildFingerprint(module);
+			const current = await readDashboardModuleManifest(ctx.cwd);
+			if (params.mode === "preview") return toolResult({
+				status: "ready",
+				module_id: module.id,
+				preview_fingerprint: previewFingerprint,
+				dashboard_revision: current?.dashboardRevision ?? null,
+				widget_count: module.widgets.length,
+			});
+			if (params.expected_preview_fingerprint !== previewFingerprint) throw new Error("Review module inputs changed after preview; preview again before publishing.");
+			if (params.expected_dashboard_revision === undefined) throw new Error("Publish requires expected_dashboard_revision from preview, including null for a new dashboard.");
+			const published = await publishDashboardModule({
+				cwd: ctx.cwd,
+				module,
+				dashboardTitle: params.dashboard_title,
+				expectedDashboardRevision: params.expected_dashboard_revision,
+			});
+			return toolResult({ status: "published", module_id: module.id, preview_fingerprint: previewFingerprint, dashboard_revision: published.dashboardRevision, module_revision: published.moduleRevision });
+		},
+	});
+
+	pi.registerTool({
+		name: "fpa_dashboard_publish_strategy",
+		label: "Publish FP&A Strategy Module",
+		description: "Preview or publish only the reviewed next-strategy module and create a server-side decision action bound to the calling main session. Other modules are preserved.",
+		promptSnippet: "Publish the reviewed strategy for human confirmation in the dashboard",
+		promptGuidelines: [
+			"Call this from the main Agent after the strategy Graph returns; Graph nodes must never publish dashboard modules.",
+			"Preview first. Publishing binds the confirmation action to this exact main session and reviewed handoff fingerprint.",
+		],
+		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 })),
+		}, { additionalProperties: false }),
+		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, 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({
+				status: "ready",
+				module_id: module.id,
+				preview_fingerprint: previewFingerprint,
+				dashboard_revision: current?.dashboardRevision ?? null,
+				strategy_version: module.source.strategy_version,
+				widget_count: module.widgets.length,
+			});
+			if (params.expected_preview_fingerprint !== previewFingerprint) throw new Error("Strategy module inputs changed after preview; preview again before publishing.");
+			if (params.expected_dashboard_revision === undefined) throw new Error("Publish requires expected_dashboard_revision from preview, including null for a new dashboard.");
+			const handoffFingerprint = module.source.handoff_fingerprint as string;
+			const request = await createStrategyDecisionRequest(ctx.cwd, {
+				sessionId: ctx.sessionManager.getSessionId(),
+				strategyVersion: module.source.strategy_version as string,
+				handoffFingerprint,
+			});
+			module.interaction = { kind: "strategy-decision", action_id: request.actionId };
+			const published = await publishDashboardModule({
+				cwd: ctx.cwd,
+				module,
+				dashboardTitle: params.dashboard_title,
+				expectedDashboardRevision: params.expected_dashboard_revision,
+			});
+			return toolResult({
+				status: "awaiting_decision",
+				module_id: module.id,
+				preview_fingerprint: previewFingerprint,
+				dashboard_revision: published.dashboardRevision,
+				module_revision: published.moduleRevision,
+				action_id: request.actionId,
+			});
+		},
+	});
+
+	pi.registerTool({
+		name: "fpa_dashboard_publish_forecast",
+		label: "Publish FP&A Forecast Module",
+		description: "Preview or publish only the next-forecast dashboard module from an exact committed approved forecast. Other dashboard modules are preserved.",
+		promptSnippet: "Publish the confirmed strategy forecast as its own dashboard module",
+		promptGuidelines: [
+			"Call this from the main Agent only after fpa_strategy_decision_commit confirmed the exact strategy and the forecast Graph returned an immutable forecast ref.",
+			"Never add this tool to a Graph tool allowlist. Preview first and publish with the exact preview fingerprint and dashboard revision.",
+		],
+		parameters: Type.Object({
+			mode: StringEnum(["preview", "publish"] as const),
+			forecast_ref: artifactRefSchema,
+			strategy_decision: Type.Object({
+				action_id: Type.String({ pattern: "^[a-f0-9]{64}$" }),
+				decision_fingerprint: Type.String({ pattern: "^[a-f0-9]{64}$" }),
+			}, { additionalProperties: false }),
+			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 })),
+		}, { additionalProperties: false }),
+		executionMode: "sequential",
+		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+			const decision = await readCommittedStrategyDecision(ctx.cwd, params.strategy_decision.action_id, params.strategy_decision.decision_fingerprint);
+			if (decision.decision !== "confirm") throw new Error("Forecast publication requires a confirmed strategy decision.");
+			const read = await readArtifactByRef(ctx.cwd, params.forecast_ref as ArtifactRefV2);
+			if (read.artifact.artifact_type !== "approved_cycle_forecast") throw new Error("Forecast module requires an approved_cycle_forecast artifact ref.");
+			const forecast = read.artifact as ApprovedCycleForecast;
+			if (forecast.status === "blocked" || !forecast.approval_conditions_satisfied) throw new Error("Forecast module requires a completed forecast whose approval conditions are satisfied.");
+			if (forecast.strategy_version !== decision.strategy_version) throw new Error("Forecast strategy_version does not match the confirmed strategy decision.");
+			const currentStrategy = (await readDashboardModuleManifest(ctx.cwd))?.modules["next-strategy"];
+			if (!currentStrategy || currentStrategy.status !== "approved") throw new Error("Forecast publication requires the current strategy dashboard module to be approved.");
+			const strategySource = await readDashboardModuleSource(ctx.cwd, "next-strategy");
+			if (strategySource?.strategy_version !== decision.strategy_version || strategySource?.handoff_fingerprint !== decision.handoff_fingerprint) {
+				throw new Error("Approved strategy module does not match the confirmed decision lineage.");
+			}
+			const module = projectForecastModule(forecast, params.forecast_ref as ArtifactRefV2);
+			const previewFingerprint = dashboardModuleBuildFingerprint(module);
+			const current = await readDashboardModuleManifest(ctx.cwd);
+			if (params.mode === "preview") return toolResult({
+				status: "ready",
+				module_id: module.id,
+				preview_fingerprint: previewFingerprint,
+				dashboard_revision: current?.dashboardRevision ?? null,
+				forecast_version: forecast.forecast_version,
+				widget_count: module.widgets.length,
+			});
+			if (params.expected_preview_fingerprint !== previewFingerprint) throw new Error("Forecast module inputs changed after preview; preview again before publishing.");
+			if (params.expected_dashboard_revision === undefined) throw new Error("Publish requires expected_dashboard_revision from preview, including null for a new dashboard.");
+			const published = await publishDashboardModule({
+				cwd: ctx.cwd,
+				module,
+				dashboardTitle: params.dashboard_title,
+				expectedDashboardRevision: params.expected_dashboard_revision,
+			});
+			return toolResult({ status: "published", module_id: module.id, preview_fingerprint: previewFingerprint, dashboard_revision: published.dashboardRevision, module_revision: published.moduleRevision });
+		},
+	});
+
+	pi.registerTool({
+		name: "fpa_strategy_decision_commit",
+		label: "Commit FP&A Strategy Decision",
+		description: "Commit an idempotent human strategy confirmation or change request from the original main session, then transition the strategy dashboard module.",
+		promptSnippet: "Commit the dashboard strategy decision in the original main session",
+		parameters: Type.Object({
+			action_id: Type.String({ pattern: "^[a-f0-9]{64}$" }),
+			decision: StringEnum(["confirm", "request_changes"] as const),
+			feedback: Type.Optional(Type.String({ minLength: 1, maxLength: 8000 })),
+		}, { additionalProperties: false }),
+		executionMode: "sequential",
+		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+			const committed = await commitStrategyDecision(ctx.cwd, {
+				actionId: params.action_id,
+				sessionId: ctx.sessionManager.getSessionId(),
+				decision: params.decision,
+				feedback: params.feedback,
+			});
+			const transitioned = await transitionStrategyModule(ctx.cwd, {
+				actionId: params.action_id,
+				status: params.decision === "confirm" ? "approved" : "changes_requested",
+			});
+			return toolResult({
+				status: "committed",
+				decision: committed.decision,
+				decision_fingerprint: committed.decisionFingerprint,
+				decision_path: committed.path,
+				strategy_version: committed.strategyVersion,
+				handoff_fingerprint: committed.handoffFingerprint,
+				dashboard_revision: transitioned.dashboardRevision,
+				next_stage: params.decision === "confirm" ? "run fpa-forecast-freeze Graph, then publish next-forecast module" : "rerun strategy planning with the exact feedback, then republish next-strategy module",
+			});
+		},
+	});
+
 	pi.registerTool({
 		name: "fpa_dashboard_status",
 		label: "FP&A Dashboard Status",
@@ -157,7 +391,7 @@ export default function fpaDashboardExtension(pi: ExtensionAPI): void {
 			if (params.expected_preview_fingerprint !== previewFingerprint) {
 				throw new Error("Dashboard inputs changed after preview; run preview again before publishing.");
 			}
-			const published = await publishDashboard({
+			const published = await publishDashboardProjection({
 				cwd: ctx.cwd,
 				build,
 				projector,