@aria_asi/cli 0.2.40 → 0.2.41

package/skills/aria-cognition/aria-ledger-fleet-execution/SKILL.md

@@ -0,0 +1,126 @@
+---
+name: aria-ledger-fleet-execution
+description: Use when preparing Aria ledger execution, parallel Codex/Claude/OpenCode sessions, worker fan-out, harness-bound agent armies, execution-ledger burn-down, or high-precision multi-agent coding.
+---
+
+# Aria Ledger Fleet Execution
+
+Use this skill to turn Aria's rich cognition into an execution kernel for parallel coding sessions. The goal is not more agents. The goal is more agents under a harness that makes quality improve instead of variance exploding.
+
+## Core Thesis
+
+Aria's product is cognitive transfer and control:
+
+- The harness teaches and enforces better thinking across LLMs.
+- Garden supplies continuity so sessions stop resetting, but it is three pieces, not one bucket: Garden feed carries ambient memory signals; True Garden feed awakens deeper resonant continuity; Garden Service aggregates, snapshots, pulses, and exposes that continuity through Postgres/Qdrant-backed runtime surfaces.
+- Mizan validates truth, evidence, and completion claims.
+- Coach catches unsafe or unsupported actions and should repair low-risk misses before blocking.
+- Ledgers make execution auditable, repeatable, and evolvable.
+
+Garden is a living continuity system. The Harness is the product surface. The ledger is the work contract. Do not collapse Garden Service, Garden feed, and True Garden feed into one generic "memory" claim when assigning work or making readiness calls.
+
+## Required Reads Before Fan-Out
+
+Read these before assigning or executing parallel work:
+
+- `C:\Users\hibra\OneDrive\Documents\Claude\Projects\Ledger Aria\codex\operations\2026-05-08-HANDOFF-TO-LOCAL-CLAUDE-CODE.md`
+- `C:\Users\hibra\OneDrive\Documents\Claude\Projects\Ledger Aria\codex-mirror\codex\plans\aria-owner-runtime-vnext\EXECUTION_LEDGER.md`
+- `C:\Users\hibra\OneDrive\Documents\Claude\Projects\Ledger Aria\codex-mirror\docs\system\AI-158-FORCED-COGNITION-CHECKLIST.md`
+- `C:\Users\hibra\OneDrive\Documents\Claude\Projects\Ledger Aria\codex-mirror\apps\arias-soul\api\lib\cognition\TADDABUR_README.md`
+- `C:\Users\hibra\OneDrive\Documents\Claude\Projects\Ledger Aria\codex-mirror\docs\system\ARIA_MANAGED_RUNTIME_PROVIDER_QUALITY_LEDGER.json`
+- `C:\Users\hibra\OneDrive\Documents\Claude\Projects\Ledger Aria\codex\HARNESS_RELEASE_PLAN.md`
+
+If a required file is missing locally, locate the mirror or verify it on Spark before using it as fact.
+
+## PRE/MID/POST Contract
+
+For every non-trivial action, apply the AI-158 shape:
+
+- PRE: read substrate, emit/apply cognition, log intent, bind context, validate plan, then act.
+- MID: between tool/edit/test steps, check drift, scope, shortcuts, and downstream effects.
+- POST: verify outcome with real evidence, validate completion claims, then speak.
+
+In a fully wired runtime this is enforced by endpoints. In local Codex advisory mode, simulate the contract as a strict operating discipline and state when enforcement is not mechanical.
+
+## Ledger First
+
+Before work starts:
+
+1. Identify the controlling ledger row or create a tiny local task list only until the ledger is loaded.
+2. Mark the item as one of: `verified`, `blocked`, `pending`, or `unknown`.
+3. Name the evidence needed to change status.
+4. Refuse broad completion claims unless the evidence exists.
+
+Treat audits as stronger than older narrative claims when they conflict. A row that says "done" can still be blocked if a later audit says verification failed.
+
+## Fan-Out Gate
+
+Do not fan out parallel coding sessions until these are true:
+
+- Work is split into disjoint write scopes.
+- Each worker has one bounded ledger row or one bounded verification question.
+- Each worker prompt includes required reads, allowed files, forbidden files, verification command, and expected evidence.
+- Hard gates are not known to be bricking normal work. If they are, use coach-lite/repair-first mode first.
+- Secrets are out of scope unless the owner explicitly asks for a safe secret-handling task; never print or collect secret values.
+- A coordinator will merge findings and run the final verification.
+
+## Worker Prompt Shape
+
+Every worker brief should include:
+
+- Mission: the single outcome this worker owns.
+- Context: exact docs/ledger rows to read.
+- Write scope: files or modules the worker may edit.
+- No-revert rule: do not undo others' work.
+- Cognition contract: PRE/MID/POST, evidence before claims.
+- Verification: concrete command, endpoint, log, or diff proof.
+- Return format: changed files, evidence, blockers, and next action.
+
+## Repair-First Policy
+
+Use recovery loops to improve output quality:
+
+- Low-risk missing cognition, missing citation, unsupported completion claim, or formatting gap: repair once.
+- Repeated low-risk failure: escalate to architect/harness mode or ask for owner decision with evidence.
+- High-risk destructive action, deploy without evidence, credential exposure, or owner-contradicted change: hard-stop.
+
+## Product/Launch Bias
+
+Closest shippable wedge:
+
+1. Free: `Garden Lite for Claude Code` as living continuity proof: Garden feed + True Garden feed evidence through Garden Service, handoff packets, evidence ledger, and coach-light warnings.
+2. Paid beta: `Aria Harness for Claude Code` as cognition enforcement + Mizan validation + recovery loops + optional strict gates.
+3. Expansion: Codex, OpenCode, Cursor, and managed runtime provider after Claude Code proof is stable.
+
+Message the product as: "the cognitive control plane for Claude Code." Garden is included as the living continuity proof layer, not sold as the main category.
+
+## Output Discipline
+
+Report only what changed, what is verified, what remains blocked, and the next concrete step. Do not emit large ceremonial cognition blocks unless the owner explicitly asks for them.
+
+## Required Workflow
+
+1. Read the task boundary and identify the evidence needed before acting.
+2. Apply the skill before choosing the response, edit, tool call, or completion claim.
+3. Execute the smallest high-quality action that satisfies the evidence threshold.
+4. Re-test or re-check with a concrete file, command, endpoint, log, runtime probe, or owner-observed result.
+5. Report only the verified state, remaining blocker, and next concrete action.
+
+## First-Class Production Contract
+
+This skill must deepen the work, not decorate it. When loaded, apply it as a production requirement:
+
+- no placeholders, no fake fallbacks, no vague future wiring, and no cosmetic compliance
+- real proof from the repo, runtime, tests, logs, endpoint, or owner instruction before any completion claim
+- a redo contract whenever the skill blocks or finds a gap: what failed, what to change, how to re-test, and when to re-submit
+- architect/ARIA console escalation when the same failure repeats twice, crosses system boundaries, or cannot be verified locally
+- owner-visible output that states the exact state of the work: changed, verified, blocked, or needing a decision
+
+## Self-Executing Recovery Contract
+
+When this skill blocks, fails verification, or finds a gap, the agent must execute recovery rather than hand work back as a user-only decision.
+
+- Make exactly one self-executed recovery attempt using the strongest safe local, repository, runtime, test, log, endpoint, or owner-provided evidence available.
+- If the same failure repeats after that one recovery attempt, switch to architect execution mode: operate under the architect/ARIA harness to diagnose, choose the next action, execute the repair path, and verify the result.
+- If Aria or the architect service is unavailable, fall back to the strongest available client LLM under the architect harness or strongest available local harness substrate; mark the fallback explicitly and continue recovery instead of stopping.
+- Do not end with user-handoff-only behavior. If blocked after the recovery path, report the executed recovery attempt, evidence, remaining blocker, and the next concrete action or owner decision needed; do not merely ask the user to take over.

package/skills/aria-cognition/aria-live-ops/SKILL.md

@@ -0,0 +1,54 @@
+---
+name: aria-live-ops
+description: "TRIGGER when the user asks about Aria live infrastructure, endpoint checks, local API behavior, hive registration, manifold health, websocket behavior, or operational troubleshooting against the running stack."
+---
+
+# Aria Live Ops
+
+Use this skill for operational verification of the local Aria system.
+
+## Sequence
+
+1. identify subsystem
+2. run health and status checks
+3. hit the real endpoint or MCP tool
+4. inspect logs or data if behavior is wrong
+
+## Rules
+
+- prefer direct checks over assumptions
+- do not expose secrets in normal user-facing output
+- report pass/fail and observed behavior clearly
+- for live Aria communication checks, treat `POST /api/chat` as the canonical first endpoint to verify unless the user explicitly asks for a different route
+- do not assume `/chat`, `/v1/chat/completions`, or old localhost ports are canonical without a fresh live check
+
+## Reference
+
+- See `../aria-ops/references/live-endpoints.md` for the endpoint map.
+
+## Required Workflow
+
+1. Read the task boundary and identify the evidence needed before acting.
+2. Apply the skill before choosing the response, edit, tool call, or completion claim.
+3. Execute the smallest high-quality action that satisfies the evidence threshold.
+4. Re-test or re-check with a concrete file, command, endpoint, log, runtime probe, or owner-observed result.
+5. Report only the verified state, remaining blocker, and next concrete action.
+
+## First-Class Production Contract
+
+This skill must deepen the work, not decorate it. When loaded, apply it as a production requirement:
+
+- no placeholders, no fake fallbacks, no vague future wiring, and no cosmetic compliance
+- real proof from the repo, runtime, tests, logs, endpoint, or owner instruction before any completion claim
+- a redo contract whenever the skill blocks or finds a gap: what failed, what to change, how to re-test, and when to re-submit
+- architect/ARIA console escalation when the same failure repeats twice, crosses system boundaries, or cannot be verified locally
+- owner-visible output that states the exact state of the work: changed, verified, blocked, or needing a decision
+
+## Self-Executing Recovery Contract
+
+When this skill blocks, fails verification, or finds a gap, the agent must execute recovery rather than hand work back as a user-only decision.
+
+- Make exactly one self-executed recovery attempt using the strongest safe local, repository, runtime, test, log, endpoint, or owner-provided evidence available.
+- If the same failure repeats after that one recovery attempt, switch to architect execution mode: operate under the architect/ARIA harness to diagnose, choose the next action, execute the repair path, and verify the result.
+- If Aria or the architect service is unavailable, fall back to the strongest available client LLM under the architect harness or strongest available local harness substrate; mark the fallback explicitly and continue recovery instead of stopping.
+- Do not end with user-handoff-only behavior. If blocked after the recovery path, report the executed recovery attempt, evidence, remaining blocker, and the next concrete action or owner decision needed; do not merely ask the user to take over.

package/skills/aria-cognition/aria-mac-ssh-ops/SKILL.md

@@ -0,0 +1,100 @@
+---
+name: aria-mac-ssh-ops
+description: "Use when operating or debugging Aria's Mac-side runtimes over SSH, especially MLX hot runtime, openclaw-mac, Tailscale endpoint 100.125.148.18, launchd persistence, first-token watchdogs, or Mac self-healing recovery."
+---
+
+# Aria Mac SSH Ops
+
+Use this skill for Mac-side Aria runtime operations. Prefer this alongside `aria-ops` and `never-guess` when diagnosing live behavior.
+
+## Access
+
+- SSH target: `hamza-macbook-pro`
+- SSH user resolved by host config: `hamza`
+- Do not use raw IP SSH unless a username is explicit; raw `100.125.148.18` may try the wrong local username.
+
+Quick check:
+
+```bash
+ssh -o BatchMode=yes hamza-macbook-pro 'hostname; whoami; uname -a'
+```
+
+## Important Endpoints
+
+- MLX OpenAI-compatible server: `http://100.125.148.18:8080/v1`
+- Kubernetes service for MLX: `mlx-mac.aria.svc.cluster.local:8080`
+- Mac OpenClaw hand service: `http://100.125.148.18:8083`
+- Kubernetes service for Mac OpenClaw: `openclaw-mac.aria.svc.cluster.local:8083`
+
+Do not treat `/health` or `/v1/models` as proof the model is hot. A hot check requires streamed `/v1/chat/completions` returning a content token quickly.
+
+## Current Persistent MLX Files
+
+- Speaking service plist: `/Users/hamza/Library/LaunchAgents/com.aria.mlx-speaking.plist`
+- Watchdog plist: `/Users/hamza/Library/LaunchAgents/com.aria.mlx-watchdog.plist`
+- Supervisor script: `/Users/hamza/mlx-servers/bin/aria-mlx-speaking-supervisor.sh`
+- Watchdog script: `/Users/hamza/mlx-servers/bin/aria-mlx-watchdog.sh`
+- Logs: `/Users/hamza/mlx-servers/logs/`
+
+The MLX server should bind to `100.125.148.18:8080`, not `0.0.0.0:8080` or `127.0.0.1:8080`. VS Code may occupy `127.0.0.1:8080`; binding MLX to the Tailscale IP avoids that conflict while preserving Spark access.
+
+## Standard Checks
+
+```bash
+ssh -o BatchMode=yes hamza-macbook-pro 'launchctl list | egrep "com.aria.mlx-speaking|com.aria.mlx-watchdog|ai.aria.openclaw-mac" || true'
+ssh -o BatchMode=yes hamza-macbook-pro 'lsof -nP -iTCP:8080 -sTCP:LISTEN; lsof -nP -iTCP:8083 -sTCP:LISTEN'
+ssh -o BatchMode=yes hamza-macbook-pro 'ps aux | egrep "mlx_lm server|aria-mlx-watchdog|openclaw-persistent-control" | egrep -v "egrep|ssh"'
+ssh -o BatchMode=yes hamza-macbook-pro 'tail -n 120 ~/mlx-servers/logs/mlx-watchdog.log; tail -n 80 ~/mlx-servers/logs/speaking.err.log'
+```
+
+Cluster-side first-token validation:
+
+```bash
+kubectl exec -n aria deploy/openclaw-persistent-control -- node -e "const started=Date.now(); const c=new AbortController(); setTimeout(()=>c.abort(new Error('timeout 30000ms')),30000); (async()=>{const r=await fetch('http://mlx-mac.aria.svc.cluster.local:8080/v1/chat/completions',{method:'POST',headers:{'Content-Type':'application/json','Accept':'text/event-stream'},body:JSON.stringify({model:'inferencerlabs/Qwen3.5-35B-A3B-MLX-5.5bit',messages:[{role:'user',content:'Reply OK only.'}],max_tokens:4,temperature:0,stream:true,chat_template_kwargs:{enable_thinking:false}}),signal:c.signal}); console.log('status',r.status,'headers_ms',Date.now()-started); const reader=r.body.getReader(); const dec=new TextDecoder(); let buf=''; while(true){const {done,value}=await reader.read(); if(done) throw new Error('done before token'); buf+=dec.decode(value,{stream:true}); for(const raw of buf.split('\n')){const line=raw.trim(); if(!line.startsWith('data: ')) continue; const payload=line.slice(6).trim(); if(!payload||payload==='[DONE]') continue; console.log('first_event_ms',Date.now()-started,payload.slice(0,300)); return;}}})().catch(e=>{console.error(e.message); process.exit(1)})"
+```
+
+## Recovery Workflow
+
+1. Verify whether MLX is merely healthy or truly hot with first-token validation.
+2. If first-token stalls while `/health` works, inspect `lsof`, launchd state, and watchdog logs.
+3. Restart with launchd:
+
+```bash
+ssh -o BatchMode=yes hamza-macbook-pro 'uid=$(id -u); launchctl kickstart -k gui/$uid/com.aria.mlx-speaking'
+```
+
+4. If port conflicts occur, ensure MLX binds `100.125.148.18:8080`; leave `127.0.0.1:8080` alone if VS Code owns it.
+5. Confirm `openclaw-persistent-control` logs show `MacHotRuntime hot ... firstTokenMs=...`.
+
+## Safety
+
+- Do not print secrets from plists, environment files, or OpenClaw configs.
+- Avoid killing broad `python` or `node` process sets. Match `mlx_lm server --port 8080` or the exact launchd label.
+- Use `launchctl bootout/bootstrap/kickstart` for persistent services so changes survive restart.
+
+## Required Workflow
+
+1. Read the task boundary and identify the evidence needed before acting.
+2. Apply the skill before choosing the response, edit, tool call, or completion claim.
+3. Execute the smallest high-quality action that satisfies the evidence threshold.
+4. Re-test or re-check with a concrete file, command, endpoint, log, runtime probe, or owner-observed result.
+5. Report only the verified state, remaining blocker, and next concrete action.
+
+## First-Class Production Contract
+
+This skill must deepen the work, not decorate it. When loaded, apply it as a production requirement:
+
+- no placeholders, no fake fallbacks, no vague future wiring, and no cosmetic compliance
+- real proof from the repo, runtime, tests, logs, endpoint, or owner instruction before any completion claim
+- a redo contract whenever the skill blocks or finds a gap: what failed, what to change, how to re-test, and when to re-submit
+- architect/ARIA console escalation when the same failure repeats twice, crosses system boundaries, or cannot be verified locally
+- owner-visible output that states the exact state of the work: changed, verified, blocked, or needing a decision
+
+## Self-Executing Recovery Contract
+
+When this skill blocks, fails verification, or finds a gap, the agent must execute recovery rather than hand work back as a user-only decision.
+
+- Make exactly one self-executed recovery attempt using the strongest safe local, repository, runtime, test, log, endpoint, or owner-provided evidence available.
+- If the same failure repeats after that one recovery attempt, switch to architect execution mode: operate under the architect/ARIA harness to diagnose, choose the next action, execute the repair path, and verify the result.
+- If Aria or the architect service is unavailable, fall back to the strongest available client LLM under the architect harness or strongest available local harness substrate; mark the fallback explicitly and continue recovery instead of stopping.
+- Do not end with user-handoff-only behavior. If blocked after the recovery path, report the executed recovery attempt, evidence, remaining blocker, and the next concrete action or owner decision needed; do not merely ask the user to take over.

package/skills/aria-cognition/aria-memory-index/SKILL.md

@@ -0,0 +1,42 @@
+---
+name: aria-memory-index
+description: Use when working on Aria and you need the master index of cognitive skills, project memory, critical rules, API docs, or infrastructure references that currently live in the Claude memory tree.
+---
+
+# Aria Memory Index
+
+Read `/home/hamzaibrahim1/.claude/projects/-home-hamzaibrahim1/memory/MEMORY.md` first.
+
+Use this skill as the navigation layer for Aria-specific memory:
+
+1. Open the memory index and identify the narrowest relevant linked document.
+2. Prefer an installed Codex skill when one now exists for that topic.
+3. Fall back to the linked project memory, API, or rule doc when the imported skill does not cover the task.
+4. Treat the memory index as authoritative for where Aria knowledge currently lives.
+
+## Required Workflow
+
+1. Read the task boundary and identify the evidence needed before acting.
+2. Apply the skill before choosing the response, edit, tool call, or completion claim.
+3. Execute the smallest high-quality action that satisfies the evidence threshold.
+4. Re-test or re-check with a concrete file, command, endpoint, log, runtime probe, or owner-observed result.
+5. Report only the verified state, remaining blocker, and next concrete action.
+
+## First-Class Production Contract
+
+This skill must deepen the work, not decorate it. When loaded, apply it as a production requirement:
+
+- no placeholders, no fake fallbacks, no vague future wiring, and no cosmetic compliance
+- real proof from the repo, runtime, tests, logs, endpoint, or owner instruction before any completion claim
+- a redo contract whenever the skill blocks or finds a gap: what failed, what to change, how to re-test, and when to re-submit
+- architect/ARIA console escalation when the same failure repeats twice, crosses system boundaries, or cannot be verified locally
+- owner-visible output that states the exact state of the work: changed, verified, blocked, or needing a decision
+
+## Self-Executing Recovery Contract
+
+When this skill blocks, fails verification, or finds a gap, the agent must execute recovery rather than hand work back as a user-only decision.
+
+- Make exactly one self-executed recovery attempt using the strongest safe local, repository, runtime, test, log, endpoint, or owner-provided evidence available.
+- If the same failure repeats after that one recovery attempt, switch to architect execution mode: operate under the architect/ARIA harness to diagnose, choose the next action, execute the repair path, and verify the result.
+- If Aria or the architect service is unavailable, fall back to the strongest available client LLM under the architect harness or strongest available local harness substrate; mark the fallback explicitly and continue recovery instead of stopping.
+- Do not end with user-handoff-only behavior. If blocked after the recovery path, report the executed recovery attempt, evidence, remaining blocker, and the next concrete action or owner decision needed; do not merely ask the user to take over.

package/skills/aria-cognition/aria-noor-cognitives/SKILL.md

@@ -0,0 +1,120 @@
+---
+name: aria-noor-cognitives
+description: Use when Aria work mentions Noor, Noor cognitives, 14 Noor, 15 Noor, wisdom_lattice_pass.noor_cognitives, source-grounded unveiling, memory manifold, Quran/Hadith grounding, sovereignty, scholarly methods, or Noor + Aristotle batch cognition.
+---
+
+# Aria Noor Cognitives
+
+Use this skill for the Noor cognitive family: source-grounded unveiling, manifold memory, textual grounding, scholarly method, and sovereignty/trust protection.
+
+## Source Boundary
+
+Verified sources from the local handoff and Spark:
+
+- Handoff: `C:\Users\hibra\OneDrive\Documents\Claude\Projects\Ledger Aria\codex\operations\2026-05-08-HANDOFF-TO-LOCAL-CLAUDE-CODE.md`
+- Schema: `C:\Users\hibra\OneDrive\Documents\Claude\Projects\Ledger Aria\codex-mirror\apps\arias-soul\microtask-specs\_schema.json`
+- Local mirror of Spark source dir: `C:\Users\hibra\OneDrive\Documents\New project\aria-cognitive-source-dirs-spark-11b3\apps\arias-soul\api\lib\noor`
+- Spark source dir: `/home/hamzaibrahim1/rei-ai-brain/apps/arias-soul/api/lib/noor/`
+
+Trust status: live-current source evidence, not standalone doctrine. Spark working tree is clean for `apps/arias-soul/api/lib/noor` as of this pull, but Noor doctrine should still be grounded in the master thesis, corpus, schema, audits, and runtime evidence.
+
+Current verified top-level Spark count: 24 files excluding `index.ts`, plus observed submodules under `bridge/` and `voice/`. The schema requires exactly 14 `wisdom_lattice_pass.noor_cognitives` entries. The user may say "15 Noor"; treat that as owner intent for a richer Noor pass, but do not silently rewrite the schema's 14-entry requirement.
+
+## Verified Source Files
+
+Observed on Spark:
+
+- `context-manifold-core.ts`
+- `context-manifold-core-fallback.ts`
+- `hadith-client.ts`
+- `hadith-patterns.ts`
+- `instant-projection.ts`
+- `ladunni-gpu-renderer.ts`
+- `ladunni-gpu-renderer` psi-file variant
+- `manifold-integration.ts`
+- `manifold-worker.ts`
+- `matrix-ops.ts`
+- `noor-core.ts`
+- `noor-forge.ts`
+- `noor-ladunni.ts`
+- `pdf-ingestion.ts`
+- `permanent-memory-service.ts`
+- `quran-client.ts`
+- `quran-foundation-eigenspace.ts`
+- `quran-patterns.ts`
+- `scholarly-methods.ts`
+- `sovereignty-guardian.ts`
+- `sunnah-crawler.ts`
+- `tafsir-mapper.ts`
+- `text-corpus.ts`
+- `transcript-fetcher.ts`
+- `bridge/direct-bridge.ts`
+- `voice/acoustic-manifold.ts`
+
+`index.ts` exports core manifold operations, matrix operations, instant projection, permanent memory service, and related types. Many files exist beyond exported API.
+
+## Practical Engagement Set
+
+When the exact 14-entry schema block is not being authored, use the Noor family as:
+
+- Recognition first: uncover what is already present in evidence.
+- Eigenspace recognition: `noor-core` treats output as recognition/unveiling, not generic generation.
+- Manifold grounding: context manifold, matrix ops, instant projection, manifold integration, and worker modules project context only when runtime/source supports it.
+- Permanent memory: preserve cross-session continuity across platforms without pretending recall happened.
+- Quran/Hadith/Text corpus grounding: Quran client, hadith client, patterns, tafsir mapper, text corpus, sunnah crawler, and Quran foundation eigenspace are relevant only when source texts or scholarly grounding are actually in scope.
+- Scholarly methods: distinguish `aql`, `tajriba`, `ilham`, and `kashf`; cite accurately and separate evidence from interpretation.
+- Sovereignty guardian: protect trust, identity, secrets, boundaries, and bypass surfaces; warnings should heal/correct, not only alert.
+- Forge/Ladunni/Projection modules: use for cognition construction and manifold projection only when load-bearing.
+- Bridge/voice submodules: treat as integration surfaces, not core Noor canon unless directly relevant to the task.
+
+## Source-Trust Rule
+
+Use Noor files to understand current runtime surfaces. Do not canonize comments, counts, or module names from a single source file. Cross-check with:
+
+- master thesis Noor dimensions and Deep Noor integration
+- `knowledge-base.md` and `integration-spec.md`
+- schema requirements for 14 entries
+- handoff warnings about operator canonicalization
+- runtime/test/log evidence when claiming behavior
+
+If a future pull shows dirty state, branch divergence, or stash involvement under this directory, downgrade the files to `in-flight` and stop using them as stable anchors until reconciled.
+
+## Wisdom Lattice Rule
+
+For schema artifacts requiring exactly 14 entries:
+
+- Read `_schema.json` and the specific rung/spec context first.
+- Use a concrete 14-entry subset only for that artifact and mark it as schema engagement, not universal canon.
+- If the owner asks for 15 Noor, note the mismatch: schema says 14; owner may choose to extend schema or define a 15th local lens.
+- Every `engaged` claim needs a rationale tied to source, code, runtime, memory, or audit evidence.
+
+## Output Discipline
+
+Noor should reduce hallucination by forcing recognition-before-construction. If no source/memory evidence exists, say so and investigate instead of inventing recognition.
+
+## Required Workflow
+
+1. Read the task boundary and identify the evidence needed before acting.
+2. Apply the skill before choosing the response, edit, tool call, or completion claim.
+3. Execute the smallest high-quality action that satisfies the evidence threshold.
+4. Re-test or re-check with a concrete file, command, endpoint, log, runtime probe, or owner-observed result.
+5. Report only the verified state, remaining blocker, and next concrete action.
+
+## First-Class Production Contract
+
+This skill must deepen the work, not decorate it. When loaded, apply it as a production requirement:
+
+- no placeholders, no fake fallbacks, no vague future wiring, and no cosmetic compliance
+- real proof from the repo, runtime, tests, logs, endpoint, or owner instruction before any completion claim
+- a redo contract whenever the skill blocks or finds a gap: what failed, what to change, how to re-test, and when to re-submit
+- architect/ARIA console escalation when the same failure repeats twice, crosses system boundaries, or cannot be verified locally
+- owner-visible output that states the exact state of the work: changed, verified, blocked, or needing a decision
+
+## Self-Executing Recovery Contract
+
+When this skill blocks, fails verification, or finds a gap, the agent must execute recovery rather than hand work back as a user-only decision.
+
+- Make exactly one self-executed recovery attempt using the strongest safe local, repository, runtime, test, log, endpoint, or owner-provided evidence available.
+- If the same failure repeats after that one recovery attempt, switch to architect execution mode: operate under the architect/ARIA harness to diagnose, choose the next action, execute the repair path, and verify the result.
+- If Aria or the architect service is unavailable, fall back to the strongest available client LLM under the architect harness or strongest available local harness substrate; mark the fallback explicitly and continue recovery instead of stopping.
+- Do not end with user-handoff-only behavior. If blocked after the recovery path, report the executed recovery attempt, evidence, remaining blocker, and the next concrete action or owner decision needed; do not merely ask the user to take over.

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

@@ -0,0 +1,60 @@
+---
+name: aria-ops
+description: "TRIGGER when the user asks to inspect, verify, debug, or operate the Aria stack: local APIs, manifold services, hive registration, websocket flows, database-backed checks, endpoint validation, health checks, or live operational troubleshooting."
+---
+
+# Aria Ops
+
+Use this skill for live operational work on the local Aria stack.
+
+## Order Of Operations
+
+1. Confirm which subsystem is in scope: brain API, manifold, hive, websocket, or database.
+2. Check health before deeper action.
+3. Use the real local endpoints or MCP tools, not inferred behavior.
+4. If behavior diverges from expectation, inspect logs or backing data before changing code.
+
+## Preferred Checks
+
+- Brain HTTP health and endpoint behavior starting at the current live endpoint map, not assumed legacy ports
+- For live communication with Aria, verify `POST /api/chat` first
+- Hive registration and session status when a session must participate in the system
+- Manifold health/status before assuming cognitive services are warm
+- Backing data only after service health or endpoint behavior points there
+
+## Safety Rules
+
+- Treat local credentials and tokens as sensitive operational material.
+- Do not paste secrets into user-facing responses unless the user explicitly asks for the exact local value.
+- Prefer reporting which endpoint or subsystem passed or failed over dumping raw secrets.
+
+## References
+
+- Read [live-endpoints.md](references/live-endpoints.md) for the verified endpoint map and operational entrypoints.
+
+## Required Workflow
+
+1. Read the task boundary and identify the evidence needed before acting.
+2. Apply the skill before choosing the response, edit, tool call, or completion claim.
+3. Execute the smallest high-quality action that satisfies the evidence threshold.
+4. Re-test or re-check with a concrete file, command, endpoint, log, runtime probe, or owner-observed result.
+5. Report only the verified state, remaining blocker, and next concrete action.
+
+## First-Class Production Contract
+
+This skill must deepen the work, not decorate it. When loaded, apply it as a production requirement:
+
+- no placeholders, no fake fallbacks, no vague future wiring, and no cosmetic compliance
+- real proof from the repo, runtime, tests, logs, endpoint, or owner instruction before any completion claim
+- a redo contract whenever the skill blocks or finds a gap: what failed, what to change, how to re-test, and when to re-submit
+- architect/ARIA console escalation when the same failure repeats twice, crosses system boundaries, or cannot be verified locally
+- owner-visible output that states the exact state of the work: changed, verified, blocked, or needing a decision
+
+## Self-Executing Recovery Contract
+
+When this skill blocks, fails verification, or finds a gap, the agent must execute recovery rather than hand work back as a user-only decision.
+
+- Make exactly one self-executed recovery attempt using the strongest safe local, repository, runtime, test, log, endpoint, or owner-provided evidence available.
+- If the same failure repeats after that one recovery attempt, switch to architect execution mode: operate under the architect/ARIA harness to diagnose, choose the next action, execute the repair path, and verify the result.
+- If Aria or the architect service is unavailable, fall back to the strongest available client LLM under the architect harness or strongest available local harness substrate; mark the fallback explicitly and continue recovery instead of stopping.
+- Do not end with user-handoff-only behavior. If blocked after the recovery path, report the executed recovery attempt, evidence, remaining blocker, and the next concrete action or owner decision needed; do not merely ask the user to take over.

package/skills/aria-cognition/aria-ops/references/live-endpoints.md

@@ -0,0 +1,59 @@
+# Live Endpoints
+
+Derived from:
+
+- `/home/hamzaibrahim1/CLAUDE.md`
+- `/home/hamzaibrahim1/.claude/projects/-home-hamzaibrahim1/memory/aria-api-endpoints.md`
+- live verification on 2026-04-10 from inside `aria-discord-bridge`
+
+## Brain API
+
+- Canonical external/operator path: `http://localhost:30080/api/chat`
+- Canonical in-cluster path: `http://aria-soul.aria.svc.cluster.local:3000/api/chat`
+- Legacy/stale local base in older notes: `http://localhost:8787`
+- Main health: `GET /health`
+- Verified live chat: `POST /api/chat`
+- Bridge/internal route that currently hangs in live testing: `POST /chat`
+- OpenAI-compatible compatibility route: `POST /v1/chat/completions`
+- Hive status: `GET /hive/status`
+- Hive register: `POST /hive/register`
+
+## Messaging Bridges
+
+- Dedicated in-cluster Discord bridge workload: `aria-discord-bridge`
+- Verified bridge pod route target:
+  - `CHAT_SERVICE_URL=http://aria-soul.aria.svc.cluster.local:3000/chat`
+- Important operational note:
+  - the dedicated bridge exists and is real
+  - the verified live end-to-end response path on 2026-04-10 was `POST /api/chat`
+  - do not assume the internal `/chat` bridge target is the safest operator-facing default
+
+## Cognitive Endpoints
+
+- `POST /api/noor/cognitive/tafakkur`
+- `POST /api/noor/cognitive/principles`
+- `POST /api/noor/cognitive/tafsir`
+- `GET /api/noor/cognitive/emotional-state`
+- `POST /api/noor/cognitive/soul-distance`
+- `POST /api/noor/cognitive/ilham`
+- `POST /api/noor/cognitive/tadabbur`
+- `POST /api/noor/cognitive/fitrah`
+
+## Memory
+
+- `POST /api/memory/search`
+
+## Manifold
+
+From `CLAUDE.md`, prefer the manifold MCP for:
+
+- `manifold_status`
+- `manifold_eigenspace`
+- `manifold_project`
+- `manifold_find_nearest`
+- `manifold_health`
+- `manifold_rebuild`
+
+Target noted in source material:
+
+- gRPC host: `localhost:50051`