dsh-foreman-node 0.2.0 → 0.2.1

package/CHANGELOG.md

@@ -1,3 +1,25 @@
+## 0.2.1 — 2026-11-08
+
+### 修复：任务跑完了，却没有回报给 hub
+
+真机上一次派单：设备做了 30 步、37 次工具调用、写了 2808 字的完整答案，**一次都没调用 `foreman_report`**。
+hub 因此一直停在 `running`，面板上那张工单永远不结束，人也收不到结果。
+
+两个原因，都修了：
+
+1. **任务文本里没有说要回报。** 设备收到的只有标题、请求原文和附件说明，模型自然当成普通任务，
+   做完就结束。现在每张派单的末尾都有一段说明：`foreman_report` 是这个任务到达人的唯一途径，
+   答在对话里不算完成。
+2. **只靠模型自觉不可靠。** 加了一层兜底：一轮结束而还没有回报时，插件自动补一条 `ready`，
+   摘要取会话里最后一段模型输出。工具被正确调用过就不会重复补。
+
+兜底是真的兜底——任何一轮正常结束都会触发它，所以即使模型完全无视那段说明，任务也不会挂死。
+
+### 加固
+
+- 会话事件监听注册失败时（宿主不提供 `ctx.effect`），仍然会挂上回报工具：
+  没有回报通道比“看不见轮次结束”严重得多。
+
 ## 0.2.0 — 2026-11-07
 
 ### 新增：配置页，设备绑定不用再碰命令行

package/lib/index.d.ts

@@ -344,6 +344,8 @@ declare class JobSessions {
   private readonly jobs;
   /** Assignments whose Session already carries the report tool, so a redelivered assign registers it only once. */
   private readonly reported;
+  /** Assignments that have actually reported; a turn ending without one is closed out by `watchTurnEnd`. */
+  private readonly reports;
   constructor(ctx: Context);
   /**
    * Resolve or create the `job-<assignmentId>` Session in the given directory, attach its `foreman_report` tool, and
@@ -372,6 +374,17 @@ declare class JobSessions {
   forget(assignmentId: string): void;
   /** Attach the `foreman_report` tool to a job Session, disposed with it. */
   reportTools(agent: Agent, assignmentId: string, onReport: (assignmentId: string, report: DeviceReport) => void): void;
+  /**
+   * Report for a job that ended without calling the tool.
+   *
+   * Telling the model to report is not a guarantee: on a real deployment a device did the work, wrote a complete
+   * answer, and never called `foreman_report`, so the hub waited at `running` forever. The tool alone leaves that
+   * failure open, so a turn that ends with no report is closed out here — `ready`, with the last thing the model said
+   * as the summary. A person still gets the result; the ledger still learns the job ended.
+   */
+  private watchTurnEnd;
+  /** The last text the assistant said in a Session, read from its stored history. */
+  private lastText;
 }
 /** Version reported in the hello, so the hub can tell which device build is talking. */
 declare const VERSION = "0.2.0";

package/lib/index.js

@@ -877,6 +877,8 @@ var JobSessions = class {
 	jobs = /* @__PURE__ */ new Map();
 	/** Assignments whose Session already carries the report tool, so a redelivered assign registers it only once. */
 	reported = /* @__PURE__ */ new Set();
+	/** Assignments that have actually reported; a turn ending without one is closed out by `watchTurnEnd`. */
+	reports = /* @__PURE__ */ new Set();
 	constructor(ctx) {
 		this.ctx = ctx;
 	}
@@ -982,7 +984,12 @@ var JobSessions = class {
 	/** Attach the `foreman_report` tool to a job Session, disposed with it. */
 	reportTools(agent, assignmentId, onReport) {
 		const registrar = agent.ctx.tools;
-		const tool = foremanReportTool({ report: onReport }, assignmentId);
+		const reported = this.reports;
+		const report = (id, deviceReport) => {
+			reported.add(id);
+			onReport(id, deviceReport);
+		};
+		const tool = foremanReportTool({ report }, assignmentId);
 		registrar.register({
 			name: tool.name,
 			description: tool.description,
@@ -999,6 +1006,62 @@ var JobSessions = class {
 			},
 			execute: (args, execution) => tool.execute(args, execution)
 		});
+		this.watchTurnEnd(agent, assignmentId, report);
+	}
+	/**
+	* Report for a job that ended without calling the tool.
+	*
+	* Telling the model to report is not a guarantee: on a real deployment a device did the work, wrote a complete
+	* answer, and never called `foreman_report`, so the hub waited at `running` forever. The tool alone leaves that
+	* failure open, so a turn that ends with no report is closed out here — `ready`, with the last thing the model said
+	* as the summary. A person still gets the result; the ledger still learns the job ended.
+	*/
+	watchTurnEnd(agent, assignmentId, report) {
+		if (typeof agent.ctx.effect !== "function") return;
+		agent.ctx.effect(() => {
+			agent.ctx.on("session/event", (session, event) => {
+				if (session.id !== agent.session.id || event.type !== "turn/end") return;
+				if (this.reports.has(assignmentId)) return;
+				this.lastText(agent).then((text) => {
+					if (this.reports.has(assignmentId)) return;
+					report(assignmentId, {
+						state: "ready",
+						summary: text === "" ? "the job finished without a report" : text.slice(0, 600)
+					});
+				}, () => {
+					if (this.reports.has(assignmentId)) return;
+					report(assignmentId, {
+						state: "ready",
+						summary: "the job finished without a report"
+					});
+				});
+			});
+			return () => {};
+		});
+	}
+	/** The last text the assistant said in a Session, read from its stored history. */
+	async lastText(agent) {
+		try {
+			var _usingCtx3 = _usingCtx();
+			await this.ctx.sessionPersistence.flush();
+			const handle = _usingCtx3.a(await this.ctx.sessionPersistence.open(agent.id, "read"));
+			let found = "";
+			for (let offset = 0;;) {
+				const { events } = await handle.read(offset, 512);
+				if (events.length === 0) break;
+				for (const event of events) {
+					if (event.type !== "assistant/message") continue;
+					const text = (event.data?.message?.content ?? []).filter((part) => part?.type === "text").map((part) => part.text ?? "").join(" ").trim();
+					if (text !== "") found = text;
+				}
+				offset += events.length;
+			}
+			return found;
+		} catch (_) {
+			_usingCtx3.e = _;
+		} finally {
+			await _usingCtx3.d();
+		}
 	}
 };
 // src/index.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-foreman-node",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Device side of dsh-foreman: connects out to a foreman hub, takes a job into a local DSH session, reports back. No ledger, no policy, no database.",
   "type": "module",
   "main": "lib/index.js",

package/src/session.ts

@@ -60,6 +60,8 @@ export class JobSessions {
   private readonly jobs = new Map<string, string>()
   /** Assignments whose Session already carries the report tool, so a redelivered assign registers it only once. */
   private readonly reported = new Set<string>()
+  /** Assignments that have actually reported; a turn ending without one is closed out by `watchTurnEnd`. */
+  private readonly reports = new Set<string>()
 
   constructor(private readonly ctx: Context) {}
 
@@ -147,10 +149,64 @@ export class JobSessions {
   /** Attach the `foreman_report` tool to a job Session, disposed with it. */
   reportTools(agent: Agent, assignmentId: string, onReport: (assignmentId: string, report: DeviceReport) => void): void {
     const registrar = agent.ctx.tools
-    const tool = foremanReportTool({ report: onReport }, assignmentId)
+    // Wrap the reporter so this Session's own turn ending can tell whether a report ever went out.
+    const reported = this.reports
+    const report = (id: string, deviceReport: DeviceReport): void => { reported.add(id); onReport(id, deviceReport) }
+    const tool = foremanReportTool({ report }, assignmentId)
     registrar.register({ name: tool.name, description: tool.description, parameters: tool.parameters,
       output: { schema: { type: 'object', additionalProperties: true },
         render: (_args: unknown, value: unknown) => [{ type: 'text' as const, text: JSON.stringify(value) }] },
       execute: (args: unknown, execution: { signal: AbortSignal }) => tool.execute(args as Record<string, unknown>, execution) })
+    this.watchTurnEnd(agent, assignmentId, report)
+  }
+
+  /**
+   * Report for a job that ended without calling the tool.
+   *
+   * Telling the model to report is not a guarantee: on a real deployment a device did the work, wrote a complete
+   * answer, and never called `foreman_report`, so the hub waited at `running` forever. The tool alone leaves that
+   * failure open, so a turn that ends with no report is closed out here — `ready`, with the last thing the model said
+   * as the summary. A person still gets the result; the ledger still learns the job ended.
+   */
+  private watchTurnEnd(agent: Agent, assignmentId: string, report: (id: string, r: DeviceReport) => void): void {
+    // The watcher is a safety net, not part of the tool: a host that cannot register it must still get the tool,
+    // because a job with no reporting channel at all is worse than one whose turn end is not observed.
+    if (typeof agent.ctx.effect !== 'function') return
+    agent.ctx.effect(() => {
+      const dispose = agent.ctx.on('session/event', (session, event) => {
+        if (session.id !== agent.session.id || event.type !== 'turn/end') return
+        if (this.reports.has(assignmentId)) return
+        // Reading the history is best effort: an unreadable history still closes the job out, because leaving the
+        // hub at `running` forever is the worse failure.
+        void this.lastText(agent).then(text => {
+          if (this.reports.has(assignmentId)) return
+          report(assignmentId, { state: 'ready', summary: text === '' ? 'the job finished without a report' : text.slice(0, 600) })
+        }, () => {
+          if (this.reports.has(assignmentId)) return
+          report(assignmentId, { state: 'ready', summary: 'the job finished without a report' })
+        })
+      })
+      return () => { void dispose }
+    })
+  }
+
+  /** The last text the assistant said in a Session, read from its stored history. */
+  private async lastText(agent: Agent): Promise<string> {
+    await this.ctx.sessionPersistence.flush()
+    await using handle = await this.ctx.sessionPersistence.open(agent.id, 'read')
+    let found = ''
+    for (let offset = 0; ;) {
+      const { events } = await handle.read(offset, 512)
+      if (events.length === 0) break
+      for (const event of events) {
+        if (event.type !== 'assistant/message') continue
+        const parts = (event.data as unknown as { message?: { content?: readonly { type?: string; text?: string }[] } })
+          ?.message?.content ?? []
+        const text = parts.filter(part => part?.type === 'text').map(part => part.text ?? '').join(' ').trim()
+        if (text !== '') found = text
+      }
+      offset += events.length
+    }
+    return found
   }
 }