zames_pro 2.96.0 → 2.96.1

package/CHANGELOG.md

@@ -7,6 +7,24 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### 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)
+
+## [2.96.1] - 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)
+
 ## [2.96.0] - 2026-11-05
 
 ### Added

package/dist/backlog.js

@@ -191,8 +191,25 @@ export function appendBacklogItem(text, item) {
     }
     const lines = src.split(NL);
     const headerRe = new RegExp('^##[ ]+' + prio + '(?![0-9])');
+    // A fenced code block is MARKDOWN, not structure: a note that documents the
+    // file format contains `## P1` inside ```…```, and treating it as a section
+    // header inserted the new item INTO that fence (parseBacklogItems skips
+    // fenced headings, so the item then became invisible to /improve). Track the
+    // fence exactly like the parser does.
+    let fence = '';
     let at = -1;
     for (let i = 0; i < lines.length; i++) {
+        const fm = /^\s*(`{3,}|~{3,})/.exec(lines[i]);
+        if (fm) {
+            const mark = fm[1][0];
+            if (!fence)
+                fence = mark;
+            else if (mark === fence)
+                fence = '';
+            continue;
+        }
+        if (fence)
+            continue;
         if (headerRe.test(lines[i])) {
             // Insert right after the header and any blank lines that follow it, so
             // the newest note sits at the top of its priority block.

package/dist/changelog.js

@@ -91,31 +91,29 @@ export function syncUnreleased(changelog, body) {
     const rest = changelog.slice(afterAnchor);
     const next = rest.search(/\n## \[/);
     const tail = next < 0 ? '' : rest.slice(next);
-    const cleanBody = String(body || '')
+    // A `## ` that does not START a line is FREE TEXT inside a bullet (a commit
+    // description that documents a markdown heading, `ignore a ## P<n> header`).
+    // Matching it ANYWHERE treated that text as a group heading: the bullet was
+    // split and a FAKE `### P<n>` section appeared in the file. Every group
+    // heading is therefore recognized on WHOLE LINES only.
+    const lines = String(body || '')
         .replace(/^## \[Unreleased\]\s*/m, '')
-        // A drafted group heading must START a line of its own. When the draft
-        // carries several groups (`## Added` … `## Fixed`) without a blank line
-        // between them, the next group used to stay glued to the last bullet
-        // (`- a### Fixed`) — it was not a heading at all, so the item vanished
-        // from the rendered changelog. The lookahead is what keeps a CONTINUATION
-        // line of a multi-line bullet in place: gluing on `\n` as well joined the
-        // indent line to the next bullet and truncated the note.
-        // The draft's groups are still `## ` at this point (they become `### `
-        // below), and the FIRST group is already preceded by the blank line of
-        // the draft — so a group always starts a line, and this rule only has to
-        // punch in the missing blank line after a bullet.
-        .replace(/([^\n])(?=## )/g, '$1' + nl + nl)
-        .trim()
-        // The draft renders groups as `## Added` (top-level), but INSIDE the file
-        // a version's groups are `### Added` (a subsection of the version heading).
-        // `## [` (the next version) is left alone. The FIRST group follows the
-        // version heading directly (no bullet before it), so the blank-line rule
-        // above never fired for it — `## [Unreleased]` came out as a bare `#`
-        // followed by `# Added`. The heading owns a blank line, always.
+        .split(nl);
+    const out = [];
+    for (const line of lines) {
+        // A heading glued to the previous bullet (`- one## Added`) does not render
+        // as a heading at all: break it onto its own line, keeping the bullet.
+        const glued = /^(?!#)(\S.*[^\s`])(## .*)$/.exec(line);
+        if (glued)
+            out.push(glued[1], '', glued[2]);
+        else
+            out.push(line);
+    }
+    const cleanBody = out
+        .join(nl)
         .replace(/^## (?!\[)/gm, '### ')
-        // One blank line between the version heading and its first group, not
-        // the three the rules above can stack up.
-        .replace(/^\n+(?=### )/gm, '');
+        .replace(/^\n+(?=### )/, '')
+        .trim();
     const section = cleanBody ? nl + nl + cleanBody + nl : nl;
     return changelog.slice(0, afterAnchor) + section + tail;
 }

package/dist/dev-watch.js

@@ -28,6 +28,12 @@ export const HOT_RELOADABLE = new Set([
     'config',
     'fsutil',
     'backlog',
+    // index.ts reloads these too; leaving them out of THIS list made the dev
+    // watcher report a false "restart zames" warning on every edit to them.
+    'restore-history',
+    // A NESTED module: only its basename is known here, which is what the
+    // watcher compares (src/input/layout.ts).
+    'layout',
     'commands',
     'run-task',
     'attach-refs',

package/dist/release-policy.js

@@ -67,9 +67,13 @@ function kindsOf(list) {
 }
 function breakingNote(list) {
     const first = list[0];
+    // One pair of parentheses around the WHOLE label: the scope used to close
+    // its own paren (`(cli): x)`) and leave a stray `)` in the operator report.
+    const label = first.scope
+        ? first.scope + ': ' + first.description
+        : first.description;
     return ('a BREAKING change (' +
-        (first.scope ? first.scope + '): ' : '') +
-        first.description +
+        label +
         ') must be released by the operator, not by an unattended /loop');
 }
 /**

package/dist/shell.js

@@ -88,13 +88,20 @@ export function assertCommandInsideRoot(root, command) {
             const raw = w.replace(/["']/g, '');
             if (!raw)
                 continue;
-            if (raw === '/' ||
-                raw === '.' ||
-                raw === '..' ||
-                raw === '~' ||
-                raw.startsWith('~/') ||
-                raw.startsWith('/') ||
-                raw.startsWith('..')) {
+            // A shell NORMALIZES a trailing separator before running the command:
+            // `rm -rf ./` and `rm -rf ../` delete the project root and its parent,
+            // but the raw word is neither `.` nor `..`, so the checks below let it
+            // through. Compare without the trailing slashes (a bare `//` is the
+            // root on POSIX and must stay one).
+            const norm = raw.replace(/\/+$/, '');
+            const bare = norm === '' ? raw.charAt(0) : norm;
+            if (bare === '/' ||
+                bare === '.' ||
+                bare === '..' ||
+                bare === '~' ||
+                bare.startsWith('~/') ||
+                bare.startsWith('/') ||
+                bare.startsWith('..')) {
                 throw new Error('Sandbox: recursive rm of an absolute/outside path is forbidden (' +
                     raw +
                     ')');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zames_pro",
-  "version": "2.96.0",
+  "version": "2.96.1",
   "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": {