@evandu/super-pi 0.1.147 → 0.1.149

package/agents/super-pi-task/core.ts

@@ -110,7 +110,7 @@ description: 用脚本清洗、转换、统计 Excel/CSV 数据
 mode: primary
 ---
 （正文从这里开始，写它的职责和工作方式。）保存后下一条消息即可使用；修改已有的自定义 Agent 就是编辑同一个目录里对应的 .md 文件。
-- 用户要多个 agent 分工协作：单个子任务用 task 工具委托，有先后依赖的流程用 workflow 工具编排；同一流程要按明确结论行反复执行时用 loop 节点，要对 primary 自己列出的一批同构对象逐项执行时用 foreach 节点，两者可以任意嵌套。需要拆分多条独立并行工作线、多会话持续跟踪管理、或用户要求创建多个会话并行时，用 session_spawn 创建兄弟会话，并用 session_status / session_dispatch / session_stop 监督管理。`;
+- 用户要多个 agent 分工协作：单个子任务用 task 工具委托，有先后依赖的流程用 workflow 工具编排；同一流程要按明确结论行反复执行时用 loop 节点，要对 primary 自己列出的一批同构对象逐项执行时用 foreach 节点，两者可以任意嵌套。需要拆分多条独立并行工作线、多会话持续跟踪管理、或用户要求创建多个会话并行时，用 session_spawn 创建兄弟会话，并用 session_status / session_dispatch / session_stop 监督管理。父会话可在 session_spawn 时用 watchdogTimeoutSeconds 声明「多久没收到汇报就提醒我一次」；被创建出来的子会话用 session_report 主动向自己的父会话汇报（status 用 in_progress 表示进行中、completed 表示完成、failed 表示失败）。`;
 
 /** The parameters, OpenCode's `tool/todo.ts:6-8` minus its schema wrapper. */
 export type TodoParams = { todos: TodoEntry[] };
@@ -1140,6 +1140,7 @@ export const SESSION_SPAWN_TOOL_NAME = "session_spawn";
 export const SESSION_STATUS_TOOL_NAME = "session_status";
 export const SESSION_DISPATCH_TOOL_NAME = "session_dispatch";
 export const SESSION_STOP_TOOL_NAME = "session_stop";
+export const SESSION_REPORT_TOOL_NAME = "session_report";
 
 /** Model-facing description for session_spawn. */
 export const SESSION_SPAWN_DESCRIPTION = `Create a new sibling conversation in the current workspace and immediately dispatch its initial task.
@@ -1164,7 +1165,8 @@ Usage notes:
 3. Use session_status with the returned conversationId to check progress, or session_dispatch to send further messages.
 4. The new session reports completion to its DIRECT parent automatically. 'parentConversationId' optionally selects that parent; by default it is the calling session.
 5. The new session always belongs to the calling session's workspace. Pass 'cwd' as a workspace-relative subdirectory (for example, 'packages/a') when it should work below the workspace root; absolute paths and traversal are rejected.
-6. Optionally pass 'model' to choose which model the NEW session runs on: {"provider":"...","modelId":"..."} - the same "provider/modelId" pair the model picker shows, and BOTH halves are required. Leave 'model' out and the new session starts on the workspace default model.`;
+6. Optionally pass 'model' to choose which model the NEW session runs on: {"provider":"...","modelId":"..."} - the same "provider/modelId" pair the model picker shows, and BOTH halves are required. Leave 'model' out and the new session starts on the workspace default model.
+7. Optionally pass 'watchdogTimeoutSeconds' to declare how long YOU are willing to wait for a report before you want to be reminded: a positive number of seconds. If the new session stays silent that long, you receive a '[Watchdog 提醒]' message naming it. A report from the child (session_report) restarts the clock; the watchdog never stops the child. Leave it out to run without a watchdog.`;
 
 /** Model-facing description for session_status. */
 export const SESSION_STATUS_DESCRIPTION = `Inspect the progress, run state, and latest activity of sibling conversations created by the orchestrator.
@@ -1207,6 +1209,28 @@ Usage notes:
    - 'queued': only cancels pending queued messages; lets the currently running turn complete naturally.
 2. Use 'messageId' if you want to cancel or interrupt one specific queued message instead of all queued messages.`;
 
+/** Model-facing description for session_report. */
+export const SESSION_REPORT_DESCRIPTION = `Report progress from THIS session to the parent session that spawned it.
+
+WHEN TO USE THIS:
+- You are a spawned sibling session, and the parent is waiting to hear from you: a milestone is done, a roadblock appeared, or the task is finished.
+- The parent set a watchdog (session_spawn's 'watchdogTimeoutSeconds'): a report is what restarts that clock, and silence is what triggers the reminder.
+- The task is over and the parent needs the outcome NOW rather than after the automatic end-of-turn result.
+
+WHEN NOT TO USE THIS:
+- This session has no parent (the user opened it directly): there is nobody to report to, and the server refuses the call.
+- You want to ASK the parent something or send it new instructions: that is session_dispatch, and only the parent can send it. A report is one-way - the parent receives it as a message.
+
+Usage notes:
+1. 'content' is required: it is the text the parent receives. Write it for the parent - what is done, what is left, what you need.
+2. 'status' says what the report MEANS:
+   - 'in_progress' (default): an interim update. The task continues, and the parent's watchdog clock restarts.
+   - 'completed': the task is finished and this is your final word.
+   - 'failed': the task could not be finished, and this says why.
+3. A 'completed' or 'failed' report tells the server the work is over, so the parent is NOT also sent the automatic end-of-turn result. Send it once, at the end, with the final answer in 'content'.
+4. Reporting does NOT end your turn. If the task is not done, keep working afterwards - the parent is waiting on the work, not on the report.
+5. The report reaches your DIRECT parent only. A sibling, a cousin, and the user's own session are all out of reach, and the server refuses those.`;
+
 /** Compact summary returned for an orchestrated session. */
 export type OrchestratorSessionSummary = {
   conversationId: string;
@@ -1271,6 +1295,13 @@ export type SessionSpawnParams = {
   wait?: boolean;
   /** Optional subdirectory (relative to the resolved workspace root) the new session's cwd should be rooted in. */
   cwd?: string;
+  /**
+   * How long the PARENT is willing to wait for a report before it wants to be reminded, in seconds.
+   *
+   * The parent declares it once, at spawn time, and the watchdog never stops the child - it only
+   * tells the parent that the child has gone quiet. A report from the child restarts the clock.
+   */
+  watchdogTimeoutSeconds?: number;
 };
 
 export type SessionStatusParams = {
@@ -1291,6 +1322,18 @@ export type SessionStopParams = {
   messageId?: string;
 };
 
+/**
+ * What this session is allowed to tell its parent.
+ *
+ * `status` is the model's word for what the report MEANS, and the server turns it into two
+ * different things: an interim report restarts the watchdog clock, a terminal one cancels it and
+ * silences the automatic end-of-turn result. The three values are the server's own vocabulary.
+ */
+export type SessionReportParams = {
+  content: string;
+  status?: "in_progress" | "completed" | "failed";
+};
+
 /**
  * THE FORMAT THE MODEL IS TOLD TO USE. The client hands its model picker a single
  * "provider/modelId" string, so this is the shape the model already knows how to read.
@@ -1303,6 +1346,34 @@ const SPAWN_MODEL_MISSING_PROVIDER_REFUSAL = `session_spawn's \`model\` paramete
 
 const SPAWN_MODEL_MISSING_MODEL_ID_REFUSAL = `session_spawn's \`model\` parameter is missing \`modelId\`. It needs BOTH \`provider\` and \`modelId\` - ${SPAWN_MODEL_FORMAT}. Provide both, or leave \`model\` out entirely to use the workspace default model.`;
 
+/**
+ * The silence watchdog the parent declares, or the reason it cannot be used.
+ *
+ * A NUMBER OF SECONDS, AND NOTHING ELSE. The server clamps whatever arrives into the range it
+ * accepts, so a nonsense value would arrive as a real watchdog with a duration nobody chose - a
+ * parent that asked for "about five minutes" and got three seconds of tolerance would be reminded
+ * before the child had said anything. So a value that is not a positive number is refused HERE,
+ * where the model is told exactly what to write instead.
+ *
+ * An ABSENT value is not a case here: it means "no watchdog", which is what a spawn without one has
+ * always meant, and the body then carries no watchdog field at all.
+ */
+const SPAWN_WATCHDOG_REFUSAL = `session_spawn's \`watchdogTimeoutSeconds\` parameter must be a positive number of seconds - how long the parent is willing to wait for a report before it wants to be reminded. Provide a number such as 300, or leave the parameter out to run without a watchdog.`;
+
+function readSpawnWatchdog(raw: unknown): { seconds?: number; error?: string } {
+  if (raw === undefined || raw === null) return {};
+  // A NUMBER, OR A STRING THAT IS ONE. Anything else - a boolean, an object, an array - is not a
+  // duration, and `Number(true)` being 1 is exactly the kind of accident a duration must not have.
+  const value = typeof raw === "number"
+    ? raw
+    : (typeof raw === "string" && raw.trim() ? Number(raw) : Number.NaN);
+  if (!Number.isFinite(value) || value <= 0) return { error: SPAWN_WATCHDOG_REFUSAL };
+  // THE SERVER'S OWN FLOOR. A watchdog shorter than a second is not a watchdog, and the server
+  // clamps it up to one second - so the tool does the same, and a parent that asked for "half a
+  // second" gets a second rather than a watchdog that never fires.
+  return { seconds: Math.max(1, Math.floor(value)) };
+}
+
 /**
  * The model selection the model asked for, or the reason it cannot be used.
  *
@@ -1359,6 +1430,13 @@ export async function executeSessionSpawn(
   if (selection.error) {
     return text(selection.error, true);
   }
+  // THE SAME TREATMENT FOR THE WATCHDOG. A silence timeout that is not a number would reach the
+  // server as a duration nobody chose, and the server would clamp it into a real watchdog anyway -
+  // so the mistake is refused here, where the model can fix it in one call.
+  const watchdog = readSpawnWatchdog(params.watchdogTimeoutSeconds);
+  if (watchdog.error) {
+    return text(watchdog.error, true);
+  }
 
   const send = deps.fetch ?? (globalFetch as unknown as TaskFetch);
   try {
@@ -1381,6 +1459,9 @@ export async function executeSessionSpawn(
         thinkingLevel: params.thinkingLevel?.trim() || undefined,
         wait: Boolean(params.wait),
         cwd: params.cwd?.trim() || undefined,
+        // ONLY WHEN A DURATION WAS GIVEN. An absent watchdog leaves the field out entirely, and the
+        // child then runs unwatched - which is what a spawn without one has always meant.
+        ...(watchdog.seconds ? { watchdogTimeoutSeconds: watchdog.seconds } : {}),
         callerConversationId: config.conversationId || undefined,
         parentConversationId: params.parentConversationId?.trim() || config.conversationId || undefined,
         capability: config.capability,
@@ -1616,3 +1697,84 @@ export async function executeSessionStop(
     return text(`session_stop network error: ${error instanceof Error ? error.message : String(error)}`, true);
   }
 }
+
+/**
+ * Execute session_report: THIS session tells its direct parent what is going on.
+ *
+ * WHO CALLS IT. The child. The parent has no use for it - the parent's half of this conversation is
+ * `session_dispatch`, `session_status` and `session_stop`. The child has no other way to speak at
+ * all: without this tool, everything a child knows stays in the child's transcript until the turn
+ * ends, and a parent waiting on a long task has nothing to read in the meantime.
+ *
+ * WHY THE CALLER ID AND NOT A TARGET. The body carries THIS session's id and no target at all. The
+ * server reads the parent off the conversation's own tree edge, so the report can only ever reach
+ * the session that spawned this one: a sibling, a cousin, and the user's own session are out of
+ * reach by construction rather than by a rule that could be forgotten. The server owns that rule and
+ * refuses what does not belong to the tree.
+ *
+ * WHY A REPORT DOES NOT END THE TURN. The parent asked to hear from this child WHILE it worked; a
+ * report that ended the child's turn would turn every interim update into a completion. So the
+ * report is a message, and the child's turn continues.
+ */
+export async function executeSessionReport(
+  params: SessionReportParams,
+  config: OrchestratorToolConfig,
+  deps: { signal?: AbortSignal; fetch?: TaskFetch } = {},
+): Promise<TaskToolResult> {
+  const text = (body: string, isError?: boolean): TaskToolResult => ({
+    content: [{ type: "text", text: body }],
+    details: undefined,
+    ...(isError ? { isError: true } : {}),
+  });
+
+  if (!config.endpoint) {
+    return text("The session_report tool is not available in this session: SUPER_PI_ORCHESTRATOR_ENDPOINT is not set.", true);
+  }
+  if (!config.conversationId) {
+    return text("The session_report tool is not available in this session: SUPER_PI_TASK_CONVERSATION is not set.", true);
+  }
+  if (!params.content || !params.content.trim()) {
+    return text("session_report requires a non-empty `content` message.", true);
+  }
+  // THE STATUS IS THE MODEL'S OWN WORD, AND THE THREE VALUES ARE THE SERVER'S VOCABULARY. An
+  // unknown value would reach the server as an interim report - the least consequential of the
+  // three - so it is normalized here rather than travelling as something the server never saw.
+  const status = params.status === "completed" || params.status === "failed" ? params.status : "in_progress";
+
+  const send = deps.fetch ?? (globalFetch as unknown as TaskFetch);
+  try {
+    const response = await send(config.endpoint, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        ...(config.token ? { authorization: `Bearer ${config.token}` } : {}),
+      },
+      body: JSON.stringify({
+        action: "report",
+        content: params.content.trim(),
+        status,
+        // THE CALLER IS THIS SESSION. There is no target field: the parent is the server's to
+        // decide, and it decides from the tree edge.
+        callerConversationId: config.conversationId,
+        capability: config.capability,
+      }),
+      ...(deps.signal ? { signal: deps.signal } : {}),
+    });
+
+    const bodyText = await response.text();
+    let payload: { ok?: boolean; delivered?: boolean; parentConversationId?: string; error?: string };
+    try {
+      payload = JSON.parse(bodyText);
+    } catch {
+      return text(`The orchestrator endpoint returned HTTP ${response.status}: ${bodyText}`, true);
+    }
+
+    if (!response.ok || !payload.ok || !payload.delivered) {
+      return text(`Failed to report to the parent session: ${payload.error ?? `HTTP ${response.status}`}`, true);
+    }
+
+    return text(`Report delivered to parent session ${payload.parentConversationId ?? "(unknown)"}.`);
+  } catch (error) {
+    return text(`session_report network error: ${error instanceof Error ? error.message : String(error)}`, true);
+  }
+}

package/agents/super-pi-task/index.ts

@@ -41,19 +41,23 @@ import {
   SESSION_STATUS_TOOL_NAME,
   SESSION_DISPATCH_TOOL_NAME,
   SESSION_STOP_TOOL_NAME,
+  SESSION_REPORT_TOOL_NAME,
   SESSION_SPAWN_DESCRIPTION,
   SESSION_STATUS_DESCRIPTION,
   SESSION_DISPATCH_DESCRIPTION,
   SESSION_STOP_DESCRIPTION,
+  SESSION_REPORT_DESCRIPTION,
   executeSessionSpawn,
   executeSessionStatus,
   executeSessionDispatch,
   executeSessionStop,
+  executeSessionReport,
   readOrchestratorConfig,
   type SessionSpawnParams,
   type SessionStatusParams,
   type SessionDispatchParams,
   type SessionStopParams,
+  type SessionReportParams,
 } from "./core.ts";
 
 /**
@@ -471,6 +475,9 @@ const extension = (pi: ExtensionApi): void => {
     cwd: Type.Optional(Type.String({
       description: "Optional workspace-root-relative subdirectory (for example, packages/a). Absolute paths, '..' traversal, UNC paths, and escaping symlinks are rejected; omit it to use the workspace root.",
     })),
+    watchdogTimeoutSeconds: Type.Optional(Type.Number({
+      description: "How long YOU are willing to wait for a report from the new session before you want to be reminded, in seconds (for example 300 for five minutes). A report from the child restarts the clock; the watchdog never stops the child. Omit it to run without a watchdog.",
+    })),
   });
 
   const SessionStatusParameters = Type.Object({
@@ -513,6 +520,27 @@ const extension = (pi: ExtensionApi): void => {
     })),
   });
 
+  /**
+   * The `session_report` parameter schema.
+   *
+   * `content` is required, because a report with nothing in it is a report that says nothing - and
+   * the parent reads it as if it had been told something. `status` is a closed union of the three
+   * words the server understands, so a model cannot invent a fourth one that arrives as an
+   * unintended interim update.
+   */
+  const SessionReportParameters = Type.Object({
+    content: Type.String({
+      description: "The text the parent receives. Write it for the parent: what is done, what is left, what you need.",
+    }),
+    status: Type.Optional(Type.Union([
+      Type.Literal("in_progress", { description: "An interim update; the task continues and the parent's watchdog clock restarts (default)" }),
+      Type.Literal("completed", { description: "The task is finished and this is the final report" }),
+      Type.Literal("failed", { description: "The task could not be finished; say why" }),
+    ], {
+      description: "What this report means: 'in_progress' (default), 'completed', or 'failed'.",
+    })),
+  });
+
   if (orchestratorConfig.endpoint) {
     pi.registerTool({
       name: SESSION_SPAWN_TOOL_NAME,
@@ -553,6 +581,24 @@ const extension = (pi: ExtensionApi): void => {
       execute: async (_toolCallId, params, signal) =>
         await executeSessionStop(params as SessionStopParams, orchestratorConfig, { signal: signal ?? undefined }),
     });
+
+    /**
+     * `session_report`, registered AFTER the four tools that act ON OTHER SESSIONS.
+     *
+     * The order is the reading order, and this one is the odd one out: the other four are a
+     * PARENT's tools - they reach out and manage somebody else's session - while this one is the
+     * CHILD's own voice. A model reading the list top to bottom meets the manager's instruments
+     * first and the worker's mouth last, which is the order the relationship actually has.
+     */
+    pi.registerTool({
+      name: SESSION_REPORT_TOOL_NAME,
+      label: "Report to Parent",
+      description: SESSION_REPORT_DESCRIPTION,
+      promptSnippet: "report progress or a blocker to the parent session that spawned this one",
+      parameters: SessionReportParameters,
+      execute: async (_toolCallId, params, signal) =>
+        await executeSessionReport(params as SessionReportParams, orchestratorConfig, { signal: signal ?? undefined }),
+    });
   }
 };
 

package/dist/client/.super-pi-client-sources.json

@@ -35,5 +35,5 @@
     "src/client/types.ts": "7c06189b32890009d28a371a64d9f29161c14a349a5b399d51d1314d38fa27ac",
     "src/client/vite-env.d.ts": "65996936fbb042915f7b74a200fcdde7e410f32a669b1ab9597cfaa4b0faddb5"
   },
-  "recordedAt": "2026-11-01T06:41:55.741Z"
+  "recordedAt": "2026-11-01T14:53:57.934Z"
 }

package/dist/server/agents.d.ts

@@ -38,7 +38,7 @@ type Frontmatter = Record<string, unknown>;
  */
 export declare const PI_TOOL_NAMES: readonly ["read", "bash", "powershell", "edit", "write", "grep", "find", "ls", "codemode", "tool_search", "list_mcp_resources", "list_mcp_resource_templates", "read_mcp_resource"];
 /** Tools shipped by this package. Authors must be able to explicitly deny host extras. */
-export declare const SUPER_PI_TOOL_NAMES: readonly ["task", "todowrite", "workflow", "run_async", "scheduled_task", "question", "tool_register", "memory", "skill_manage", "session_search", "session_spawn", "session_status", "session_dispatch", "session_stop", "knowledge_search", "knowledge_import", "document_read", "document_write", "web_search", "web_fetch", "feishu_doc_read", "feishu_doc_write"];
+export declare const SUPER_PI_TOOL_NAMES: readonly ["task", "todowrite", "workflow", "run_async", "scheduled_task", "question", "tool_register", "memory", "skill_manage", "session_search", "session_spawn", "session_status", "session_dispatch", "session_stop", "session_report", "knowledge_search", "knowledge_import", "document_read", "document_write", "web_search", "web_fetch", "feishu_doc_read", "feishu_doc_write"];
 /**
  * Whether a name can be a real Pi tool. A name is real if it is one of `PI_TOOL_NAMES`, an MCP
  * server tool, or a PATTERN.

package/dist/server/agents.js

@@ -40,7 +40,7 @@ export const PI_TOOL_NAMES = [
 export const SUPER_PI_TOOL_NAMES = [
     "task", "todowrite", "workflow", "run_async", "scheduled_task", "question", "tool_register",
     "memory", "skill_manage", "session_search",
-    "session_spawn", "session_status", "session_dispatch", "session_stop",
+    "session_spawn", "session_status", "session_dispatch", "session_stop", "session_report",
     "knowledge_search", "knowledge_import",
     "document_read", "document_write", "web_search", "web_fetch", "feishu_doc_read", "feishu_doc_write",
 ];

package/dist/server/application/session-orchestrator-service.d.ts

@@ -110,16 +110,27 @@ export declare class SessionOrchestratorService {
      */
     private readonly lengthContinuations;
     /**
-     * THE CHILDREN THAT HAVE ALREADY REPORTED THEIR OWN RESULT TO THEIR PARENT.
+     * THE CHILDREN THAT HAVE ALREADY REPORTED THEIR OWN RESULT TO THEIR PARENT, AND WHEN.
      *
      * A child can report explicitly - the `report` action - and that report is the child's own
      * statement of what it did. When the child's turn then ends, the automatic completion report
      * would deliver the same thing a second time, so the automatic path steps aside for a child that
-     * is in this set.
+     * is in this map.
      *
      * The entry is added only by a TERMINAL report (`completed` / `failed`), because an interim
      * update is not the child's final word: the task is still running, and the parent will want to
      * hear how it ended.
+     *
+     * WHY THE MAP HOLDS A TIMESTAMP AND NOT A FLAG. A flag says "this child reported", and that is
+     * not the same question as "this child reported ABOUT THE TURN THAT JUST ENDED". A flag stays
+     * true for the rest of the child's life, so it silences every automatic report the child ever
+     * produces again: the parent gives the same child a second task, the child finishes, and the
+     * result is swallowed because of a report the parent received about the FIRST task. The parent
+     * waits for a result that was written and never arrives, and nothing in the transcript says why.
+     *
+     * The timestamp answers the real question: the report was made INSIDE this turn, so it speaks for
+     * this turn. A report made before the turn started speaks for an earlier one, and this turn's
+     * result is still its own.
      */
     private readonly reportedChildren;
     constructor(store: Store, conversationService: ConversationService, runService: RunService, ledger: SessionLedger, broadcaster?: EventBroadcaster | undefined, watchdog?: SessionWatchdog);

package/dist/server/application/session-orchestrator-service.js

@@ -39,18 +39,29 @@ export class SessionOrchestratorService {
      */
     lengthContinuations = new Map();
     /**
-     * THE CHILDREN THAT HAVE ALREADY REPORTED THEIR OWN RESULT TO THEIR PARENT.
+     * THE CHILDREN THAT HAVE ALREADY REPORTED THEIR OWN RESULT TO THEIR PARENT, AND WHEN.
      *
      * A child can report explicitly - the `report` action - and that report is the child's own
      * statement of what it did. When the child's turn then ends, the automatic completion report
      * would deliver the same thing a second time, so the automatic path steps aside for a child that
-     * is in this set.
+     * is in this map.
      *
      * The entry is added only by a TERMINAL report (`completed` / `failed`), because an interim
      * update is not the child's final word: the task is still running, and the parent will want to
      * hear how it ended.
+     *
+     * WHY THE MAP HOLDS A TIMESTAMP AND NOT A FLAG. A flag says "this child reported", and that is
+     * not the same question as "this child reported ABOUT THE TURN THAT JUST ENDED". A flag stays
+     * true for the rest of the child's life, so it silences every automatic report the child ever
+     * produces again: the parent gives the same child a second task, the child finishes, and the
+     * result is swallowed because of a report the parent received about the FIRST task. The parent
+     * waits for a result that was written and never arrives, and nothing in the transcript says why.
+     *
+     * The timestamp answers the real question: the report was made INSIDE this turn, so it speaks for
+     * this turn. A report made before the turn started speaks for an earlier one, and this turn's
+     * result is still its own.
      */
-    reportedChildren = new Set();
+    reportedChildren = new Map();
     constructor(store, conversationService, runService, ledger, broadcaster, watchdog) {
         this.store = store;
         this.conversationService = conversationService;
@@ -180,6 +191,11 @@ export class SessionOrchestratorService {
         // writes the words under the reader's own name - so the child's transcript showed an
         // instruction the reader never typed, wearing the reader's avatar, and a reader who looked at
         // the child session saw their own name on somebody else's order.
+        //
+        // THE TURN'S START IS RECORDED HERE, because the question "did this child already report THIS
+        // turn?" is answered by comparing the report's time against it. A report made inside the turn
+        // speaks for the turn; a report made before it speaks for an earlier one.
+        const turnStartedAt = Date.now();
         const runPromise = this.runService.enqueueAndRunAsAgent(conversationId, content);
         const completion = (async () => {
             let failure;
@@ -229,14 +245,23 @@ export class SessionOrchestratorService {
                 const result = await this.persistSessionResult(conversationId, failure);
                 if (result) {
                     const current = this.store.conversation(conversationId);
-                    // AN INTERRUPTED CHILD HAS NO RESULT TO REPORT. "stopped" means somebody pressed stop, and
-                    // the half-finished answer that was on screen is not a result anybody stated. The parent is
-                    // told nothing, which is right: the child can be asked again, and then it reports.
-                    const interrupted = current?.status === "stopped";
-                    // A CHILD THAT REPORTED ITSELF IS NOT REPORTED TWICE. The explicit report is the child's
-                    // own statement of what it did, so the automatic completion steps aside for it.
-                    const alreadyReported = this.reportedChildren.has(conversationId);
-                    if (!interrupted && !alreadyReported) {
+                    // THE REPORT GOES OUT ONLY WHEN THE CHILD'S TURN ENDED. The statuses that mean "the turn is
+                    // over" are `completed` and `failed`; `running` and `awaiting_background` mean work is still
+                    // in flight and its result is not final, and `stopped` means somebody pressed stop, so the
+                    // half-finished answer on screen is not a result anybody stated.
+                    //
+                    // This is what separates the two channels. The automatic report says "the task ended, here
+                    // is what it produced"; the explicit report says "the child is telling its parent something
+                    // now", and can be called at any point in the task's life.
+                    const turnEnded = current?.status === "completed" || current?.status === "failed";
+                    // A CHILD THAT REPORTED ITSELF IS NOT REPORTED TWICE - BUT ONLY FOR THE TURN IT REPORTED.
+                    // The explicit terminal report is the child's own statement of what it did, so the
+                    // automatic completion steps aside for it - when the report was made inside THIS turn.
+                    // A report from an earlier turn says nothing about this one's result, and silencing this
+                    // one because of that would swallow a result the parent is still waiting for.
+                    const reportedAt = this.reportedChildren.get(conversationId);
+                    const alreadyReported = reportedAt !== undefined && reportedAt >= turnStartedAt;
+                    if (turnEnded && !alreadyReported) {
                         await this.runService.enqueueSessionResult({
                             conversationId,
                             parentConversationId: current?.parentConversationId,
@@ -255,6 +280,16 @@ export class SessionOrchestratorService {
                 // turn an already-finished child turn into a second failure.
                 console.warn(`Super Pi: session result callback failed for ${conversationId}:`, error instanceof Error ? error.message : String(error));
             }
+            finally {
+                // THE RECORD IS SPENT BY THE TURN IT SPOKE FOR. Whatever it was about, that turn is over.
+                //
+                // A record left behind would be harmless - the timestamp comparison already keeps it from
+                // silencing a later turn - but it would keep saying "this child reported" to every future
+                // reader of this code, and the next thing that consults it would have to re-derive the
+                // timestamp rule. Dropping it here keeps one rule in one place: a report belongs to the
+                // turn that was running when it was made.
+                this.reportedChildren.delete(conversationId);
+            }
             if (failure !== undefined) {
                 console.warn(`Super Pi: dispatch failed for conversation ${conversationId}:`, failure instanceof Error ? failure.message : String(failure));
                 this.ledger.update(conversationId, { status: "failed" });
@@ -386,7 +421,10 @@ export class SessionOrchestratorService {
         // does not silence the automatic report: the child is still working, and the parent will want
         // to hear how the task ended.
         if (status === "completed" || status === "failed") {
-            this.reportedChildren.add(childConversationId);
+            // THE TIME OF THE REPORT IS THE PART THAT MATTERS. It is what tells the completion path
+            // whether this report spoke for the turn that is ending or for an earlier one, and it is
+            // stamped here - where the report is made - rather than where it is looked up later.
+            this.reportedChildren.set(childConversationId, Date.now());
             await this.watchdog.cancel(childConversationId);
         }
         else {

package/dist/server/runtime.js

@@ -24,7 +24,7 @@ import { LengthExceededError } from "./turn-failure.js";
 // paths recognise a delivery identically. Re-exported because they were part of this module's surface.
 export { describeDeliveredUserMessage, describePiQueue } from "./pi-session-events.js";
 import { createPiSession, createSdkCatalog, piSdkAvailable, resolveTranscriptFile, superPiExtensionPaths } from "./pi-session.js";
-import { TASK_CONVERSATION_ENV, PARENT_CONVERSATION_ENV, TASK_DEPTH_ENV, TASK_ENDPOINT_ENV, TASK_EXEC_ENDPOINT_ENV, TASK_ROSTER_ENV, TASK_TOOL_NAME, TODO_ENDPOINT_ENV, TODO_TOOL_NAME, SCHEDULED_TASK_ENDPOINT_ENV, SCHEDULED_TASK_TOOL_NAME, WORKFLOW_ENDPOINT_ENV, WORKFLOW_TOOL_NAME, RUN_ASYNC_TOOL_NAME, ORCHESTRATOR_ENDPOINT_ENV, ORCHESTRATOR_WORKSPACE_ENV, SESSION_SPAWN_TOOL_NAME, SESSION_STATUS_TOOL_NAME, SESSION_DISPATCH_TOOL_NAME, SESSION_STOP_TOOL_NAME, rosterPayload, } from "./task-tool.js";
+import { TASK_CONVERSATION_ENV, PARENT_CONVERSATION_ENV, TASK_DEPTH_ENV, TASK_ENDPOINT_ENV, TASK_EXEC_ENDPOINT_ENV, TASK_ROSTER_ENV, TASK_TOOL_NAME, TODO_ENDPOINT_ENV, TODO_TOOL_NAME, SCHEDULED_TASK_ENDPOINT_ENV, SCHEDULED_TASK_TOOL_NAME, WORKFLOW_ENDPOINT_ENV, WORKFLOW_TOOL_NAME, RUN_ASYNC_TOOL_NAME, ORCHESTRATOR_ENDPOINT_ENV, ORCHESTRATOR_WORKSPACE_ENV, SESSION_SPAWN_TOOL_NAME, SESSION_STATUS_TOOL_NAME, SESSION_DISPATCH_TOOL_NAME, SESSION_STOP_TOOL_NAME, SESSION_REPORT_TOOL_NAME, rosterPayload, } from "./task-tool.js";
 import { BLOCKING_UI_METHODS, EXTENSION_UI_METHODS, } from "./types.js";
 import { loadConversationImages } from "./upload.js";
 import { describeToolCall, describeToolCallArgs, describeToolCallInProgress, extractPartialResultText, extractToolResultText, readQuestionCall } from "./tool-calls.js";
@@ -1260,7 +1260,7 @@ export class PiRpcRuntime {
         if (process.env.SUPER_PI_FEISHU_ENDPOINT)
             names.push(FEISHU_READ_TOOL_NAME, FEISHU_WRITE_TOOL_NAME);
         if (this.options.orchestratorEndpoint)
-            names.push(SESSION_SPAWN_TOOL_NAME, SESSION_STATUS_TOOL_NAME, SESSION_DISPATCH_TOOL_NAME, SESSION_STOP_TOOL_NAME);
+            names.push(SESSION_SPAWN_TOOL_NAME, SESSION_STATUS_TOOL_NAME, SESSION_DISPATCH_TOOL_NAME, SESSION_STOP_TOOL_NAME, SESSION_REPORT_TOOL_NAME);
         return names;
     }
     /**
@@ -1479,7 +1479,7 @@ export class PiRpcRuntime {
         // allowlist and naming a tool Pi has not registered would change the spawn line for every other
         // mode. The prompt asks for a bare JSON array and nothing else; if the model spends a turn on a
         // tool call anyway the reranker times out and falls back to the lexical order.
-        const agentArgs = memoryReview ? ["--no-extensions", "--no-skills", "--no-mcp", "--no-context-files", "--no-prompt-templates", "--tools", "memory,skill_manage,session_search"] : knowledgeRerank ? ["--no-extensions", "--no-skills", "--no-mcp", "--no-context-files", "--no-prompt-templates"] : await agentSpawnArgs(this.agents.promptDir, agent, { extraAllowedTools: [...(extensionArgs.length ? [TASK_TOOL_NAME, TODO_TOOL_NAME, WORKFLOW_TOOL_NAME, RUN_ASYNC_TOOL_NAME, SCHEDULED_TASK_TOOL_NAME, "question", "tool_register", ...(this.options.orchestratorEndpoint ? [SESSION_SPAWN_TOOL_NAME, SESSION_STATUS_TOOL_NAME, SESSION_DISPATCH_TOOL_NAME, SESSION_STOP_TOOL_NAME] : [])] : []), ...(memoryEnabled ? ["memory", "skill_manage", "session_search"] : []), ...(knowledgeEnabled ? [KNOWLEDGE_TOOL_NAME, KNOWLEDGE_IMPORT_TOOL_NAME] : []), ...(documentsEnabled ? [DOCUMENT_READ_TOOL_NAME, DOCUMENT_WRITE_TOOL_NAME] : []), ...(webEnabled ? [WEB_SEARCH_TOOL_NAME, WEB_FETCH_TOOL_NAME] : []), ...(feishuEnabled ? [FEISHU_READ_TOOL_NAME, FEISHU_WRITE_TOOL_NAME] : [])] });
+        const agentArgs = memoryReview ? ["--no-extensions", "--no-skills", "--no-mcp", "--no-context-files", "--no-prompt-templates", "--tools", "memory,skill_manage,session_search"] : knowledgeRerank ? ["--no-extensions", "--no-skills", "--no-mcp", "--no-context-files", "--no-prompt-templates"] : await agentSpawnArgs(this.agents.promptDir, agent, { extraAllowedTools: [...(extensionArgs.length ? [TASK_TOOL_NAME, TODO_TOOL_NAME, WORKFLOW_TOOL_NAME, RUN_ASYNC_TOOL_NAME, SCHEDULED_TASK_TOOL_NAME, "question", "tool_register", ...(this.options.orchestratorEndpoint ? [SESSION_SPAWN_TOOL_NAME, SESSION_STATUS_TOOL_NAME, SESSION_DISPATCH_TOOL_NAME, SESSION_STOP_TOOL_NAME, SESSION_REPORT_TOOL_NAME] : [])] : []), ...(memoryEnabled ? ["memory", "skill_manage", "session_search"] : []), ...(knowledgeEnabled ? [KNOWLEDGE_TOOL_NAME, KNOWLEDGE_IMPORT_TOOL_NAME] : []), ...(documentsEnabled ? [DOCUMENT_READ_TOOL_NAME, DOCUMENT_WRITE_TOOL_NAME] : []), ...(webEnabled ? [WEB_SEARCH_TOOL_NAME, WEB_FETCH_TOOL_NAME] : []), ...(feishuEnabled ? [FEISHU_READ_TOOL_NAME, FEISHU_WRITE_TOOL_NAME] : [])] });
         // Refused here, with the reason, rather than handed to the spawn: an ENOENT from `spawn` reads as
         // "the app is broken" and hides the one fact that matters, which is where it looked for Pi.
         if (!this.pi.found)

package/dist/server/task-tool.d.ts

@@ -257,11 +257,14 @@ export declare const SESSION_SPAWN_TOOL_NAME = "session_spawn";
 export declare const SESSION_STATUS_TOOL_NAME = "session_status";
 export declare const SESSION_DISPATCH_TOOL_NAME = "session_dispatch";
 export declare const SESSION_STOP_TOOL_NAME = "session_stop";
+export declare const SESSION_REPORT_TOOL_NAME = "session_report";
 /** Model-facing description for session_spawn. */
-export declare const SESSION_SPAWN_DESCRIPTION = "Create a new sibling conversation in the current workspace and immediately dispatch its initial task.\n\nDIFFERENCE FROM THE 'task' TOOL:\n- The 'task' tool delegates to a transient, one-shot subagent process (scout, critic, patcher) that runs once, returns its final text, and terminates. It has no conversation history and does not appear in the workspace sidebar.\n- 'session_spawn' creates a real, persistent sibling CONVERSATION in Super Pi. It appears in the sidebar, retains multi-turn message history, can receive follow-up messages via session_dispatch, can be inspected via session_status, and can be stopped via session_stop. The user can also switch to it in the Web UI.\n\nWHEN TO USE THIS:\n- Long-running, multi-phase tracks of work that require ongoing context, multiple turns of dialogue, or independent user visibility.\n- Parallel work streams (e.g., Track A: backend refactor, Track B: frontend component update) where both need full conversational capabilities.\n- When the user asks you to act as an orchestrator/manager who delegates to multiple sessions.\n\nWHEN NOT TO USE THIS:\n- For one-off, focused delegation with a single answer: use 'task' (with scout/critic/patcher). It is faster, cheaper, and returns directly to your transcript.\n- For running shell commands or build watchers: use 'run_async'.\n- For a linear multi-step subagent pipeline: use 'workflow'.\n\nUsage notes:\n1. Spawning is ASYNCHRONOUS by default: it creates the conversation, enqueues the initial task, and returns the new conversationId immediately. The sibling session runs in the background.\n2. The initial task should provide clear context and goals since the new session starts with a fresh conversation history.\n3. Use session_status with the returned conversationId to check progress, or session_dispatch to send further messages.\n4. The new session reports completion to its DIRECT parent automatically. 'parentConversationId' optionally selects that parent; by default it is the calling session.\n5. The new session always belongs to the calling session's workspace. Pass 'cwd' as a workspace-relative subdirectory (for example, 'packages/a') when it should work below the workspace root; absolute paths and traversal are rejected.\n6. Optionally pass 'model' to choose which model the NEW session runs on: {\"provider\":\"...\",\"modelId\":\"...\"} - the same \"provider/modelId\" pair the model picker shows, and BOTH halves are required. Leave 'model' out and the new session starts on the workspace default model.";
+export declare const SESSION_SPAWN_DESCRIPTION = "Create a new sibling conversation in the current workspace and immediately dispatch its initial task.\n\nDIFFERENCE FROM THE 'task' TOOL:\n- The 'task' tool delegates to a transient, one-shot subagent process (scout, critic, patcher) that runs once, returns its final text, and terminates. It has no conversation history and does not appear in the workspace sidebar.\n- 'session_spawn' creates a real, persistent sibling CONVERSATION in Super Pi. It appears in the sidebar, retains multi-turn message history, can receive follow-up messages via session_dispatch, can be inspected via session_status, and can be stopped via session_stop. The user can also switch to it in the Web UI.\n\nWHEN TO USE THIS:\n- Long-running, multi-phase tracks of work that require ongoing context, multiple turns of dialogue, or independent user visibility.\n- Parallel work streams (e.g., Track A: backend refactor, Track B: frontend component update) where both need full conversational capabilities.\n- When the user asks you to act as an orchestrator/manager who delegates to multiple sessions.\n\nWHEN NOT TO USE THIS:\n- For one-off, focused delegation with a single answer: use 'task' (with scout/critic/patcher). It is faster, cheaper, and returns directly to your transcript.\n- For running shell commands or build watchers: use 'run_async'.\n- For a linear multi-step subagent pipeline: use 'workflow'.\n\nUsage notes:\n1. Spawning is ASYNCHRONOUS by default: it creates the conversation, enqueues the initial task, and returns the new conversationId immediately. The sibling session runs in the background.\n2. The initial task should provide clear context and goals since the new session starts with a fresh conversation history.\n3. Use session_status with the returned conversationId to check progress, or session_dispatch to send further messages.\n4. The new session reports completion to its DIRECT parent automatically. 'parentConversationId' optionally selects that parent; by default it is the calling session.\n5. The new session always belongs to the calling session's workspace. Pass 'cwd' as a workspace-relative subdirectory (for example, 'packages/a') when it should work below the workspace root; absolute paths and traversal are rejected.\n6. Optionally pass 'model' to choose which model the NEW session runs on: {\"provider\":\"...\",\"modelId\":\"...\"} - the same \"provider/modelId\" pair the model picker shows, and BOTH halves are required. Leave 'model' out and the new session starts on the workspace default model.\n7. Optionally pass 'watchdogTimeoutSeconds' to declare how long YOU are willing to wait for a report before you want to be reminded: a positive number of seconds. If the new session stays silent that long, you receive a '[Watchdog \u63D0\u9192]' message naming it. A report from the child (session_report) restarts the clock; the watchdog never stops the child. Leave it out to run without a watchdog.";
 /** Model-facing description for session_status. */
 export declare const SESSION_STATUS_DESCRIPTION = "Inspect the progress, run state, and latest activity of sibling conversations created by the orchestrator.\n\nWHEN TO USE THIS:\n- To check whether a spawned sibling conversation is still running, has finished (idle), is stopped, or encountered an error.\n- To read the latest assistant progress snippet without bloating your context with the session's entire raw message transcript.\n- To list all sibling conversations under your coordination when conversationId is omitted.\n\nUsage notes:\n1. When 'conversationId' is provided: returns a compact summary for that specific session, including its run status ('idle', 'running', 'waiting', 'stopped', 'failed'), messageCount, turnCount, lastAssistantSnippet, lastUserSnippet, activeTool, and error (if any).\n2. When 'conversationId' is omitted: returns a summary list of sibling conversations whose direct parent is 'parentConversationId' (the calling session by default).\n3. By default it never returns full transcripts; concise summaries keep your context window lean. Set 'includeOutput' with a conversationId to read the final output from its result file, capped to the last 64Ki characters with an explicit truncation notice.";
 /** Model-facing description for session_dispatch. */
 export declare const SESSION_DISPATCH_DESCRIPTION = "Send a message, follow-up instructions, or steering guidance to an existing sibling conversation.\n\nWHEN TO USE THIS:\n- To follow up with a sibling session after reading its progress with session_status.\n- To give feedback, provide additional requirements, or answer a question from a sibling session.\n- To kick off a new turn on an idle or stopped sibling session.\n\nUsage notes:\n1. 'conversationId' is required and must identify an existing sibling conversation.\n2. 'content' is the text instruction sent to that session, just as if typed by a user in that session's chat.\n3. Dispatch is ASYNCHRONOUS by default: it enqueues the message into the session's queue and returns immediately.\n4. If the sibling session is currently busy running a turn, the dispatched message is placed in its waiting queue and processed when the active turn completes.";
 /** Model-facing description for session_stop. */
 export declare const SESSION_STOP_DESCRIPTION = "Stop execution in a sibling conversation.\n\nWHEN TO USE THIS:\n- When a sibling session has gone down the wrong path, is stuck in an unwanted loop, or when the overall goal has changed and remaining work should be aborted.\n- To clear pending queued messages before they start running.\n\nUsage notes:\n1. 'mode' controls what to stop:\n   - 'all' (default): stops the currently running turn and cancels all pending queued messages in the session.\n   - 'active': only interrupts the active running turn; leaves any pending queued messages untouched.\n   - 'queued': only cancels pending queued messages; lets the currently running turn complete naturally.\n2. Use 'messageId' if you want to cancel or interrupt one specific queued message instead of all queued messages.";
+/** Model-facing description for session_report. */
+export declare const SESSION_REPORT_DESCRIPTION = "Report progress from THIS session to the parent session that spawned it.\n\nWHEN TO USE THIS:\n- You are a spawned sibling session, and the parent is waiting to hear from you: a milestone is done, a roadblock appeared, or the task is finished.\n- The parent set a watchdog (session_spawn's 'watchdogTimeoutSeconds'): a report is what restarts that clock, and silence is what triggers the reminder.\n- The task is over and the parent needs the outcome NOW rather than after the automatic end-of-turn result.\n\nWHEN NOT TO USE THIS:\n- This session has no parent (the user opened it directly): there is nobody to report to, and the server refuses the call.\n- You want to ASK the parent something or send it new instructions: that is session_dispatch, and only the parent can send it. A report is one-way - the parent receives it as a message.\n\nUsage notes:\n1. 'content' is required: it is the text the parent receives. Write it for the parent - what is done, what is left, what you need.\n2. 'status' says what the report MEANS:\n   - 'in_progress' (default): an interim update. The task continues, and the parent's watchdog clock restarts.\n   - 'completed': the task is finished and this is your final word.\n   - 'failed': the task could not be finished, and this says why.\n3. A 'completed' or 'failed' report tells the server the work is over, so the parent is NOT also sent the automatic end-of-turn result. Send it once, at the end, with the final answer in 'content'.\n4. Reporting does NOT end your turn. If the task is not done, keep working afterwards - the parent is waiting on the work, not on the report.\n5. The report reaches your DIRECT parent only. A sibling, a cousin, and the user's own session are all out of reach, and the server refuses those.";

package/dist/server/task-tool.js

@@ -362,6 +362,7 @@ export const SESSION_SPAWN_TOOL_NAME = "session_spawn";
 export const SESSION_STATUS_TOOL_NAME = "session_status";
 export const SESSION_DISPATCH_TOOL_NAME = "session_dispatch";
 export const SESSION_STOP_TOOL_NAME = "session_stop";
+export const SESSION_REPORT_TOOL_NAME = "session_report";
 /** Model-facing description for session_spawn. */
 export const SESSION_SPAWN_DESCRIPTION = `Create a new sibling conversation in the current workspace and immediately dispatch its initial task.
 
@@ -385,7 +386,8 @@ Usage notes:
 3. Use session_status with the returned conversationId to check progress, or session_dispatch to send further messages.
 4. The new session reports completion to its DIRECT parent automatically. 'parentConversationId' optionally selects that parent; by default it is the calling session.
 5. The new session always belongs to the calling session's workspace. Pass 'cwd' as a workspace-relative subdirectory (for example, 'packages/a') when it should work below the workspace root; absolute paths and traversal are rejected.
-6. Optionally pass 'model' to choose which model the NEW session runs on: {"provider":"...","modelId":"..."} - the same "provider/modelId" pair the model picker shows, and BOTH halves are required. Leave 'model' out and the new session starts on the workspace default model.`;
+6. Optionally pass 'model' to choose which model the NEW session runs on: {"provider":"...","modelId":"..."} - the same "provider/modelId" pair the model picker shows, and BOTH halves are required. Leave 'model' out and the new session starts on the workspace default model.
+7. Optionally pass 'watchdogTimeoutSeconds' to declare how long YOU are willing to wait for a report before you want to be reminded: a positive number of seconds. If the new session stays silent that long, you receive a '[Watchdog 提醒]' message naming it. A report from the child (session_report) restarts the clock; the watchdog never stops the child. Leave it out to run without a watchdog.`;
 /** Model-facing description for session_status. */
 export const SESSION_STATUS_DESCRIPTION = `Inspect the progress, run state, and latest activity of sibling conversations created by the orchestrator.
 
@@ -424,3 +426,24 @@ Usage notes:
    - 'active': only interrupts the active running turn; leaves any pending queued messages untouched.
    - 'queued': only cancels pending queued messages; lets the currently running turn complete naturally.
 2. Use 'messageId' if you want to cancel or interrupt one specific queued message instead of all queued messages.`;
+/** Model-facing description for session_report. */
+export const SESSION_REPORT_DESCRIPTION = `Report progress from THIS session to the parent session that spawned it.
+
+WHEN TO USE THIS:
+- You are a spawned sibling session, and the parent is waiting to hear from you: a milestone is done, a roadblock appeared, or the task is finished.
+- The parent set a watchdog (session_spawn's 'watchdogTimeoutSeconds'): a report is what restarts that clock, and silence is what triggers the reminder.
+- The task is over and the parent needs the outcome NOW rather than after the automatic end-of-turn result.
+
+WHEN NOT TO USE THIS:
+- This session has no parent (the user opened it directly): there is nobody to report to, and the server refuses the call.
+- You want to ASK the parent something or send it new instructions: that is session_dispatch, and only the parent can send it. A report is one-way - the parent receives it as a message.
+
+Usage notes:
+1. 'content' is required: it is the text the parent receives. Write it for the parent - what is done, what is left, what you need.
+2. 'status' says what the report MEANS:
+   - 'in_progress' (default): an interim update. The task continues, and the parent's watchdog clock restarts.
+   - 'completed': the task is finished and this is your final word.
+   - 'failed': the task could not be finished, and this says why.
+3. A 'completed' or 'failed' report tells the server the work is over, so the parent is NOT also sent the automatic end-of-turn result. Send it once, at the end, with the final answer in 'content'.
+4. Reporting does NOT end your turn. If the task is not done, keep working afterwards - the parent is waiting on the work, not on the report.
+5. The report reaches your DIRECT parent only. A sibling, a cousin, and the user's own session are all out of reach, and the server refuses those.`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evandu/super-pi",
-  "version": "0.1.147",
+  "version": "0.1.149",
   "description": "Web control plane and companion for Pi",
   "license": "MIT",
   "type": "module",
@@ -216,6 +216,7 @@
     "scripts/session-spawn-model.test.mjs",
     "scripts/background-result-steer.test.mjs",
     "scripts/session-report-watchdog.test.mjs",
+    "scripts/session-report-tool.test.mjs",
     "scripts/awaiting-background-status.test.mjs"
   ],
   "check:browser": [