zames_pro 2.41.1 → 2.43.0

package/dist/browser.js

@@ -1,5 +1,6 @@
 import { chromium, } from 'playwright';
 import { extractAnswer, extractTokenUsage, dumpNetBody, isFinishedWithoutAnswer, } from './net-capture.js';
+import { rewriteFailedAttachments } from './commands.js';
 import path from 'path';
 import os from 'os';
 import fs from 'fs/promises';
@@ -391,6 +392,12 @@ export class DeepSeekBrowser {
     // the agent hung until the timeout.
     _netBody;
     _netHookInstalled;
+    // The page object the net hook was installed on. A RELAUNCH (e.g. the
+    // headless UA fix) creates a NEW page; comparing against this lets
+    // _installNetHook re-attach to the new page instead of silently skipping
+    // (which left the post-fix page with no capture and "no answer" in
+    // headless, while headed worked).
+    _netHookPage;
     // Fired right when a message is actually typed/sent (AFTER the send-pause
     // and attachments). Used to start the "agent is working" spinner only when
     // a generation really begins, not during the pre-send phase (chat open,
@@ -462,6 +469,7 @@ export class DeepSeekBrowser {
         this._lastHistoryError = '';
         this._netBody = '';
         this._netHookInstalled = false;
+        this._netHookPage = null;
         this.onSendStart = null;
         this.onSendPause = null;
         this.onSendState = null;
@@ -609,12 +617,16 @@ export class DeepSeekBrowser {
         await this.page.goto(CHAT_URL, { waitUntil: 'domcontentloaded' });
     }
     _installNetHook() {
-        if (this._netHookInstalled)
-            return;
         const pg = this['page'];
         if (!pg)
             return;
+        // Skip only when the hook is ALREADY on THIS page. After a relaunch the
+        // page object changed, so we must attach to the new one — otherwise the
+        // capture stayed dead and ask() saw "no answer".
+        if (this._netHookInstalled && this._netHookPage === pg)
+            return;
         this._netHookInstalled = true;
+        this._netHookPage = pg;
         pg.on('response', (resp) => {
             void this._onResponse(resp).catch(() => { });
         });
@@ -1848,7 +1860,12 @@ export class DeepSeekBrowser {
     // Attach files/images to the chat via the hidden <input type=file> of the
     // DeepSeek upload widget. The element is not visible, so we set the files
     // programmatically (Playwright setInputFiles works on hidden inputs too).
+    // Returns the files that could NOT be attached (read error, no upload
+    // widget, or a failed upload), so the caller can rewrite their path in the
+    // message to [attach-failed: name]. The model must not believe a file was
+    // attached when it was not.
     async _attachFiles(files) {
+        const failed = [];
         const bufPayload = [];
         for (const f of files) {
             try {
@@ -1856,6 +1873,7 @@ export class DeepSeekBrowser {
                 bufPayload.push({ name: f.name, mimeType: f.mime, buffer });
             }
             catch (e) {
+                failed.push({ path: f.path, name: f.name });
                 this._notice(theme.warn(this._t('ds.attach_read_failed', {
                     name: f.name,
                     error: e.message,
@@ -1863,7 +1881,7 @@ export class DeepSeekBrowser {
             }
         }
         if (!bufPayload.length)
-            return;
+            return failed;
         // Preferred path: click the attach button and let the file chooser event
         // carry the files. This is how a real user attaches a file and it reliably
         // triggers DeepSeek's upload handler.
@@ -1889,7 +1907,7 @@ export class DeepSeekBrowser {
                 await chooser.setFiles(bufPayload);
                 // Wait for the upload preview instead of a fixed 2.5s sleep.
                 await this._awaitUploadPreview(files.map((f) => f.name), 2500);
-                return;
+                return failed;
             }
             catch { }
         }
@@ -1897,17 +1915,22 @@ export class DeepSeekBrowser {
         const input = this.page.locator('input[type="file"]').first();
         if ((await input.count()) === 0) {
             this._notice(theme.warn(this._t('ds.attach_no_input')));
-            return;
+            for (const f of files)
+                failed.push({ path: f.path, name: f.name });
+            return failed;
         }
         try {
             await input.setInputFiles(bufPayload, { timeout: 15_000 });
         }
         catch (e) {
             this._notice(theme.warn(this._t('ds.attach_failed', { error: e.message })));
-            return;
+            for (const f of files)
+                failed.push({ path: f.path, name: f.name });
+            return failed;
         }
         // Wait for the upload to finish (the attach preview to appear).
         await this._awaitUploadPreview(files.map((f) => f.name), 2000);
+        return failed;
     }
     // Wait for the upload preview (the attached-file chip above the
     // input) to appear, instead of a fixed 2.5s/2s sleep. The signal is the
@@ -2092,10 +2115,15 @@ export class DeepSeekBrowser {
         await this._applyToggles();
         // Attach files/images FIRST (before the text): the DeepSeek upload widget
         // shows them above the input, and only then the message can be sent.
+        // A file that FAILED to attach has its real path in the prompt text (see
+        // substituteAttachmentMarkers); rewrite it to [attach-failed: name] so the
+        // model does not believe the file is available.
+        let finalPrompt = prompt;
         if (attachments.length) {
-            await this._attachFiles(attachments);
+            const failed = await this._attachFiles(attachments);
+            finalPrompt = rewriteFailedAttachments(finalPrompt, failed);
         }
-        await this._setInputText(input, prompt);
+        await this._setInputText(input, finalPrompt);
         // Send immediately: the input is already verified by _setInputText, and a
         // clickable send button normally appears right away. The old code slept a
         // fixed 50ms here, which only added latency (the button does not need it).

package/dist/commands.js

@@ -532,6 +532,19 @@ export function substituteAttachmentMarkers(text, attachments) {
     out = out.replace(/\[file#(\d+)\]/g, (whole, n) => filePath.get(Number(n)) ?? whole);
     return out;
 }
+// Rewrite the paths of files that FAILED to attach into [attach-failed: name]
+// in the task text, so the model does not believe an unavailable file was
+// attached. The prompt carries real paths (substituteAttachmentMarkers), so a
+// failed file's path is replaced in place. Pure, so it is unit-tested.
+export function rewriteFailedAttachments(text, failed) {
+    let out = String(text ?? '');
+    for (const f of failed || []) {
+        if (!f || !f.path)
+            continue;
+        out = out.split(f.path).join('[attach-failed: ' + f.name + ']');
+    }
+    return out;
+}
 // True when a `/config ...` line can be handled LIVE (while the agent is busy):
 // the text subcommands only touch config values, never the chat. The bare
 // `/config` and `/config menu` (which pause the editor and read keys) are NOT

package/dist/context.js

@@ -1,6 +1,65 @@
 import fs from 'fs/promises';
 import path from 'path';
 import os from 'os';
+// Built-in skills, always available unless a project/global skill with the
+// same name overrides them (real files win). They give the agent proven,
+// reusable workflows in the spirit of Claude Code / Codex. English only (the
+// body goes into the agent-facing task text).
+const BUILTIN_SKILLS = [
+    {
+        name: 'commit',
+        description: 'Prepare a clean git commit from the current changes (stage, message).',
+        body: 'Prepare a commit from the current working-tree changes. Steps:\n' +
+            '1. Run `git status` and `git diff` (and `git diff --staged`) to see exactly what changed.\n' +
+            '2. Stage ONLY the files that belong to the intended change — never `git add -A` blindly.\n' +
+            '3. Write a short imperative subject line (<=72 chars) and an optional body explaining WHY.\n' +
+            '4. Commit with `git commit`. Do NOT push.\n' +
+            'If the changes are unrelated or include junk, report that and ask before committing.',
+    },
+    {
+        name: 'review',
+        description: 'Review the current diff for bugs, risks and style issues (no code changes).',
+        body: 'Review the current uncommitted diff. Do NOT change any code — only report.\n' +
+            '1. Get the diff with `git diff` (and `git diff --staged`).\n' +
+            '2. Look for real problems: correctness bugs, unhandled edge cases, races, ' +
+            'silent failures, security issues, broken error handling.\n' +
+            '3. For each finding give file:line, what is wrong and WHY it matters.\n' +
+            '4. End with a short verdict: safe to commit / needs fixes, and list the must-fix items first.',
+    },
+    {
+        name: 'test',
+        description: 'Run the project tests and fix failures until green.',
+        body: 'Run the project test suite and make it green. Steps:\n' +
+            '1. Find the test command (package.json scripts, Makefile, README).\n' +
+            '2. Run it. If it passes, report the result and stop.\n' +
+            '3. On failure, read the failing test and the code it exercises. Fix the ROOT cause ' +
+            '(do not weaken or delete the test to make it pass, unless the test itself is wrong).\n' +
+            '4. Re-run until it passes. Report what changed and the final result.',
+    },
+    {
+        name: 'debug',
+        description: 'Systematically diagnose and fix a bug.',
+        body: 'Diagnose a bug systematically. Steps:\n' +
+            '1. Reproduce it: find the smallest command/steps that show the failure.\n' +
+            '2. Form a hypothesis about the cause and find evidence in the code (read the actual code path).\n' +
+            '3. Narrow it down (logs, a focused test, a minimal repro) BEFORE editing.\n' +
+            '4. Fix the ROOT cause, not the symptom. Add a regression test that fails before and passes after.\n' +
+            '5. Verify the fix and report the cause, the change and the test.',
+    },
+    {
+        name: 'explain',
+        description: 'Explain how a file/module/feature works.',
+        body: 'Explain how the requested code works, for a developer new to it.\n' +
+            '1. Read the relevant files (start from the entry point and follow the calls).\n' +
+            '2. Give a concise overview: what it does, its inputs/outputs, the main flow.\n' +
+            '3. Call out non-obvious details: side effects, ordering, error handling, ' +
+            'couplings, and any WHY-comments that matter.\n' +
+            '4. Do NOT change code. Answer in the operator language.',
+    },
+];
+export function builtinSkills() {
+    return BUILTIN_SKILLS;
+}
 const MAX_FILE_BASE = 60000;
 const MAX_TOTAL = 240000;
 const CRLF_RE = /\r\n/g;
@@ -190,6 +249,24 @@ export async function loadSkills(workdir) {
         }
     }
     found.sort((a, b) => a.name.localeCompare(b.name));
+    // Built-in skills come LAST (lowest priority): any project/global skill
+    // with the same name already claimed `seen` and wins. Only the not-overridden
+    // built-ins are appended, with an empty path and the body inline.
+    for (const b of BUILTIN_SKILLS) {
+        const key = b.name.toLowerCase();
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        found.push({
+            name: b.name,
+            description: b.description,
+            path: '',
+            dir: '',
+            source: 'global',
+            userInvokable: true,
+            builtinBody: b.body,
+        });
+    }
     return found;
 }
 const PROJECT_COMMAND_DIRS = [

package/dist/index.js

@@ -454,14 +454,20 @@ async function expandSlashTarget(workdir, name, rest) {
         const skill = skills.find((s) => s.name.toLowerCase() === name.toLowerCase() && s.userInvokable);
         if (skill) {
             let body = '';
-            try {
-                const raw = await fs.readFile(skill.path, 'utf-8');
-                body = skillBody(raw);
+            if (skill.builtinBody !== undefined) {
+                body = skill.builtinBody;
             }
-            catch {
-                body = '';
+            else {
+                try {
+                    const raw = await fs.readFile(skill.path, 'utf-8');
+                    body = skillBody(raw);
+                }
+                catch {
+                    body = '';
+                }
             }
-            const header = 'Follow the skill "' + skill.name + '" (from ' + skill.path + ').';
+            const from = skill.path ? ' (from ' + skill.path + ')' : ' (built-in)';
+            const header = 'Follow the skill "' + skill.name + '"' + from + '.';
             const extra = rest
                 ? '\n\nAdditional instructions from the operator: ' + rest
                 : '';
@@ -2537,11 +2543,13 @@ async function main() {
             else {
                 console.log(theme.system(t('skills.title', { n: String(skills.length) })));
                 for (const s of skills) {
+                    const src = s.path ? s.source : 'built-in';
                     console.log('  ' +
                         theme.user('/' + s.name) +
-                        theme.dim(' [' + s.source + '] ') +
+                        theme.dim(' [' + src + '] ') +
                         (s.description || theme.dim(t('common.none'))));
-                    console.log(theme.dim('      ' + s.path));
+                    if (s.path)
+                        console.log(theme.dim('      ' + s.path));
                 }
             }
             continue;

package/dist/system-prompt.js

@@ -37,17 +37,18 @@ export function renderContextSection(context) {
             const tools = s.allowedTools && s.allowedTools.length
                 ? ' [tools: ' + s.allowedTools.join(', ') + ']'
                 : '';
+            // A built-in skill (no file on disk) says so instead of an empty path.
+            const loc = s.path ? '\n  file: ' + s.path : '\n  (built-in)';
             return ('- ' +
                 s.name +
                 tools +
                 ': ' +
                 (s.description || '(no description)') +
-                '\n  file: ' +
-                s.path);
+                loc);
         });
         out +=
             '\n## Skills\n\n' +
-                'Specialized workflows available as SKILL.md files. When a task matches a skill description, read its file and follow its instructions. Skills are progressive disclosure: only read the body when the skill applies.\n\n' +
+                'Specialized workflows. A skill with a `file:` is a SKILL.md on disk (read it when it applies); a `(built-in)` skill has no file — the operator can invoke it with /<name> and its instructions arrive as the task. Skills are progressive disclosure: only read the body when the skill applies.\n\n' +
                 lines.join('\n') +
                 '\n';
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zames_pro",
-  "version": "2.41.1",
+  "version": "2.43.0",
   "description": "Terminal coding agent over chat.deepseek.com via Playwright",
   "type": "module",
   "bin": {