@twinsearth/dsh-master 3.3.4 → 3.3.5

package/dist-host/index.js

@@ -18,12 +18,16 @@
  * 不可用时子插件必须 fail-closed，绝不本地降级执行。
  */
 import { AGENT_CATALOG, FANG_CONTRACT_MIN, FANG_SERVICE, MASTER_VERSION, ROLE_MATRIX, ROW, SERVICE, SUBPLUGIN_CATALOG, bearerOf, detectRole, enabledOf, jsonResponse, masterError, readJsonBody, roleAllowed, safeGet, } from "./kernel.js";
+import { randomBytes } from 'node:crypto';
 import { BRIDGE_PATH, filterEnv } from "./superagent/dispatch.js";
 import { createBridgeTokenManager } from "./superagent/bridge-tokens.js";
+import { attachCommandCenterChannel, CHANNEL_PATH } from "./channel/server.js";
 export const name = 'dsh-master';
 export const inject = [];
 /** 状态路由（Client UI 读取；只读、非敏感、loopback-only 由宿主 webServer 保证）。 */
 export const STATUS_ROUTE = '/dsh-master/api/status';
+/** 3.3.5：智囊团只读快照（交接/计划/反馈/复核）。 */
+export const DUAL_ROUTE = '/dsh-master/api/dual';
 /**
  * 房主核心 apply。
  * @param {object} ctx Cordis context
@@ -104,8 +108,88 @@ export function apply(ctx, config = {}) {
                 : '宿主缺少 agentPresets 服务（DSH web bundle 才有），本 Host 无法选择该 preset。',
         }));
     };
-    const service = {
-        id: SERVICE.master,
+    /**
+     * 3.3.5：智囊团只读快照（面板数据源）。
+     * 只暴露“谁在等什么”，不暴露 token、不提供写入口；dual 未装配时给 available:false。
+     */
+    const dualSnapshot = () => {
+        const dual = safeGet(ctx, SERVICE.dual);
+        if (!dual || typeof dual.status !== 'function') {
+            return { ok: true, available: false, reason: 'dual-service-unavailable', updatedAt: Date.now(), handoffs: [], plans: [], feedbacks: [], reviews: [], loop: null };
+        }
+        const safe = (fn, fallback) => { try {
+            return fn();
+        }
+        catch {
+            return fallback;
+        } };
+        const handoffs = safe(() => dual.pm.listHandoffs().items, []);
+        const plans = safe(() => dual.pjm.listPlans().items, []);
+        const feedbacks = safe(() => dual.pjm.listFeedback().items, []);
+        const reviews = safe(() => dual.pm.listReviews().items, []);
+        return {
+            ok: true,
+            available: true,
+            updatedAt: Date.now(),
+            agents: { pm: 'master-pm', pjm: 'master-pjm' },
+            loop: safe(() => dual.status().loop, null),
+            handoffs: handoffs.map((item) => ({
+                id: item.id,
+                prdId: item.prdId,
+                title: item.title,
+                status: item.status,
+                reason: item.reason ?? null,
+                openQuestions: (item.openQuestions ?? []).slice(0, 10),
+                acceptance: (item.acceptance ?? []).slice(0, 10),
+                planId: item.planId ?? null,
+                preparedAt: item.preparedAt ?? null,
+            })),
+            plans: plans.map((plan) => {
+                const progress = safe(() => dual.pjm.progress(plan.id).progress, null);
+                const lastReport = Array.isArray(plan.reports) && plan.reports.length > 0 ? plan.reports.at(-1) : null;
+                return {
+                    id: plan.id,
+                    prdId: plan.prdId,
+                    title: plan.title,
+                    status: plan.status,
+                    handoffId: plan.handoffId ?? null,
+                    progress,
+                    lastReport: lastReport ? { status: lastReport.status, summary: lastReport.summary, blocker: lastReport.blocker ?? null, at: lastReport.at } : null,
+                    pmReview: plan.pmReview ?? null,
+                    feedbackId: plan.feedbackId ?? null,
+                };
+            }),
+            feedbacks: feedbacks.map((item) => ({
+                id: item.id,
+                planId: item.planId,
+                prdId: item.prdId ?? null,
+                createdAt: item.createdAt ?? null,
+                summary: String(item.summary ?? '').slice(0, 500),
+                metrics: item.metrics ?? null,
+                openIssues: (item.openIssues ?? []).slice(0, 10),
+            })),
+            reviews: reviews.map((review) => ({
+                id: review.id,
+                feedbackId: review.feedbackId,
+                planId: review.planId,
+                verdict: review.verdict,
+                createdAt: review.createdAt ?? null,
+                failed: (review.acceptanceChecks ?? []).filter((check) => check.met !== true).map((check) => check.criterion),
+            })),
+        };
+    };
+    /**
+     * 智能体通道 token（3.3.5）：每次加载随机生成；只读 status 暴露给同源面板。
+     * 跨站页面由 Origin 校验挡住；token 只是纵深防御，不是唯一门槛。
+     */
+    const channelToken = String(config.channelToken ?? '').trim() || randomBytes(24).toString('hex');
+    const safeOrigin = (fn) => { try {
+        return String(fn() ?? '');
+    }
+    catch {
+        return '';
+    } };
+    const service = { id: SERVICE.master,
         name: 'dsh-master',
         version: MASTER_VERSION,
         role,
@@ -174,6 +258,8 @@ export function apply(ctx, config = {}) {
                         return null;
                     }
                 })(),
+                /** 3.3.5：智囊团 WebSocket 通道（同源面板用；chat 目前返回具名缺口）。 */
+                channel: { path: CHANNEL_PATH, token: channelToken },
                 roleMatrix: ROLE_MATRIX,
                 bridge: {
                     enabled: Boolean(String(config.bridgeToken ?? '').trim()) || bridgeTokens.describe().tokens.length > 0,
@@ -231,6 +317,32 @@ export function apply(ctx, config = {}) {
                 catch (error) {
                     logWarn(`[dsh-master] status route registration failed: ${String(error?.message ?? error)}`);
                 }
+                // v3.3.5：智囊团只读数据源（交接 / 计划 / 反馈 / 复核）。无写口、无 token。
+                try {
+                    webServer.register({
+                        kind: 'exact',
+                        path: DUAL_ROUTE,
+                        method: 'GET',
+                        handler: async (req, res) => jsonResponse(res, 200, dualSnapshot()),
+                    });
+                }
+                catch (error) {
+                    logWarn(`[dsh-master] dual route registration failed: ${String(error?.message ?? error)}`);
+                }
+                // v3.3.5：智囊团 WebSocket 通道（双向；当前只推快照，chat 返回具名缺口）。
+                try {
+                    const channel = attachCommandCenterChannel({
+                        webServer,
+                        token: channelToken,
+                        dualSnapshot,
+                        allowedOrigin: safeOrigin(() => webServer.getOrigin?.()),
+                        logger: { info: logWarn, warn: logWarn, error: logWarn },
+                    });
+                    logWarn(`[dsh-master] command-center channel: ${channel.attached ? channel.path : `not attached (${channel.reason})`}`);
+                }
+                catch (error) {
+                    logWarn(`[dsh-master] command-center channel failed: ${String(error?.message ?? error)}`);
+                }
                 // v3.2.3：原身 Router → 母体 forker 的跨进程派发桥。
                 try {
                     webServer.register({

package/dist-host/kernel.js

@@ -7,7 +7,7 @@
  * 与瓮城 dsh-Fang 的协作只走 DSH 服务键，不 import fang 代码。
  */
 import crypto from 'node:crypto';
-export const MASTER_VERSION = '3.3.4';
+export const MASTER_VERSION = '3.3.5';
 export const FANG_CONTRACT_MIN = '3.1.14';
 export const SERVICE = Object.freeze({
     master: 'dshMaster',
@@ -69,18 +69,18 @@ export const AGENT_CATALOG = Object.freeze([
         preset: 'master-pm',
         name: '产品经理（PM）',
         nameEn: 'Product Manager',
-        responsibilities: ['需求澄清与选择题请示', 'WHY/WHAT 与 PRD', '六类现状盘点（证据驱动）'],
-        tools: ['pm_create_prd', 'pm_create_assessment', 'pm_write_prd', 'pm_list_prds'],
-        boundary: '只读代码与文档 + 向用户提问 + 写 PRD/盘点；不执行、不派发、不发布。',
+        responsibilities: ['需求澄清与选择题请示', 'WHY/WHAT 与 PRD', '六类现状盘点（证据驱动）', '交接给 PJM', '复核/复盘/总结'],
+        tools: ['pm_create_prd', 'pm_create_assessment', 'pm_write_prd', 'pm_list_prds', 'pm_handoff_to_pjm', 'pm_review_feedback', 'pm_pipeline', 'pm_next_action'],
+        boundary: '只读代码与文档 + 向用户提问 + 写 PRD/盘点/复核；不执行、不派发、不发布。',
     }),
     Object.freeze({
         id: 'master-pjm',
         preset: 'master-pjm',
         name: '项目经理（PJM）',
         nameEn: 'Project Manager',
-        responsibilities: ['WBS 与七类项目管理', '隔离派发与节点汇总', '测试/交付/验收与结案'],
-        tools: ['pjm_create_plan', 'pjm_dispatch_step', 'pjm_complete_step', 'pjm_project_status', 'pjm_write_project', 'pjm_close_project'],
-        boundary: '只读代码 + 计划/派发/汇报；派发必须经 fangForker.spawn，无 forker 即 fail-closed。',
+        responsibilities: ['WBS 与七类项目管理', '接单与隔离派发', '节点自反馈', '测试/交付/验收与结案'],
+        tools: ['pjm_create_plan', 'pjm_take_handoff', 'pjm_dispatch_step', 'pjm_complete_step', 'pjm_project_status', 'pjm_check_step', 'pjm_report', 'pjm_submit_feedback', 'pjm_write_project', 'pjm_close_project', 'pjm_next_action'],
+        boundary: '只读代码 + 计划/派发/反馈；派发必须经 fangForker.spawn，无 forker 即 fail-closed；不替 PM 决定需求。',
     }),
 ]);
 export const ROLE = Object.freeze({ mother: 'mother', essence: 'essence', fork: 'fork' });

package/dist-host/plugins/cost-optimizer.js

@@ -108,7 +108,7 @@ export function apply(ctx, config = {}) {
     };
     const service = {
         id: SERVICE.cost,
-        version: '3.3.4',
+        version: '3.3.5',
         role,
         get mode() {
             return system.policy.describe().mode;
@@ -354,7 +354,7 @@ export function apply(ctx, config = {}) {
             return {
                 ok: true,
                 id: 'cost-optimizer',
-                version: '3.3.4',
+                version: '3.3.5',
                 role,
                 mode: current.mode,
                 requestedMode: current.requestedMode,
@@ -396,7 +396,7 @@ export function apply(ctx, config = {}) {
                         doubleCountGuard: report.doubleCountGuard,
                     };
                 })(),
-                note: '3.3.4：系统层记账/预算/灰度/审计 + A1 工具输出紧凑化（默认 shadow）+ 瓮城回流出口（contract 1.1.1 真实投递，回执计数修复）；工具面 A2–A3 与决策复用 B1–B4 已接入（shadow 默认）；3.3.3 起角色矩阵母体全开、分身挂双主管；3.3.4 起内置 PM/PJM 两个智能体 preset。',
+                note: '3.3.5：系统层记账/预算/灰度/审计 + A1 工具输出紧凑化（默认 shadow）+ 瓮城回流出口（contract 1.1.1 真实投递，回执计数修复）；工具面 A2–A3 与决策复用 B1–B4 已接入（shadow 默认）；3.3.3 起角色矩阵母体全开、分身挂双主管；3.3.4 起内置 PM/PJM 两个智能体 preset；3.3.5 起补齐引擎原语、可中断 LLM 流、WS 通道与流式管线。',
             };
         },
     };

package/dist-host/plugins/dual-manager.js

@@ -17,8 +17,9 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import { FANG_SERVICE, MASTER_VERSION, ROW, SERVICE, createIdFactory, detectRole, enabledOf, masterError, roleAllowed, safeGet, } from "../kernel.js";
-import { closePlan, normalizeAssessment, normalizePlan, normalizePrd, planProgress } from "../dual/schema.js";
-import { renderAssessmentDocument, renderClosureDocument, renderPrdDocument, renderProjectDocument } from "../dual/documents.js";
+import { closePlan, acceptHandoff, normalizeAssessment, normalizeFeedback, normalizeHandoff, normalizePlan, normalizePrd, normalizeReview, planProgress } from "../dual/schema.js";
+import { renderAssessmentDocument, renderClosureDocument, renderPrdDocument, renderProjectDocument, renderReviewDocument } from "../dual/documents.js";
+import { nextPjmAction, nextPmAction } from "../dual/orchestrator.js";
 export const name = 'dsh-master-dual-manager';
 export const inject = ['dshMaster'];
 export const ROW_ID = ROW.dual;
@@ -47,9 +48,15 @@ export function apply(ctx, config = {}) {
     const newPrdId = createIdFactory('prd');
     const newAssessmentId = createIdFactory('review');
     const newPlanId = createIdFactory('plan');
+    const newHandoffId = createIdFactory('handoff');
+    const newFeedbackId = createIdFactory('feedback');
+    const newReviewId = createIdFactory('pmreview');
     const prds = new Map();
     const assessments = new Map();
     const plans = new Map();
+    const handoffs = new Map();
+    const feedbacks = new Map();
+    const reviews = new Map();
     const decisionCenter = () => safeGet(ctx, FANG_SERVICE.decisionCenter);
     const forker = () => {
         const service = safeGet(ctx, FANG_SERVICE.forker);
@@ -134,6 +141,108 @@ export function apply(ctx, config = {}) {
                 return masterError('assessment-not-found', 'Assessment not found', { id: String(id ?? '') });
             return await writeWorkspaceDocument(agent, path.join('docs', 'pm', `REVIEW-${id}.md`), renderAssessmentDocument(assessment));
         },
+        /** 闭环第一步：PM 把 PRD（+盘点）打成交接包；open questions / 冲突未清则不给 ready。 */
+        createHandoff(prdId, input = {}) {
+            const prd = prds.get(String(prdId ?? ''));
+            if (!prd)
+                return masterError('prd-not-found', 'PRD not found', { id: String(prdId ?? '') });
+            const assessmentId = String(input.assessmentId ?? '').trim();
+            const assessment = assessmentId ? assessments.get(assessmentId) : null;
+            if (assessmentId && !assessment)
+                return masterError('assessment-not-found', 'Assessment not found', { id: assessmentId });
+            const made = normalizeHandoff(prd, assessment, { ...input, prdId: prd.id }, { id: newHandoffId() });
+            if (!made.ok)
+                return made;
+            handoffs.set(made.handoff.id, made.handoff);
+            return { ...made, ready: made.handoff.status === 'ready', reason: made.handoff.reason };
+        },
+        getHandoff(id) {
+            const handoff = handoffs.get(String(id ?? ''));
+            return handoff ? { ok: true, handoff } : masterError('handoff-not-found', 'Handoff not found', { id: String(id ?? '') });
+        },
+        listHandoffs() {
+            return { ok: true, items: [...handoffs.values()] };
+        },
+        /** 闭环第三步：PM 复核 PJM 反馈（逐条验收 + 复盘 + 总结），结论必须与验收一致。 */
+        reviewFeedback(feedbackId, input = {}) {
+            const feedback = feedbacks.get(String(feedbackId ?? ''));
+            if (!feedback)
+                return masterError('feedback-not-found', 'Feedback not found', { id: String(feedbackId ?? '') });
+            const made = normalizeReview(feedback, { ...input, feedbackId: feedback.id }, { id: newReviewId() });
+            if (!made.ok)
+                return made;
+            reviews.set(made.review.id, made.review);
+            const plan = plans.get(feedback.planId);
+            const handoff = [...handoffs.values()].find((item) => item.planId === feedback.planId) ?? null;
+            if (plan) {
+                plan.pmReview = Object.freeze({
+                    reviewId: made.review.id,
+                    verdict: made.review.verdict,
+                    accepted: made.review.verdict === 'accepted',
+                    reviewedAt: made.review.createdAt,
+                });
+                // 结案后仍保留事实，只标注“是否被 PM 接受”；不伪造重新开场。
+                plan.updatedAt = Date.now();
+            }
+            return { ok: true, review: made.review, planAccepted: made.review.verdict === 'accepted', handoffId: handoff?.id ?? null };
+        },
+        getReview(id) {
+            const review = reviews.get(String(id ?? ''));
+            return review ? { ok: true, review } : masterError('pm-review-not-found', 'Review not found', { id: String(id ?? '') });
+        },
+        listReviews() {
+            return { ok: true, items: [...reviews.values()] };
+        },
+        /** 闭环状态：一个 PRD 走到哪一步（交接/计划/反馈/复核）。 */
+        pipeline(prdId) {
+            const prd = prds.get(String(prdId ?? ''));
+            if (!prd)
+                return masterError('prd-not-found', 'PRD not found', { id: String(prdId ?? '') });
+            const handoff = [...handoffs.values()].filter((item) => item.prdId === prd.id).at(-1) ?? null;
+            const plan = handoff?.planId ? plans.get(handoff.planId) ?? null : [...plans.values()].filter((item) => item.prdId === prd.id).at(-1) ?? null;
+            const feedback = plan ? [...feedbacks.values()].filter((item) => item.planId === plan.id).at(-1) ?? null : null;
+            const review = feedback ? [...reviews.values()].filter((item) => item.feedbackId === feedback.id).at(-1) ?? null : null;
+            const stage = review
+                ? (review.verdict === 'accepted' ? 'accepted' : 'changes-requested')
+                : feedback ? 'feedback-submitted'
+                    : plan ? (plan.status === 'closed' ? 'closed-without-feedback' : 'planning')
+                        : handoff ? (handoff.status === 'ready' ? 'handoff-ready' : 'needs-clarification')
+                            : 'drafted';
+            return {
+                ok: true,
+                prdId: prd.id,
+                stage,
+                handoffId: handoff?.id ?? null,
+                handoffStatus: handoff?.status ?? null,
+                planId: plan?.id ?? null,
+                planStatus: plan?.status ?? null,
+                feedbackId: feedback?.id ?? null,
+                reviewId: review?.id ?? null,
+                verdict: review?.verdict ?? null,
+            };
+        },
+        /** 闭环第三步落盘：复核 + 复盘 + 总结文档。 */
+        async writeReview(reviewId, { agent } = {}) {
+            const review = reviews.get(String(reviewId ?? ''));
+            if (!review)
+                return masterError('pm-review-not-found', 'Review not found', { id: String(reviewId ?? '') });
+            const feedback = feedbacks.get(review.feedbackId) ?? null;
+            const handoff = feedback ? [...handoffs.values()].find((item) => item.planId === review.planId) ?? null : null;
+            const markdown = renderReviewDocument(review, { feedback, handoff });
+            return await writeWorkspaceDocument(agent, path.join('docs', 'pm', `REVIEW-${review.id}.md`), markdown);
+        },
+        /** 编排建议：PM 下一步该做什么（纯推荐，不产生副作用）。 */
+        nextAction(prdId) {
+            const prd = prds.get(String(prdId ?? ''));
+            if (!prd)
+                return masterError('prd-not-found', 'PRD not found', { id: String(prdId ?? '') });
+            const assessment = [...assessments.values()].filter((item) => item.prdId === prd.id).at(-1) ?? null;
+            const handoff = [...handoffs.values()].filter((item) => item.prdId === prd.id).at(-1) ?? null;
+            const plan = handoff?.planId ? plans.get(handoff.planId) ?? null : null;
+            const feedback = plan ? [...feedbacks.values()].filter((item) => item.planId === plan.id).at(-1) ?? null : null;
+            const review = feedback ? [...reviews.values()].filter((item) => item.feedbackId === feedback.id).at(-1) ?? null : null;
+            return { ok: true, prdId: prd.id, ...nextPmAction({ prd, assessment, handoff, feedback, review }), pipeline: pm.pipeline(prd.id) };
+        },
         /** 歧义澄清：复用瓮城决策中心，返回 ticket 或明确的 unavailable。 */
         async askUser({ question, context = '', options = [], level = 'yellow' } = {}) {
             const q = String(question ?? '').trim();
@@ -161,17 +270,125 @@ export function apply(ctx, config = {}) {
         },
     };
     const pjm = {
-        /** PRD → 七类项目计划与可调度 WBS。 */
+        /** PRD → 七类项目计划与可调度 WBS；给 handoffId 时同时完成接单。 */
         plan(prdId, input = {}) {
             const prd = prds.get(String(prdId ?? ''));
             if (!prd)
                 return masterError('prd-not-found', 'PRD not found', { id: String(prdId ?? '') });
+            const handoffId = String(input.handoffId ?? '').trim();
+            const handoff = handoffId ? handoffs.get(handoffId) : null;
+            if (handoffId && !handoff)
+                return masterError('handoff-not-found', 'Handoff not found', { id: handoffId });
+            if (handoff && handoff.status === 'needs-clarification') {
+                return masterError('handoff-not-ready', 'PM must resolve open questions before PJM plans', { reason: handoff.reason, openQuestions: handoff.openQuestions });
+            }
+            if (handoff && handoff.prdId !== prd.id)
+                return masterError('handoff-prd-mismatch', 'Handoff belongs to a different PRD', { handoffId, prdId: prd.id });
             const made = normalizePlan(prd, input, { id: newPlanId() });
             if (!made.ok)
                 return made;
             plans.set(made.plan.id, made.plan);
+            if (handoff) {
+                const accepted = acceptHandoff(handoff, { planId: made.plan.id });
+                if (!accepted.ok)
+                    return { ...accepted, plan: made.plan };
+                made.plan.handoffId = handoff.id;
+            }
             return made;
         },
+        /** 接单（独立调用）：只有 ready 的交接包能被接走。 */
+        takeHandoff(handoffId, input = {}) {
+            const handoff = handoffs.get(String(handoffId ?? ''));
+            if (!handoff)
+                return masterError('handoff-not-found', 'Handoff not found', { id: String(handoffId ?? '') });
+            return acceptHandoff(handoff, { planId: input.planId });
+        },
+        listHandoffs() {
+            return { ok: true, items: [...handoffs.values()] };
+        },
+        /** 节点自反馈：执行中随时可报，不等到最后；blocked 必须写原因。 */
+        report(planId, input = {}) {
+            const plan = plans.get(String(planId ?? ''));
+            if (!plan)
+                return masterError('plan-not-found', 'Plan not found', { id: String(planId ?? '') });
+            const summary = String(input.summary ?? '').trim();
+            if (!summary)
+                return missing('summary');
+            const status = ['progress', 'blocked', 'done'].includes(String(input.status)) ? String(input.status) : 'progress';
+            if (status === 'blocked' && !String(input.blocker ?? input.reason ?? '').trim()) {
+                return masterError('blocker-required', 'a blocked report must name the blocker');
+            }
+            plan.reports = Array.isArray(plan.reports) ? plan.reports : [];
+            plan.reports.push(Object.freeze({
+                stepId: String(input.stepId ?? '') || null,
+                status,
+                summary,
+                blocker: String(input.blocker ?? input.reason ?? '').trim() || null,
+                evidence: Array.isArray(input.evidence) ? input.evidence.map(String).filter(Boolean) : [],
+                at: Date.now(),
+            }));
+            plan.updatedAt = Date.now();
+            return { ok: true, planId: plan.id, status, reports: plan.reports.length, progress: planProgress(plan) };
+        },
+        /** 项目级自反馈：计划全部步骤完成后提交给 PM 复核。 */
+        submitFeedback(planId, input = {}) {
+            const plan = plans.get(String(planId ?? ''));
+            if (!plan)
+                return masterError('plan-not-found', 'Plan not found', { id: String(planId ?? '') });
+            const prd = prds.get(plan.prdId) ?? null;
+            const handoff = [...handoffs.values()].find((item) => item.planId === plan.id) ?? null;
+            const made = normalizeFeedback(plan, prd, { ...input, planId: plan.id, handoffId: handoff?.id ?? input.handoffId }, { id: newFeedbackId() });
+            if (!made.ok)
+                return made;
+            feedbacks.set(made.feedback.id, made.feedback);
+            plan.feedbackId = made.feedback.id;
+            return { ...made, handoffId: handoff?.id ?? null };
+        },
+        listFeedback() {
+            return { ok: true, items: [...feedbacks.values()] };
+        },
+        /** 单步状态：房主没有 VM 作业队列，这里报的是派发/执行/汇报的真实状态。 */
+        checkStep(planId, stepId) {
+            const plan = plans.get(String(planId ?? ''));
+            if (!plan)
+                return masterError('plan-not-found', 'Plan not found', { id: String(planId ?? '') });
+            const step = plan.steps.find((item) => item.id === String(stepId ?? ''));
+            if (!step)
+                return masterError('step-not-found', 'Step not found', { id: String(stepId ?? '') });
+            const reports = (Array.isArray(plan.reports) ? plan.reports : []).filter((report) => !report.stepId || report.stepId === step.id);
+            return {
+                ok: true,
+                planId: plan.id,
+                stepId: step.id,
+                title: step.title,
+                status: step.status,
+                owner: step.owner ?? null,
+                where: step.where ?? null,
+                estimateMinutes: step.estimateMinutes ?? null,
+                actualMinutes: step.actualMinutes ?? null,
+                summary: step.summary ?? null,
+                evidence: step.evidence ?? [],
+                acceptance: step.acceptance ?? [],
+                fork: step.fork ?? null,
+                reports: reports.slice(-5),
+                note: 'no-vm-jobs: 房主经 fangForker 派发隔离执行体，没有 vm_job_submit / vm_job_status 这类作业队列',
+            };
+        },
+        /** 编排建议：PJM 下一步该做什么（纯推荐，不产生副作用）。 */
+        nextAction(planId) {
+            const plan = plans.get(String(planId ?? ''));
+            if (!plan)
+                return masterError('plan-not-found', 'Plan not found', { id: String(planId ?? '') });
+            const handoff = [...handoffs.values()].find((item) => item.planId === plan.id)
+                ?? [...handoffs.values()].filter((item) => item.prdId === plan.prdId).at(-1)
+                ?? null;
+            const feedback = [...feedbacks.values()].filter((item) => item.planId === plan.id).at(-1) ?? null;
+            return { ok: true, planId: plan.id, ...nextPjmAction({ handoff, plan, feedback }), progress: planProgress(plan) };
+        },
+        getFeedback(id) {
+            const feedback = feedbacks.get(String(id ?? ''));
+            return feedback ? { ok: true, feedback } : masterError('feedback-not-found', 'Feedback not found', { id: String(id ?? '') });
+        },
         getPlan(id) {
             const plan = plans.get(String(id ?? ''));
             return plan ? { ok: true, plan } : masterError('plan-not-found', 'Plan not found', { id: String(id ?? '') });
@@ -301,8 +518,15 @@ export function apply(ctx, config = {}) {
                 version: MASTER_VERSION,
                 role,
                 agents: { pm: 'master-pm', pjm: 'master-pjm' },
-                pm: { prds: prds.size, assessments: assessments.size },
-                pjm: { plans: plans.size, closed: [...plans.values()].filter((plan) => plan.status === 'closed').length },
+                pm: { prds: prds.size, assessments: assessments.size, handoffs: handoffs.size, reviews: reviews.size },
+                pjm: { plans: plans.size, closed: [...plans.values()].filter((plan) => plan.status === 'closed').length, feedbacks: feedbacks.size },
+                loop: {
+                    pendingHandoffs: [...handoffs.values()].filter((item) => item.status !== 'accepted').length,
+                    acceptedHandoffs: [...handoffs.values()].filter((item) => item.status === 'accepted').length,
+                    awaitingReview: [...feedbacks.values()].filter((item) => ![...reviews.values()].some((review) => review.feedbackId === item.id)).length,
+                    accepted: [...reviews.values()].filter((review) => review.verdict === 'accepted').length,
+                    changesRequested: [...reviews.values()].filter((review) => review.verdict === 'changes-requested').length,
+                },
                 cooperation: {
                     decisionCenter: Boolean(decisionCenter()),
                     forker: Boolean(forker()),
@@ -317,7 +541,7 @@ export function apply(ctx, config = {}) {
     master.registerSubplugin({
         id: 'dual-manager',
         name: 'dsh-master-dual-manager',
-        capabilities: ['pm-prd', 'pm-assessment', 'pm-document', 'pm-ask-user', 'pjm-plan', 'pjm-dispatch', 'pjm-progress', 'pjm-close'],
+        capabilities: ['pm-prd', 'pm-assessment', 'pm-document', 'pm-ask-user', 'pm-handoff', 'pm-review', 'pjm-plan', 'pjm-dispatch', 'pjm-progress', 'pjm-close', 'pjm-feedback'],
         description: 'PM/PJM 双智能体共享服务；master-pm 与 master-pjm preset 复用此服务',
     });
     return service;

package/docs/AGENTS-PM-PJM.md

@@ -81,16 +81,100 @@ Rules  真实状态汇报，失败/阻塞/未测量不得包装成完成；
    │  (新会话选 preset: master-pm)
    ▼
 PM: 澄清选择题 → PRD(prd_*) → 六类盘点(review_*) → docs/pm/*.md
-   │  只移交 prdId + 验收标准 + 未决问题
+   │  pm_handoff_to_pjm：验收标准齐全 + 无未决问题/冲突 ⇒ ready
    ▼
-PJM: 会审 → WBS(plan_*) → fangForker.spawn 派生分身 → 节点汇总
-   │                                      │
-   │                          每步记录 evidence / actualMinutes
+PJM: pjm_take_handoff / pjm_create_plan({handoffId}) 接单
+   │  WBS → fangForker.spawn 派生分身 → pjm_report 节点自反馈
+   │  每步记录 evidence / actualMinutes
    ▼
-PJM: 全绿 → 结案（summary/评审报告/验收/资料）→ docs/pjm/*.md
+PJM: 全步 done → pjm_submit_feedback（交付/偏差/遗留/测试）
+   ▼
+PM: pm_review_feedback（逐条 met + 证据 + 复盘 + 总结）
+   │  verdict 必须与验收一致：有未达标 ⇒ changes-requested
+   ▼
+accepted ⇒ 计划标记 pmReview.accepted；changes-requested ⇒ 退回重做
 ```
 
-当前实现里两者**不共享隐式上下文**：PM 只写 PRD/盘点，PJM 只读 PRD 与自己的计划，跨角色只传 id 与结构。
+**闭环门禁**（都写在 `src/dual/schema.ts`，有测试）：
+
+| 环节 | 门禁 |
+|---|---|
+| PM 交接 | 验收标准 ≥1；未决问题/冲突必须清零，否则 `needs-clarification`，PJM 不允许接单 |
+| PJM 接单 | 只有 `ready` 能接；重复接单 `handoff-already-accepted` |
+| 节点自反馈 | `blocked` 必须写 blocker；不等到最后才报 |
+| 项目反馈 | 必须全部步骤 `done`；`summary` 必填；带交付/偏差/遗留/测试 |
+| PM 复核 | 验收逐条 `met` 必须是布尔；`accepted` 不能带未达标项；`changes-requested` 不能带全达标项 |
+| 闭环状态 | `pm_pipeline` 给出 drafted → handoff-ready/needs-clarification → planning → feedback → accepted/changes-requested |
+
+**跨角色只传结构**：PRD/盘点/交接包/计划/反馈/复核都是显式记录（`handoff_*`、`feedback_*`、`pmreview_*`），
+不共享隐式上下文；PM 不能替 PJM 编造执行结果，PJM 不能给自己复核。
+
+### 4.3 工具清单与「草案 → 实际」对照
+
+**PM（8 个）**：`pm_create_prd` · `pm_create_assessment` · `pm_write_prd` · `pm_list_prds` ·
+`pm_handoff_to_pjm` · `pm_review_feedback` · `pm_pipeline` · `pm_next_action`
+
+**PJM（11 个）**：`pjm_create_plan` · `pjm_take_handoff` · `pjm_dispatch_step` · `pjm_complete_step` ·
+`pjm_project_status` · `pjm_check_step` · `pjm_report` · `pjm_submit_feedback` · `pjm_write_project` ·
+`pjm_close_project` · `pjm_next_action`
+
+| 常见草案名 | 房主实际 | 说明 |
+|---|---|---|
+| `ask_user_choice`（emit 事件后返回“请等待”） | **宿主工具 `ask_user_question`**（preset 已挂载） | 草案那样“发完就返回”不会真正阻塞，模型会继续瞎编；真实阻塞在宿主 `userQuestions` |
+| `write_prd_doc` | `pm_write_prd` | 只写 Session workspace 下 `docs/pm`，越界拒写；PRD 结构由 `pm_create_prd` 先落库 |
+| `spawn_dev_environment` | `pjm_take_handoff` + `pjm_dispatch_step` | 无 `umbrella.derivedManager`；派发只走 `fangForker.spawn`，无 forker 即 fail-closed |
+| `execute_project_step` | `pjm_dispatch_step` + `pjm_complete_step` | 房主不直接跑命令；执行发生在隔离执行体，结果由 `complete_step` 记账 |
+| `check_task_status`（`vm_job_status`） | `pjm_project_status` + `pjm_check_step` | 没有 VM 作业队列；状态来自计划、节点汇报与派发记录 |
+
+**契约测试**（`test/agent-tools.test.mjs`，6 条）保证：
+
+- 每个工具都有合法命名、`type:'object'` 参数、`output.schema/render` 封套；
+- `AGENT_CATALOG` 声称的工具**确实注册了**（防止文档漂移）；
+- 任何工具的描述/参数里**不出现** `vm_create/vm_exec/vm_job_submit/vm_job_status/vm_snapshot/vm_restore/umbrella.`；
+- 未知 id 一律返回具名 code（`prd-not-found` / `plan-not-found` / `feedback-not-found` / `handoff-not-found` / `step-not-found`）；
+- PM→PJM 闭环全部经工具跑通，且派发在无 forker 时返回 `fang-forker-unavailable`；
+- 不存在任何工具去“假装阻塞提问”。
+
+
+
+### 4.2 编排策略：下一步做什么由状态机决定（3.3.5）
+
+模型知道工具清单，但未必知道"现在该用哪个"。所以把闭环状态机写成确定性函数
+（`src/dual/orchestrator.ts`），并通过 `pm_next_action` / `pjm_next_action` 暴露给模型：
+
+| 状态 | PM 推荐动作 | PJM 推荐动作 |
+|---|---|---|
+| 还没有 PRD | `create_prd` | — |
+| 有 PRD 无盘点 | `create_assessment` | — |
+| 有未决问题 / 冲突 | `clarify`（**blocking**，必须问用户） | — |
+| 验收齐备、无未决 | `handoff` | — |
+| 交接包未就绪 | `blocked`（原因） | `return_to_pm`（**blocking**，不得硬开工） |
+| 交接包 ready | 等 PJM（非阻塞） | `take_handoff` |
+| 有交接无计划 | — | `create_plan`（WBS 由模型拆） |
+| 有 pending 步骤 | — | `dispatch`（下一个 stepId） |
+| 有 running 步骤 | — | `report`（progress，不重复派发） |
+| 有 failed 步骤 | — | `report`（blocked，不得写成完成） |
+| 节点报告为 blocked | — | `report`（blocking，等决策） |
+| 全部 done 无反馈 | — | `complete_feedback` |
+| 有反馈未复核 | `review` | `close` / `done` |
+| 已通过 / 已退回 | `done` | `done` |
+
+**测试保证**：每个推荐动作都必须映射到 preset 里真实注册的工具
+（`test/orchestrator.test.mjs` 交叉比对 `AGENT_CATALOG`），防止文档与工具漂移；
+反向也检查工具清单没有"孤儿工具"。编排只给建议，不产生任何副作用。
+
+### 4.1 「自动交接」到底自动了什么
+
+| 自动（代码确定性完成） | 不自动（需要模型判断） |
+|---|---|
+| 门禁判定：验收标准 ≥1、未决问题/冲突清零 → `ready` | 把验收标准拆成 WBS 步骤，以及每步的 prompt/owner/场景/估时 |
+| 接单绑定：`ready` 才能接，接单后写 `status=accepted`、`planId`、`plan.handoffId` | 判断某条验收是否真的满足（PM 复核时逐条 `met`） |
+| 状态流转：`drafted → handoff-ready / needs-clarification → planning → feedback → accepted / changes-requested` | 写 PRD 的需求内容、六类盘点、复盘结论 |
+| 防重：重复接单、未完成就提交反馈、结论与验收不一致，全部拒收 | 决定是否退回重做、退回理由是否成立 |
+
+**为什么不做「自动拆 WBS」**：交接包只带验收标准与约束，**不含 `steps` 字段**；带 `handoffId` 调
+`pjm_create_plan` 仍必须由 PJM 给步骤，否则返回 `steps-required`。这是刻意的——把验收翻译成步骤需要
+理解语义，代码里硬编码只会产出看起来合理、实际不可执行的假 WBS（`test/pm-pjm-loop.test.mjs` 有断言）。
 
 ## 5. 如何启用