qlogicagent 2.13.3 → 2.13.5

package/dist/cli/acp-extended-handlers.js

@@ -0,0 +1,484 @@
+import { randomUUID } from "node:crypto";
+import * as path from "node:path";
+import { getBuiltInAgents } from "../orchestration/subagent/agent-registry.js";
+import { ProductRunCoordinator } from "../orchestration/product-run-coordinator.js";
+import { runForkedAgent } from "../runtime/execution/forked-agent.js";
+import { runSpecChatRound } from "../orchestration/solo-spec-builder.js";
+import { runWorkflowChatRound } from "../orchestration/workflow-chat-builder.js";
+import { buildCapabilityCatalog } from "../orchestration/workflow/capability-catalog.js";
+import { WorkflowStore } from "../orchestration/workflow/workflow-store.js";
+import { getUserAgentHome } from "../runtime/infra/agent-paths.js";
+import { ASK_USER_TOOL_NAME } from "../skills/tools/ask-user-tool.js";
+import { handleDream as handleDreamRpc } from "./handlers/dream-handler.js";
+import { ensureProductOrchestrator, ensureProductPlanner, productProjectMap, writeProductTerminalPlanStatus } from "./handlers/product-handler.js";
+import { ensureSoloEvaluator, soloProjectMap } from "./handlers/solo-handler.js";
+import { makeAskUserBackend } from "./turn-ask-user-setup.js";
+import * as projectStore from "../runtime/infra/project-store.js";
+import { createCliForkedAgentRunner } from "./agent-runner-factory.js";
+/** Build an AgentLogger that prefixes every line and routes to host.log (shared by forked-agent calls). */
+function prefixedLogger(log, prefix) {
+    return {
+        info: (msg) => log(`${prefix} ${msg}`),
+        warn: (msg) => log(`${prefix} WARN: ${msg}`),
+        error: (msg) => log(`${prefix} ERROR: ${msg}`),
+        debug: (msg) => log(`${prefix} ${msg}`),
+    };
+}
+export async function handleAcpDream(host, params) {
+    host.log(`[acp] x/dream: session=${params.sessionId}`);
+    const dreamClient = host.resolveClientForPurpose("textGeneration");
+    if (!dreamClient) {
+        return { ok: false, summary: "No LLM transport configured for dream" };
+    }
+    const agentHome = getUserAgentHome();
+    const syntheticMsg = {
+        jsonrpc: "2.0",
+        id: `acp-dream-${randomUUID().slice(0, 8)}`,
+        method: "memory.dream",
+        params: {
+            turnId: `dream-${randomUUID().slice(0, 8)}`,
+            sessionId: params.sessionId || host.currentSessionId,
+            config: {
+                memoryRoot: params.config?.memoryRoot || host.resolveMemoryRoot?.() || path.join(agentHome, "memory"),
+                transcriptDir: params.config?.transcriptDir || host.resolveTranscriptDir?.() || path.join(agentHome, "agent-logs"),
+                model: dreamClient.model,
+                apiKey: dreamClient.apiKey,
+                ...params.config,
+            },
+        },
+    };
+    await handleDreamRpc.call(host, syntheticMsg);
+    return { ok: true, summary: "Dream consolidation triggered" };
+}
+/**
+ * Resolve a plan run's cwd from its project's workspaceDir (mutates params.cwd when unset), so
+ * Solo/Product worktrees land in the user's workspace (e.g. ~/.qlogicagent/workspaces/default) —
+ * not the gateway's own process.cwd(), which polluted xiaozhiclaw-runtime/.worktrees. The
+ * rpc-registry handler did this; the x/ ACP entry (the one the gateway actually calls) didn't.
+ */
+function resolvePlanCwd(params) {
+    if (params.cwd)
+        return;
+    const projectId = params.projectId;
+    const proj = projectId ? projectStore.getProjectById(projectId) : projectStore.getActiveProject();
+    if (proj?.workspaceDir)
+        params.cwd = proj.workspaceDir;
+}
+export async function handleAcpSoloStart(host, params) {
+    host.log("[acp] x/solo.start");
+    resolvePlanCwd(params);
+    const evaluator = ensureSoloEvaluator.call(host);
+    const soloId = await evaluator.start(params);
+    // R2 容器优先:前端在进入竞赛前已新建/绑定一个 type:"solo" 工作区项目(projectId 由 resolvePlanCwd
+    // 用来取 cwd)。这里只把本次 run 绑定到那个已存在容器(写 leaderSessionId/planAgents/planStatus),
+    // 不再影子创建重复项目(旧行为会另建一个指向同一 workspaceDir 的 solo 项目)。projectId 缺失/无效 =
+    // 前端没走容器步骤(不应发生),记日志、不建项目。winner 由 ensureSoloEvaluator 的 onEvaluation 经
+    // soloProjectMap 回写。
+    try {
+        const sp = params;
+        const container = sp.projectId ? projectStore.getProjectById(sp.projectId) : undefined;
+        if (container) {
+            projectStore.updateProject(container.id, {
+                leaderSessionId: soloId,
+                planAgents: Array.isArray(sp.agents) ? sp.agents : [],
+                planStatus: "running",
+            });
+            soloProjectMap.set(soloId, container.id);
+            const full = projectStore.getProjectById(container.id);
+            if (full)
+                host.sendNotification("project.created", full);
+        }
+        else {
+            host.log(`[acp] solo.start: 缺少有效 projectId(${sp.projectId})——容器优先要求前端先建/绑工作区项目`);
+        }
+    }
+    catch (err) {
+        host.log(`[acp] solo plan project bind failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return evaluator.getStatus(soloId);
+}
+export async function handleAcpSoloStatus(host, params) {
+    host.log("[acp] x/solo.status");
+    const soloId = params.soloId;
+    if (!soloId) {
+        return host.soloEvaluator ? host.soloEvaluator.listSessions() : [];
+    }
+    const evaluator = ensureSoloEvaluator.call(host);
+    const status = evaluator.getStatus(soloId);
+    if (!status)
+        throw new Error(`Solo session ${soloId} not found`);
+    return status;
+}
+export async function handleAcpSoloSelect(host, params) {
+    host.log("[acp] x/solo.select");
+    const evaluator = ensureSoloEvaluator.call(host);
+    const branch = await evaluator.select(params);
+    return { ok: true, mergedBranch: branch };
+}
+export async function handleAcpSoloCancel(host, params) {
+    host.log("[acp] x/solo.cancel");
+    const evaluator = ensureSoloEvaluator.call(host);
+    const soloId = params.soloId;
+    await evaluator.cancel(soloId);
+    return { ok: true };
+}
+export async function handleAcpSoloSubscribe(host, params) {
+    host.log("[acp] x/solo.subscribe");
+    const soloId = params.soloId;
+    return { ok: true, soloId };
+}
+export async function handleAcpSoloMessage(host, params) {
+    host.log("[acp] x/solo.message");
+    const evaluator = ensureSoloEvaluator.call(host);
+    const { soloId, agentId, content, agentIndex } = params;
+    return evaluator.message(soloId, agentId, content, agentIndex);
+}
+export async function handleAcpSoloEvaluate(host, params) {
+    host.log("[acp] x/solo.evaluate");
+    const evaluator = ensureSoloEvaluator.call(host);
+    const { soloId, evaluatorAgentId, evaluatorIndex } = params;
+    return evaluator.triggerEvaluation(soloId, evaluatorAgentId, evaluatorIndex);
+}
+/**
+ * R3 多轮对话式 spec(x/solo.specChat):每轮带全量 history 跑一次 runSpecChatRound(受限工具
+ * ask_user + set_spec,纯推理不改文件)。澄清走 Cut6 的 turn.ask_user/thread.user_response 往返。
+ * 成功返回 { reply, spec };LLM/连接级失败降级 { error }(不抛,前端可重发)。
+ */
+export async function handleAcpSoloSpecChat(host, params) {
+    host.log("[acp] x/solo.specChat");
+    const sp = params;
+    const rawTask = typeof sp.rawTask === "string" ? sp.rawTask.trim() : "";
+    const history = Array.isArray(sp.history) ? sp.history : [];
+    if (!rawTask && history.length === 0)
+        return { error: "Missing required param: rawTask/history" };
+    const client = host.resolveClientForPurpose("textGeneration");
+    if (!client)
+        return { error: "No LLM provider configured; send a prompt first to configure the model" };
+    const askUserToolDef = host.toolCatalog.getToolManifest().find(t => t.function.name === ASK_USER_TOOL_NAME);
+    if (!askUserToolDef)
+        return { error: "ask_user tool is unavailable" };
+    const specAbort = new AbortController();
+    try {
+        const { reply, spec } = await runSpecChatRound({
+            rawTask: rawTask || history.find(h => h.role === "user")?.content || "",
+            history,
+            transport: client.transport,
+            apiKey: client.apiKey,
+            model: client.model,
+            createAgentRunner: createCliForkedAgentRunner,
+            askUserToolDef,
+            askUser: makeAskUserBackend(host),
+            log: prefixedLogger(msg => host.log(msg), "[solo-spec-chat]"),
+            parentSignal: specAbort.signal,
+        });
+        return { reply, spec };
+    }
+    catch (err) {
+        const detail = err instanceof Error ? err.message : String(err);
+        host.log(`[acp] solo.specChat failed: ${detail}`);
+        return { error: detail };
+    }
+}
+/**
+ * R3 启动软门防呆(x/solo.specJudge):用 host LLM 一次性评判 spec 是否达可开赛标准。
+ * 无 LLM → 降级放行({ ok:true })(软门本就"警告可走")。返回 { ok, issues[] }。
+ */
+export async function handleAcpSoloSpecJudge(host, params) {
+    host.log("[acp] x/solo.specJudge");
+    const sp = params;
+    const spec = sp.spec;
+    if (!spec || typeof spec.goal !== "string")
+        return { ok: false, issues: ["规格缺失"] };
+    const client = host.resolveClientForPurpose("textGeneration");
+    if (!client)
+        return { ok: true, issues: [] }; // 无 LLM:软门放行
+    const specText = [
+        `GOAL: ${spec.goal}`,
+        `CONSTRAINTS:\n${(spec.constraints ?? []).map(c => `- ${c}`).join("\n")}`,
+        `ACCEPTANCE:\n${(spec.acceptance ?? []).map(a => `- ${a}`).join("\n")}`,
+    ].join("\n");
+    const judgePrompt = `你是 Solo 竞赛规格的质量审查员。判断下面规格是否达到可开赛标准:
+- goal 是否清晰具体(非空泛)?
+- acceptance 是否 ≥1 条且每条可客观判定(满足/不满足)?
+- constraints 是否具体(可空)?
+只输出:第一行 \`VERDICT: OK\` 或 \`VERDICT: NEEDS_WORK\`;若 NEEDS_WORK,随后每行一条问题 \`- <中文、具体、可改>\`(最多 3 条)。不要其它内容。
+
+规格:
+${specText}`;
+    try {
+        const res = await runForkedAgent({
+            promptMessages: [{ role: "user", content: judgePrompt }],
+            systemPrompt: "你是严格但务实的规格审查员。",
+            tools: [],
+            transport: client.transport,
+            toolInvoker: { invoke: async () => ({ result: "" }) },
+            createAgentRunner: createCliForkedAgentRunner,
+            apiKey: client.apiKey,
+            model: client.model,
+            log: prefixedLogger(msg => host.log(msg), "[solo-spec-judge]"),
+            forkLabel: "solo-spec-judge",
+            maxTurns: 1,
+            parentSignal: new AbortController().signal,
+        });
+        const text = res.events
+            .filter((e) => e.type === "end" && "content" in e)
+            .map((e) => e.content ?? "").join("")
+            || res.events.filter((e) => e.type === "delta" && "text" in e).map((e) => e.text).join("");
+        const ok = /VERDICT:\s*OK/i.test(text) && !/VERDICT:\s*NEEDS_WORK/i.test(text);
+        const issues = ok ? [] : text.split("\n").map(l => l.replace(/^\s*[-*]\s?/, "").trim())
+            .filter(l => l && !/^VERDICT:/i.test(l)).slice(0, 3);
+        return { ok, issues };
+    }
+    catch (err) {
+        host.log(`[acp] solo.specJudge failed (放行): ${err instanceof Error ? err.message : String(err)}`);
+        return { ok: true, issues: [] }; // 评判失败也放行(软门)
+    }
+}
+/**
+ * M4 自动化页对话式搭图/改图(x/workflow.chat):forked agent + propose_workflow 工具,产出工作流提案
+ * (新建 def / 改已有 patch),propose-only 无副作用。澄清走 Cut6 ask 往返。失败降级 { error } 不抛。
+ * 应用由前端经既有 workflow.create/patch 完成(触发 WS 回流画布),故本轮不碰引擎控制器。
+ */
+export async function handleAcpWorkflowChat(host, params) {
+    host.log("[acp] x/workflow.chat");
+    const wp = params;
+    const history = Array.isArray(wp.history) ? wp.history : [];
+    if (history.length === 0)
+        return { error: "Missing required param: history" };
+    const client = host.resolveClientForPurpose("textGeneration");
+    if (!client)
+        return { error: "No LLM provider configured; send a prompt first to configure the model" };
+    // 真实能力目录(D24/IT-3):AI 只许引用目录内能力(propose 校验回环拒幻觉)。
+    // 项目根:带 projectId 时按项目解析(skill 启用是 project-aware 的),缺省 active root。
+    // channel 引擎不可知:网关在转发本 RPC 时注入 `channels: string[]`,此处并入目录。
+    let projectRoot = host.getActiveProjectRoot();
+    const projectId = params.projectId;
+    if (typeof projectId === "string" && projectId) {
+        const project = projectStore.getProjectById(projectId);
+        if (!project)
+            return { error: `unknown projectId "${projectId}"` };
+        projectRoot = project.workspaceDir;
+    }
+    const catalog = buildCapabilityCatalog({
+        getToolManifest: () => host.toolCatalog.getToolManifest(),
+        listAgentIds: () => [
+            { id: "qlogicagent", name: "小智(默认)" },
+            ...host.acpDetector.list().filter((a) => a.status === "available" && a.id !== "qlogicagent").map((a) => ({ id: a.id, name: a.name })),
+        ],
+        projectRoot,
+    });
+    const channels = params.channels;
+    if (Array.isArray(channels)) {
+        for (const ch of channels) {
+            if (typeof ch === "string" && ch) {
+                catalog.push({ category: "channel", kind: "channel", id: ch, label: `渠道: ${ch}`, paramsTemplate: { channel: ch, payload: "" } });
+            }
+        }
+    }
+    const abort = new AbortController();
+    try {
+        const { reply, def, patch, trigger, rejected } = await runWorkflowChatRound({
+            history,
+            currentWorkflow: typeof wp.currentWorkflow === "string" ? wp.currentWorkflow : undefined,
+            scope: Array.isArray(wp.scope) ? wp.scope.filter((s) => typeof s === "string") : undefined,
+            catalog,
+            transport: client.transport,
+            apiKey: client.apiKey,
+            model: client.model,
+            createAgentRunner: createCliForkedAgentRunner,
+            log: prefixedLogger(msg => host.log(msg), "[workflow-chat]"),
+            parentSignal: abort.signal,
+        });
+        if (rejected)
+            host.log(`[acp] workflow.chat: all ${rejected.attempts} propose attempts rejected — ${rejected.errors.join("; ")}`);
+        return { reply, def, patch, trigger, ...(rejected ? { rejected } : {}) };
+    }
+    catch (err) {
+        const detail = err instanceof Error ? err.message : String(err);
+        host.log(`[acp] workflow.chat failed: ${detail}`);
+        return { error: detail };
+    }
+}
+export async function handleAcpAgentsList(host) {
+    host.log("[acp] x/agents.list");
+    return getBuiltInAgents();
+}
+/**
+ * x/workflow.matchIntent(spec D22 语义兜底)— 确定性短语在客户端已查过且未命中,且存在
+ * semantic:true 的活跃意图工作流时才会被调用:对候选集做**一次**轻量 LLM 分类(单发,非 agent
+ * turn)。候选枚举是纯文件读(active root + automation 项目的工作流 store),不经引擎。
+ * 无 LLM / 分类失败 → {matched:null}(放行进正常聊天,绝不拦死用户消息)。
+ */
+export async function handleAcpWorkflowMatchIntent(host, params) {
+    host.log("[acp] x/workflow.matchIntent");
+    const text = typeof params.text === "string" ? params.text.trim() : "";
+    if (!text)
+        return { matched: null, error: "Missing required param: text" };
+    const surface = typeof params.surface === "string" ? params.surface : undefined;
+    // 候选 = 全部根的 active intent 工作流(semantic 开启的才参与语义兜底)。
+    const roots = new Map();
+    const active = projectStore.getActiveProject();
+    roots.set(host.getActiveProjectRoot(), { cwd: host.getActiveProjectRoot(), projectId: active?.id });
+    for (const project of projectStore.listProjects()) {
+        if (project.type === "automation")
+            roots.set(project.workspaceDir, { cwd: project.workspaceDir, projectId: project.id });
+    }
+    const candidates = [];
+    for (const root of roots.values()) {
+        const records = await new WorkflowStore(root.cwd).listActive();
+        for (const rec of records) {
+            if (rec.trigger?.type !== "intent" || !rec.trigger.semantic)
+                continue;
+            if (surface && rec.trigger.surfaces && !rec.trigger.surfaces.includes(surface))
+                continue;
+            candidates.push({ workflowId: rec.id, projectId: root.projectId, name: rec.name, phrases: [...rec.trigger.phrases, ...(rec.trigger.aliases ?? [])] });
+        }
+    }
+    if (candidates.length === 0)
+        return { matched: null };
+    const client = host.resolveClientForPurpose("textGeneration");
+    if (!client)
+        return { matched: null }; // 无 LLM:兜底放行(不拦消息)
+    const list = candidates.map((c, i) => `${i + 1}. id=${c.workflowId} 名称「${c.name}」 触发短语:${c.phrases.join(" / ")}`).join("\n");
+    const prompt = `用户在聊天输入框说了一句话。判断这句话是否明确表达了"要运行下面某个自动化"的意图(同义改写也算;闲聊/提问/无关内容一律不算)。
+候选自动化:
+${list}
+
+用户的话:「${text}」
+
+只输出一行:命中给 \`MATCH: <id>\`;不命中给 \`MATCH: none\`。宁可 none 不要误报。`;
+    try {
+        const res = await runForkedAgent({
+            promptMessages: [{ role: "user", content: prompt }],
+            systemPrompt: "你是意图分类器,只输出规定格式。",
+            tools: [],
+            transport: client.transport,
+            toolInvoker: { invoke: async () => ({ result: "" }) },
+            createAgentRunner: createCliForkedAgentRunner,
+            apiKey: client.apiKey,
+            model: client.model,
+            log: prefixedLogger(msg => host.log(msg), "[intent-match]"),
+            forkLabel: "intent-match",
+            maxTurns: 1,
+            parentSignal: new AbortController().signal,
+        });
+        const out = res.events
+            .filter((e) => e.type === "end" && "content" in e)
+            .map((e) => e.content ?? "").join("")
+            || res.events.filter((e) => e.type === "delta" && "text" in e).map((e) => e.text).join("");
+        const m = /MATCH:\s*([\w-]+)/.exec(out);
+        const id = m?.[1];
+        if (!id || id === "none")
+            return { matched: null };
+        const hit = candidates.find((c) => c.workflowId === id);
+        if (!hit)
+            return { matched: null }; // LLM 幻觉 id → 视为未命中(宁缺勿误)
+        return { matched: { workflowId: hit.workflowId, projectId: hit.projectId, name: hit.name } };
+    }
+    catch (err) {
+        host.log(`[acp] workflow.matchIntent failed: ${err instanceof Error ? err.message : String(err)}`);
+        return { matched: null }; // 分类失败放行,不拦死消息
+    }
+}
+export async function handleAcpProductCreate(host, params) {
+    host.log("[acp] x/product.create");
+    resolvePlanCwd(params);
+    const orchestrator = ensureProductOrchestrator.call(host);
+    const productId = await orchestrator.create(params);
+    // R2 容器优先:把本次 product run 绑定到前端已建/绑的 type:"product" 容器项目,使其进 历史方案
+    // (与 solo.start 对齐;此前 product 根本不落 type:product 项目 → 历史方案从无 product)。projectId
+    // 缺失/无效 = 前端没走容器步骤(不应发生),记日志、不建项目。终态回写见 productProjectMap 的 TODO。
+    try {
+        const sp = params;
+        const container = sp.projectId ? projectStore.getProjectById(sp.projectId) : undefined;
+        if (container) {
+            projectStore.updateProject(container.id, {
+                leaderSessionId: productId,
+                planAgents: Array.isArray(sp.instances) ? sp.instances.map((i) => i.agentId ?? "").filter(Boolean) : [],
+                planStatus: "running",
+            });
+            productProjectMap.set(productId, container.id);
+            const full = projectStore.getProjectById(container.id);
+            if (full)
+                host.sendNotification("project.created", full);
+        }
+        else {
+            host.log(`[acp] product.create: 缺少有效 projectId(${sp.projectId})——容器优先要求前端先建/绑工作区项目`);
+        }
+    }
+    catch (err) {
+        host.log(`[acp] product plan project bind failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return { productId };
+}
+export async function handleAcpProductPlan(host, params) {
+    host.log("[acp] x/product.plan");
+    const planner = ensureProductPlanner.call(host);
+    return planner.plan(params);
+}
+export async function handleAcpProductConfirm(host, params) {
+    host.log("[acp] x/product.confirm");
+    const planner = ensureProductPlanner.call(host);
+    const confirmParams = params;
+    const orchestrator = ensureProductOrchestrator.call(host);
+    return new ProductRunCoordinator(planner, orchestrator).confirmAndStart(confirmParams);
+}
+export async function handleAcpProductMessage(host, params) {
+    host.log("[acp] x/product.message");
+    const planner = ensureProductPlanner.call(host);
+    const orchestrator = ensureProductOrchestrator.call(host);
+    const msgParams = params;
+    return new ProductRunCoordinator(planner, orchestrator).message(msgParams.productId, msgParams.content);
+}
+export async function handleAcpProductResume(host, params) {
+    host.log("[acp] x/product.resume");
+    const orchestrator = ensureProductOrchestrator.call(host);
+    const productId = params.productId;
+    await orchestrator.resume(productId, host.getActiveProjectRoot());
+    return { ok: true };
+}
+export async function handleAcpProductStatus(host, params) {
+    host.log("[acp] x/product.status");
+    const productId = params.productId;
+    if (!host.productOrchestrator) {
+        return productId ? null : [];
+    }
+    if (!productId) {
+        return host.productOrchestrator.list(host.getActiveProjectRoot());
+    }
+    const status = host.productOrchestrator.getStatus(productId);
+    if (!status)
+        throw new Error(`Product session ${productId} not found`);
+    return status;
+}
+export async function handleAcpProductPause(host, params) {
+    host.log("[acp] x/product.pause");
+    const orchestrator = ensureProductOrchestrator.call(host);
+    const productId = params.productId;
+    await orchestrator.pause(productId);
+    return { ok: true };
+}
+export async function handleAcpProductCancel(host, params) {
+    host.log("[acp] x/product.cancel");
+    const orchestrator = ensureProductOrchestrator.call(host);
+    const productId = params.productId;
+    await orchestrator.delete(productId);
+    // R2 终态回写:取消 → 容器项目 planStatus="cancelled"(比照 solo.cancel→onTerminal),使 历史方案
+    // 正确且 recovery 不会把死掉的 run 复原成空白 running 视图。delete() 同步移除 session,完成回调不会
+    // 再触发,且 helper guard 仅迁移 "running" → 不会与并发完成互相覆盖。
+    writeProductTerminalPlanStatus(host, productId, "cancelled");
+    return { ok: true };
+}
+export async function handleAcpProductRollback(host, params) {
+    host.log("[acp] x/product.rollback");
+    const orchestrator = ensureProductOrchestrator.call(host);
+    const productId = params.productId;
+    const checkpointId = params.checkpointId ?? "latest";
+    await orchestrator.rollback(productId, checkpointId);
+    return { ok: true };
+}
+export async function handleAcpProductSubscribe(host, params) {
+    host.log("[acp] x/product.subscribe");
+    const productId = params.productId;
+    return { ok: true, productId };
+}

package/dist/cli/acp-extended-handlers.product-confirm.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/acp-extended-handlers.product-confirm.test.js

@@ -0,0 +1,56 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+const { fakeOrchestrator, fakePlanner } = vi.hoisted(() => ({
+    fakeOrchestrator: { create: vi.fn() },
+    fakePlanner: {
+        confirm: vi.fn(),
+        getSession: vi.fn(),
+        markExecuting: vi.fn(),
+    },
+}));
+vi.mock("./handlers/product-handler.js", () => ({
+    ensureProductOrchestrator: () => fakeOrchestrator,
+    ensureProductPlanner: () => fakePlanner,
+    productProjectMap: new Map(),
+    writeProductTerminalPlanStatus: vi.fn(),
+}));
+import { handleAcpProductConfirm } from "./acp-extended-handlers.js";
+function fakeHost(overrides = {}) {
+    return {
+        log: () => { },
+        sendNotification: vi.fn(),
+        getActiveProjectRoot: () => "X:/active",
+        ...overrides,
+    };
+}
+describe("handleAcpProductConfirm", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        fakePlanner.confirm.mockResolvedValue({ productId: "product-plan", ok: true });
+        fakePlanner.getSession.mockReturnValue({
+            productId: "product-plan",
+            goal: "build the thing",
+            cwd: "X:/repo",
+            plan: { name: "Planned Product" },
+        });
+        fakeOrchestrator.create.mockResolvedValue("product-plan");
+    });
+    it("starts execution with the planning productId so status/message/resume keep one run identity", async () => {
+        const params = {
+            productId: "product-plan",
+            instances: [{ name: "builder", agentId: "qlogicagent", role: "build" }],
+            tasks: [{ taskId: "t1", assignee: "builder", prompt: "do it" }],
+            budget: { maxTotalTokens: 1000 },
+        };
+        const result = await handleAcpProductConfirm(fakeHost(), params);
+        expect(result).toEqual({ productId: "product-plan", ok: true });
+        expect(fakeOrchestrator.create).toHaveBeenCalledWith(expect.objectContaining({
+            productId: "product-plan",
+            name: "Planned Product",
+            cwd: "X:/repo",
+            instances: params.instances,
+            tasks: params.tasks,
+            budget: params.budget,
+        }));
+        expect(fakePlanner.markExecuting).toHaveBeenCalledWith("product-plan");
+    });
+});

package/dist/cli/acp-extended-handlers.product-project.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/acp-extended-handlers.product-project.test.js

@@ -0,0 +1,66 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+// R2 容器优先:x/product.create(handleAcpProductCreate)绑定前端已建/绑的 type:"product" 容器项目,
+// 与 handleAcpSoloStart 对齐。Mock orchestrator(免真跑)+ projectStore(断言 updateProject/不 create)。
+const { fakeOrchestrator, productProjectMap, writeProductTerminalPlanStatus, projectStoreMock } = vi.hoisted(() => ({
+    fakeOrchestrator: { create: vi.fn(), delete: vi.fn() },
+    productProjectMap: new Map(),
+    writeProductTerminalPlanStatus: vi.fn(),
+    projectStoreMock: {
+        getProjectById: vi.fn(),
+        getActiveProject: vi.fn(),
+        createProject: vi.fn(),
+        updateProject: vi.fn(),
+    },
+}));
+vi.mock("./handlers/product-handler.js", () => ({
+    ensureProductOrchestrator: () => fakeOrchestrator,
+    ensureProductPlanner: () => ({}),
+    productProjectMap,
+    writeProductTerminalPlanStatus,
+}));
+vi.mock("../runtime/infra/project-store.js", () => projectStoreMock);
+import { handleAcpProductCreate, handleAcpProductCancel } from "./acp-extended-handlers.js";
+function fakeHost(overrides = {}) {
+    return {
+        log: () => { },
+        sendNotification: vi.fn(),
+        getActiveProjectRoot: () => "X:/active",
+        ...overrides,
+    };
+}
+describe("handleAcpProductCreate — 容器优先(绑定 type:product 容器,进历史方案)", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        productProjectMap.clear();
+        fakeOrchestrator.create.mockResolvedValue("prod-xyz");
+    });
+    it("绑定已存在 product 容器:updateProject(running) + productProjectMap,不 createProject", async () => {
+        projectStoreMock.getProjectById.mockReturnValue({ id: "proj-prod", type: "product", workspaceDir: "X:/w" });
+        await handleAcpProductCreate(fakeHost(), {
+            instances: [{ agentId: "qlogicagent" }],
+            tasks: [],
+            projectId: "proj-prod",
+        });
+        expect(projectStoreMock.createProject).not.toHaveBeenCalled();
+        expect(projectStoreMock.updateProject).toHaveBeenCalledWith("proj-prod", expect.objectContaining({ leaderSessionId: "prod-xyz", planStatus: "running", planAgents: ["qlogicagent"] }));
+        expect(productProjectMap.get("prod-xyz")).toBe("proj-prod");
+    });
+    it("缺少有效 projectId:不创建也不更新项目", async () => {
+        projectStoreMock.getProjectById.mockReturnValue(undefined);
+        projectStoreMock.getActiveProject.mockReturnValue(undefined);
+        await handleAcpProductCreate(fakeHost(), { instances: [{ agentId: "a" }], tasks: [] });
+        expect(projectStoreMock.createProject).not.toHaveBeenCalled();
+        expect(projectStoreMock.updateProject).not.toHaveBeenCalled();
+    });
+});
+describe("handleAcpProductCancel — 终态回写(取消→planStatus=cancelled)", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        productProjectMap.clear();
+    });
+    it("orchestrator.delete 后回写 cancelled(比照 solo.cancel)", async () => {
+        await handleAcpProductCancel(fakeHost(), { productId: "prod-1" });
+        expect(fakeOrchestrator.delete).toHaveBeenCalledWith("prod-1");
+        expect(writeProductTerminalPlanStatus).toHaveBeenCalledWith(expect.anything(), "prod-1", "cancelled");
+    });
+});

package/dist/cli/acp-extended-handlers.solo-project.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/acp-extended-handlers.solo-project.test.js

@@ -0,0 +1,51 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+// R2 容器优先:solo.start 不再影子创建项目,而是绑定前端已建/绑的容器项目。
+// Mock 掉 evaluator(避免真 spawn)+ projectStore(断言 createProject 不被调)。
+// vi.hoisted:让 mock 句柄在被提升的 vi.mock 工厂里可用(否则 TDZ)。
+const { fakeEvaluator, soloProjectMap, projectStoreMock } = vi.hoisted(() => ({
+    fakeEvaluator: { start: vi.fn(), getStatus: vi.fn(() => ({ soloId: "solo-xyz" })) },
+    soloProjectMap: new Map(),
+    projectStoreMock: {
+        getProjectById: vi.fn(),
+        getActiveProject: vi.fn(),
+        createProject: vi.fn(),
+        updateProject: vi.fn(),
+    },
+}));
+vi.mock("./handlers/solo-handler.js", () => ({
+    ensureSoloEvaluator: vi.fn(() => fakeEvaluator),
+    soloProjectMap,
+}));
+vi.mock("../runtime/infra/project-store.js", () => projectStoreMock);
+import { handleAcpSoloStart } from "./acp-extended-handlers.js";
+function fakeHost(overrides = {}) {
+    return {
+        log: () => { },
+        sendNotification: vi.fn(),
+        getActiveProjectRoot: () => "X:/active",
+        ...overrides,
+    };
+}
+describe("handleAcpSoloStart — 容器优先(绑定已存在项目,不影子创建)", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        soloProjectMap.clear();
+        fakeEvaluator.start.mockResolvedValue("solo-xyz");
+        fakeEvaluator.getStatus.mockReturnValue({ soloId: "solo-xyz" });
+    });
+    it("绑定已存在 projectId 容器:不调 createProject,只 updateProject + 映射 soloId", async () => {
+        const existing = { id: "proj-1", name: "p", workspaceDir: "X:/work", type: "solo" };
+        projectStoreMock.getProjectById.mockReturnValue(existing);
+        await handleAcpSoloStart(fakeHost(), { task: "t", agents: ["qlogicagent", "qlogicagent"], projectId: "proj-1" });
+        expect(projectStoreMock.createProject).not.toHaveBeenCalled();
+        expect(projectStoreMock.updateProject).toHaveBeenCalledWith("proj-1", expect.objectContaining({ leaderSessionId: "solo-xyz", planStatus: "running" }));
+        expect(soloProjectMap.get("solo-xyz")).toBe("proj-1");
+    });
+    it("projectId 缺失/无效:不创建也不更新项目(容器优先要求前端先建/绑)", async () => {
+        projectStoreMock.getProjectById.mockReturnValue(undefined);
+        projectStoreMock.getActiveProject.mockReturnValue(undefined);
+        await handleAcpSoloStart(fakeHost(), { task: "t", agents: ["a", "b"] });
+        expect(projectStoreMock.createProject).not.toHaveBeenCalled();
+        expect(projectStoreMock.updateProject).not.toHaveBeenCalled();
+    });
+});

package/dist/cli/acp-extended-handlers.specchat.test.d.ts

@@ -0,0 +1 @@
+export {};