zames_pro 2.96.1 → 2.96.3

package/CHANGELOG.md

@@ -7,13 +7,25 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.96.3] - 2026-11-06
+
 ### Fixed
 
-- **release-policy:** one pair of parens in the BREAKING note
-- **changelog:** a group heading must start a line, not sit inside a bullet
-- **backlog:** ignore a fenced section header when appending
-- **dev-watch:** follow index.ts's hot-reloadable list (restore-history, input/layout)
-- **shell:** block a recursive rm of ./ and ../ (trailing slash)
+- **banner:** keep a banner field on one line inside the box
+- **scheduler:** reschedule a job whose nextAt is not finite
+- **goal:** keep a condition from injecting its own verdict block
+- **compact:** keep operator and summary text out of the carryover headings
+- **release:** sync the changelog and rebuild its pages inside a release
+
+## [2.96.2] - 2026-11-06
+
+### Fixed
+
+- **info:** keep a /chat and /pwd value on one line
+- **status:** flatten a status/doctor value and drop a broken count
+- **limits:** never render a negative or NaN counter in /limits
+- **restore-history:** keep a plain answer that opens with 'thinking for'
+- **commands:** keep a project file/skill/command name on one /context row
 
 ## [2.96.1] - 2026-11-06
 

package/dist/banner.js

@@ -81,11 +81,16 @@ function clip(s, max) {
  * (the terminal width minus a safety column).
  */
 export function renderStartupBanner(info, contentWidth) {
-    const title = theme.assistant('  ' + info.title) + theme.dim('  v' + info.version);
-    const dir = theme.system('  cwd: ') + theme.dir(info.workdir);
-    const prov = theme.system('  provider: ') + theme.toggleOn(info.provider);
+    // Every field is printed INSIDE the box: a newline in the working directory
+    // or in the provider label (both come from the config/environment) broke the
+    // borders apart, so each value is flattened to one line first.
+    const oneLine = (v) => String(v ?? '').replace(/\s+/g, ' ');
+    const title = theme.assistant('  ' + oneLine(info.title)) +
+        theme.dim('  v' + oneLine(info.version));
+    const dir = theme.system('  cwd: ') + theme.dir(oneLine(info.workdir));
+    const prov = theme.system('  provider: ') + theme.toggleOn(oneLine(info.provider));
     const lines = [title, dir, prov];
     if (info.hint)
-        lines.push(theme.dim('  ' + info.hint));
+        lines.push(theme.dim('  ' + oneLine(info.hint)));
     return box(lines, contentWidth);
 }

package/dist/commands.js

@@ -64,11 +64,16 @@ export function formatDiffStat(statText, opts = {}, t = translate('en')) {
 /** One renderable line per loaded context source (file + char count). */
 export function formatContextSources(agents, memory, skills, commands, opts = {}, t = translate('en')) {
     const lines = [];
+    // Paths, skill and command names come from the operator's PROJECT: a
+    // newline in one of them started a NEW row of the report (a crafted
+    // `/cmd\nFAKE` printed a bare `FAKE` line), so every value is flattened to
+    // one line first — the same rule as renderDoctor/formatJobLine.
+    const oneLine = (v) => String(v ?? '').replace(/\s+/g, ' ');
     lines.push(t('context.title'));
     if (typeof opts.systemPromptChars === 'number') {
         lines.push(t('context.system_prompt', { n: String(opts.systemPromptChars) }));
     }
-    const fileLine = (p, content) => '  ' + p + '  (' + content.length + ' chars)';
+    const fileLine = (p, content) => '  ' + oneLine(p) + '  (' + content.length + ' chars)';
     lines.push(t('context.agents'));
     if (agents.length)
         for (const a of agents)
@@ -84,13 +89,13 @@ export function formatContextSources(agents, memory, skills, commands, opts = {}
     lines.push(t('context.skills'));
     if (skills.length)
         for (const s of skills)
-            lines.push('  ' + s.name + (s.path ? '  ' + s.path : ''));
+            lines.push('  ' + oneLine(s.name) + (s.path ? '  ' + oneLine(s.path) : ''));
     else
         lines.push('  ' + t('context.none'));
     lines.push(t('context.commands'));
     if (commands.length)
         for (const c of commands)
-            lines.push('  /' + c.name);
+            lines.push('  /' + oneLine(c.name));
     else
         lines.push('  ' + t('context.none'));
     return lines.join(NL);
@@ -575,8 +580,19 @@ export function buildCompactToolResult(todos = [], goal = null) {
  * they are session state the model-written summary is not guaranteed to keep.
  */
 export function buildCompactCarryover(summary, task, todos = [], goal = null) {
-    const body = String(summary ?? '').trim();
-    const goalText = String(task ?? '').trim();
+    const NL2 = NL + NL;
+    // The carried text becomes the FIRST USER TURN of the new chat. The task is
+    // OPERATOR text and the summary is MODEL text: a line starting with `## `
+    // would fake one of the SESSION blocks this function appends itself (a todo
+    // checklist / a goal the agent never had), so such lines are indented out of
+    // the heading namespace.
+    const noHeadings = (v) => String(v ?? '')
+        .split(NL)
+        .map((l) => (/^## /.test(l) ? ' ' + l : l))
+        .join(NL)
+        .trim();
+    const body = noHeadings(summary);
+    const goalText = noHeadings(task);
     let out = 'Context carried over from a previous chat (compacted). ' +
         'Treat it as the history of our work so far and continue from the current state.';
     out += NL + NL + body;

package/dist/goal.js

@@ -29,6 +29,15 @@ export function clampGoalCondition(condition) {
 // is requested; no tools.
 export function buildEvaluatorPrompt(condition) {
     const NL = String.fromCharCode(10);
+    // The condition is OPERATOR text pasted VERBATIM. A line of it that looks
+    // like the requested answer format (`Reply with EXACTLY two lines`,
+    // `VERDICT: MET`) would let the operator's own words stand in for the
+    // judge's verdict and close an unfinished task as done: such a line is
+    // quoted instead of being left at the start of a line.
+    const safeCondition = String(condition ?? '')
+        .split(NL)
+        .map((l) => /^\s*(?:reply with|verdict\s*:|reason\s*:)/i.test(l) ? '> ' + l : l)
+        .join(NL);
     return ('You are a strict COMPLETION EVALUATOR. You do NOT do the work and you do NOT call tools. Read ' +
         'the conversation above and judge - from what the agent has ALREADY surfaced - whether ' +
         'the completion condition below is satisfied.' +
@@ -36,7 +45,7 @@ export function buildEvaluatorPrompt(condition) {
         NL +
         'Completion condition:' +
         NL +
-        condition +
+        safeCondition +
         NL +
         NL +
         'Reply with EXACTLY two lines, nothing else:' +

package/dist/info-commands.js

@@ -10,6 +10,11 @@ import { theme } from './theme.js';
  */
 export function createInfoCommands(deps) {
     const { t } = deps;
+    // A chat id comes from the page URL and the working directory from the
+    // process cwd: a newline in either would start a LINE of its own in the
+    // terminal, so a value is flattened before it is printed (the same rule
+    // `/status` and `/doctor` already follow).
+    const oneLine = (v) => String(v ?? '').replace(/\s+/g, ' ');
     const printLines = (lines, print) => {
         for (const line of lines)
             print(theme.system(line));
@@ -24,17 +29,19 @@ export function createInfoCommands(deps) {
             handler: async (ctx) => {
                 const id = deps.currentChatId();
                 if (id) {
-                    ctx.print(theme.system(t('chats.current_id', { v: id })));
-                    ctx.print(theme.system(`URL: ${deps.chatUrl(id)}`));
+                    ctx.print(theme.system(t('chats.current_id', { v: oneLine(id) })));
+                    ctx.print(theme.system(`URL: ${oneLine(deps.chatUrl(id))}`));
                     return;
                 }
                 const live = await deps.resolveChatId();
-                ctx.print(theme.system(live ? t('chats.current_id', { v: live }) : t('chats.not_created')));
+                ctx.print(theme.system(live
+                    ? t('chats.current_id', { v: oneLine(live) })
+                    : t('chats.not_created')));
             },
         },
         {
             name: 'pwd',
-            handler: (ctx) => ctx.print(theme.system(deps.workdir())),
+            handler: (ctx) => ctx.print(theme.system(oneLine(deps.workdir()))),
         },
         {
             name: 'transcript',

package/dist/limits-command.js

@@ -5,9 +5,17 @@ import { translate } from './i18n.js';
  */
 export function formatLimits(stats, opts, t = translate('en')) {
     const out = [];
+    // A counter is a count and a pause is a duration: a negative/NaN/Infinity
+    // value (a hand-edited telemetry line, a broken provider counter) must not
+    // render as `-3s` / `NaNs`, which reads like a real measurement.
+    const num = (v) => typeof v === 'number' && Number.isFinite(v) ? String(Math.max(0, v)) : '0';
     out.push({
         kind: 'title',
-        text: t('limits.title', { provider: opts.providerLabel }),
+        // The provider label comes from the config: a newline in it would start a
+        // row of its own.
+        text: t('limits.title', {
+            provider: String(opts.providerLabel ?? '').replace(/\s+/g, ' '),
+        }),
     });
     const windows = [
         ['10m', stats.last10m],
@@ -17,20 +25,20 @@ export function formatLimits(stats, opts, t = translate('en')) {
     for (const [label, n] of windows) {
         out.push({
             kind: 'window',
-            text: t('limits.window', { label, n: String(n) }),
+            text: t('limits.window', { label, n: num(n) }),
         });
     }
     out.push({
         kind: 'rate',
         text: t('limits.rate', {
-            n: String(stats.rateLimits),
-            sec: String(Math.round(stats.avgBlockMs / 1000)),
+            n: num(stats.rateLimits),
+            sec: String(Math.round(Number(num(stats.avgBlockMs)) / 1000)),
         }),
     });
     out.push({
         kind: 'interval',
         text: t('limits.interval', {
-            sec: String(Math.round(opts.intervalMs / 1000)),
+            sec: String(Math.round(Number(num(opts.intervalMs)) / 1000)),
             adaptive: opts.adaptive ? t('limits.adaptive_on') : '',
         }),
     });

package/dist/restore-history.js

@@ -260,7 +260,16 @@ export function stripThinkBlocks(text) {
     // "OK2"); the reasoning BODY was already removed with its subtree.
     // A single newline: with the blank-line form the `[\s\S]*?` below ate
     // the whole answer and the restored turn vanished.
-    t = t.replace(/^\s*(?:thought|thinking|think)\s+for\s+[^\n]*\n?/i, '');
+    // The header is `Thought for <duration>`: the FIRST word is the past tense
+    // (`Thought`) or the bare `Think`, and the duration must look like a TIME
+    // (`1 second`, `12s`, `2 minutes`). Matching any `think for <anything>`
+    // dropped a plain answer that OPENS with the same words.
+    t = t.replace(/^\s*(?:thought|thinking|think)\s+for\s+\d+(?:\.\d+)?\s*(?:seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h)(?![a-z])\b[^\n]*\n?/i, '');
+    // The DOM may hand the header WITHOUT its newline (`Thought for 1
+    // secondOK2`), so a header followed directly by the answer text is dropped
+    // too. The duration must be a real TIME word, never just `for <word>`: a
+    // plain answer opening with the same words keeps its line.
+    t = t.replace(/^\s*(?:thought|thinking|think)\s+for\s+\d+(?:\.\d+)?\s*(?:seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h)(?=[A-Z\u0410-\u042f])/i, '');
     // The DOM may hand the header WITHOUT its newline ("Thought for 1
     // secondOK2"): drop the header up to the first non-space run only when a
     // line break or the end of the text follows it.

package/dist/scheduler.js

@@ -256,6 +256,23 @@ export class Scheduler {
     due(now) {
         const fired = [];
         for (const job of this.jobs) {
+            // A NON-FINITE `nextAt` (a restored/hand-edited job, a NaN from a broken
+            // date) passed every comparison below: `NaN > now` is false, so the job
+            // was reported due on EVERY tick and the reschedule arithmetic kept it
+            // NaN forever — the busy loop the zero-interval guard exists to stop.
+            if (!Number.isFinite(job.nextAt)) {
+                if (job.kind === 'loop' && job.intervalMs && job.intervalMs > 0) {
+                    job.nextAt = now + job.intervalMs;
+                }
+                else if (job.kind === 'cron' && job.cron) {
+                    const nxt = nextCronTime(job.cron, now);
+                    job.nextAt = nxt === null ? Number.POSITIVE_INFINITY : nxt;
+                }
+                else {
+                    job.nextAt = Number.POSITIVE_INFINITY;
+                }
+                continue;
+            }
             if (job.nextAt > now)
                 continue;
             fired.push({ ...job });

package/dist/status-command.js

@@ -6,18 +6,29 @@ export function formatStatus(s, t = translate('en')) {
     const none = t('common.none');
     const onoff = (b) => (b ? t('common.on') : t('common.off'));
     const lines = [];
-    lines.push(t('status.workdir', { v: s.workdir }));
-    lines.push(t('status.review_mode', { v: s.reviewMode || no }));
+    // Every value printed here comes from the ENVIRONMENT (a working directory,
+    // a chat id) or from the config: a newline in one of them starts a status
+    // row of its own, so each value is flattened to one line — the same rule
+    // renderDoctor already applies to its cells.
+    const oneLine = (v) => String(v ?? '').replace(/\s+/g, ' ');
+    // A count must be a real number: `String(NaN)` used to print `NaN` in a row
+    // that reads like a measurement.
+    const count = (n) => typeof n === 'number' && Number.isFinite(n) && n >= 0 ? String(n) : '0';
+    const val = (v, fallback) => v ? oneLine(v) : fallback;
+    lines.push(t('status.workdir', { v: oneLine(s.workdir) }));
+    lines.push(t('status.review_mode', {
+        v: s.reviewMode ? oneLine(s.reviewMode) : no,
+    }));
     if (s.reviewMode && s.origDir) {
-        lines.push(t('status.orig_dir', { v: s.origDir }));
+        lines.push(t('status.orig_dir', { v: oneLine(s.origDir) }));
     }
-    lines.push(t('status.chat', { v: s.chatId || none }));
+    lines.push(t('status.chat', { v: val(s.chatId, none) }));
     lines.push(t('status.fresh_next', { v: s.freshNext ? yes : no }));
     lines.push(t('status.prompt_next', { v: s.promptNext ? yes : no }));
-    lines.push(t('status.last_chat', { v: s.lastChat || none }));
-    lines.push(t('status.sessions', { v: s.sessionsDir }));
+    lines.push(t('status.last_chat', { v: val(s.lastChat, none) }));
+    lines.push(t('status.sessions', { v: oneLine(s.sessionsDir) }));
     lines.push(t('status.dev', { v: s.devMode ? t('common.on') : t('common.off') }));
-    lines.push(t('status.max_iter', { v: s.maxIterations }));
+    lines.push(t('status.max_iter', { v: count(s.maxIterations) }));
     lines.push(t('status.headless', { v: s.headless ? yes : no }));
     lines.push(t('status.debug', { v: s.debug ? yes : no }));
     lines.push(t('status.toggles', {
@@ -26,27 +37,28 @@ export function formatStatus(s, t = translate('en')) {
     }));
     lines.push(t('status.undo', { v: onoff(s.undo) }));
     lines.push(t('status.checkpoint', { v: onoff(s.checkpoint) }));
-    lines.push(t('status.transcript', { v: s.transcriptFile || t('common.off') }));
-    // The GOAL is operator text (`/goal <free text>`) and a newline in it would
-    // start a new terminal line, faking another status row (`FAKE: hacked`) —
-    // one status entry must stay on one line.
-    const oneLine = (v) => String(v ?? '').replace(/\s+/g, ' ');
+    lines.push(t('status.transcript', {
+        v: s.transcriptFile ? oneLine(s.transcriptFile) : t('common.off'),
+    }));
+    // The GOAL is operator text (`/goal <free text>`): one status entry must
+    // stay on one line.
     lines.push(t('status.goal', { v: s.goal ? oneLine(s.goal) : none }));
-    lines.push(t('status.locale', { v: s.localeName }));
+    lines.push(t('status.locale', { v: oneLine(s.localeName) }));
     // A NEGATIVE tool count is nonsense (a broken MCP server status, a
-    // hand-edited value): "MCP tools: -2" reads like a real measurement, the
-    // same rule the token counter below already follows.
-    // `none` ("(none)") would claim that the tools themselves are absent;
-    // with no MCP pool configured the COUNT is simply unknown.
-    const mcpCount = s.mcpToolCount === null || s.mcpToolCount < 0
+    // hand-edited value): "MCP tools: -2" reads like a real measurement.
+    const mcpCount = s.mcpToolCount === null ||
+        !Number.isFinite(s.mcpToolCount) ||
+        s.mcpToolCount < 0
         ? t('common.unknown')
-        : s.mcpToolCount;
+        : String(s.mcpToolCount);
     lines.push(t('status.mcp', { v: mcpCount }));
     // A NEGATIVE count is nonsense (a broken provider counter): show "unknown"
     // rather than a number that reads like a real measurement.
-    const tokens = s.tokenUsage === null || s.tokenUsage < 0 ? null : s.tokenUsage;
+    const tokens = s.tokenUsage === null || !Number.isFinite(s.tokenUsage) || s.tokenUsage < 0
+        ? null
+        : s.tokenUsage;
     lines.push(t('status.tokens', {
-        v: tokens === null ? t('common.unknown') : tokens,
+        v: tokens === null ? t('common.unknown') : String(tokens),
     }));
     return lines;
 }
@@ -57,26 +69,31 @@ export function formatStatus(s, t = translate('en')) {
  */
 export function doctorProbeSummary(p) {
     const rows = [];
+    // A branch name, a missing capability id and a server/tool COUNT come from
+    // the repository and from a broken MCP probe: a newline started a row of its
+    // own and `NaN`/`-3` read like real measurements.
+    const oneLine = (v) => String(v ?? '').replace(/\s+/g, ' ');
+    const count = (n) => typeof n === 'number' && Number.isFinite(n) && n >= 0 ? n : 0;
     rows.push({
         status: p.gitOk ? 'ok' : 'warn',
-        label: p.gitOk ? 'git: ' + (p.gitBranch || 'detached') : 'git: absent',
+        label: p.gitOk
+            ? 'git: ' + oneLine(p.gitBranch || 'detached')
+            : 'git: absent',
     });
     rows.push({
         status: p.authSaved ? 'ok' : 'warn',
         label: p.authSaved ? 'auth: saved' : 'auth: not saved',
     });
+    const servers = count(p.mcpServers);
+    const tools = count(p.mcpTools);
     rows.push({
-        status: p.mcpTools > 0 ? 'ok' : 'warn',
-        label: 'mcp: ' +
-            String(p.mcpServers) +
-            ' servers / ' +
-            String(p.mcpTools) +
-            ' tools',
+        status: tools > 0 ? 'ok' : 'warn',
+        label: 'mcp: ' + String(servers) + ' servers / ' + String(tools) + ' tools',
     });
     if (p.uiMissingCritical && p.uiMissingCritical.length) {
         rows.push({
             status: 'warn',
-            label: 'ui: missing ' + p.uiMissingCritical.join(', '),
+            label: 'ui: missing ' + oneLine(p.uiMissingCritical.join(', ')),
         });
     }
     return rows;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zames_pro",
-  "version": "2.96.1",
+  "version": "2.96.3",
   "description": "Terminal coding agent that drives a real browser to chat with DeepSeek, Qwen or GLM — no API key required. Reads and edits files, runs commands, commits to git, like Claude Code / Codex CLI.",
   "type": "module",
   "bin": {