Super Skills: arquitectura y plan de inicialización

// apps/api/src/routes/ready.ts (montar en index.ts junto a healthRoute)
import { Hono } from 'hono';
import { sql } from '../substrate/db';
import { env } from '../env';
import { FUNCTIONS } from '../inngest/functions'; // las 10 funciones

const REQUIRED_TABLES = ['superskills', 'plan_drafts', 'intents', 'plans', 'traces', 'step_executions'];

export const readyRoute = new Hono().get('/ready', async (c) => {
  const checks: Record<string, boolean | string> = {};

  // 1. DB viva
  try { await sql`SELECT 1 AS ok`; checks.substrate_db = true; }
  catch { checks.substrate_db = false; }

  // 2. Schema aplicado (cubre los DOS directorios de migraciones)
  try {
    const rows = await sql`
      SELECT unnest(${REQUIRED_TABLES}::text[]) AS t,
             to_regclass('public.' || unnest(${REQUIRED_TABLES}::text[])) IS NOT NULL AS present`;
    const missing = rows.filter(r => !r.present).map(r => r.t);
    checks.schema = missing.length === 0 ? true : `missing: ${missing.join(',')}`;
  } catch { checks.schema = false; }

  // 3. Executor Inngest alcanzable + funciones registradas
  try {
    const base = env.INNGEST_BASE_URL; // http://127.0.0.1:8288
    const ping = await fetch(base, { signal: AbortSignal.timeout(2000) });
    checks.inngest_reachable = ping.ok;
    // endpoint por confirmar segun version del executor (p.ej. /v1/apps)
    const apps = await fetch(`${base}/v1/apps`, { signal: AbortSignal.timeout(2000) }).then(r => r.json());
    const registered = apps?.data?.find((a) => a.name?.includes('substrate'))?.functions_count ?? 0;
    checks.inngest_functions = registered >= FUNCTIONS.length ? true : `registered ${registered}/${FUNCTIONS.length}`;
  } catch { checks.inngest_reachable = false; }

  // 4. Env critico (espejo de assertProdEnvComplete)
  checks.env = Boolean(env.INNGEST_EVENT_KEY && env.SUBSTRATE_API_TOKEN && env.NOTIFY_EMAIL_OPS)
    || 'missing critical env';

  const ready = Object.values(checks).every(v => v === true);
  return c.json({ ready, checks }, ready ? 200 : 503);
});

# /etc/systemd/system/agent-squad-api.service.d/robustness.conf (extender el drop-in existente)
[Service]
# Espera activa a las dependencias reales, no solo al daemon Docker (gap e)
ExecStartPre=/bin/sh -c 'until pg_isready -q -h 127.0.0.1 -p 5433; do sleep 2; done'
ExecStartPre=/bin/sh -c 'until (echo > /dev/tcp/127.0.0.1/8288) 2>/dev/null; do sleep 2; done'
TimeoutStartSec=180

# substrate-infra/scripts/auto-deploy-api.sh (reemplaza el bloque de las lineas 49-57)
systemctl restart agent-squad-api.service

# 1. Gate de readiness compuesto (NO el /health barato)
for i in $(seq 1 30); do
  code=$(curl -s -o /dev/null -w '%{http_code}' http://127.0.0.1:4000/ready) && [ "$code" = "200" ] && break
  sleep 2
done
[ "$code" = "200" ] || { echo "ERROR: /ready=$code, marker NO actualizado" >&2; exit 1; }

# 2. Forzar re-registro en el executor (no depender del polling de 5s)
curl -sf -X PUT http://127.0.0.1:4000/api/inngest > /dev/null \
  || { echo "ERROR: PUT /api/inngest fallo" >&2; exit 1; }

# 3. Verificar registro real de las 10 funciones (endpoint por confirmar)
fns=$(curl -sf http://127.0.0.1:8288/v1/apps | jq '[.data[] | select(.name|test("substrate")) | .functions_count] | add // 0')
[ "$fns" -ge 10 ] || { echo "ERROR: solo $fns/10 funciones registradas" >&2; exit 1; }

# 4. Smoke: disparar el canary ya, sin esperar el cron de 10 min (ruta por confirmar)
curl -sf -X POST http://127.0.0.1:4000/api/dev/canary-fire > /dev/null || true

# 5. Solo ahora, actualizar el marker
git -C "$REPO" rev-parse HEAD > "$MARKER"

// apps/api/src/substrate/engine-ready.ts (guard con cache corto para no penalizar cada launch)
let cache = { ok: false, at: 0 };
const TTL_MS = 15_000;

export async function assertExecutePlanRegistered(): Promise<void> {
  if (Date.now() - cache.at < TTL_MS && cache.ok) return;
  try {
    // endpoint por confirmar segun version del executor self-hosted
    const res = await fetch(`${env.INNGEST_BASE_URL}/v1/apps`, { signal: AbortSignal.timeout(1500) });
    const apps = await res.json();
    const fns = apps?.data?.flatMap((a) => a.functions?.map((f) => f.id) ?? []) ?? [];
    cache = { ok: fns.some((id) => id.includes('substrate-execute-plan')), at: Date.now() };
  } catch {
    cache = { ok: false, at: Date.now() };
  }
  if (!cache.ok) throw new Error('engine_not_ready');
}

// apps/api/src/routes/superskills.ts (dentro del handler de launch, ANTES de crear nada)
try {
  await assertExecutePlanRegistered();
} catch {
  return c.json({ error: 'engine_not_ready' }, 503); // en vez del 201 fantasma del gap (d)
}
// ... getSuperskill + merge de overrides + launchCompiledPlan como hoy ...

// Y en launch-plan.ts, la compensacion (mitad 1 del gap d):
try {
  await inngest.send({ name: 'plan.compiled', data: { intent_id, plan_id, template_id, workspace_id } });
} catch (err) {
  await updateIntentStatus(intent.id, 'failed');
  await completeTrace(trace.id, { verdict: 'failed', reason: 'event_send_failed' }); // firma real por confirmar
  throw err; // la ruta lo mapea a 502 launch_failed como hoy, pero ya sin huerfanos 'running'
}