dsh-workplan 0.0.0-stage → 1.4.3

package/lib/watchdog.js

@@ -0,0 +1,184 @@
+/**
+ * Timeout policy for one child execution.
+ *
+ * The rule this module exists to enforce: a child is stopped only when it is
+ * demonstrably not making progress, or when it exceeds an absolute ceiling.
+ *
+ * History that produced this module: `runSubtask` used to race the child
+ * against a single 300 000 ms wall-clock timer. A research child that
+ * legitimately needed six minutes was recorded as `blocked`, `markDependentsBlocked`
+ * then turned that one verdict into a whole plan reporting 0/N complete, and the
+ * dashboard offered no recovery — the plan was terminal. Across the recorded
+ * sessions that single timer produced every one of the observed child timeouts.
+ *
+ * Progress is read from the child's own session log (`ctx.sessions.get(id).seq`),
+ * which grows with every appended step, tool call and streamed delta. That is a
+ * public, non-deprecated accessor, and it is optional: when the child session
+ * cannot be observed, only the absolute ceiling applies — never a shorter idle
+ * guess, because a false stall would kill healthy work.
+ */
+/**
+ * Decide whether one child execution has exhausted its budget.
+ *
+ * Pure function: the watchdog loop only supplies observations.
+ *
+ * @param input.now - current time in epoch milliseconds.
+ * @param input.startedAt - when the current attempt started.
+ * @param input.lastProgressAt - last time the child's session log grew.
+ * @param input.idleMs - no-progress window that means "wedged".
+ * @param input.hardMs - absolute ceiling for one attempt.
+ * @param input.progressObservable - whether the child's log can be read at all.
+ * @returns `'exhausted'` on the ceiling, `'stalled'` on an idle window, else `null`.
+ */
+export function pickTimeoutReason(input) {
+    const { now, startedAt, lastProgressAt, idleMs, hardMs, progressObservable } = input;
+    if (!Number.isFinite(now) || !Number.isFinite(startedAt))
+        return null;
+    if (now - startedAt >= hardMs)
+        return 'exhausted';
+    if (progressObservable && Number.isFinite(lastProgressAt) && now - lastProgressAt >= idleMs) {
+        return 'stalled';
+    }
+    return null;
+}
+/**
+ * Render any rejection value as readable text.
+ *
+ * `String(error)` on a plain object yields `[object Object]`; one recorded
+ * subtask was blocked with exactly that string, which made the failure
+ * undiagnosable from the dashboard and the durable result message.
+ *
+ * @param value - a rejected value of unknown shape.
+ * @returns a non-empty, human-readable description.
+ */
+export function describeError(value) {
+    if (value === null || value === undefined)
+        return '未知失败';
+    if (typeof value === 'string') {
+        const text = value.trim();
+        return text === '' ? '未知失败' : text;
+    }
+    if (value instanceof Error) {
+        const message = typeof value.message === 'string' ? value.message.trim() : '';
+        return message !== '' ? message : (value.name || '未知失败');
+    }
+    if (typeof value === 'object') {
+        const record = value;
+        for (const key of ['message', 'reason', 'error', 'detail']) {
+            const field = record[key];
+            if (typeof field === 'string' && field.trim() !== '')
+                return field.trim();
+            if (field instanceof Error && field.message?.trim())
+                return field.message.trim();
+            if (field && typeof field === 'object') {
+                const nested = describeError(field);
+                if (nested !== '未知失败' && nested !== '[object Object]')
+                    return nested;
+            }
+        }
+        try {
+            const text = JSON.stringify(value);
+            if (typeof text === 'string' && text !== '' && text !== '{}')
+                return text.slice(0, 500);
+        }
+        catch {
+            // Circular structures have no JSON form; fall through to the constructor name.
+        }
+        const name = value?.constructor?.name;
+        return name ? `未命名错误（${name}）` : '未命名对象错误';
+    }
+    return String(value);
+}
+/**
+ * Watch one child's session-log growth and reject when it stalls or runs out.
+ *
+ * @param input.getSeq - reads the child's current event sequence, or undefined when unobservable.
+ * @param input.idleMs - no-progress window.
+ * @param input.hardMs - absolute ceiling.
+ * @param input.pollMs - observation period.
+ * @param input.makeError - builds the rejection for the decided reason.
+ * @param input.onProgress - called after each observed log growth.
+ * @param input.now - clock, injectable for tests.
+ * @returns a watchdog handle.
+ */
+export function createProgressWatchdog(input) {
+    const clock = input.now ?? (() => Date.now());
+    const pollMs = Math.max(10, Math.floor(input.pollMs ?? 2000));
+    const startedAt = clock();
+    let lastProgress = startedAt;
+    let lastSeq = null;
+    let growth = 0;
+    let settled = false;
+    let timer = null;
+    let rejectOnce = () => { };
+    const fired = new Promise((_resolve, reject) => {
+        rejectOnce = reject;
+    });
+    // The caller may await a race in which this promise loses; keep the
+    // rejection handled so Node never reports an unhandled rejection.
+    fired.catch(() => { });
+    const finish = (reason) => {
+        if (settled)
+            return;
+        settled = true;
+        if (timer) {
+            clearInterval(timer);
+            timer = null;
+        }
+        rejectOnce(input.makeError(reason));
+    };
+    const poll = () => {
+        if (settled)
+            return;
+        const now = clock();
+        let seq;
+        try {
+            seq = input.getSeq();
+        }
+        catch {
+            seq = undefined;
+        }
+        if (typeof seq === 'number' && Number.isFinite(seq)) {
+            if (lastSeq === null) {
+                lastSeq = seq;
+            }
+            else if (seq > lastSeq) {
+                lastSeq = seq;
+                growth += 1;
+                lastProgress = now;
+                try {
+                    input.onProgress?.({ now, seq, elapsedMs: now - startedAt });
+                }
+                catch {
+                    // An observer must never break the watchdog.
+                }
+            }
+        }
+        const reason = pickTimeoutReason({
+            now,
+            startedAt,
+            lastProgressAt: lastProgress,
+            idleMs: Math.max(1, Math.floor(input.idleMs)),
+            hardMs: Math.max(1, Math.floor(input.hardMs)),
+            progressObservable: lastSeq !== null,
+        });
+        if (reason)
+            finish(reason);
+    };
+    timer = setInterval(poll, pollMs);
+    timer.unref?.();
+    return {
+        fired,
+        stop() {
+            if (settled)
+                return;
+            settled = true;
+            if (timer) {
+                clearInterval(timer);
+                timer = null;
+            }
+        },
+        lastProgressAt: () => lastProgress,
+        progressEvents: () => growth,
+    };
+}

package/locale/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Task progress",
+    "description": "Plain-language view of the steps, who is doing the work, how far it has gone, and what is stuck; technical notes stay collapsed."
+  }
+}

package/locale/zh.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "任务进度",
+    "description": "用大白话展示任务分几步、谁在做、做到哪一步、哪里卡住了；需要时再展开专业说明。"
+  }
+}

package/package.json

@@ -1,6 +1,76 @@
 {
   "name": "dsh-workplan",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.4.3",
+  "description": "Automatic task decomposition, real department subagents, and a responsive workplan dashboard for DeepSeek Harness.",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/abbaababa/dsh-workplan.git"
+  },
+  "homepage": "https://github.com/abbaababa/dsh-workplan#readme",
+  "bugs": {
+    "url": "https://github.com/abbaababa/dsh-workplan/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "dsh",
+    "deepseek-harness",
+    "deepseek",
+    "plugin",
+    "bundle",
+    "workplan",
+    "task-decomposition",
+    "subagents",
+    "dashboard"
+  ],
+  "main": "lib/host.js",
+  "exports": {
+    ".": "./lib/host.js",
+    "./entry": "./lib/host.js",
+    "./client": "./client.js",
+    "./locale/*.json": "./locale/*.json",
+    "./icon": "./icon.svg",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "src",
+    "lib",
+    "vendor",
+    "client.js",
+    "tsconfig.json",
+    "cordis.patch.yml",
+    "locale",
+    "icon.svg",
+    "CHANGELOG.md",
+    "README.md",
+    "README.en.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "immediately": true
+    }
+  },
+  "scripts": {
+    "clean": "rm -rf dist dist-tests",
+    "build": "rm -rf dist && tsc -p tsconfig.json && cp dist/plan.js dist/runtime.js dist/host.js dist/watchdog.js lib/ && cp dist/client.js client.js",
+    "check": "tsc -p tsconfig.json --noEmit",
+    "test": "npm run build && rm -rf dist-tests && tsc -p tsconfig.test.json && node --test dist-tests/tests/*.test.js",
+    "verify": "npm run check && npm test"
+  },
+  "devDependencies": {
+    "@types/node": "^22.20.5",
+    "@types/react": "^18.3.31",
+    "typescript": "^5.9.3"
+  }
+}