sistema-multiagente-sdlc 1.3.0 → 1.4.0

package/CHANGELOG.md

@@ -4,6 +4,27 @@
 
 _No hay cambios pendientes._
 
+## [1.4.0] — 2026-05-24
+
+### Added
+
+- ADR `0004-codegraph-graphify-orden-canonico.md`: cierra la decisión pendiente de ADR 0002 y canoniza CodeGraph para estructura de código + Graphify para semántica documental/export Obsidian.
+- Runtime Node multiagente como interfaz canónica: `sdlc session-start`, `resume`, `save`, `continua`, `memory-sync`, `validate-runtime` y `hooks install --post-merge-checkpoint`.
+- `.sdlc/session.json` como estado generado de sesión para healthcheck y continuidad cross-IDE.
+- Skills canónicas `resume`, `save` y `continua` bajo `.github/skills/` y mirrors para `.claude/`, `.agents/` y `.windsurf/`, todas apuntando al mismo CLI `sdlc`.
+- `templates/scripts/continua.mjs` como implementación portable Node de continuidad; `continua.ps1` queda como wrapper Windows delgado.
+- Migración `1.4.0` con marcador `.sdlc/migrations/1.4.0-applied.txt`.
+
+### Changed
+
+- `sdlc doctor` y el runner de regresión validan la versión `1.4.0`.
+- El manifest de skills gobernadas incluye `resume`, `save` y `continua`.
+- La continuidad multiagente deja de depender de PowerShell como runtime primario; PowerShell queda para compatibilidad en Windows.
+
+### Tests
+
+- Regresión extendida con smoke tests de `session-start`, `resume`, `save --no-mutate`, `continua`, `memory-sync --mode health`, `validate-runtime` y `hooks install`.
+
 ## [1.3.0] — 2026-05-23
 
 ### Added

package/README.md

@@ -47,6 +47,28 @@ node ./bin/sdlc.js install --target ../legacy-project --mode legacy --project-na
 node ./bin/sdlc.js doctor --target ../legacy-project --json
 ```
 
+## Runtime Multiagente
+
+Desde `1.4.0`, `sdlc` incluye comandos ejecutables para continuidad cross-IDE. El runtime primario es Node; los wrappers PowerShell solo existen para ergonomia Windows.
+
+```powershell
+sdlc session-start --target . --json
+sdlc resume --target . --markdown
+sdlc save --target . --event manual --json
+sdlc continua --target . --platform codex --json
+sdlc memory-sync --target . --mode health --json
+sdlc validate-runtime --target . --json
+sdlc hooks install --target . --post-merge-checkpoint --json
+```
+
+Reglas base:
+
+- `session-start` crea `.sdlc/session.json` con healthcheck de Headroom, CodeGraph, Graphify, caveman, vault y slice actual.
+- `resume` es solo lectura y recompone contexto en orden repo -> CodeGraph -> Graphify -> vault.
+- `save` escribe checkpoints locales en el vault; no promueve GitHub Issues, OpenSpec ni PRs sin gate humano.
+- `hooks install --post-merge-checkpoint` instala un hook local `post-merge` que ejecuta `sdlc save --event post-merge`.
+- `memory-sync --mode nightly --apply` importa chats y exporta Graphify al vault; no crea checkpoints automaticos.
+
 ## Modes
 
 | Mode | Use when | Adds |
@@ -124,7 +146,7 @@ All external installs are opt-in. Scripts default to dry-run or local-only behav
 
 Side-by-side de los dos frameworks. La intención no es competir sino aclarar dónde se solapan y dónde cada uno se especializa. Datos de BMAD tomados de su README oficial v6 (`bmad-code-org/BMAD-METHOD`, npm `bmad-method`).
 
-| Feature | BMAD-METHOD v6 | SistemaMultiagente_SDLC v1.3.0 |
+| Feature | BMAD-METHOD v6 | SistemaMultiagente_SDLC v1.4.0 |
 | --- | --- | --- |
 | License | MIT | MIT |
 | Runtime requisitos | Node ≥20.12, Python ≥3.10, `uv` | Node ≥18, PowerShell (pwsh/powershell), Git |

package/migrations/1.4.0/README.md

@@ -0,0 +1,8 @@
+# Migration 1.4.0
+
+Adds the executable runtime layer for multi-agent continuity:
+
+- Node-first `sdlc` runtime commands.
+- Generated `.sdlc/session.json`.
+- Cross-IDE `resume`, `save`, and `continua` skills.
+- Thin PowerShell wrappers for Windows convenience.

package/migrations/1.4.0/up.mjs

@@ -0,0 +1,14 @@
+export function up(files = {}) {
+  const extra = {
+    ".sdlc/migrations/1.4.0-applied.txt": "Migration 1.4.0 applied by SistemaMultiagente_SDLC.\ngenerated-by-sdlc\n"
+  };
+
+  const configPath = ".sdlc/config.json";
+  if (typeof files[configPath] === "string") {
+    const config = JSON.parse(files[configPath]);
+    config.frameworkVersion = "1.4.0";
+    extra[configPath] = `${JSON.stringify(config, null, 2)}\n`;
+  }
+
+  return extra;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sistema-multiagente-sdlc",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "Framework reusable para instalar un SDLC multiagente gobernado en repos greenfield o legacy.",
   "type": "module",
   "bin": {

package/src/cli.js

@@ -17,6 +17,15 @@ import {
 } from "./file-utils.js";
 import { buildManagedFiles, defaultConfig, FRAMEWORK_VERSION, validateConfigShape } from "./render.js";
 import { applyMigrations, migrationsToRun, SUPPORTED_VERSIONS } from "./migrations.js";
+import {
+  commandContinua,
+  commandHooks,
+  commandMemorySync,
+  commandResume,
+  commandSave,
+  commandSessionStart,
+  commandValidateRuntime
+} from "./runtime.js";
 
 const EXIT_OK = 0;
 const EXIT_ERROR = 1;
@@ -44,7 +53,10 @@ function parseArgs(argv) {
     }
     positionals.push(token);
   }
-  result.command = positionals[0] ?? "help";
+  result.positionals = positionals;
+  result.command = positionals[0] === "hooks" && positionals[1] === "install"
+    ? "hooks install"
+    : positionals[0] ?? "help";
   return result;
 }
 
@@ -622,7 +634,7 @@ function commandHelp() {
     exitCode: EXIT_OK,
     payload: {
       status: "ok",
-      message: "Uso: sdlc <init|install|upgrade|rollback|doctor|diff|prune-backups|migrate-config> [--target <repo>] [--json]\nSi --target se omite, se usa el directorio actual (process.cwd())."
+      message: "Uso: sdlc <init|install|upgrade|rollback|doctor|diff|prune-backups|migrate-config|session-start|resume|save|continua|memory-sync|validate-runtime|hooks install> [--target <repo>] [--json]\nSi --target se omite, se usa el directorio actual (process.cwd())."
     }
   };
 }
@@ -645,6 +657,20 @@ export function run(argv) {
       return commandPruneBackups(parsed.options);
     case "migrate-config":
       return commandMigrateConfig(parsed.options);
+    case "session-start":
+      return commandSessionStart(parsed.options);
+    case "resume":
+      return commandResume(parsed.options);
+    case "save":
+      return commandSave(parsed.options);
+    case "continua":
+      return commandContinua(parsed.options);
+    case "memory-sync":
+      return commandMemorySync(parsed.options);
+    case "validate-runtime":
+      return commandValidateRuntime(parsed.options);
+    case "hooks install":
+      return commandHooks(parsed.options);
     case "help":
     default:
       return commandHelp();

package/src/migrations.js

@@ -2,12 +2,14 @@ import { up as up_1_0_1 } from "../migrations/1.0.1/up.mjs";
 import { up as up_1_1_0 } from "../migrations/1.1.0/up.mjs";
 import { up as up_1_2_0 } from "../migrations/1.2.0/up.mjs";
 import { up as up_1_3_0 } from "../migrations/1.3.0/up.mjs";
+import { up as up_1_4_0 } from "../migrations/1.4.0/up.mjs";
 
 const REGISTRY = [
   { version: "1.0.1", up: up_1_0_1 },
   { version: "1.1.0", up: up_1_1_0 },
   { version: "1.2.0", up: up_1_2_0 },
-  { version: "1.3.0", up: up_1_3_0 }
+  { version: "1.3.0", up: up_1_3_0 },
+  { version: "1.4.0", up: up_1_4_0 }
 ];
 
 function semverTuple(v) {

package/src/render.js

@@ -2,7 +2,7 @@ import path from "node:path";
 import { renderTemplates } from "./template-loader.js";
 export { validateConfigShape } from "./config-validator.js";
 
-export const FRAMEWORK_VERSION = "1.3.0";
+export const FRAMEWORK_VERSION = "1.4.0";
 export const SCHEMA_VERSION = 1;
 export const SUPPORTED_MODES = new Set(["greenfield", "legacy"]);
 

package/src/runtime.js

@@ -0,0 +1,476 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { ensureDir, pathExists, readJson, readTextIfExists, writeJson, writeText } from "./file-utils.js";
+
+const EXIT_OK = 0;
+const EXIT_ERROR = 1;
+const EXIT_ACTION_REQUIRED = 2;
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function expandEnv(value) {
+  if (!value || typeof value !== "string") return value;
+  return value
+    .replace(/%([^%]+)%/g, (_, name) => process.env[name] ?? `%${name}%`)
+    .replace(/\$\{([^}]+)\}/g, (_, name) => process.env[name] ?? `\${${name}}`);
+}
+
+function safeReadJson(filePath) {
+  try {
+    return pathExists(filePath) ? readJson(filePath) : null;
+  } catch {
+    return null;
+  }
+}
+
+function getConfig(target) {
+  return safeReadJson(path.join(target, ".sdlc", "config.json")) ?? {};
+}
+
+function getProjectSlug(target, config = getConfig(target)) {
+  return config.project?.slug || path.basename(path.resolve(target)).toLowerCase().replace(/[^a-z0-9]+/g, "-");
+}
+
+function runCommand(command, args = [], cwd = process.cwd(), timeout = 8000) {
+  const windowsShell = process.platform === "win32";
+  const quoteWindowsArg = (value) => {
+    const text = String(value);
+    return /[\s"&|<>^]/.test(text) ? `"${text.replace(/"/g, '\\"')}"` : text;
+  };
+  const result = windowsShell
+    ? spawnSync([command, ...args].map(quoteWindowsArg).join(" "), {
+        cwd,
+        encoding: "utf8",
+        shell: true,
+        timeout
+      })
+    : spawnSync(command, args, {
+        cwd,
+        encoding: "utf8",
+        timeout
+      });
+  return {
+    ok: result.status === 0,
+    status: result.status,
+    stdout: (result.stdout ?? "").trim(),
+    stderr: (result.stderr ?? "").trim(),
+    error: result.error?.message
+  };
+}
+
+function checkHttp(url, timeoutMs = 1200) {
+  const code = `
+    const url = ${JSON.stringify(url)};
+    const timeout = ${Number(timeoutMs)};
+    const signal = AbortSignal.timeout(timeout);
+    fetch(url, { signal })
+      .then((res) => process.exit(res.ok ? 0 : 2))
+      .catch(() => process.exit(1));
+  `;
+  const result = spawnSync(process.execPath, ["-e", code], { encoding: "utf8", timeout: timeoutMs + 1000 });
+  return result.status === 0;
+}
+
+function fileAgeHours(filePath) {
+  if (!pathExists(filePath)) return null;
+  return Math.round(((Date.now() - fs.statSync(filePath).mtimeMs) / 36_000) / 100) / 100;
+}
+
+function latestFile(root, extension = ".md") {
+  if (!pathExists(root)) return null;
+  const files = [];
+  const walk = (current) => {
+    for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
+      const absolute = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        walk(absolute);
+      } else if (entry.name.endsWith(extension)) {
+        files.push(absolute);
+      }
+    }
+  };
+  walk(root);
+  return files
+    .map((file) => ({ file, mtime: fs.statSync(file).mtimeMs }))
+    .sort((a, b) => b.mtime - a.mtime)[0]?.file ?? null;
+}
+
+function preview(text, max = 900) {
+  if (!text) return null;
+  const clean = text.replace(/\s+/g, " ").trim();
+  return clean.length > max ? `${clean.slice(0, max).trim()}...` : clean;
+}
+
+function resolveMemoryConfig(target) {
+  const localPath = path.join(target, "scripts", "obsidian-memory.config.local.json");
+  const examplePath = path.join(target, "scripts", "obsidian-memory.config.example.json");
+  const configPath = pathExists(localPath) ? localPath : pathExists(examplePath) ? examplePath : null;
+  const config = configPath ? safeReadJson(configPath) : null;
+  const projectSlug = config?.projectSlug || getProjectSlug(target);
+  const rawVault = config?.vaultRoot || config?.obsidian?.vaultPath;
+  const vaultRoot = rawVault && !String(rawVault).includes("{{") ? path.resolve(expandEnv(String(rawVault))) : path.join(target, ".sdlc", "vault");
+  return {
+    configPath,
+    config,
+    projectSlug,
+    vaultRoot,
+    projectRoot: path.join(vaultRoot, projectSlug),
+    checkpointsDir: path.join(vaultRoot, projectSlug, "checkpoints"),
+    syncLogsDir: path.join(vaultRoot, projectSlug, "logs", "sync"),
+    graphifyDir: config?.graphifyObsidianDir ? path.resolve(expandEnv(String(config.graphifyObsidianDir))) : path.join(vaultRoot, "graphify", projectSlug)
+  };
+}
+
+function readState(target) {
+  const currentSlicePath = path.join(target, ".github", "agent-state", "current-slice.md");
+  const activeSlicesPath = path.join(target, ".github", "agent-state", "active-slices.yaml");
+  const phaseStatusPath = path.join(target, ".github", "agent-state", "phase-status.yaml");
+  const currentSlice = readTextIfExists(currentSlicePath);
+  const activeSlices = readTextIfExists(activeSlicesPath);
+  const phaseStatus = readTextIfExists(phaseStatusPath);
+  const sliceId = currentSlice?.match(/`([^`]+)`/)?.[1] ?? "unknown";
+  const phase = currentSlice?.match(/SDLC Phase\s*\n\s*-\s*`([^`]+)`/i)?.[1] ?? currentSlice?.match(/\bF\d+(?:\.\d+)?\b/)?.[0] ?? "unknown";
+  return {
+    currentSlicePath,
+    activeSlicesPath,
+    phaseStatusPath,
+    sliceId,
+    phase,
+    currentSlicePreview: preview(currentSlice),
+    activeSlicesPreview: preview(activeSlices),
+    phaseStatusPreview: preview(phaseStatus),
+    activeSliceDeclared: Boolean(activeSlices && /active:\s*\n\s*-\s*/.test(activeSlices))
+  };
+}
+
+function schedulerHeadroomTask() {
+  if (process.platform !== "win32") {
+    return { supported: false, exists: false, taskName: null };
+  }
+  const ps = [
+    "-NoProfile",
+    "-Command",
+    "Get-ScheduledTask | Where-Object { $_.TaskName -match 'Headroom' } | Select-Object -First 1 -ExpandProperty TaskName"
+  ];
+  const result = spawnSync("powershell.exe", ps, { encoding: "utf8", timeout: 5000 });
+  const stdout = (result.stdout ?? "").trim();
+  return { supported: true, exists: result.status === 0 && Boolean(stdout), taskName: stdout || null };
+}
+
+function collectRuntime(target) {
+  const config = getConfig(target);
+  const memory = resolveMemoryConfig(target);
+  const state = readState(target);
+  const claudeSettings = safeReadJson(path.join(os.homedir(), ".claude", "settings.json"));
+  const claudeSettingsText = claudeSettings ? JSON.stringify(claudeSettings) : "";
+  const codegraphDb = path.join(target, ".codegraph", "codegraph.db");
+  const codegraphStatus = pathExists(path.join(target, ".codegraph", "config.json")) ? runCommand("codegraph", ["status"], target, 12_000) : null;
+  const graphManifest = path.join(target, "graphify-out", "manifest.json");
+  const graphReport = path.join(target, "graphify-out", "GRAPH_REPORT.md");
+  const gitBranch = runCommand("git", ["branch", "--show-current"], target, 5000);
+  const gitHead = runCommand("git", ["log", "-1", "--oneline"], target, 5000);
+  const scheduler = schedulerHeadroomTask();
+
+  return {
+    generatedAt: nowIso(),
+    target,
+    project: getProjectSlug(target, config),
+    git: {
+      branch: gitBranch.ok ? gitBranch.stdout : null,
+      head: gitHead.ok ? gitHead.stdout : null
+    },
+    state,
+    headroom: {
+      healthUrl: "http://127.0.0.1:8787/health",
+      healthy: checkHttp("http://127.0.0.1:8787/health"),
+      claudeBaseUrl: claudeSettings?.env?.ANTHROPIC_BASE_URL ?? null,
+      hookDetected: /headroom\s+init\s+hook\s+ensure/i.test(claudeSettingsText),
+      scheduler
+    },
+    caveman: {
+      hookDetected: /caveman-activate\.js/i.test(claudeSettingsText),
+      trackerDetected: /caveman-mode-tracker\.js/i.test(claudeSettingsText),
+      flag: readTextIfExists(path.join(os.homedir(), ".claude", ".caveman-active"))?.trim() ?? null
+    },
+    codegraph: {
+      configured: pathExists(path.join(target, ".codegraph", "config.json")),
+      dbPath: pathExists(codegraphDb) ? codegraphDb : null,
+      dbAgeHours: fileAgeHours(codegraphDb),
+      statusOk: codegraphStatus ? codegraphStatus.ok : false,
+      statusPreview: codegraphStatus ? preview(codegraphStatus.stdout || codegraphStatus.stderr, 500) : null
+    },
+    graphify: {
+      graphPath: pathExists(path.join(target, "graphify-out", "graph.json")) ? path.join(target, "graphify-out", "graph.json") : null,
+      manifestAgeHours: fileAgeHours(graphManifest),
+      reportAgeHours: fileAgeHours(graphReport)
+    },
+    vault: {
+      configPath: memory.configPath,
+      root: memory.vaultRoot,
+      exists: pathExists(memory.vaultRoot),
+      latestCheckpoint: latestFile(memory.checkpointsDir) ?? latestFile(path.join(memory.projectRoot, "logs"))
+    }
+  };
+}
+
+function lazyRefreshCodeGraph(target, runtime) {
+  if (!runtime.codegraph.configured || runtime.codegraph.statusOk) {
+    return { attempted: false, reason: runtime.codegraph.configured ? "status-ok" : "not-configured" };
+  }
+
+  const result = runCommand("codegraph", ["sync", "."], target, 60_000);
+  return {
+    attempted: true,
+    ok: result.ok,
+    status: result.status,
+    preview: preview(result.stdout || result.stderr, 500)
+  };
+}
+
+function runtimeFindings(runtime) {
+  const findings = [];
+  const add = (level, code, message) => findings.push({ level, code, message });
+  if (!runtime.headroom.hookDetected) add("warning", "headroom-hook-missing", "Claude headroom hook not detected.");
+  if (!runtime.headroom.scheduler.exists) add("warning", "headroom-scheduler-missing", "Headroom Scheduler fallback not detected.");
+  if (!runtime.caveman.hookDetected) add("warning", "caveman-hook-missing", "Caveman activation hook not detected.");
+  if (runtime.codegraph.configured && !runtime.codegraph.statusOk) add("warning", "codegraph-status", "CodeGraph configured but status check failed.");
+  if (runtime.graphify.manifestAgeHours !== null && runtime.graphify.manifestAgeHours > 24) add("warning", "graphify-stale", `Graphify manifest age ${runtime.graphify.manifestAgeHours}h.`);
+  if (!runtime.vault.exists) add("warning", "vault-missing", `Vault path not found: ${runtime.vault.root}`);
+  if (runtime.state.sliceId !== "unknown" && !runtime.state.activeSliceDeclared) add("warning", "active-slices-empty", "current-slice exists but active-slices.yaml has no active entry.");
+  return findings;
+}
+
+export function commandSessionStart(options) {
+  const target = path.resolve(options.target ?? process.cwd());
+  let runtime = collectRuntime(target);
+  const codegraphRefresh = lazyRefreshCodeGraph(target, runtime);
+  if (codegraphRefresh.attempted) {
+    runtime = collectRuntime(target);
+  }
+  runtime.codegraph.lazyRefresh = codegraphRefresh;
+  const findings = runtimeFindings(runtime);
+  const payload = {
+    status: findings.some((f) => f.level === "error") ? "error" : findings.length > 0 ? "warning" : "ok",
+    runtime,
+    findings
+  };
+  writeJson(path.join(target, ".sdlc", "session.json"), payload);
+  return { exitCode: EXIT_OK, payload };
+}
+
+export function commandValidateRuntime(options) {
+  const target = path.resolve(options.target ?? process.cwd());
+  const runtime = collectRuntime(target);
+  const findings = runtimeFindings(runtime);
+  const hasErrors = findings.some((f) => f.level === "error");
+  const hasWarnings = findings.some((f) => f.level === "warning");
+  return {
+    exitCode: hasErrors ? EXIT_ERROR : hasWarnings ? EXIT_ACTION_REQUIRED : EXIT_OK,
+    payload: {
+      status: hasErrors ? "error" : hasWarnings ? "warning" : "ok",
+      findings,
+      runtime
+    }
+  };
+}
+
+export function commandResume(options) {
+  const target = path.resolve(options.target ?? process.cwd());
+  const runtime = collectRuntime(target);
+  const memory = resolveMemoryConfig(target);
+  const openSpecChanges = path.join(target, "openspec", "changes");
+  const activeChanges = pathExists(openSpecChanges)
+    ? fs.readdirSync(openSpecChanges, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name !== "archive").map((entry) => entry.name)
+    : [];
+  const result = {
+    status: "ok",
+    ownerAgent: runtime.state.phase === "definition" ? "analista-requisitos-migracion" : "orquestador-opus",
+    sliceId: runtime.state.sliceId,
+    phase: runtime.state.phase,
+    branch: runtime.git.branch,
+    head: runtime.git.head,
+    activeChanges,
+    latestCheckpoint: runtime.vault.latestCheckpoint,
+    readinessStatus: "unknown",
+    promotionStatus: "draft-local",
+    nextCommand: runtime.state.phase === "definition" ? "/enrich-us o Continua con analista-requisitos-migracion" : "Continua",
+    runtimeSummary: {
+      headroomHealthy: runtime.headroom.healthy,
+      codegraphOk: runtime.codegraph.statusOk,
+      graphifyReportAgeHours: runtime.graphify.reportAgeHours,
+      vault: memory.vaultRoot
+    }
+  };
+  if (options.markdown) {
+    return {
+      exitCode: EXIT_OK,
+      payload: {
+        status: "ok",
+        message: [
+          "# SDLC Resume",
+          "",
+          `- owner-agent: ${result.ownerAgent}`,
+          `- slice-id: ${result.sliceId}`,
+          `- phase: ${result.phase}`,
+          `- branch: ${result.branch ?? "unknown"}`,
+          `- latest-checkpoint: ${result.latestCheckpoint ?? "none"}`,
+          `- next-command: ${result.nextCommand}`,
+          "",
+          "## Active OpenSpec changes",
+          "",
+          ...(activeChanges.length ? activeChanges.map((change) => `- ${change}`) : ["- none"])
+        ].join("\n")
+      }
+    };
+  }
+  return { exitCode: EXIT_OK, payload: result };
+}
+
+export function commandSave(options) {
+  const target = path.resolve(options.target ?? process.cwd());
+  const event = options.event ?? "manual";
+  const noMutate = Boolean(options["no-mutate"] || options["dry-run"]);
+  let runtime = collectRuntime(target);
+  const codegraphRefresh = lazyRefreshCodeGraph(target, runtime);
+  if (codegraphRefresh.attempted) {
+    runtime = collectRuntime(target);
+  }
+  runtime.codegraph.lazyRefresh = codegraphRefresh;
+  const memory = resolveMemoryConfig(target);
+  const timestamp = new Date().toISOString().replace(/[-:TZ.]/g, "").slice(0, 12);
+  const sliceSlug = runtime.state.sliceId === "unknown" ? "unknown" : runtime.state.sliceId.toLowerCase().replace(/[^a-z0-9]+/g, "-");
+  const checkpointPath = path.join(memory.checkpointsDir, `${timestamp}-slice-${sliceSlug}.md`);
+  const diffStat = runCommand("git", ["diff", "--stat"], target, 5000);
+  const content = [
+    "---",
+    "generated_by: sdlc-save",
+    `event: ${event}`,
+    `created_at: ${nowIso()}`,
+    `slice: ${runtime.state.sliceId}`,
+    `phase: ${runtime.state.phase}`,
+    `branch: ${runtime.git.branch ?? "unknown"}`,
+    "promotion_status: draft-local",
+    "---",
+    "",
+    `# Checkpoint ${runtime.state.sliceId}`,
+    "",
+    "## Runtime",
+    "",
+    `- Headroom healthy: ${runtime.headroom.healthy}`,
+    `- CodeGraph OK: ${runtime.codegraph.statusOk}`,
+    `- Graphify report age hours: ${runtime.graphify.reportAgeHours ?? "unknown"}`,
+    "",
+    "## Git Diff Stat",
+    "",
+    "```text",
+    diffStat.stdout || "(no diff)",
+    "```",
+    "",
+    "## Next Command",
+    "",
+    runtime.state.phase === "definition" ? "Continua con analista-requisitos-migracion." : "Continua.",
+    ""
+  ].join("\n");
+  if (!noMutate) {
+    ensureDir(path.dirname(checkpointPath));
+    writeText(checkpointPath, content);
+  }
+  return {
+    exitCode: EXIT_OK,
+    payload: {
+      status: "ok",
+      dry_run: noMutate,
+      event,
+      checkpoint: checkpointPath
+    }
+  };
+}
+
+export function commandContinua(options) {
+  const session = commandSessionStart(options).payload;
+  const resume = commandResume(options).payload;
+  return {
+    exitCode: EXIT_OK,
+    payload: {
+      status: "ok",
+      platform: options.platform ?? "codex",
+      sessionStatus: session.status,
+      resume
+    }
+  };
+}
+
+export function commandMemorySync(options) {
+  const target = path.resolve(options.target ?? process.cwd());
+  const mode = options.mode ?? "health";
+  const apply = Boolean(options.apply);
+  const memory = resolveMemoryConfig(target);
+  const steps = [];
+  const logLines = [`[${nowIso()}] memory-sync mode=${mode} apply=${apply}`];
+  const addStep = (name, result) => {
+    steps.push({ name, ...result });
+    logLines.push(`[${nowIso()}] ${name}: ${result.status}`);
+  };
+  const configOk = Boolean(memory.configPath && pathExists(memory.configPath));
+  addStep("config", { status: configOk ? "ok" : "missing", path: memory.configPath });
+  if (mode === "health" || !apply) {
+    return { exitCode: configOk ? EXIT_OK : EXIT_ACTION_REQUIRED, payload: { status: configOk ? "ok" : "warning", dry_run: !apply, mode, steps } };
+  }
+  ensureDir(memory.syncLogsDir);
+  const logPath = path.join(memory.syncLogsDir, `${new Date().toISOString().replace(/[-:TZ.]/g, "").slice(0, 12)}-${mode}.log`);
+  if (["sync", "nightly"].includes(mode)) {
+    const converter = path.join(target, "scripts", "claude-to-obsidian.py");
+    if (configOk && pathExists(converter)) {
+      const result = runCommand(options["python-exe"] ?? "python", [converter, "--config", memory.configPath], target, 60_000);
+      addStep("sync", { status: result.ok ? "ok" : "error", stdout: result.stdout, stderr: result.stderr });
+    } else {
+      addStep("sync", { status: "skipped", reason: "config or converter missing" });
+    }
+  }
+  if (["export-graph", "nightly"].includes(mode)) {
+    const exporter = path.join(target, "scripts", "export-graphify-obsidian.py");
+    const graph = path.join(target, "graphify-out", "graph.json");
+    if (pathExists(exporter) && pathExists(graph)) {
+      const result = runCommand(options["python-exe"] ?? "python", [exporter, "--graph", graph, "--output-dir", memory.graphifyDir], target, 60_000);
+      addStep("export-graph", { status: result.ok ? "ok" : "error", stdout: result.stdout, stderr: result.stderr });
+    } else {
+      addStep("export-graph", { status: "skipped", reason: "graphify export inputs missing" });
+    }
+  }
+  writeText(logPath, `${logLines.join("\n")}\n`);
+  const failed = steps.some((step) => step.status === "error");
+  return { exitCode: failed ? EXIT_ERROR : EXIT_OK, payload: { status: failed ? "error" : "ok", dry_run: false, mode, logPath, steps } };
+}
+
+export function commandHooks(options) {
+  const target = path.resolve(options.target ?? process.cwd());
+  if (!options["post-merge-checkpoint"]) {
+    return { exitCode: EXIT_ERROR, payload: { status: "error", message: "Falta --post-merge-checkpoint" } };
+  }
+  const hookPath = path.join(target, ".git", "hooks", "post-merge");
+  const script = [
+    "#!/bin/sh",
+    "# generated by SistemaMultiagente_SDLC",
+    "target=\"$(pwd)\"",
+    "if command -v cygpath >/dev/null 2>&1; then",
+    "  target=\"$(cygpath -w \"$target\")\"",
+    "elif pwd -W >/dev/null 2>&1; then",
+    "  target=\"$(pwd -W)\"",
+    "fi",
+    "if command -v npx >/dev/null 2>&1; then",
+    "  npx --no-install sdlc save --target \"$target\" --event post-merge --json >/dev/null 2>&1 || true",
+    "fi",
+    ""
+  ].join("\n");
+  writeText(hookPath, script);
+  try {
+    fs.chmodSync(hookPath, 0o755);
+  } catch {
+    // chmod is best-effort on Windows.
+  }
+  return { exitCode: EXIT_OK, payload: { status: "ok", hook: hookPath } };
+}

package/templates/.agents/skills/continua/SKILL.md

@@ -0,0 +1,8 @@
+---
+name: continua
+description: "Continua el flujo SDLC con `npx --no-install sdlc continua --target . --platform codex --json`."
+---
+
+# Continua
+
+Usar el CLI Node `sdlc continua` como entrada canónica cross-IDE.

package/templates/.agents/skills/resume/SKILL.md

@@ -0,0 +1,8 @@
+---
+name: resume
+description: "Reconstruye contexto SDLC sin mutar archivos usando `npx --no-install sdlc resume --target . --markdown`."
+---
+
+# Resume
+
+Usar el CLI Node `sdlc resume` como fuente unica del comportamiento cross-IDE.

package/templates/.agents/skills/save/SKILL.md

@@ -0,0 +1,8 @@
+---
+name: save
+description: "Guarda checkpoint SDLC portable usando `npx --no-install sdlc save --target . --event manual --json`."
+---
+
+# Save
+
+Usar el CLI Node `sdlc save`. No promover decisiones durables sin gate humano.

package/templates/.claude/skills/continua/SKILL.md

@@ -0,0 +1,18 @@
+---
+name: continua
+description: "Ejecuta session-start + resume para continuar un slice SDLC desde cualquier IDE. Usar cuando el usuario diga Continua."
+---
+
+# Continua
+
+Ejecutar:
+
+```powershell
+npx --no-install sdlc continua --target . --platform claude_code --json
+```
+
+Reglas:
+
+- Primero valida runtime.
+- Luego reconstruye contexto.
+- Si hay gate humano pendiente, no implementar; reportar owner y bloqueo.

package/templates/.claude/skills/resume/SKILL.md

@@ -0,0 +1,18 @@
+---
+name: resume
+description: "Reconstruye contexto SDLC sin mutar archivos usando el runtime Node de SistemaMultiagente_SDLC. Usar cuando el usuario invoque /resume o pida retomar contexto."
+---
+
+# Resume
+
+Ejecutar:
+
+```powershell
+npx --no-install sdlc resume --target . --markdown
+```
+
+Reglas:
+
+- No modificar archivos.
+- Respetar jerarquia repo -> CodeGraph -> Graphify -> vault.
+- Si falta definicion funcional o readiness, devolver owner a `analista-requisitos-migracion`.

package/templates/.claude/skills/save/SKILL.md

@@ -0,0 +1,18 @@
+---
+name: save
+description: "Escribe un checkpoint portable en el vault local usando el runtime Node de SistemaMultiagente_SDLC. Usar cuando el usuario invoque /save o pida guardar continuidad."
+---
+
+# Save
+
+Ejecutar:
+
+```powershell
+npx --no-install sdlc save --target . --event manual --json
+```
+
+Reglas:
+
+- Escribe checkpoint local en el vault.
+- No promueve a GitHub Issue, OpenSpec ni PR sin gate humano.
+- Marcar cualquier decision durable como pendiente de promocion al repo.

package/templates/.github/skills/continua/SKILL.md

@@ -0,0 +1,18 @@
+---
+name: continua
+description: "Ejecuta session-start + resume para continuar un slice SDLC desde cualquier IDE. Usar cuando el usuario diga Continua."
+---
+
+# Continua
+
+Comando canónico:
+
+```powershell
+npx --no-install sdlc continua --target . --platform claude_code --json
+```
+
+Reglas:
+
+- Primero valida runtime.
+- Luego reconstruye contexto.
+- Si hay gate humano pendiente, no implementar; reportar owner y bloqueo.

package/templates/.github/skills/resume/SKILL.md

@@ -0,0 +1,18 @@
+---
+name: resume
+description: "Reconstruye contexto SDLC sin mutar archivos usando el runtime Node de SistemaMultiagente_SDLC. Usar cuando el usuario invoque /resume o pida retomar contexto."
+---
+
+# Resume
+
+Comando canónico:
+
+```powershell
+npx --no-install sdlc resume --target . --markdown
+```
+
+Reglas:
+
+- No modificar archivos.
+- Respetar jerarquia repo -> CodeGraph -> Graphify -> vault.
+- Si falta definicion funcional o readiness, devolver owner a `analista-requisitos-migracion`.

package/templates/.github/skills/save/SKILL.md

@@ -0,0 +1,18 @@
+---
+name: save
+description: "Escribe un checkpoint portable en el vault local usando el runtime Node de SistemaMultiagente_SDLC. Usar cuando el usuario invoque /save o pida guardar continuidad."
+---
+
+# Save
+
+Comando canónico:
+
+```powershell
+npx --no-install sdlc save --target . --event manual --json
+```
+
+Reglas:
+
+- Escribe checkpoint local en el vault.
+- No promueve a GitHub Issue, OpenSpec ni PR sin gate humano.
+- Marcar cualquier decision durable como pendiente de promocion al repo.

package/templates/.sdlc/session.json

@@ -0,0 +1,8 @@
+{
+  "status": "new",
+  "generatedBy": "SistemaMultiagente_SDLC",
+  "frameworkVersion": "{{frameworkVersion}}",
+  "project": "{{project.slug}}",
+  "updatedAt": null,
+  "runtime": {}
+}

package/templates/.windsurf/skills/continua/SKILL.md

@@ -0,0 +1,8 @@
+---
+name: continua
+description: "Continua el flujo SDLC usando el CLI Node `sdlc continua`."
+---
+
+# Continua
+
+Ejecutar `npx --no-install sdlc continua --target . --platform windsurf --json`.

package/templates/.windsurf/skills/resume/SKILL.md

@@ -0,0 +1,8 @@
+---
+name: resume
+description: "Reconstruye contexto SDLC sin mutar archivos usando el CLI Node `sdlc resume`."
+---
+
+# Resume
+
+Ejecutar `npx --no-install sdlc resume --target . --markdown`.

package/templates/.windsurf/skills/save/SKILL.md

@@ -0,0 +1,8 @@
+---
+name: save
+description: "Guarda checkpoint SDLC portable usando el CLI Node `sdlc save`."
+---
+
+# Save
+
+Ejecutar `npx --no-install sdlc save --target . --event manual --json`.

package/templates/manifest.yaml

@@ -15,6 +15,8 @@ templates:
     target: indice-operativo.md
   - source: .sdlc/README.md
     target: .sdlc/README.md
+  - source: .sdlc/session.json
+    target: .sdlc/session.json
   - source: .github/AGENTS.md
     target: .github/AGENTS.md
   - source: .github/agents/ownership-matrix.md
@@ -87,6 +89,8 @@ templates:
     target: .graphifyignore
   - source: scripts/continua.ps1
     target: scripts/continua.ps1
+  - source: scripts/continua.mjs
+    target: scripts/continua.mjs
   - source: scripts/publish-trace.ps1
     target: scripts/publish-trace.ps1
   - source: scripts/export-graphify-obsidian.py
@@ -178,6 +182,30 @@ templates:
     target: .claude/skills/commit/SKILL.md
   - source: .github/skills/commit/SKILL.md
     target: .github/skills/commit/SKILL.md
+  - source: .github/skills/resume/SKILL.md
+    target: .github/skills/resume/SKILL.md
+  - source: .github/skills/save/SKILL.md
+    target: .github/skills/save/SKILL.md
+  - source: .github/skills/continua/SKILL.md
+    target: .github/skills/continua/SKILL.md
+  - source: .claude/skills/resume/SKILL.md
+    target: .claude/skills/resume/SKILL.md
+  - source: .claude/skills/save/SKILL.md
+    target: .claude/skills/save/SKILL.md
+  - source: .claude/skills/continua/SKILL.md
+    target: .claude/skills/continua/SKILL.md
+  - source: .agents/skills/resume/SKILL.md
+    target: .agents/skills/resume/SKILL.md
+  - source: .agents/skills/save/SKILL.md
+    target: .agents/skills/save/SKILL.md
+  - source: .agents/skills/continua/SKILL.md
+    target: .agents/skills/continua/SKILL.md
+  - source: .windsurf/skills/resume/SKILL.md
+    target: .windsurf/skills/resume/SKILL.md
+  - source: .windsurf/skills/save/SKILL.md
+    target: .windsurf/skills/save/SKILL.md
+  - source: .windsurf/skills/continua/SKILL.md
+    target: .windsurf/skills/continua/SKILL.md
   - source: .github/skills/openspec-propose/SKILL.md
     target: .github/skills/openspec-propose/SKILL.md
   - source: .github/skills/openspec-explore/SKILL.md

package/templates/scripts/agent-skills.manifest.json

@@ -27,6 +27,9 @@
     "openspec-verify",
     "operacion-cli-devops",
     "orquestacion-multiagente",
+    "resume",
+    "save",
+    "continua",
     "ui-ux-diseno"
   ],
   "externalCollections": [

package/templates/scripts/continua.mjs

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+function parseArgs(argv) {
+  const options = { platform: "codex", ttlHours: 4, noLock: false, json: false, vaultPath: "" };
+  for (let i = 0; i < argv.length; i += 1) {
+    const token = argv[i];
+    const next = argv[i + 1];
+    if (token === "--json" || token === "-Json") options.json = true;
+    else if (token === "--no-lock" || token === "-NoLock") options.noLock = true;
+    else if ((token === "--platform" || token === "-Platform") && next) { options.platform = next; i += 1; }
+    else if ((token === "--ttl-hours" || token === "-TtlHours") && next) { options.ttlHours = Number(next); i += 1; }
+    else if ((token === "--vault-path" || token === "-VaultPath") && next) { options.vaultPath = next; i += 1; }
+  }
+  return options;
+}
+
+function readText(filePath) {
+  return fs.existsSync(filePath) ? fs.readFileSync(filePath, "utf8") : null;
+}
+
+function preview(text, max = 700) {
+  if (!text) return null;
+  const clean = text.replace(/\s+/g, " ").trim();
+  return clean.length > max ? `${clean.slice(0, max).trim()}...` : clean;
+}
+
+function latestFile(root, extension = ".md") {
+  if (!root || !fs.existsSync(root)) return null;
+  const files = [];
+  const walk = (current) => {
+    for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
+      const absolute = path.join(current, entry.name);
+      if (entry.isDirectory()) walk(absolute);
+      else if (entry.name.endsWith(extension) && entry.name !== "TEMPLATE.md") files.push(absolute);
+    }
+  };
+  walk(root);
+  return files.map((file) => ({ file, mtime: fs.statSync(file).mtimeMs })).sort((a, b) => b.mtime - a.mtime)[0]?.file ?? null;
+}
+
+function resolveRepo() {
+  return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+}
+
+function resolveVault(repo, provided) {
+  if (provided) return provided;
+  const configPath = path.join(repo, "scripts", "obsidian-memory.config.local.json");
+  if (!fs.existsSync(configPath)) return "";
+  try {
+    const config = JSON.parse(fs.readFileSync(configPath, "utf8"));
+    return config.vaultRoot || "";
+  } catch {
+    return "";
+  }
+}
+
+const options = parseArgs(process.argv.slice(2));
+const repo = resolveRepo();
+const agentState = path.join(repo, ".github", "agent-state");
+const platformContext = path.join(agentState, "platform-context.json");
+const currentSlicePath = path.join(agentState, "current-slice.md");
+const phaseStatusPath = path.join(agentState, "phase-status.yaml");
+const activeSlicesPath = path.join(agentState, "active-slices.yaml");
+const handoffsDir = path.join(agentState, "handoffs");
+const graphReportPath = path.join(repo, "graphify-out", "GRAPH_REPORT.md");
+const vaultPath = resolveVault(repo, options.vaultPath);
+
+const now = new Date();
+const expires = new Date(now.getTime() + options.ttlHours * 60 * 60 * 1000);
+const currentSlice = readText(currentSlicePath);
+const phaseStatus = readText(phaseStatusPath);
+const activeSlices = readText(activeSlicesPath);
+const graphReport = readText(graphReportPath);
+const sliceId = currentSlice?.match(/`([^`]+)`/)?.[1] ?? "unknown";
+const slicePhase = currentSlice?.match(/\bF\d+(?:\.\d+)?\b/)?.[0] ?? "unknown";
+const latestHandoff = latestFile(handoffsDir);
+const latestVaultCheckpoint = latestFile(vaultPath);
+
+const result = {
+  status: "ok",
+  project: "{{project.slug}}",
+  generated_at: now.toISOString().replace(/\.\d{3}Z$/, "Z"),
+  platform: options.platform,
+  lock_written: !options.noLock,
+  lock: {
+    owner_platform: options.platform,
+    locked_at: now.toISOString().replace(/\.\d{3}Z$/, "Z"),
+    expires_at: expires.toISOString().replace(/\.\d{3}Z$/, "Z"),
+    ttl_hours: options.ttlHours
+  },
+  current_slice: {
+    id: sliceId,
+    phase: slicePhase,
+    preview: preview(currentSlice)
+  },
+  active_slices_preview: preview(activeSlices),
+  phase_status_preview: preview(phaseStatus),
+  latest_handoff: latestHandoff,
+  graph_report: {
+    path: graphReportPath,
+    exists: Boolean(graphReport),
+    preview: preview(graphReport)
+  },
+  vault_checkpoint: latestVaultCheckpoint
+};
+
+if (!options.noLock) {
+  fs.mkdirSync(agentState, { recursive: true });
+  fs.writeFileSync(platformContext, `${JSON.stringify(result, null, 2)}\n`, "utf8");
+}
+
+if (options.json) {
+  process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+} else {
+  process.stdout.write(`CONTINUA - SDLC context resume\nProject: {{project.slug}}\nPlatform: ${options.platform}\nSlice: ${sliceId} (${slicePhase})\nLatest handoff: ${latestHandoff ?? ""}\nVault checkpoint: ${latestVaultCheckpoint ?? ""}\nGraph report: ${Boolean(graphReport)}\n`);
+}

package/templates/scripts/continua.ps1

@@ -1,12 +1,6 @@
 <#
 .SYNOPSIS
-  Rebuilds SDLC working context and optionally writes the multi-agent lock.
-
-.DESCRIPTION
-  Reads .github/agent-state, graphify-out and the optional memory vault so an
-  agent can resume the active slice without rebuilding context from raw code.
-  By default it writes .github/agent-state/platform-context.json with a TTL lock.
-  Use -NoLock for a read-only preview.
+  Thin Windows wrapper for the Node-first continua runtime.
 #>
 
 [CmdletBinding()]
@@ -22,120 +16,16 @@ param(
 Set-StrictMode -Version Latest
 $ErrorActionPreference = 'Stop'
 
-$Repo = Split-Path $PSScriptRoot -Parent
-$AgentState = Join-Path $Repo '.github\agent-state'
-$PlatformContext = Join-Path $AgentState 'platform-context.json'
-$CurrentSlicePath = Join-Path $AgentState 'current-slice.md'
-$PhaseStatusPath = Join-Path $AgentState 'phase-status.yaml'
-$ActiveSlicesPath = Join-Path $AgentState 'active-slices.yaml'
-$HandoffsDir = Join-Path $AgentState 'handoffs'
-$GraphReportPath = Join-Path $Repo 'graphify-out\GRAPH_REPORT.md'
-
-function Read-TextOrNull {
-  param([string] $Path)
-  if (Test-Path -LiteralPath $Path) {
-    return (Get-Content -LiteralPath $Path -Raw)
-  }
-  return $null
-}
-
-function Get-Preview {
-  param([string] $Text, [int] $Max = 700)
-  if (-not $Text) { return $null }
-  if ($Text.Length -le $Max) { return $Text.Trim() }
-  return $Text.Substring(0, $Max).Trim()
-}
-
-function Get-LatestFile {
-  param([string] $Root, [string] $Filter = '*.md')
-  if (-not (Test-Path -LiteralPath $Root)) { return $null }
-  $files = @(Get-ChildItem -LiteralPath $Root -Filter $Filter -File -Recurse |
-    Where-Object { $_.Name -ne 'TEMPLATE.md' } |
-    Sort-Object LastWriteTimeUtc -Descending)
-  if ($files.Count -eq 0) { return $null }
-  return $files[0]
-}
-
-if (-not $VaultPath) {
-  $configPath = Join-Path $Repo 'scripts\obsidian-memory.config.local.json'
-  if (Test-Path -LiteralPath $configPath) {
-    try {
-      $config = Get-Content -LiteralPath $configPath -Raw | ConvertFrom-Json
-      if ($config.vaultRoot) { $VaultPath = [string] $config.vaultRoot }
-    } catch {
-      Write-Warning "No se pudo leer ${configPath}: $_"
-    }
-  }
-}
-
-$now = [datetime]::UtcNow
-$expires = $now.AddHours($TtlHours)
-$currentSlice = Read-TextOrNull -Path $CurrentSlicePath
-$phaseStatus = Read-TextOrNull -Path $PhaseStatusPath
-$activeSlices = Read-TextOrNull -Path $ActiveSlicesPath
-$graphReport = Read-TextOrNull -Path $GraphReportPath
-$latestHandoff = Get-LatestFile -Root $HandoffsDir
-$latestVaultCheckpoint = if ($VaultPath) { Get-LatestFile -Root $VaultPath } else { $null }
-
-$sliceId = 'unknown'
-$slicePhase = 'unknown'
-if ($currentSlice -and $currentSlice -match '`([^`]+)`') {
-  $sliceId = $Matches[1]
-}
-if ($currentSlice -and $currentSlice -match '(F\d+(?:\.\d+)?)') {
-  $slicePhase = $Matches[1]
+$ScriptRoot = $PSScriptRoot
+$NodeScript = Join-Path $ScriptRoot 'continua.mjs'
+if (-not (Test-Path -LiteralPath $NodeScript)) {
+  throw "continua.mjs not found: $NodeScript"
 }
 
-$result = [ordered]@{
-  status = 'ok'
-  project = '{{project.slug}}'
-  generated_at = $now.ToString('yyyy-MM-ddTHH:mm:ssZ')
-  platform = $Platform
-  lock_written = (-not $NoLock)
-  lock = [ordered]@{
-    owner_platform = $Platform
-    locked_at = $now.ToString('yyyy-MM-ddTHH:mm:ssZ')
-    expires_at = $expires.ToString('yyyy-MM-ddTHH:mm:ssZ')
-    ttl_hours = $TtlHours
-  }
-  current_slice = [ordered]@{
-    id = $sliceId
-    phase = $slicePhase
-    preview = Get-Preview -Text $currentSlice
-  }
-  active_slices_preview = Get-Preview -Text $activeSlices
-  phase_status_preview = Get-Preview -Text $phaseStatus
-  latest_handoff = if ($latestHandoff) { $latestHandoff.FullName } else { $null }
-  graph_report = [ordered]@{
-    path = $GraphReportPath
-    exists = [bool] $graphReport
-    preview = Get-Preview -Text $graphReport
-  }
-  vault_checkpoint = if ($latestVaultCheckpoint) { $latestVaultCheckpoint.FullName } else { $null }
-}
+$argsList = @($NodeScript, '--platform', $Platform, '--ttl-hours', [string]$TtlHours)
+if ($NoLock) { $argsList += '--no-lock' }
+if ($Json) { $argsList += '--json' }
+if ($VaultPath) { $argsList += @('--vault-path', $VaultPath) }
 
-if (-not $NoLock) {
-  if (-not (Test-Path -LiteralPath $AgentState)) {
-    New-Item -ItemType Directory -Path $AgentState -Force | Out-Null
-  }
-  $result | ConvertTo-Json -Depth 8 | Set-Content -LiteralPath $PlatformContext -Encoding UTF8
-}
-
-if ($Json) {
-  $result | ConvertTo-Json -Depth 8
-  exit 0
-}
-
-Write-Host ''
-Write-Host 'CONTINUA - SDLC context resume'
-Write-Host "Project: {{project.slug}}"
-Write-Host "Platform: $Platform"
-Write-Host "Slice: $sliceId ($slicePhase)"
-Write-Host "Latest handoff: $($result.latest_handoff)"
-Write-Host "Vault checkpoint: $($result.vault_checkpoint)"
-Write-Host "Graph report: $($result.graph_report.exists)"
-if ($NoLock) {
-  Write-Host 'Lock: preview only'
-} else {
-  Write-Host "Lock: written until $($result.lock.expires_at)"
-}
+& node @argsList
+exit $LASTEXITCODE