feat(execution): a round's store and board channel are scoped by run

.gitignore

@@ -10,6 +10,8 @@ coverage/
 .mcp.json
 /.benchmarks/
 /.playwright-cli/
+# Scratch and experiment output for a session; never a home for a necessary file (AGENTS.md).
+/.temp/
 graph.html
 /output/
 /design/

.pi/extensions/nmg/index.ts

@@ -27,7 +27,6 @@
   type DaemonConnection,
 } from "../../../src/cli/daemon-client.ts";
 import { resolveNmgDataDir } from "../../../src/cli/data-path.ts";
-import { describeStart, shortRound, startRound, type OooRoundAction } from "./ooo-round.ts";
 import {
   archiveOrStage,
   archiveNodeName,
@@ -264,171 +263,171 @@
     }
   });
 
   pi.on("before_agent_start", async (event, ctx) => {
     const sessionId = ctx.sessionManager.getSessionId();
     const isNewUserTurn = recallFlow.beginTurn(
       sessionId,
       piUserTurnKey(ctx.sessionManager, event.prompt),
     );
     await beginDisclosureTurn(sessionId, isNewUserTurn);
     const completionNudge = popCompletionNudge(event.prompt);
     // Pi re-enters before_agent_start after tool results. A completed graph may
     // already exist at that point, but it must be reviewed on the next user
     // turn, not consumed by an internal tool loop from the same prompt.
     const pendingFeedback = isNewUserTurn ? controllerShadow.pendingFeedback(sessionId) : null;
     if (pendingFeedback) await controllerShadow.feedbackNudgeShown(sessionId, pendingFeedback);
     const feedbackNudge = pendingFeedback
       ? renderDisclosure(nmgPrompts.shadow_feedback_nudge, {
           active_graph_id: pendingFeedback.activeGraphId,
           semantic_task_id: pendingFeedback.semanticTaskId,
         })
       : "";
     const pendingClaimOutcome = isNewUserTurn
       ? controllerShadow.pendingClaimOutcome(sessionId)
       : null;
     if (pendingClaimOutcome) {
       await controllerShadow.claimOutcomeNudgeShown(sessionId, pendingClaimOutcome);
     }
     const claimOutcomeNudge = pendingClaimOutcome
       ? renderDisclosure(nmgPrompts.shadow_claim_outcome_nudge, {
           active_graph_id: pendingClaimOutcome.activeGraphId,
           semantic_task_id: pendingClaimOutcome.semanticTaskId,
           memory_ids: pendingClaimOutcome.memoryIds.join(","),
         })
       : "";
     const nudge = [completionNudge, feedbackNudge, claimOutcomeNudge].filter(Boolean).join("\n");
     let reasoningCheckpoint = "";
     if (labToolsEnabled) {
       try {
         const status = (await invokeDaemon(await connection(), "lab", {
           action: "status",
           capability: "reasoning_workspace",
           sessionId,
         })) as { activation?: unknown };
         if (status.activation) {
           const consumed = (await invokeDaemon(await connection(), "lab", {
             action: "invoke",
             capability: "reasoning_workspace",
             sessionId,
             operation: "consume_checkpoint",
             input: { maxNodes: 24, maxChars: 6_000 },
           })) as { output?: { text?: string } | null };
           reasoningCheckpoint = consumed.output?.text ?? "";
         }
       } catch (error) {
         reasoningCheckpoint = `Reasoning workspace unavailable: ${message(error)}`;
       }
     }
     let runtimeAgContext = "";
     try {
       const result = (await invoke("sessionActiveGraph", {
         action: "snapshot",
         sessionId,
       })) as {
         snapshot?:
           import("../../../src/core/session-active-graph.ts").SessionActiveGraphSnapshot | null;
       };
       runtimeAgContext = renderSessionActiveGraphSurface(result.snapshot ?? null);
     } catch {
       // Search and ordinary Pi operation continue without optional working state.
     }
     const runtimeContext = [runtimeAgContext, reasoningCheckpoint].filter(Boolean).join("\n");
     const recallRequest = taskWindow.prepare(sessionId, event.prompt);
     const dynamicContext = composeNmgContextMessage("", "", nudge, runtimeContext);
     if (!recallRequest) {
       return {
         systemPrompt: composeNmgSystemPrompt(event.systemPrompt),
         ...(dynamicContext
           ? {
               message: {
                 customType: "nmg-context",
                 content: dynamicContext,
                 display: true,
                 details: { count: 0 },
               },
             }
           : {}),
       };
     }
     try {
       let context = (await invoke("search", {
         query: recallRequest.query,
         projectDir: projectDirectory(),
         sessionId,
         maxTier: Math.min(configuredAutoRecallTier(), recallRequest.maxTier) as MemoryTier,
         limit: Math.min(configuredAutoRecallLimit(), recallRequest.limit),
         initialEvidenceTarget: configuredInitialTarget(),
         strongHitTopGap: configuredStrongHitTopGap(),
         strongHitInitialTarget: configuredStrongHitInitialTarget(),
         secondPass: qpp2Mode === "active",
         graphHops: Math.min(1, recallRequest.graphHops),
         tieredDisclosure: true,
         // Tell the daemon this is an automatic recall decision: it stages the
         // injected graph for online learning (explicit nmg_search stays unstaged).
         autoRecall: true,
       })) as MemoryContext;
       if (controllerRerankMode === "active") {
         context = await controllerShadow.rerank(context);
       }
       const fullContext = context;
       if (qpp2Mode === "active") {
         context = await applyLearnedFold(context, controllerShadow, qpp2RetainedMass, false);
       }
       const recalled = await formatDisclosedContext(sessionId, context, "header");
       await controllerShadow.retrieval(fullContext, sessionId, "automatic", recalled);
       // Automatic recall is still a retrieval trace. Keep it in the per-turn
       // attribution window so agent_end can distinguish surfaced evidence from
       // candidates that were merely injected.
       agentAttributionFlow.note(sessionId, fullContext);
       const recordCount = (recalled.match(/memory=/g) ?? []).length;
       const searchNudge = formatSearchRecommendation(context, recommendationMode);
       const recallContext = composeNmgContextMessage(
         recalled,
         "",
         [
           nudge,
           searchNudge,
           recordCount > 0 ? recallFeedbackAffordance(fullContext.activeGraph?.id) : "",
         ]
           .filter(Boolean)
           .join("\n"),
         runtimeContext,
       );
       return {
         systemPrompt: composeNmgSystemPrompt(event.systemPrompt),
         ...(recallContext
           ? {
               message: {
                 customType: "nmg-context",
                 content: recallContext,
                 display: true,
                 details: { count: recordCount },
               },
             }
           : {}),
       };
     } catch (error) {
       const errorContext = composeNmgContextMessage(
         "",
         `NMG unavailable: ${message(error)}`,
         nudge,
         runtimeContext,
       );
       return {
         systemPrompt: composeNmgSystemPrompt(event.systemPrompt),
         ...(errorContext
           ? {
               message: {
                 customType: "nmg-context",
                 content: errorContext,
                 display: true,
                 details: { count: 0 },
               },
             }
           : {}),
       };
     }
   });
 
   // TUI 折叠开关：nmg-context 默认折叠为一个 [nmg-context] chip，避免每轮刷屏。
   // /nmg-recall 切换展开（走 pi 默认渲染：label + 全文）。状态只影响后续渲染
@@ -449,210 +448,210 @@
   // NMG 总二级/三级菜单。早期只有独立的 /nmg-recall 命令；现在统一收编到
   // /nmg 下，保留 /nmg-recall 作为别名。状态只影响后续渲染与重开会话后的
   // 历史恢复；已渲染的历史消息不重绘（pi 无公开 force-rerender）。
   const nmgMenuHandler = async (args: string, ctx: ExtensionCommandContext): Promise<void> => {
     const parts = args.trim().split(/\s+/).filter(Boolean);
     const [sub, ...rest] = parts;
     const restText = rest.join(" ");
     switch (sub) {
       case "recall": {
         recallCollapsed = !recallCollapsed;
         ctx.ui.notify(
           recallCollapsed
             ? "nmg-context 已折叠（只显示 [nmg-context] chip）"
             : "nmg-context 已展开（显示召回全文）",
           "info",
         );
         return;
       }
       case "wake": {
         const current = readWakeConfig();
         const [wcmd, wvalRaw] = restText.split(/\s+/);
         const wval = Number(wvalRaw);
         switch (wcmd) {
           case "on":
             writeWakeConfig({ ...current, enabled: true });
             ctx.ui.notify("黑板唤醒已开启（世界频道+活跃频道有新 open 条目会唤醒）", "info");
             return;
           case "off":
             writeWakeConfig({ ...current, enabled: false });
             ctx.ui.notify("黑板唤醒已关闭", "info");
             return;
           case "status": {
             const budgetText = current.budget === 0 ? "不限制" : `${current.budget}/天`;
             const cooldownText =
               current.cooldownMs === 0 ? "无" : `${Math.round(current.cooldownMs / 60_000)} 分`;
             ctx.ui.notify(
               `黑板唤醒：${current.enabled ? "开" : "关"} · 预算 ${budgetText} · 冷却 ${cooldownText} · 轮询 ${Math.round(current.intervalMs / 1_000)} 秒 · 世界广播 ${current.worldBroadcast ? "开" : "关"}`,
               "info",
             );
             return;
           }
           case "budget": {
             if (!Number.isFinite(wval)) {
               ctx.ui.notify("用法：/nmg wake budget N（0=不限制）", "warning");
               return;
             }
             const budget = Math.max(0, Math.min(100, Math.round(wval)));
             writeWakeConfig({ ...current, budget });
             ctx.ui.notify(`黑板唤醒预算已设为 ${budget === 0 ? "不限制" : `${budget}/天`}`, "info");
             return;
           }
           case "cooldown": {
             if (!Number.isFinite(wval)) {
               ctx.ui.notify("用法：/nmg wake cooldown M（0=无冷却）", "warning");
               return;
             }
             const cooldownMs = wval === 0 ? 0 : Math.max(30_000, Math.round(wval * 60_000));
             writeWakeConfig({ ...current, cooldownMs });
             ctx.ui.notify(
               `黑板唤醒冷却已设为 ${cooldownMs === 0 ? "无" : `${Math.round(cooldownMs / 60_000)} 分钟`}`,
               "info",
             );
             return;
           }
           case "interval": {
             if (!Number.isFinite(wval)) {
               ctx.ui.notify("用法：/nmg wake interval S（秒，最小 5）", "warning");
               return;
             }
             const intervalMs = Math.max(5_000, Math.round(wval * 1_000));
             writeWakeConfig({ ...current, intervalMs });
             ctx.ui.notify(`黑板唤醒轮询已设为 ${Math.round(intervalMs / 1_000)} 秒`, "info");
             return;
           }
           case "world": {
             // 无参切换；0 关、1 开。
             const world =
               wvalRaw === "0" ? false : wvalRaw === "1" ? true : !current.worldBroadcast;
             writeWakeConfig({ ...current, worldBroadcast: world });
             ctx.ui.notify(
               world
                 ? "已开启世界频道协作广播：协作类新条目会同时发到世界频道拉其他 agent"
                 : "已关闭世界频道协作广播",
               "info",
             );
             return;
           }
           default: {
             const enabled = !current.enabled;
             writeWakeConfig({ ...current, enabled });
             ctx.ui.notify(enabled ? "黑板唤醒已开启" : "黑板唤醒已关闭", "info");
           }
         }
         return;
       }
       default: {
         // 无参数 → 交互式选择菜单（可上下键选，不用手敲）；未知子命令 → 总览提示。
         if (parts.length === 0) {
           await nmgInteractiveMenu(ctx);
           return;
         }
         const wake = readWakeConfig();
         const budgetText = wake.budget === 0 ? "不限制" : `${wake.budget}/天`;
         const cooldownText =
           wake.cooldownMs === 0 ? "无" : `${Math.round(wake.cooldownMs / 60_000)} 分`;
         ctx.ui.notify(
           `NMG 菜单：/nmg recall（召回折叠 ${recallCollapsed ? "开" : "关"}） · /nmg wake on|off|status|budget N|cooldown M|interval S（唤醒 ${wake.enabled ? "开" : "关"}，预算 ${budgetText}，冷却 ${cooldownText}，轮询 ${Math.round(wake.intervalMs / 1_000)} 秒）`,
           "info",
         );
       }
     }
   };
   // 交互式选择菜单：/nmg（无参数）弹出可上下键选的列表，避免手敲。带参数的
   // 形式（/nmg recall、/nmg wake on 等）仍保留，供脚本/快捷路径直接调用。
   const nmgInteractiveMenu = async (ctx: ExtensionCommandContext): Promise<void> => {
     if (!ctx.hasUI || typeof ctx.ui.select !== "function") {
       ctx.ui.notify(
         "当前模式不支持交互菜单，可用：/nmg recall、/nmg wake on|off|status|budget N|cooldown M|interval S",
         "warning",
       );
       return;
     }
     const choice = await ctx.ui.select(
       "NMG 控制台",
       nmgMenuOptions(recallCollapsed, readWakeConfig()),
     );
     if (!choice) return; // 用户取消
     if (choice.startsWith("召回")) {
       await nmgMenuHandler("recall", ctx);
       return;
     }
     if (choice.startsWith("唤醒：开启/关闭")) {
       const onOff = await ctx.ui.select("黑板唤醒", ["开启", "关闭"]);
       if (!onOff) return;
       const current = readWakeConfig();
       writeWakeConfig({ ...current, enabled: onOff === "开启" });
       ctx.ui.notify(onOff === "开启" ? "黑板唤醒已开启" : "黑板唤醒已关闭", "info");
       return;
     }
     if (choice.startsWith("唤醒：世界广播")) {
       const onOff = await ctx.ui.select("世界频道协作广播", ["开启", "关闭"]);
       if (!onOff) return;
       const current = readWakeConfig();
       writeWakeConfig({ ...current, worldBroadcast: onOff === "开启" });
       ctx.ui.notify(
         onOff === "开启"
           ? "已开启世界频道协作广播：协作类新条目会同时发到世界频道拉其他 agent"
           : "已关闭世界频道协作广播",
         "info",
       );
       return;
     }
     if (choice.startsWith("唤醒：参数设置")) {
       // 挡位选择（select 预设值，避免随意输入溢出/无效）；自由数字只走命令形式
       // （/nmg wake budget N 等，已有 clamp）。
       const param = await ctx.ui.select("唤醒参数", ["每日上限", "冷却", "轮询"]);
       if (!param) return;
       const current = readWakeConfig();
       if (param === "每日上限") {
         const option = await ctx.ui.select("每日唤醒上限", ["不限制", "3/天", "8/天", "15/天"]);
         if (!option) return;
         const budget = option === "不限制" ? 0 : Number(option.split("/")[0]);
         writeWakeConfig({ ...current, budget });
         ctx.ui.notify(`黑板唤醒预算已设为 ${budget === 0 ? "不限制" : `${budget}/天`}`, "info");
       } else if (param === "冷却") {
         const option = await ctx.ui.select("冷却", ["无", "10 分钟", "30 分钟", "1 小时"]);
         if (!option) return;
         const cooldownMs =
           option === "无"
             ? 0
             : option === "10 分钟"
               ? 600_000
               : option === "30 分钟"
                 ? 1_800_000
                 : 3_600_000;
         writeWakeConfig({ ...current, cooldownMs });
         ctx.ui.notify(
           `黑板唤醒冷却已设为 ${cooldownMs === 0 ? "无" : `${Math.round(cooldownMs / 60_000)} 分钟`}`,
           "info",
         );
       } else if (param === "轮询") {
         const option = await ctx.ui.select("轮询", ["5 秒", "30 秒", "60 秒", "5 分钟"]);
         if (!option) return;
         const intervalMs =
           option === "5 秒"
             ? 5_000
             : option === "30 秒"
               ? 30_000
               : option === "60 秒"
                 ? 60_000
                 : 300_000;
         writeWakeConfig({ ...current, intervalMs });
         ctx.ui.notify(`黑板唤醒轮询已设为 ${Math.round(intervalMs / 1_000)} 秒`, "info");
       }
       return;
     }
     {
       const wake = readWakeConfig();
       const budgetText = wake.budget === 0 ? "不限制" : `${wake.budget}/天`;
       const cooldownText =
         wake.cooldownMs === 0 ? "无" : `${Math.round(wake.cooldownMs / 60_000)} 分`;
       ctx.ui.notify(
         `NMG：召回折叠 ${recallCollapsed ? "开" : "关"} · 唤醒 ${wake.enabled ? "开" : "关"}（预算 ${budgetText}，冷却 ${cooldownText}，轮询 ${Math.round(wake.intervalMs / 1_000)} 秒）`,
         "info",
       );
     }
   };
   // 菜单项带当前状态，进子菜单前就看得见：召回折叠/展开、唤醒开/关、参数当前值。
   // 预算/冷却支持 0（不限制/无），轮询保持最小 5 秒（0 无意义）。
   const nmgMenuOptions = (
@@ -1053,51 +1052,6 @@
     },
   });
 
-  // The restricted out-of-order round, registered by default like the other NMG tools: a
-  // consumer that has to be switched on is not one. The cost boundary is per call: `live` spends
-  // tokens, while the default replays recorded answers and spends nothing.
-  pi.registerTool({
-    name: "ooo_round",
-    label: "Restricted OoO round",
-    description:
-      "Drive one restricted out-of-order round. " +
-      "action=submit starts the round detached from a spec JSON and returns immediately (a live " +
-      "round takes minutes and spends tokens); action=status reads the round's own run directory " +
-      "from another process; action=cancel records an operator decision that survives a restart. " +
-      "The coordinator, not this tool, decides acceptance.",
-    parameters: Type.Object({
-      action: Type.Union([Type.Literal("submit"), Type.Literal("status"), Type.Literal("cancel")]),
-      specPath: Type.Optional(
-        Type.String({ description: "submit only: path to the round spec JSON" }),
-      ),
-      runDir: Type.Optional(
-        Type.String({ description: "the round's own directory; required for every action" }),
-      ),
-      reason: Type.Optional(Type.String({ description: "cancel only: why the round was stopped" })),
-      live: Type.Optional(
-        Type.Boolean({
-          description:
-            "submit only: use real model calls (costs tokens); absent means recorded answers",
-        }),
-      ),
-    }),
-    async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
-      const request = {
-        action: params.action as OooRoundAction,
-        specPath: params.specPath,
-        runDir: params.runDir,
-        reason: params.reason,
-        live: params.live,
-      };
-      if (request.action === "submit") {
-        const started = startRound(projectDirectory(), request);
-        return toolResult(started, describeStart(request, started));
-      }
-      const reply = await shortRound(projectDirectory(), request);
-      return toolResult(reply, `round ${reply.action}: exit ${reply.code}\n${reply.output}`);
-    },
-  });
-
   pi.registerTool({
     name: "nmg_remember",
     label: "Remember with NMG",