archondev 2.19.34 → 2.19.37

package/dist/{chunk-MSWU7N4T.js → chunk-KZP4GK6K.js}

@@ -4794,6 +4794,56 @@ function extractGovernanceViolations(errorMessage) {
   if (!errorMessage.startsWith(prefix)) return [];
   return errorMessage.slice(prefix.length).split(",").map((item) => item.trim()).filter(Boolean);
 }
+function isPathScopeGovernanceViolation(errorMessage) {
+  return extractGovernanceViolations(errorMessage).some((violation) => violation.toLowerCase().includes("outside the allowed paths"));
+}
+function collectAllowedPathsFromArchitecture(schema) {
+  const paths = (schema.components ?? []).flatMap((component) => component.paths ?? []).filter((path) => typeof path === "string" && path.trim().length > 0);
+  return Array.from(new Set(paths));
+}
+async function attemptPathScopeAutoRecovery(atom, cwd, parseSchema, options) {
+  if (!options.nonTerminating || options.autoRecoverAttempted) {
+    return false;
+  }
+  const allowedPaths = collectAllowedPathsFromArchitecture(parseSchema);
+  if (allowedPaths.length === 0) {
+    return false;
+  }
+  const { listLocalAtoms, plan } = await import("./plan-S5EULQKJ.js");
+  const before = await listLocalAtoms();
+  const recoveryStartedAt = Date.now();
+  const recoverySource = atom.description ?? atom.title;
+  const scopedRequest = `${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"));
+  await plan(scopedRequest, { conversational: true });
+  const after = await listLocalAtoms();
+  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;
+  };
+  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 });
+  return true;
+}
 function createPrompt() {
   const rl = createInterface({
     input: process.stdin,
@@ -5068,7 +5118,23 @@ ${conflictReport.blockerCount} blocking conflict(s) found.`));
         errorMessage: executionResult.errorMessage
       });
       if (isGovernanceViolation(executionResult.errorMessage)) {
-        printExecuteNextActions(atom.externalId, false);
+        const pathScopeViolation = isPathScopeGovernanceViolation(executionResult.errorMessage);
+        if (pathScopeViolation) {
+          const recovered = await attemptPathScopeAutoRecovery(
+            atom,
+            cwd,
+            parseResult.schema,
+            options
+          );
+          if (recovered) {
+            return;
+          }
+        }
+        printExecuteNextActions(
+          atom.externalId,
+          false,
+          pathScopeViolation ? "governance_path" : "generic"
+        );
         return;
       }
       return fail();
@@ -5183,12 +5249,18 @@ Running quality gates for ${targetEnvName}...`));
     prompt.close();
   }
 }
-function printExecuteNextActions(atomExternalId, success) {
+function printExecuteNextActions(atomExternalId, success, context = "generic") {
   console.log();
   console.log(chalk2.bold("Next best action:"));
   if (success) {
     console.log(chalk2.dim(`  \u2022 Run ${chalk2.cyan("archon list")} to select your next atom.`));
   } else {
+    if (context === "governance_path") {
+      console.log(chalk2.dim(`  \u2022 In chat, say ${chalk2.cyan('"adjust this atom to allowed paths"')} to re-scope automatically.`));
+      console.log(chalk2.dim(`  \u2022 Then say ${chalk2.cyan('"continue"')} to execute the re-scoped atom.`));
+      console.log(chalk2.dim(`  \u2022 Run ${chalk2.cyan(`archon show ${atomExternalId}`)} to inspect the blocked atom.`));
+      return;
+    }
     console.log(chalk2.dim(`  \u2022 Run ${chalk2.cyan(`archon show ${atomExternalId}`)} to inspect this atom.`));
   }
   console.log(chalk2.dim(`  \u2022 Run ${chalk2.cyan("archon credits")} to verify balance/tier.`));

package/dist/{execute-ACRWMKWF.js → execute-HXE6WQFQ.js}

@@ -1,6 +1,6 @@
 import {
   execute
-} from "./chunk-MSWU7N4T.js";
+} from "./chunk-KZP4GK6K.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-MSWU7N4T.js";
+} from "./chunk-KZP4GK6K.js";
 import {
   cloudCancel,
   cloudLogs,
@@ -3683,7 +3683,7 @@ async function handleAgentConversationInput(cwd, input) {
     pendingAnalysisToAtomRequest = null;
     console.log(chalk5.dim("\n> Great. Creating a governed task from the approved analysis plan.\n"));
     const { plan: plan3 } = await import("./plan-S5EULQKJ.js");
-    await plan3(request, { conversational: true });
+    await plan3(await withAllowedPathScope(cwd, request), { conversational: true });
     console.log(chalk5.dim("\n> Starting implementation now...\n"));
     await continueWithCurrentTask(cwd);
     return true;
@@ -3724,7 +3724,7 @@ async function handleAgentConversationInput(cwd, input) {
   }
   console.log(chalk5.dim("\n> Got it! Creating a task for this...\n"));
   const { plan: plan2 } = await import("./plan-S5EULQKJ.js");
-  await plan2(input, { conversational: true });
+  await plan2(await withAllowedPathScope(cwd, input), { conversational: true });
   if (shouldAutoExecuteAfterPlanning(input)) {
     await continueWithCurrentTask(cwd);
     return true;
@@ -3886,7 +3886,7 @@ async function applyApprovedProposal(cwd) {
   }
   console.log(chalk5.dim("\n> Great. I will create the task from your approved request.\n"));
   const { plan: plan2 } = await import("./plan-S5EULQKJ.js");
-  await plan2(approvedRequest, { conversational: true });
+  await plan2(await withAllowedPathScope(cwd, approvedRequest), { conversational: true });
   if (shouldAutoExecuteAfterPlanning(approvedRequest)) {
     await continueWithCurrentTask(cwd);
     return;
@@ -4061,7 +4061,7 @@ async function continueWithCurrentTask(cwd) {
   console.log(chalk5.dim(`
 Continuing with ${nextAtom.externalId}...
 `));
-  const { execute: execute2 } = await import("./execute-ACRWMKWF.js");
+  const { execute: execute2 } = await import("./execute-HXE6WQFQ.js");
   await execute2(nextAtom.externalId, { nonTerminating: true });
 }
 async function replanLatestBlockedAtom(cwd) {
@@ -4172,7 +4172,7 @@ async function handleFreeformJourneyInput(cwd, input) {
     if (state.hasArchitecture) {
       console.log(chalk5.dim("\n> Got it! Creating a task for this...\n"));
       const { plan: plan3 } = await import("./plan-S5EULQKJ.js");
-      await plan3(freeform, { conversational: true });
+      await plan3(await withAllowedPathScope(cwd, freeform), { conversational: true });
       return true;
     }
     console.log(chalk5.dim("\n> Let me understand your project better...\n"));
@@ -4181,7 +4181,7 @@ async function handleFreeformJourneyInput(cwd, input) {
   }
   console.log(chalk5.dim("\n> Got it! Creating a task for this...\n"));
   const { plan: plan2 } = await import("./plan-S5EULQKJ.js");
-  await plan2(freeform, { conversational: true });
+  await plan2(await withAllowedPathScope(cwd, freeform), { conversational: true });
   return true;
 }
 function extractActionableFollowUpFromExplore(input) {
@@ -4240,7 +4240,7 @@ async function handlePostExploreAction(cwd, request, options = {}) {
     console.log(chalk5.dim("> Got it! Creating a task for this...\n"));
   }
   const { plan: plan2 } = await import("./plan-S5EULQKJ.js");
-  await plan2(request, { conversational: true });
+  await plan2(await withAllowedPathScope(cwd, request), { conversational: true });
   if (options.agentMode) {
     if (shouldAutoExecuteAfterPlanning(sourceInput)) {
       await continueWithCurrentTask(cwd);
@@ -4250,6 +4250,17 @@ async function handlePostExploreAction(cwd, request, options = {}) {
     console.log(chalk5.dim('\nReply "execute atom" when you want implementation to start, or tell me what to change.'));
   }
 }
+async function withAllowedPathScope(cwd, request) {
+  const allowedPaths = await listArchitecturePaths(cwd);
+  if (allowedPaths.length === 0) {
+    return request;
+  }
+  return `${request}
+
+Constraints:
+- Only modify files within these allowed architecture paths: ${allowedPaths.join(", ")}
+- If required files are outside this scope, propose the minimum architecture path update first.`;
+}
 async function planTask() {
   const { plan: plan2 } = await import("./plan-S5EULQKJ.js");
   const description = await promptWithCommands("Describe what you want to build", { allowMultiline: true });
@@ -4345,7 +4356,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-ACRWMKWF.js");
+    const { execute: execute2 } = await import("./execute-HXE6WQFQ.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.34",
+  "version": "2.19.37",
   "description": "Local-first AI-powered development governance system",
   "main": "dist/index.js",
   "bin": {