@jaimevalasek/aioson 1.3.0

package/docs/testing/genome-2.0-manual-regression.md

@@ -0,0 +1,23 @@
+# Genome 2.0 Manual Regression
+
+Run this only after the gated rollout in `genome-2.0-rollout.md` finishes green.
+
+## Core
+
+- Create a Genome 2.0 file with the core helpers or CLI and confirm both markdown and `.meta.json` are written.
+- Read a legacy genome markdown and confirm the core still normalizes it without error.
+- Apply a genome to a squad and inspect `squad.manifest.json`, `.designs/*.blueprint.json` and `docs/readiness.md`.
+
+## Dashboard
+
+- Open `/genomes` and confirm the new genome appears with metadata and binding counts.
+- Open `/squads` and confirm the target squad shows genome badges.
+- Open the squad workspace and use `Manage genomes` to inspect bindings.
+- Open `/pipelines` and confirm pipelines still load with squad-only nodes.
+- Open a pipeline node inspector and confirm genome bindings appear as contextual badges and inspector items.
+
+## Compatibility
+
+- Re-run the same flow with a legacy genome fixture and confirm no page crashes or malformed payloads.
+- Confirm pipelines never accept genome as executable node.
+- Confirm removing a binding from the dashboard does not corrupt the persisted manifest.

package/docs/testing/genome-2.0-matrix.md

@@ -0,0 +1,36 @@
+# Genome 2.0 Test Matrix
+
+## Scope
+
+| Scenario | Layer | Expected Result |
+| --- | --- | --- |
+| 1. Legacy genome is readable by the core | `aioson` core | Markdown without v2 frontmatter is normalized and receives synthesized compat metadata |
+| 2. Genome 2.0 is generated and saved | `aioson` core | Markdown and `.meta.json` are persisted together with v2 schema |
+| 3. New squad receives genome | `aioson` squad binding | Manifest, blueprint and readiness get synchronized bindings |
+| 4. Existing squad receives binding | `aioson` squad binding | Executor and squad scopes merge without breaking legacy executor genomes |
+| 5. Artisan generates Genome Brief | `aios-dashboard` Artisan API | Genome brief result returns markdown, confidence and fallback file write remains non-fatal |
+| 6. `/genomes` lists metadata | `aios-dashboard` catalog | Catalog returns local genome metadata, origin and binding counts |
+| 7. `/squads` shows bindings | `aios-dashboard` squads | Squad payload and UI consumers expose squad and executor bindings |
+| 8. `/pipelines` shows badges | `aios-dashboard` pipelines | Pipeline payload exposes contextual `genomeBindings` on squad nodes only |
+| 9. Legacy data remains valid | cross-repo contract | Dashboard still reads manifests written by the core for legacy and v2 formats |
+
+## Automated Coverage
+
+- Core fixtures and smoke: `tests/integration/genome-2.0-smoke.test.js`
+- Core binding contract: `tests/integration/genome-binding-contract.test.js`
+- Dashboard Artisan brief API: `tests/api/artisan.generate-genome-brief.test.mjs`
+- Dashboard contract and catalog/bindings: `tests/integration/genome-binding-contract.test.mjs`
+- Dashboard pipeline/catalog integration: `tests/integration/dashboard.genome-catalog-and-bindings.test.mjs`
+
+## Rollout Entry Point
+
+- Full gated rollout: `npm run test:genome-2.0:rollout -- --dashboard-root ../aios-dashboard`
+- Operational runbook: `genome-2.0-rollout.md`
+
+## Shared Fixtures
+
+- `tests/fixtures/genomes/legacy-genome.md`
+- `tests/fixtures/genomes/genome-2.0.md`
+- `tests/fixtures/genomes/genome-2.0.meta.json`
+- `tests/fixtures/squads/squad-without-genome/`
+- `tests/fixtures/squads/squad-with-genome/`

package/docs/testing/genome-2.0-rollout.md

@@ -0,0 +1,184 @@
+# Genome 2.0 Rollout Runbook
+
+## Goal
+
+Bring the full Genome 2.0 package into `aioson` and `aios-dashboard` with explicit gates, repeatable checks, and a non-destructive fallback path.
+
+This document operationalizes Phase 09 from `notes-local/plano-genoma-2/09-rollout-checklist.md`.
+
+## Recommended implementation order
+
+1. Block A: `aioson` core, bindings, compatibility.
+2. Block B: dashboard Artisan genome incubation and `/genomes` catalog.
+3. Block C: dashboard squad bindings and pipeline contextual badges.
+4. Block D: integration, regression, and manual close-out.
+
+## Recommended merge order
+
+1. `aioson` Phase 01
+2. `aioson` Phase 02
+3. `aioson` Phase 03
+4. `aios-dashboard` Phase 04
+5. `aios-dashboard` Phase 05
+6. `aios-dashboard` Phase 06
+7. `aios-dashboard` Phase 07
+8. Integration coverage from Phase 08
+9. This rollout phase and final docs
+
+## Commands by block
+
+### Block A
+
+Run from `aioson`:
+
+```bash
+npm run test:genome-2.0:block-a
+```
+
+This executes:
+
+- core smoke for legacy + v2 genomes;
+- compatibility tests;
+- full core test suite;
+- core lint.
+
+### Block B
+
+Run from `aios-dashboard`:
+
+```bash
+npm run test:genome-2.0:block-b
+```
+
+This covers:
+
+- Genome Brief generation helpers and API payloads;
+- Artisan schema compatibility;
+- `/genomes` catalog and detail payloads.
+
+### Block C
+
+Run from `aios-dashboard`:
+
+```bash
+npm run test:genome-2.0:block-c
+```
+
+This covers:
+
+- squad genome apply/remove flows;
+- squad bindings payloads;
+- pipeline genome badge payloads.
+
+### Block D
+
+Run from `aios-dashboard`:
+
+```bash
+npm run test:genome-2.0:block-d
+```
+
+This executes the full dashboard gate:
+
+- complete automated suite;
+- lint;
+- production build.
+
+### Full rollout from the core repo
+
+Run from `aioson`:
+
+```bash
+npm run test:genome-2.0:rollout -- --dashboard-root ../aios-dashboard
+```
+
+Useful options:
+
+- `--block=A|B|C|D`
+- `--skip-dashboard`
+- `--dry-run`
+- `--json`
+
+## Mandatory smoke acceptance
+
+### After Block A
+
+- [ ] Legacy genome is readable.
+- [ ] Genome 2.0 writes markdown and `.meta.json`.
+- [ ] New squad binding persists correctly.
+- [ ] Existing squad binding stays compatible.
+- [ ] Migrate and repair paths still work in dry-run.
+
+### After Block B
+
+- [ ] `/artisan` supports genome ideas.
+- [ ] `Genome Brief` is persisted.
+- [ ] `/genomes` lists legacy and v2 genomes.
+- [ ] Catalog cards show type, depth, and evidence mode.
+
+### After Block C
+
+- [ ] `/squads` manages squad and executor bindings.
+- [ ] Apply and remove binding flows are stable.
+- [ ] `/pipelines` shows contextual genome badges only.
+- [ ] Legacy pipelines remain valid.
+
+### After Block D
+
+- [ ] Automated checks pass.
+- [ ] Manual checklist is complete.
+- [ ] Legacy data remains accessible.
+
+## Manual close-out
+
+Use the manual regression guide in `genome-2.0-manual-regression.md` after the automated rollout checks pass.
+
+Recommended sequence:
+
+1. Validate `/genomes`.
+2. Validate `/squads` binding management.
+3. Validate `/pipelines` contextual rendering.
+4. Re-check a legacy genome end-to-end.
+
+## Fallback strategy
+
+If compatibility regresses at any point:
+
+1. Keep the new code in place.
+2. Stop new writes where possible.
+3. Keep tolerant reads active.
+4. Record the gap before patching.
+5. Re-run the relevant block and then the full rollout gate.
+
+Dashboard-specific fallback:
+
+- keep `/genomes` returning a minimal payload;
+- hide advanced genome badges if enrichment breaks;
+- never block the listing because of missing v2 metadata.
+
+## Final release acceptance
+
+Only close the package when all statements below are true:
+
+- [ ] Genome 2.0 can be created.
+- [ ] Genome 2.0 can be applied to a new squad.
+- [ ] Genome 2.0 can be applied to an existing squad.
+- [ ] `/artisan` supports genome incubation.
+- [ ] `/genomes` exposes the enriched catalog.
+- [ ] `/squads` manages bindings safely.
+- [ ] `/pipelines` treats genomes as context, not executable nodes.
+- [ ] Automated and manual validation are both complete.
+
+## Suggested commit messages
+
+```bash
+feat(core): implement genome 2.0 foundation
+feat(core): add genome bindings to squads
+feat(core): add migration and compatibility layer for genome 2.0
+feat(dashboard): add genome incubation flow to artisan
+feat(dashboard): enrich genomes catalog for genome 2.0
+feat(dashboard): add genome bindings management to squads
+feat(dashboard): show genome bindings in squad pipelines without changing pipeline model
+test(integration): add end-to-end coverage for genome 2.0 and dashboard bindings
+docs(plan): add rollout checklist for genome 2.0 program
+```

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@jaimevalasek/aioson",
+  "version": "1.3.0",
+  "description": "AI operating framework for hyper-personalized software.",
+  "keywords": [
+    "ai",
+    "agents",
+    "claude",
+    "codex",
+    "gemini",
+    "opencode",
+    "cli",
+    "framework"
+  ],
+  "license": "MIT",
+  "main": "src/cli.js",
+  "bin": {
+    "aios": "bin/aioson.js",
+    "aioson": "bin/aioson.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "template/",
+    "docs/",
+    "README.md",
+    "CHANGELOG.md",
+    "CONTRIBUTING.md",
+    "CODE_OF_CONDUCT.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "test": "node --test",
+    "test:genoma": "node --test tests/genoma-compat.test.js tests/genoma-migrate.test.js",
+    "test:genome-2.0-smoke": "node scripts/smoke/genome-2.0-smoke.js",
+    "test:genome-2.0:block-a": "node scripts/smoke/genome-2.0-smoke.js && npm run test:genoma && npm test && npm run lint",
+    "test:genome-2.0:rollout": "node scripts/testing/genome-2.0-rollout.js",
+    "lint": "node --check src/*.js src/commands/*.js src/i18n/*.js src/i18n/messages/*.js bin/*.js",
+    "ci": "npm run lint && npm test"
+  },
+  "dependencies": {
+    "better-sqlite3": "^12.6.2"
+  }
+}

package/src/agents.js

@@ -0,0 +1,56 @@
+'use strict';
+
+const { AGENT_DEFINITIONS } = require('./constants');
+const { getLocalizedAgentPath } = require('./locales');
+
+function normalizeAgentName(input) {
+  return String(input || '')
+    .trim()
+    .toLowerCase()
+    .replace(/^@/, '');
+}
+
+function getAgentDefinition(name) {
+  const normalized = normalizeAgentName(name);
+  return AGENT_DEFINITIONS.find((agent) => agent.id === normalized) || null;
+}
+
+function listAgentDefinitions() {
+  return [...AGENT_DEFINITIONS];
+}
+
+function resolveInstructionPath(agent, locale) {
+  if (!locale) return agent.path;
+  return getLocalizedAgentPath(agent.id, locale);
+}
+
+function buildAgentPrompt(agent, tool, options = {}) {
+  const safeTool = String(tool || 'codex').toLowerCase();
+  const instructionPath = options.instructionPath || agent.path;
+  const dependencyText =
+    agent.dependsOn.length > 0
+      ? `Check required context files first: ${agent.dependsOn.join(', ')}.`
+      : 'No prerequisite context files are required.';
+
+  if (safeTool === 'claude') {
+    return `Read ${instructionPath} and execute ${agent.command}. ${dependencyText} Write output to ${agent.output}.`;
+  }
+
+  if (safeTool === 'gemini') {
+    return `Run the Gemini command mapped to ${instructionPath} and execute ${agent.command}. ${dependencyText} Save result to ${agent.output}.`;
+  }
+
+  if (safeTool === 'opencode') {
+    return `Use agent "${agent.id}" from ${instructionPath}. ${dependencyText} Save output to ${agent.output}.`;
+  }
+
+  return `Read AGENTS.md and execute ${agent.command} using ${instructionPath}. ${dependencyText} Save output to ${agent.output}.`;
+}
+
+module.exports = {
+  normalizeAgentName,
+  getAgentDefinition,
+  listAgentDefinitions,
+  resolveInstructionPath,
+  buildAgentPrompt
+};