@guanlin4924/devflow-pi 0.1.16 → 0.1.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@guanlin4924/devflow-pi",
-  "version": "0.1.16",
+  "version": "0.1.17",
   "type": "module",
   "description": "Devflow 专项研发 Pi，基于固定版本 OMP Runtime 组装研发状态机、代码智能、设计、实现与质量门禁。",
   "license": "UNLICENSED",

package/plugins/devflow-core/extensions/devflow-core.ts

@@ -1310,7 +1310,7 @@ export default function devflowCore(pi: ExtensionAPI) {
       read: z.boolean().optional(),
       delta: z.object({
         op: z.enum(["add", "link", "update"]),
-        kind: z.enum(["source", "code", "term", "object", "behavior", "requirement", "rule", "boundary", "slice", "risk", "decision", "acceptance", "api"]).optional(),
+        kind: z.enum(["source", "code", "term", "object", "behavior", "requirement", "rule", "boundary", "slice", "risk", "decision", "acceptance", "api", "workload_shape", "workload_constraint"]).optional(),
         id: z.string().min(1).optional(),
         data: z.record(z.string(), z.unknown()).optional(),
         from: z.string().min(1).optional(),
@@ -1340,6 +1340,36 @@ export default function devflowCore(pi: ExtensionAPI) {
           return renderResult({ ok: false, exitCode: 2, stdout: "", stderr: "confirm requires expectedRevision, nodeId and evidence" });
         }
         args.push("--write", "--expected-revision", String(params.expectedRevision), "--node-id", params.nodeId, "--evidence-json", JSON.stringify(params.evidence));
+        const inspected = parseJsonResult(
+          await runRuby(ctx.cwd, "workflow-orchestrator/scripts/requirement_graph.rb", ["inspect", "--feature", params.feature, "--json"]),
+        );
+        const node = Array.isArray(inspected?.graph?.nodes)
+          ? inspected.graph.nodes.find((candidate: unknown) => typeof candidate === "object" && candidate !== null && (candidate as { id?: unknown }).id === params.nodeId) as { kind?: unknown; data?: unknown } | undefined
+          : undefined;
+        const architectureDecision = node?.kind === "decision" && typeof node?.data === "object" && node.data !== null && (node.data as { decision_type?: unknown }).decision_type === "architecture_option_comparison";
+        const architectureRisk = node?.kind === "risk" && typeof node?.data === "object" && node.data !== null && (node.data as { risk_type?: unknown }).risk_type === "architecture_option_risk";
+        if (node?.kind === "workload_shape" || node?.kind === "workload_constraint" || architectureDecision || architectureRisk) {
+          const preview = JSON.stringify(node.data ?? {}, null, 2);
+          const decisionDialog = architectureDecision;
+          const riskDialog = architectureRisk;
+          const confirmed = await ctx.ui.confirm(
+            decisionDialog ? "确认架构方案取舍" : riskDialog ? "确认架构风险处理" : "确认工作负载事实或缺口",
+            [
+              `Feature：${params.feature}`,
+              `节点：${params.nodeId}`,
+              `类型：${decisionDialog ? "架构方案比较" : riskDialog ? "架构风险处理" : node.kind === "workload_shape" ? "工作负载形态" : "工作负载约束"}`,
+              decisionDialog
+                ? "确认的含义是：你已核对候选方案、证据与取舍，并接受其中 recommendation_option_id 作为本次架构选择。"
+                : riskDialog
+                  ? "确认的含义是：你已核对失败模式、影响、处理方式、负责人和复核条件；它不代表生产风险从此消失。"
+                : "确认的含义仅是：该事实或缺口、来源与责任归属已被你核对；它不代表容量已经满足，也不会替你选择实现方案。",
+              "待确认内容：",
+              preview.length > 8_000 ? `${preview.slice(0, 8_000)}\n…（内容过长，已截断）` : preview,
+            ].join("\n\n"),
+          );
+          if (!confirmed) return renderResult({ ok: false, exitCode: 1, stdout: "", stderr: "User declined workload confirmation; node remains candidate." });
+          args.push("--confirmed-interactively");
+        }
       }
       return renderResult(
         await runRuby(ctx.cwd, "workflow-orchestrator/scripts/requirement_graph.rb", args),
@@ -1348,6 +1378,222 @@ export default function devflowCore(pi: ExtensionAPI) {
     },
   });
 
+  pi.registerTool({
+    name: "devflow_runtime_context",
+    label: "Devflow Runtime Context",
+    description: "Collect or inspect the P0 repository-declared dependency snapshot and its coverage.",
+    parameters: z.object({
+      action: z.enum(["collect", "inspect"]),
+    }),
+    approval: (args) => args.action === "collect" ? "write" : "read",
+    async execute(_id, params, _signal, _onUpdate, ctx) {
+      return renderResult(
+        await runRuby(ctx.cwd, "workflow-orchestrator/scripts/runtime_context_collector.rb", [params.action, "--json"]),
+        { action: params.action },
+      );
+    },
+  });
+
+  pi.registerTool({
+    name: "devflow_static_runtime_context",
+    label: "Devflow Static Runtime Context",
+    description: "Collect or inspect the P1 static evidence snapshot. It records only repository declarations and references, never production health or capacity.",
+    parameters: z.object({
+      action: z.enum(["collect", "inspect"]),
+    }),
+    approval: (args) => args.action === "collect" ? "write" : "read",
+    async execute(_id, params, _signal, _onUpdate, ctx) {
+      return renderResult(
+        await runRuby(ctx.cwd, "workflow-orchestrator/scripts/static_runtime_context_collector.rb", [params.action, "--json"]),
+        { action: params.action },
+      );
+    },
+  });
+
+  pi.registerTool({
+    name: "devflow_architecture_assessment",
+    label: "Devflow Architecture Assessment",
+    description: "Confirm an immutable delta set through an explicit user dialog, then assess only that Core-owned manifest against a pinned runtime-context snapshot.",
+    parameters: z.object({
+      action: z.enum(["inspect", "assess", "write-manifest"]),
+      feature: z.string().min(1),
+      baseSnapshotRevision: z.number().int().min(0).optional(),
+      deltaSetId: z.string().min(1).optional(),
+      deltaJson: z.array(z.record(z.string(), z.unknown())).optional(),
+      sourceBundleRevision: z.string().min(1).optional(),
+      expectedAssessmentRevision: z.number().int().min(0).optional(),
+      write: z.boolean().optional(),
+    }),
+    approval: (args) => args.action === "write-manifest" || args.write ? "write" : "read",
+    async execute(_id, params, _signal, _onUpdate, ctx) {
+      const args = [params.action, "--feature", params.feature, "--json"];
+      if (params.action === "inspect") {
+        if (params.deltaSetId) args.push("--delta-set-id", params.deltaSetId);
+        return renderResult(
+          await runRuby(ctx.cwd, "workflow-orchestrator/scripts/architecture_assessment.rb", args),
+          { action: params.action, feature: params.feature },
+        );
+      }
+      if (!params.deltaSetId) {
+        return renderResult({ ok: false, exitCode: 2, stdout: "", stderr: "deltaSetId is required" });
+      }
+      args.push("--delta-set-id", params.deltaSetId);
+      if (params.action === "assess") {
+        if (params.baseSnapshotRevision === undefined) {
+          return renderResult({ ok: false, exitCode: 2, stdout: "", stderr: "assess requires baseSnapshotRevision and deltaSetId; deltas and manifest are Core-owned" });
+        }
+        args.push("--base-snapshot-revision", String(params.baseSnapshotRevision));
+        if (params.write) {
+          const inspected = parseJsonResult(await runRuby(ctx.cwd, "workflow-orchestrator/scripts/architecture_assessment.rb", ["inspect", "--feature", params.feature, "--delta-set-id", params.deltaSetId, "--json"]));
+          const currentRevision = typeof inspected?.current_assessment_revision === "number" ? inspected.current_assessment_revision : undefined;
+          if (currentRevision === undefined) {
+            return renderResult({ ok: false, exitCode: 1, stdout: "", stderr: "Unable to read the current assessment revision for CAS." });
+          }
+          args.push("--write", "--expected-assessment-revision", String(currentRevision));
+        }
+      }
+      if (params.action === "write-manifest") {
+        if (!params.sourceBundleRevision || !params.deltaJson?.length) {
+          return renderResult({ ok: false, exitCode: 2, stdout: "", stderr: "write-manifest requires deltaSetId, sourceBundleRevision and a non-empty deltaJson" });
+        }
+        const preview = params.deltaJson.map((rawDelta, index) => {
+          const delta = rawDelta as Record<string, unknown>;
+          const source = delta.source && typeof delta.source === "object" ? delta.source as Record<string, unknown> : {};
+          return [
+            `${index + 1}. ID：${String(delta.id ?? "(缺失)")}`,
+            `依赖：${String(delta.subject ?? "(缺失)")}`,
+            `来源：${String(source.locator ?? "(缺失)")}`,
+            `来源 revision：${String(source.repository_revision ?? "(缺失)")}`,
+            `内容哈希：${String(source.input_hash ?? "(缺失)")}`,
+          ].join("\n");
+        }).join("\n\n");
+        const confirmed = await ctx.ui.confirm(
+          "确认架构评估 Delta 集合",
+          [
+            `Feature：${params.feature}`,
+            `Delta 集合：${params.deltaSetId}`,
+            `需求/方案 revision：${params.sourceBundleRevision}`,
+            "确认后 Core 会创建不可覆盖的 manifest；后续评估只能读取这一份确认内容。",
+            "请核对以下依赖、来源与哈希：",
+            preview,
+          ].join("\n\n"),
+        );
+        if (!confirmed) return renderResult({ ok: false, exitCode: 1, stdout: "", stderr: "User declined delta-set confirmation; no manifest was written." });
+        args.push("--source-bundle-revision", params.sourceBundleRevision, "--delta-json", JSON.stringify(params.deltaJson), "--confirmed-interactively", "--write");
+      }
+      return renderResult(
+        await runRuby(ctx.cwd, "workflow-orchestrator/scripts/architecture_assessment.rb", args),
+        { action: params.action, feature: params.feature },
+      );
+    },
+  });
+
+  pi.registerTool({
+    name: "devflow_workload_constraint",
+    label: "Devflow Workload Constraint",
+    description: "Validate a workload constraint (NFR) against its source-status schema.",
+    parameters: z.object({
+      constraintJson: z.record(z.string(), z.unknown()),
+    }),
+    approval: "read",
+    async execute(_id, params, _signal, _onUpdate, ctx) {
+      return renderResult(
+        await runRuby(ctx.cwd, "workflow-orchestrator/scripts/workload_constraint.rb", ["validate", "--constraint-json", JSON.stringify(params.constraintJson), "--json"]),
+        {},
+      );
+    },
+  });
+
+  pi.registerTool({
+    name: "devflow_architecture_constraint",
+    label: "Devflow Architecture Constraint",
+    description: "Validate candidate workload shape or workload constraint inputs without assigning confirmation, decisions, or gate status.",
+    parameters: z.object({
+      action: z.enum(["validate-shape", "validate-constraint"]),
+      shapeJson: z.record(z.string(), z.unknown()).optional(),
+      constraintJson: z.record(z.string(), z.unknown()).optional(),
+    }),
+    approval: "read",
+    async execute(_id, params, _signal, _onUpdate, ctx) {
+      if (params.action === "validate-shape" && !params.shapeJson) {
+        return renderResult({ ok: false, exitCode: 2, stdout: "", stderr: "validate-shape requires shapeJson" });
+      }
+      if (params.action === "validate-constraint" && !params.constraintJson) {
+        return renderResult({ ok: false, exitCode: 2, stdout: "", stderr: "validate-constraint requires constraintJson" });
+      }
+      const args = [params.action, "--json"];
+      if (params.shapeJson) args.push("--shape-json", JSON.stringify(params.shapeJson));
+      if (params.constraintJson) args.push("--constraint-json", JSON.stringify(params.constraintJson));
+      return renderResult(
+        await runRuby(ctx.cwd, "workflow-orchestrator/scripts/architecture_constraints.rb", args),
+        { action: params.action },
+      );
+    },
+  });
+
+  pi.registerTool({
+    name: "devflow_architecture_feasibility",
+    label: "Devflow Architecture Feasibility",
+    description: "Read confirmed workload facts and a pinned static-context snapshot to derive an advisory architecture assessment. It never selects an option or claims production capacity.",
+    parameters: z.object({
+      feature: z.string().min(1),
+    }),
+    approval: "read",
+    async execute(_id, params, _signal, _onUpdate, ctx) {
+      return renderResult(
+        await runRuby(ctx.cwd, "workflow-orchestrator/scripts/architecture_feasibility.rb", ["assess", "--feature", params.feature, "--json"]),
+        { feature: params.feature },
+      );
+    },
+  });
+
+  pi.registerTool({
+    name: "devflow_architecture_brief",
+    label: "Devflow Architecture Brief",
+    description: "Inspect or regenerate the Core-derived architecture brief from the current graph and static-context snapshot. The brief is a view, never an agent-authored source of truth.",
+    parameters: z.object({
+      action: z.enum(["inspect", "render"]),
+      feature: z.string().min(1),
+    }),
+    approval: (args) => args.action === "render" ? "write" : "read",
+    async execute(_id, params, _signal, _onUpdate, ctx) {
+      if (params.action === "inspect") {
+        return renderResult(
+          await runRuby(ctx.cwd, "workflow-orchestrator/scripts/architecture_brief.rb", ["inspect", "--feature", params.feature, "--json"]),
+          { action: params.action, feature: params.feature },
+        );
+      }
+      const inspected = parseJsonResult(
+        await runRuby(ctx.cwd, "workflow-orchestrator/scripts/architecture_brief.rb", ["inspect", "--feature", params.feature, "--json"]),
+      );
+      const currentRevision = typeof inspected?.brief_revision === "number" ? inspected.brief_revision : undefined;
+      if (currentRevision === undefined) {
+        return renderResult({ ok: false, exitCode: 1, stdout: "", stderr: "Unable to read the current architecture brief revision for CAS." });
+      }
+      return renderResult(
+        await runRuby(ctx.cwd, "workflow-orchestrator/scripts/architecture_brief.rb", ["render", "--feature", params.feature, "--write", "--expected-brief-revision", String(currentRevision), "--json"]),
+        { action: params.action, feature: params.feature },
+      );
+    },
+  });
+
+  pi.registerTool({
+    name: "devflow_stale_check",
+    label: "Devflow Stale Check",
+    description: "Check field-level staleness of consumed evidence against the current snapshot.",
+    parameters: z.object({
+      consumedRevision: z.number().int().min(0),
+      evidencePaths: z.array(z.string().min(1)),
+    }),
+    approval: "read",
+    async execute(_id, params, _signal, _onUpdate, ctx) {
+      return renderResult(
+        await runRuby(ctx.cwd, "workflow-orchestrator/scripts/stale_check.rb", ["check", "--consumed-revision", String(params.consumedRevision), "--evidence-paths", JSON.stringify(params.evidencePaths), "--json"]),
+        {},
+      );
+    },
+  });
+
   pi.registerTool({
     name: "devflow_evidence",
     label: "Devflow Evidence Pack",

package/plugins/devflow-core/skills/workflow-orchestrator/SKILL.md

@@ -117,6 +117,7 @@ After each step completes, verify the step's gate before advancing:
 | requirement-feasibility-review | 可实现性审查.meta.json `status=ready_for_baseline`、`baseline_gate=pass`、`gap_count=0` 且无 critical finding | Reject advance to requirement-baseline |
 | requirement-baseline | baseline.md review conclusion is "通过" AND baseline.meta.json `review_status` / `traceability_status` are `passed` AND blocking counters are all 0 | Reject advance to api-contract |
 | api-contract | api-contract.meta.json `review_status` / `traceability_status` are `passed` AND `pending_contract_count` is 0 | Reject advance to dual tracks |
+| architecture-feasibility | Core-derived `architecture-brief.md` / meta exist. If `assessment_level=full`, require `assessment_status=ready` and `comparison_status=confirmed`; a lightweight incomplete result may proceed only as an explicitly unresolved downstream input. | Reject advance to dual tracks for an incomplete full assessment |
 | ui-spec | UI-SPEC.md review conclusion is "通过" | Reject advance to feature-breakdown |
 | feature-breakdown | 功能点梳理.md review conclusion is "通过" | Reject advance to tech-specs |
 | api-call-guide | api-call-guide.meta.json `frontend_consumable` and `mock_ready` are true, pending_items is empty | Reject merge gate |
@@ -161,8 +162,8 @@ When the inspector returns `route_failure_branch`:
 When the inspector returns `run_parallel_window`:
 
 0. **Track filtering**（新增）：读取 STATE.md 的 `active_track` 字段
-   - 如果 `active_track == "A"`：只路由完整需求主链及 Track A 步骤（requirement-triage、requirement-wayfinder、domain-modeling、requirement-feasibility-review、requirement-baseline、api-contract、backend-tech-spec、api-call-guide），完成后阻断在轨道边界
-   - 如果 `active_track == "B"`：新需求必须完成完整需求主链；前端设计步骤仍依赖 api-contract。允许步骤为 requirement-triage、requirement-wayfinder、domain-modeling、requirement-feasibility-review、requirement-baseline、api-contract、ui-spec、feature-breakdown、frontend-tech-spec、api-supplement，完成后阻断在轨道边界
+   - 如果 `active_track == "A"`：只路由完整需求主链及 Track A 步骤（requirement-triage、requirement-wayfinder、domain-modeling、requirement-feasibility-review、requirement-baseline、api-contract、architecture-feasibility、backend-tech-spec、api-call-guide），完成后阻断在轨道边界
+   - 如果 `active_track == "B"`：新需求必须完成完整需求主链；前端设计步骤仍依赖 api-contract 和 architecture-feasibility。允许步骤为 requirement-triage、requirement-wayfinder、domain-modeling、requirement-feasibility-review、requirement-baseline、api-contract、architecture-feasibility、ui-spec、feature-breakdown、frontend-tech-spec、api-supplement，完成后阻断在轨道边界
    - 如果未设置或无效：保留全部 branch_steps（双轨道）
    - 过滤后如果只剩一个步骤，退化为串行执行（不启动并行窗口）