@lmzhen/dsh-evolution-commands 0.3.22 → 0.3.24

package/lib/index.js

@@ -23,7 +23,7 @@ function apply(ctx, rawConfig = {}) {
 			name: "evolution",
 			description: "Self-evolution status and approval controls",
 			recordInput: false,
-			input: { hint: "pending | approve <id> | reject <id> | curator run|pause|resume|status|report|scope | mutations | restore | consolidate <target> <sources...> | skill restore <name> | skills health | skills refresh | learn [request] | maintain [--timeout ms | --facts] | preset install | restructure <name> \"<heading>\" <to_file> | replay" },
+			input: { hint: "pending [--detail] | approve <id> | reject <id> | curator run|pause|resume|status|report|scope | mutations | restore | consolidate <target> <sources...> | skill restore <name> | skills health | skills refresh | learn [request] | maintain [--timeout ms | --facts] | preset install | restructure <name> \"<heading>\" <to_file> | replay" },
 			async handler(invocation) {
 				const input = invocation.rawInput?.trim() ?? "";
 				const ok = (text) => ({
@@ -35,10 +35,17 @@ function apply(ctx, rawConfig = {}) {
 					text
 				});
 				const approval = ctx.get("evolutionApproval");
-				if (input === "pending") {
+				const pendingMatch = /^pending(?: --detail)?$/.exec(input);
+				if (pendingMatch) {
 					const pending = approval ? [...await approval.list("pending"), ...await approval.list("executing")] : [];
 					if (pending.length === 0) return ok("No pending evolution writes.");
-					return ok(pending.map((p) => `${p.id}  ${p.kind}  ${p.status === "executing" ? "EXECUTING " : ""}${p.summary}`).join("\n") + (pending.some((p) => p.status === "executing") ? "\n(EXECUTING: a previous approve may have crashed after running; verify the write manually, then reject — approve will not re-run it)" : ""));
+					const detailed = pendingMatch[0] === "pending --detail";
+					return ok(pending.map((p) => {
+						if (!detailed) return `${p.id}  ${p.kind}  ${p.status === "executing" ? "EXECUTING " : ""}${p.summary}`;
+						const status = p.status === "executing" ? "EXECUTING" : p.status;
+						const line = `${p.id}  ${p.kind}  ${status}  ${p.summary}`;
+						return p.args === void 0 ? line : `${line}\n  staged args: ${safeStagedArgs(p.args)}`;
+					}).join("\n") + (pending.some((p) => p.status === "executing") ? "\n(EXECUTING: a previous approve may have crashed after running; verify the write manually, then reject — approve will not re-run it)" : ""));
 				}
 				if (input.startsWith("approve ")) {
 					const id = input.slice(8).trim();
@@ -218,7 +225,10 @@ function apply(ctx, rawConfig = {}) {
 							library,
 							subagents,
 							parent: invocation.agent,
-							evolutionPolicy: { get: () => ctx.get("evolutionPolicy")?.get() }
+							evolutionPolicy: { get: () => ctx.get("evolutionPolicy")?.get() },
+							logger: { warn: (message) => {
+								ctx.logger.warn(message);
+							} }
 						}, {
 							timeoutMs: runTimeoutMs,
 							descriptions: () => enrichment.descriptions,
@@ -319,33 +329,67 @@ function resolveAgentPresetDir(importMetaUrl) {
 		return siblingCandidate;
 	}
 }
+const defaultFs = {
+	writeFileSync: (path, data) => {
+		writeFileSync(path, data);
+	},
+	existsSync: (path) => existsSync(path),
+	copyFileSync: (from, to) => {
+		copyFileSync(from, to);
+	},
+	renameSync: (from, to) => {
+		renameSync(from, to);
+	},
+	rmSync: (path, options) => {
+		rmSync(path, options);
+	}
+};
 /**
 * S6.3 (E-40): atomically replace a set of files within one directory.
 * Each file is staged to a sibling `<name>.tmp`, then renamed into place
 * (atomic on the same filesystem); a pre-existing file keeps a single
 * `<name>.bak`. A failure at ANY staging step removes the staged temps and
-* leaves the previous files untouched — a half-written target is impossible.
+* leaves the previous files untouched — a half-written target is impossible
+* up to the staging and backup phases.
+*
+* F-211: the rename COMMIT phase does not carry the same guarantee. When a
+* filesystem refuses to overwrite the destination, the code removes it and
+* retries the rename; if the retry ALSO fails the destination is gone. The
+* single `.bak` created above still holds the previous content, so the target
+* is restored from it (best-effort) before the original rename error is
+* rethrown, so a failed commit never leaves the file missing.
 */
-function atomicWriteFiles(targetDir, writes) {
+function atomicWriteFiles(targetDir, writes, fs = defaultFs) {
 	const stage = (name) => join(targetDir, `${name}.tmp`);
 	try {
-		for (const { name, content } of writes) writeFileSync(stage(name), content);
+		for (const { name, content } of writes) fs.writeFileSync(stage(name), content);
 		for (const { name } of writes) {
 			const finalPath = join(targetDir, name);
 			const bakPath = join(targetDir, `${name}.bak`);
-			if (existsSync(finalPath) && !existsSync(bakPath)) copyFileSync(finalPath, bakPath);
+			if (fs.existsSync(finalPath) && !fs.existsSync(bakPath)) fs.copyFileSync(finalPath, bakPath);
 		}
 		for (const { name } of writes) {
 			const finalPath = join(targetDir, name);
+			const bakPath = join(targetDir, `${name}.bak`);
+			const tmp = stage(name);
 			try {
-				renameSync(stage(name), finalPath);
+				fs.renameSync(tmp, finalPath);
 			} catch {
-				rmSync(finalPath, { force: true });
-				renameSync(stage(name), finalPath);
+				fs.rmSync(finalPath, { force: true });
+				try {
+					fs.renameSync(tmp, finalPath);
+				} catch (renameError) {
+					if (fs.existsSync(bakPath)) try {
+						fs.copyFileSync(bakPath, finalPath);
+					} catch {
+						throw new Error(`atomicWriteFiles: "${name}" was removed but recovery from ${bakPath} failed (${renameError instanceof Error ? renameError.message : String(renameError)}); verify the file manually`);
+					}
+					throw renameError;
+				}
 			}
 		}
 	} catch (error) {
-		for (const { name } of writes) rmSync(stage(name), {
+		for (const { name } of writes) fs.rmSync(stage(name), {
 			force: true,
 			recursive: true
 		});
@@ -367,5 +411,14 @@ function atomicWriteFiles(targetDir, writes) {
 function countMaintainRecommendations(text) {
 	return text?.match(/^- \[/gm)?.length ?? 0;
 }
+/** F-328: render staged args for `pending --detail`, truncated to 500 chars.
+* args may be non-JSON (a tool produced garbage), so the render is fail-safe. */
+function safeStagedArgs(args) {
+	try {
+		return JSON.stringify(args).slice(0, 500);
+	} catch {
+		return "(unserializable)";
+	}
+}
 //#endregion
-export { apply, countMaintainRecommendations, name };
+export { apply, atomicWriteFiles, countMaintainRecommendations, name };

package/lib/types/index.d.ts

@@ -24,6 +24,37 @@ export interface Config {
     maintainTimeoutMs?: number | undefined;
 }
 export declare function apply(ctx: Context, rawConfig?: Config): void;
+/** F-211: the fs surface atomicWriteFiles uses — injectable so the commit-phase
+ * rename-failure path is deterministically testable. Defaults to node:fs. */
+interface FsOps {
+    writeFileSync(path: string, data: string | Uint8Array): void;
+    existsSync(path: string): boolean;
+    copyFileSync(from: string, to: string): void;
+    renameSync(from: string, to: string): void;
+    rmSync(path: string, options?: {
+        force?: boolean;
+        recursive?: boolean;
+    }): void;
+}
+/**
+ * S6.3 (E-40): atomically replace a set of files within one directory.
+ * Each file is staged to a sibling `<name>.tmp`, then renamed into place
+ * (atomic on the same filesystem); a pre-existing file keeps a single
+ * `<name>.bak`. A failure at ANY staging step removes the staged temps and
+ * leaves the previous files untouched — a half-written target is impossible
+ * up to the staging and backup phases.
+ *
+ * F-211: the rename COMMIT phase does not carry the same guarantee. When a
+ * filesystem refuses to overwrite the destination, the code removes it and
+ * retries the rename; if the retry ALSO fails the destination is gone. The
+ * single `.bak` created above still holds the previous content, so the target
+ * is restored from it (best-effort) before the original rename error is
+ * rethrown, so a failed commit never leaves the file missing.
+ */
+export declare function atomicWriteFiles(targetDir: string, writes: Array<{
+    name: string;
+    content: string | Uint8Array;
+}>, fs?: FsOps): void;
 /**
  * Count the recommendation bullets in a rendered maintain plan.
  * `formatPlan` renders each recommendation as a line starting with `- [<kind>]`;
@@ -37,4 +68,5 @@ export declare function apply(ctx: Context, rawConfig?: Config): void;
  * evolution-maintenance outcome change (out of this package's scope).
  */
 export declare function countMaintainRecommendations(text: string | undefined): number;
+export {};
 //# sourceMappingURL=index.d.ts.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lmzhen/dsh-evolution-commands",
   "description": "Human commands for the evolution family (community build)",
-  "version": "0.3.22",
+  "version": "0.3.24",
   "publishConfig": {
     "access": "public"
   },
@@ -30,9 +30,9 @@
   ],
   "license": "MIT",
   "dependencies": {
-    "@lmzhen/dsh-evolution-approval": "^0.3.22",
-    "@lmzhen/dsh-evolution-core": "^0.3.22",
-    "@lmzhen/dsh-evolution-maintenance": "^0.3.22"
+    "@lmzhen/dsh-evolution-approval": "^0.3.24",
+    "@lmzhen/dsh-evolution-core": "^0.3.24",
+    "@lmzhen/dsh-evolution-maintenance": "^0.3.24"
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",