Cómo abordar el onboarding
por misiones

read -rp "email de prueba: " EMAIL; read -rsp "password: " PW; echo
# TP-A1 · autenticar por el MISMO endpoint que auth.ts:30 → user.id DINÁMICO
RESP=$(curl -s -X POST "$IBASE/api/auth/sessions?client_type=server" \
  -H "content-type: application/json" -H "apikey: $IANON" \
  -d "{\"email\":\"$EMAIL\",\"password\":\"$PW\"}")
UID=$(echo "$RESP" | jq -r '.user.id // empty')
[ -n "$UID" ] && echo "TP-A1 OK · sesión válida · user.id=$UID" || { echo "TP-A1 FAIL (fail-closed)"; }
# TP-A2 · el gate del user recién nacido — query EXACTA de access.ts:38 con el UID descubierto
curl -s -H "Authorization: Bearer $ISK" \
  "$IBASE/api/database/records/user_access?user_id=eq.$UID&select=authorized" | jq -c \
  | sed 's/^/TP-A2 · user_access = /'   # []  → no autorizado (fail-closed) → gateado a /welcome

# usa $UID del H1 (o redescubrilo con el login). $COOKIE = valor de insforge_session del navegador.
# (a) ANTES: gateado
curl -s -o /dev/null -w "A2-antes · %{http_code} → %{redirect_url}\n" \
  -b "insforge_session=$COOKIE" https://app.agentsquadai.com/office
# (b) grant a mano (operador) — tabla user_access, columnas de access.ts
curl -s -X POST "$IBASE/api/database/records/user_access" -H "Authorization: Bearer $ISK" \
  -H "content-type: application/json" -d "{\"user_id\":\"$UID\",\"authorized\":true}" | jq -c
# (c) DESPUÉS: pasa el gate
curl -s -H "Authorization: Bearer $ISK" \
  "$IBASE/api/database/records/user_access?user_id=eq.$UID&select=authorized" | jq -c \
  | sed 's/^/A2-despues · user_access = /'   # [{"authorized":true}]

curl -s -X POST -b "insforge_session=$COOKIE" -H "content-type: application/json" \
  -d '{}' https://app.agentsquadai.com/api/user/state | jq '.app_state.onboarding_answers'
# Evidencia: onboarding_answers ≠ null (las respuestas persistieron).

# (1) el squad vive en app_state
curl -s -X POST -b "insforge_session=$COOKIE" -H "content-type: application/json" \
  -d '{}' https://app.agentsquadai.com/api/user/state | jq '.app_state.squads'
# (2) prueba del SEAM: el workspace de ejecución NO es el squad — es fijo
echo "workspace de ejecución (fijo): $WSID"
grep -n "SUBSTRATE_WORKSPACE_ID" $WEB/src/lib/server/substrate.ts
# Evidencia: squads[] con shape válido + confirmación de que $WSID ≠ squad.id

curl -s "http://127.0.0.1:4000/api/workspaces/$WSID/activity?limit=1" \
  -H "Authorization: Bearer $TOKEN" | jq '{shipped: .stats.succeeded24h, review: .stats.pendingReview}'
# Evidencia: los números que ve el office == los del substrato (o fallback si null).

# (1) sin sesión → 403 (gate doble)
curl -s -o /dev/null -w "sin-sesion · %{http_code}\n" -X POST \
  https://app.agentsquadai.com/api/substrate/compose -H "content-type: application/json" -d '{}'
# (2) el bearer va SOLO server-side: nunca aparece en el bundle del browser
grep -rn "SUBSTRATE_API_TOKEN" $WEB/src/lib/server/ | wc -l   # >0 en /server
grep -rn "SUBSTRATE_API_TOKEN" $WEB/src/routes/ | grep -v "/api/" | wc -l  # 0 fuera de server
# Evidencia: 403 sin sesión + token confinado a lib/server.

# declara un intent con valores VÁLIDOS y captura intent.id de la respuesta (no lo pegás)
INTENT=$(curl -s -X POST "http://127.0.0.1:4000/api/intents" -H "Authorization: Bearer $TOKEN" \
  -H "content-type: application/json" \
  -d "{\"workspace_id\":\"$WSID\",\"kind\":\"answer_question\",\"subject_label\":\"onboarding smoke test\",\"acceptance_criteria_ref\":\"answer.accuracy@1\"}")
IID=$(echo "$INTENT" | jq -r '.intent.id // empty')
echo "intent.id dinámico: $IID"   # vacío → revisá el 4xx: kind fuera del enum o ref sin @N
# TP-0 · el intent existe y no está en error
q "SELECT id,status FROM intents WHERE id='$IID';"

PID=$(q "SELECT id FROM plans WHERE intent_id='$IID' ORDER BY 1 LIMIT 1;")
echo "plan.id dinámico: $PID"
# TP-1 · cada operation_ref del plan (deberían resolver todos en el catálogo)
q "SELECT ordinal, step_id, operation_ref FROM steps WHERE plan_id='$PID' ORDER BY ordinal;"

TR=$(q "SELECT id FROM traces WHERE workspace_id='$WSID' ORDER BY started_at DESC LIMIT 1;")
echo "trace.id dinámico: $TR"
# TP-2 · correlación
q "SELECT status, inngest_run_id FROM traces WHERE id='$TR';"
# TP-3 · capa 1: una fila por CADA step, sin fallos inesperados
q "SELECT step_id, status, cost, error FROM step_executions WHERE trace_id='$TR' ORDER BY started_at;"

# descubre el doc/chunks más recientes del workspace
DOC=$(q "SELECT document_id FROM document_chunks WHERE workspace_id='$WSID' ORDER BY created_at DESC LIMIT 1;")
# TP-4 · el contenido indexado está anonimizado (buscá etiquetas, no PII cruda)
q "SELECT security_level, left(content,120) FROM document_chunks WHERE document_id='$DOC' LIMIT 3;"
# TP-5 · conteo de chunks + que existe embedding
q "SELECT count(*) FROM document_chunks WHERE document_id='$DOC' AND embedding IS NOT NULL;"

# TP-6a · el gate RBAC en aislamiento (determinista, siempre corre) — la función real del filtro
cd /home/clawd/agent-squad-app/apps/api && bun -e "import {levelsAtOrBelow} from './src/substrate/query/clearance'; \
  console.log('publico     →', levelsAtOrBelow('publico')); \
  console.log('confidencial→', levelsAtOrBelow('confidencial'))"
# esperado: publico → ['publico']  ·  confidencial → ['publico','interno','confidencial']

# TP-6b · sobre datos vivos: los chunk_id de la evidencia de un document.query real → su nivel real
SE=$(q "SELECT trace_id||'|'||step_id FROM step_executions se
        WHERE EXISTS (SELECT 1 FROM steps s WHERE s.plan_id=(SELECT plan_id FROM traces WHERE id=se.trace_id)
                      AND s.step_id=se.step_id AND s.operation_ref ILIKE 'document.query%')
        ORDER BY started_at DESC LIMIT 1;")
[ -n "$SE" ] && q "SELECT dc.security_level, count(*)
   FROM step_executions se,
        jsonb_array_elements(se.outputs_snapshot->'answer'->'evidence') ev
        JOIN document_chunks dc ON dc.chunk_id = ev->>'chunk_id'
   WHERE se.trace_id='${SE%|*}' AND se.step_id='${SE#*|}' GROUP BY dc.security_level;" \
  || echo "aún no hay un step document.query; lanzá el SuperSkill 'document-query' con clearance publico primero"

# TP-9 · el step evaluator y su resultado (reusa $TR del H9)
q "SELECT se.step_id, s.operation_ref, se.status, se.verdict
   FROM step_executions se JOIN steps s ON s.plan_id=(SELECT plan_id FROM traces WHERE id='$TR')
     AND s.step_id=se.step_id
   WHERE se.trace_id='$TR' AND s.operation_ref ILIKE '%eval%';"

# TP-10 · descubrir una trace suspendida y su artifact pendiente
TRW=$(q "SELECT id FROM traces WHERE workspace_id='$WSID' AND status='awaiting_human' ORDER BY started_at DESC LIMIT 1;")
ART=$(q "SELECT id FROM artifacts WHERE workspace_id='$WSID' AND produced_by->>'trace_id'='$TRW' AND status='pending_review' LIMIT 1;")
echo "trace suspendida=$TRW · artifact pendiente=$ART"
# aprobar (resume la corrida)
curl -s -X POST "http://127.0.0.1:4000/api/approvals" -H "Authorization: Bearer $TOKEN" \
  -H "content-type: application/json" \
  -d "{\"workspace_id\":\"$WSID\",\"artifact_id\":\"$ART\",\"decision\":\"approved\"}" | jq -c
# verificar el resume
q "SELECT status FROM traces WHERE id='$TRW';"

# TP-7 · claims con su provenance (reusa $TR)
q "SELECT subject, predicate, provenance->>'step_id' AS step, confidence
   FROM claims WHERE workspace_id='$WSID' AND provenance->>'trace_id'='$TR';"
# TP-12 · artifacts con su produced_by
q "SELECT kind, status, content_addr, produced_by->>'step_id' AS step
   FROM artifacts WHERE workspace_id='$WSID' AND produced_by->>'trace_id'='$TR';"

# TP-11 · candidatos en build-gate (si los hay)
curl -s "http://127.0.0.1:4000/api/forge/pending?workspace_id=$WSID" \
  -H "Authorization: Bearer $TOKEN" | jq '.pending | length'
# confirmar bwrap activo (el muro de verify Y execute) — probe idéntico al de sandbox.ts
bwrap --ro-bind / / --unshare-all --die-with-parent /usr/bin/true && echo "bwrap OK (namespaces sin privilegios)"
cat /proc/sys/kernel/apparmor_restrict_unprivileged_userns   # 1 + perfil /etc/apparmor.d/bwrap = correcto

# TP-13 · la vista de traza completa (endpoint espejo del que usa el office/demo)
curl -s "http://127.0.0.1:4000/api/workspaces/$WSID/traces/$TR" -H "Authorization: Bearer $TOKEN" \
  | jq '{intent: .trace.intent_statement, steps: [.steps[] | {op: .operation_ref, status: .exec.status}], artifacts: (.artifacts|length), claims: (.claims|length)}'
# capa 2/3 · el mismo trace en Langfuse (span id determinista ${trace_id}-${stepId})
LFHOST=$(grep ^LANGFUSE_HOST $API/.env | cut -d= -f2-); echo "Langfuse: ${LFHOST:-http://127.0.0.1:3030} → buscar trace $TR"