archondev 2.19.36 → 2.19.38

package/dist/{chunk-B5OHK54H.js → chunk-6RDZF7BB.js}

@@ -4802,7 +4802,8 @@ function collectAllowedPathsFromArchitecture(schema) {
   return Array.from(new Set(paths));
 }
 async function attemptPathScopeAutoRecovery(atom, cwd, parseSchema, options) {
-  if (!options.nonTerminating || options.autoRecoverAttempted) {
+  const recoveryDepth = options.autoRecoverDepth ?? 0;
+  if (!options.nonTerminating || recoveryDepth >= 2) {
     return false;
   }
   const allowedPaths = collectAllowedPathsFromArchitecture(parseSchema);
@@ -4811,27 +4812,49 @@ async function attemptPathScopeAutoRecovery(atom, cwd, parseSchema, options) {
   }
   const { listLocalAtoms, plan } = await import("./plan-S5EULQKJ.js");
   const before = await listLocalAtoms();
-  const beforeIds = new Set(before.map((entry) => entry.externalId));
+  const recoveryStartedAt = Date.now();
   const recoverySource = atom.description ?? atom.title;
-  const scopedRequest = `${recoverySource}
+  const normalizedAllowedPaths = allowedPaths.map((path) => path.trim()).filter(Boolean);
+  const forcedBasePath = normalizedAllowedPaths.map((path) => path.replace(/\/\*\*$/, "").replace(/\*.*$/, "")).find((path) => path.length > 0 && path !== ".");
+  const strictScopeLine = normalizedAllowedPaths.join(", ");
+  const scopedRequest = recoveryDepth === 0 ? `${recoverySource}
 
 Constraints:
-- Only modify files within these allowed architecture paths: ${allowedPaths.join(", ")}
-- If required files are outside scope, first propose the minimum architecture path update needed.`;
-  console.log(chalk2.dim("\nAuto-recovery: re-planning with allowed-path scope constraints...\n"));
+- Only modify files within these allowed architecture paths: ${strictScopeLine}
+- Before implementation, choose exact target file paths and ensure every path matches the allowed scope.
+- If required files are outside scope, first propose the minimum architecture path update needed.` : `${recoverySource}
+
+Hard Constraints:
+- EVERY output file path MUST start with: ${forcedBasePath ?? normalizedAllowedPaths[0]}
+- Do not create files outside this base path.
+- If this cannot satisfy the task, return a minimal architecture path update proposal instead of writing out-of-scope files.`;
+  const phaseLabel = recoveryDepth === 0 ? "scope-constrained retry" : "forced-base-path retry";
+  console.log(chalk2.dim(`
+Auto-recovery: re-planning with ${phaseLabel}...
+`));
   await plan(scopedRequest, { conversational: true });
   const after = await listLocalAtoms();
-  const replacement = after.filter((entry) => !beforeIds.has(entry.externalId) && entry.status === "READY").sort((a, b) => {
+  const byMostRecent = (a, b) => {
     const aTime = new Date(String(a.updatedAt ?? a.createdAt ?? "")).getTime() || 0;
     const bTime = new Date(String(b.updatedAt ?? b.createdAt ?? "")).getTime() || 0;
     return bTime - aTime;
-  })[0];
+  };
+  let replacement = after.filter((entry) => {
+    if (entry.status !== "READY") return false;
+    if (entry.externalId === atom.externalId) return false;
+    const updatedAt = new Date(String(entry.updatedAt ?? entry.createdAt ?? "")).getTime() || 0;
+    return updatedAt >= recoveryStartedAt - 2e3;
+  }).sort(byMostRecent)[0];
+  if (!replacement) {
+    replacement = after.filter((entry) => entry.status === "READY" && entry.externalId !== atom.externalId).sort(byMostRecent)[0];
+  }
   if (!replacement) {
+    console.log(chalk2.yellow("Auto-recovery could not find a replacement READY atom to retry."));
     return false;
   }
   console.log(chalk2.dim(`Auto-recovery: retrying with ${replacement.externalId}...
 `));
-  await execute(replacement.externalId, { ...options, autoRecoverAttempted: true, nonTerminating: true });
+  await execute(replacement.externalId, { ...options, autoRecoverDepth: recoveryDepth + 1, nonTerminating: true });
   return true;
 }
 function createPrompt() {

package/dist/{execute-QCEAXLVH.js → execute-I7YHYKPQ.js}

@@ -1,6 +1,6 @@
 import {
   execute
-} from "./chunk-B5OHK54H.js";
+} from "./chunk-6RDZF7BB.js";
 import "./chunk-EBHHIUCB.js";
 import "./chunk-LGWUWEEJ.js";
 import "./chunk-WGLVDEZC.js";

package/dist/index.js

@@ -56,7 +56,7 @@ import {
   EnvironmentConfigLoader,
   EnvironmentValidator,
   execute
-} from "./chunk-B5OHK54H.js";
+} from "./chunk-6RDZF7BB.js";
 import {
   cloudCancel,
   cloudLogs,
@@ -4061,7 +4061,7 @@ async function continueWithCurrentTask(cwd) {
   console.log(chalk5.dim(`
 Continuing with ${nextAtom.externalId}...
 `));
-  const { execute: execute2 } = await import("./execute-QCEAXLVH.js");
+  const { execute: execute2 } = await import("./execute-I7YHYKPQ.js");
   await execute2(nextAtom.externalId, { nonTerminating: true });
 }
 async function replanLatestBlockedAtom(cwd) {
@@ -4259,6 +4259,7 @@ async function withAllowedPathScope(cwd, request) {
 
 Constraints:
 - Only modify files within these allowed architecture paths: ${allowedPaths.join(", ")}
+- Before writing code/content, choose exact output file paths and ensure each one stays inside allowed scope.
 - If required files are outside this scope, propose the minimum architecture path update first.`;
 }
 async function planTask() {
@@ -4356,7 +4357,7 @@ async function executeNext() {
   const atomId = await prompt("Enter atom ID to execute (or press Enter for first pending)");
   const targetId = atomId.trim() || pendingAtoms[0]?.id;
   if (targetId) {
-    const { execute: execute2 } = await import("./execute-QCEAXLVH.js");
+    const { execute: execute2 } = await import("./execute-I7YHYKPQ.js");
     await execute2(targetId, {});
   } else {
     console.log(chalk5.yellow("No atom to execute."));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "archondev",
-  "version": "2.19.36",
+  "version": "2.19.38",
   "description": "Local-first AI-powered development governance system",
   "main": "dist/index.js",
   "bin": {