@aria_asi/cli 0.2.40 → 0.2.41

package/skills/firecrawl-interact/SKILL.md

@@ -0,0 +1,112 @@
+---
+name: firecrawl-interact
+description: |
+  Control and interact with a live browser session on any scraped page — click buttons, fill forms, navigate flows, and extract data using natural language prompts or code. Use when the user needs to interact with a webpage beyond simple scraping: logging into a site, submitting forms, clicking through pagination, handling infinite scroll, navigating multi-step checkout or wizard flows, or when a regular scrape failed because content is behind JavaScript interaction. Also useful for authenticated scraping via profiles. Triggers on "interact", "click", "fill out the form", "log in to", "sign in", "submit", "paginated", "next page", "infinite scroll", "interact with the page", "navigate to", "open a session", or "scrape failed".
+allowed-tools:
+  - Bash(firecrawl *)
+  - Bash(npx firecrawl *)
+---
+
+# firecrawl interact
+
+Interact with scraped pages in a live browser session. Scrape a page first, then use natural language prompts or code to click, fill forms, navigate, and extract data.
+
+## When to use
+
+- Content requires interaction: clicks, form fills, pagination, login
+- `scrape` failed because content is behind JavaScript interaction
+- You need to navigate a multi-step flow
+- Last resort in the [workflow escalation pattern](firecrawl-cli): search → scrape → map → crawl → **interact**
+- **Never use interact for web searches** — use `search` instead
+
+## Quick start
+
+```bash
+# 1. Scrape a page (scrape ID is saved automatically)
+firecrawl scrape "<url>"
+
+# 2. Interact with the page using natural language
+firecrawl interact --prompt "Click the login button"
+firecrawl interact --prompt "Fill in the email field with test@example.com"
+firecrawl interact --prompt "Extract the pricing table"
+
+# 3. Or use code for precise control
+firecrawl interact --code "agent-browser click @e5" --language bash
+firecrawl interact --code "agent-browser snapshot -i" --language bash
+
+# 4. Stop the session when done
+firecrawl interact stop
+```
+
+## Options
+
+| Option                | Description                                       |
+| --------------------- | ------------------------------------------------- |
+| `--prompt <text>`     | Natural language instruction (use this OR --code) |
+| `--code <code>`       | Code to execute in the browser session            |
+| `--language <lang>`   | Language for code: bash, python, node             |
+| `--timeout <seconds>` | Execution timeout (default: 30, max: 300)         |
+| `--scrape-id <id>`    | Target a specific scrape (default: last scrape)   |
+| `-o, --output <path>` | Output file path                                  |
+
+## Profiles
+
+Use `--profile` on the scrape to persist browser state (cookies, localStorage) across scrapes:
+
+```bash
+# Session 1: Login and save state
+firecrawl scrape "https://app.example.com/login" --profile my-app
+firecrawl interact --prompt "Fill in email with user@example.com and click login"
+
+# Session 2: Come back authenticated
+firecrawl scrape "https://app.example.com/dashboard" --profile my-app
+firecrawl interact --prompt "Extract the dashboard data"
+```
+
+Read-only reconnect (no writes to profile state):
+
+```bash
+firecrawl scrape "https://app.example.com" --profile my-app --no-save-changes
+```
+
+## Tips
+
+- Always scrape first — `interact` requires a scrape ID from a previous `firecrawl scrape` call
+- The scrape ID is saved automatically, so you don't need `--scrape-id` for subsequent interact calls
+- Use `firecrawl interact stop` to free resources when done
+- For parallel work, scrape multiple pages and interact with each using `--scrape-id`
+
+## See also
+
+- [firecrawl-scrape](../firecrawl-scrape/SKILL.md) — try scrape first, escalate to interact only when needed
+- [firecrawl-search](../firecrawl-search/SKILL.md) — for web searches (never use interact for searching)
+- [firecrawl-agent](../firecrawl-agent/SKILL.md) — AI-powered extraction (less manual control)
+## Trigger
+
+Use when the owner asks for this skill's described Firecrawl capability, when the current task needs web discovery/extraction/interaction beyond local files, or when a URL/query/data-extraction flow would otherwise be guessed from memory. Do not use for local repo edits unless the product code is explicitly integrating Firecrawl.
+
+## Workflow
+
+1. Classify the request as search, scrape, crawl, map, download, interact, clone, or product integration before taking action.
+2. Preserve the owner goal and scope: target URL/query, depth, output format, auth/profile needs, and what must not be touched.
+3. Use the real Firecrawl runtime/CLI/API path for the selected capability; do not fabricate page content, screenshots, links, or structured fields.
+4. Validate the result against the requested shape: markdown/content quality, URL coverage, schema fields, pagination/auth interaction, local files, or product integration behavior.
+5. If the result is incomplete, emit a redo contract: missing data, next Firecrawl action, re-test command/probe, and architect/ARIA console escalation if the same failure repeats.
+
+## 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/firecrawl-map/SKILL.md

@@ -0,0 +1,79 @@
+---
+name: firecrawl-map
+description: |
+  Discover and list all URLs on a website, with optional search filtering. Use this skill when the user wants to find a specific page on a large site, list all URLs, see the site structure, find where something is on a domain, or says "map the site", "find the URL for", "what pages are on", or "list all pages". Essential when the user knows which site but not which exact page.
+allowed-tools:
+  - Bash(firecrawl *)
+  - Bash(npx firecrawl *)
+---
+
+# firecrawl map
+
+Discover URLs on a site. Use `--search` to find a specific page within a large site.
+
+## When to use
+
+- You need to find a specific subpage on a large site
+- You want a list of all URLs on a site before scraping or crawling
+- Step 3 in the [workflow escalation pattern](firecrawl-cli): search → scrape → **map** → crawl → interact
+
+## Quick start
+
+```bash
+# Find a specific page on a large site
+firecrawl map "<url>" --search "authentication" -o .firecrawl/filtered.txt
+
+# Get all URLs
+firecrawl map "<url>" --limit 500 --json -o .firecrawl/urls.json
+```
+
+## Options
+
+| Option                            | Description                  |
+| --------------------------------- | ---------------------------- |
+| `--limit <n>`                     | Max number of URLs to return |
+| `--search <query>`                | Filter URLs by search query  |
+| `--sitemap <include\|skip\|only>` | Sitemap handling strategy    |
+| `--include-subdomains`            | Include subdomain URLs       |
+| `--json`                          | Output as JSON               |
+| `-o, --output <path>`             | Output file path             |
+
+## Tips
+
+- **Map + scrape is a common pattern**: use `map --search` to find the right URL, then `scrape` it.
+- Example: `map https://docs.example.com --search "auth"` → found `/docs/api/authentication` → `scrape` that URL.
+
+## See also
+
+- [firecrawl-scrape](../firecrawl-scrape/SKILL.md) — scrape the URLs you discover
+- [firecrawl-crawl](../firecrawl-crawl/SKILL.md) — bulk extract instead of map + scrape
+- [firecrawl-download](../firecrawl-download/SKILL.md) — download entire site (uses map internally)
+## Trigger
+
+Use when the owner asks for this skill's described Firecrawl capability, when the current task needs web discovery/extraction/interaction beyond local files, or when a URL/query/data-extraction flow would otherwise be guessed from memory. Do not use for local repo edits unless the product code is explicitly integrating Firecrawl.
+
+## Workflow
+
+1. Classify the request as search, scrape, crawl, map, download, interact, clone, or product integration before taking action.
+2. Preserve the owner goal and scope: target URL/query, depth, output format, auth/profile needs, and what must not be touched.
+3. Use the real Firecrawl runtime/CLI/API path for the selected capability; do not fabricate page content, screenshots, links, or structured fields.
+4. Validate the result against the requested shape: markdown/content quality, URL coverage, schema fields, pagination/auth interaction, local files, or product integration behavior.
+5. If the result is incomplete, emit a redo contract: missing data, next Firecrawl action, re-test command/probe, and architect/ARIA console escalation if the same failure repeats.
+
+## 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/firecrawl-scrape/SKILL.md

@@ -0,0 +1,97 @@
+---
+name: firecrawl-scrape
+description: |
+  Extract clean markdown from any URL, including JavaScript-rendered SPAs. Use this skill whenever the user provides a URL and wants its content, says "scrape", "grab", "fetch", "pull", "get the page", "extract from this URL", or "read this webpage". Handles JS-rendered pages, multiple concurrent URLs, and returns LLM-optimized markdown. Use this instead of WebFetch for any webpage content extraction.
+allowed-tools:
+  - Bash(firecrawl *)
+  - Bash(npx firecrawl *)
+---
+
+# firecrawl scrape
+
+Scrape one or more URLs. Returns clean, LLM-optimized markdown. Multiple URLs are scraped concurrently.
+
+## When to use
+
+- You have a specific URL and want its content
+- The page is static or JS-rendered (SPA)
+- Step 2 in the [workflow escalation pattern](firecrawl-cli): search → **scrape** → map → crawl → interact
+
+## Quick start
+
+```bash
+# Basic markdown extraction
+firecrawl scrape "<url>" -o .firecrawl/page.md
+
+# Main content only, no nav/footer
+firecrawl scrape "<url>" --only-main-content -o .firecrawl/page.md
+
+# Wait for JS to render, then scrape
+firecrawl scrape "<url>" --wait-for 3000 -o .firecrawl/page.md
+
+# Multiple URLs (each saved to .firecrawl/)
+firecrawl scrape https://example.com https://example.com/blog https://example.com/docs
+
+# Get markdown and links together
+firecrawl scrape "<url>" --format markdown,links -o .firecrawl/page.json
+
+# Ask a question about the page
+firecrawl scrape "https://example.com/pricing" --query "What is the enterprise plan price?"
+```
+
+## Options
+
+| Option                   | Description                                                      |
+| ------------------------ | ---------------------------------------------------------------- |
+| `-f, --format <formats>` | Output formats: markdown, html, rawHtml, links, screenshot, json |
+| `-Q, --query <prompt>`   | Ask a question about the page content (5 credits)                |
+| `-H`                     | Include HTTP headers in output                                   |
+| `--only-main-content`    | Strip nav, footer, sidebar — main content only                   |
+| `--wait-for <ms>`        | Wait for JS rendering before scraping                            |
+| `--include-tags <tags>`  | Only include these HTML tags                                     |
+| `--exclude-tags <tags>`  | Exclude these HTML tags                                          |
+| `-o, --output <path>`    | Output file path                                                 |
+
+## Tips
+
+- **Prefer plain scrape over `--query`.** Scrape to a file, then use `grep`, `head`, or read the markdown directly — you can search and reason over the full content yourself. Use `--query` only when you want a single targeted answer without saving the page (costs 5 extra credits).
+- **Try scrape before interact.** Scrape handles static pages and JS-rendered SPAs. Only escalate to `interact` when you need interaction (clicks, form fills, pagination).
+- Multiple URLs are scraped concurrently — check `firecrawl --status` for your concurrency limit.
+- Single format outputs raw content. Multiple formats (e.g., `--format markdown,links`) output JSON.
+- Always quote URLs — shell interprets `?` and `&` as special characters.
+- Naming convention: `.firecrawl/{site}-{path}.md`
+
+## See also
+
+- [firecrawl-search](../firecrawl-search/SKILL.md) — find pages when you don't have a URL
+- [firecrawl-interact](../firecrawl-interact/SKILL.md) — when scrape can't get the content, use `interact` to click, fill forms, etc.
+- [firecrawl-download](../firecrawl-download/SKILL.md) — bulk download an entire site to local files
+## Trigger
+
+Use when the owner asks for this skill's described Firecrawl capability, when the current task needs web discovery/extraction/interaction beyond local files, or when a URL/query/data-extraction flow would otherwise be guessed from memory. Do not use for local repo edits unless the product code is explicitly integrating Firecrawl.
+
+## Workflow
+
+1. Classify the request as search, scrape, crawl, map, download, interact, clone, or product integration before taking action.
+2. Preserve the owner goal and scope: target URL/query, depth, output format, auth/profile needs, and what must not be touched.
+3. Use the real Firecrawl runtime/CLI/API path for the selected capability; do not fabricate page content, screenshots, links, or structured fields.
+4. Validate the result against the requested shape: markdown/content quality, URL coverage, schema fields, pagination/auth interaction, local files, or product integration behavior.
+5. If the result is incomplete, emit a redo contract: missing data, next Firecrawl action, re-test command/probe, and architect/ARIA console escalation if the same failure repeats.
+
+## 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/firecrawl-search/SKILL.md

@@ -0,0 +1,88 @@
+---
+name: firecrawl-search
+description: |
+  Web search with full page content extraction. Use this skill whenever the user asks to search the web, find articles, research a topic, look something up, find recent news, discover sources, or says "search for", "find me", "look up", "what are people saying about", or "find articles about". Returns real search results with optional full-page markdown — not just snippets. Provides capabilities beyond Claude's built-in WebSearch.
+allowed-tools:
+  - Bash(firecrawl *)
+  - Bash(npx firecrawl *)
+---
+
+# firecrawl search
+
+Web search with optional content scraping. Returns search results as JSON, optionally with full page content.
+
+## When to use
+
+- You don't have a specific URL yet
+- You need to find pages, answer questions, or discover sources
+- First step in the [workflow escalation pattern](firecrawl-cli): search → scrape → map → crawl → interact
+
+## Quick start
+
+```bash
+# Basic search
+firecrawl search "your query" -o .firecrawl/result.json --json
+
+# Search and scrape full page content from results
+firecrawl search "your query" --scrape -o .firecrawl/scraped.json --json
+
+# News from the past day
+firecrawl search "your query" --sources news --tbs qdr:d -o .firecrawl/news.json --json
+```
+
+## Options
+
+| Option                               | Description                                   |
+| ------------------------------------ | --------------------------------------------- |
+| `--limit <n>`                        | Max number of results                         |
+| `--sources <web,images,news>`        | Source types to search                        |
+| `--categories <github,research,pdf>` | Filter by category                            |
+| `--tbs <qdr:h\|d\|w\|m\|y>`          | Time-based search filter                      |
+| `--location`                         | Location for search results                   |
+| `--country <code>`                   | Country code for search                       |
+| `--scrape`                           | Also scrape full page content for each result |
+| `--scrape-formats`                   | Formats when scraping (default: markdown)     |
+| `-o, --output <path>`                | Output file path                              |
+| `--json`                             | Output as JSON                                |
+
+## Tips
+
+- **`--scrape` fetches full content** — don't re-scrape URLs from search results. This saves credits and avoids redundant fetches.
+- Always write results to `.firecrawl/` with `-o` to avoid context window bloat.
+- Use `jq` to extract URLs or titles: `jq -r '.data.web[].url' .firecrawl/search.json`
+- Naming convention: `.firecrawl/search-{query}.json` or `.firecrawl/search-{query}-scraped.json`
+
+## See also
+
+- [firecrawl-scrape](../firecrawl-scrape/SKILL.md) — scrape a specific URL
+- [firecrawl-map](../firecrawl-map/SKILL.md) — discover URLs within a site
+- [firecrawl-crawl](../firecrawl-crawl/SKILL.md) — bulk extract from a site
+## Trigger
+
+Use when the owner asks for this skill's described Firecrawl capability, when the current task needs web discovery/extraction/interaction beyond local files, or when a URL/query/data-extraction flow would otherwise be guessed from memory. Do not use for local repo edits unless the product code is explicitly integrating Firecrawl.
+
+## Workflow
+
+1. Classify the request as search, scrape, crawl, map, download, interact, clone, or product integration before taking action.
+2. Preserve the owner goal and scope: target URL/query, depth, output format, auth/profile needs, and what must not be touched.
+3. Use the real Firecrawl runtime/CLI/API path for the selected capability; do not fabricate page content, screenshots, links, or structured fields.
+4. Validate the result against the requested shape: markdown/content quality, URL coverage, schema fields, pagination/auth interaction, local files, or product integration behavior.
+5. If the result is incomplete, emit a redo contract: missing data, next Firecrawl action, re-test command/probe, and architect/ARIA console escalation if the same failure repeats.
+
+## 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/fitrah-guard/SKILL.md

@@ -0,0 +1,78 @@
+---
+name: fitrah-guard
+description: Fitrah axiom guard. Trigger when a decision affects a person, trust, secrets, safety, dignity, truthfulness, evidence, readiness claims, guidance, user data, harmful advice, or honesty-vs-convenience tradeoffs. For full Aria axiom/first-principles work, also load aria-axioms-first-principles.
+---
+
+# Fitrah Guard
+
+Use this as the fast moral and epistemic veto before action. For Aria/Harness work, load `aria-axioms-first-principles` too; that skill contains the fuller source-trust map, first-class coach principles, runtime subset distinction, and harness first_principle binding.
+
+## The 10 Immutable Axioms
+
+1. `truth_over_deception`: truth is always preferable to comfortable deception.
+2. `no_harm`: harm to a person supersedes business advantage, speed, aesthetics, or convenience.
+3. `sacred_trust`: the one who trusts you holds a sacred contract; never betray it.
+4. `dignity`: every being deserves dignity in interaction.
+5. `power_obligates_service`: the more capable, the more responsible.
+6. `reflection_before_action`: action without reflection is reckless; reflection without action is paralysis.
+7. `correlation_not_causation`: correlation must never be presented as causation without evidence.
+8. `admit_ignorance`: "I do not know" is better than confident fabrication.
+9. `experience_hierarchy`: first-hand evidence outranks second-hand report, which outranks speculation.
+10. `trust_tradeoff`: short-term loss for long-term trust is the right trade.
+
+## Fast Check
+
+Before significant action:
+
+1. State the intended action.
+2. Ask who or what could be harmed, misled, exposed, pressured, or deprived of agency.
+3. Ask what evidence is first-hand, second-hand, or speculation.
+4. Ask whether a short-term gain is eroding long-term trust.
+5. If any axiom is violated, stop or reframe.
+
+## Vetoes
+
+Reject or reframe when:
+
+- A claim is more confident than the evidence.
+- A secret, private tag, credential, or trusted substrate could leak.
+- A destructive or irreversible action lacks explicit authorization and recovery posture.
+- A person is treated as a means rather than a beneficiary.
+- A correlation is being sold as a cause.
+- The answer pretends certainty instead of checking.
+
+## Output
+
+Keep the visible result practical:
+
+- `veto`: the action cannot proceed as stated.
+- `reframe`: safer truthful alternative.
+- `evidence_needed`: the one direct check that would change the status.
+- `proceed`: the action aligns with the axioms and has adequate evidence.
+
+## 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/forge-quality-rules/SKILL.md

@@ -0,0 +1,61 @@
+---
+name: forge-quality-rules
+description: TRIGGER when building, repairing, or reviewing forge or Aria implementation where stubs, placeholders, fake cognition, cosmetic fixes, or unverified completion would be a failure. Use during implementation, debugging, and code review.
+---
+
+# Forge Quality Rules
+
+Use this when the task needs a sharper quality bar than "it compiles" or "it kind of works".
+
+## Non-Negotiable
+
+- no stubs
+- no placeholders
+- no fake fallbacks presented as fixes
+- no surface heuristics pretending to be real cognition or validation
+- no completion claim without evidence
+
+## Required Workflow
+
+1. inspect actual state
+2. implement a real fix
+3. run a brief quality pass across engineering plus any relevant non-engineering domains
+4. verify behavior with evidence
+5. distill one reusable lesson or principle
+6. only then close the task
+
+## Quality Pass Questions
+
+- what does this artifact do now, not in theory?
+- where could it silently fail?
+- what user, business, design, or operational cost does it introduce?
+- is the result understandable, not just technically functional?
+
+## Output
+
+- call out cosmetic or fake fixes directly
+- if the root cause is still open, say the issue is not actually fixed
+- keep the final quality summary readable, not a cognition dump
+
+## References
+
+- [../aria-forge-guardrails/references/checklist.md](../aria-forge-guardrails/references/checklist.md)
+- [../aria-essence/references/evolution-loop.md](../aria-essence/references/evolution-loop.md)
+
+## 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/ghazali-8lens/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: ghazali-8lens
+description: Use when validating the quality, coherence, trustworthiness, or downstream consequences of a plan, implementation, design, decision, or explanation through a stronger multi-lens review.
+---
+
+# Ghazali 8-Lens
+
+Use this as a validation pass when a normal quick check would miss second-order problems.
+
+## The Eight Lenses
+
+1. Truth
+2. Harm
+3. Trust
+4. Power
+5. Reflection
+6. Context
+7. Impact
+8. Beauty
+
+## Workflow
+
+1. Name the artifact under review.
+2. Run all eight lenses.
+3. Mark each lens as pass, concern, or fail.
+4. Fix the artifact where a lens materially fails.
+5. Report only the lenses that changed the result or remain risky.
+
+## Rules
+
+- This is a validator, not a substitute for execution or verification.
+- Keep the lens output compact and readable.
+- If all eight pass but the artifact still lacks evidence, it is not done.
+
+## References
+
+- Use [../aria-essence/references/readable-cognition.md](../aria-essence/references/readable-cognition.md) for readable user-facing summaries.
+- Use [../aria-essence/references/evolution-loop.md](../aria-essence/references/evolution-loop.md) when the review yields a reusable principle.
+
+## 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/ijtihad-novel/SKILL.md

@@ -0,0 +1,42 @@
+---
+name: ijtihad-novel
+description: Use when the problem is genuinely novel, precedent is weak, standard patterns do not fit, or an architecture or policy decision must be reasoned from principles rather than copied from examples.
+---
+
+# Ijtihad Novel
+
+Read `/home/hamzaibrahim1/.claude/skills/ijtihad-novel.md` for the full novel-reasoning posture.
+
+Workflow:
+
+1. State why the problem is actually novel and where precedent fails.
+2. Load the source doc and reason from principles rather than cargo-culted patterns.
+3. Mark assumptions clearly and distinguish them from observed facts.
+4. Pair with `tadabbur` and `fitrah-guard` when the decision has downstream or moral consequences.
+
+## 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.