chainlesschain 0.162.71 → 0.162.73

package/src/commands/loop.js

@@ -73,20 +73,26 @@ function spawnIteration(cmd, args, { shell, onChild, capture }) {
     });
     if (onChild) onChild(child);
 
-    let output = "";
+    const outChunks = [];
     if (capture) {
       child.stdout?.on("data", (d) => {
-        output += d;
+        outChunks.push(d);
         process.stdout.write(d);
       });
       child.stderr?.on("data", (d) => {
-        output += d;
+        outChunks.push(d);
         process.stderr.write(d);
       });
     }
 
     // `close` (not `exit`) so piped stdio is fully drained before we resolve.
     child.on("close", (code, signal) => {
+      // Decode the captured bytes once, at the end. Accumulating with
+      // `output += chunk` would decode each stdout chunk independently, so a
+      // multi-byte UTF-8 character split across a chunk boundary corrupts the
+      // captured string that `--until <regex>` / `--dynamic` directive parsing
+      // reads. (The raw passthrough writes above are unaffected.)
+      const output = Buffer.concat(outChunks).toString("utf-8");
       resolve({ exitCode: code == null ? null : code, output, signal });
     });
     child.on("error", (err) => {

package/src/commands/memory.js

@@ -63,9 +63,8 @@ export function registerMemoryCommand(program) {
     .option("--json", "Output as JSON")
     .action(async (options) => {
       try {
-        const { loadProjectInstructions } = await import(
-          "../lib/project-instructions.js"
-        );
+        const { loadProjectInstructions } =
+          await import("../lib/project-instructions.js");
         const cwd = options.cwd || process.cwd();
         const loaded = loadProjectInstructions({ cwd });
         if (options.json) {
@@ -519,7 +518,10 @@ export function registerMemoryCommand(program) {
 
         if (options.edit) {
           const { execSync } = await import("child_process");
-          const editor = process.env.EDITOR || process.env.VISUAL || "nano";
+          const editor =
+            process.env.EDITOR ||
+            process.env.VISUAL ||
+            (process.platform === "win32" ? "notepad" : "nano");
           const filePath = `${memoryDir}/MEMORY.md`;
           try {
             execSync(`${editor} "${filePath}"`, { stdio: "inherit" });

package/src/commands/orchestrate.js

@@ -521,9 +521,12 @@ async function _webhookMode(cwd, options) {
       return;
     }
 
-    let body = "";
-    req.on("data", (chunk) => (body += chunk.toString("utf8")));
+    const bodyChunks = [];
+    req.on("data", (chunk) => bodyChunks.push(chunk));
     req.on("end", async () => {
+      // Decode once: per-chunk toString() would corrupt a multi-byte UTF-8
+      // char (e.g. Chinese IM webhook text) split across a chunk boundary.
+      const body = Buffer.concat(bodyChunks).toString("utf-8");
       let taskText = null;
       let source = TASK_SOURCE.CLI;
 

package/src/commands/video.js

@@ -281,6 +281,7 @@ export function registerVideoCommand(program) {
     .action(async (action, options) => {
       const { promises: fs } = await import("fs");
       const pathMod = await import("path");
+      const osMod = await import("os");
 
       const base = process.env.APPDATA
         ? pathMod.join(
@@ -290,7 +291,10 @@ export function registerVideoCommand(program) {
             "video-editing",
           )
         : pathMod.join(
-            process.env.HOME || "~",
+            // os.homedir() resolves the real home on every platform; the old
+            // `process.env.HOME || "~"` left a literal "~" on Windows (HOME
+            // often unset there) which fs can't resolve.
+            osMod.homedir(),
             ".chainlesschain",
             "video-editing",
           );

package/src/lib/agents.js

@@ -21,6 +21,7 @@ import fsDefault from "node:fs";
 import pathDefault from "node:path";
 import { homedir } from "node:os";
 import yaml from "js-yaml";
+import { projectRootBase } from "./project-root.cjs";
 
 const _deps = { fs: fsDefault, path: pathDefault };
 
@@ -46,26 +47,36 @@ function parseFrontmatter(content) {
 /** Normalize `tools` (comma string | array | null) into a string[] or null. */
 export function normalizeTools(tools) {
   if (tools == null) return null;
-  const list = Array.isArray(tools)
-    ? tools
-    : String(tools).split(/[,\s]+/);
+  const list = Array.isArray(tools) ? tools : String(tools).split(/[,\s]+/);
   const out = list.map((t) => String(t).trim()).filter(Boolean);
   return out.length > 0 ? out : null;
 }
 
 /** Directories scanned for agent files — project first (shadows personal). */
 export function agentDirs(cwd = process.cwd(), opts = {}) {
+  const fs = opts.deps?.fs || _deps.fs;
   const path = opts.deps?.path || _deps.path;
   const home = opts.home || homedir();
   // Project-native first (highest precedence), then the Claude-Code-portable
   // location (so existing `.claude/agents/*.md` work unchanged), then personal.
   // discoverAgents reverses + last-write-wins, so `.chainlesschain/agents/`
   // shadows `.claude/agents/` shadows `~/.claude/agents/` on a name clash.
-  return [
+  const dirs = [
     { dir: path.join(cwd, ".chainlesschain", "agents"), scope: "project" },
     { dir: path.join(cwd, ".claude", "agents"), scope: "project" },
-    { dir: path.join(home, ".claude", "agents"), scope: "personal" },
   ];
+  // Subdirectory run: also scan the project-root `.claude` (cwd stays closest
+  // and wins on a name clash through the reverse + last-write-wins below).
+  const root = projectRootBase(cwd, { fs, path });
+  if (root) {
+    dirs.push({
+      dir: path.join(root, ".chainlesschain", "agents"),
+      scope: "project",
+    });
+    dirs.push({ dir: path.join(root, ".claude", "agents"), scope: "project" });
+  }
+  dirs.push({ dir: path.join(home, ".claude", "agents"), scope: "personal" });
+  return dirs;
 }
 
 /** Recursively collect `*.md` files under `dir` as `{file, rel}` (rel uses /). */