refacil-sdd-ai 4.3.0 → 4.4.1

package/agents/auditor.md

@@ -157,10 +157,17 @@ Next step: [/refacil:archive | /refacil:verify]
   "summary": "<1-line summary>",
   "failCount": <integer count of FAILs in NEW code>,
   "preexistingCount": <integer count of pre-existing FAILs found>,
-  "blockers": <true|false — new code only>
+  "blockers": <true|false — new code only>,
+  "failedFiles": ["path/to/file-1.ts", "path/to/file-2.ts"]
 }
 ```
 
+**`failedFiles` rules**:
+- On `REQUIERE CORRECCIONES`: list the relative paths (from repo root) of every file in the **blocking scope** (`changedFiles`) that had at least one CRITICAL or HIGH FAIL.
+- On `APROBADO` or `APROBADO CON OBSERVACIONES`: emit `"failedFiles": []`.
+- Files with only MEDIUM/LOW findings do NOT appear in `failedFiles`.
+- Pre-existing context files do NOT appear in `failedFiles` — only blocking scope.
+
 **IMPORTANT about the JSON block**:
 - Use the literal fence ` ```refacil-review-result ` (not ` ```json `).
 - Emit it ALWAYS, even if the verdict is `REQUIERE CORRECCIONES`.

package/agents/proposer.md

@@ -2,7 +2,7 @@
 name: refacil-proposer
 description: Generates SDD-AI planning artifacts (proposal, specs, design, tasks) for any codebase. Delegated by /refacil:propose — do not invoke directly.
 tools: Read, Grep, Glob, Bash, Edit, Write
-model: opusplan
+model: sonnet
 ---
 
 # refacil-proposer — Planning Artifact Generator

package/bin/cli.js

@@ -25,12 +25,12 @@ const {
 const { installHooks, uninstallHooks, cleanLegacySettingsHooks } = require('../lib/hooks');
 const { handleCompact } = require('../lib/commands/compact');
 const { handleBus } = require('../lib/commands/bus');
-const { handleSdd, autoMigrateOpenspec } = require('../lib/commands/sdd');
+const { handleSdd, autoMigrateOpenspec, findProjectRoot } = require('../lib/commands/sdd');
 const { syncIgnoreFiles } = require('../lib/ignore-files');
 const { methodologyMigrationPending } = require('../lib/methodology-migration-pending');
 
 const packageRoot = path.resolve(__dirname, '..');
-const projectRoot = process.cwd();
+const projectRoot = findProjectRoot();
 
 // --- check-update (SessionStart) + notify-update (UserPromptSubmit) ---
 
@@ -506,7 +506,7 @@ function help() {
     4. Run: /refacil:setup (generates AGENTS.md for your project)
 
   Requirements:
-    - Node.js >= 20.19.0
+    - Node.js >= 20.0.0
     - Claude Code >= 2.1.89 (required by compact-bash for silent rewrite) or Cursor
   `);
 }
@@ -549,7 +549,7 @@ switch (command) {
     handleBus(process.argv[3], process.argv.slice(4), packageRoot);
     break;
   case 'sdd':
-    handleSdd(process.argv[3], process.argv.slice(4));
+    handleSdd(process.argv[3], process.argv.slice(4), projectRoot);
     break;
   case 'clean':
     clean();

package/lib/commands/sdd.js

@@ -3,7 +3,19 @@
 const fs = require('fs');
 const path = require('path');
 
-const projectRoot = process.cwd();
+function findProjectRoot() {
+  let dir = process.cwd();
+  const { root } = path.parse(dir);
+  while (dir !== root) {
+    if (fs.existsSync(path.join(dir, 'refacil-sdd')) || fs.existsSync(path.join(dir, '.git'))) {
+      return dir;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return process.cwd();
+}
 
 // --- Helpers ---
 
@@ -65,6 +77,65 @@ function autoMigrateOpenspec(root) {
   // Si ambos existen o ninguno existe → no hacer nada
 }
 
+// --- Minimal YAML parser/serializer for memory.yaml ---
+// Supports: string values and string-array values only.
+
+function parseMemoryYaml(content) {
+  const result = {};
+  const lines = content.split('\n');
+  let currentKey = null;
+  let currentList = null;
+
+  for (const line of lines) {
+    if (!line.trim() || line.trim().startsWith('#')) continue;
+
+    // List item: "  - value"
+    if (/^\s{2,}- /.test(line)) {
+      const value = line.replace(/^\s*- /, '').trim();
+      if (currentKey && currentList !== null) {
+        currentList.push(value);
+      }
+      continue;
+    }
+
+    // Key-value: "key: value" or "key:" (empty/start of list)
+    const kvMatch = line.match(/^([a-zA-Z][a-zA-Z0-9_-]*):\s*(.*)/);
+    if (kvMatch) {
+      currentKey = kvMatch[1];
+      const val = kvMatch[2].trim();
+      if (val === '') {
+        // Could be a list
+        currentList = [];
+        result[currentKey] = currentList;
+      } else {
+        currentList = null;
+        result[currentKey] = val;
+      }
+      continue;
+    }
+
+    currentKey = null;
+    currentList = null;
+  }
+
+  return result;
+}
+
+function serializeMemoryYaml(obj) {
+  const lines = [];
+  for (const [key, value] of Object.entries(obj)) {
+    if (Array.isArray(value)) {
+      lines.push(`${key}:`);
+      for (const item of value) {
+        lines.push(`  - ${item}`);
+      }
+    } else {
+      lines.push(`${key}: ${value}`);
+    }
+  }
+  return lines.join('\n') + '\n';
+}
+
 // --- Subcomandos ---
 
 function cmdValidateName(argv) {
@@ -79,7 +150,7 @@ function cmdValidateName(argv) {
   }
 }
 
-function cmdNewChange(argv) {
+function cmdNewChange(argv, projectRoot) {
   const args = parseArgs(argv);
   const name = args._positional[0];
 
@@ -107,7 +178,7 @@ function cmdNewChange(argv) {
   console.log(`Cambio '${name}' creado en refacil-sdd/changes/${name}/`);
 }
 
-function cmdArchive(argv) {
+function cmdArchive(argv, projectRoot) {
   const args = parseArgs(argv);
   const name = args._positional[0];
 
@@ -134,6 +205,10 @@ function cmdArchive(argv) {
     process.exit(1);
   }
 
+  // Delete memory.yaml before archiving (CA-18)
+  const memoryFile = path.join(sourceDir, 'memory.yaml');
+  if (fs.existsSync(memoryFile)) fs.unlinkSync(memoryFile);
+
   fs.mkdirSync(archiveDir, { recursive: true });
   fs.renameSync(sourceDir, destDir);
 
@@ -145,7 +220,138 @@ function cmdArchive(argv) {
   console.log(`Cambio '${name}' archivado en refacil-sdd/changes/archive/${date}-${name}/`);
 }
 
-function cmdList(argv) {
+function cmdSetMemory(argv, projectRoot) {
+  const args = parseArgs(argv);
+  const name = args._positional[0];
+
+  if (!name) {
+    console.error('Uso: refacil-sdd-ai sdd set-memory <nombre-cambio> [--last-step <value>] [--stack-detected <value>] [--touched-files <csv>] [--commands-run <value>] [--criteria-run <csv>]');
+    process.exit(1);
+  }
+
+  const root = projectRoot;
+
+  // Guard: ensure the change directory exists before any file operation
+  const changeDir = path.join(root, 'refacil-sdd', 'changes', name);
+  if (!fs.existsSync(changeDir)) {
+    console.error(`No existe el cambio '${name}' en refacil-sdd/changes/${name}/`);
+    process.exit(1);
+  }
+
+  // Require at least one field flag
+  const knownFlags = ['last-step', 'stack-detected', 'touched-files', 'commands-run', 'criteria-run'];
+  if (!knownFlags.some((f) => args[f] !== undefined)) {
+    console.error('set-memory: debe especificar al menos un campo (--last-step, --stack-detected, --touched-files, --commands-run, --criteria-run)');
+    process.exit(1);
+  }
+
+  const memoryPath = path.join(changeDir, 'memory.yaml');
+
+  // Read existing memory to merge
+  let existing = {};
+  if (fs.existsSync(memoryPath)) {
+    try {
+      existing = parseMemoryYaml(fs.readFileSync(memoryPath, 'utf8'));
+    } catch (_) {
+      existing = {};
+    }
+  }
+
+  // Apply flags
+  if (args['last-step']) existing['lastStep'] = args['last-step'];
+  if (args['stack-detected']) existing['stackDetected'] = args['stack-detected'];
+  if (args['touched-files']) {
+    existing['touchedFiles'] = args['touched-files'].split(',').map((s) => s.trim()).filter(Boolean);
+  }
+  if (args['commands-run']) existing['commandsRun'] = args['commands-run'];
+  if (args['criteria-run']) {
+    existing['criteriaRun'] = args['criteria-run'].split(',').map((s) => s.trim()).filter(Boolean);
+  }
+
+  fs.writeFileSync(memoryPath, serializeMemoryYaml(existing), 'utf8');
+  console.log(`memory.yaml actualizado para '${name}'`);
+}
+
+function cmdGetMemory(argv, projectRoot) {
+  const args = parseArgs(argv);
+  const name = args._positional[0];
+  const wantJson = args.json === true;
+
+  if (!name) {
+    console.error('Uso: refacil-sdd-ai sdd get-memory <nombre-cambio> [--json]');
+    process.exit(1);
+  }
+
+  const root = projectRoot;
+  const memoryPath = path.join(root, 'refacil-sdd', 'changes', name, 'memory.yaml');
+
+  if (!fs.existsSync(memoryPath)) {
+    if (wantJson) {
+      process.stdout.write('{}\n');
+    }
+    process.exit(0);
+  }
+
+  const content = fs.readFileSync(memoryPath, 'utf8');
+
+  if (wantJson) {
+    let parsed = {};
+    try {
+      parsed = parseMemoryYaml(content);
+    } catch (_) {
+      parsed = {};
+    }
+    process.stdout.write(JSON.stringify(parsed) + '\n');
+  } else {
+    process.stdout.write(content);
+  }
+}
+
+function cmdSetReviewFails(argv, projectRoot) {
+  const args = parseArgs(argv);
+  const name = args._positional[0];
+
+  if (!name) {
+    console.error('Uso: refacil-sdd-ai sdd set-review-fails <nombre-cambio> --files <csv>');
+    process.exit(1);
+  }
+
+  const root = projectRoot;
+  const changeDir = path.join(root, 'refacil-sdd', 'changes', name);
+  if (!fs.existsSync(changeDir)) {
+    console.error(`No existe el cambio '${name}' en refacil-sdd/changes/${name}/`);
+    process.exit(1);
+  }
+
+  const files = args.files
+    ? args.files.split(',').map((s) => s.trim()).filter(Boolean)
+    : [];
+
+  const reviewFailsPath = path.join(changeDir, '.review-last-fails.json');
+  fs.writeFileSync(reviewFailsPath, JSON.stringify({ failedFiles: files }, null, 2), 'utf8');
+  console.log(`.review-last-fails.json actualizado para '${name}'`);
+}
+
+function cmdClearReviewFails(argv, projectRoot) {
+  const args = parseArgs(argv);
+  const name = args._positional[0];
+
+  if (!name) {
+    console.error('Uso: refacil-sdd-ai sdd clear-review-fails <nombre-cambio>');
+    process.exit(1);
+  }
+
+  const root = projectRoot;
+  const reviewFailsPath = path.join(root, 'refacil-sdd', 'changes', name, '.review-last-fails.json');
+
+  if (fs.existsSync(reviewFailsPath)) {
+    fs.unlinkSync(reviewFailsPath);
+    console.log(`.review-last-fails.json eliminado para '${name}'`);
+  }
+  // Silent exit 0 if not exists
+}
+
+function cmdList(argv, projectRoot) {
   const args = parseArgs(argv);
   const wantJson = args.json === true;
 
@@ -184,7 +390,7 @@ function cmdList(argv) {
   }
 }
 
-function cmdStatus(argv) {
+function cmdStatus(argv, projectRoot) {
   const args = parseArgs(argv);
   const name = args._positional[0];
   const wantJson = args.json === true;
@@ -273,7 +479,7 @@ function cmdStatus(argv) {
   }
 }
 
-function cmdMarkReviewed(argv) {
+function cmdMarkReviewed(argv, projectRoot) {
   const args = parseArgs(argv);
   const name = args._positional[0];
 
@@ -314,7 +520,7 @@ function cmdMarkReviewed(argv) {
   console.log(`Review marcado como aprobado para '${name}' (verdict: ${payload.verdict})`);
 }
 
-function cmdTasksUpdate(argv) {
+function cmdTasksUpdate(argv, projectRoot) {
   const args = parseArgs(argv);
   const name = args._positional[0];
 
@@ -390,44 +596,69 @@ function sddHelp() {
       --task N                           Número de task (1-indexed)
       --done                             Confirma que la task está hecha
     sdd validate-name <nombre>         Valida el formato del nombre de un cambio
+    sdd set-memory <nombre>            Escribe o fusiona campos en memory.yaml del cambio
+      [--last-step <value>]              Último paso ejecutado (apply, test, etc.)
+      [--stack-detected <value>]         Stack tecnológico detectado
+      [--touched-files <csv>]            Archivos modificados (separados por coma)
+      [--commands-run <value>]           Comando de test ejecutado
+      [--criteria-run <csv>]             Criterios CA/CR ejecutados (separados por coma)
+    sdd get-memory <nombre>            Lee memory.yaml del cambio
+      [--json]                           Salida en JSON (por defecto: YAML raw)
+    sdd set-review-fails <nombre>      Escribe .review-last-fails.json con archivos fallidos
+      --files <csv>                      Archivos con fallos (separados por coma)
+    sdd clear-review-fails <nombre>    Elimina .review-last-fails.json del cambio
 
   Notas:
     - Los nombres de cambio deben empezar con minúscula y usar solo [a-z0-9-]
     - Si existe openspec/ y no existe refacil-sdd/, se migra automáticamente
+    - sdd archive elimina memory.yaml automáticamente antes de mover el cambio
   `);
 }
 
 // --- Dispatcher ---
 
-function handleSdd(sub, argv) {
+function handleSdd(sub, argv, projectRoot) {
   const args = argv || [];
+  const root = projectRoot || findProjectRoot();
 
   switch (sub) {
     case 'new-change':
-      cmdNewChange(args);
+      cmdNewChange(args, root);
       break;
     case 'archive':
-      cmdArchive(args);
+      cmdArchive(args, root);
       break;
     case 'list':
-      cmdList(args);
+      cmdList(args, root);
       break;
     case 'status':
-      cmdStatus(args);
+      cmdStatus(args, root);
       break;
     case 'mark-reviewed':
-      cmdMarkReviewed(args);
+      cmdMarkReviewed(args, root);
       break;
     case 'tasks-update':
-      cmdTasksUpdate(args);
+      cmdTasksUpdate(args, root);
       break;
     case 'validate-name':
       cmdValidateName(args);
       break;
+    case 'set-memory':
+      cmdSetMemory(args, root);
+      break;
+    case 'get-memory':
+      cmdGetMemory(args, root);
+      break;
+    case 'set-review-fails':
+      cmdSetReviewFails(args, root);
+      break;
+    case 'clear-review-fails':
+      cmdClearReviewFails(args, root);
+      break;
     default:
       sddHelp();
       process.exit(1);
   }
 }
 
-module.exports = { handleSdd, parseArgs, autoMigrateOpenspec, validateChangeName };
+module.exports = { handleSdd, parseArgs, autoMigrateOpenspec, validateChangeName, findProjectRoot };

package/lib/installer.js

@@ -71,10 +71,12 @@ function installSkills(packageRoot, projectRoot) {
 // Claude Code: tools allowlist granular, model: sonnet|opus|haiku
 // Cursor: readonly: true|false (booleano), model: inherit (default)
 function transformFrontmatterForCursor(content) {
-  const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  const normalized = content.replace(/\r\n/g, '\n');
+  const match = normalized.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
   if (!match) return content;
 
   const [, frontmatterRaw, body] = match;
+  // work with normalized content from here on
   const lines = frontmatterRaw.split('\n');
   const out = [];
   let toolsLine = null;
@@ -295,9 +297,9 @@ function checkNodeVersion() {
   const major = parseInt(version.split('.')[0].replace('v', ''));
   const minor = parseInt(version.split('.')[1]);
 
-  if (major < 20 || (major === 20 && minor < 19)) {
+  if (major < 20) {
     console.log(`\n  ADVERTENCIA: Node.js ${version} detectado.`);
-    console.log('  refacil-sdd-ai requiere Node.js >= 20.19.0.');
+    console.log('  refacil-sdd-ai requiere Node.js >= 20.0.0.');
     console.log('  Las skills se instalaran pero /refacil:setup podria fallar al instalar OpenSpec.\n');
     return false;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "refacil-sdd-ai",
-  "version": "4.3.0",
+  "version": "4.4.1",
   "description": "SDD-AI: Specification-Driven Development with AI — development methodology using AI with Claude Code and Cursor",
   "bin": {
     "refacil-sdd-ai": "./bin/cli.js"
@@ -35,7 +35,7 @@
     "node": ">=20.0.0"
   },
   "scripts": {
-    "test": "node --test test/hooks.test.js test/installer.test.js test/ignore-files.test.js test/methodology-migration-pending.test.js test/sdd.test.js test/refactor-integrar-openspec-nativo.test.js test/refactor-rutas-refacil-sdd.test.js test/refactor-agents-english.test.js test/remove-openspec-legacy.test.js"
+    "test": "node --test test/hooks.test.js test/installer.test.js test/ignore-files.test.js test/methodology-migration-pending.test.js test/sdd.test.js test/refactor-integrar-openspec-nativo.test.js test/refactor-rutas-refacil-sdd.test.js test/refactor-agents-english.test.js test/remove-openspec-legacy.test.js test/find-project-root.test.js"
   },
   "dependencies": {
     "ws": "^8.18.0"

package/skills/apply/SKILL.md

@@ -99,6 +99,22 @@ The sub-agent will use the briefing as the primary guide and will only read the
 
 Returns ONE single message with the report + JSON block fenced as ` ```refacil-apply-result `.
 
+### Step 2.5: Save cross-skill memory (memory.yaml)
+
+After parsing the `refacil-apply-result` block and only if `result` is not `"FAILED"`:
+- Extract `touchedFiles` from the result (list of files actually created/modified by the implementer).
+
+Run:
+```bash
+refacil-sdd-ai sdd set-memory <changeName> \
+  --last-step apply \
+  --touched-files "<comma-separated list of modified files>"
+```
+
+This command merges into memory.yaml at the repo root using `findProjectRoot()` — no manual path construction needed.
+
+If `result` is `"FAILED"`, skip and wait for user instructions.
+
 ### Step 3: Present result and next step
 
 Show the user the **report** (everything before the `refacil-apply-result` block). Do not show the JSON block — it is internal metadata.

package/skills/archive/SKILL.md

@@ -61,23 +61,19 @@ Inspect the change folder in `refacil-sdd/changes/`:
 
 Depending on the type, follow the corresponding step:
 
-### Step 2A: Bug fix → Manual archiving (no `sdd archive` CLI)
+### Step 2A: Bug fix → Archive with native CLI
 
-Bug fixes only contain `summary.md` (and optionally `.review-passed`); they are not full proposal/spec/design/task trees. Archive them with **git mv** / **mv** per the steps below — **do not** use `refacil-sdd-ai sdd archive` for these folders.
+Bug fixes only contain `summary.md` (and optionally `.review-passed`). The CLI `refacil-sdd-ai sdd archive` handles the folder move internally with its own `findProjectRoot()`, so there is no need for manual `mv` — use the CLI for the move, and only write specs/review.yaml manually (the CLI does not cover those).
 
-1. **Move to archive (move operation, not copy)**: transfer the full fix folder from `refacil-sdd/changes/[fix-name]/` to `refacil-sdd/changes/archive/[ISO-date]-[fix-name]/`. The source folder **must be eliminated** when done.
+0. **Read artifacts before archiving**: read `summary.md` and `.review-passed` from `refacil-sdd/changes/[fix-name]/` **now**, before the CLI moves the folder. The archived path will be different.
 
-   Recommended execution order (deterministic and cross-platform):
-   1. Ensure the `refacil-sdd/changes/archive/` directory exists (create if not present).
-   2. Prefer an **atomic move** with `git mv "refacil-sdd/changes/[fix-name]" "refacil-sdd/changes/archive/[ISO-date]-[fix-name]"` when the fix is already under git control (moves and stages at once).
-   3. If `git mv` does not apply (untracked files or error), use instead:
-      - Linux/macOS/Windows: `mv "refacil-sdd/changes/[fix-name]" "refacil-sdd/changes/archive/[ISO-date]-[fix-name]"`. Always use `mv` (not `cp -r`) — verify source no longer exists after the move.
-   4. **Mandatory post-move verification**: run a listing/existence test to confirm:
-      - `refacil-sdd/changes/[fix-name]/` **no longer exists**.
-      - `refacil-sdd/changes/archive/[ISO-date]-[fix-name]/` **does exist** and contains `summary.md` (+ `.review-passed` if it existed).
-   5. If the verification fails (source folder survived), explicitly delete it with `rm -rf "refacil-sdd/changes/[fix-name]"` and re-verify. Do not continue to step 2 until the state is consistent.
+1. **Archive with the CLI** — let the CLI handle the move (it automatically deletes memory.yaml if present):
+   ```bash
+   refacil-sdd-ai sdd archive [fix-name]
+   ```
+   The CLI resolves the repo root internally, deletes memory.yaml if present, moves the folder to `refacil-sdd/changes/archive/[ISO-date]-[fix-name]/`, and exits with code 0 on success. If it exits non-zero, stop and report the error to the user.
 
-2. **Document in specs**: Read the `summary.md` and `.review-passed` from the fix (from the **archived** path at `refacil-sdd/changes/archive/[ISO-date]-[fix-name]/`, no longer from the original path), and create an individual spec for the bug at `refacil-sdd/specs/[descriptive-name]/spec.md`.
+2. **Document in specs**: using the content read in step 0, create an individual spec at `$(git rev-parse --show-toplevel)/refacil-sdd/specs/[descriptive-name]/spec.md`.
 
    **Spec folder name**: Use a short, clear kebab-case description of the bug (e.g. `fix-session-timeout-redis`, `fix-null-pointer-payment-callback`). **Do NOT use ticket IDs** (REF-123, JIRA-456, etc.) — the name must be descriptive so `/refacil:explore` can find and understand the fix without external context.
 
@@ -101,7 +97,7 @@ Bug fixes only contain `summary.md` (and optionally `.review-passed`); they are
    - **THEN** the system SHALL [normal behavior without regression]
    ```
 
-3. **Persist review metadata separately**: create `refacil-sdd/specs/[descriptive-name]/review.yaml` with the fields from `.review-passed` plus the Jira links from Step 1.5:
+3. **Persist review metadata separately**: create `$(git rev-parse --show-toplevel)/refacil-sdd/specs/[descriptive-name]/review.yaml` with the fields from `.review-passed` plus the Jira links from Step 1.5:
    ```yaml
    verdict: APROBADO|APROBADO CON OBSERVACIONES
    date: 2026-04-10T00:00:00.000Z
@@ -140,7 +136,7 @@ The spec and review evidence are written **before** running the CLI archive comm
      ```
    - If `review.yaml` already exists, update only the fields that changed without removing others.
 
-3. **Run the CLI archive**: `refacil-sdd-ai sdd archive <changeName>` — this moves the change to `refacil-sdd/changes/archive/<date>-<changeName>/`.
+3. **Run the CLI archive**: `refacil-sdd-ai sdd archive <changeName>` — the CLI automatically deletes memory.yaml if present, then moves the change to `refacil-sdd/changes/archive/<date>-<changeName>/`.
 4. Verify the command completed successfully (exit 0) and the original folder no longer exists.
 
 5. Continue to **Step 3**.
@@ -151,8 +147,8 @@ The goal is for `refacil-sdd/specs/` to document how the system works TODAY.
 
 Before showing the summary, run a **final cleanup verification** (applies to both bug fixes and regular changes):
 
-- `refacil-sdd/changes/[original-name]/` **must NOT exist** (only the archived version must survive in `refacil-sdd/changes/archive/...`).
-- If the source folder survived for any reason (failed move, partial copy, interrupted move), explicitly delete it with `rm -rf "refacil-sdd/changes/[original-name]"` before confirming to the user.
+- `$(git rev-parse --show-toplevel)/refacil-sdd/changes/[original-name]/` **must NOT exist** (only the archived version must survive in `refacil-sdd/changes/archive/...`).
+- If the source folder survived for any reason (failed move, partial copy, interrupted move), explicitly delete it with `rm -rf "$(git rev-parse --show-toplevel)/refacil-sdd/changes/[original-name]"` before confirming to the user.
 
 ```
 === Change archived ===

package/skills/explore/SKILL.md

@@ -17,6 +17,18 @@ This skill is a **thin wrapper** that delegates the investigation to the `refaci
 - If `$ARGUMENTS` is empty, ask the user for the question or topic to explore BEFORE invoking the sub-agent.
 - If there is a question, continue.
 
+### Step 0.1: Duplicate exploration guard (CA-11)
+
+Before delegating, check the current session conversation context for a prior complete exploration report with overlapping scope (same modules, files, or question topic):
+
+- **If a prior complete exploration exists for the same or highly overlapping topic**: summarize the already-known context in 2-3 sentences and ask:
+  ```
+  I already explored [topic] earlier in this session. The key findings were: [summary].
+  Do you want me to run a targeted follow-up on a specific aspect, or proceed with a new full exploration?
+  ```
+  Wait for the user's answer before proceeding.
+- **If there is no prior exploration** (or it is on a clearly different topic): continue to Step 1 without interruption.
+
 ### Step 1: Delegate to the refacil-investigator sub-agent
 
 Invoke the `refacil-investigator` sub-agent passing it:

package/skills/prereqs/METHODOLOGY-CONTRACT.md

@@ -57,19 +57,22 @@ Critical rule:
 
 If the current branch is protected and code needs to be written:
 
-1. Inform and ask for a task identifier (Jira or other).
+1. **Ask for a task identifier first** — before any git action, ask the user:
+   *"What is the task number or name for this branch? (e.g. SEGINF-20, REF-123, or a short descriptive name)"*
+   Wait for the user's answer before continuing.
 2. Verify clean working directory (`git status --porcelain`).
 3. If there are uncommitted changes, ask for approval to `git stash push -m "auto-stash-refacil"`.
 4. Detect the base branch to create a working branch from:
    - Prefer `develop`, then `dev`.
    - Only if neither exists (new repo), use `main` or `master` as a temporary exception.
    - Switch and update (`git pull origin <base>`). If none exist, stop.
-5. Create the working branch:
-   - Feature: `feature/<ID>`
-   - Bugfix: `fix/<ID>`
-   - Without ID: short descriptive name and recommend creating a ticket.
-6. Restore `stash` if used.
-7. If the user does not approve the process, stop.
+5. **Propose the branch name and wait for explicit user approval before creating it:**
+   - Feature: `feature/<ID>` (e.g. `feature/SEGINF-20`)
+   - Bugfix: `fix/<ID>` (e.g. `fix/SEGINF-20`)
+   - Without ID: propose a short descriptive name (e.g. `fix/project-root-consistency`) and **require explicit approval** before proceeding.
+   Example: *"I'll create branch `fix/SEGINF-20` from `develop`. Shall I proceed?"*
+6. **Only after explicit user confirmation**: create the branch and restore stash if used.
+7. If the user does not approve at any point, stop.
 
 ## §5 — Output policy (UX)
 

package/skills/propose/SKILL.md

@@ -12,6 +12,18 @@ This skill is a **wrapper** that prepares the scope, delegates SDD artifact gene
 
 ## Flow
 
+### Step 0.5: Duplicate exploration guard (CA-11)
+
+Before gathering context or delegating, check the current session conversation for a prior complete exploration report with overlapping scope (same modules, files, or described topic):
+
+- **If a prior complete exploration exists for the same or highly overlapping topic**: summarize the already-known context in 2-3 sentences and ask:
+  ```
+  I already explored [topic] earlier in this session. The key findings were: [summary].
+  Do you want me to run a targeted follow-up, or proceed with the full exploration for this proposal?
+  ```
+  Wait for the user's answer. If they confirm "proceed", continue to Step 1 — do not re-invoke a full exploration automatically.
+- **If there is no prior exploration** for this topic: continue to Step 1 without interruption.
+
 ### Step 1: Understand the change
 
 If the user did NOT provide sufficient context in `$ARGUMENTS`, ask:
@@ -21,15 +33,15 @@ If the user did NOT provide sufficient context in `$ARGUMENTS`, ask:
 
 If `$ARGUMENTS` is already clear, do not ask again.
 
-### Step 1.5: Change folder identifier (blocking)
+### Step 1.5: Validate change name (blocking)
 
-The `refacil-sdd/changes/<name>/` directory **cannot** use a `<name>` whose **first character is not an ASCII letter** `[a-zA-Z]` — see **`refacil-prereqs/METHODOLOGY-CONTRACT.md` §9**. Names like `2026-04-17-expose-something` cause `refacil-sdd-ai sdd status <name>` and other SDD commands to fail.
+Before delegating to the sub-agent, agree on or derive the **final slug** of the change (kebab-case: `feat-...`, `expose-...`, `imp-...`, etc.) then validate it with the CLI:
 
-**Before delegating to the sub-agent:**
+Run `refacil-sdd-ai sdd validate-name <slug>`:
+- If exit 0: the name is valid — continue.
+- If exit 1: show the CLI's error message to the user and ask them to provide a corrected slug. Repeat until `sdd validate-name` exits 0.
 
-1. Agree on or derive the **final slug** of the change (kebab-case: `feat-...`, `expose-...`, `imp-...`, etc.). Dates or tickets do not go at the **start** of the name.
-2. If the user proposes an invalid name, **correct it** (e.g. `feat-` or `change-` prefix) or ask for the correct slug; **do not** delegate until you have a valid name.
-3. Communicate the final agreed slug to the user before generating.
+Communicate the final agreed slug to the user before generating.
 
 ### Step 2: Delegate to the refacil-proposer sub-agent
 
@@ -86,6 +98,6 @@ Do you want me to continue with /refacil:apply?
 
 ## Rules
 
-- **Change folder name**: always comply with **§9** of the methodology contract (first character ASCII letter; never start with a digit). Validate BEFORE delegating.
+- **Change folder name**: always validate with `refacil-sdd-ai sdd validate-name <slug>` before delegating. Do not proceed if it exits 1.
 - **Always delegate generation to the sub-agent**. Do not replicate the codebase exploration or artifact generation logic here.
 - **Flow continuity**: if the user confirms affirmatively ("yes", "ok", "go", "continue", etc.) the continuity question in Step 4, immediately invoke the **Skill tool** with `skill: "refacil:apply"`. Do not describe it in text or wait for the user to type `/refacil:apply`. (See `METHODOLOGY-CONTRACT.md §5`.)

package/skills/review/SKILL.md

@@ -43,11 +43,21 @@ If you already have a `changeName`, run `refacil-sdd-ai sdd status <changeName>
    The change [name] already has an approved review ([verdict] — [date]) and there are no subsequent changes.
    ```
 
+### Step 0.4: Incremental scope (CA-07 — only if re-running after REQUIERE CORRECCIONES)
+
+If `changeName` is not null, check whether `refacil-sdd/changes/<changeName>/.review-last-fails.json` exists (read by explicit path — it is NOT a dotfile but may be hidden in listings):
+
+- **If the file EXISTS**: read `failedFiles` from it. Compute:
+  `incrementalScope = failedFiles ∪ changedFilesUnion`
+  - If `incrementalScope` is empty (CR-02): fall back to `changedFilesUnion` and add a comment in the briefing: `"# warning: incremental scope was empty — using full changedFilesUnion"`.
+  - Use `incrementalScope` as `changedFiles` in the briefing (Step 0.5), instead of the full `changedFilesUnion`.
+- **If the file does NOT exist**: use `changedFilesUnion` as `changedFiles` normally.
+
 ### Step 0.5: Build briefing for the sub-agent (reduces auditor tool calls)
 
 Before invoking the sub-agent, extract the context that the auditor would otherwise calculate on its own:
 
-1. **Changed files** — use **`changedFilesUnion` from Step 0.3** as the blocking scope. Do not run `git diff` or `git status` again.
+1. **Changed files** — use the scope resolved in Step 0.4 (`incrementalScope` if available, otherwise `changedFilesUnion`). Do not run `git diff` or `git status` again.
 
 2. **Project type** — read `package.json` (if it exists) and inspect the dependencies:
    - Backend indicators: `@nestjs/*`, `express`, `fastify`, `koa`, `typeorm`, `prisma`, `pg`, `mongoose`, `bullmq`, `amqplib`
@@ -56,6 +66,10 @@ Before invoking the sub-agent, extract the context that the auditor would otherw
 
 3. **Change objective** (only if there is an active change in `refacil-sdd/changes/`) — read the first section of `proposal.md`. Extract the objective in 1-2 sentences. If the scope is `git-diff` without an active change → `null`.
 
+4. **Cross-skill memory** — run `refacil-sdd-ai sdd get-memory <changeName> --json` and parse the JSON to extract `stackDetected` and `touchedFiles`. Include them in the briefing so the auditor skips re-discovery. If the command outputs `{}` or fails, omit — do not block (CR-04).
+
+5. **Mode** — default `concise`. If re-running after a prior `REQUIERE CORRECCIONES` (i.e., `.review-last-fails.json` was found with non-empty `failedFiles` in Step 0.4): set `mode: focused` — the auditor re-evaluates only the failing checklist items on the `failedFiles` (CR-05: focused mode still reads those files). Otherwise keep `concise`.
+
 Build the BRIEFING block:
 
 ```
@@ -64,7 +78,9 @@ scope: <changeName | "git-diff">
 changedFiles: [path/file-1.ts, path/file-2.ts, ...]
 projectType: backend | frontend | fullstack | library
 changeObjective: <objective in 1-2 sentences, or null>
-mode: concise | detailed
+mode: concise | detailed | focused
+stackDetected: <from memory.yaml, or omit>
+touchedFiles: [...]                   # from memory.yaml — omit if not present
 ```
 
 ### Step 1: Delegate to the refacil-auditor sub-agent
@@ -85,6 +101,18 @@ Show the user the **concise report** (everything before the `refacil-review-resu
 
 **If the sub-agent returned `SCOPE_ERROR: <reason>`**: propagate the error to the user and ask for clarification. Do not write a marker.
 
+### Step 2.5: Persist or clean incremental-scope state (CA-06/CA-08/CA-09/CR-01)
+
+Parse the `refacil-review-result` block from the sub-agent.
+
+**If `verdict` is `REQUIERE CORRECCIONES`**:
+- Only if `changeName` is not null (CR-01) AND the block includes a `failedFiles` field (CA-09 backward compat):
+  - Run: `refacil-sdd-ai sdd set-review-fails <changeName> --files "<comma-separated failedFiles>"`
+- If `changeName` is null or `failedFiles` is absent: skip silently.
+
+**If `verdict` is `APROBADO` or `APROBADO CON OBSERVACIONES`**:
+- Run: `refacil-sdd-ai sdd clear-review-fails <changeName>`
+
 ### Step 3: Create `.review-passed` marker (if applicable)
 
 Parse the ` ```refacil-review-result ` block from the sub-agent. If `verdict` is **APROBADO** or **APROBADO CON OBSERVACIONES** and `changeName` is not null:
@@ -110,6 +138,24 @@ Where the values are extracted from the sub-agent's `refacil-review-result` bloc
 - `changeName` is null.
 - The sub-agent returned `SCOPE_ERROR`.
 
+### Step 3.5: Offer to apply corrections (only if REQUIERE CORRECCIONES)
+
+If `verdict` is `REQUIERE CORRECCIONES`, after showing the report present a numbered list of the findings (blockers first, then medium/low) and ask:
+
+```
+X corrections are needed. Do you want me to apply them?
+- "yes" / "all" — apply all
+- "1, 3" (numbers) — apply only those items
+- "no" / "skip" — you'll handle them manually
+```
+
+**According to the user's response:**
+- **"yes" / "all"**: apply every correction using Edit/Write/Bash tools directly in this skill. After each correction, note it as applied.
+- **"N, M" (specific items)**: apply only those numbered items.
+- **"no" / "skip" / no answer**: do not apply anything — continue to Step 4.
+
+After applying corrections (if any): summarize what was applied, then continue to Step 4.
+
 ### Step 4: Recommend next step
 
 According to the parsed `verdict`, add at the end of your response:
@@ -120,9 +166,9 @@ The next step is to archive the change.
 Do you want me to continue with /refacil:archive?
 ```
 
-**If REQUIERE CORRECCIONES:**
+**If REQUIERE CORRECCIONES** (after Step 3.5):
 ```
-Once the corrections are applied, the next step is to re-verify the implementation.
+The next step is to re-verify the implementation.
 Do you want me to continue with /refacil:verify?
 ```
 
@@ -132,4 +178,7 @@ Do you want me to continue with /refacil:verify?
 - **Always delegate to the sub-agent**. Do not replicate checklist or evaluation logic here.
 - **The marker is created by this skill, not the sub-agent**.
 - If the sub-agent returned something out of format (no parseable JSON block and not `SCOPE_ERROR`), inform the user: "The reviewer returned an unstructured report — no marker was created. Review the report manually."
-- **Flow continuity**: if the user confirms affirmatively ("yes", "ok", "go", "continue", etc.) the continuity question, immediately invoke the corresponding **Skill tool**: `skill: "refacil:archive"` if the verdict is APROBADO/APROBADO CON OBSERVACIONES, or `skill: "refacil:verify"` if REQUIERE CORRECCIONES. (See `METHODOLOGY-CONTRACT.md §5`.)
+- **Flow continuity**:
+  - If verdict is APROBADO/APROBADO CON OBSERVACIONES and user confirms → immediately invoke `skill: "refacil:archive"`.
+  - If verdict is REQUIERE CORRECCIONES and user confirms verify (Step 4) → immediately invoke `skill: "refacil:verify"`.
+  - Do not describe the skill in text or wait for the user to type the command. (See `METHODOLOGY-CONTRACT.md §5`.)

package/skills/test/SKILL.md

@@ -69,6 +69,23 @@ Parse the `refacil-test-result` block from the sub-agent:
 - **If `passed: false`** (tests failed): present the `issues` from the JSON and ask the user how to proceed. **Do not continue to Step 4** until the tests pass.
 - **If `passed: true`**: continue to Step 4.
 
+### Step 3.5: Update cross-skill memory (memory.yaml)
+
+After parsing the `refacil-test-result` block and only if `passed: true`:
+- Extract from the result or from the briefing: `commandsRun` (test command used), `criteriaRun` (list of CA-XX/CR-XX covered by tests), `stackDetected` (if the tester identified the stack).
+
+Run:
+```bash
+refacil-sdd-ai sdd set-memory <changeName> \
+  --last-step test \
+  --commands-run "<test command used>" \
+  --criteria-run "<comma-separated criteria IDs that were run>"
+```
+
+If `stackDetected` is available, add `--stack-detected "<stack>"` to the command as well.
+
+This command merges into memory.yaml, preserving fields from other steps (e.g. `touchedFiles` from apply).
+
 ### Step 4: Flow continuity (only if tests passed)
 
 Add:

package/skills/verify/SKILL.md

@@ -27,6 +27,16 @@ If you already have a `changeName`, run `refacil-sdd-ai sdd status <changeName>
 
 If **this session** inspects the change directory before or after delegating, apply **`refacil-prereqs/METHODOLOGY-CONTRACT.md` §8**.
 
+### Step 0.6: Verify validator agent is installed (blocking — CA-12)
+
+Before doing anything else, check that `.claude/agents/refacil-validator.md` exists (read by explicit path or `ls -la .claude/agents/refacil-validator.md`).
+
+**If the file does NOT exist**, stop immediately:
+```
+El agente `refacil-validator` no está instalado. Ejecuta `/refacil:update` y reinicia la sesión antes de volver a correr `/refacil:verify`.
+```
+Do not continue and do not escalate to any other agent.
+
 ### Step 1: Build briefing for the sub-agent (reduces validator tool calls)
 
 Before invoking the sub-agent, extract the context that the validator would otherwise calculate on its own:
@@ -40,6 +50,8 @@ Before invoking the sub-agent, extract the context that the validator would othe
 
 3. **Scope files** — run `git diff --name-only HEAD` to get the files modified in this change.
 
+4. **Cross-skill memory** — run `refacil-sdd-ai sdd get-memory <changeName> --json` and parse the JSON output to extract `commandsRun` and `criteriaRun`. Include them in the briefing so the validator uses the same command without re-discovering it and can skip re-reading specs for those criteria. If the output is `{}` or the command fails, skip — do not block verification (CR-04).
+
 Build the BRIEFING block:
 
 ```
@@ -54,6 +66,8 @@ criteria:
     - CR-01: <description>
 changedFiles: [path/file-1.ts, ...]
 mode: concise | detailed
+commandsRun: [<command>, ...]          # from memory.yaml — omit if not present
+criteriaRun: [CA-01, CR-01, ...]       # from memory.yaml — omit if not present
 ```
 
 ### Step 2: Delegate to the refacil-validator sub-agent
@@ -73,7 +87,18 @@ The sub-agent:
 
 Show the user the **combined report** (everything before the `refacil-verify-result` block). Do not show the JSON block — it is internal metadata.
 
-**If the sub-agent returned a scope error** (without JSON block): propagate to the user and ask for clarification.
+**If the sub-agent failed to load** (tool error, agent type not found, or no response at all): stop immediately and do NOT escalate to any other agent:
+```
+The validator sub-agent could not be loaded — retry or run `/refacil:verify` again.
+```
+
+**If the sub-agent responded but without a `refacil-verify-result` block** (unstructured output): show the raw report and stop:
+```
+The validator returned an unstructured report — continue manually.
+```
+Do not re-invoke a different agent.
+
+**If the sub-agent returned a scope error** (`SCOPE_ERROR: <reason>`, without JSON block): propagate to the user and ask for clarification. This is NOT the CA-01 failsafe — the agent loaded correctly but found an ambiguous scope.
 
 ### Step 4: Process the result
 
@@ -124,5 +149,8 @@ Do you want me to apply these corrections? (yes/no)
 - **Corrections are ONLY applied by this wrapper** (Step 5), after explicit approval.
 - **Corrections must be surgical**: only what is necessary to resolve the reported issues.
 - Maximum 2 rounds of automatic correction before escalating to manual.
-- If the sub-agent returned something out of format, inform: "The validator returned an unstructured report — continue manually."
+- **Sub-agent failsafe (CA-01)**: if the validator fails to load (tool error) or returns no response — stop and inform the user. Do NOT escalate to any other agent.
+- **Unstructured output (CA-02)**: if the validator responds but without a `refacil-verify-result` block — show the raw report and stop. Do NOT re-invoke another agent.
+- **SCOPE_ERROR (CR-03)**: if the validator returns `SCOPE_ERROR: <reason>` — propagate and ask for clarification. CA-01 does NOT apply here.
+- **Agent missing (CA-12)**: checked in Step 0.6 — stop before delegating if `.claude/agents/refacil-validator.md` is absent.
 - **Flow continuity**: if the result is APPROVED and the user confirms affirmatively, immediately invoke the **Skill tool** with `skill: "refacil:review"`. (See `METHODOLOGY-CONTRACT.md §5`.)