Sol Advisor has strong architectural foundations and clear design thinking around role pinning and reviewer isolation, but ships incomplete. Terra lane is production-viable for private architect-led workflows; Luna lane is strategically important but documented-only, blocking enterprise adoption of multi-task orchestration.
Production readiness requires completing Luna lane as executable Codex-integrated code with audit logging, enforcing reviewer isolation via fresh-thread spawning, adding preflight availability checks with hard-stop policies, and establishing CI/CD gates. Without these hardening steps, silent capability downgrades and reviewer bias remain unguarded.
ReadyBase found little analyzable source, so this is low-confidence.
How ReadyBase scores this →4-persona convergence (CTO, CPO, CISO, Scrum Master), low cost (~50 LOC), transferable. Prevents silent model downgrades, tool skips, permission escalations, root cause of architect assumption breakage. Essential trust mechanism across all stakeholder roles.
4-persona convergence (CTO, CPO, VPE, CISO), central to reproducibility SLA and auditability. Medium cost (config maintenance + testing matrix) offset by enabling safe policy enforcement, preventing post-deployment capability drift, version-controlling role definitions.
3-persona convergence (CTO, CPO, Scrum Master), low cost (~200 LOC template + TOML enforcement), foundational for multi-agent safety. Prevents workers from inheriting lost context, enables reliable delegation, prevents silent architecture redesigns on concurrent changes.
2-persona convergence (CISO, Scrum Master), low cost (documentation + metadata field), closes audit/trust gap. Enables verification of actual security boundaries (OS vs. application-level), essential for compliance, threat modeling, and operator confidence.
2-persona convergence (CPO, Scrum Master), low cost (~100 LOC role contracts + TOML enforcement), critical for enterprise adoption. Silent redesigns break user trust; global contract prevents architectural drift when Sol Advisor operates on active branches.
2-persona convergence (CTO, CPO), minimal cost, transferable. Core to Sol Advisor's value proposition. Eliminates reviewer bias by separating implementation concerns, enables auditable decision chains, maintains architectural consistency at scale.
2-persona convergence (CTO, CISO), medium cost (~10% overhead + CI hooks), hardens supply chain. Catches silent corruption at scale, guarantees deployment consistency, enables safe automated migrations and legacy artifact retirement via immutable byte digest storage.
2-persona convergence (CPO, CISO), high cost (architecture refactor + session-state handoff), eliminates reviewer confirmation bias and compromise propagation risk. Foundational to architect ≠ implementer promise despite implementation burden; currently violates this in Sol Advisor primary-session design.
4-persona convergence (CPO, VPE, CISO, Scrum Master), high cost (1000+ LOC Codex integration + authz checks), domain-specific. Luna is the differentiator for multi-task enterprise workflows; current prose-only design blocks adoption by preventing auditability (CISO), deterministic task tracking (VPE/Scrum Master), reusable implementation (CPO/Scrum Master).
Weak-to-moderate convergence (flagged by VPE/Scrum Master as Luna prerequisite), medium cost (~300 LOC correlation logic), transferable. Luna workflows break when temp task IDs fail downstream; metadata-based correlation required for progress tracking and multi-task synchronization.
Low-to-moderate convergence (CTO + implicit Scrum Master alignment), low cost (actually reduces operational burden), enables safe CI/CD integration, dry-run workflows, recovery from partial failures. Aligns with no-silent-degradation policy.
Weak convergence (CPO primary, Scrum Master context), low cost (audit SKILL.md + user prompt hook), clarifies product positioning. Terra is safe default, Luna requires explicit request. Reduces accidental escalations, aligns with zero-trust security principle.
Weak convergence (CISO), low cost (flip trust hierarchy in inspect-agent-runtime.sh), security best practice. Prevents local actors from overriding authoritative metadata and escalating privileges. Hardens routing security model against supply-chain tampering.
Weak convergence (CTO context on template safety), low cost (already exists in codebase patterns), enables safe version migrations. Byte-level verification of legacy artifact identity prevents silent upgrade failures and enables secure rollback without cascading redesign.
Weak convergence (catalog-sourced, no explicit persona findings), low cost (already in plugins/sol-advisor/scripts), security hardening. Prevents field inference, forces explicit routing metadata, closes log-based reconnaissance vectors in agent telemetry.
Sol Advisor is an architect workflow plugin for Codex that implements capability-routed software delivery through two configurable lanes. The default Terra lane keeps architect and reviewer in the primary session while delegating implementation work to a sandboxed Terra-model agent; the opt-in Luna lane (documented but not implemented as executable code) is designed to spawn user-visible multi-task workflows for escalation. Both lanes use TOML-pinned agent configurations to enforce model and reasoning-effort consistency across spawns, template verification via SHA-256 digest comparison with atomic rename, and structured handoff contracts.
Role-pinned agent configurations via TOML (no per-call overrides; audit trails on drift) combined with deliberate context isolation to prevent reviewer bias and design-by-committee compromise. Luna lane opt-in escalation for user-visible multi-task orchestration (if completed). Differentiator is transferable patterns: SHA-256 template verification with atomic rename, idempotent --check mode installation, and verifiable role-scoped model pinning.
Luna lane (user-visible multi-task escalation) is fully documented as a core feature in SKILL.md and role contracts but is not implemented as executable Codex app code, so the marquee differentiator for enterprise multi-task workflows exists only in prose, blocking adoption and auditability.
Eliminates reviewer bias, maintains architecture consistency, enables auditable decision chains at any scale
Cost Minimal overhead; leverage existing agent caching and structured handoffs
Reproducible deployments, explicit policy, prevents hidden agent substitutions, environment-agnostic scaling
Cost Maintain config in version control, enforce role definition discipline
Prevents cascading silent failures, makes incidents loud and debuggable, catches assumption violations early
Cost Never add fallbacks; may break workflows relying on hidden substitutions
Catches silent corruption at scale, guarantees deployment consistency, enables safe automated migrations
Cost Build verification infrastructure and CI hooks; ~10% install-time overhead
Enables safe CI/CD integration, dry-run workflows, recovery from partial failures, infrastructure-as-code pattern
Cost Minimal; actually reduces operational risk and support burden
Prevents context loss in task spawning, enables reliable autonomous delegation, scales team coordination
Cost Discipline in message structuring; ~5 lines of metadata per spawn
Eliminates confirmation bias in acceptance gates, Sol Advisor's core value (architect + reviewer) only works if reviewers are cognitively isolated, yet current design keeps both in primary session creating hidden review debt.
Cost Architecture refactor: decouple reviewer spawn from primary context; requires session-state handoff schema and fresh-thread guidelines.
Luna lane (user-visible tasks) is documented but not implemented as reusable code; each escalation inherits brittle prose-only guidance, blocking scaling to higher-stakes workflows.
Cost Define structured task-packet schema in roles/role-contracts.md; add auto-generation to Luna orchestration skill to emit valid packets on creation.
Sol Advisor currently ships with two lanes (Terra/Luna) but neither is an obvious 'safe default', users must choose upfront; this pattern lets Terra be the safe path and Luna an explicit upgrade decision.
Cost Audit SKILL.md for default-vs-escalation clarity; add user prompt hook that gates Luna activation behind explicit request (e.g. 'use Luna for this').
Sol Advisor roles define models (GPT-5.6 Sol/Terra) but lack enforcement, drift in reasoning_effort or model_id undermines reproducibility and SLA predictability that enterprise users need.
Cost Role config (TOML) already exists; add env-var validation + testing matrix to verify pinned settings are respected on spawn.
Users trust Sol Advisor to deliver architect-grade review; silent fallbacks (e.g. to cheaper model) break trust and bury serious degradation in logs, turning Sol Advisor into a liability.
Cost Add preflight-check phase to each role spawn; wire hard-fail errors into user-facing toast/status (not silent logs).
Luna lane is the high-touch/high-value escalation, but shipping as prose-only documentation (not code) means every new user/integrator must reverse-engineer and re-implement, blocking Luna adoption.
Cost Promote Luna task creation from prose (SKILL.md) to agent code; add declarative task-creation functions to orchestration skill library.
Sol Advisor integrates into existing workflows; silent redesign breaks user trust and makes it unsafe to use on active branches, limiting enterprise adoption.
Cost Codify in sol-advisor-terra-implementer.toml as a pinned instruction; add verification step to spot silent architecture changes in diff review.
762 lines of untested code in the trust/audit moat (egress ledger, model backends), the cornerstone of distillx's competitive claim, creates silent regressions and blocks confident refactoring
Cost Low; ~100-150 new unit tests targeting completer interface contract and egress.containsSource(), 2-3 days engineering
Zero CI gates means test failures go undetected until production use; no enforcement that new code has tests; regressions ship without friction
Cost Very low; one 50-line .github/workflows/test.yml + go test/lint/vet, <1 day
STRATEGY.md flags this as the single biggest spend risk: scaling from 10→100 repos/day is easy and silent without a cap; one config mistake → $1000s/day bill
Cost Low; ~50 lines in trending.go + config.yaml entry, 1 day; saves future infrastructure debt
Current 6-persona panel runs in same process/context, creating bias risk in synthesis phase (Phase 5); independent re-review catches groupthink and scoring drift
Cost High; requires structuring persona workers as separate runners, passing structured context (not raw state), ~3-5 days refactor + testing
Personas (CTO, CPO, VPE, CISO, Scrum Master) should have locked model/effort per role; today config.yaml has one global model for all personas, risking inconsistent judgment
Cost Medium; add per-persona config stanza + persona.go marshaling, 2 days; enables better A/B testing of persona quality
Distillx's trending/hosted tier roadmap will need multi-task orchestration; Sol Advisor's example shows documentation can mask implementation gaps until they hit production
Cost Low; audit phase 6 (Apply) to see which recommendations need code that doesn't exist, add to backlog; prevents spec-implementation drift
STRATEGY.md flags chars/4 as over/under-filling token budgets on token-dense code; silent over-truncation on minified JS or non-Latin text breaks judgment quality
Cost Low; swap ingest.go:48 from f.Tokens = len(f.Content)/4 to real tokenizer call, add test cases for non-Latin/minified, 1 day
inspect-agent-runtime.sh inverts this: checks local files first, enabling local actors to override authoritative metadata and escalate privileges.
Cost Flip trust hierarchy in inspect-agent-runtime.sh to prioritize public metadata; fail if local/public conflict.
Privilege-escalation control flow is unverifiable and unauditable; explicit opt-in constraint cannot be enforced if only documented in prose.
Cost Reimplement Luna lane as code (agents, task creation, authz checks) with audit logging; retire prose-only design.
Guidance exists but not enforced in role-contracts.md; operators cannot verify whether actual security is OS-enforced or application-level.
Cost Add threat-model field to role contracts; validate at agent definition; audit deploy to confirm isolation mechanism.
SKILL.md design has primary task performing both architecture and final review in one session, creating approval bias and compromise propagation risk.
Cost Refactor orchestration skill to spawn isolated reviewer thread; add context-isolation verification in sol-advisor-sol-reviewer.toml.
Silent fallback hides security-posture downgrade from audit; no mechanism prevents role demotion or capability substitution.
Cost Add required-capability validation to agent spawn; fail hard if model/permission unavailable; log all rejected substitutions.
Model pinning is designed in TOML files, but lacks runtime verification to prevent post-deployment capability substitution or config tampering.
Cost Add model-fingerprint verification at agent initialization; sign/encrypt TOML; fail if pinned model unavailable at spawn time.
Supply-chain attack surface; compromised templates execute with full agent privileges; SHA-256 verification exists but is not mandatory in workflow.
Cost Make SHA-256 verification mandatory and blocking in install-agents.sh; fail loudly on mismatch; log all verifications for audit.
Luna is the differentiator for user-visible multi-task workflows; prose-only SKILL.md contracts can't enforce determinism or prevent context loss
Cost Medium: ~1000 LOC for Codex app integration (task create/list/wait) + sample workflow
Isolated agents risk silent architecture redesigns and buried ambiguity; no structured schema enforces objective/ownership/constraints/verification boundaries
Cost Low: ~200 LOC for packet template + agent TOML enforcement rules
Terra implementer has local instructions but multi-agent workflows lack global contract; redesigns happen silently without explicit preservation policy
Cost Low: ~100 LOC for role-contracts.md + enforcement in agent TOML configs
Luna workflows lose sync with created tasks when temp client IDs fail downstream; progress tracking and task monitoring break
Cost Medium: ~300 LOC for metadata correlation logic + sample lookup script
Silent capability substitution (model downgrade, tool skip) breaks architect assumptions without alerting users
Cost Low: ~50 LOC for preflight validation + explicit failure modes in Terra + Luna contracts
Audit/trust risk: users and operators can't verify actual OS-level isolation vs tool-allowlist enforcement; security boundary claims unverifiable
Cost Low: document in role-contracts.md + add to plugin.json metadata
Strong design principles with clear implementation patterns: TOML-based role pinning (reproducible, version-controllable), SHA-256 template verification with atomic rename (supply-chain integrity), two-lane escalation (safe default Terra + explicit opt-in Luna), and separation of architect from implementer by delegating work to sandboxed threads. However, critical execution gaps undermine coherence: Luna lane designed but not implemented as code, reviewer isolation designed but not enforced (architect and reviewer remain in primary session together), routing metadata extraction inverts trust hierarchy (prioritizes local files over public metadata), and worker context-preservation contracts incomplete. Architecture will age well if gaps are filled, but currently carries debt from incomplete features and enforcement gaps.
Alpha-stage plugin. Terra lane has functional operational scripts (install-agents.sh, verify.sh, inspect-agent-runtime.sh) demonstrating basic tooling maturity. Luna lane documented but non-functional. Critical absences: zero CI/CD pipeline (ReadyBase: 0), zero test coverage (ReadyBase: 0%), no hard-stop failure modes on unavailable capabilities (silent model substitution possible), reviewer isolation designed but not enforced, incomplete worker context-preservation contracts, no audit logging. Assessment verdict explicitly states 'not production-ready; requires significant hardening before enterprise deployment.'
Good supply-chain foundation (SHA-256 template verification, atomic replace, allowlisted metadata extraction with jq, designed role-based separation). Critical trust gaps: routing metadata extraction inverts threat model by prioritizing LOCAL rollout files over PUBLIC authoritative metadata, enables local actors to override and escalate privileges. Luna lane's explicit opt-in constraint is prose-only in SKILL.md, not enforced as code, making privilege-escalation control unverifiable and unauditable. Missing: audit logging for escalations, preflight capability validation (silent model substitution undetected), sandbox vs permission-profile distinction undocumented (operators cannot verify actual OS-enforced isolation vs tool-allowlist application-level control). Trust machinery designed but incompletely enforced.
Core patterns are transferable: TOML-based role pinning (no vendor lock-in, version-controllable), SHA-256 template verification (reusable supply-chain pattern), idempotent --check mode installation (best practice for safe rollouts), two-lane safe-default + escalation pattern. Agent role contracts (.toml files) are modular. However, Luna implementation does not exist as reusable code (can't reuse unimplemented features), self-contained task packet schema designed but not enforced, worker guidance (code preservation, ambiguity surfacing) exists only in terra-implementer.toml (local), not as global contract, and many architectural patterns documented in prose (SKILL.md) rather than as reusable libraries. Specificity to Codex plugin architecture limits external reuse.
Documentation exists (README.md, SKILL.md, role-contracts.md, plugin.json, agent .toml files) but significantly overstates implementation status, creating major truth gap. Luna lane is fully documented as a core feature and design requirement across SKILL.md and role-contracts.md but is NOT implemented as executable Codex app code, this is the marquee gap. README may use aspirational language ('Sol Advisor is an architect workflow for capability-routed software delivery'). Task packet schema designed but not fully documented or enforced. Worker guidance (code preservation, ambiguity surfacing) local to terra-implementer.toml, not formalized as global contract. Agent .toml files lack inline documentation. No architecture decision records (ADRs). ReadyBase scores documentation at 10/100; rating at 20 reflects that documentation exists but systematically overstates what is actually implemented in code.
Zero formal test coverage (ReadyBase: 0%), zero CI/CD pipeline (ReadyBase: 0), no test suite. Verification scripts (install-agents.sh, verify.sh) perform operational validation (SHA-256 hash checks, cleanup traps, state verification) but are not a test suite and do not run in CI/CD. No unit tests for security-critical packages (claude model backends, egress ledger). No integration tests for agent spawning, role pinning, Luna lane workflows, or reviewer isolation. No pre-deployment test gates. Assessment flags persona finding from VPE: 'Zero CI gates means test failures go undetected until production use; no enforcement that new code has tests; regressions ship without friction.'
Core Sol Advisor separation of concerns; reveals multi-agent coordination and review flow
Defines architectural boundaries and assumption safety; foundational fault model
Shows config-driven role abstraction and reproducibility enforcement mechanism
Reveals task isolation, context preservation, and delegation safety patterns
Clarifies security model and enforcement boundaries essential to understanding trust
Shows contract-based concurrency control and architectural consistency maintenance
Reveals metadata-driven routing hierarchy and trust model in agent spawning
Shows privilege escalation model and user-facing design philosophy
Demonstrates observability and metadata extraction patterns for routing verification
Operational safety pattern; useful but secondary to core multi-agent architecture
Principle stated but current Sol Advisor violates it; extract as ideal vs. reality gap
Supply chain safety pattern; tangential to core architecture but demonstrates verification
Migration safety pattern; demonstrates versioning but specific to template lifecycle
Task correlation prerequisite for Luna lane; Luna not yet fully extracted from prose
Currently prose-only with implementation gap; not a completed reusable pattern
Extract 9 core patterns in order: (1) architect/verifier/implementer separation + review flow, (2) fail-stop semantics + boundaries, (3) TOML role config, (4) task packet format, (5) sandbox vs. permissions security model, (6) metadata-driven routing + precedence, (7) observability + metadata extraction, (8) Terra/Luna privilege model, (9) operational safety. Document each with code locations, dependencies, and enforcement points. Biggest risk: Luna lane exists only in prose (SKILL.md, not code) and blocks task correlation + multi-task auditing; flag Luna implementation gap prominently and defer it to phase 2 until architecture is extracted.