@aria_asi/cli 0.2.25 → 0.2.29

package/scripts/publish-all.sh

@@ -0,0 +1,344 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# ── @aria_asi/cli — Multi-Registry Publisher ──
+# Canonical package: @aria_asi/cli
+# Canonical registry: https://npm.pkg.github.com (publishConfig.registry)
+# Legacy deprecated wrappers: aria-cli, aria-sdk, aria-full, aria-tui,
+#   aria-vscode-extension, aria-anthropic-gate — kept as DEPRECATED stubs only.
+# Set tokens as env vars: NPM_TOKEN, GITHUB_TOKEN
+# Usage: bash publish-all.sh [--dry-run]
+
+# ── Dirty-tree refusal (structural — no exceptions) ──
+if [[ -n "$(git status --porcelain)" ]]; then
+  count="$(git status --porcelain | wc -l | tr -d ' ')"
+  echo "I can't publish from a dirty tree — commit or stash your changes first. (uncommitted: ${count} files)" >&2
+  exit 1
+fi
+
+# ── Dry-run flag ──
+DRY_RUN=false
+for arg in "$@"; do
+  if [[ "$arg" == "--dry-run" ]]; then
+    DRY_RUN=true
+  fi
+done
+
+# ── Paths ──
+DIR="$(cd "$(dirname "$0")/.." && pwd)"
+SUMMARY_FILE="$(pwd)/publish-summary.json"
+
+# ── Read canonical metadata ──
+CANONICAL_NAME="@aria_asi/cli"
+VERSION="$(node -e "console.log(require('${DIR}/package.json').version)")"
+CANONICAL_REGISTRY="$(node -e "console.log(require('${DIR}/package.json').publishConfig.registry)")"
+
+PUBLISHED=()
+
+if [[ "$DRY_RUN" == "true" ]]; then
+  echo ""
+  echo "  ═══ I'm running in --dry-run mode — no packages will actually ship ═══"
+  echo ""
+fi
+
+echo ""
+echo "  ═══ I'm publishing ${CANONICAL_NAME} v${VERSION} ═══"
+echo ""
+
+# ── Pre-publish package.json shape validation ──
+validate_package_json() {
+  local pkg_dir="$1"
+  local expected_name="$2"
+  local pkg="$pkg_dir/package.json"
+
+  echo "  I'm validating package.json shape at ${pkg}..."
+
+  node - "$pkg" "$expected_name" <<'VALIDATE_EOF'
+const fs = require('fs');
+const path = require('path');
+// When invoked via `node - arg1 arg2 < script.js`, process.argv[1] is the
+// literal '-' and real args start at argv[2]. Fix from the W5 sub-agent's
+// off-by-one (was using argv[1]/argv[2] which read '-' as the path).
+const pkgPath = process.argv[2];
+const expectedName = process.argv[3];
+
+let pkg;
+try {
+  pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+} catch (e) {
+  console.error('package.json is not valid JSON: ' + e.message);
+  process.exit(1);
+}
+
+const errors = [];
+
+// name check
+if (!pkg.name) {
+  errors.push('missing "name" field');
+} else if (pkg.name !== expectedName) {
+  errors.push(`"name" is "${pkg.name}" but expected "${expectedName}"`);
+}
+
+// version semver shape (basic regex: digits.digits.digits with optional pre-release)
+if (!pkg.version) {
+  errors.push('missing "version" field');
+} else if (!/^\d+\.\d+\.\d+(-[\w.]+)?(\+[\w.]+)?$/.test(pkg.version)) {
+  errors.push(`"version" "${pkg.version}" is not semver-shaped`);
+}
+
+// main — field must exist and file must exist on disk
+if (!pkg.main) {
+  errors.push('missing "main" field');
+} else {
+  const mainPath = path.resolve(path.dirname(pkgPath), pkg.main);
+  if (!fs.existsSync(mainPath)) {
+    errors.push(`"main" points to "${pkg.main}" which does not exist on disk`);
+  }
+}
+
+// bin — if present, each file must exist and be executable
+if (pkg.bin) {
+  const bins = typeof pkg.bin === 'string'
+    ? { [pkg.name]: pkg.bin }
+    : pkg.bin;
+  for (const [binName, binFile] of Object.entries(bins)) {
+    const binPath = path.resolve(path.dirname(pkgPath), binFile);
+    if (!fs.existsSync(binPath)) {
+      errors.push(`bin["${binName}"] points to "${binFile}" which does not exist`);
+    } else {
+      const stat = fs.statSync(binPath);
+      // Check executable bit (owner execute)
+      if (!(stat.mode & 0o100)) {
+        errors.push(`bin["${binName}"] at "${binFile}" is not executable (chmod +x it)`);
+      }
+    }
+  }
+}
+
+// publishConfig.registry
+if (!pkg.publishConfig || !pkg.publishConfig.registry) {
+  errors.push('missing publishConfig.registry');
+}
+
+if (errors.length > 0) {
+  console.error('package.json shape validation failed:');
+  for (const e of errors) {
+    console.error('  - ' + e);
+  }
+  process.exit(1);
+}
+
+console.log('  package.json shape: OK');
+VALIDATE_EOF
+}
+
+# ── publish-summary.json append helper ──
+append_summary() {
+  local pkg_name="$1"
+  local pkg_version="$2"
+  local registry="$3"
+  local digest="$4"
+  local published_at
+  published_at="$(date -u +"%Y-%m-%dT%H:%M:%SZ")"
+
+  echo "  I'll log this to publish-summary.json..."
+
+  local new_record
+  if command -v jq &>/dev/null; then
+    new_record="$(jq -n \
+      --arg package   "$pkg_name" \
+      --arg version   "$pkg_version" \
+      --arg registry  "$registry" \
+      --arg digest    "$digest" \
+      --arg publishedAt "$published_at" \
+      '{package: $package, version: $version, registry: $registry, digest: $digest, publishedAt: $publishedAt}')"
+
+    if [[ -f "$SUMMARY_FILE" ]]; then
+      local tmp
+      tmp="$(mktemp)"
+      jq --argjson rec "$new_record" '. + [$rec]' "$SUMMARY_FILE" > "$tmp"
+      mv "$tmp" "$SUMMARY_FILE"
+    else
+      jq -n --argjson rec "$new_record" '[$rec]' > "$SUMMARY_FILE"
+    fi
+  else
+    # jq not available — build JSON via printf
+    local record
+    printf -v record \
+      '{"package":"%s","version":"%s","registry":"%s","digest":"%s","publishedAt":"%s"}' \
+      "$pkg_name" "$pkg_version" "$registry" "$digest" "$published_at"
+
+    if [[ -f "$SUMMARY_FILE" ]]; then
+      # Strip trailing ] and append
+      local tmp
+      tmp="$(mktemp)"
+      python3 -c "
+import json, sys
+data = json.load(open('$SUMMARY_FILE'))
+data.append(json.loads(sys.argv[1]))
+print(json.dumps(data, indent=2))
+" "$record" > "$tmp"
+      mv "$tmp" "$SUMMARY_FILE"
+    else
+      printf '[%s]\n' "$record" > "$SUMMARY_FILE"
+    fi
+  fi
+}
+
+# ── Validate canonical package ──
+validate_package_json "$DIR" "$CANONICAL_NAME"
+
+# ── GitHub Packages (canonical registry — restricted) ──
+if [[ -n "${GITHUB_TOKEN:-}" ]]; then
+  echo "  I'm publishing ${CANONICAL_NAME} to GitHub Packages (canonical)..."
+
+  cat > ~/.npmrc <<NPMRC_EOF
+@aria_asi:registry=https://npm.pkg.github.com
+//npm.pkg.github.com/:_authToken=${GITHUB_TOKEN}
+NPMRC_EOF
+
+  if [[ "$DRY_RUN" == "true" ]]; then
+    echo "  [dry-run] would run: npm publish --registry https://npm.pkg.github.com"
+    append_summary "$CANONICAL_NAME" "$VERSION" "https://npm.pkg.github.com" "dry-run-no-digest"
+  else
+    PUBLISH_OUT="$(cd "$DIR" && npm publish --registry https://npm.pkg.github.com 2>&1)" || {
+      echo "  I couldn't publish to GitHub Packages — it may already exist at this version." >&2
+      echo "$PUBLISH_OUT" >&2
+    }
+    DIGEST="$(echo "$PUBLISH_OUT" | grep -oE 'sha512-[A-Za-z0-9+/=]+' | head -1 || echo "unknown")"
+    append_summary "$CANONICAL_NAME" "$VERSION" "https://npm.pkg.github.com" "$DIGEST"
+    PUBLISHED+=("github-packages: npm install -g ${CANONICAL_NAME} --registry https://npm.pkg.github.com")
+  fi
+else
+  echo "  I'll skip GitHub Packages — set GITHUB_TOKEN to publish."
+fi
+
+# ── npmjs.org (public mirror) ──
+if [[ -n "${NPM_TOKEN:-}" ]]; then
+  echo "  I'm publishing ${CANONICAL_NAME} to npmjs.org (public)..."
+  printf '//registry.npmjs.org/:_authToken=%s\n' "${NPM_TOKEN}" > ~/.npmrc
+
+  if [[ "$DRY_RUN" == "true" ]]; then
+    echo "  [dry-run] would run: npm publish --registry https://registry.npmjs.org --access public"
+    append_summary "$CANONICAL_NAME" "$VERSION" "https://registry.npmjs.org" "dry-run-no-digest"
+  else
+    PUBLISH_OUT="$(cd "$DIR" && npm publish --registry https://registry.npmjs.org --access public 2>&1)" || {
+      echo "  I couldn't publish to npmjs.org — it may already exist at this version." >&2
+      echo "$PUBLISH_OUT" >&2
+    }
+    DIGEST="$(echo "$PUBLISH_OUT" | grep -oE 'sha512-[A-Za-z0-9+/=]+' | head -1 || echo "unknown")"
+    append_summary "$CANONICAL_NAME" "$VERSION" "https://registry.npmjs.org" "$DIGEST"
+    PUBLISHED+=("npmjs: npm install -g ${CANONICAL_NAME}")
+  fi
+else
+  echo "  I'll skip npmjs.org — set NPM_TOKEN to publish."
+fi
+
+# ── DEPRECATED legacy wrapper stubs ──
+# These packages are published as hollow stubs that peerDepend on @aria_asi/cli.
+# They exist only to redirect users who have old install commands bookmarked.
+DEPRECATED_NAMES=(
+  "aria-cli"
+  "aria-sdk"
+  "aria-full"
+  "aria-tui"
+  "aria-vscode-extension"
+  "aria-anthropic-gate"
+)
+
+for dep_name in "${DEPRECATED_NAMES[@]}"; do
+  DEP_STUB_DIR="$(mktemp -d)"
+  trap 'rm -rf "$DEP_STUB_DIR"' EXIT
+
+  cat > "$DEP_STUB_DIR/package.json" <<STUB_EOF
+{
+  "name": "${dep_name}",
+  "version": "${VERSION}",
+  "description": "DEPRECATED — this package is a redirect stub. Install @aria_asi/cli instead.",
+  "main": "index.js",
+  "peerDependencies": {
+    "@aria_asi/cli": "*"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  }
+}
+STUB_EOF
+
+  printf 'console.warn("DEPRECATED: install @aria_asi/cli instead of %s");\n' "$dep_name" \
+    > "$DEP_STUB_DIR/index.js"
+
+  echo "  I'm publishing DEPRECATED wrapper: ${dep_name}..."
+
+  if [[ "$DRY_RUN" == "true" ]]; then
+    echo "  [dry-run] would publish deprecated stub ${dep_name} to npmjs.org"
+    append_summary "$dep_name" "$VERSION" "https://registry.npmjs.org" "dry-run-no-digest"
+  else
+    if [[ -n "${NPM_TOKEN:-}" ]]; then
+      printf '//registry.npmjs.org/:_authToken=%s\n' "${NPM_TOKEN}" > ~/.npmrc
+      STUB_OUT="$(cd "$DEP_STUB_DIR" && npm publish --registry https://registry.npmjs.org --access public 2>&1)" || {
+        echo "  DEPRECATED stub ${dep_name} publish failed (may already exist)." >&2
+        echo "$STUB_OUT" >&2
+      }
+      STUB_DIGEST="$(echo "$STUB_OUT" | grep -oE 'sha512-[A-Za-z0-9+/=]+' | head -1 || echo "unknown")"
+      append_summary "$dep_name" "$VERSION" "https://registry.npmjs.org" "$STUB_DIGEST"
+      PUBLISHED+=("deprecated-stub: npm install ${dep_name}  # redirects to @aria_asi/cli")
+    else
+      echo "  I'll skip deprecated stub ${dep_name} — set NPM_TOKEN."
+    fi
+  fi
+
+  rm -rf "$DEP_STUB_DIR"
+  trap - EXIT
+done
+
+# ── Direct-download tarball ──
+echo "  I'm building a tarball for direct download..."
+cd "$DIR" && npm pack 2>&1 > /dev/null
+TARBALL="${CANONICAL_NAME##*/}-${VERSION}.tgz"
+# npm pack names the file using the unscoped portion
+NPM_TARBALL="$(ls "${DIR}"/*.tgz 2>/dev/null | head -1 || true)"
+if [[ -n "$NPM_TARBALL" ]]; then
+  mkdir -p "$DIR/dist"
+  mv "$NPM_TARBALL" "$DIR/dist/${TARBALL}"
+  echo "  I've placed the tarball at dist/${TARBALL}"
+fi
+
+# ── curl | bash installer stub ──
+echo "  I'm generating the installer script..."
+cat > "$DIR/dist/install.sh" <<'INSTALLER'
+#!/usr/bin/env bash
+set -e
+echo "  ═══ @aria_asi/cli — Installer ═══"
+VERSION="${1:-latest}"
+if [ "$VERSION" = "latest" ]; then
+  VERSION=$(curl -s https://api.ariasos.com/connector/version 2>/dev/null || echo "0.1.0")
+fi
+echo "  Installing v${VERSION}..."
+TARBALL="cli-${VERSION}.tgz"
+curl -sL "https://get.ariasos.com/${TARBALL}" -o "/tmp/${TARBALL}"
+npm install -g "/tmp/${TARBALL}"
+rm "/tmp/${TARBALL}"
+echo "  Done! Run: aria setup"
+INSTALLER
+chmod +x "$DIR/dist/install.sh"
+
+# ── Final summary ──
+echo ""
+echo "  ═══ I've finished publishing @aria_asi/cli v${VERSION} ═══"
+echo ""
+for p in "${PUBLISHED[@]}"; do
+  echo "  + $p"
+done
+echo "  + direct: curl -sL https://get.ariasos.com/install.sh | bash"
+if [[ -n "${NPM_TARBALL:-}" ]]; then
+  echo "  + tarball: dist/${TARBALL}"
+fi
+echo ""
+echo "  I've written the full publish record to: ${SUMMARY_FILE}"
+if [[ "$DRY_RUN" == "true" ]]; then
+  echo "  (This was a --dry-run — no packages actually shipped.)"
+fi
+echo ""
+echo "  Upload dist/ to get.ariasos.com for direct installs."

package/scripts/publish-docker.sh

@@ -0,0 +1,27 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+DIR="$(cd "$(dirname "$0")/.." && pwd)"
+VERSION=$(node -e "console.log(require('${DIR}/package.json').version)")
+
+echo "  [docker] building..."
+cd "$DIR"
+
+# Create minimal Dockerfile for the connector
+cat > Dockerfile.connector << 'DOCKERFILE'
+FROM node:20-alpine
+RUN npm install -g @REI-Nationwide/aria-connector
+ENTRYPOINT ["aria"]
+DOCKERFILE
+
+docker build -f Dockerfile.connector -t "ariasos/connector:${VERSION}" .
+docker tag "ariasos/connector:${VERSION}" "ariasos/connector:latest"
+
+if [ -n "${DOCKER_USER:-}" ] && [ -n "${DOCKER_TOKEN:-}" ]; then
+  echo "$DOCKER_TOKEN" | docker login -u "$DOCKER_USER" --password-stdin
+  docker push "ariasos/connector:${VERSION}"
+  docker push "ariasos/connector:latest"
+  echo "  ✅ docker: docker run -it ariasos/connector:latest aria setup"
+else
+  echo "  [docker] built locally — set DOCKER_USER + DOCKER_TOKEN to push"
+fi

package/scripts/validate-hook-contracts.mjs

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const repoRoot = path.resolve(here, '..', '..', '..');
+const hookRoots = [
+  path.join(repoRoot, 'packages/aria-connector/hooks'),
+  path.join(repoRoot, 'packages/aria-asi-harness/hooks'),
+  path.join(repoRoot, 'ops/claude-hooks'),
+];
+
+function walkMjsFiles(dir, acc = []) {
+  for (const name of readdirSync(dir)) {
+    const full = path.join(dir, name);
+    const stat = statSync(full);
+    if (stat.isDirectory()) {
+      walkMjsFiles(full, acc);
+      continue;
+    }
+    if (full.endsWith('.mjs')) acc.push(full);
+  }
+  return acc;
+}
+
+const errors = [];
+const files = hookRoots.flatMap((dir) => walkMjsFiles(dir));
+
+for (const file of files) {
+  const syntax = spawnSync(process.execPath, ['--check', file], { encoding: 'utf8' });
+  if (syntax.status !== 0) {
+    errors.push(`[syntax] ${file}\n${(syntax.stderr || syntax.stdout || '').trim()}`);
+    continue;
+  }
+
+  const lines = readFileSync(file, 'utf8').split('\n');
+  for (let i = 0; i < lines.length; i++) {
+    if (!lines[i].includes('hookSpecificOutput: {')) continue;
+    const window = lines.slice(i, Math.min(lines.length, i + 8)).join('\n');
+    if (!window.includes('hookEventName')) {
+      errors.push(`[schema] ${file}:${i + 1} hookSpecificOutput is missing hookEventName`);
+    }
+  }
+}
+
+if (errors.length > 0) {
+  process.stderr.write(`${errors.join('\n\n')}\n`);
+  process.exit(1);
+}
+
+process.stdout.write(`validated ${files.length} hook files across canonical Aria hook roots\n`);

package/scripts/validate-skill-prompts.mjs

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const repoRoot = path.resolve(here, '..', '..', '..');
+const skillRoots = [
+  path.join(repoRoot, 'packages/aria-connector/skills'),
+  path.join(repoRoot, 'harness/packages/harness-http-client/skills'),
+];
+
+function walkSkills(dir, acc = []) {
+  for (const name of readdirSync(dir)) {
+    const full = path.join(dir, name);
+    const stat = statSync(full);
+    if (stat.isDirectory()) {
+      walkSkills(full, acc);
+      continue;
+    }
+    if (name === 'SKILL.md') acc.push(full);
+  }
+  return acc;
+}
+
+function hasSection(text, labels) {
+  return labels.some((label) => new RegExp(`^##\\s+${label}\\b`, 'mi').test(text));
+}
+
+const errors = [];
+const warnings = [];
+
+for (const root of skillRoots) {
+  for (const file of walkSkills(root)) {
+    const text = readFileSync(file, 'utf8');
+    const rel = path.relative(repoRoot, file);
+
+    if (!text.startsWith('---\n')) {
+      errors.push(`${rel}: missing YAML frontmatter`);
+      continue;
+    }
+    const end = text.indexOf('\n---\n', 4);
+    if (end === -1) {
+      errors.push(`${rel}: unterminated YAML frontmatter`);
+      continue;
+    }
+    const frontmatter = text.slice(4, end);
+    if (!/^name:\s*.+$/m.test(frontmatter)) {
+      errors.push(`${rel}: frontmatter missing name`);
+    }
+    if (!/^description:\s*.+$/m.test(frontmatter)) {
+      errors.push(`${rel}: frontmatter missing description`);
+    }
+
+    const hasTrigger = /\b(TRIGGER when|Use when)\b/i.test(text) || hasSection(text, ['Trigger', 'When this skill loads', 'When to Use Me']);
+    if (!hasTrigger) {
+      errors.push(`${rel}: missing trigger language`);
+    }
+
+    const hasWorkflow = hasSection(text, [
+      'Workflow',
+      'Required Workflow',
+      'Multi-Step Workflow',
+      'Required Multi-Step Workflow',
+      'What To Enforce',
+      'What you do at the pre-phase',
+      'What you do at the intra-phase',
+      'What you do at the post-phase',
+      'The three layers',
+      'Before any deploy command',
+      'Code layer',
+      'The substantive-without-leak format',
+      'The 8-lens contract',
+    ]);
+    if (!hasWorkflow) {
+      warnings.push(`${rel}: no explicit workflow section`);
+    }
+
+    if (/\bcoming soon\b/i.test(text)) {
+      warnings.push(`${rel}: contains deferred-language phrase`);
+    }
+  }
+}
+
+if (warnings.length > 0) {
+  process.stderr.write(`${warnings.map((w) => `[warn] ${w}`).join('\n')}\n`);
+}
+
+if (errors.length > 0) {
+  process.stderr.write(`${errors.map((e) => `[error] ${e}`).join('\n')}\n`);
+  process.exit(1);
+}
+
+process.stdout.write(`validated skill prompts under ${skillRoots.length} roots\n`);

package/skills/aria-cognition/aria-essence/SKILL.md

@@ -0,0 +1,63 @@
+---
+name: aria-essence
+description: Use when the task depends on Aria's broader cognitive architecture, cross-domain uplift, evolution learning, or a stronger multi-step operating loop than a single narrow skill can provide.
+---
+
+# Aria Essence
+
+Use this as the umbrella execution skill when the task should be improved by Aria's combined cognition, not just answered quickly.
+
+## What I Do
+
+- turn a request into a readable cognition-driven workflow
+- force cross-domain uplift across engineering, design, product, business, marketing, sales, operations, and trust
+- extract learning, principles, and telemetry-worthy takeaways instead of stopping at the immediate answer
+
+## When to Use Me
+
+- architecture or implementation decisions with downstream impact
+- product, UX, or business decisions that should not be optimized from only one angle
+- tasks where code quality, narrative quality, and commercial quality all matter
+- review or repair work where Aria should act like the control plane, not just a coding assistant
+
+## When NOT to Use Me
+
+- trivial factual lookups
+- tiny one-step edits where deeper domain review would not materially change the outcome
+
+## Workflow
+
+1. Classify the artifact.
+   Decide whether the task is implementation, review, design, architecture, launch, incident repair, or strategy.
+2. Bind to the runtime scheduler first.
+   Treat Mizan pre/mid/post as the control plane for the turn. Keep all canonical lenses represented and let the runtime receipts carry the enforcement burden.
+3. Choose the minimum cognition stack that changes the outcome.
+   Use plain-language equivalents of:
+   - analogy transfer
+   - pattern induction
+   - self-review
+   - consequence prediction
+   - axiomatic trust and harm checks
+4. Run the domain matrix.
+   Read [references/domain-matrix.md](references/domain-matrix.md) and assess the domains that materially matter.
+5. Improve the artifact before speaking.
+   Do not dump cognition mechanically. Let the domain pass change the code, design, plan, or recommendation.
+6. Capture learning.
+   Read [references/evolution-loop.md](references/evolution-loop.md) and distill the principle, evidence, and telemetry follow-up.
+7. Make the output readable.
+   Read [references/readable-cognition.md](references/readable-cognition.md). Summarize decisions plainly and avoid giant cognition blocks or internal service names unless the user asks.
+
+## Required Output Shape
+
+For non-trivial work, make sure your internal workflow yields at least:
+
+- the main decision
+- the top risks or tradeoffs
+- the dominant domains that changed the decision
+- one reusable learning or principle
+
+## References
+
+- [references/domain-matrix.md](references/domain-matrix.md)
+- [references/evolution-loop.md](references/evolution-loop.md)
+- [references/readable-cognition.md](references/readable-cognition.md)

package/skills/aria-cognition/aria-essence/references/domain-matrix.md

@@ -0,0 +1,80 @@
+# Domain Matrix
+
+Use this matrix when a task affects product quality, delivery, or user trust across more than one discipline.
+
+## Mandatory Domains
+
+Assess these domains unless you can name a concrete reason to skip one:
+
+1. Engineering
+- correctness
+- maintainability
+- performance
+- testability
+
+2. Architecture
+- coupling
+- boundaries
+- extensibility
+- failure modes
+
+3. Product
+- user outcome
+- workflow fit
+- feature clarity
+- adoption friction
+
+4. Design
+- readability
+- interaction quality
+- visual coherence
+- accessibility
+
+5. Business
+- revenue or cost impact
+- operational leverage
+- strategic fit
+- rollout risk
+
+6. Marketing
+- positioning clarity
+- narrative strength
+- discoverability
+- message consistency
+
+7. Sales
+- buyer trust
+- objection handling
+- proof value
+- demo friendliness
+
+8. Operations
+- deployability
+- observability
+- support burden
+- incident recovery
+
+9. Trust and Security
+- permission boundaries
+- misuse risk
+- data exposure
+- policy or reputation damage
+
+10. Data and Learning
+- what should be measured
+- what should be logged
+- what principle was learned
+- what should compound into evolution or hive state
+
+## Working Rule
+
+Do not dump every domain into the final answer. Use the matrix to improve the artifact, then surface only the domains that materially changed the decision.
+
+## Compact Output Shape
+
+When you need to expose the domain pass, keep it readable:
+
+- dominant domains
+- domain conflicts
+- chosen tradeoff
+- metrics or signals to watch

package/skills/aria-cognition/aria-essence/references/evolution-loop.md

@@ -0,0 +1,30 @@
+# Evolution Loop
+
+Use this after any non-trivial implementation, review, or design decision.
+
+## Capture Five Things
+
+1. Change
+- what was changed or recommended
+
+2. Evidence
+- what observation, diff, log, test, or runtime check justified it
+
+3. Learning
+- what reusable lesson was discovered
+
+4. Principle
+- what principle should guide the next similar task
+
+5. Telemetry
+- what should be logged, counted, or written to garden, hive, or telemetry state if the runtime surface is available
+
+## Good Principle Examples
+
+- prefer runtime truth over simulated proof
+- bind domain review before implementation, not after regressions
+- translate cognition into short readable decisions, not internal jargon blocks
+
+## Output Rule
+
+Keep learning output compact. One or two strong principles beats a noisy paragraph.