dsh-root-planner-preset 1.1.0 → 1.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-root-planner-preset",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "type": "module",
   "description": "DSH agent preset that outsources file reading to strictly read-only subagents, while the root agent keeps the plan and owns every file mutation.",
   "license": "MIT",

package/tools/extract-tool-inventory.mjs

@@ -0,0 +1,65 @@
+// Extracts the runtime's own global-tool inventory from a session log.
+//
+// `tools.restrict()` prints every known global tool when it refuses a name, so a
+// session that hit `names unknown global tool` carries the authoritative list for
+// its own environment. That list is what the child mask has to be a subset of, and
+// it is the only trustworthy source — a mask built from memory breaks every child
+// creation, which is exactly what happened twice in this repository.
+//
+// Usage: node tools/extract-tool-inventory.mjs <session.jsonl.zstd> [...]
+
+import { readFileSync } from 'node:fs';
+import { createZstdDecompress } from 'node:zlib';
+
+/** Locate the end of the first zstd frame, where the next one begins. */
+function firstFrameEnd(buf) {
+  for (let i = 4; i + 4 <= buf.length; i += 1) {
+    if (buf[i] === 0x28 && buf[i + 1] === 0xb5 && buf[i + 2] === 0x2f && buf[i + 3] === 0xfd) return i;
+  }
+  return buf.length;
+}
+
+/**
+ * Decompress a concatenated-zstd log frame by frame. A single decompress call
+ * stops at the first frame, which is why a naive read of these logs returns a few
+ * hundred bytes out of tens of kilobytes and hides every event.
+ * @param {string} path - the .jsonl.zstd log.
+ * @returns {Promise<string>} the whole decompressed text.
+ */
+async function decompressAll(path) {
+  let rest = readFileSync(path);
+  let text = '';
+  while (rest.length > 0) {
+    const slice = rest.subarray(0, firstFrameEnd(rest));
+    try {
+      text += await new Promise((resolve, reject) => {
+        const chunks = [];
+        const decoder = createZstdDecompress();
+        decoder.on('data', (chunk) => chunks.push(chunk));
+        decoder.on('error', reject);
+        decoder.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
+        decoder.end(slice);
+      });
+    } catch {
+      break;
+    }
+    if (slice.length >= rest.length) break;
+    rest = rest.subarray(slice.length);
+  }
+  return text;
+}
+
+for (const path of process.argv.slice(2)) {
+  const text = await decompressAll(path);
+  const match = /known global tools: ([^"\\\]]+)/.exec(text);
+  process.stdout.write(`\n=== ${path.split(/[\\/]/).pop()} (${text.length} chars decompressed) ===\n`);
+  if (match === null) {
+    process.stdout.write(`no inventory line found. mentions "unknown global tool": ${text.includes('unknown global tool')}\n`);
+    continue;
+  }
+  const tools = match[1]
+    .split(',')
+    .map((name) => name.trim())
+    .filter(Boolean);
+  process.stdout.write(`${tools.length} global tools:\n  ${tools.join('\n  ')}\n`);
+}

package/tools/verify-session.mjs

@@ -17,42 +17,45 @@ import { readdirSync, readFileSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { createZstdDecompress } from 'node:zlib';
 
+/** Locate the end of the first zstd frame, where the next one begins. */
+function frameBytes(buf) {
+  for (let i = 4; i + 4 <= buf.length; i += 1) {
+    if (buf[i] === 0x28 && buf[i + 1] === 0xb5 && buf[i + 2] === 0x2f && buf[i + 3] === 0xfd) return i;
+  }
+  return buf.length;
+}
+
 /**
- * Decompress a concatenated-zstd file. The session logs are appended frame by
- * frame, and a single decompress call stops at the first frame — which yields a
- * 300-byte file out of an 85 KB one and silently hides every event.
+ * Decompress a concatenated-zstd file frame by frame.
+ *
+ * A single decompress call stops at the first frame, which is why a naive read of
+ * these logs returns 323 bytes out of 139 KB and silently hides every event.
+ * Measured on a real log: frame-by-frame reads 143 654 characters where one call
+ * read 323.
  * @param {Buffer} buf - whole file.
  * @returns {Promise<string>} the complete decompressed text.
  */
 async function decompressAll(buf) {
-  const out = [];
   let rest = buf;
-  for (;;) {
-    const text = await new Promise((resolve, reject) => {
-      const chunks = [];
-      const dec = createZstdDecompress();
-      dec.on('data', (chunk) => chunks.push(chunk));
-      dec.on('error', reject);
-      dec.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
-      dec.end(rest);
-    });
-    if (text.length === 0) break;
-    out.push(text);
-    // Each frame's decompressed size is not exposed; feed the remainder in and let
-    // the next frame fail once the buffer is exhausted.
-    const consumed = frameBytes(rest, text.length);
-    if (consumed === undefined || consumed >= rest.length) break;
-    rest = rest.subarray(consumed);
-  }
-  return out.join('');
-}
-
-/** Locate the end of the first zstd frame by magic-number scanning. */
-function frameBytes(buf, ) {
-  for (let i = 4; i + 4 <= buf.length; i += 1) {
-    if (buf[i] === 0x28 && buf[i + 1] === 0xb5 && buf[i + 2] === 0x2f && buf[i + 3] === 0xfd) return i;
+  let text = '';
+  while (rest.length > 0) {
+    const slice = rest.subarray(0, frameBytes(rest));
+    try {
+      text += await new Promise((resolve, reject) => {
+        const chunks = [];
+        const dec = createZstdDecompress();
+        dec.on('data', (chunk) => chunks.push(chunk));
+        dec.on('error', reject);
+        dec.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
+        dec.end(slice);
+      });
+    } catch {
+      break;
+    }
+    if (slice.length >= rest.length) break;
+    rest = rest.subarray(slice.length);
   }
-  return undefined;
+  return text;
 }
 
 /** Read one session directory into {header, events}. */
@@ -86,6 +89,7 @@ const base = join(rootDir, '..');
 const root = await readSession(rootDir);
 
 const sessions = [{ dir: rootDir, ...root }];
+const candidates = [];
 for (const name of readdirSync(base)) {
   if (name === rootDir.split(/[\\/]/).pop()) continue;
   const candidate = join(base, name);
@@ -96,10 +100,31 @@ for (const name of readdirSync(base)) {
   }
   const session = await readSession(candidate);
   // Only real children count. Sibling ROOT sessions of other conversations live in
-  // the same directory and have no parentSession — including them made the report
-  // claim the run failed when it had not.
+  // the same directory and have no parentSession — including them made this report
+  // claim a run had failed when it had not.
   if (session.header?.origin !== 'subagent') continue;
-  sessions.push({ dir: candidate, ...session });
+  candidates.push({ dir: candidate, ...session });
+}
+
+/**
+ * Keep only the root's real descendants. Other presets delegate too, and their
+ * subagent sessions sit in the same directory; without this walk they appear as
+ * children of this run and fail the preset check for the wrong reason.
+ */
+const rootId = root.header?.id;
+const childrenOf = new Map();
+for (const session of candidates) {
+  const parent = session.header?.parentSession;
+  if (parent === undefined) continue;
+  const list = childrenOf.get(parent) ?? [];
+  list.push(session);
+  childrenOf.set(parent, list);
+}
+const queue = [...(childrenOf.get(rootId) ?? [])];
+while (queue.length > 0) {
+  const session = queue.shift();
+  sessions.push(session);
+  queue.push(...(childrenOf.get(session.header?.id) ?? []));
 }
 
 const failures = [];