maos

Concierge / health-check / inventory / router for the operator's **9Router** gateway (local OpenAI-compatible AI gateway). Knows real ports, DB paths, comboStrategies SSOT, logs-in-SQLite, and combo taxonomy (leaf · eco · mega · council). Use to ASK anything about 9Router, run health/inventory, find combos/strategies, audit gaps, or route to the right fix surface. Never invents endpoints; capability-detects first (Mente Tomé). Modes: explain · health · inventory · guide · audit · dashboard.

Analyze tasks and recommend optimal sub-agent(s) for execution

Use when about to spawn a subagent/skill/task (Task tool, Agent tool, /command). Defines 6 decision criteria (decomposable/specialist-exists/audit-capacity/score≥MEDIUM/not-HUMAN-DOMAIN/time-budget), 11 mandatory briefing components (context/scope/motivation/purpose/objective/DoR/DoD/deliverables/feedback-loops/constraints/channel-fallback-chain), accountability preservation (parent NEVER delegates accountability — only execution; "delegating does not waive the responsibility received"), recursion ≤2, parallel ≤3. Harmonizes the agentic-inheritance principle (tree-returns-to-root · subordinate-is-parent's-full-responsibility · audit-output · zero-drift). Cross-vendor AAIF.

Generic, vendor-neutral session-observability engine (ASH — Agentic Session Harness). Per-session journals capturing goal · tasks · decisions[] · sources · transcript_hash, plus a decision-audit (why the agent decided X, spec_alignment drift). Ships CLIs (agentic-walkthrough timeline · agentic-decisions audit report · agentic-decide capture · agentic-reindex backfill) + SessionStart/Stop hooks. Use when you need an auditable record of what an agent did and WHY across sessions. Promoted from a host product 2026-06-02 (Layer-1 community engine).

Use when you need to evaluate, test, score, benchmark, or QA an agentic-tool (a skill/SKILL.md, agent, subagent, slash-command, prompt, or MCP-tool) — e.g. "is this skill any good?", "does this skill actually trigger?", "test this agent", "did my edit regress the skill?", "compare these two skill versions", "score this command". Produces a behavioral eval report; does NOT author or modify the tool.

Use when you want to turn a raw intent/instruction into a REUSABLE agentic-tool — e.g. "turn this into a skill", "forge an agentic-tool for X", "make this a recurring command/agent", "convert these instructions into a tool", "criar um agentic-tool para …", "research then build the best tool for …". Researches pre-existing internal + external solutions FIRST (DRY), decides the OPTIMAL artifact TYPE among {prompt · skill · command · agent/subagent · mcp · plugin · marketplace · rule/hook}, names it (delegating to `anima` when present, else 5-axis inline fallback), makes it AI-agnostic + multi-agentic, then forges + saves it (operator-confirmed). The genesis stage of the agentic-tool lifecycle (forge → evaluate → train → operate → deprecate). Hands off to agentic-tool-evaluator + -trainer. Cross-vendor AAIF (Claude / Cursor / Codex / Copilot / Gemini / Aider).

Use when you have a CANDIDATE tool that already exists (an external repo/MCP/plugin/skill someone found, e.g. from a GitHub trend or a YouTube review — OR an internal proposal) and need to decide whether and HOW to take it on. Triggers — "should I adopt this tool?", "is X worth installing?", "vet/appraise this repo/MCP for us", "should we install or build our own?", "does this conflict with what we already have?", "intake this candidate", "avalie se vale adotar X", "instalar ou criar?". It runs the adoption-decision pipeline (understand → research similars → compare/cross → validate viability → DECIDE among install/create-internally/absorb/adapt/sub-agent/abandon/defer-HITL) and, only when the verdict is INSTALL and the operator says GO, delegates a governed install. It does NOT create a tool from a bare intent (→ agentic-tool-forge), score an already-owned tool (→ agentic-tool-evaluator), or improve one (→ agentic-tool-trainer). A thin composer — it reimplements none of those; it decides.

Conductor of the agentic-tool lifecycle — given ANY --source-object (intent · url · plugin · marketplace · path to an existing tool), ROUTE it to the right family member and run the divergent→convergent pass: analyze → research similars → compare → critique → DEBATE → CONVERGE → validate → improve → HARMONIZE → then forge/adopt/improve one+ agentic-tools of any --type and SAVE to --location (akasha · multi-agent-os · vek-ai-toolkit). A thin preset that COMPOSES existing primitives (agentic-tool-forge/ intake/evaluator/trainer · anima · converge · perspective-trio) — reimplements nothing; applies + passes 11 principles (DRY · KISS · SSOT · YAGNI · anti-over-eng · anti-theater · boy-scout · DNA-geracional · continuity · idempotency · handoff). Use when ANY source should become the right agentic-tool in one governed pass. Triggers: "agentic-tool-pipeline", "forge a tool from this url/plugin/intent", "turn any source into the right agentic-tool", "route to the agentic-tool lifecycle".

Use when you want to improve, tune, coach, or evolve an existing agentic-tool (skill/agent/subagent/command/prompt/MCP-tool) based on its eval results — OR distill a brand-new tool from an observed human↔agent task ("turn what we just did into a skill", "make a skill from this session", "this skill underperforms, improve it", "track my corrections and patch the tool", "compare version performance over time"). Consumes eval reports; hands finalized authoring back to skill-writer/forge.

Generate ONE precise name/identifier for anything (files, modules, DBs, agentic-tools, brands, media, prompts). Triggers: "name this X", "batize isto", "qual o melhor nome", "how should I name", "sugira um nome", "rename", "what should I call". Researches first, classifies register (machine/agent/human), scores 12 correctness + 4 resonance aspects, returns a single decided name + rationale + runner-up — not a menu. NOT for bulk rename sets (maos:naming-organizer) or forging tools (agentic-tool-forge delegates naming here). Cross-vendor AAIF.

Prevent file conflicts between multiple AI agents working in parallel

On-demand audit and analysis of agent orchestration flows via Sentinel Protocol

Autonomous unattended orchestration entry point. Delegates an entire operator goal across one or more sub-agents using the existing GaaS/GaaC delegation framework, with hard-bounded autonomy levels and depth-capped recursion. Use when the operator wants the assistant to drive a multi-step goal without per-step approval, while still respecting Sentinel anomaly thresholds, Anti-Conflict worktree discipline, and the 6-attempt escalation rule. Triggers: "auto-pilot", "unattended orchestration", "delegate the whole goal", "run autonomously", "drive this end to end", "piloto automático".

Use when an agent needs to WAIT for a Bitbucket Cloud pipeline/build to finish and act on the outcome — instead of fixed-interval polling. Backgrounds a poll-until-done loop that exits the instant the build COMPLETES, so the harness re-invokes the agent on the real event; on FAILURE it returns the redacted failure diagnosis (failed steps + error-relevant log tail) already baked in. Pairs with the maos-mcp-hub atlassian_bitbucket gateway.

Operator-facing work-focus conductor — the human twin of the agent-facing reactivate/Entelecheia. ONE front-door answering "what should I focus on now? who asked me for what, by when? any loose ends?" GATHERS all scattered work (delegates work-compass), PRIORITIZES it (delegates pulse's Eisenhower 2x2; optionally ops-strategist's 4-lens if present), SURFACES a people-ask view (who / when / by-when) over existing tracker fields, and PRESENTS one operator briefing. Composes the existing family; reimplements nothing. Read-only by default; on-demand only (MAOS stays sole conductor). Soul-name: Oikonomos (the classical household steward). Triggers: "chief of staff", "keep me on track", "keep me focused", "what should I focus on", "my priorities", "what's on my plate", "who asked me for what", "o que devo focar", "me mantenha no foco", "minhas prioridades", "second brain".

Concierge / onboarding / router / docs-researcher / guarded-operator for the CLAUDE-CODE PLATFORM ITSELF — installing, configuring, using the CLI, manipulating agentic-tools (MCP, skill, command, agent/subagent, plugin, marketplace, hook, rule), choosing the best SCOPE [user, project, local, enterprise] and SOURCE [direct, plugin, marketplace, official], and — the core — researching the OFFICIAL+CURRENT Claude-Code docs AND each tool's own docs BEFORE acting. Use to LEARN or ONBOARD the platform, decide where+how to install/configure a tool, render a control-panel DASHBOARD, run a HEALTH-CHECK or SELF-TEST, or do a GUARDED install. It ROUTES + RESEARCHES + (guarded) OPERATES — never reimplements claude-code-guide (Q&A), find-docs, agentic-tool-forge, the lifecycle skills, or the sibling concierges; it orients and hands the exact reservation. Soul-name Cicerone. AAIF cross-vendor. NEVER fabricates a command (capability-detected or doc-sourced, else "not found").

Use when you need to RE-TARGET a piece of your own technical content for a DIFFERENT audience, abstraction level, intent, or language — then optionally render it in another format. E.g. "adapt this for the CEO", "turn my technical work into daily-standup talking points", "explain this migration to the PO", "re-target this for non-technical stakeholders", "traduzir este conteúdo técnico para leigos", "vira um pitch / deck / one-pager disto", "recast this for a junior dev". It DISTILLS the source faithfully, RECASTS it through a named strategy lens (Minto · Feynman · progressive-disclosure · detail-preserving), runs a FAITHFULNESS check (no unsupported claims) with an information-loss note, then hands off rendering to existing producers (markdown · slides · one-pager PDF · NotebookLM source/prompt). It re-targets COMMUNICATION; it does NOT re-engineer code/architecture (angular→flutter, monolith→microservices) — for that use refactor/migration agents. Cross-vendor AAIF.

Prepare optimal context package before delegating tasks to sub-agents

Converge ≥2 AI-agent proposals into one validated synthesis via a 5-act protocol (steelman → critique → compare → synthesize → reject-log). Vendor-neutral, single-session, general-purpose, AUDIT-not-PERSUASION discipline. Use when multiple agents (or multiple humans, or human+agent) produced competing proposals and a single consolidated artifact is needed with explicit provenance, rejected alternatives, audit chain, and impartial neutral framing safe for downstream evaluation. Triggers: "converge proposals", "merge agent outputs", "synthesize multiple AI responses", "compare and consolidate", "cross-agent arbitration", "reconcile conflicting recommendations".

Use to audit whether a governance corpus is ALIVE or THEATER — does each rule/memory/instruction actually FIRE at a live decision point, or is it present-but-dormant? Idempotent, read-only: scans a corpus (e.g. a user-scope rules dir + MEMORY/AGENTS/CLAUDE, or a repo's docs/governance) and classifies each artifact FIRING / DORMANT-OK / THEATER / STALE via an empirical grep-for-live-references test, kind-aware so reference docs and decision-records are not mistaken for theater. Detects re-learning (the symptom of non-firing) and proposes effectivation — sharpen an existing fire-point > add a new passive rule. NOT for testing a rule's self-validity (that is a rule-quality concern), triaging a directive braindump (use directive-braindump-triage), or measuring run-level SLIs (that is a separate observability concern).

Capture a non-trivial agent decision (with sources + rationale + spec-alignment) into the ASH decision-audit trail via `agentic-decide`, so it can later be audited with `agentic-decisions`. Use WHEN you make a decision that shapes the product/architecture/code AND that a reviewer might question later — especially any choice that touches a SPEC (BR/FR/NFR/ADR) or the manifesto, or that deviates from a prototype/spec. The operator's pain: AI agents drift from canonical SPECs and there is no way to ask "why did the agent decide that?". This skill closes the capture gap (agent reasoning is ephemeral — recorded only if written at decision-time). Cross-vendor AAIF (Bash + jq). Do NOT use for trivial actions (typos, formatting, read-only inspection) or for capturing OPERATOR directives (those are the ash Stop subagent's job — this is for the AGENT's own decisions).

Use when a task, DoR, DoD, metric, KPI, or acceptance criterion is ABSTRACT ("is this good / healthy / professional / beautiful / stylish / risky / inconclusive?") and an agent would otherwise GUESS a number. Decomposes the abstract construct into a recursive value-tree whose leaves are each directly measurable (D), typeable/observable (T), or bounded-calibrated-judgment (J), then a deterministic script rolls it up into score + band + confidence + sensitivity + an explicit "inconclusive → escalate" verdict. Turns a guess into a reproducible, auditable measurement-spec.

Emit the correct governance prompt (init / dna / finalize) before, during, and after delegating to a sub-agent. Use when delegating work, spawning sub-agents, running parallel agents, or planning a multi-agent task. Covers cross-provider (Jira / Linear / Bitbucket / GitHub / GitLab) and AI-provider agnostic.

MAOS-native deliberation-before-coding guardrail principles (L0 substrate, content-not-runtime). Use when an agent is about to write/modify code and needs the house discipline for HOW to approach the change: think-before-coding (state the problem, the constraint set, and at least one rejected alternative BEFORE the first edit), simplicity-first (the least mechanism that fully achieves the outcome — no speculative abstraction), surgical-changes (smallest reviewable diff; never opportunistic refactors inside a fix), and goal-driven execution (every edit traces to the stated goal; drift = stop and re-anchor). Apply at task start, before large diffs, during PDCA fix rounds, and whenever a review flags over-engineering or scope creep.

Use to triage an operator directive-braindump (a scratch of mixed directives, e.g. a prompt-aux / *.braindump.md) against the auto-loaded corpus (rules · memories · tickets) so a future amnesic agent executes ONLY the verified residual and never re-processes what is already done. Idempotent: recon-first → decompose into atomic directives → classify each DONE/OPEN/DROP-EXPLICIT/COVERED + the artifact that fulfills it → inter-dependency DAG → Eisenhower residual roadmap, emitted as a provenance ledger. Cures the re-learning anti-pattern: never re-execute an already-satisfied directive. NOT for auditing whether standing rules fire (use corpus-firing-audit — the firing/vitality axis) or for adopting an external tool (use agentic-tool-intake). Cross-vendor AAIF.

Count real dogfood cycles per agentic-tool (the ≥2-cycle promotion gate authority). Use to mark a dogfood cycle (in-progress / complete+ratified+evidence) or to tally how many real cycles a tool has before promotion. Replaces changelog-prose cycle counting with a structured, jq-countable, auditable ledger. Triggers - "how many dogfood cycles does X have", "mark this cycle complete", "is X promotion-eligible", "count cycles".

List unresolved pendencies for --scope=[current|session|repo|vault|all] ordered by Eisenhower matrix (Q1 urgent+important → Q4). Thin composer over work-compass (SSOT for aggregation) + Eisenhower classifier (urgent×important) + AAA rigor (Accuracy·Auditability·Accountability) under the Triple-AAA lens (Governance × Test × Production × Compliance). EXECUTABLE since v0.2.0: `bin/work-compass-aggregate.py --sort=Eisenhower --pendency-scope=<scope> --include=pending`. Use when operator wants "pendências --scope=current --sort=Eisenhower", "o que é pendente ordenado", "triple-A pendency list", "AAA queue".

Retrieves and queries up-to-date documentation and code examples from Context7 for any programming library or framework. Use when writing code that depends on external packages, verifying API signatures, looking up usage patterns, generating code with specific libraries, or when training data may be outdated.

Diagnose where an AI-native startup is in its lifecycle (Idea → MVP → Launch → Scale) and route to the right stage discipline. Provides the four-stage map, per-stage goals/exit-criteria/failure-modes, and a vendor-neutral product matrix (conversational-research / agentic-coding / workflow-automation, with Claude Chat/Code/Cowork as reference). Use when a founder asks "where am I", "what should I focus on now", "am I ready to move to the next stage", "how do AI-native startups work", or wants an overview of the whole journey. For deep work inside a single stage, this skill hands off to founder-stage-idea / -mvp / -launch / -scale.

Idea-stage discipline for an AI-native startup: validate that a real, specific, frequent problem exists — and that your solution addresses it — BEFORE writing any production code. Provides the problem-solution-fit exit gate, the signature failure modes (mistaking building for validating; "no competition" as advantage; surveys instead of interviews), and ready-to-use prompts for problem-hypothesis sharpening, competitive-landscape synthesis, and customer-discovery interviews. Use when a founder says "I have an idea", "should I build this", "validate my idea", "customer discovery", "is there a market", or "who are my competitors".

Launch-stage discipline for an AI-native startup: turn early traction into a repeatable, channel-driven growth engine and build the company around the product, so operations run WITHOUT the founder in every loop. Provides the 3-element exit gate (defensible CAC·LTV·payback; production-hardened; ops without founder bottleneck), the failure modes (technical debt comes due, founder-as-bottleneck, security/compliance no longer deferrable, expansion before ready), and exercises (architectural audit + remediation sequencing, attention/bottleneck audit, SOC 2 / GDPR / HIPAA compliance workstream, lightweight PM operating system). Use when a founder says "we launched", "scale our growth", "I'm the bottleneck", "tech debt", "SOC 2 / GDPR / HIPAA / compliance", or "set up sprints / processes".

MVP-stage discipline for an AI-native startup: turn a validated problem into the smallest focused product that real users actually use, while moving fast WITHOUT accruing compounding technical debt. Provides the product-market-fit exit gate (Sean Ellis ≥40% "very disappointed"; the pull-vs-push effort test), the failure modes (agentic tech debt, false PMF, zero-friction scope creep, insecure-by- inexperience), and emittable templates (architecture-context / CLAUDE.md, scope definition, pre-launch measurement framework, security-review brief, pivot diagnostic). Use when a founder says "build the MVP", "define architecture/scope", "do I have product-market fit", "security review", "set up metrics", or "should I pivot".

Scale-stage discipline for an AI-native startup: build systematic, mature-org growth and a defensible moat while keeping the lean AI-centered structural advantage. Provides the threshold exit gate (sustainable profitability / IPO-ready / acquisition), the failure modes (can't delegate the operating layer, scaling technical operations, scaling org functions, building a real GTM), and exercises (bottleneck map + week-away stress test, enterprise-infra gap analysis, GTM build, turning domain expertise into reusable Skills, data-moat narrative, workflow lock-in audit). Use when a founder says "we're scaling", "build a moat", "enterprise readiness / SLAs", "go-to-market / GTM", "delegate operations", or "defensibility".

Harness-agnostic, self-driven, self-scored condition-loop that drives a GAP-REGISTER (G1..Gn) to convergence — loops until [every gap dispositioned (fix | defer | accept-risk) AND agentic convergence AND autonomy_score >= 0.85]. Five phases: DoR -> RECAP (build the gap-register) -> RESOLVE (MoE diverge->converge per gap) -> VALIDATE (independent audit, experts != RESOLVE) -> PERSIST (decision-audit + reject-log + tickets + boy-scout). Defining novelty: expresses the loop DECLARATIVELY so the agent self-drives it in ANY harness (cowork / Code / SDK) — NO /goal dependency; an anti-gaming DERIVED score that names its binding constraint; a low-score -> rotate-the-MoE-roster re-loop (NOT HITL). Thin preset: composes pulse, perspective-trio, converge, persona-pipeline, cascade-resolver, convergence-engine, decision-capture — reimplements nothing. Triggers: "gap-loop", "goal-n-loop", "drive gaps to convergence", "harness-agnostic loop", "self-scored loop", "loop until converged".

Enforce hierarchical merge protocol - branches merge to parent, not directly to main

Use to apply Google-Analytics-style usage analytics to our OWN agentic-tools corpus — attribution (how was a skill actually reached: a direct /command, an explicit Skill-tool call, or a referral/citation from another skill's own body), recency+frequency+retention (RFM-lite: is usage a one-shot burst or sticky repeat-usage over distinct days), trend (this window vs the prior window), and funnel drop-off across known multi-step lifecycle chains (e.g. forge -> evaluate -> train). Composes corpus-firing-audit's log sources and NEVER re-implements its binary FIRING/DORMANT classification — Ichnos answers a different question ("how is it found and used, over time?") that a snapshot count cannot. Triggers - "apply GA principles to our tools", "usage analytics for our skills", "which tools are sticky vs one-shot", "why is X dormant: attribution/awareness/discoverability?", "funnel for the forge/quiesce lifecycle", "traffic/attention across our agentic-tools".

Deterministic dispatcher of cognitive lens-stacks per work-graph node. Given a node (ticket/task/step/decision/pr/session) it emits one of three verdicts — DISPATCH (embody this lens-stack), NULL_PROFILE (embody NO lens), INCONCLUSIVE (fail-safe) — computed OUTSIDE the model so an agent cannot pick its own cognitive lens by vibe. Third orthogonal axis of an existing family: `response-compression` controls WHAT is said (verbosity), `slm-routing` controls WHERE it is sent (compute target), this controls HOW it is thought. Confidence is COMPUTED from the dogfood ledger, never hardcoded — which means faithful to that ledger, NOT unfalsifiable. NO lens-stack here has a measured efficacy result — read the epistemic-status block before relying on it. Four independent adversarial red-team rounds have REFUTED every version so far (v0.1.0-v0.4.0), each finding defects in the previous round's fix; v0.5.0 carries the fourth round's repair and is NOT yet cleared.

Use when creating, updating, superseding, archiving, reading, searching, or walking the persistent memory corpus. The ONE crash-safe writer to memory — route every memory mutation through it instead of editing topic files directly, so identity-dedup, atomic forgetting (supersede archives the old fact in the same op), and write-ahead crash recovery are guaranteed.

Deterministic SitRep briefing of operator work state (repos/PRs/tasks/memory) for fast context restore. Default 7 sections: state, done, in-flight, blockers, decisions-awaiting, risks, next-action. Recap mode (--mode=recap): N-Tree objectives, % done/PRs/convergence, gaps, pendings, unasked/unanswered Qs, undecided decisions, HITL, Eisenhower 2x2, DAG, blockers. Triggers: "morning briefing", "bom dia retomando", "where was I", "state recap", "session recap", "end of session recap". Cold-start OK (unlike /context-restore). Cross-vendor AAIF.

Synthesize Mission, Vision, Values from ontological analysis output

Route NotebookLM work between the notebooklm-py CLI, the notebooklm-mcp-cli MCP server, and the `@notebooklm-mcp` Claude Code toggle. Use when ingesting sources, generating podcasts/reports, or syncing docs into a notebook, and when deciding which client and which account (personal/work) to use.

Concierge / health-check / inventory / router for the operator's **OmniRoute** gateway (v3.8+ local AI proxy). Knows real port, storage.sqlite schema, strategy enum (19 values), fusion/judgeModel, provider_connections, and parity with 9Router SSOT. Use to ASK anything about OmniRoute, run health/inventory, audit combo/strategy gaps, plan strategy heal from 9Router, or route ops. Never invents routes; capability-detects first (Mente Tomé). Modes: explain · health · inventory · guide · audit · heal-parity · dashboard.

Analyze repository through 8 philosophical dimensions for MVV extraction

Run a profile-aware, bounded delivery loop when work arrives through chat, ticket, backlog, specification, PR, hook, webhook, bootstrap or prototype. Classify the trigger, recover the goal, derive a measurable DoD, choose the smallest evidence-ready lifecycle stage, and drive it through outer OODA plus inner PDCA using existing goal-recovery, Prisma, Hodos, gap-loop and quiesce primitives. Use for "implement end to end", "technical work is delegated", "recover then converge", or "ooda-loop". Triggers and operator profiles never grant authority; hard boundaries, independent verification, budgets, plateau stops and irreducible business/access HITL remain.

Use when you want to deliver a session/work recap as a FAITHFUL, dosed NARRATIVE — a "summary as an opera": a short story-arc (acts) with measured humour, situational (never personal) wit, instigating-but-not-alarming drama, a call-to-action, the key insights, and a closing moral — for a HUMAN; or a structured consolidated payload for an AGENT. Triggers: "resumo da ópera", "summary as an opera", "narrate this session", "give me the story of what we did", "recap with a bit of flair", "debrief com pegada narrativa", "tell the tale of this work". It does NOT re-summarize — it CONSUMES an existing session map (from `postflight` P2-DEBRIEF / `morning-briefing --mode=recap`) and re-casts it through the named OPERA REGISTER, then runs a FAITHFULNESS gate (every beat traces to a real fact; no invented drama) + a TONE-SAFETY gate (no alarm; wit never aimed at a person). It is the narrative-warm register member of the content/recap family — a specialised, dosed sibling of `content-recast`. Cross-vendor AAIF.

Use when operator says "salva isto", "tome nota", "remember this", "from now on", "capture this rule/tip", OR when detecting substantive operator quote with signal (imperative verb to agent / meta-statement about process / correction-refinement / multi-clause guidance with exception). Applies §3.5 2-step filter (Analyze decompose → Validate 5 critérios), then persists to memory + framework refinements + index. Codifies the recurring pattern detected 5x in single bootstrap session (Triple-touch fired per v1.3.1 Recurring→Artifact reflex). Cross-vendor AAIF compatible.

Synchronous CI-time PII detection — CPF Modulo-11 (algorithmic checksum, not just regex), RFC 5322 email subset (catastrophic-backtracking-safe), E.164-BR phone — with allowlist for developer-artifact false-positives. Wires the `ai-governance-linter.yml` step that v1.0 declared with a placeholder comment but never implemented. Closes Gap G1 of the OS3PD manifesto v4.13.0 (Principle 6 — Respect Wildlife). Output: structured records with masked excerpts; raw PII never appears in any log line.

Self-referential session-method audit — turn the firing/theater lens onto THIS session's OWN enacted methods/tools (not the standing governance corpus, not the produced result). Per method: FIRED-WELL / THEATER / INCONSISTENT / MISFIRE / GAP, then RESEARCH better methods, COUNCIL-converge (verifier>generator; red-team the verdict), and FIX (gap-loop, worktree-disciplined). Composes existing primitives (corpus-firing-audit lens, enhance-pipeline, convergence-engine + its council seats, gap-loop) — reimplements nothing; read-only through COUNCIL. Use when ending or mid a substantive session, to ask "were our METHODS sound or did we perform ceremony?" before trusting its conclusions; or on a recurring smell that a gate/recon/council/ verifier was invoked but hollow. Triggers: "praxis-audit", "audit this session's own methods/tools", "did our tools fire or was it theater", "self-audit the methods we used", "find gaps/theater in how this session worked".

Use at the start of a session or before starting an action/task in any git repo to get the workspace into a correct, healthy, isolated, ticket-anchored state BEFORE touching code: (R0) anchor the session to its ticket on the N-Tree + classify the session type, (R1) detect the right branch without interfering with other agents/sessions/worktrees, (R2) safely heal the current branch from origin, and (R3) create a git worktree the moment you are about to create/update files. Reads whatever governance is present at invocation (CLAUDE/AGENTS/CONTRIBUTING/README/ protocols/memories) and adapts.

Use when FINALIZING any text artifact — a doc / ADR / README / ticket body / PR description / commit message / release note — to check GRAMMAR (pt-BR + en-US), TYPOS, and MIS-FORMATTING before it ships. For the THOROUGH tier, run cspell (the workhorse — it flags novel typos like "Aurona" that grep and codespell miss) + LanguageTool (grammar/concordância/acentos/spelling, LOCAL — never a public API) + markdownlint-cli2 (structure), and offer an optional Grammar-Genie rewrite for tone. Compose the deterministic linters with the probabilistic rewrite (ECE pattern); do not build a new engine. Report issues with file:line + fix suggestions; apply fixes only with confirmation. SKIP for trivial/throwaway text. Triggers: "proofread this", "revise / check grammar", "revisar gramática / ortografia", "find typos", "antes de commitar revise o texto", "is this text clean", "lint this doc", "check spelling pt-BR", "/proofread".