zames_pro 2.69.0 → 2.71.0

package/dist/ui-health.js

@@ -0,0 +1,71 @@
+// UI health check — a cheap "can the agent still drive this page?" probe.
+//
+// WHY: every selector in deepseek-ui.ts is an assumption about a page we do
+// not control. When DeepSeek ships a redesign, the FIRST symptom used to be a
+// task hanging on "input field not found" (or a silently mis-clicked send),
+// minutes into a run. This module turns that into an explicit answer BEFORE
+// the task: it checks the capabilities the agent ALWAYS needs and reports the
+// missing ones. The page object is injected (the browser owns Playwright), so
+// the decision logic here stays pure and unit-testable.
+//
+// Only ALWAYS-PRESENT capabilities are probed. The Stop button and the answer
+// nodes are TRANSIENT (Stop exists only during generation, answers only after
+// a turn), so a presence probe on a healthy idle page would report false
+// negatives; they are deliberately excluded.
+import { INPUT_SELECTORS, SEND_SELECTORS, TOGGLE_SELECTORS, NEW_CHAT_SELECTOR, NEW_CHAT_TEXT_RE, } from './deepseek-ui.js';
+// Critical: without the input the prompt cannot be typed, without send it
+// cannot be submitted — a task would hang on `ds.input_missing`. Advisory:
+// toggles/newChat degrade gracefully (the toggles fall back to the configured
+// state, newChat falls back to navigating to the base URL).
+export const UI_CAPABILITIES = [
+    { capability: 'input', selectors: INPUT_SELECTORS, critical: true },
+    { capability: 'send', selectors: SEND_SELECTORS, critical: true },
+    { capability: 'toggles', selectors: TOGGLE_SELECTORS, critical: false },
+    { capability: 'newChat', selectors: [NEW_CHAT_SELECTOR], critical: false },
+];
+async function hasAny(page, sel, textRe) {
+    try {
+        const n = textRe
+            ? await page.countByText(sel, textRe)
+            : await page.count(sel);
+        return n > 0;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Probe the always-present DeepSeek controls. Never throws: a dead page is
+ * reported as every capability missing, which the caller surfaces to the
+ * operator instead of letting the next task hang.
+ */
+export async function probeUiHealth(page) {
+    const present = [];
+    const missing = [];
+    const missingCritical = [];
+    for (const spec of UI_CAPABILITIES) {
+        let found = false;
+        // The new-chat control is matched by an EXACT text label on a broad
+        // element set (it is a <div> on the current build, not a <button>).
+        const textRe = spec.capability === 'newChat' ? NEW_CHAT_TEXT_RE : undefined;
+        for (const sel of spec.selectors) {
+            if (await hasAny(page, sel, textRe)) {
+                found = true;
+                break;
+            }
+        }
+        if (found)
+            present.push(spec.capability);
+        else {
+            missing.push(spec.capability);
+            if (spec.critical)
+                missingCritical.push(spec.capability);
+        }
+    }
+    return {
+        ok: missingCritical.length === 0,
+        present,
+        missing,
+        missingCritical,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zames_pro",
-  "version": "2.69.0",
+  "version": "2.71.0",
   "description": "Terminal coding agent that drives chat.deepseek.com through Playwright — no API key required. Reads and edits files, runs commands, commits to git, like Claude Code / Codex CLI.",
   "type": "module",
   "bin": {

package/scripts/self-smoke.mjs

@@ -42,8 +42,9 @@ fs.mkdirSync(WORK, { recursive: true })
 
 // --- project modules (dynamic: they read HOME at import) --------------------
 const { DeepSeekBrowser } = await import('../src/browser.ts')
-const { createTools } = await import('../src/tools.ts')
+const { createTools, filterToolsForReadOnly } = await import('../src/tools.ts')
 const { runAgentLoop } = await import('../src/agent-loop.ts')
+const { createSubagentRunner } = await import('../src/subagent.ts')
 const { loadConfig } = await import('../src/config.ts')
 const { Transcript } = await import('../src/transcript.ts')
 
@@ -149,6 +150,49 @@ async function main() {
     maxAfterToolRetries: cfg.browser.maxAfterToolRetries,
   })
   record('follow-up answered', outC.trim().length > 0, JSON.stringify(outC.slice(0, 80)))
+  const onSubagent = createSubagentRunner({
+    browser,
+    workdir: WORK,
+    locale: 'ru',
+    runAgentLoop,
+    buildTools: (readOnly) => {
+      const base = createTools(WORK, {})
+      return readOnly ? filterToolsForReadOnly(base) : base
+    },
+    transcript,
+    maxSubagents: 2,
+    askDeadlineMs: cfg.browser.askDeadlineMs,
+    maxAfterToolRetries: cfg.browser.maxAfterToolRetries,
+  })
+
+  // Scenario D — subagents (N36): the model delegates via Task; the runner
+  // opens a separate chat, returns only the report, and restores the parent
+  // chat. Requires browser.subagents (off by default).
+  const subTools = createTools(WORK, { subagents: true })
+  const outD = await runAgentLoop({
+    browser,
+    tools: subTools,
+    task:
+      'Use the Task tool with subagent_type "explore" to find which word is written in the file smoke.txt. ' +
+      'prompt the subagent in a self-contained way. Then, based on its report, call respond with that word.',
+    workdir: WORK,
+    maxIterations: 20,
+    freshChat: true,
+    sendSystemPrompt: true,
+    transcript,
+    onSubagent,
+    onToolCall: (n) => console.log('  tool: ' + n),
+    onAssistantMessage: (m) => console.log('  answer: ' + m),
+    onWarning: (m) => console.log('  warn: ' + m),
+    locale: 'ru',
+    askDeadlineMs: cfg.browser.askDeadlineMs,
+    maxAfterToolRetries: cfg.browser.maxAfterToolRetries,
+  })
+  record(
+    'subagent: parent used the report',
+    /HELLO_SMOKE/i.test(outD),
+    JSON.stringify(outD.slice(0, 120)),
+  )
 }
 
 let failed = false