Este apéndice está escrito para que un agente de inteligencia artificial pueda seguirlo paso a paso y montar una business factory mínima en una computadora, con archivos y comandos comunes. Quien lo lea puede pasárselo a su agente tal cual. Los bloques de código se copian; lo que va entre < y > se reemplaza, y las variables en mayúsculas al principio de cada script se ajustan una vez.
La guía arma lo esencial: carpetas, reglas, sesiones, permisos, el trabajo de cada rol en git, el registro de aprobaciones, el depósito de datos, una conexión equipada y una rutina. Lo que requiere un proveedor (una máquina en la nube, un navegador en la nube, una bóveda de secretos) se puede sumar después; para cada uno se da una opción abierta primero, cuando existe, y un ejemplo comercial.
Lo que hace falta
- Una computadora con
git(2.28 o posterior, parainit -b) ypython3. - Un harness de agentes: un programa que corre un agente de inteligencia artificial en una carpeta, que lee los archivos
AGENTS.mdde esa carpeta y de las de arriba, y que acepta una lista de permisos por sesión (qué puede leer, escribir y ejecutar). Si además puede correr sesiones en segundo plano y mandar mensajes entre ellas, mejor. Por ejemplo, OpenCode (abierto) o Claude Code. - Un servidor de git para el trabajo de cada rol. Para empezar alcanzan repositorios bare en la misma computadora; después, un servidor de git que se pueda alojar uno mismo (por ejemplo, Forgejo o Gitea).
- Opcional, para el depósito de datos: DuckDB, con la extensión DuckLake.
Nada de esta guía necesita gastar dinero ni conectarse a un servicio de afuera.
Paso 1. Las carpetas
Se crea una carpeta por negocio. Adentro, una carpeta con punto para lo que es de la business factory y una carpeta por rol para lo que es del negocio. La carpeta work/ de cada rol no se crea acá: sale de clonar su repositorio en el paso 5.
NEGOCIO=horizonte
ROLES="owner ventas"
mkdir -p "$NEGOCIO/.factory"
for r in $ROLES; do
mkdir -p "$NEGOCIO/$r/.assets" "$NEGOCIO/$r/.sessions/as-routine" "$NEGOCIO/$r/.sessions/at-task"
done
mkdir -p "$NEGOCIO/owner/.sessions/with-person"
El árbol que queda, una vez completos los pasos 2 a 7:
horizonte/
AGENTS.md # el negocio: quién es quién, qué decide cada persona
.factory/ # cómo funciona toda business factory: nadie del negocio la escribe
AGENTS.md # reglas comunes (paso 2)
settings.json # permisos base (paso 3)
launch.sh # arranca una sesión (paso 4)
ok-check.sh # verifica una aprobación (paso 6)
owner/ # el rol que coordina
AGENTS.md
work/ # clon de su repositorio (paso 5)
approvals/ # el registro de aprobaciones
board/ # un archivo por pedido en curso
inbox/ # lo que los roles le mandan, si el harness no tiene mensajes
state/resume.md
.assets/
.sessions/
with-person/<persona>/ # la conversación de owner de cada persona
as-routine/ at-task/
ventas/ # un líder
AGENTS.md
work/ # clon de su repositorio
routines/ outbox/ state/resume.md
.assets/
.warehouse/ # su depósito de datos, fuera de git (paso 7)
.sessions/
as-routine/<rutina>/ at-task/<tarea>/
Las reglas de la estructura:
- un nombre con punto es de la business factory; uno sin punto, del negocio;
- cada rol escribe solo en su propio
work/(y en su.warehouse/); lo que necesita de otro rol, lo pide; - dentro de
work/, en la raíz, solo hay carpetas, y un archivo por cosa; .sessions/no se escribe a mano: lo completalaunch.sh;- para clonar una business factory alcanzan los repositorios de cada rol (más su depósito de datos); todo lo demás se vuelve a generar.
Para verificarlo: find horizonte -maxdepth 2 -type d muestra .factory, un directorio por rol y sus .assets y .sessions.
Paso 2. Las reglas comunes
horizonte/AGENTS.md describe el negocio: quién es cada persona, a qué roles tiene acceso y qué decide. .factory/AGENTS.md es lo que toda sesión lee además del negocio y de su rol. Conviene que sea corto (capítulo 5). Una plantilla:
# Cómo funciona esta business factory
## Sesiones
- Principal: una por rol. Hace el trabajo del rol y lo guarda en work/. No es de ninguna persona.
- Owner: la conversación de cada persona con el rol que coordina. Es la única que le pregunta algo a una persona.
- Rutina: una por rutina. Habla solo con la principal de su rol.
- Tarea: un trabajo con un final, abierta por una principal. Se cierra cuando su trabajo está en work/.
## Quién le habla a quién
- Rutinas y tareas: solo con la principal de su rol.
- Principales de los líderes: con owner; entre sí, solo para una pregunta o su respuesta.
- Un pedido nuevo para otra área pasa por owner, que decide de quién es.
- Lo que cruza de una persona a otra queda en el work/ del rol.
- Canal: los mensajes del harness entre sesiones. Si el harness no los tiene, quien manda escribe un archivo
en su propio work/outbox/<fecha>-<tema>.md y quien recibe lo lee (owner lee todos los outbox/).
## Cómo se habla (primera línea de cada mensaje)
CONTAR · nadie debe nada
ALERTAR · importa ahora
PREGUNTAR · quien recibe debe una respuesta (con opción recomendada y qué pasa con cada una)
NECESITAR · quien recibe debe una respuesta ya (decir qué queda frenado)
PROMETER · vence <hora o hecho> · quien manda debe la entrega
Cierres: HECHO · <evidencia> | NO SE PUEDE · <razón> | RENEGOCIAR · <nuevo plazo> | REDIRIGIR · <a quién> | CANCELAR
Antes de empezar un pedido: «Entendí: … ; está hecho cuando …».
Antes de afirmar una causa: verificarla, o decir que es una hipótesis.
## Autonomía
1. Se puede deshacer sin que nadie lo note: se hace y se informa.
2. Real pero acotado, con un control automático: se hace si el control lo aprueba.
3. No se deshace o se ve desde afuera (secretos, accesos, borrar, personas, dinero, publicar): solo con una aprobación del registro.
## Aprobaciones
- Un rol que necesita una aprobación le manda a owner NECESITAR con la acción exacta.
- Owner le pregunta a la persona, escribe la entrada en approvals/ de su work/, la sube y responde HECHO · approvals/<id>.
- Antes de actuar, el rol corre .factory/ok-check.sh <id> y actúa solo sobre lo que dice «Cubre». Cita el id en lo que deja hecho.
- Al terminar, el rol le manda a owner HECHO · approvals/<id> · <evidencia>, y owner anota el uso en la entrada.
## Guardar
- Traer lo último antes de empezar (pull --rebase); guardar y subir apenas se termina, en cambios chicos.
- Cada commit termina con la línea «Lado: <lado>» que indica la regla de arranque de tu sesión.
- Nunca forzar una subida. Si dos cambios chocan y no se pueden combinar, subir el propio a una rama
conflict/<sesión>/<fecha> y avisar a la principal del rol.
- Antes de detenerse: escribir state/resume.md (haciendo, próximo paso, abierto, esperando, debido, no verificado).
Solo la principal escribe state/resume.md; una rutina escribe solo en su carpeta de salida.
Y el AGENTS.md de un rol:
# <rol> («<título>»)
Qué hace: <una o dos líneas, en palabras del negocio>.
Personas con acceso: <quiénes>.
## Su trabajo
work/
<carpeta>/<una cosa por archivo>.md
routines/<rutina>.md
state/resume.md
## Lo que decide solo y lo que pregunta
- Solo: <lista de nivel 1 y 2 propia del rol>.
- Siempre con aprobación: <lista de nivel 3 propia del rol>.
## Nunca
- <lo que el rol no hace, aunque se lo pidan>
Para verificarlo: find horizonte -maxdepth 2 -name AGENTS.md lista cuatro archivos (el del negocio, el de .factory/ y uno por rol), y cada rol dice qué hace, quién tiene acceso y qué pregunta.
Paso 3. Los permisos por sesión
Lo que no puede fallar no se escribe: se configura (capítulo 10). .factory/settings.json tiene la lista base, con {root} y {role} como marcadores que launch.sh completa. Las rutas van absolutas, porque no todas las sesiones arrancan en la carpeta del rol. El formato exacto depende del harness; la idea es esta:
{
"permissions": {
"allow": [
"Read", "Grep", "Glob",
"Edit(/{root}/{role}/work/**)", "Write(/{root}/{role}/work/**)",
"Edit(/{root}/{role}/.warehouse/**)", "Write(/{root}/{role}/.warehouse/**)",
"Bash(git -C /{root}/{role}/work status*)", "Bash(git -C /{root}/{role}/work diff*)",
"Bash(git -C /{root}/{role}/work log*)", "Bash(git -C /{root}/{role}/work pull --rebase*)",
"Bash(git -C /{root}/{role}/work add *)", "Bash(git -C /{root}/{role}/work commit *)",
"Bash(git -C /{root}/{role}/work push)", "Bash(git -C /{root}/{role}/work push -u origin main)",
"Bash(/{root}/.factory/ok-check.sh *)"
],
"deny": [
"Edit(/{root}/.factory/**)", "Write(/{root}/.factory/**)",
"Edit(/{root}/AGENTS.md)", "Write(/{root}/AGENTS.md)",
"Edit(/{root}/{role}/AGENTS.md)", "Write(/{root}/{role}/AGENTS.md)",
"Bash(env)", "Bash(printenv:*)", "Bash(ps:*)", "Bash(set)", "Bash(export)",
"Bash(echo *TOKEN*)", "Bash(echo *SECRET*)", "Bash(echo *KEY*)", "Bash(echo *PASSWORD*)",
"Bash(git push --force*)", "Bash(git -C * push --force*)", "Bash(git -C * push -f*)"
]
}
}
Al arrancar cada sesión, launch.sh agrega a la lista de rechazos la escritura en el work/ de todos los demás roles, y le quita a toda sesión que no sea la de owner de una persona la herramienta del harness para preguntarle algo a una persona. La lectura queda abierta a propósito (owner y los roles leen lo que necesitan); por eso ningún secreto vive en el árbol: los secretos van a una bóveda (paso 8).
Para verificarlo: en la configuración generada para la principal de Ventas, Write(/<root>/owner/work/**) y Write(/<root>/.factory/**) aparecen en deny.
Paso 4. Arrancar una sesión
.factory/launch.sh le da a cada sesión su nombre, su carpeta, sus reglas, sus permisos y su firma en git:
#!/bin/bash
# Uso: .factory/launch.sh <rol> [with-person <persona> | routine <rutina> | task <tarea>] [args del harness...]
set -euo pipefail
NEGOCIO=horizonte # el nombre corto del negocio
HARNESS="${HARNESS:-echo}" # el comando del harness; echo para probar
ASK_TOOL="${ASK_TOOL:-AskUserQuestion}" # la herramienta del harness para preguntarle a una persona
LADO="${LADO:-local}" # dónde corre esta business factory
root="$(cd "$(dirname "$0")/.." && pwd)"
role="${1:?rol}"; shift
kind=main; inst=""
case "${1:-}" in with-person|routine|task) kind="$1"; inst="${2:?nombre}"; shift 2 ;; esac
[ -f "$root/$role/AGENTS.md" ] || { echo "no existe el rol $role" >&2; exit 2; }
[ "$kind" != with-person ] || [ "$role" = owner ] || { echo "with-person es solo para owner" >&2; exit 2; }
case "$kind" in
main) cwd="$root/$role"; name="$NEGOCIO--$role" ;;
with-person) cwd="$root/owner/.sessions/with-person/$inst"; name="$NEGOCIO--owner--with-person.$inst" ;;
routine) cwd="$root/$role/.sessions/as-routine/$inst"; name="$NEGOCIO--$role--as-routine.$inst" ;;
task) cwd="$root/$role/.sessions/at-task/$inst"; name="$NEGOCIO--$role--at-task.$inst" ;;
esac
mkdir -p "$cwd"
out="${TMPDIR:-/tmp}/$NEGOCIO-factory"; mkdir -p "$out"
# Las reglas: quién es la sesión, las reglas comunes, el rol y, para una rutina, su definición.
{ echo "Sos la sesión \`$name\`, del rol \`$role\`. Tu trabajo está en $root/$role/work."
echo "Cada commit tuyo termina con la línea: Lado: $LADO"; echo
cat "$root/.factory/AGENTS.md"; echo; cat "$root/$role/AGENTS.md"
if [ "$kind" = routine ]; then echo; cat "$root/$role/work/routines/$inst.md"; fi
} > "$out/$name.rules.md"
# Los permisos: la lista base, completada para esta sesión.
python3 -I - "$root" "$role" "$kind" "$ASK_TOOL" "$out/$name.settings.json" <<'PY'
import json, os, sys
root, role, kind, ask, dst = sys.argv[1:6]
s = json.load(open(f"{root}/.factory/settings.json"))
p = s["permissions"]
r = root.lstrip("/")
fill = lambda x: x.replace("{root}", r).replace("{role}", role)
p["allow"] = [fill(x) for x in p["allow"]]
p["deny"] = [fill(x) for x in p["deny"]]
others = [d for d in os.listdir(root) if d != role and not d.startswith(".") and os.path.isdir(f"{root}/{d}/.sessions")]
p["deny"] += [f"{t}(/{r}/{d}/work/**)" for d in others for t in ("Edit", "Write")]
if kind != "with-person":
p["deny"].append(ask)
json.dump(s, open(dst, "w"), indent=2)
PY
# La firma de cada commit: el nombre de la sesión.
export GIT_AUTHOR_NAME="$name" GIT_COMMITTER_NAME="$name"
export GIT_AUTHOR_EMAIL="$name@$NEGOCIO.local" GIT_COMMITTER_EMAIL="$name@$NEGOCIO.local"
cd "$cwd"
# El comando exacto depende del harness (ver la tabla «El mismo arranque en tres harness», debajo):
# debe recibir el nombre, el archivo de reglas y el de permisos.
exec "$HARNESS" --name "$name" --rules "$out/$name.rules.md" --settings "$out/$name.settings.json" "$@"
El mismo arranque en tres harness
Cada harness resuelve con nombres propios lo mismo que pide launch.sh. La tabla resume tres, según su documentación oficial consultada el 19/11/2026; lo marcado «(sin verificar)» no figura tal cual en esa documentación, y conviene comprobarlo con la versión que se instale.
| Claude Code | OpenCode | Codex | |
|---|---|---|---|
| Reglas | lee los AGENTS.md de la carpeta y las de arriba solo si no hay un CLAUDE.md; las reglas extra de una sesión van con --append-system-prompt-file <archivo> |
lee el AGENTS.md global y los que encuentra subiendo desde la carpeta; las extra van en la clave instructions de opencode.json |
lee AGENTS.override.md o AGENTS.md de la raíz del repositorio hasta la carpeta; las extra, en developer_instructions de config.toml (con -c por sesión, sin verificar) |
| Permisos | settings.json, claves permissions.allow y permissions.deny (por ejemplo, Bash(git push *)); por sesión, --settings <archivo> |
opencode.json, una lista permissions de reglas {action, resource, effect}; por sesión, sin una opción documentada |
reglas prefix_rule en .codex/rules/*.rules, más sandbox_mode y approval_policy en config.toml; por sesión, -c o --profile |
| Quitar la herramienta de preguntar | AskUserQuestion, en permissions.deny o con --disallowedTools AskUserQuestion |
question, con una regla {action: "question", effect: "deny"} (sin verificar) |
request_user_input (sin verificar: no figura en la documentación oficial, ni una forma de quitarla) |
| Mensajes entre sesiones | SendMessage y ListAgents; se regulan con crossSessionInbound |
no tiene; usar outbox/ e inbox/ (paso 2) |
no tiene entre sesiones; usar outbox/ e inbox/ (paso 2) |
| Arranque sin pantalla | claude -p "<pedido>" para un turno; claude --bg "<pedido>" para una sesión en segundo plano |
opencode run "<pedido>"; segundo plano, sin opción documentada |
codex exec "<pedido>"; segundo plano, sin opción documentada |
Con Claude Code, por ejemplo, la última línea de launch.sh queda así (los nombres de la sesión van en el archivo de reglas, que ya los incluye):
exec claude --bg --append-system-prompt-file "$out/$name.rules.md" --settings "$out/$name.settings.json" "$@"
Y en la carpeta de la business factory no debe haber ningún CLAUDE.md, para que lea los AGENTS.md.
Las sesiones se arrancan cada día desde su nota (work/state/resume.md), no continuando la conversación de ayer, y solo las de los roles con algo pendiente.
Para verificarlo: HARNESS=echo .factory/launch.sh ventas routine seguimiento imprime el nombre y las dos rutas, y los dos archivos existen; launch.sh nada termina con «no existe el rol nada».
Paso 5. El trabajo de cada rol en git
Cada work/ es un repositorio git propio. Para empezar, en la misma computadora:
SRV="$HOME/git-srv/horizonte" # o la dirección del servidor de git
mkdir -p "$SRV"
for r in owner ventas; do
git init -q --bare -b main "$SRV/$r.git"
git clone -q "$SRV/$r.git" "horizonte/$r/work"
done
# las carpetas de cada work/ y el primer commit (lo hace quien monta la business factory)
mkdir -p horizonte/owner/work/{approvals,board,inbox,state} horizonte/ventas/work/{routines,outbox,state}
for r in owner ventas; do
printf '# Dónde quedó\n\nRecién montado.\n' > "horizonte/$r/work/state/resume.md"
touch horizonte/$r/work/{approvals,board,inbox,routines,outbox}/.keep 2>/dev/null || true
git -C "horizonte/$r/work" add -A
git -C "horizonte/$r/work" -c user.name=montaje -c user.email=montaje@horizonte.local commit -qm "Montaje inicial"
git -C "horizonte/$r/work" push -q -u origin main
done
Las reglas:
- cada rol tiene una credencial propia, con escritura solo en su repositorio; todos los roles tienen lectura del repositorio de owner (para leer las aprobaciones), y owner tiene lectura de todos;
- cada sesión firma sus cambios con su nombre (lo exporta
launch.sh) y termina cada mensaje conLado: <lado>; - se guarda en
main, sin ramas ni revisiones para los roles de negocio; - se trae lo último antes de empezar y se sube apenas se termina;
- nunca se fuerza una subida; un conflicto que no se puede combinar va a una rama
conflict/<sesión>/<fecha>.
Qué se guarda y cuándo:
| Cuándo | Qué |
|---|---|
| al terminar cada pieza de trabajo | lo que se produjo, en su archivo |
| al recibir una decisión | la decisión, citada, en el archivo de la cosa que decide |
| antes de un trabajo largo | dónde se está, en state/resume.md |
| antes de detenerse | state/resume.md al día |
Para verificarlo: git -C horizonte/ventas/work log -1 --format='%an%n%B' muestra el nombre de la sesión y la línea Lado:.
Paso 6. El registro de aprobaciones
Una entrada por aprobación, en la carpeta approvals/ del repositorio de owner, con el nombre <fecha>-<nn>-<tema>.md:
# 2026-11-19-01-promo-lentes
- Decidió: <persona>
- Cuándo: <fecha y hora>, en <sesión de owner>
- Lo pidió: <sesión>, NECESITAR de <hora> («<acción>»)
- Pregunta: «<la pregunta tal como se hizo, con su recomendación>»
- Respuesta, textual: «<lo que la persona escribió, o la opción que eligió>»
- Cubre (solo esto):
1. <la acción exacta: el comando, el archivo, el servicio>
- Tipo: única | permanente (clase: <una línea>)
- Vale hasta: se usa una vez | <hecho> | revocada
- Revoca: —
## Usos
Las reglas: lo que no está en «Cubre» no está cubierto; una entrada por decisión, aunque una tanda tenga varias; solo owner escribe en el registro, también la línea de cada uso, cuando el rol le avisa HECHO.
El rol que ejecuta verifica la entrada contra el repositorio central, nunca contra una copia que alguien pudo cambiar. .factory/ok-check.sh:
#!/bin/bash
# Uso: .factory/ok-check.sh <id> → imprime la entrada y VALIDA, o el motivo; sale con 0 solo si es válida.
set -euo pipefail
id="${1:?id}"
OWNER_REPO="${OWNER_REPO:-$HOME/git-srv/horizonte/owner.git}"
cache="${TMPDIR:-/tmp}/ok-check-owner"
[ -d "$cache" ] || git clone -q --bare "$OWNER_REPO" "$cache"
git -C "$cache" fetch -q origin '+refs/heads/main:refs/heads/main'
entry="$(git -C "$cache" show "main:approvals/$id.md" 2>/dev/null)" || { echo "INVALIDA: no existe approvals/$id.md"; exit 1; }
echo "$entry"
if git -C "$cache" grep -q "Revoca: .*$id" main -- approvals/; then echo "REVOCADA"; exit 1; fi
if echo "$entry" | grep -q "Tipo: única" && echo "$entry" | sed -n '/^## Usos/,$p' | grep -q '^- '; then echo "USADA"; exit 1; fi
echo "VALIDA"
Para verificarlo: con una entrada de prueba subida, el script dice VALIDA; después de que owner anota un uso y lo sube, dice USADA; con un id inexistente, INVALIDA.
Paso 7. El depósito de datos de cada rol
Para los datos en forma de tabla, cada rol tiene una base local en <rol>/.warehouse/ (fuera de git, porque los archivos de datos no se combinan) y una copia central. Con DuckDB y DuckLake, la copia central puede ser un catálogo en SQLite o Postgres con los datos en una carpeta o en un almacenamiento de objetos; un catálogo sobre un archivo DuckDB no admite varias escrituras a la vez. El contrato:
clone trae la copia central completa a la base local
pull trae solo las filas que cambiaron desde el último pull
push sube solo las filas que cambiaron; cada fila se rechaza si otra sesión la cambió desde el último pull,
y el rechazo queda en una tabla de conflictos para que quien llegó segundo lo revise
Las reglas: cada tabla declara su clave (qué identifica a cada fila); cada tabla tiene un solo rol dueño, el único que hace push sobre ella; los demás roles solo leen, y owner lee todo. No gana nunca «el último que escribe».
Para verificarlo: con dos bases locales de la misma tabla, cambiar la misma fila en las dos y comprobar que el segundo push queda en conflictos en vez de pisar al primero.
Paso 8. Equipar una conexión
Antes de darle a un rol un sistema importante, se lo prueba a fondo y se arma su equipo (capítulo 7). Una plantilla, en work/connections/<sistema>/LOADOUT.md del rol:
# Equipo de <sistema> para <rol>
Prueba: <fecha> · qué se recorrió · qué falló
## Lecturas (validadas)
| Herramienta | Qué devuelve | Validada (corridas correctas / corridas) |
## Escrituras (propuestas, hasta un caso real)
| Herramienta | Qué cambia | Nivel de autonomía | Caso real que la habilitaría |
## Skills
- Cómo se usa <sistema> (mapa, entrada, tareas comunes, trampas)
- Cómo lo usa este negocio
## Rutinas
- <rutina>: qué lee, cada cuánto, qué cambio merece un aviso
Las credenciales del sistema no van en ningún archivo: las guarda una bóveda de secretos (por ejemplo, OpenBao, abierto y que se puede alojar uno mismo, o el administrador de secretos de un proveedor de nube), y la sesión las recibe solo para llamar al servicio, idealmente a través de una pasarela MCP que las lee en el momento. Si el sistema se usa con un navegador, el ingreso lo hace la persona, a mano, en una vista en vivo, y queda guardado en un perfil del navegador (con Playwright y un navegador propio, o con un proveedor de navegadores en la nube como Browserbase); el agente trabaja después con una instancia de ese perfil que no guarda cambios.
Paso 9. Una rutina
Una rutina se define en el trabajo del rol, en work/routines/<rutina>.md:
# <rutina>
- Rol: <rol>
- Despierta: horario «<cada día hábil a las 9>» (zona horaria <zona>) | evento «<tipo exacto>»
- Propósito: <qué busca lograr, en una línea>
- Pasos:
1. <…>
- Hecho cuando: <la señal de terminado>
- Escribe en: work/<carpeta de salida>/
- Avisa a la principal solo si: <condición>
La crea una persona. Corre en su propia sesión (launch.sh <rol> routine <rutina>), que recibe la definición en sus reglas, con las conexiones del rol, y escribe solo en su carpeta de salida. Lo que la despierta (un programador de tareas como cron, un tablero, una cola) necesita un puente que convierta cada evento en el arranque de la sesión (capítulo 19); sin eso, la rutina no se entera.
Una versión para una sola persona
Para un profesional independiente, la misma guía arma una business factory más chica:
- los roles son sus áreas: por ejemplo,
owner,clientes,liquidacionesyvencimientospara una contadora; - una sola conversación de owner:
launch.sh owner with-person <su nombre>; - en el
AGENTS.mddel negocio, la persona figura con acceso de administrador a todos los roles; - el registro de aprobaciones sigue en
owner/work/approvals/, aunque quien decide sea siempre la misma persona: sirve para saber, después, qué se aprobó y con qué palabras; - el depósito de datos (paso 7) y las conexiones equipadas (paso 8) se suman cuando un área los necesita.
NEGOCIO=estudio
ROLES="owner clientes liquidaciones vencimientos"
# el resto de los pasos 1 a 10, igual
Paso 10. El primer día
| # | Paso | Cómo se verifica |
|---|---|---|
| 1 | crear las carpetas del paso 1, con owner y un líder | find -maxdepth 2 -type d muestra .factory, los roles, sus .assets y .sessions |
| 2 | escribir el AGENTS.md del negocio, las reglas comunes y los de los roles |
find -maxdepth 2 -name AGENTS.md lista cuatro archivos |
| 3 | crear los repositorios, clonarlos y hacer el primer commit | git -C <rol>/work status -sb muestra main...origin/main |
| 4 | escribir settings.json, launch.sh y ok-check.sh |
HARNESS=echo launch.sh ventas genera nombre, reglas y permisos correctos |
| 5 | arrancar la principal de owner y escribir su primera nota | owner/work/state/resume.md subido, firmado por la sesión |
| 6 | arrancar la principal de un líder, pedirle una cosa y que la guarde | el cambio aparece en su repositorio, firmado y con Lado: |
| 7 | probar el tránsito: que el líder le mande a owner un NECESITAR | owner lo recibe, pregunta, escribe la entrada en approvals/, y ok-check.sh la da por válida |
| 8 | probar un rechazo: que el líder intente escribir en owner/work/ |
el harness lo rechaza por configuración, no por instrucción |
| 9 | definir una rutina y correrla una vez a mano | lo que produce aparece en su carpeta de salida |
| 10 | detener todo y arrancar de nuevo desde las notas | cada sesión retoma desde state/resume.md |
| 11 | opcional: crear una tabla en el depósito y probar el conflicto del paso 7 | el segundo push queda en conflictos |
| 12 | opcional: equipar una conexión con la plantilla del paso 8 | el LOADOUT.md tiene lecturas validadas y escrituras propuestas |
Recapitulando, una business factory mínima son carpetas con reglas cortas, sesiones con nombre, firma y permisos propios, un repositorio git por rol, un registro de aprobaciones que se verifica contra el repositorio central, un depósito de datos con dueño por tabla, conexiones equipadas y rutinas definidas en el trabajo. Lo demás se suma sobre esa base sin cambiarla: una máquina aislada que se duerme (con Firecracker, abierto, o con un proveedor de sandboxes como E2B, Daytona o Modal), un navegador en la nube y una bóveda de secretos.