Current authoritative specification: v29 / Full R23

All five original participants newly approved this exact master and twenty phase digests. Thirteen recipes now validate Cargo workspace at the authorized repository root; target/executable containment and STOP on error remain mandatory. P52 source commit1d5f6b9 is preserved, so its next stage is verification. This corrects documentation and source provenance within the original scope.

Master: D:/0_repos/AgentsCommander_iac/.ac/plans/2992-settings-owner/plan-v29-settings-owner.md
Plan-SHA256: E12A49A810F4270C93BFA7D2EA0C9829EE99AF0B95231912C5CFC30FA80A2051
Mapping: D:/0_repos/AgentsCommander_iac/.ac/plans/2992-settings-owner/phase-issues-v17.json
Identity-SHA256 (compact identity object): 43A926CB7FE16F1FB9CC1D16E5437851C894993C51CD7BBBA5CFF1DFE5EC8D2A
Consensus: D:/0_repos/AgentsCommander_iac/.ac/project-shared/2992-settings-owner/minimum-path-20261016/full-r23-consensus-approved-v1.json
Standing authorization: D:/0_repos/AgentsCommander_iac/.ac/plans/2992-settings-owner/v29-standing-authorization-receipt-v1.json
Complete joined phase and file-impact packet: D:/0_repos/AgentsCommander_iac/.ac/project-shared/2992-settings-owner/minimum-path-20261016/v29-mapped-review-packet-v1.md

All twenty child/branch identities and BASE values are preserved. Six delivered phases remain closed; fourteen phases remain sequential. Execution requires a fresh cold gate and explicit lead dispatch. Shipper exclusively runs product checks; no intermediate app build. Previously requested final no-bundle build once after all phases merge from clean synchronized main, with room09 artifact path/hash/bytes/UTC/sourceSHA; no installation/release/version bump.

Phase P57, child#3151, owner ac-dev-rust-v5, class design-bearing, branch refactor/3151-settings-owner-p57-catalog-admission, dependencies P56.
Canonical phase file (sole implementation specification): D:/0_repos/AgentsCommander_iac/.ac/plans/2992-settings-owner/P57-v2-catalog-admission.md
Phase-SHA256: 48748FE3A25DC3787EFD510948DEA6CB64137D30BCA37E923A2D6BF837A78EA1
Allowed MODIFIED paths (0A/0D):

• src-tauri/src/config/coding_agents_catalog.rs
• src-tauri/src/config/settings.rs
• src-tauri/src/lib.rs
• src-tauri/src/commands/ac_discovery.rs
• src-tauri/src/cli/new_project.rs
• src-tauri/src/cli/open_project.rs
• src-tauri/src/commands/session.rs
• src-tauri/src/agent_update.rs

Implementation remains gated by previous dependency delivery and its own cold dispatch. Functional acceptance remains the complete frozen phase recipe.

Historical issue body, superseded only by the current exact specification above:

Part of #2992. This phase implements the user-required strict rejection of duplicate JSON members in consumed AgentsCommander configuration. Return an error with the file intact; never choose first/last, repair, default or partially consume duplicates. Other errors preserve their existing policy.

Approved Full R17 specification: D:/0_repos/AgentsCommander_iac/.ac/plans/2992-settings-owner/plan-v23-settings-owner.md
Plan-SHA256: FA45A1A72BD0A8DF30F3AFD0BAE6DDA3159FA5DCD65D5F7B4EC5CDFF4F6B34F3
Phase: P57; owner ac-dev-rust-v5; class design-bearing; depends on P56 (#3150), which must be merged before starting.
Phase file: D:/0_repos/AgentsCommander_iac/.ac/plans/2992-settings-owner/P57-v1-catalog-admission.md
Phase-SHA256: A9190488E9337BABDAEB8D29D94AB21C03FC66D25B5B80031B7FA6A65C2CC546
Consensus: D:/0_repos/AgentsCommander_iac/.ac/project-shared/2992-settings-owner/minimum-path-20261016/full-r17-consensus-approved-v1.json

Source is gated by the exact mapping/standing-authorization receipt and a successful cold implementation dispatch. Branch is created only at phase start from current synchronized main. Product checks are executed exclusively by shipper; no intermediate app build. One final requested no-bundle build after all phases merge.

The following immutable phase specification contains the situation, decided change, exact allowed files, acceptance and verification commands. It is the sole implementation specification; the issue/mapping supplies administrative identity only.

E2992 P57 v1 — catalog-admission

Status: READY_FOR_IMPLEMENTATION
Versión:1; inicial R16, sin archivo histórico creado en R15. Readiness sólo AUTORÍA; consenso/ejecución pendientes.
Owner: ac-dev-rust-v5. Class: design-bearing. Changed contract: admisión de configuración. Depends-on: P56.
Epic2992; workflow Full continuación R16, gate frío full-r16-planning-cold-gate-approved-v1.json. Sólo autoría autorizada; fuente bloqueada.
Participantes exactos: ac-architect-v5, ac-dev-rust-v5, ac-dev-webpage-ui-v5, ac-dev-rust-grinch-v5, ac-architect-grinch-v5. Mismo master+veinte digests, revisión pendiente; lead despacha, votos previos no se transfieren.
Repo D:/0_repos/AgentsCommander_iac/.ac/room-09-ac-dev-team-v5/repo-AgentsCommander; diseño9ce147f8454af7ad9d4bd27c1a358f93fd229850. Rutas producto relativas al repo, planes desde .ac.
Fuente pedido: autorización rechazo p45-user-reject-duplicate-json-paths-authorization-v1.json/decisión restore v2/propuesta v3/reconciliación R15-B1, no permiso de fuente.
Riesgo rutinario funcional transversal: selección/conservación/concurrencia cooperante, sin host attestation/signing/PATH hostil.

Archivos permitidos

Sólo MODIFIED/ADDED0/REMOVED0; 8 paths máximo10, un dueño, secuencial tras dependencia merged. No reabrir seis entregadas.

Objetivo y corte verde

Cerrar catálogos AC y sus publishers/callers; CatalogReport conserva shape y negativa global. Completar catálogo/tuning en preparadores restore ya aterrizados, sin otro store.

Decisiones por archivo

• config/coding_agents_catalog.rs: read_catalog_snapshot_with:2785 captura base/project/local y legacy elegible; admitir CADA documento presente antes schema/proyección/shadowing. parse_local_layer:2071/load_catalog_report:3352/3399 convierten duplicate en unavailable.code="duplicateJsonMember", catálogo vacío, diagnóstico sin keys/valores; NO warnings con catálogo parcial. into_result retorna Err con prefijo.
• run_catalog_initialization_with_scope:4910/initialize_catalog_under_lock:4682 y seeds pasan Result: validar actual/legacy que se consumirá o moverá ANTES de recovery/rename/migrate/seed/refresh bajo locks actuales. Settled journal aún valida actual leído; legacy retirado no leído/movido no se inspecciona. No renombrar/limpiar archivo duplicado; mismo contenido/ubicación.
• config/settings.rs: load_catalog_for_settings/seed callers conservan negativa global y Result; no defaults ante unavailable duplicate ni reutilización de fallback de otro dominio. Reusar parse_strict_json:1655 sólo tras admisión común para evitar clave arbitraria en error de duplicado.
• lib.rs: callers de init :4270/:4274 retornan StartupError antes setup; agregar catálogo/tuning de launch a MISMO prepare_native_restore_startup, no constructor alternativo. Admitir antes cualquier efecto seleccionado; recheck async mismo modo/targets.
• commands/ac_discovery.rs: :2296/3195/3377/3612/3683 propagan Err completo, nunca source unavailable opcional con candidatos previos.
• cli/new_project.rs y cli/open_project.rs: :76/:100 propagan duplicate del seed, no éxito falso por fail-soft genérico. Si operación ya publicó otro archivo, reportar error/outcome real, no no-write/rollback supuesto. Otras fallas de seed conservan política.
• commands/session.rs: :3109 sustituye unwrap_or_default únicamente por manejo fallible que retorna Err duplicate ANTES de selección de tuning/PTY; errores ordinarios conservan su política. Preparadores restore incluyen misma lectura/admisión/targets de catálogo/tuning, live comparte la mitad y recheck tras update gate. No future API ni opción que permita saltarlo.
• agent_update.rs: :1706/:3558 conserva Err/estado de fallo visible, no comando generado usando catálogo fallback. Mantener refresh autorizado sólo después admisión y efecto real.
  Actualizar inline callers de Result juntos; wrappers seed infalibles sin producto al terminar. No nuevo parser/dependencia, manager de errores, formato ni token.

Evidencia y aceptación propia

Reuso confirmado de snapshot/layers/catalog report/locks y código de inicialización al HEAD/blueprint; referencia catálogo->settings ya existe, sin nuevo arco.
Inline e2992_duplicate_json_: layer ignorada por schema/shadowing dup invalida report completo y into_result Err; actual/legacy antes seed/rename deja bytes/path intactos; válido sí inicializa y conserva overrides entre archivos; launch/agent update nunca fallback. Restore configuración seleccionada falla antes contador services/purge; reemplazo posterior cancela uso con receta conservada y tail P51 intacto.
Handoff P58: backend catálogo/co-managed/teams/agents cerrado, menús/ayuda y grupos pendientes; P45 completará cuatro fuentes core y P50 binding activo. No declarar rechazo global anticipado.

Contrato común de admisión y preservación

Único dueño settings/RAM, sin nueva fuente productiva. Configuración JSON AC realmente consumida incluye core, menús/ayuda, catálogos, project/team/agent/replica/co-managed y config.state mixto por selección/perfiles. Primera lectura necesaria para boot/restore automático rechaza startup; lectura/reemplazo posterior rechaza uso dependiente. Sin discovery de no usados, defaults/partial/Off ante duplicate, reparación automática ni atomicidad multiarchivo.
Igualdad de claves decodificadas por objeto recursivo (x/\u0078 iguales); padre repetido invalida, padres/índices diferentes y literal a.b versus a/b válidos; overrides entre documentos válidos. No casefold/normalización Unicode/identidad filesystem de keys. No confundir IDs repetidos con duplicate JSON.
Bytes admitidos son los mismos que se parsean; antes Value/typed/filter/merge/shadowing/refresh/naming. Caps/locks/autoridad/identidad/revocation/rechecks actuales preceden y acompañan lectura; preparado no acredita actualidad. Ausencia verificada conserva ausencia; otros errores mantienen política, sintaxis siempre pasa por parser nativo.
Err duplicateJsonMember: con archivo/causa sin keys/values/env/token; conservar razón tipada donde existe. IPC/WS Err envelope actual, CLI mensaje/exit no cero, boot StartupError/present_fatal; workers sin Result cortan acción dependiente y ERROR sanitizado al sink/error_log_event existente. No log sólo WARN y fallback. Pre-auth remoto nunca revela path/payload; respuesta fija sensible intacta, diagnóstico local autorizado.
No tocar sessions/clocks/TASK/protocolos/journals/caches puramente operativos, capture/state ni loops TOML; config.state sí se valida entero por uso mixto. No parser/deps/framework/registry/transporte/esquema nuevo.
Preservar dueño/availability/guard por expresión/PTY permit hasta write, principal/caps/privacidad, nueve sessions/F2/FinalRetention, retención activa+archivada y QuitGate. P51 current_read fallible/factories/catch/guards/barriers/tail y cadencia/cancelación exactos; sin reabrir seis entregadas. Fallo parcial real nunca se llama rollback/no-write ni adopta defaults.

Capas y evidencia estática

Base9ce147f8454af7ad9d4bd27c1a358f93fd229850. Índice raíz room09 ready44413/262454 sin SHA; metadata_changed obliga fuente directa focal, no prueba universal de callers. Blueprint v3 y reconciliación R15-B1 respaldan receta, no sustituyen decisiones de esta spec ni son spec alternativa.
Delta duplicate previsto: cero parejas de módulos nuevas/retiradas; adaptador en path_identity y forwarding por relaciones existentes. Callbacks puros hacia hojas local_overlay/co_managed/capture_catalog/container_repos/session_context evitan imports al scanner/host. Nada lower->AppHandle/Tauri/CLI/WS. PRE histórico c61cfbd/SCC89 y module-arcs DDBC8A498AF2FBFCFA8275001F0A623A77BD4615E1AF601AECBA3231A47A16FC no son POST actual.
Shipper debe comprobar PRE/POST integrado exacto, SCC member sets idénticos, cero nuevas parejas externas, arcos regenerados byte-idénticos y guards verdes; manual métodos/macros/guards complementa detector. No compile/Send/lifetime/runtime/test/graph/CI/GUI PASS durante autoría. Hallazgo no previsto detiene corte/revisión acotada, no ampliar baseline.

Ejecución futura y entrega (no ejecutada durante autoría)

No mutar producto antes de cinco votos exactos, revisión humana y despacho del lead. Un solo corte en vuelo; dueño ac-dev-rust-v5. Revisor Rust Grinch, arquitectura Grinch y dueño UI revisan el mismo conjunto. Child/branch/bases/PR/recibos van en registro externo MAP provisto por lead externo, nunca editar Markdown congelado. Un child y un PR por fase; epic2992 permanece abierto hasta integración/build final.

Todas las compilaciones/tests/fmt/grafos/npm son ejecución FUTURA EXCLUSIVA ac-shipper-v5; Rust/UI sólo editan fuente autorizada. Los comandos focales anteriores se ejecutan DESPUÉS de inicializar R/EVIDENCE/toolchain/containment abajo. Shipper retiene stdout/stderr/exit/UTC con timeout del runner; filtro vacío/fallo/timeout bloquea. Verificar Node22.14.0/npm11.6.2/Rust1.98.1 y locks intactos; Cargo sólo proceso, sin config/jobs/profile/caches globales. Antes de integration tests repetir --no-run --message-format=json con sus tres --test y el mismo chequeo de executable containment. No build intermedio; único build de producto final tras todas las fases.

Git Bash en Windows; cwd raíz repo room09. Ejecutar con timeout/log/stdout/stderr/exit del runner existente, stdin no interactivo; guardar evidencia en target/2992-evidence/<PHASE_ID>. Fallo/timeout/filtro vacío no es PASS. No reset/clean global ni restauración que pise terceros.

set -euo pipefail
PHASE_ID="P57"
EXPECTED_DEPS="P56"
R="D:/0_repos/AgentsCommander_iac/.ac/room-09-ac-dev-team-v5/repo-AgentsCommander"
cd "$R"
test "$(git rev-parse --show-toplevel)" = "$R"
test -z "$(git status --porcelain=v1 --untracked-files=all)"
test -z "$(git diff --cached --name-only)"
: "${MAP:?lead debe proveer ruta exacta del mapping validado de este conjunto}"
export MAP PHASE_ID EXPECTED_DEPS
# CHILD/BRANCH provistos por lead desde mapping validado, no inventarlos.
export CHILD BRANCH
node --input-type=module - <<'NODE'
import fs from 'node:fs'; import assert from 'node:assert/strict';
const m=JSON.parse(fs.readFileSync(process.env.MAP,'utf8'));
const p=m.phases[process.env.PHASE_ID]; assert(p);
assert.equal(String(p.child),process.env.CHILD); assert.equal(p.branch,process.env.BRANCH);
assert.deepEqual(p.dependencies,process.env.EXPECTED_DEPS.split(',').filter(Boolean));
assert(new RegExp('^refactor/'+p.child+'-[a-z0-9-]+$').test(p.branch));
NODE
test "$(gh issue view "$CHILD" --repo mblua/AgentsCommander --json state --jq .state)" = OPEN
gh api --paginate repos/mblua/AgentsCommander/issues/2992/sub_issues --jq '.[].number' | grep -Fx "$CHILD"
git fetch origin main
git diff --name-status 9ce147f8454af7ad9d4bd27c1a358f93fd229850 origin/main
# Clasificar drift por paths/formatter/toolchain/CI. Refrescar sólo evidencia relevante.
EVIDENCE="$R/target/2992-evidence/$PHASE_ID"
mkdir -p "$EVIDENCE"
node --input-type=module - <<'NODE' > "$EVIDENCE/dependencies.tsv"
import fs from 'node:fs';import assert from 'node:assert/strict';
const m=JSON.parse(fs.readFileSync(process.env.MAP,'utf8'));
for(const id of m.phases[process.env.PHASE_ID].dependencies){
 const p=m.phases[id]; assert(p.pr&&p.mergeSha); console.log(p.pr+'\t'+p.mergeSha);
}
NODE
while IFS=$'\t' read -r dep_pr merge_sha; do
 test "$(gh pr view "$dep_pr" --repo mblua/AgentsCommander --json state --jq .state)" = MERGED
 test "$(gh pr view "$dep_pr" --repo mblua/AgentsCommander --json baseRefName --jq .baseRefName)" = main
 test "$(gh pr view "$dep_pr" --repo mblua/AgentsCommander --json mergeCommit --jq .mergeCommit.oid)" = "$merge_sha"
 git merge-base --is-ancestor "$merge_sha" origin/main
done < "$EVIDENCE/dependencies.tsv"
git switch -c "$BRANCH" origin/main
BASE="$(git rev-parse HEAD)"
printf '%s\n' "$BASE" > "$EVIDENCE/base.sha"
git branch --show-current
git status --porcelain=v1 --untracked-files=all
node --version # esperado22.14.0
npm --version # esperado11.6.2
export CARGO_TARGET_DIR="$R/target" CARGO_BUILD_BUILD_DIR="$R/target"
cd "$R/src-tauri"
rustc +1.98.1 -vV
cargo +1.98.1 --version
cargo +1.98.1 metadata --locked --no-deps --format-version=1 > "$EVIDENCE/metadata.json"
export EVIDENCE R
node --input-type=module - <<'NODE'
import fs from 'node:fs';import path from 'node:path';import assert from 'node:assert/strict';
const m=JSON.parse(fs.readFileSync(process.env.EVIDENCE+'/metadata.json'));
const normal=p=>path.resolve(p).replaceAll('\\','/').toLowerCase();
assert.equal(normal(m.target_directory),normal(process.env.R+'/target'));
assert.equal(normal(m.workspace_root),normal(process.env.R+'/src-tauri'));
NODE
cargo +1.98.1 test --locked --lib --no-run --message-format=json > "$EVIDENCE/test-artifacts.jsonl"
node --input-type=module - <<'NODE'
import fs from 'node:fs';import path from 'node:path';import assert from 'node:assert/strict';
const normal=p=>path.resolve(p).replaceAll('\\','/').toLowerCase();
const root=normal(process.env.R+'/target')+'/';let n=0;
for(const l of fs.readFileSync(process.env.EVIDENCE+'/test-artifacts.jsonl','utf8').split('\n').filter(Boolean)){
 const a=JSON.parse(l);if(a.executable){assert(normal(a.executable).startsWith(root));n++}
}assert(n>0,'no test executable');console.log({containedExecutables:n});
NODE
cargo +1.98.1 test --locked --lib e2992_duplicate_json_ -- --list > "$EVIDENCE/duplicate-list.txt"
grep -F e2992_duplicate_json_ "$EVIDENCE/duplicate-list.txt"
# Lista debe incluir casos de ESTA fase; revisar nombres/count>0, no aceptar sólo casos previos.
cargo +1.98.1 test --locked --lib e2992_duplicate_json_ -- --test-threads=1 --nocapture
cargo +1.98.1 check --locked --all-targets
cargo +1.98.1 fmt --all -- --check
cargo +1.98.1 test --locked --test loops_layering --test instance_gitignore_layering --test project_settings_layering

Conservar Node22.14.0/npm11.6.2/Rust1.98.1 de CI y locks existentes. Sin cambios de versiones/deps/formatter ajenos. Al escribir: revalidar branch/base/index/paths, registrar preimagen y output propio por path. Recuperar sólo bytes propios aún intactos; preservar cambios ajenos y reportar conflicto. Comparar full BASE..HEAD (jamás HEAD~1), staged y ordinary-untracked; todo hunk propio dentro de la tabla. Cero es estado válido, no ausencia de evidencia.

Antes de push/PR integrar origin/main localmente y resolver sólo conflictos autorizados. Registrar PRE actual (origin/main) e integrated HEAD limpios. Si merge incorpora cambios ajenos, mantener full diff desde BASE y documentar por separado ese delta byte-idéntico a upstream; comprobar también PRE..HEAD para aislar trabajo propio, sin ocultar cambios ni reiniciar diseño por drift ajeno. No ampliar union propia para silenciar gates.

cd "$R"
git fetch origin main
PRE="$(git rev-parse origin/main)"
git merge --no-edit origin/main
# Resolver/commit si corresponde; después debe estar limpio.
test -z "$(git status --porcelain=v1 --untracked-files=all)"
mkdir -p "$EVIDENCE/pre-source"
git archive "$PRE" | tar -x -C "$EVIDENCE/pre-source"
set +e
node scripts/01-rust_module-dependency-cycles.mjs "$EVIDENCE/pre-source/src-tauri" --emit-graph "$EVIDENCE/pre.json" --quiet > "$EVIDENCE/pre-detector.log" 2>&1
pre_exit=$?
node scripts/01-rust_module-dependency-cycles.mjs src-tauri --emit-graph "$EVIDENCE/post.json" --quiet > "$EVIDENCE/post-detector.log" 2>&1
post_exit=$?
set -e
test "$pre_exit" -le 1
test "$post_exit" -le 1
node scripts/02-module-arc-record.mjs --graph "$EVIDENCE/post.json" --out "$EVIDENCE/post-arcs.txt"
export EVIDENCE
node --input-type=module - <<'NODE'
import fs from 'node:fs';import assert from 'node:assert/strict';
const root=process.env.EVIDENCE,pre=JSON.parse(fs.readFileSync(root+'/pre.json')),post=JSON.parse(fs.readFileSync(root+'/post.json'));
function scc(g){
 const a=new Map(g.modules.map(n=>[n.id,[]]));for(const e of g.edges)if(e.from!==e.to)a.get(e.from).push(e.to);
 let i=0,idx=new Map,low=new Map,stack=[],on=new Set,sets=[];
 function walk(v){idx.set(v,i);low.set(v,i++);stack.push(v);on.add(v);
  for(const w of a.get(v)){if(!idx.has(w)){walk(w);low.set(v,Math.min(low.get(v),low.get(w)))}else if(on.has(w))low.set(v,Math.min(low.get(v),idx.get(w)))}
  if(low.get(v)===idx.get(v)){let z=[],w;do{w=stack.pop();on.delete(w);z.push(w)}while(w!==v);sets.push(z.sort())}}
 for(const v of a.keys())if(!idx.has(v))walk(v);
 const cyclic=sets.filter(z=>z.length>1).sort((a,b)=>a[0].localeCompare(b[0]));
 assert.equal(cyclic.length,g.summary.moduleCycles);return {sets,cyclic,map:new Map(sets.flatMap((z,i)=>z.map(v=>[v,i])))};
}
const a=scc(pre),b=scc(post);assert.deepEqual(b.cyclic,a.cyclic);
const arcs=g=>new Set(g.edges.filter(e=>e.from!==e.to).map(e=>e.from+' -> '+e.to)),old=arcs(pre),now=arcs(post);
const internal=(f,t)=>a.map.has(f)&&a.map.get(f)===a.map.get(t)&&a.sets[a.map.get(f)].length>1;
assert(internal(a.cyclic[0][0],a.cyclic[0][1])); // control positivo sobre SCC real
const outside=a.sets.find(z=>z.length===1);assert(outside);assert(!internal(a.cyclic[0][0],outside[0]));
const added=[...now].filter(x=>!old.has(x));for(const x of added){const [f,t]=x.split(' -> ');assert(internal(f,t),'new cross-boundary arc '+x)}
console.log(JSON.stringify({cyclicSccs:b.cyclic.length,memberSetsIdentical:true,newArcs:added,newCrossBoundaryPairs:0}));
NODE
cmp "$EVIDENCE/post-arcs.txt" src-tauri/module-arcs.txt
npm run check:arcs
npm run check:cycles
git diff --check "$BASE" HEAD
git diff --name-status "$BASE" HEAD
git diff --name-status "$PRE" HEAD
git diff --cached --exit-code
git status --porcelain=v1 --untracked-files=all

Reviewer compara grafos por SCC con algoritmo del instrumento: coverage.graphShape.cyclicSccs debe ser igual PRE/POST, TODOS los conjuntos completos de miembros idénticos, cero NUEVAS parejas from->to entre SCC PRE distintos; referencias internas sólo en SCC preexistente. No basta igual número/SCC count. Graph exit1 con archivo válido es ciclos existentes; exit2/3/análisis ausente bloquea. Instrumento1.1.1 ignora métodos/macros y algunos paths: revisar manualmente referencias reales/guards y el permiso PTY; no afirmar cero universal. Registro regenerado byte-idéntico y guards verdes antes de publicación, no POST imaginario.

Todos los jobs disparados y configured-required verdes en exact PR-head. CI actual: ci-tier/test-debt/rust-regression Windows/clippy-linux/rust-regression-linux/rust-linux-release-parity/rust-regression-macos/rust-fmt/terminal-snapshot-portable/windows-release-cli-smoke/issue-1850-windows-profile/frontend-regression según tier. Lead consulta reglas required reales y aplica ci:full para evidencia OS nueva; skips inexplicados/otro SHA bloquean. P41 incorpora filtros e2992_ en Linux/macOS existentes; Windows ya corre --lib --bins --tests. No nuevo runner.

git rev-parse HEAD
# Tras autorización de publicar: PR base main, head BRANCH/SHA exactos, cierre sólo CHILD.
gh pr view "$PR" --repo mblua/AgentsCommander --json baseRefName,headRefName,headRefOid,closingIssuesReferences,statusCheckRollup
gh pr checks "$PR" --repo mblua/AgentsCommander --watch
gh pr checks "$PR" --repo mblua/AgentsCommander --required

Lead verifica conjunto de cierres exactamente {CHILD}, tested-head, mergeSHA y ancestry en main; guarda recibos externos. No cierre de epic por keyword de fase. Build histórico sólo tras todos los children merged: shipper ejecuta npm run build:prod:no-bundle en main limpio/upstream origin/main/igualdad targetSHA; copia no-clobber de agentscommander_testeable.exe al target/release/agentscommander_standalone_room-09__.exe (UTC del build), entrega path/hash/bytes/UTC/SHAfuente; lead verifica y recién entonces cierra epic. No instalación/release/version bump.