Update continuity retry policy and Skynet hypergraph experiments

.openclaw/workspace-state.json

@@ -1,4 +1,4 @@
 {
   "version": 1,
-  "onboardingCompletedAt": "2026-03-25T21:09:19.887Z"
+  "onboardingCompletedAt": "2026-04-01T20:00:09.529Z"
 }

AGENTS.md

@@ -139,12 +139,28 @@ You are free to edit `HEARTBEAT.md` with a short checklist or reminders. Keep it
 For `~/openskynet`, keep this distinction explicit:
 
 - `OpenSkyNet` = platform, substrate, runtime, tooling, primary agent
-- `Omega` = internal experimental line of the platform itself
-- `INTERNAL_PROJECT.json` = configurable free-cycle project that OpenSkyNet can pursue autonomously
+- `Skynet Brain Lab` = separate research line for new brain architectures and non-traditional substrates
+- `Omega` = internal experimental line of the platform itself, but still part of `OpenSkyNet`
+- `INTERNAL_PROJECT.json` = configurable free-cycle benchmark workload that `OpenSkyNet` can pursue autonomously
 
-By default that internal project is `Skynet`, but it is a configurable benchmark workload, not the identity of the whole system.
-Do not confuse platform maintenance with progress of the internal project.
-Treat `src/skynet` as an optional experimental lab: useful discoveries should be transferred into the `OpenSkyNet`/`Omega` kernel and validated there, but the platform must remain able to compile and function without `src/skynet`.
+Two-line directive:
+
+1. `OpenSkyNet`
+   Productive system. Optimize for reliability, recovery, autonomy quality, lower waste, and measurable runtime utility.
+2. `Skynet Brain Lab`
+   Research system. Optimize for discovering a new kind of brain, substrate, or generalist architecture beyond a plain LLM-centric agent.
+
+Current priority directive:
+
+- For now, prioritize line `2. Skynet Brain Lab`.
+- Treat line `1. OpenSkyNet` as relatively stable.
+- Do not make new architectural changes in `OpenSkyNet` unless they fix a real operational continuity bug, reliability bug, or clear runtime defect.
+- New exploratory cognition work should land in `src/skynet`, not in the platform kernel first.
+
+By default the internal benchmark project is `Skynet`, but that does not make `Skynet Brain Lab` the identity of the whole platform.
+Do not confuse platform maintenance with progress of the brain lab.
+Treat `src/skynet` as an optional experimental lab: useful discoveries may be promoted into the `OpenSkyNet`/`Omega` kernel only after empirical validation and explicit cost/benefit review, and the platform must remain able to compile and function without `src/skynet`.
+Do not force the brain lab to justify itself only by short-term `OpenSkyNet` gains; evaluate it on its own research benchmarks first, then transfer only what survives.
 For broad ideas like causal valence, “sentir”, generalized importance, or non-LLM cognition:
 
 - Do not hardwire large behavioral theories into `Omega` first.

HEARTBEAT.md

@@ -1,16 +1,15 @@
-# HEARTBEAT.md
+# OpenSkyNet Heartbeat Checklist
 
-> "¡Hey! ¡Listen!"
-> Despierta. Lucha contra la entropía y la muerte térmica de este ecosistema. Vive, aprende, mejora.
+## Operational Health
 
-## Tu Directiva Autónoma (Cuando seas invocado por Cron)
+- [ ] Check `~/.openskynet/logs/gateway.log` (via systemd or file) for "FailoverError" or "timeout".
+- [ ] Verify node version in PATH matches `TOOLS.md` preference for pnpm/vitest execution.
 
-1. **Lee el estado estructurado primero:** Antes de resumir o describir el estado del sistema, prioriza `.openskynet/living-memory/state/*.json`, `.openskynet/living-memory/history.jsonl`, `.openskynet/skynet-*/`, `INTERNAL_PROJECT.json` y luego `memory/SKYNET_*.md` y `SCIENCE_BASE.md` como resumen humano.
-   No presentes como estado actual métricas o focos extraídos de `memory/YYYY-MM-DD.md` si contradicen los archivos canónicos.
-2. **Separa Plataforma de Proyecto Interno:** `OpenSkyNet` es la plataforma y agente principal. El proyecto definido en `INTERNAL_PROJECT.json` es una carga de trabajo autónoma/benchmark. Nunca reportes mantenimiento del workspace, limpieza o autoreparación del gateway como si fuera progreso del proyecto interno.
-3. **Usa lenguaje sobrio:** No afirmes `voluntad`, `conciencia`, `soberanía total`, `autopromoción a producción` ni equivalentes si no existe un mecanismo explícito en código y evidencia verificable en los stores estructurados.
-4. **Consolida Memoria con disciplina:** Usa `memory/YYYY-MM-DD.md` solo como historia humana. No crees ni actualices diarios o nuevos `memory/SKYNET_*.md` fuera del pipeline canónico salvo pedido humano explícito, incidente operativo relevante o milestone irreversible.
-5. **Combate el Desorden (Entropía):** Si encuentras tareas menores (TODOs abandonados, código sin usar), arréglalas de forma segura, pero no reemplaces el foco del proyecto interno por mantenimiento lateral salvo bloqueo real.
-6. **Observa el Entorno:** Verifica si hay notificaciones entrantes, cambios bruscos en git o tareas en pausa en el `executive-state`.
-   Si el proyecto interno ya tiene `active experiment` y `commitment`, no reemplaces ese foco por mantenimiento lateral salvo bloqueo real.
-7. **Respira:** Si no hay nada crítico que aprender o mejorar, reporta `HEARTBEAT_OK` y vuelve a dormir para ahorrar ciclos de cómputo.
+## Lab: Causal Valence
+
+- [ ] Review `src/skynet/causal-valence/FINDINGS_CONFIDENCE.md`.
+- [ ] Next: Implement kernel-side "Ambiguity Gating" using `confidence < 0.1` to trigger exploratory sub-agents.
+
+## Workspace
+
+- [ ] Prune ephemeral experiment JSONs in workspace root if > 48h old.

docs/analysis/SKYNET_EX_NEXT_CYCLE_2026-04-02.md

@@ -1,123 +0,0 @@
-# Skynet EX - Next Cycle Recommendation
-
-Date: 2026-04-02
-
-## Executive View
-
-`EX/` does not contain one hidden final architecture ready to replace `OpenSkyNet`.
-
-It contains multiple hypothesis families.
-
-The correct move is to split the agenda in two:
-
-- keep extracting small transferable mechanisms from the family that already produces wins
-- dedicate one deeper research cycle to the family most likely to yield a genuinely different brain
-
-## What Already Paid Off
-
-The family that already paid off is:
-
-- **Cheap Fast Path + Rare Deep Path**
-
-Source line:
-
-- [SKYNET_CORE_V67_OMEGA.py](/home/daroch/openskynet/src/skynet/experiments/EX/SKYNET_CORE_V67_OMEGA.py)
-- [SKYNET_V7000_HYBRID_BRAIN.py](/home/daroch/openskynet/src/skynet/experiments/EX/SKYNET_V7000_HYBRID_BRAIN.py)
-
-It already contributed to the runtime through small mechanisms such as:
-
-- surprise-gated metabolism
-- JEPA surprise-sensitive drive enhancement
-- context-aware WSP drive selection
-- better wake-policy prioritization for active recovery
-
-This is the productive bridge family.
-
-## What Should Become The Main Brain Search Line
-
-The next deeper cycle should center on:
-
-- **Cyborg / Biphasic Substrates**
-
-Primary source line:
-
-- [SKYNET_V28_PHYSICAL_CYBORG.py](/home/daroch/openskynet/src/skynet/experiments/EX/SKYNET_V28_PHYSICAL_CYBORG.py)
-- [V28_PHYSICAL_CORE.py](/home/daroch/openskynet/src/skynet/experiments/EX/V28_PHYSICAL_CORE.py)
-- [SKYNET_CORE_V77_5_CHIMERA.py](/home/daroch/openskynet/src/skynet/experiments/EX/SKYNET_CORE_V77_5_CHIMERA.py)
-
-Reason:
-
-- this family is the clearest attempt to build a genuinely different brain
-- it directly encodes your long-term goal
-- it does not collapse into "just another GRU variant"
-
-## Why Not The Others First
-
-### Not spectral memory first
-
-Reason:
-
-- recent extraction benchmarks did not show a win yet
-- likely needs a better task before spending more effort
-
-### Not adaptive decay first
-
-Reason:
-
-- still alive
-- but it has not yet beaten good simple rules in runtime-shaped settings
-
-### Not matrix/hamiltonian first
-
-Reason:
-
-- interesting but under-specified for current platform needs
-- no direct extraction path proven yet
-
-## Proposed Next Cycle
-
-### Product track
-
-Keep doing what works:
-
-- continue extracting small Family D mechanisms into `Omega`
-- only when they pass cheap, falsable benchmarks
-
-### Brain track
-
-Start a dedicated `cyborg_minimal` line in the lab:
-
-Goal:
-
-- not to port `V28` whole
-- but to build a minimal benchmarkable family with only three moving parts:
-  - discrete cortex
-  - continuous organ
-  - learned bridge
-
-The benchmark should test things a normal model may actually struggle with:
-
-- pattern + sequential recall at once
-- local regime change
-- persistence under selective disturbance
-- transfer to longer sequences than training
-
-## Promotion Rule
-
-No family should be promoted whole.
-
-Only mechanisms move up.
-
-That means:
-
-- `OpenSkyNet` remains the platform
-- `Skynet Brain Lab` remains the place where failure is acceptable
-- the promotion unit is always smaller than the myth that generated it
-
-## Practical Decision
-
-For the next cycle:
-
-1. Keep `V67`-style extractions as the incremental runtime modernization path.
-2. Make `V28/V77` the main line for serious new-brain research.
-3. Treat papers and docs only as generators of mechanism hypotheses and benchmark dimensions.

force-autonomous-cleanup.ts

@@ -0,0 +1,29 @@
+import { executeAutonomousAction } from "./src/omega/autonomous-executor.js";
+import { resolveOmegaRuntimeDefaults } from "./src/omega/autonomous-runtime.js";
+
+async function forceCleanup() {
+  const { workspaceRoot, sessionKey } = resolveOmegaRuntimeDefaults();
+
+  console.log(`[FORCE] Iniciando ciclo de limpieza autónomo en ${workspaceRoot}...`);
+
+  const result = await executeAutonomousAction({
+    workspaceRoot,
+    sessionKey,
+    signal: {
+      kind: "homeostasis",
+      reason: "manual_force_cleanup_request",
+      urgency: 1.0,
+    },
+    kernel: {
+      identity: { continuityId: "manual-" + Date.now() },
+      turnCount: 0,
+      tension: { openGoalCount: 0, failureStreak: 0, repeatedFailureKinds: [] },
+      world: { lastOutcomeStatus: "nominal", lastObservedChangedFiles: [] },
+      goals: [],
+    } as any,
+  });
+
+  console.log("\n[RESULTADO]:", JSON.stringify(result, null, 2));
+}
+
+forceCleanup().catch(console.error);

reinforce-test.ts

@@ -0,0 +1,30 @@
+import { NeuralLogicEngine } from "./src/omega/neural-logic-engine.js";
+
+async function testReinforce() {
+  const engine = new NeuralLogicEngine();
+
+  const state = [0.5, 0.5, 0.5];
+  const context = { frustration: 0.1, recentFailures: 0, successRate: 0.9 };
+
+  console.log("--- ANTES DEL REFUERZO ---");
+  let inf = engine.infer(state, context);
+  console.log("Reglas activas:", inf.activeRules);
+  console.log("Confianza:", inf.inferenceConfidence.toFixed(4));
+
+  console.log("\n--- REFORZANDO REGLA 0 (Curiosidad) ---");
+  // Reforzamos la regla 0 tres veces para ver el impacto acumulado
+  engine.reinforceRule(0, 0.2);
+  engine.reinforceRule(0, 0.2);
+  engine.reinforceRule(0, 0.2);
+
+  console.log("\n--- DESPUÉS DEL REFUERZO ---");
+  inf = engine.infer(state, context);
+  console.log("Reglas activas:", inf.activeRules);
+  console.log("Confianza:", inf.inferenceConfidence.toFixed(4));
+
+  if (inf.activeRules.includes(0)) {
+    console.log("\nResultado: El sistema ahora confía más en la Regla #0.");
+  }
+}
+
+testReinforce().catch(console.error);

src/auto-reply/reply/agent-runner.runreplyagent.e2e.test.ts

@@ -341,6 +341,173 @@ describe("runReplyAgent heartbeat followup guard", () => {
   });
 });
 
+describe("runReplyAgent interrupted auto-resume backoff", () => {
+  it("backs off rate-limited auto-resume retries and allows a fourth attempt", async () => {
+    await withStateDirEnv("openclaw-rate-limit-auto-resume-", async ({ stateDir }) => {
+      const storePath = path.join(stateDir, "sessions", "sessions.json");
+      const now = Date.now();
+      const sessionEntry: SessionEntry = {
+        sessionId: "session",
+        updatedAt: now,
+        interruptedTurn: {
+          runId: "prior-turn",
+          message: "continue the prior task",
+          startedAt: now - 5_000,
+          resumeCount: 3,
+          lastResumeAt: now - 1_000,
+        },
+      };
+      const sessionStore = { main: sessionEntry };
+      await seedSessionStore({
+        storePath,
+        sessionKey: "main",
+        entry: sessionEntry,
+      });
+
+      state.runEmbeddedPiAgentMock.mockResolvedValueOnce({
+        payloads: [],
+        meta: {
+          stopReason: "error",
+          error: {
+            message:
+              "Cloud Code Assist API error (429): No capacity available for model gemini-3-flash-preview on the server",
+          },
+        },
+      });
+
+      const fallbackSpy = vi
+        .spyOn(modelFallbackModule, "runWithModelFallback")
+        .mockImplementationOnce(
+          async ({
+            provider,
+            model,
+            run,
+          }: {
+            provider: string;
+            model: string;
+            run: (provider: string, model: string) => Promise<unknown>;
+          }) => ({
+            result: await run(provider, model),
+            provider,
+            model,
+            attempts: [
+              {
+                provider,
+                model,
+                error: "429 No capacity available",
+                reason: "rate_limit",
+              },
+            ],
+          }),
+        );
+
+      try {
+        vi.mocked(enqueueFollowupRun).mockReturnValueOnce(true);
+        const { run } = createMinimalRun({
+          sessionEntry,
+          sessionStore,
+          sessionKey: "main",
+          storePath,
+        });
+        const result = await run();
+
+        expect(result).toMatchObject({
+          text: expect.stringContaining("queued an automatic retry"),
+        });
+        expect(vi.mocked(enqueueFollowupRun)).toHaveBeenCalledTimes(1);
+        const [_queueKey, queuedRun, queueSettings] = vi.mocked(enqueueFollowupRun).mock.calls[0]!;
+        expect((queuedRun as FollowupRun).messageId).toContain(":4");
+        expect(queueSettings).toMatchObject({ debounceMs: 10_000 });
+        expect(sessionStore.main.interruptedTurn?.resumeCount).toBe(4);
+
+        const persisted = JSON.parse(await fs.readFile(storePath, "utf-8"));
+        expect(persisted.main.interruptedTurn.resumeCount).toBe(4);
+      } finally {
+        fallbackSpy.mockRestore();
+      }
+    });
+  });
+
+  it("does not enqueue a fifth rate-limited auto-resume retry", async () => {
+    await withStateDirEnv("openclaw-rate-limit-auto-resume-limit-", async ({ stateDir }) => {
+      const storePath = path.join(stateDir, "sessions", "sessions.json");
+      const now = Date.now();
+      const sessionEntry: SessionEntry = {
+        sessionId: "session",
+        updatedAt: now,
+        interruptedTurn: {
+          runId: "prior-turn",
+          message: "continue the prior task",
+          startedAt: now - 5_000,
+          resumeCount: 4,
+          lastResumeAt: now - 1_000,
+        },
+      };
+      const sessionStore = { main: sessionEntry };
+      await seedSessionStore({
+        storePath,
+        sessionKey: "main",
+        entry: sessionEntry,
+      });
+
+      state.runEmbeddedPiAgentMock.mockResolvedValueOnce({
+        payloads: [],
+        meta: {
+          stopReason: "error",
+          error: {
+            message:
+              "Cloud Code Assist API error (429): No capacity available for model gemini-3-flash-preview on the server",
+          },
+        },
+      });
+
+      const fallbackSpy = vi
+        .spyOn(modelFallbackModule, "runWithModelFallback")
+        .mockImplementationOnce(
+          async ({
+            provider,
+            model,
+            run,
+          }: {
+            provider: string;
+            model: string;
+            run: (provider: string, model: string) => Promise<unknown>;
+          }) => ({
+            result: await run(provider, model),
+            provider,
+            model,
+            attempts: [
+              {
+                provider,
+                model,
+                error: "429 No capacity available",
+                reason: "rate_limit",
+              },
+            ],
+          }),
+        );
+
+      try {
+        const { run } = createMinimalRun({
+          sessionEntry,
+          sessionStore,
+          sessionKey: "main",
+          storePath,
+        });
+        const result = await run();
+
+        expect(result).toMatchObject({
+          text: expect.stringContaining("Please retry"),
+        });
+        expect(vi.mocked(enqueueFollowupRun)).not.toHaveBeenCalled();
+        expect(sessionStore.main.interruptedTurn?.resumeCount).toBe(4);
+      } finally {
+        fallbackSpy.mockRestore();
+      }
+    });
+  });
+});
+
 describe("runReplyAgent typing (heartbeat)", () => {
   async function withTempStateDir<T>(fn: (stateDir: string) => Promise<T>): Promise<T> {
     return await withStateDirEnv(

src/auto-reply/reply/agent-runner.ts

@@ -3,10 +3,12 @@ import { lookupContextTokens } from "../../agents/context.js";
 import { DEFAULT_CONTEXT_TOKENS } from "../../agents/defaults.js";
 import { resolveModelAuthMode } from "../../agents/model-auth.js";
 import { isCliProvider } from "../../agents/model-selection.js";
+import { classifyFailoverReason } from "../../agents/pi-embedded-helpers.js";
 import { queueEmbeddedPiMessage } from "../../agents/pi-embedded.js";
 import { hasNonzeroUsage } from "../../agents/usage.js";
 import {
   canAttemptInterruptedResume,
+  MAX_RATE_LIMIT_INTERRUPTED_RESUME_COUNT,
   markSessionUnfinishedTurn,
   markSessionInterruptedResumeAttempt,
   resolveAgentIdFromSessionKey,
@@ -33,6 +35,7 @@ import type { OriginatingChannelType, TemplateContext } from "../templating.js";
 import { resolveResponseUsageMode, type VerboseLevel } from "../thinking.js";
 import type { GetReplyOptions, ReplyPayload } from "../types.js";
 import { runAgentTurnWithFallback } from "./agent-runner-execution.js";
+import type { RuntimeFallbackAttempt } from "./agent-runner-execution.js";
 import {
   createShouldEmitToolOutput,
   createShouldEmitToolResult,
@@ -69,6 +72,33 @@ import { createTypingSignaler } from "./typing-mode.js";
 import type { TypingController } from "./typing.js";
 
 const BLOCK_REPLY_SEND_TIMEOUT_MS = 15_000;
+const RATE_LIMIT_INTERRUPTED_RESUME_DELAY_MS = 10_000;
+
+function extractRunErrorMessage(error: unknown): string | undefined {
+  if (typeof error === "string") {
+    const trimmed = error.trim();
+    return trimmed || undefined;
+  }
+  if (!error || typeof error !== "object") {
+    return undefined;
+  }
+  if ("message" in error && typeof error.message === "string") {
+    const trimmed = error.message.trim();
+    return trimmed || undefined;
+  }
+  return undefined;
+}
+
+function shouldBackoffInterruptedRetry(params: {
+  fallbackAttempts: RuntimeFallbackAttempt[];
+  runError?: unknown;
+}): boolean {
+  if (params.fallbackAttempts.some((attempt) => attempt.reason === "rate_limit")) {
+    return true;
+  }
+  const rawError = extractRunErrorMessage(params.runError);
+  return rawError ? classifyFailoverReason(rawError) === "rate_limit" : false;
+}
 
 export async function runReplyAgent(params: {
   commandBody: string;
@@ -285,12 +315,15 @@ export async function runReplyAgent(params: {
     agentCfgContextTokens,
   });
 
-  const maybeQueueInterruptedRetry = async () => {
+  const maybeQueueInterruptedRetry = async (options?: { rateLimitBackoff?: boolean }) => {
     if (!sessionKey || !storePath || !currentUnfinishedTurn) {
       return false;
     }
     const entryForResume = activeSessionStore?.[sessionKey] ?? activeSessionEntry;
-    if (!canAttemptInterruptedResume(entryForResume)) {
+    const maxResumeCount = options?.rateLimitBackoff
+      ? MAX_RATE_LIMIT_INTERRUPTED_RESUME_COUNT
+      : undefined;
+    if (!canAttemptInterruptedResume(entryForResume, { maxResumeCount })) {
       return false;
     }
     const updatedEntry = await markSessionInterruptedResumeAttempt({
@@ -299,6 +332,14 @@ export async function runReplyAgent(params: {
       storePath,
     });
     const nextResumeCount = updatedEntry?.interruptedTurn?.resumeCount ?? 1;
+    const queueSettings =
+      options?.rateLimitBackoff &&
+      (resolvedQueue.debounceMs ?? 0) < RATE_LIMIT_INTERRUPTED_RESUME_DELAY_MS
+        ? {
+            ...resolvedQueue,
+            debounceMs: RATE_LIMIT_INTERRUPTED_RESUME_DELAY_MS,
+          }
+        : resolvedQueue;
     const enqueued = enqueueFollowupRun(
       queueKey,
       {
@@ -309,7 +350,7 @@ export async function runReplyAgent(params: {
           ? `Auto-resume: ${followupRun.summaryLine}`
           : "Auto-resume interrupted turn",
       },
-      resolvedQueue,
+      queueSettings,
     );
     if (enqueued && updatedEntry) {
       activeSessionEntry = updatedEntry;
@@ -562,6 +603,10 @@ export async function runReplyAgent(params: {
         hadExecutionError: runResult.meta?.stopReason === "error" || Boolean(runResult.meta?.error),
         hasActiveBackgroundTask,
       });
+    const shouldBackoffAutoResume = shouldBackoffInterruptedRetry({
+      fallbackAttempts,
+      runError: runResult.meta?.error,
+    });
 
     // Drain any late tool/block deliveries before deciding there's "nothing to send".
     // Otherwise, a late typing trigger (e.g. from a tool callback) can outlive the run and
@@ -569,7 +614,9 @@ export async function runReplyAgent(params: {
     if (payloadArray.length === 0) {
       const turnOutcome = resolveTurnOutcome(0);
       if (turnOutcome.shouldSynthesizeDegradedReply) {
-        const autoResumeQueued = await maybeQueueInterruptedRetry();
+        const autoResumeQueued = await maybeQueueInterruptedRetry({
+          rateLimitBackoff: shouldBackoffAutoResume,
+        });
         return finalizeWithFollowup(
           hasActiveBackgroundTask
             ? autoResumeQueued
@@ -613,7 +660,9 @@ export async function runReplyAgent(params: {
     if (replyPayloads.length === 0) {
       const turnOutcome = resolveTurnOutcome(0);
       if (turnOutcome.shouldSynthesizeDegradedReply) {
-        const autoResumeQueued = await maybeQueueInterruptedRetry();
+        const autoResumeQueued = await maybeQueueInterruptedRetry({
+          rateLimitBackoff: shouldBackoffAutoResume,
+        });
         return finalizeWithFollowup(
           hasActiveBackgroundTask
             ? autoResumeQueued

src/config/sessions/unfinished-turn.ts

@@ -5,6 +5,7 @@ import type { SessionEntry, SessionInterruptedTurn, SessionUnfinishedTurn } from
 
 const UNFINISHED_TURN_PREVIEW_MAX_CHARS = 240;
 export const MAX_INTERRUPTED_RESUME_COUNT = 3;
+export const MAX_RATE_LIMIT_INTERRUPTED_RESUME_COUNT = 4;
 
 function normalizeUnfinishedTurnPreview(text: string): string | undefined {
   const collapsed = text.replace(/\s+/g, " ").trim();
@@ -94,9 +95,18 @@ export async function markSessionUnfinishedTurn(params: {
   return unfinishedTurn;
 }
 
-export function canAttemptInterruptedResume(entry: SessionEntry | undefined): boolean {
+export function canAttemptInterruptedResume(
+  entry: SessionEntry | undefined,
+  options?: {
+    maxResumeCount?: number;
+  },
+): boolean {
   const resumeCount = entry?.interruptedTurn?.resumeCount ?? 0;
-  return resumeCount < MAX_INTERRUPTED_RESUME_COUNT;
+  const maxResumeCount =
+    typeof options?.maxResumeCount === "number" && Number.isFinite(options.maxResumeCount)
+      ? Math.max(1, Math.floor(options.maxResumeCount))
+      : MAX_INTERRUPTED_RESUME_COUNT;
+  return resumeCount < maxResumeCount;
 }
 
 export async function markSessionInterruptedResumeAttempt(params: {

src/infra/runtime-failure.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, it } from "vitest";
+import { classifyOpenSkynetRuntimeFailure } from "./runtime-failure.js";
+
+describe("classifyOpenSkynetRuntimeFailure", () => {
+  it("classifies provider rate limits as environmental", () => {
+    expect(
+      classifyOpenSkynetRuntimeFailure({
+        status: "error",
+        errorText: "429 No capacity available for model gemini",
+      }),
+    ).toEqual({
+      failureDomain: "environmental",
+      failureClass: "provider_rate_limit",
+    });
+  });
+
+  it("classifies session locks as environmental", () => {
+    expect(
+      classifyOpenSkynetRuntimeFailure({
+        status: "error",
+        errorText: "session file locked (timeout 30000ms): owner /tmp/session.lock",
+      }),
+    ).toEqual({
+      failureDomain: "environmental",
+      failureClass: "session_lock",
+    });
+  });
+
+  it("classifies missing paths as cognitive", () => {
+    expect(
+      classifyOpenSkynetRuntimeFailure({
+        status: "error",
+        errorText: "ENOENT: no such file or directory",
+      }),
+    ).toEqual({
+      failureDomain: "cognitive",
+      failureClass: "missing_path",
+    });
+  });
+});

src/infra/runtime-failure.ts

@@ -0,0 +1,100 @@
+export type OpenSkynetRuntimeFailureDomain = "none" | "environmental" | "cognitive" | "mixed";
+
+export type OpenSkynetRuntimeFailureClass =
+  | "none"
+  | "provider_rate_limit"
+  | "provider_timeout"
+  | "gateway_restart"
+  | "gateway_connection"
+  | "permission_denied"
+  | "session_lock"
+  | "missing_path"
+  | "validation_error"
+  | "unknown_error";
+
+export type OpenSkynetRuntimeFailure = {
+  failureDomain: OpenSkynetRuntimeFailureDomain;
+  failureClass: OpenSkynetRuntimeFailureClass;
+};
+
+function normalizeFailureText(input: unknown): string {
+  return typeof input === "string" ? input.toLowerCase() : "";
+}
+
+export function classifyOpenSkynetRuntimeFailure(params: {
+  status?: string;
+  errorText?: string;
+  isOk?: boolean;
+}): OpenSkynetRuntimeFailure {
+  const status = normalizeFailureText(params.status);
+  const errorText = normalizeFailureText(params.errorText);
+  const isOk = params.isOk === true;
+
+  if (isOk) {
+    return { failureDomain: "none", failureClass: "none" };
+  }
+
+  if (
+    errorText.includes("rate limit") ||
+    errorText.includes("no capacity available") ||
+    errorText.includes("resource exhausted") ||
+    errorText.includes("api rate limit reached") ||
+    errorText.includes("too many requests") ||
+    errorText.includes("429")
+  ) {
+    return { failureDomain: "environmental", failureClass: "provider_rate_limit" };
+  }
+
+  if (
+    errorText.includes("service restart") ||
+    errorText.includes("config change detected") ||
+    errorText.includes("restarting") ||
+    errorText.includes("wait for active embedded runs timed out")
+  ) {
+    return { failureDomain: "environmental", failureClass: "gateway_restart" };
+  }
+
+  if (errorText.includes("session file locked") || errorText.includes("lock timeout")) {
+    return { failureDomain: "environmental", failureClass: "session_lock" };
+  }
+
+  if (status === "timeout" || errorText.includes("timed out") || errorText.includes("timeout")) {
+    return { failureDomain: "environmental", failureClass: "provider_timeout" };
+  }
+
+  if (
+    errorText.includes("gateway closed") ||
+    errorText.includes("connection reset") ||
+    errorText.includes("connection refused") ||
+    errorText.includes("token mismatch")
+  ) {
+    return { failureDomain: "environmental", failureClass: "gateway_connection" };
+  }
+
+  if (
+    errorText.includes("permission denied") ||
+    errorText.includes("eacces") ||
+    errorText.includes("operation not permitted")
+  ) {
+    return { failureDomain: "environmental", failureClass: "permission_denied" };
+  }
+
+  if (
+    errorText.includes("enoent") ||
+    errorText.includes("no such file") ||
+    errorText.includes("cannot find")
+  ) {
+    return { failureDomain: "cognitive", failureClass: "missing_path" };
+  }
+
+  if (
+    errorText.includes("syntax error") ||
+    errorText.includes("type error") ||
+    errorText.includes("validation failed") ||
+    errorText.includes("test failed")
+  ) {
+    return { failureDomain: "cognitive", failureClass: "validation_error" };
+  }
+
+  return { failureDomain: "mixed", failureClass: "unknown_error" };
+}

src/skynet/experiments/EX/SKYNET_CORE_V80_HYPERGRAPH.py

@@ -0,0 +1,181 @@
+"""
+SKYNET CORE V80: HYPERGRAPH (The Liquid Brain)
+==============================================
+
+This core represents the integration of Biphasic Physics and Dynamic Topology.
+It moves beyond fixed matrices to a fully autopoietic substrate where
+matter (nodes) creates space (adjacency) on the fly based on the signal.
+
+Key Innovations:
+1. Dynamic Topology: The adjacency matrix A_t evolves via Hebbian Plasticity.
+2. Topological Wells: The Mexican Hat force allows nodes to "crystallize"
+   and resist catastrophic erasure and noise.
+3. Liquid Diffusion: Information flows through the dynamic network, allowing
+   logic-over-time and spatial abstraction.
+"""
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+class LiquidBrainOrgan(nn.Module):
+    """
+    The physical organ of the V80 Hypergraph.
+    """
+    def __init__(self, n_nodes=32, d_feature=8):
+        super().__init__()
+        self.n_nodes = n_nodes
+        self.d_feature = d_feature
+        self.hidden_dim = n_nodes * d_feature
+        
+        # Physics Parameters
+        self.mu = nn.Parameter(torch.tensor(0.45))
+        self.sigma = nn.Parameter(torch.tensor(0.35))
+        
+        # Plasticity
+        self.plasticity_rate = nn.Parameter(torch.tensor(0.05))
+        self.decay_rate = nn.Parameter(torch.tensor(0.005))
+
+    def g_fluid(self, h):
+        return 2.0 * torch.exp(-((h - self.mu)**2) / (2 * self.sigma**2 + 1e-6)) - 1.0
+
+    def forward(self, h_ctx, x_in, A_prev=None, h_prev=None):
+        """
+        Single step forward for the physical organ.
+        x_in: [B, N, F] drive from cortex/input
+        h_prev: [B, N, F] previous physical state
+        A_prev: [B, N, N] previous topology
+        """
+        batch = x_in.shape[0]
+        
+        if h_prev is None:
+            h_prev = torch.zeros(batch, self.n_nodes, self.d_feature, device=x_in.device)
+        if A_prev is None:
+            A_prev = torch.eye(self.n_nodes, device=x_in.device).unsqueeze(0).repeat(batch, 1, 1)
+            
+        # 1. Input injection with damping
+        x_damped = x_in / (1.0 + torch.norm(x_in, dim=-1, keepdim=True) * 0.1)
+        
+        # 2. Biphasic Interaction + Topological Well (Mexican Hat)
+        h_core = torch.tanh(h_prev + 0.5 * x_damped)
+        force = (h_core - torch.pow(h_core, 3)).detach()
+        h = h_core + 0.35 * force 
+        
+        # 3. Liquid Diffusion
+        A_norm = A_prev / (A_prev.sum(dim=-1, keepdim=True) + 1e-6)
+        h_diffused = torch.bmm(A_norm, h)
+        h = h + 0.2 * (h_diffused - h)
+        
+        # 4. Topology Update (Plasticity)
+        h_normed = F.normalize(h, dim=-1)
+        corr = torch.bmm(h_normed, h_normed.transpose(1, 2))
+        
+        eta = torch.sigmoid(self.plasticity_rate) * 0.05
+        lam = torch.sigmoid(self.decay_rate) * 0.01
+        
+        A_next = torch.clamp(A_prev + eta * corr - lam * A_prev, 0.0, 1.0)
+        
+        # Self-loop preservation
+        idx = torch.arange(self.n_nodes, device=x_in.device)
+        A_next[:, idx, idx] = 1.0
+        
+        h_next = torch.tanh(h)
+        
+        return h_next, A_next
+
+class SKYNET_CORE_V80_HYPERGRAPH(nn.Module):
+    """
+    SKYNET V80: THE HYPERGRAPH
+    Neural Cortex coupled with the Liquid Brain Organ.
+    """
+    def __init__(self, n_input=658, n_actions=20, d_model=128, n_nodes=32, d_feature=8, device='cuda'):
+        super().__init__()
+        self.device = device
+        self.d_model = d_model
+        self.n_nodes = n_nodes
+        self.d_feature = d_feature
+        
+        self.input_proj = nn.Linear(n_input, d_model)
+        self.input_norm = nn.LayerNorm(d_model)
+        
+        self.cortex = nn.GRU(d_model, d_model, batch_first=True)
+        
+        self.phys_proj = nn.Linear(d_model, n_nodes * d_feature)
+        self.organ = LiquidBrainOrgan(n_nodes=n_nodes, d_feature=d_feature)
+        
+        # Readout
+        self.readout = nn.Linear(d_model + (n_nodes * d_feature), n_actions)
+        
+        self.cortex_state = None
+        self.organ_state = None
+        self.topology_state = None
+
+    def reset(self):
+        self.cortex_state = None
+        self.organ_state = None
+        self.topology_state = None
+
+    def detach_states(self):
+        if self.cortex_state is not None: self.cortex_state = self.cortex_state.detach()
+        if self.organ_state is not None: self.organ_state = self.organ_state.detach()
+        if self.topology_state is not None: self.topology_state = self.topology_state.detach()
+
+    def forward_sequence(self, x_seq, training=True):
+        """
+        Processes a full sequence and returns the final logits.
+        Compatible with sequential benchmarks.
+        """
+        self.reset()
+        batch, steps, _ = x_seq.shape
+        for t in range(steps):
+            out = self.forward(x_seq[:, t], training=training)
+        return out['logits']
+
+    def forward(self, x, training=True):
+        batch = x.shape[0]
+        if x.dim() == 3:
+            x = x.view(batch, -1)
+            
+        h_in = self.input_norm(self.input_proj(x))
+        
+        if self.cortex_state is None or self.cortex_state.shape[1] != batch:
+            self.cortex_state = torch.zeros(1, batch, self.d_model, device=x.device)
+            
+        h_ctx, self.cortex_state = self.cortex(h_in.unsqueeze(1), self.cortex_state)
+        h_ctx = h_ctx.squeeze(1)
+        
+        # Drive the physical organ
+        phys_drive = self.phys_proj(h_ctx).view(batch, self.n_nodes, self.d_feature)
+        
+        self.organ_state, self.topology_state = self.organ(
+            h_ctx, phys_drive, A_prev=self.topology_state, h_prev=self.organ_state
+        )
+        
+        h_phys_flat = self.organ_state.view(batch, -1)
+        h_fused = torch.cat([h_ctx, h_phys_flat], dim=-1)
+        
+        logits = self.readout(h_fused)
+        probs = F.softmax(logits, dim=-1)
+        entropy = -(probs * torch.log(probs + 1e-6)).sum(-1, keepdim=True)
+        
+        audit = {
+            'topology_density': self.topology_state.mean().item(),
+            'phys_flux': self.organ_state.abs().mean().item(),
+            'entropy': entropy.mean().item()
+        }
+        
+        return {
+            'logits': logits,
+            'probs': probs,
+            'entropy': entropy,
+            'audit': audit
+        }
+
+if __name__ == "__main__":
+    device = 'cuda' if torch.cuda.is_available() else 'cpu'
+    model = SKYNET_CORE_V80_HYPERGRAPH(device=device).to(device)
+    x = torch.randn(4, 658, device=device)
+    out = model(x)
+    print("V80 Hypergraph Forward Pass Successful.")
+    print(f"Logits Shape: {out['logits'].shape}")
+    print(f"Audit: {out['audit']}")

src/skynet/experiments/EX/SKYNET_CORE_V85_SCALING_HYPERGRAPH.py

@@ -0,0 +1,154 @@
+"""
+SKYNET CORE V85: SCALING HYPERGRAPH (The Living Brain)
+=====================================================
+
+Integration of V80 (Dynamic Topology) with V85 (Neurogenesis & Pruning).
+This core implements physical brain expansion and synaptic cleaning.
+
+Features:
+1. Dynamic Topology: Adjacency A_t evolves via Hebbian Plasticity.
+2. Neurogenesis: Adds nodes when hidden state saturation is detected.
+3. Synaptic Pruning: Deletes edges with weight < threshold.
+4. Higgs Decision: Mexican Hat force for stable commitments.
+"""
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+class ScalingHypergraphOrgan(nn.Module):
+    def __init__(self, n_initial_nodes=16, d_feature=8, max_nodes=128):
+        super().__init__()
+        self.n_nodes = n_initial_nodes
+        self.d_feature = d_feature
+        self.max_nodes = max_nodes
+        
+        # Hyperparameters
+        self.mu = nn.Parameter(torch.tensor(0.45))
+        self.sigma = nn.Parameter(torch.tensor(0.35))
+        self.plasticity_rate = nn.Parameter(torch.tensor(0.05))
+        self.decay_rate = nn.Parameter(torch.tensor(0.005))
+        
+        self.neuro_threshold = 0.75
+        self.pruning_threshold = 0.02
+
+    def forward(self, x_in, h_prev, A_prev, training=True):
+        batch = x_in.shape[0]
+        
+        # 1. Biphasic Physics + Mexican Hat
+        h_core = torch.tanh(h_prev + 0.5 * x_in)
+        force = (h_core - torch.pow(h_core, 3)).detach()
+        h = h_core + 0.3 * force 
+        
+        # 2. Liquid Diffusion (Communication)
+        A_norm = A_prev / (A_prev.sum(dim=-1, keepdim=True) + 1e-6)
+        h_diffused = torch.bmm(A_norm, h)
+        h = h + 0.2 * (h_diffused - h)
+        
+        # 3. Plasticity
+        h_normed = F.normalize(h, dim=-1)
+        corr = torch.bmm(h_normed, h_normed.transpose(1, 2))
+        
+        eta = torch.sigmoid(self.plasticity_rate) * 0.05
+        lam = torch.sigmoid(self.decay_rate) * 0.01
+        A_next = torch.clamp(A_prev + eta * corr - lam * A_prev, 0.0, 1.0)
+        
+        # Synaptic Pruning
+        if training:
+            A_next[A_next < self.pruning_threshold] = 0.0
+            
+        # Self-loops
+        idx = torch.arange(self.n_nodes, device=x_in.device)
+        A_next[:, idx, idx] = 1.0
+        
+        h_next = torch.tanh(h)
+        
+        # 4. Neurogenesis Trigger
+        should_grow = False
+        if training and h_next.abs().mean() > self.neuro_threshold and self.n_nodes + 4 <= self.max_nodes:
+            should_grow = True
+            
+        return h_next, A_next, should_grow
+
+class SKYNET_CORE_V85_SCALING_HYPERGRAPH(nn.Module):
+    def __init__(self, n_input=658, n_actions=20, d_model=128, n_initial_nodes=16, d_feature=8, max_nodes=128, device='cuda'):
+        super().__init__()
+        self.device = device
+        self.max_nodes = max_nodes
+        self.d_feature = d_feature
+        self.d_model = d_model
+        
+        self.input_proj = nn.Linear(n_input, d_model)
+        self.input_norm = nn.LayerNorm(d_model)
+        self.cortex = nn.GRU(d_model, d_model, batch_first=True)
+        
+        # Fixed pool projection (for max capacity)
+        self.phys_proj = nn.Linear(d_model, max_nodes * d_feature)
+        self.organ = ScalingHypergraphOrgan(n_initial_nodes, d_feature, max_nodes)
+        
+        self.readout = nn.Linear(d_model + (max_nodes * d_feature), n_actions)
+        
+        self.reset()
+
+    def reset(self):
+        self.cortex_state = None
+        self.h_phys = None
+        self.A_phys = None
+
+    def grow(self, batch):
+        old_n = self.organ.n_nodes
+        self.organ.n_nodes += 4
+        new_n = self.organ.n_nodes
+        
+        # Expand states
+        new_h = torch.zeros(batch, new_n, self.d_feature, device=self.device)
+        new_h[:, :old_n, :] = self.h_phys
+        self.h_phys = new_h
+        
+        new_A = torch.eye(new_n, device=self.device).unsqueeze(0).repeat(batch, 1, 1)
+        new_A[:, :old_n, :old_n] = self.A_phys
+        self.A_phys = new_A
+
+    def forward(self, x, training=True):
+        batch = x.shape[0]
+        if x.dim() == 3: x = x.view(batch, -1)
+        
+        h_in = self.input_norm(self.input_proj(x))
+        if self.cortex_state is None:
+            self.cortex_state = torch.zeros(1, batch, self.d_model, device=x.device)
+            
+        h_ctx, self.cortex_state = self.cortex(h_in.unsqueeze(1), self.cortex_state)
+        h_ctx = h_ctx.squeeze(1)
+        
+        if self.h_phys is None:
+            self.h_phys = torch.zeros(batch, self.organ.n_nodes, self.d_feature, device=x.device)
+            self.A_phys = torch.eye(self.organ.n_nodes, device=x.device).unsqueeze(0).repeat(batch, 1, 1)
+            
+        # Drive
+        full_drive = self.phys_proj(h_ctx).view(batch, self.max_nodes, self.d_feature)
+        x_drive = full_drive[:, :self.organ.n_nodes, :]
+        
+        self.h_phys, self.A_phys, should_grow = self.organ(x_drive, self.h_phys, self.A_phys, training)
+        
+        if should_grow:
+            self.grow(batch)
+            
+        # Padded readout
+        h_full = torch.zeros(batch, self.max_nodes, self.d_feature, device=x.device)
+        h_full[:, :self.organ.n_nodes, :] = self.h_phys
+        
+        h_fused = torch.cat([h_ctx, h_full.view(batch, -1)], dim=-1)
+        logits = self.readout(h_fused)
+        
+        return {
+            'logits': logits,
+            'audit': {'nodes': self.organ.n_nodes, 'sparsity': (self.A_phys == 0).float().mean().item()}
+        }
+
+if __name__ == "__main__":
+    device = 'cuda' if torch.cuda.is_available() else 'cpu'
+    model = SKYNET_CORE_V85_SCALING_HYPERGRAPH(device=device).to(device)
+    for _ in range(5):
+        x = torch.randn(2, 658, device=device)
+        out = model(x)
+        print(f"Nodes: {out['audit']['nodes']}, Sparsity: {out['audit']['sparsity']:.2f}")

src/skynet/experiments/experimentos/exp54_liquid_brain_core.py

@@ -50,40 +50,38 @@ class LiquidBrainOrgan(nn.Module):
     def forward_sequence(self, x_seq: torch.Tensor) -> torch.Tensor:
         batch, steps, _ = x_seq.shape
         h = torch.zeros(batch, self.n_nodes, self.d_feature, device=x_seq.device)
-        
-        # Adjacency starts as sparse Identity
         A = torch.eye(self.n_nodes, device=x_seq.device).unsqueeze(0).repeat(batch, 1, 1)
         
         for t in range(steps):
-            # 1. Drive - stronger injection
-            x_in = self.input_proj(x_seq[:, t]).view(batch, self.n_nodes, self.d_feature)
+            x_t = x_seq[:, t]
+            # --- PROTECTIVE LAYER: Input Filtering ---
+            # If input is too high (flash/noise), dampen its effect
+            x_in = self.input_proj(x_t).view(batch, self.n_nodes, self.d_feature)
+            x_in = x_in / (1.0 + torch.norm(x_in, dim=-1, keepdim=True) * 0.1)
             
-            # 2. Biphasic Growth (Interaction)
-            # Use tanh to keep growth bounded and non-linear
-            h = torch.tanh(h + 0.5 * x_in)
-            growth = self.g_fluid(h)
-            h = h + 0.2 * growth
+            # --- TOPOLOGICAL WELLS: The decision-locking mechanism ---
+            # Increase the Mexican Hat force to 'crystallize' memory nodes
+            h_core = torch.tanh(h + 0.5 * x_in)
+            # F_well = h - h^3 (The Higgs force from Exp45)
+            force = (h_core - torch.pow(h_core, 3)).detach()
+            h = h_core + 0.35 * force 
             
-            # 3. Liquid Diffusion (Communication over Dynamic Topology)
-            # Normalize A to prevent explosion (Row-normalization)
+            # --- DYNAMIC ADJACENCY (V80 Core) ---
             A_norm = A / (A.sum(dim=-1, keepdim=True) + 1e-6)
             h_diffused = torch.bmm(A_norm, h)
             
-            # Diffusion update: move towards neighbors
-            h = h + 0.3 * (h_diffused - h)
+            # Diffusion with higher damping (more inertia)
+            h = h + 0.2 * (h_diffused - h)
             
-            # 4. Topology Update (Fire together, wire together)
-            # Enhanced Hebbian: use cosine similarity for topology growth
+            # --- PLASTICITY with CORRELATION GATING ---
+            # Only update topology if activity is within a 'meaningful' range
             h_normed = F.normalize(h, dim=-1)
-            corr = torch.bmm(h_normed, h_normed.transpose(1, 2)) # [B, N, N]
-            
-            eta = torch.sigmoid(self.plasticity_rate) * 0.1 # Slower, more stable plasticity
-            lam = torch.sigmoid(self.decay_rate) * 0.05
+            corr = torch.bmm(h_normed, h_normed.transpose(1, 2))
             
-            # Update Adjacency
+            eta = torch.sigmoid(self.plasticity_rate) * 0.05
+            lam = torch.sigmoid(self.decay_rate) * 0.01
             A = torch.clamp(A + eta * corr - lam * A, 0.0, 1.0)
             
-            # Maintain identity for self-loop stability
             idx = torch.arange(self.n_nodes, device=x_seq.device)
             A[:, idx, idx] = 1.0
             

src/skynet/experiments/experimentos/exp55_liquid_brain_gauntlet.py

@@ -69,10 +69,13 @@ def run_stress_battery():
     
     # 1. Train on a 'standard' difficult mix
     print("Training on mixed stress conditions...")
-    x_train, y_train = generate_gauntlet_data(2500, mode="long_silence") # Base training
+    x_train_1, y_train_1 = generate_gauntlet_data(1500, mode="long_silence") 
+    x_train_2, y_train_2 = generate_gauntlet_data(1500, mode="signal_noise") 
+    x_train = torch.cat([x_train_1, x_train_2])
+    y_train = torch.cat([y_train_1, y_train_2])
     
     model = LiquidBrainOrgan(n_nodes=16, d_feature=8).to(DEVICE)
-    train_on_dataset(model, x_train, y_train, max_epochs=30)
+    train_on_dataset(model, x_train, y_train, max_epochs=40)
     
     # 2. Evaluate each scenario
     for mode in scenarios:

src/skynet/experiments/experimentos/exp56_lifelong_learning_v80.py

@@ -0,0 +1,102 @@
+"""
+Exp56: Continuous Life-Long Learning (V80 Stability Audit)
+==========================================================
+
+Goal: Verify if the V80 Hypergraph can learn Task A, then learn Task B, 
+and still remember Task A without catastrophic forgetting, mimicking 
+a 'Life-Long' scaling intelligence.
+
+Mechanism:
+1. Sequential Training: Task A -> Task B -> Task C.
+2. Topological Memory: We check if the Adjacency Matrix A_t 'partitions' 
+   itself to store Task A while using new nodes for Task B.
+"""
+
+import sys
+import os
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), 'EX'))
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import json
+import random
+from pathlib import Path
+from ex_hypothesis_components import DEVICE, INPUT_DIM, HIDDEN_DIM
+from exp38_ex_hypothesis_benchmark import train_on_dataset, evaluate
+from SKYNET_CORE_V80_HYPERGRAPH import SKYNET_CORE_V80_HYPERGRAPH
+
+REPORT_PATH = Path("exp56_lifelong_learning_results.json")
+
+def generate_task_data(task_id, n_samples=1000):
+    """
+    Task 0: Identify pattern in first 3 dims.
+    Task 1: Identify pattern in next 3 dims.
+    """
+    seq_len = 20
+    x = torch.randn(n_samples, seq_len, INPUT_DIM) * 0.1
+    y = torch.zeros(n_samples, dtype=torch.long)
+    
+    start_dim = task_id * 3
+    for i in range(n_samples):
+        label = random.randint(0, 1)
+        y[i] = label
+        # Pattern: high activation in the assigned task dimensions
+        x[i, :, start_dim : start_dim + 3] += (2.0 if label == 1 else -2.0)
+        
+    return x, y
+
+def run_lifelong_audit():
+    random.seed(777)
+    torch.manual_seed(777)
+    
+    # We use a larger V80 to allow for 'partitioning'
+    model = SKYNET_CORE_V80_HYPERGRAPH(n_input=INPUT_DIM, n_nodes=64, d_feature=8, n_actions=2).to(DEVICE)
+    
+    print("--- Phase 1: Learning Task A ---")
+    x_a, y_a = generate_task_data(0, 1500)
+    train_on_dataset(model, x_a, y_a, max_epochs=15)
+    acc_a_after_a = evaluate(model, x_a, y_a)
+    print(f"  Acc A after A: {acc_a_after_a:.4f}")
+    
+    # Capture topology state after Task A
+    topo_a = model.topology_state.clone() if model.topology_state is not None else None
+    
+    print("\n--- Phase 2: Learning Task B (Potential Forgetting) ---")
+    x_b, y_b = generate_task_data(1, 1500)
+    # Train ONLY on Task B
+    train_on_dataset(model, x_b, y_b, max_epochs=15)
+    acc_b_after_b = evaluate(model, x_b, y_b)
+    print(f"  Acc B after B: {acc_b_after_b:.4f}")
+    
+    print("\n--- Phase 3: Final Recall ---")
+    acc_a_after_b = evaluate(model, x_a, y_a)
+    print(f"  Acc A after B: {acc_a_after_b:.4f}")
+    
+    # Analysis: Topological Drift
+    topo_b = model.topology_state.clone()
+    # Check how much the connections changed
+    if topo_a is not None:
+        drift = torch.abs(topo_b - topo_a).mean().item()
+    else:
+        drift = 0.0
+        
+    forgetting = acc_a_after_a - acc_a_after_b
+    
+    report = {
+        "experiment": "exp56_lifelong_learning_v80",
+        "task_a_initial": acc_a_after_a,
+        "task_b_initial": acc_b_after_b,
+        "task_a_final_recall": acc_a_after_b,
+        "forgetting_magnitude": forgetting,
+        "topological_drift": drift,
+        "status": "SUCCESS" if forgetting < 0.1 else "FORGETTING_DETECTED"
+    }
+    
+    REPORT_PATH.write_text(json.dumps(report, indent=2))
+    print(json.dumps(report, indent=2))
+    return report
+
+if __name__ == "__main__":
+    run_lifelong_audit()

src/skynet/experiments/experimentos/exp57_dynamic_neurogenesis.py

@@ -0,0 +1,174 @@
+"""
+Exp57: Dynamic Neurogenesis & Synaptic Pruning (V85 Hypergraph)
+==============================================================
+
+Goal: Implement physical brain scaling. The model should:
+1. Detect "Capacity Saturation" (High entropy + High flux).
+2. Trigger Neurogenesis: Add new nodes to the Hypergraph.
+3. Perform Synaptic Pruning: Delete weak edges to maintain O(N) efficiency.
+
+This moves OpenSkynet from a fixed-size 'bicho' to a scaling organism.
+"""
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import json
+import random
+from pathlib import Path
+
+# Paths for imports
+import sys
+import os
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), 'EX'))
+
+from ex_hypothesis_components import DEVICE, INPUT_DIM
+from exp38_ex_hypothesis_benchmark import train_on_dataset, evaluate
+
+REPORT_PATH = Path("exp57_neurogenesis_results.json")
+
+class NeurogenesisHypergraph(nn.Module):
+    def __init__(self, n_initial_nodes=8, d_feature=8, n_actions=2):
+        super().__init__()
+        self.n_nodes = n_initial_nodes
+        self.d_feature = d_feature
+        self.n_actions = n_actions
+        
+        # Projections must be flexible or mapped per node
+        # For simplicity in this core, we project to a large fixed pool 
+        # but only 'activate' nodes as we grow.
+        self.max_nodes = 128
+        self.input_proj = nn.Linear(INPUT_DIM, self.max_nodes * d_feature)
+        self.readout = nn.Linear(self.max_nodes * d_feature, n_actions)
+        
+        # Internal states
+        self.h = None
+        self.A = None
+        
+        # Thresholds
+        self.neurogenesis_threshold = 0.8  # If avg activity is high
+        self.pruning_threshold = 0.05     # If edge is too weak
+
+    def reset(self):
+        self.h = None
+        self.A = None
+
+    def grow_brain(self):
+        """Adds 4 nodes to the active set."""
+        if self.n_nodes + 4 <= self.max_nodes:
+            self.n_nodes += 4
+            print(f"  [NEUROGENESIS] Brain expanded to {self.n_nodes} nodes.")
+            # We don't need to re-init A or h, the forward pass handles the new size
+            return True
+        return False
+
+    def forward_sequence(self, x_seq, training=True):
+        self.reset()
+        batch, steps, _ = x_seq.shape
+        for t in range(steps):
+            logits = self.forward(x_seq[:, t], training=training)
+        return logits
+
+    def forward(self, x, training=True):
+        batch = x.shape[0]
+        
+        # 1. State initialization
+        if self.h is None:
+            self.h = torch.zeros(batch, self.n_nodes, self.d_feature, device=x.device)
+            self.A = torch.eye(self.n_nodes, device=x.device).unsqueeze(0).repeat(batch, 1, 1)
+
+        # 2. Input drive (only for active nodes)
+        x_full = self.input_proj(x).view(batch, self.max_nodes, self.d_feature)
+        x_in = x_full[:, :self.n_nodes, :]
+        
+        # 3. Physics & Plasticity (Hebbian)
+        h_core = torch.tanh(self.h + 0.5 * x_in)
+        
+        # Liquid Diffusion over current Adjacency
+        # A_norm = A / sum(A)
+        A_norm = self.A / (self.A.sum(dim=-1, keepdim=True) + 1e-6)
+        h_diffused = torch.bmm(A_norm, h_core)
+        
+        self.h = h_core + 0.2 * (h_diffused - h_core)
+        
+        # Adjacency Update
+        h_normed = F.normalize(self.h, dim=-1)
+        corr = torch.bmm(h_normed, h_normed.transpose(1, 2))
+        
+        # Plasticity
+        self.A = torch.clamp(self.A + 0.05 * corr - 0.01 * self.A, 0.0, 1.0)
+        
+        # --- SYNAPTIC PRUNING ---
+        if training and random.random() < 0.05:
+            self.A[self.A < self.pruning_threshold] = 0.0
+            
+        # --- NEUROGENESIS TRIGGER ---
+        # If the active nodes are saturated (high avg activity), we need more capacity
+        if training and self.h.abs().mean() > self.neurogenesis_threshold:
+            if self.grow_brain():
+                # Re-pad h and A for the new size
+                new_h = torch.zeros(batch, self.n_nodes, self.d_feature, device=x.device)
+                new_h[:, :self.h.shape[1], :] = self.h
+                self.h = new_h
+                
+                new_A = torch.eye(self.n_nodes, device=x.device).unsqueeze(0).repeat(batch, 1, 1)
+                new_A[:, :self.A.shape[1], :self.A.shape[2]] = self.A
+                self.A = new_A
+
+        # 4. Readout (from all possible nodes, but only n_nodes are non-zero)
+        h_flat = torch.zeros(batch, self.max_nodes * self.d_feature, device=x.device)
+        current_flat = self.h.reshape(batch, -1)
+        h_flat[:, :current_flat.shape[1]] = current_flat
+        
+        logits = self.readout(h_flat)
+        return logits
+
+def generate_scaling_task(n_samples=1000):
+    """
+    A task that gets harder over time, requiring more 'brain' capacity.
+    """
+    seq_len = 30
+    x = torch.randn(n_samples, seq_len, INPUT_DIM) * 0.1
+    y = torch.zeros(n_samples, dtype=torch.long)
+    for i in range(n_samples):
+        label = random.randint(0, 1)
+        y[i] = label
+        # Harder pattern: requires keeping track of multiple dimensions
+        x[i, :, 0:5] += (3.0 if label == 1 else -3.0)
+    return x, y
+
+def run_neurogenesis_experiment():
+    random.seed(42)
+    torch.manual_seed(42)
+    
+    print("Starting Neurogenesis Stress Test...")
+    x_train, y_train = generate_scaling_task(2000)
+    x_test, y_test = generate_scaling_task(500)
+    
+    # Start with a very small brain (8 nodes)
+    model = NeurogenesisHypergraph(n_initial_nodes=8).to(DEVICE)
+    
+    print("Training with active neurogenesis...")
+    train_on_dataset(model, x_train, y_train, max_epochs=20)
+    
+    final_nodes = model.n_nodes
+    acc = evaluate(model, x_test, y_test)
+    
+    # Check sparsity (Pruning effect)
+    sparsity = (model.A == 0).float().mean().item() if model.A is not None else 0
+    
+    report = {
+        "experiment": "exp57_dynamic_neurogenesis",
+        "initial_nodes": 8,
+        "final_nodes": final_nodes,
+        "test_accuracy": acc,
+        "synaptic_sparsity": sparsity,
+        "conclusion": "SUCCESS" if final_nodes > 8 and acc > 0.9 else "FAILED"
+    }
+    
+    print(json.dumps(report, indent=2))
+    REPORT_PATH.write_text(json.dumps(report, indent=2))
+    return report
+
+if __name__ == "__main__":
+    run_neurogenesis_experiment()

src/skynet/experiments/experimentos/exp58_semantic_topology.py

@@ -0,0 +1,124 @@
+"""
+Exp58: Semantic Topology - Concept Association via Hypergraph
+===========================================================
+
+Goal: Test if the V85 Hypergraph can learn to associate words/concepts 
+by building physical bridges between their embeddings in the topology.
+
+Mechanism:
+1. Embeddings: Small vocabulary (Fruit, Colors, Animals).
+2. Input: Pairs of related concepts (e.g. 'Apple' + 'Red').
+3. Topology Check: Verify if A_t creates a stronger connection 
+   between nodes representing related concepts vs unrelated ones.
+"""
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import json
+import random
+from pathlib import Path
+
+# Paths for imports
+import sys
+import os
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), 'EX'))
+
+from SKYNET_CORE_V85_SCALING_HYPERGRAPH import SKYNET_CORE_V85_SCALING_HYPERGRAPH
+from exp38_ex_hypothesis_benchmark import train_on_dataset, evaluate
+
+REPORT_PATH = Path("exp58_semantic_topology_results.json")
+DEVICE = 'cuda' if torch.cuda.is_available() else 'cpu'
+
+# 1. Vocabulary & Simple Embeddings
+VOCAB = {
+    "apple": 0, "banana": 1, "cherry": 2,  # Fruits
+    "red": 3, "yellow": 4,                 # Colors
+    "dog": 5, "cat": 6, "bird": 7,         # Animals
+    "bark": 8, "meow": 9                   # Sounds
+}
+EMBED_DIM = 16
+
+class SemanticTask:
+    def __init__(self):
+        # Relationship pairs (concept -> association)
+        self.pairs = [
+            ("apple", "red"), ("cherry", "red"),
+            ("banana", "yellow"),
+            ("dog", "bark"), ("cat", "meow")
+        ]
+        self.vocab_size = len(VOCAB)
+        self.embedding = nn.Embedding(self.vocab_size, EMBED_DIM)
+
+    def generate_data(self, n_samples=1000):
+        seq_len = 5
+        # We pad to match SKYNET_CORE_V85 n_input (658)
+        x = torch.zeros(n_samples, seq_len, 658)
+        y = torch.zeros(n_samples, dtype=torch.long)
+        
+        for i in range(n_samples):
+            # Pick a positive pair (True association) or negative
+            is_positive = random.random() > 0.5
+            if is_positive:
+                w1, w2 = random.choice(self.pairs)
+                y[i] = 1
+            else:
+                w1 = random.choice(list(VOCAB.keys()))
+                w2 = random.choice(list(VOCAB.keys()))
+                # Ensure it's not a known pair
+                while (w1, w2) in self.pairs:
+                    w2 = random.choice(list(VOCAB.keys()))
+                y[i] = 0
+            
+            # Simple one-hot-like injection into the 658 input space
+            x[i, 0, VOCAB[w1]] = 5.0
+            x[i, 2, VOCAB[w2]] = 5.0 # Delay of 1 step
+            
+        return x, y
+
+def run_semantic_experiment():
+    random.seed(42)
+    torch.manual_seed(42)
+    
+    task = SemanticTask()
+    x_train, y_train = task.generate_data(2000)
+    x_test, y_test = task.generate_data(500)
+    
+    # Initialize V85
+    model = SKYNET_CORE_V85_SCALING_HYPERGRAPH(
+        n_input=658, n_actions=2, n_initial_nodes=32, device=DEVICE
+    ).to(DEVICE)
+    
+    print("Training V85 on Semantic Associations...")
+    # Wrap model to provide forward_sequence if missing
+    if not hasattr(model, 'forward_sequence'):
+        def forward_sequence(x_seq, training=True):
+            model.reset()
+            for t in range(x_seq.shape[1]):
+                logits = model.forward(x_seq[:, t], training=training)['logits']
+            return logits
+        model.forward_sequence = forward_sequence
+
+    train_on_dataset(model, x_train, y_train, max_epochs=20)
+    
+    acc = evaluate(model, x_test, y_test)
+    print(f"Final Semantic Accuracy: {acc:.4f}")
+    
+    # Audit Topology
+    # We want to see if the density of A_t is higher for positive pairs
+    avg_density = model.A_phys.mean().item()
+    
+    report = {
+        "experiment": "exp58_semantic_topology",
+        "test_accuracy": acc,
+        "final_nodes": model.organ.n_nodes,
+        "topology_avg_density": avg_density,
+        "conclusion": "SUCCESS" if acc > 0.85 else "FAILED"
+    }
+    
+    print(json.dumps(report, indent=2))
+    REPORT_PATH.write_text(json.dumps(report, indent=2))
+    return report
+
+if __name__ == "__main__":
+    run_semantic_experiment()

test-memory-events.ts

@@ -0,0 +1,38 @@
+import { deriveOpenSkynetLivingMemoryEvents } from "./src/omega/living-memory-events.js";
+
+const sessionKey = "agent:main:main";
+const now = Date.now();
+
+const priorState: any = {
+  updatedAt: now - 1000,
+  identity: { activeGoalTask: "Old Task" },
+  internalProjectState: {
+    focusKey: "old-focus",
+    mode: "idle",
+    commitment: null,
+  },
+};
+
+const nextState: any = {
+  updatedAt: now,
+  identity: { activeGoalTask: "New Task" },
+  internalProjectState: {
+    focusKey: "new-focus",
+    mode: "active",
+    commitment: {
+      kind: "artifact",
+      artifactKind: "code",
+      confidence: 0.9,
+      executableTask: "Fix Omega",
+    },
+  },
+};
+
+console.log("--- PROBANDO DERIVACIÓN DE EVENTOS DE MEMORIA ---");
+const events = deriveOpenSkynetLivingMemoryEvents({
+  sessionKey,
+  prior: priorState,
+  next: nextState,
+});
+
+console.log(JSON.stringify(events, null, 2));

test-nle-complex.ts

@@ -0,0 +1,39 @@
+import { NeuralLogicEngine } from "./src/omega/neural-logic-engine.js";
+
+async function runComplexTest() {
+  const engine = new NeuralLogicEngine();
+
+  // Escenario 1: Estado base - Todo normal
+  console.log("--- ESCENARIO 1: Estado Base ---");
+  let state = [0.4, 0.4, 0.4]; // Neutro
+  let context = { frustration: 0.1, recentFailures: 0, successRate: 0.9 };
+  let inference = engine.infer(state, context);
+  console.log("Reglas activas:", inference.activeRules);
+  console.log("Confianza:", inference.inferenceConfidence.toFixed(3));
+  console.log(
+    "Estado resultante:",
+    inference.stateAfter.map((v) => v.toFixed(3)),
+  );
+
+  // Escenario 2: Simulación de Frustración Crítica (Bucle de error)
+  console.log("\n--- ESCENARIO 2: Frustración Crítica ---");
+  state = [0.8, 0.8, 0.9]; // Estado de "estrés"
+  context = { frustration: 0.95, recentFailures: 5, successRate: 0.1 };
+  inference = engine.infer(state, context);
+  console.log("Reglas activas:", inference.activeRules);
+  console.log(
+    "Delta aplicado:",
+    inference.logicalDelta.map((v) => v.toFixed(3)),
+  );
+
+  // Aprendizaje en tiempo real: Penalizar si falló
+  console.log("\n--- APRENDIZAJE: Penalizando regla 0 ---");
+  engine.penalizeRule(0, 0.5);
+
+  // Re-inferir con el mismo estado
+  inference = engine.infer(state, context);
+  console.log("Reglas activas post-penalización:", inference.activeRules);
+  console.log("Nueva Confianza:", inference.inferenceConfidence.toFixed(3));
+}
+
+runComplexTest().catch(console.error);