@lousy-agents/cli 5.17.11 → 5.17.12

package/api/copilot-with-fastify/.devcontainer/devcontainer.json

@@ -10,7 +10,7 @@
         },
         "ghcr.io/devcontainers/features/copilot-cli:1.0.0": {},
         "ghcr.io/anthropics/devcontainer-features/claude-code:1": {
-            "version": "v2.1.218"
+            "version": "v2.1.219"
         },
         "ghcr.io/rocker-org/devcontainer-features/apt-packages:1.0.2": {
             "packages": "yamllint, shellcheck",

package/api/copilot-with-fastify/package-lock.json

@@ -18,7 +18,7 @@
             },
             "devDependencies": {
                 "@biomejs/biome": "2.5.3",
-                "@lousy-agents/mcp": "5.17.10",
+                "@lousy-agents/mcp": "5.17.11",
                 "@modelcontextprotocol/server-sequential-thinking": "2026.7.4",
                 "@testcontainers/postgresql": "12.0.4",
                 "@types/node": "24.13.3",
@@ -972,9 +972,9 @@
             }
         },
         "node_modules/@lousy-agents/mcp": {
-            "version": "5.17.10",
-            "resolved": "https://registry.npmjs.org/@lousy-agents/mcp/-/mcp-5.17.10.tgz",
-            "integrity": "sha512-kyuOOgHi46onNnI510/L5y8REr+7Rnk4ane5z/ehtTM+7KnfHSqzWfbgxAbiOagx1tmIlISqFsZgwyFQ/g+EOQ==",
+            "version": "5.17.11",
+            "resolved": "https://registry.npmjs.org/@lousy-agents/mcp/-/mcp-5.17.11.tgz",
+            "integrity": "sha512-g88nSiJDaQ8q8rGBDMdBZmbqp1rZaqkzPT+E/zOiHy+vhupn49+MxNogBoFeEJADWJYN8zpTgDlMXQ8MGFNwgg==",
             "dev": true,
             "license": "BSD-2-Clause-Patent",
             "dependencies": {

package/api/copilot-with-fastify/package.json

@@ -29,7 +29,7 @@
     },
     "devDependencies": {
         "@biomejs/biome": "2.5.3",
-        "@lousy-agents/mcp": "5.17.10",
+        "@lousy-agents/mcp": "5.17.11",
         "@modelcontextprotocol/server-sequential-thinking": "2026.7.4",
         "@testcontainers/postgresql": "12.0.4",
         "@types/node": "24.13.3",

package/cli/copilot-with-citty/.devcontainer/devcontainer.json

@@ -10,7 +10,7 @@
         },
         "ghcr.io/devcontainers/features/copilot-cli:1.0.0": {},
         "ghcr.io/anthropics/devcontainer-features/claude-code:1": {
-            "version": "v2.1.218"
+            "version": "v2.1.219"
         },
         "ghcr.io/rocker-org/devcontainer-features/apt-packages:1.0.2": {
             "packages": "yamllint, shellcheck",

package/cli/copilot-with-citty/package.json

@@ -20,7 +20,7 @@
     },
     "devDependencies": {
         "@biomejs/biome": "2.5.3",
-        "@lousy-agents/mcp": "5.17.10",
+        "@lousy-agents/mcp": "5.17.11",
         "@modelcontextprotocol/server-sequential-thinking": "2026.7.4",
         "@types/node": "24.13.3",
         "@upstash/context7-mcp": "3.2.4",

package/dist/index.js

@@ -3032,7 +3032,7 @@ exports.basename = (path, { windows } = {}) => {
 
 
 },
-580(__unused_rspack_module, __unused_rspack___webpack_exports__, __webpack_require__) {
+9646(__unused_rspack_module, __unused_rspack___webpack_exports__, __webpack_require__) {
 // NAMESPACE OBJECT: ../../node_modules/micromark/lib/constructs.js
 var constructs_namespaceObject = {};
 __webpack_require__.r(constructs_namespaceObject);
@@ -3407,26 +3407,304 @@ function directory_guard_createNearestExistingSyncDirectoryGuard(rootReal, targe
     return directory_guard_createSyncDirectoryGuard(root);
 }
 
-;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/fsync.js
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/directory-durability.js
 
 
-async function syncDirectoryBestEffort(dirPath) {
+
+
+
+
+function directoryOpenFlags() {
     if (process.platform === "win32") {
-        return;
+        return "r";
     }
-    let handle;
+    return (external_node_fs_.constants.O_RDONLY |
+        external_node_fs_.constants.O_DIRECTORY |
+        external_node_fs_.constants.O_NOFOLLOW |
+        external_node_fs_.constants.O_NONBLOCK);
+}
+function isWindowsDirectorySyncUnsupported(error) {
+    if (process.platform !== "win32") {
+        return false;
+    }
+    const code = error.code;
+    return (code === "EACCES" ||
+        code === "EINVAL" ||
+        code === "EISDIR" ||
+        code === "ENOSYS" ||
+        code === "ENOTSUP" ||
+        code === "EPERM");
+}
+function isWindowsDirectoryOpenUnsupported(error) {
+    if (process.platform !== "win32") {
+        return false;
+    }
+    const code = error.code;
+    return code === "EINVAL" || code === "EISDIR" || code === "ENOSYS" || code === "ENOTSUP";
+}
+function unsupportedOutcome(error) {
+    const code = error.code;
+    return code ? { status: "unsupported", code } : { status: "unsupported" };
+}
+function assertDirectory(identity, pathname, label) {
+    if (identity.isSymbolicLink() || !identity.isDirectory()) {
+        throw new errors_FsSafeError("not-file", `${label} must be a real directory: ${pathname}`);
+    }
+}
+async function createDirectoryReceipt(directoryPath, label) {
+    const resolvedPath = external_node_path_.resolve(directoryPath);
+    const identity = await promises_.lstat(resolvedPath);
+    assertDirectory(identity, resolvedPath, label);
+    return {
+        path: resolvedPath,
+        realPath: await promises_.realpath(resolvedPath),
+        identity,
+    };
+}
+function createDirectoryReceiptSync(directoryPath, label) {
+    const resolvedPath = path.resolve(directoryPath);
+    const identity = fsSync.lstatSync(resolvedPath);
+    assertDirectory(identity, resolvedPath, label);
+    return {
+        path: resolvedPath,
+        realPath: fsSync.realpathSync(resolvedPath),
+        identity,
+    };
+}
+async function assertDirectoryReceiptCurrent(receipt, label) {
+    const currentIdentity = await promises_.lstat(receipt.path);
+    assertDirectory(currentIdentity, receipt.path, label);
+    if (!file_identity_sameFileIdentity(receipt.identity, currentIdentity) ||
+        (await promises_.realpath(receipt.path)) !== receipt.realPath) {
+        throw new errors_FsSafeError("path-mismatch", `${label} changed during durable directory operation: ${receipt.path}`);
+    }
+}
+function assertDirectoryReceiptCurrentSync(receipt, label) {
+    const currentIdentity = fsSync.lstatSync(receipt.path);
+    assertDirectory(currentIdentity, receipt.path, label);
+    if (!sameFileIdentity(receipt.identity, currentIdentity) ||
+        fsSync.realpathSync(receipt.path) !== receipt.realPath) {
+        throw new FsSafeError("path-mismatch", `${label} changed during durable directory operation: ${receipt.path}`);
+    }
+}
+async function assertOpenDirectoryCurrent(handle, receipt, label) {
+    const openedIdentity = await handle.stat();
+    assertDirectory(openedIdentity, receipt.path, label);
+    if (!file_identity_sameFileIdentity(receipt.identity, openedIdentity)) {
+        throw new errors_FsSafeError("path-mismatch", `${label} handle changed during directory sync: ${receipt.path}`);
+    }
+    await assertDirectoryReceiptCurrent(receipt, label);
+}
+class PinnedDirectoryImpl {
+    receipt;
+    #handle;
+    #label;
+    #closed = false;
+    constructor(handle, receipt, label) {
+        this.#handle = handle;
+        this.receipt = receipt;
+        this.#label = label;
+    }
+    async assertCurrent() {
+        if (this.#closed) {
+            throw new errors_FsSafeError("helper-failed", `${this.#label} pin is already closed`);
+        }
+        await assertOpenDirectoryCurrent(this.#handle, this.receipt, this.#label);
+    }
+    async sync() {
+        await this.assertCurrent();
+        try {
+            await this.#handle.sync();
+        }
+        catch (error) {
+            if (!isWindowsDirectorySyncUnsupported(error)) {
+                throw error;
+            }
+            await this.assertCurrent();
+            return unsupportedOutcome(error);
+        }
+        await this.assertCurrent();
+        return { status: "synced" };
+    }
+    async close() {
+        if (this.#closed) {
+            return;
+        }
+        this.#closed = true;
+        await this.#handle.close();
+    }
+}
+async function pinDirectory(directory, options = {}) {
+    const label = options.label ?? "directory";
+    const receipt = typeof directory === "string" ? await createDirectoryReceipt(directory, label) : directory;
+    await assertDirectoryReceiptCurrent(receipt, label);
+    const handle = await promises_.open(receipt.path, directoryOpenFlags());
     try {
-        const flags = external_node_fs_.constants.O_RDONLY |
-            ("O_DIRECTORY" in external_node_fs_.constants ? external_node_fs_.constants.O_DIRECTORY : 0) |
-            ("O_NOFOLLOW" in external_node_fs_.constants ? external_node_fs_.constants.O_NOFOLLOW : 0);
-        handle = await promises_.open(dirPath, flags);
-        await handle.sync();
+        await assertOpenDirectoryCurrent(handle, receipt, label);
+        return new PinnedDirectoryImpl(handle, receipt, label);
+    }
+    catch (error) {
+        await handle.close().catch(() => undefined);
+        throw error;
+    }
+}
+async function syncDirectory(directory, options = {}) {
+    const label = options.label ?? "directory";
+    const receipt = typeof directory === "string" ? await createDirectoryReceipt(directory, label) : directory;
+    let pinned;
+    try {
+        pinned = await pinDirectory(receipt, { label });
+    }
+    catch (error) {
+        if (!isWindowsDirectoryOpenUnsupported(error)) {
+            throw error;
+        }
+        await assertDirectoryReceiptCurrent(receipt, label);
+        return unsupportedOutcome(error);
+    }
+    try {
+        return await pinned.sync();
+    }
+    finally {
+        await pinned.close();
+    }
+}
+function syncDirectorySync(directory, options = {}) {
+    const label = options.label ?? "directory";
+    const receipt = typeof directory === "string" ? createDirectoryReceiptSync(directory, label) : directory;
+    assertDirectoryReceiptCurrentSync(receipt, label);
+    let descriptor;
+    try {
+        descriptor = fsSync.openSync(receipt.path, directoryOpenFlags());
+    }
+    catch (error) {
+        if (!isWindowsDirectoryOpenUnsupported(error)) {
+            throw error;
+        }
+        assertDirectoryReceiptCurrentSync(receipt, label);
+        return unsupportedOutcome(error);
+    }
+    try {
+        const openedIdentity = fsSync.fstatSync(descriptor);
+        assertDirectory(openedIdentity, receipt.path, label);
+        if (!sameFileIdentity(receipt.identity, openedIdentity)) {
+            throw new FsSafeError("path-mismatch", `${label} handle changed during directory sync: ${receipt.path}`);
+        }
+        assertDirectoryReceiptCurrentSync(receipt, label);
+        try {
+            fsSync.fsyncSync(descriptor);
+        }
+        catch (error) {
+            if (!isWindowsDirectorySyncUnsupported(error)) {
+                throw error;
+            }
+            assertDirectoryReceiptCurrentSync(receipt, label);
+            return unsupportedOutcome(error);
+        }
+        assertDirectoryReceiptCurrentSync(receipt, label);
+        return { status: "synced" };
+    }
+    finally {
+        fsSync.closeSync(descriptor);
+    }
+}
+async function syncDirectoryBestEffort(directoryPath) {
+    await syncDirectory(directoryPath).catch(() => undefined);
+}
+function syncDirectoryBestEffortSync(directoryPath) {
+    try {
+        syncDirectorySync(directoryPath);
     }
     catch {
-        // Some filesystems reject directory handles; keep the write usable there.
+        // Compatibility helper for operations whose primary write may remain usable.
+    }
+}
+async function findExistingAncestorReceipt(targetPath, label) {
+    let currentPath = path.resolve(targetPath);
+    while (true) {
+        try {
+            return await createDirectoryReceipt(currentPath, label);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT") {
+                throw error;
+            }
+        }
+        const parentPath = path.dirname(currentPath);
+        if (parentPath === currentPath) {
+            throw new FsSafeError("not-found", `${label} has no existing directory ancestor`);
+        }
+        currentPath = parentPath;
+    }
+}
+async function ensureDurableDirectory(options) {
+    const directoryPath = path.resolve(options.directoryPath);
+    const label = options.label ?? "directory";
+    const ancestorReceipt = await findExistingAncestorReceipt(directoryPath, label);
+    const targetExists = ancestorReceipt.path === directoryPath;
+    if (options.expectedExistingIdentity &&
+        (!targetExists || !sameFileIdentity(options.expectedExistingIdentity, ancestorReceipt.identity))) {
+        throw new FsSafeError("path-mismatch", `${label} changed before durable directory pinning: ${directoryPath}`);
+    }
+    const ancestor = await pinDirectory(ancestorReceipt, { label });
+    const pinnedDirectories = [ancestor];
+    try {
+        await ancestor.assertCurrent();
+        if (!targetExists) {
+            if (options.create) {
+                await options.create(directoryPath);
+            }
+            else {
+                const created = await ensureAbsoluteDirectory(directoryPath, {
+                    mode: options.mode,
+                    scopeLabel: label,
+                });
+                if (!created.ok) {
+                    throw created.error;
+                }
+            }
+        }
+        await ancestor.assertCurrent();
+        let currentPath = ancestor.receipt.path;
+        for (const segment of path
+            .relative(ancestor.receipt.path, directoryPath)
+            .split(path.sep)
+            .filter(Boolean)) {
+            currentPath = path.join(currentPath, segment);
+            pinnedDirectories.push(await pinDirectory(currentPath, { label }));
+        }
+        let parentSync = { status: "not-needed" };
+        for (let index = pinnedDirectories.length - 1; index > 0; index -= 1) {
+            const parent = pinnedDirectories[index - 1];
+            const child = pinnedDirectories[index];
+            if (!parent || !child) {
+                throw new FsSafeError("helper-failed", `${label} directory pin chain is incomplete`);
+            }
+            await child.assertCurrent();
+            try {
+                const outcome = await parent.sync();
+                if (outcome.status === "unsupported") {
+                    parentSync = outcome;
+                }
+                else if (parentSync.status === "not-needed") {
+                    parentSync = outcome;
+                }
+            }
+            catch (error) {
+                throw new FsSafeError("helper-failed", `${label} could not sync created directory edge ${child.receipt.path} through ${parent.receipt.path}`, { cause: error });
+            }
+            await child.assertCurrent();
+        }
+        const finalReceipt = pinnedDirectories.at(-1)?.receipt;
+        if (!finalReceipt) {
+            throw new FsSafeError("helper-failed", `${label} directory receipt is missing`);
+        }
+        await ancestor.assertCurrent();
+        await assertDirectoryReceiptCurrent(finalReceipt, label);
+        return { ...finalReceipt, parentSync };
     }
     finally {
-        await handle?.close().catch(() => undefined);
+        await Promise.all(pinnedDirectories.toReversed().map(async (directory) => directory.close()));
     }
 }
 
@@ -62334,4 +62612,4 @@ if (installedChunkData !== 0) { // 0 means "already installed".'
 // module factories are used so entry inlining is disabled
 // startup
 // Load entry module and return exports
-var __webpack_exports__ = __webpack_require__(580);
+var __webpack_exports__ = __webpack_require__(9646);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@lousy-agents/cli",
-    "version": "5.17.11",
+    "version": "5.17.12",
     "description": "CLI scaffolding tool that sets up projects with structure, instructions, and feedback loops for AI coding assistants",
     "type": "module",
     "repository": {

package/ui/copilot-with-react/.devcontainer/devcontainer.json

@@ -10,7 +10,7 @@
         },
         "ghcr.io/devcontainers/features/copilot-cli:1.0.0": {},
         "ghcr.io/anthropics/devcontainer-features/claude-code:1": {
-            "version": "v2.1.218"
+            "version": "v2.1.219"
         },
         "ghcr.io/rocker-org/devcontainer-features/apt-packages:1.0.2": {
             "packages": "libnss3, libnspr4, libatk1.0-0t64, libatk-bridge2.0-0t64, libcups2t64, libdrm2, libdbus-1-3, libatspi2.0-0t64, libxcomposite1, libxdamage1, libxfixes3, libxrandr2, libgbm1, libxkbcommon0, libasound2t64, yamllint, shellcheck",

package/ui/copilot-with-react/package.json

@@ -23,7 +23,7 @@
     "devDependencies": {
         "@biomejs/biome": "2.5.3",
         "@eslint/eslintrc": "3.3.6",
-        "@lousy-agents/mcp": "5.17.10",
+        "@lousy-agents/mcp": "5.17.11",
         "@modelcontextprotocol/server-sequential-thinking": "2026.7.4",
         "@testing-library/jest-dom": "7.0.0",
         "@testing-library/react": "16.3.2",
@@ -33,7 +33,7 @@
         "@upstash/context7-mcp": "3.2.4",
         "@vitejs/plugin-react": "6.0.4",
         "@vitest/ui": "4.1.10",
-        "eslint": "10.7.0",
+        "eslint": "10.8.0",
         "eslint-config-next": "16.2.11",
         "happy-dom": "20.11.1",
         "jsdom": "29.1.1",