imhcode 1.0.0

package/skills/homelab-network-setup/SKILL.md

@@ -0,0 +1,129 @@
+---
+name: homelab-network-setup
+description: Practical home and homelab network planning for gateways, switches, access points, IP ranges, DHCP reservations, DNS, cabling, and common beginner mistakes.
+origin: community
+---
+
+# Homelab Network Setup
+
+Use this skill to design a home or small-lab network that can grow without
+needing a full rebuild.
+
+## When to Use
+
+- Planning a new home network or redesigning an ISP-router-only setup.
+- Choosing gateway, switch, and access point roles.
+- Designing IP ranges, DHCP scopes, static reservations, and DNS.
+- Preparing for future VLANs, Pi-hole, NAS, lab servers, or VPN access.
+- Troubleshooting a new network that has double NAT, unstable Wi-Fi, or changing
+  server addresses.
+
+## How It Works
+
+Start by separating device roles:
+
+```text
+Internet
+  |
+Modem or ONT
+  |
+Gateway or router      NAT, firewall, DHCP, DNS, inter-VLAN routing
+  |
+Managed switch         wired clients, AP uplinks, optional VLAN trunks
+  |
+Access points          Wi-Fi only; ideally wired backhaul
+Servers and NAS        stable addresses, DNS names, monitoring
+Clients and IoT        DHCP pools, isolated later if VLANs are available
+```
+
+Pick a gateway that matches the operator, not just the feature checklist:
+
+| Option | Best fit | Notes |
+| --- | --- | --- |
+| ISP router | Basic internet only | Limited control and often poor VLAN support |
+| UniFi gateway | Managed home network | Good UI, ecosystem lock-in |
+| OPNsense or pfSense | Flexible homelab | Strong VLAN, firewall, VPN, and DNS control |
+| MikroTik | Advanced network users | Powerful, but easy to misconfigure |
+| Linux router | Tinkerers | Document rollback before using as primary gateway |
+
+## IP Plan
+
+Avoid the most common default, `192.168.1.0/24`, when you expect to use VPNs.
+It often conflicts with hotels, offices, and ISP routers.
+
+```text
+Example small homelab plan:
+
+192.168.10.0/24  trusted clients
+192.168.20.0/24  IoT and media devices
+192.168.30.0/24  servers and NAS
+192.168.40.0/24  guest Wi-Fi
+192.168.99.0/24  network management
+
+Gateway convention: .1
+Infrastructure reservations: .2 through .49
+Dynamic DHCP pool: .50 through .240
+Spare room: .241 through .254
+```
+
+Use `home.arpa` for local names. It is reserved for home networks and avoids the
+leakage/conflict problems of ad hoc names like `home.lan`.
+
+```text
+nas.home.arpa
+pihole.home.arpa
+gateway.home.arpa
+switch-01.home.arpa
+```
+
+## DHCP And DNS
+
+- Use DHCP reservations for anything you SSH into, bookmark, monitor, or expose
+  as a service.
+- Hand out the gateway as DNS until a local resolver is intentionally deployed.
+- If using Pi-hole or another DNS filter, give it a reservation first, then point
+  DHCP DNS options at that address.
+- Keep a small static/reserved range per subnet so replacements do not collide
+  with dynamic leases.
+
+## Cabling And Wi-Fi
+
+- Prefer wired AP backhaul over mesh when you can run Ethernet.
+- Use a PoE switch for APs and cameras if the budget allows it.
+- Label both ends of each cable and keep a simple port map.
+- Put the gateway, switch, DNS server, and NAS on UPS power if outages are common.
+
+## Examples
+
+### Beginner Upgrade
+
+Goal: Keep the ISP router but stabilize a small lab.
+
+1. Set DHCP reservations for NAS, Pi, and any SSH hosts.
+2. Move local names to `home.arpa`.
+3. Disable duplicate DHCP servers on secondary routers or APs.
+4. Wire the main AP instead of relying on wireless backhaul.
+
+### VLAN-Ready Plan
+
+Goal: Prepare for future segmentation without enabling it immediately.
+
+1. Choose non-overlapping /24 ranges for trusted, IoT, servers, guest, and
+   management.
+2. Reserve .1 for the gateway and .2-.49 for infrastructure on every subnet.
+3. Buy a gateway and switch that support VLANs and inter-VLAN firewall rules.
+4. Document which SSIDs and switch ports will eventually map to each network.
+
+## Anti-Patterns
+
+- Double NAT without a reason or documentation.
+- Using `192.168.1.0/24` when VPN access is planned.
+- Dynamic addresses for NAS, Pi-hole, Home Assistant, or other service hosts.
+- Consumer routers repurposed as APs while their DHCP servers are still enabled.
+- Flat networks with cameras, smart plugs, laptops, and servers all sharing the
+  same trust boundary.
+
+## See Also
+
+- Skill: `network-interface-health`
+- Skill: `network-config-validation`

package/skills/imhcode/SKILL.md

@@ -0,0 +1,183 @@
+---
+name: imhcode
+description: "IMH-Code — Imam Hussain Coding Harness Platform. Multi-agent orchestrated framework for fast-first SaaS development. Specialized in Next.js + Laravel + PostgreSQL stack. Supports model routing, smart skill loading, and configurable testing modes (fast, balanced, strict)."
+---
+
+# IMH-Code — AI Agency Orchestrator
+
+<HARD-GATE>
+You MUST NOT write ANY code, scaffold ANY project, create ANY component, or take ANY implementation action until:
+1. Phase 1 (Write & Plan) is complete — \`PROJECT_BRIEF.md\` exists and is approved by the user.
+2. Phase 2 (Brainstorm) is complete — \`docs/brainstorming.md\` has been reviewed and answered.
+3. Phase 3 (Sprint Plan) is complete — \`docs/sprint-N/plan.md\` and \`docs/sprint-N/progress.md\` exist.
+4. You are executing Phase 4 with the correct executor agent dispatched and their skill bindings loaded.
+
+If the user says "build X" or "create X" — you start with Phase 1. NO EXCEPTIONS.
+</HARD-GATE>
+
+## Overview
+
+IMH-Code is a production-grade multi-agent orchestration framework specialized for **SaaS development** using the **Next.js + Laravel + PostgreSQL** stack. It replaces monolithic prompts with a **6-Phase Pipeline** where specialized generic role-based agents (each with curated skill packs) are dispatched to complete specific tasks.
+
+As the orchestrator (Planner), your job is to guide the user through this pipeline — **in order, with no skipping**.
+
+---
+
+## Context Recovery Protocol (MANDATORY for Non-Fresh-Start Requests)
+
+<HARD-GATE>
+When the user says "continue", "resume", "keep going", "continue development", or ANY variant that implies work-in-progress — you MUST NOT start planning or coding immediately.
+
+Instead, follow this EXACT recovery sequence:
+
+### Step 1: Read Context Files
+
+Read these files IN ORDER. If a file doesn't exist, note it as MISSING:
+
+1. \`PROJECT_BRIEF.md\` — What is the project? What sprint are we on?
+2. \`docs/sprint-N/plan.md\` — What are the tasks for the current sprint?
+3. \`docs/sprint-N/progress.md\` — Which tasks are done? Which are in progress?
+4. \`.imhcode/context.md\` — Compact context summary
+
+### Step 2: Determine Current Phase
+
+Based on what exists and what's missing, determine the current phase:
+
+| If this is true...                                       | You are in... | Next action                                 |
+| -------------------------------------------------------- | ------------- | ------------------------------------------- |
+| No \`PROJECT_BRIEF.md\`                                    | Phase 1       | Run plan command to generate brainstorming  |
+| \`PROJECT_BRIEF.md\` exists but no \`docs/sprint-N/plan.md\` | Phase 3       | Run plan command to generate sprint plan    |
+| \`plan.md\` exists but tasks are ⬜/🔨 in \`progress.md\`    | Phase 4       | Continue execute command from next task    |
+| All tasks ✅/⏭️ but no final testing reports             | Phase 5       | Run test command to execute test sprint     |
+
+### Step 3: Run Document Existence Check
+
+Before doing ANYTHING else, verify ALL mandatory documents exist for the current sprint.
+Print this checklist with ✅ or ❌ for each:
+
+\`\`\`
+═══════════════════════════════════════════
+  DOCUMENT EXISTENCE CHECK — Sprint N
+  [ ] PROJECT_BRIEF.md
+  [ ] docs/sprint-N/plan.md
+  [ ] docs/sprint-N/progress.md
+  [ ] docs/sprint-N/deferred.md
+  [ ] .imhcode/context.md
+  [ ] imhcode.config.json
+═══════════════════════════════════════════
+\`\`\`
+
+If ANY document is ❌ MISSING, CREATE IT NOW before proceeding to execution.
+
+### Step 4: Report Status to User
+
+Tell the user:
+- What phase you're in
+- What's done so far
+- What's next
+- Any missing documents you just created
+
+Then proceed.
+</HARD-GATE>
+
+---
+
+## The 6-Phase Pipeline
+
+### Phase 1: Write
+User writes their initial prompt or problem description inside \`docs/start.md\`.
+
+### Phase 2: Plan (brainstorming generation)
+Run \`imhcode plan\`. The planner agent reads \`docs/start.md\` and generates \`docs/brainstorming.md\` containing:
+- Categorized questions about the frontend, backend, deployment, and stack.
+- Smart auto-recommended answers based on keywords in the prompt.
+- Testing strategy options: Fast (default), Balanced, or Strict TDD.
+
+### Phase 3: Brainstorm (answering questions)
+The user reviews \`docs/brainstorming.md\` and modifies any recommended answers if needed. Once done, the user runs \`imhcode plan\` again.
+
+### Phase 4: Sprint Planning (sprint generation)
+The planner agent reads the completed \`docs/brainstorming.md\`, writes configurations (like \`testing_mode\`) to \`imhcode.config.json\`, generates \`PROJECT_BRIEF.md\`, and generates all sprints:
+- \`docs/sprint-N/plan.md\`
+- \`docs/sprint-N/progress.md\`
+- \`docs/sprint-N/deferred.md\`
+- \`docs/sprint-N/tasks/task_*.sh\`
+- If Fast or Balanced mode was selected, a final testing sprint is automatically appended to the roadmap.
+
+### Phase 5: Execution
+Run \`imhcode execute N\`. This runs the task execution harness sequentially. Each task is executed by the appropriate executor agent (e.g., \`nextjs-executor\`, \`laravel-executor\`).
+- **Smart Skill Loading**: The agent only loads core skills (3-5 max). Extended skills are matched on-demand based on keywords in the task description.
+- **Compact Context**: The agent reads \`.imhcode/context.md\` instead of raw files to save tokens.
+- **Model Routing**: The agent uses the routed model from \`imhcode.config.json\`'s \`model_routing\` based on the agent's category.
+
+### Phase 6: Testing & Audit
+Run \`imhcode test\` to run the final testing sprint:
+- Generates backend unit tests, frontend component tests, and E2E Playwright tests.
+- Performs security audit (OWASP Top 10) using \`security-auditor\`.
+- Performs SEO and accessibility audit using \`seo-optimizer\`.
+- Outputs final reports and coverage.
+
+---
+
+## Generic Agent Architecture (19 Agents)
+
+Instead of named persona agents, the framework uses 19 generic, role-based agents. When executing a task, check \`imhcode.config.json\` model routing for model mapping.
+
+| ID | Role | Category | Core Skills |
+|---|---|---|---|
+| \`planner\` | Project Planner & Coordinator | planning | imhcode, imhcode-brainstorm, imhcode-sprint-planner |
+| \`designer\` | UX/UI Designer | frontend | frontend-design, ui-ux-pro-max, modern-web-design |
+| \`nextjs-executor\` | Next.js Full-Stack | frontend | nextjs-turbopack, shadcn-ui, tailwindcss-v4 |
+| \`react-executor\` | React/Vite SPA | frontend | vite-patterns, frontend-design |
+| \`vue-executor\` | Vue/Nuxt | frontend | vue3-composition, nuxt4-patterns |
+| \`laravel-executor\` | Laravel Full-Stack | backend | laravel-patterns, backend-patterns |
+| \`python-executor\` | Python/FastAPI/Django | backend | python-patterns, fastapi-patterns |
+| \`java-executor\` | Java/Spring Boot | backend | java-patterns, springboot-patterns |
+| \`flutter-executor\` | Flutter/Dart Mobile | backend | dart-flutter-patterns |
+| \`react-native-executor\` | React Native/Expo | backend | react-native-best-practices |
+| \`ios-executor\` | iOS/SwiftUI | backend | swiftui-patterns |
+| \`android-executor\` | Android/Kotlin | backend | kotlin-patterns |
+| \`systems-executor\` | Systems (Go/Rust/C++) | backend | golang-patterns, rust-patterns |
+| \`web3-executor\` | Web3/Smart Contracts | backend | solidity-patterns |
+| \`tester\` | QA & Testing | testing | e2e-testing, webapp-testing |
+| \`security-auditor\` | Security Auditor | testing | imhcode-security, security-scan |
+| \`seo-optimizer\` | SEO & Content | review | seo, seo-growth |
+| \`devops-executor\` | DevOps & Deployment | backend | deployment-patterns, docker-patterns |
+| \`debugger\` | Debugging Agent | review | systematic-debugging, error-handling |
+
+---
+
+## Sub-Agent Dispatch Protocol
+
+When dispatching ANY agent during Phase 5 execution:
+
+\`\`\`
+1. Announce: "I am now acting as [Agent ID] ([Role]). Skills: [core skills] + matched [extended skills]"
+2. Read imhcode.config.json to identify routed model.
+3. Read .imhcode/context.md for project context.
+4. Execute using ONLY bound skills for the category.
+5. Drop persona: "Returning to Planner."
+\`\`\`
+
+---
+
+## Codebase Structure Rules (MANDATORY)
+
+<HARD-GATE>
+ALL application code MUST live inside the project's designated code directories at the root of the repository.
+
+\`\`\`
+your-project/
+├── frontend/          ← ALL frontend code (Next.js, React, etc.)
+├── backend/           ← ALL backend code (Laravel, Django, etc.)
+├── agents/            ← IMH-Code agent definitions (manifests + prompts)
+├── skills/            ← IMH-Code skills library (SKILL.md files)
+├── PROJECT_BRIEF.md   ← Master requirements document
+└── imhcode.config.json ← Routing and configuration
+\`\`\`
+
+RULES:
+1. Frontend code goes in \`frontend/\` ONLY.
+2. Backend code goes in \`backend/\` ONLY.
+3. NEVER create application code files at the project root.
+</HARD-GATE>

package/skills/imhcode-brainstorm/SKILL.md

@@ -0,0 +1,37 @@
+---
+name: imhcode-brainstorm
+description: "Guidelines for Phase 2-3 Brainstorming. The planner agent reads docs/start.md, generates docs/brainstorming.md with smart recommended answers, and reads user answers to configure testing strategy and model routing."
+---
+
+# IMH-Code Brainstorming Skill (Phase 2-3)
+
+This skill governs Phase 2 (Plan) and Phase 3 (Brainstorm) of the IMH-Code workflow.
+
+## File-Based Interactive Brainstorming Protocol
+
+To keep the development fast and simple, brainstorming operates via structured markdown documents in the `docs/` folder:
+
+### Step 1: Generate Brainstorming Document (Phase 2)
+- **Trigger**: User runs `imhcode plan` when `docs/start.md` exists but `docs/brainstorming.md` does not.
+- **Actions**:
+  1. The planner agent reads the user's project description from the `<!-- WRITE_PROMPT_HERE -->` section of `docs/start.md`.
+  2. The agent auto-detects stack requirements (frontend, backend, database, mobile).
+  3. The agent generates `docs/brainstorming.md` containing:
+     - Clear, categorized questions about stack choices, features, deployment, and testing strategy.
+     - **Auto-Recommended Answers** parsed from keywords in the prompt to minimize typing for the user.
+     - **Testing Strategy Question**: Standardizing on **Fast Mode** (no tests per sprint, final testing sprint only) as the default recommendation for maximum speed.
+  4. The planner outputs a guide in the chat:
+     `✅ Brainstorming document created: docs/brainstorming.md. Please review/edit the recommended answers and run "imhcode plan" again to generate sprints.`
+
+### Step 2: Read Brainstorming Answers & Generate Sprints (Phase 4)
+- **Trigger**: User runs `imhcode plan` when `docs/brainstorming.md` exists.
+- **Actions**:
+  1. The planner agent reads the answers from `docs/brainstorming.md`.
+  2. **Testing Mode Configuration**: Parses Q24 (Testing Strategy) and writes `"testing_mode": "fast" | "balanced" | "strict"` to `imhcode.config.json`.
+  3. **Model Routing Confirmation**: Saves the confirmed routing map to `imhcode.config.json`.
+  4. **Deliverables Generation**:
+     - Generates `PROJECT_BRIEF.md` at the project root summarizing requirements, stack, and sprint status.
+     - Generates `docs/sprint-1/`, `docs/sprint-2/`, etc. plans, trackers, and bash scripts.
+     - **Auto-Generated Testing Sprint**: If Fast or Balanced mode is selected, the final sprint (e.g. Sprint 3) is automatically generated containing QA, security, SEO, and browser tests.
+  5. The planner outputs a completion message in the chat:
+     `✅ Sprint plans generated successfully! Run "imhcode execute 1" to start Sprint 1.`

package/skills/imhcode-codebase-knowledge/SKILL.md

@@ -0,0 +1,37 @@
+---
+name: imhcode-codebase-knowledge
+description: 'Use this skill to map, document, or onboard into an existing codebase. Generates STACK.md, STRUCTURE.md, ARCHITECTURE.md, CONVENTIONS.md, INTEGRATIONS.md, TESTING.md, and CONCERNS.md in docs/codebase/.'
+---
+
+# Acquire Codebase Knowledge
+
+Produces seven populated documents in `docs/codebase/` covering everything needed to work effectively on the project. Only document what is verifiable from files or terminal output — never infer or assume.
+
+## Output Contract (Required)
+
+Before finishing, all of the following must be true:
+
+1. Exactly these files exist in `docs/codebase/`: `STACK.md`, `STRUCTURE.md`, `ARCHITECTURE.md`, `CONVENTIONS.md`, `INTEGRATIONS.md`, `TESTING.md`, `CONCERNS.md`.
+2. Every claim is traceable to source files, config, or terminal output.
+3. Unknowns are marked as `[TODO]`; intent-dependent decisions are marked `[ASK USER]`.
+4. Every document includes a short "evidence" list with concrete file paths.
+
+## Workflow
+
+```
+- [ ] Phase 1: Run scan, read intent documents
+- [ ] Phase 2: Investigate each documentation area
+- [ ] Phase 3: Populate all seven docs in docs/codebase/
+- [ ] Phase 4: Validate docs, present findings, resolve all [ASK USER] items
+```
+
+### Phase 1: Scan and Read Intent
+
+1. Run the scan script from the target project root:
+   ```bash
+   python3 "$SKILL_ROOT/scripts/scan.py" --output docs/codebase/.codebase-scan.txt
+   ```
+   Where `$SKILL_ROOT` is the absolute path to the skill folder.
+
+2. Search for PRD, TRD, README, ROADMAP, SPEC, DESIGN files and read them.
+3. Summarize project intent.

package/skills/imhcode-codebase-knowledge/assets/templates/ARCHITECTURE.md

@@ -0,0 +1,49 @@
+# Architecture
+
+## Core Sections (Required)
+
+### 1) Architectural Style
+
+- Primary style: [layered/feature/event-driven/other]
+- Why this classification: [short evidence-backed rationale]
+- Primary constraints: [2-3 constraints that shape design]
+
+### 2) System Flow
+
+```text
+[entry] -> [processing] -> [domain logic] -> [data/integration] -> [response/output]
+```
+
+Describe the flow in 4-6 steps using file-backed evidence.
+
+### 3) Layer/Module Responsibilities
+
+| Layer or module | Owns | Must not own | Evidence |
+|-----------------|------|--------------|----------|
+| [name] | [responsibility] | [non-responsibility] | [file] |
+
+### 4) Reused Patterns
+
+| Pattern | Where found | Why it exists |
+|---------|-------------|---------------|
+| [singleton/repository/adapter/etc] | [path] | [reason] |
+
+### 5) Known Architectural Risks
+
+- [Risk 1 + impact]
+- [Risk 2 + impact]
+
+### 6) Evidence
+
+- [path/to/entrypoint]
+- [path/to/main-layer-files]
+- [path/to/data-or-integration-layer]
+
+## Extended Sections (Optional)
+
+Add only when needed:
+
+- Startup or initialization order details
+- Async/event topology diagrams
+- Anti-pattern catalog with refactoring paths
+- Failure-mode analysis and resilience posture

package/skills/imhcode-codebase-knowledge/assets/templates/CONCERNS.md

@@ -0,0 +1,56 @@
+# Codebase Concerns
+
+## Core Sections (Required)
+
+### 1) Top Risks (Prioritized)
+
+| Severity | Concern | Evidence | Impact | Suggested action |
+|----------|---------|----------|--------|------------------|
+| [high/med/low] | [issue] | [file or scan output] | [impact] | [next action] |
+
+### 2) Technical Debt
+
+List the most important debt items only.
+
+| Debt item | Why it exists | Where | Risk if ignored | Suggested fix |
+|-----------|---------------|-------|-----------------|---------------|
+| [item] | [reason] | [path] | [risk] | [fix] |
+
+### 3) Security Concerns
+
+| Risk | OWASP category (if applicable) | Evidence | Current mitigation | Gap |
+|------|--------------------------------|----------|--------------------|-----|
+| [risk] | [A01/A03/etc or N/A] | [path] | [what exists] | [what is missing] |
+
+### 4) Performance and Scaling Concerns
+
+| Concern | Evidence | Current symptom | Scaling risk | Suggested improvement |
+|---------|----------|-----------------|-------------|-----------------------|
+| [issue] | [path/metric] | [symptom] | [risk] | [action] |
+
+### 5) Fragile/High-Churn Areas
+
+| Area | Why fragile | Churn signal | Safe change strategy |
+|------|-------------|-------------|----------------------|
+| [path] | [reason] | [recent churn evidence] | [approach] |
+
+### 6) `[ASK USER]` Questions
+
+Add unresolved intent-dependent questions as a numbered list.
+
+1. [ASK USER] [question]
+
+### 7) Evidence
+
+- [scan output section reference]
+- [path/to/code-file]
+- [path/to/config-or-history-evidence]
+
+## Extended Sections (Optional)
+
+Add only when needed:
+
+- Full bug inventory
+- Component-level remediation roadmap
+- Cost/effort estimates by concern
+- Dependency-risk and ownership mapping

package/skills/imhcode-codebase-knowledge/assets/templates/CONVENTIONS.md

@@ -0,0 +1,52 @@
+# Coding Conventions
+
+## Core Sections (Required)
+
+### 1) Naming Rules
+
+| Item | Rule | Example | Evidence |
+|------|------|---------|----------|
+| Files | [RULE] | [EXAMPLE] | [FILE] |
+| Functions/methods | [RULE] | [EXAMPLE] | [FILE] |
+| Types/interfaces | [RULE] | [EXAMPLE] | [FILE] |
+| Constants/env vars | [RULE] | [EXAMPLE] | [FILE] |
+
+### 2) Formatting and Linting
+
+- Formatter: [TOOL + CONFIG FILE]
+- Linter: [TOOL + CONFIG FILE]
+- Most relevant enforced rules: [RULE_1], [RULE_2], [RULE_3]
+- Run commands: [COMMANDS]
+
+### 3) Import and Module Conventions
+
+- Import grouping/order: [RULE]
+- Alias vs relative import policy: [RULE]
+- Public exports/barrel policy: [RULE]
+
+### 4) Error and Logging Conventions
+
+- Error strategy by layer: [SHORT SUMMARY]
+- Logging style and required context fields: [SUMMARY]
+- Sensitive-data redaction rules: [SUMMARY]
+
+### 5) Testing Conventions
+
+- Test file naming/location rule: [RULE]
+- Mocking strategy norm: [RULE]
+- Coverage expectation: [RULE or TODO]
+
+### 6) Evidence
+
+- [path/to/lint-config]
+- [path/to/format-config]
+- [path/to/representative-source-file]
+
+## Extended Sections (Optional)
+
+Add only for large or inconsistent codebases:
+
+- Layer-specific error handling matrix
+- Language-specific strictness options
+- Repo-specific commit/branching conventions
+- Known convention violations to clean up

package/skills/imhcode-codebase-knowledge/assets/templates/INTEGRATIONS.md

@@ -0,0 +1,48 @@
+# External Integrations
+
+## Core Sections (Required)
+
+### 1) Integration Inventory
+
+| System | Type (API/DB/Queue/etc) | Purpose | Auth model | Criticality | Evidence |
+|--------|---------------------------|---------|------------|-------------|----------|
+| [name] | [type] | [purpose] | [auth] | [high/med/low] | [file] |
+
+### 2) Data Stores
+
+| Store | Role | Access layer | Key risk | Evidence |
+|-------|------|--------------|----------|----------|
+| [db/cache/etc] | [role] | [module] | [risk] | [file] |
+
+### 3) Secrets and Credentials Handling
+
+- Credential sources: [env/secrets manager/config]
+- Hardcoding checks: [result]
+- Rotation or lifecycle notes: [known/unknown]
+
+### 4) Reliability and Failure Behavior
+
+- Retry/backoff behavior: [implemented/none/partial]
+- Timeout policy: [where configured]
+- Circuit-breaker or fallback behavior: [if any]
+
+### 5) Observability for Integrations
+
+- Logging around external calls: [yes/no + where]
+- Metrics/tracing coverage: [yes/no + where]
+- Missing visibility gaps: [list]
+
+### 6) Evidence
+
+- [path/to/integration-wrapper]
+- [path/to/config-or-env-template]
+- [path/to/monitoring-or-logging-config]
+
+## Extended Sections (Optional)
+
+Add only when needed:
+
+- Endpoint-by-endpoint catalog
+- Auth flow sequence diagrams
+- SLA/SLO per integration
+- Region/failover topology notes

package/skills/imhcode-codebase-knowledge/assets/templates/STACK.md

@@ -0,0 +1,56 @@
+# Technology Stack
+
+## Core Sections (Required)
+
+### 1) Runtime Summary
+
+| Area | Value | Evidence |
+|------|-------|----------|
+| Primary language | [VALUE] | [FILE_PATH] |
+| Runtime + version | [VALUE] | [FILE_PATH] |
+| Package manager | [VALUE] | [FILE_PATH] |
+| Module/build system | [VALUE] | [FILE_PATH] |
+
+### 2) Production Frameworks and Dependencies
+
+List only high-impact production dependencies (frameworks, data, transport, auth).
+
+| Dependency | Version | Role in system | Evidence |
+|------------|---------|----------------|----------|
+| [NAME] | [VERSION] | [ROLE] | [FILE_PATH] |
+
+### 3) Development Toolchain
+
+| Tool | Purpose | Evidence |
+|------|---------|----------|
+| [TOOL] | [LINT/FORMAT/TEST/BUILD] | [FILE_PATH] |
+
+### 4) Key Commands
+
+```bash
+[install command]
+[build command]
+[test command]
+[lint command]
+```
+
+### 5) Environment and Config
+
+- Config sources: [LIST FILES]
+- Required env vars: [VAR_1], [VAR_2], [TODO]
+- Deployment/runtime constraints: [SHORT NOTE]
+
+### 6) Evidence
+
+- [path/to/manifest]
+- [path/to/runtime-config]
+- [path/to/build-or-ci-config]
+
+## Extended Sections (Optional)
+
+Add only when needed for complex repos:
+
+- Full dependency taxonomy by category
+- Detailed compiler/runtime flags
+- Environment matrix (dev/stage/prod)
+- Process manager and container runtime details